public void RemoveAndDestroyAllPrefabCategories(bool showProgresBar = false)
{
List <PrefabCategory> allPrefabCategories = GetAllPrefabCategories();
var prefabCategoriesToDestroy = new List <PrefabCategory>();
foreach (PrefabCategory prefabCategory in allPrefabCategories)
{
if (CanPrefabCategoryBeRemovedFromDatabase(prefabCategory))
{
_prefabCategories.RemoveEntity(prefabCategory);
PrefabCategoryWasRemovedFromDatabaseMessage.SendToInterestedListeners(prefabCategory);
prefabCategoriesToDestroy.Add(prefabCategory);
}
}
if (showProgresBar)
{
for (int categoryIndex = 0; categoryIndex < prefabCategoriesToDestroy.Count; ++categoryIndex)
{
PrefabCategory prefabCategory = prefabCategoriesToDestroy[categoryIndex];
EditorUtility.DisplayProgressBar("Removing categories", "Please wait... (" + prefabCategory.Name + ")", (categoryIndex + 1) / (float)prefabCategoriesToDestroy.Count);
UndoEx.DestroyObjectImmediate(prefabCategory);
}
EditorUtility.ClearProgressBar();
}
else
{
foreach (PrefabCategory prefabCategory in prefabCategoriesToDestroy)
{
UndoEx.DestroyObjectImmediate(prefabCategory);
}
}
}
public static void ActivatePreviousPrefabInPrefabCategory(PrefabCategory prefabCategory)
{
List <Prefab> filteredPrefabs = prefabCategory.GetFilteredPrefabs();
int prefabIndex = prefabCategory.GetPrefabIndex(prefabCategory.ActivePrefab) - 1;
if (prefabIndex < 0)
{
prefabIndex = prefabCategory.NumberOfPrefabs - 1;
}
while (prefabIndex >= 0)
{
Prefab newActivePrefab = prefabCategory.GetPrefabByIndex(prefabIndex);
if (filteredPrefabs.Contains(newActivePrefab))
{
prefabCategory.SetActivePrefab(newActivePrefab);
return;
}
--prefabIndex;
}
prefabCategory.SetActivePrefab(null);
}
private void PlaceObjectFromPlacementGuide(bool checkForIntersection)
{
ObjectPlacementGuide placementGuide = ObjectPlacementGuide.Instance;
GameObject placedHierarchyRoot = null;
OrientedBox guideHierarchyWorldOrientedBox = ObjectPlacementGuide.SceneObject.GetHierarchyWorldOrientedBox();
List <GameObject> intersectingObjects = ObjectQueries.GetIntersectingObjects(guideHierarchyWorldOrientedBox, new List <GameObject> {
_strokeSurface.SurfaceObject
}, true);
if (!checkForIntersection || ObjectPlacementSettings.Get().ObjectIntersectionSettings.AllowIntersectionForDecorPaintSingleModeDrag ||
intersectingObjects.Count == 0)
{
placedHierarchyRoot = Octave3DScene.Get().InstantiateObjectHierarchyFromPrefab(placementGuide.SourcePrefab, placementGuide.gameObject.transform);
ObjectHierarchyRootsWerePlacedInSceneMessage.SendToInterestedListeners(placedHierarchyRoot, ObjectHierarchyRootsWerePlacedInSceneMessage.PlacementType.ObjectPlacement);
List <GameObject> allPlacedObjects = placedHierarchyRoot.GetAllChildrenIncludingSelf();
_objectsPlacedWhileDragging.AddRange(allPlacedObjects);
DecorPaintObjectPlacement.Get().DecorPaintMask.ObjectCollectionMask.Mask(allPlacedObjects);
}
_orientedBoxOfLastPlacedHierarchy = ObjectPlacementGuide.SceneObject.GetHierarchyWorldOrientedBox();
_pivotPointsOfLastPlacedHierarchy.FromOrientedBoxAndDecorStrokeSurface(_orientedBoxOfLastPlacedHierarchy, _strokeSurface);
if (DecorPaintObjectPlacementSettings.Get().SingleDecorPaintModeSettings.RandomizePrefabsInActiveCategory)
{
PrefabCategory activePrefabCategory = PrefabCategoryDatabase.Get().ActivePrefabCategory;
if (activePrefabCategory != null)
{
activePrefabCategory.RandomizeActivePrefab();
}
}
}
public void RenamePrefabCategory(PrefabCategory prefabCategory, string newName)
{
if (ContainsPrefabCategory(prefabCategory))
{
_prefabCategories.RenameEntity(prefabCategory, newName);
}
}
public PrefabWasTransferredToCategoryMessage(Prefab prefab, PrefabCategory sourceCategory, PrefabCategory destinationCategory)
: base(MessageType.PrefabWasTransferredToCategory)
{
_sourceCategory = sourceCategory;
_destinationCategory = destinationCategory;
_prefab = prefab;
}
private void RenderObjectGroupSelectionPopup()
{
ObjectGroupDatabase objectGroupDatabase = Octave3DWorldBuilder.ActiveInstance.PlacementObjectGroupDatabase;
if (objectGroupDatabase.NumberOfGroups == 0)
{
EditorGUILayoutEx.InformativeLabel("No object groups are currently available.");
return;
}
PrefabCategoryDatabase prefabCategoryDatabase = PrefabCategoryDatabase.Get();
PrefabCategory activeCategory = prefabCategoryDatabase.ActivePrefabCategory;
List <ObjectGroup> allObjectGroups = objectGroupDatabase.GetAllObjectGroups();
if (activeCategory.ObjectGroup == null)
{
activeCategory.SetObjectGroup(allObjectGroups[0]);
}
int currentGroupIndex = allObjectGroups.FindIndex(0, item => item == activeCategory.ObjectGroup);
if (currentGroupIndex < 0)
{
return;
}
int newGroupIndex = EditorGUILayoutEx.Popup(GetContentForObjectGroupSelectionPopup(), currentGroupIndex, objectGroupDatabase.GetAllObjectGroupNames());
if (newGroupIndex != currentGroupIndex)
{
UndoEx.RecordForToolAction(activeCategory);
activeCategory.SetObjectGroup(allObjectGroups[newGroupIndex]);
}
}
private static void EnsureGuideUsesBeginTileConnectionPrefab()
{
ObjectPlacementPathTileConnectionSettings tileConnectionSettings = ObjectPlacement.Get().PathObjectPlacement.PathSettings.TileConnectionSettings;
ObjectPlacementPathTileConnectionTypeSettings beginTileConnectionSettings = tileConnectionSettings.GetSettingsForTileConnectionType(ObjectPlacementPathTileConnectionType.Begin);
if (CanRefreshGuideToUseBeginTileConnectionPrefab(beginTileConnectionSettings))
{
PrefabCategory categoryWhichContainsBeginPrefab = PrefabCategoryDatabase.Get().GetPrefabCategoryWhichContainsPrefab(beginTileConnectionSettings.Prefab);
if (categoryWhichContainsBeginPrefab == null)
{
return;
}
PrefabCategoryDatabase.Get().SetActivePrefabCategory(categoryWhichContainsBeginPrefab);
categoryWhichContainsBeginPrefab.SetActivePrefab(beginTileConnectionSettings.Prefab);
ObjectPlacement.Get().DestroyPlacementGuide();
ObjectPlacementGuide.CreateFromActivePrefabIfNotExists();
}
// Note: When using tile connections, we will always use the original prefab scale
if (ObjectPlacementGuide.ExistsInScene)
{
ObjectPlacementGuide.Instance.WorldScale = beginTileConnectionSettings.Prefab.InitialWorldScale;
}
}
private static PrefabCategory CreateNewPrefabCategoryWithUniqueName(string name, List <string> existingCategoryNames)
{
PrefabCategory newPrefabCategory = Octave3DWorldBuilder.ActiveInstance.CreateScriptableObject <PrefabCategory>();
newPrefabCategory.Name = UniqueEntityNameGenerator.GenerateUniqueName(name, existingCategoryNames);
return(newPrefabCategory);
}
public bool CanPrefabCategoryBeRemovedFromDatabase(PrefabCategory prefabCategory)
{
if (prefabCategory.Name == DefaultPrefabCategoryName)
{
return(false);
}
return(true);
}
public bool CanPrefabCategoryBeRenamed(PrefabCategory prefabCategory)
{
if (prefabCategory.Name == DefaultPrefabCategoryName)
{
return(false);
}
return(true);
}
private void CreateNewCategoryFromDroppedFolderAndAssignPrefabs(PrefabFolderDropData prefabFolderDropData)
{
PrefabCategory newPrefabCategory = PrefabCategoryDatabase.Get().CreatePrefabCategory(prefabFolderDropData.FolderNameInPath);
newPrefabCategory.SetPathFolderNames(FileSystem.GetFolderNamesInPath(prefabFolderDropData.FolderPath));
newPrefabCategory.AddPrefabCollection(prefabFolderDropData.ValidPrefabs);
_lastCreatedCategory = newPrefabCategory;
}
protected override void PerformDrop()
{
PrefabCategory activePrefabCategory = PrefabCategoryDatabase.Get().ActivePrefabCategory;
PerformPrefabsToCategoryDropOperation(activePrefabCategory);
PerformPrefabFoldersToCategoryDropOperation(activePrefabCategory);
PrefabTagsWindow.Get().RepaintOctave3DWindow();
}
public static void SetPrefabOffsetFromGridSurface(PrefabCategory prefabCategory, float offsetFromGridSurface)
{
List <Prefab> allPrefabsInCategory = prefabCategory.GetAllPrefabs();
foreach (Prefab prefab in allPrefabsInCategory)
{
prefab.OffsetFromGridSurface = offsetFromGridSurface;
}
}
private void RenderSetPrefabOffsetFromObjectSurfaceInActiveCategoryButton()
{
if (GUILayout.Button(GetContentForSetPrefabOffsetFromObjectSurfaceInActiveCategoryButton(), GUILayout.Width(EditorGUILayoutEx.PreferedActionButtonWidth + 3.0f)))
{
PrefabCategory activePrefabCategory = PrefabCategoryDatabase.Get().ActivePrefabCategory;
UndoEx.RecordForToolAction(activePrefabCategory.GetAllPrefabs());
PrefabCategoryActions.SetPrefabOffsetFromObjectSurface(activePrefabCategory, ViewData.PrefabOffsetFromObjectSurface);
}
}
private void RenderNextPrefabButton(float buttonWidth)
{
if (GUILayout.Button(GetContentForNextPrefabButton(), GUILayout.Width(buttonWidth)))
{
PrefabCategory activePrefabCategory = PrefabCategoryDatabase.Get().ActivePrefabCategory;
UndoEx.RecordForToolAction(activePrefabCategory);
PrefabCategoryActions.ActivateNextPrefabInPrefabCategory(activePrefabCategory);
}
}
public void SetActivePrefabCategory(PrefabCategory newActivePrefabCategory)
{
if (newActivePrefabCategory == null || !ContainsPrefabCategory(newActivePrefabCategory))
{
return;
}
_prefabCategories.MarkEntity(newActivePrefabCategory);
NewPrefabCategoryWasActivatedMessage.SendToInterestedListeners(newActivePrefabCategory);
}
private void RenderCreateNewCategoryButton()
{
if (GUILayout.Button(GetContentForCreateNewCategoryButton(), GUILayout.Width(143.0f)))
{
PrefabCategoryDatabase prefabCategoryDatabase = PrefabCategoryDatabase.Get();
UndoEx.RecordForToolAction(prefabCategoryDatabase);
PrefabCategory newCategory = prefabCategoryDatabase.CreatePrefabCategory(ViewData.NameForNewPrefabCategory);
prefabCategoryDatabase.SetActivePrefabCategory(newCategory);
}
}
private void PerformPrefabFoldersToCategoryDropOperation(PrefabCategory prefabCategory)
{
var prefabFoldersDropData = new PrefabFoldersToCategoryDropData(prefabCategory, PrefabFoldersDropSettings.ProcessSubfolders);
prefabFoldersDropData.FromLastDropOperation();
if (prefabFoldersDropData.PrefabFoldersDropDataCollection.Count != 0)
{
var prefabFoldersDropOperation = new PrefabFoldersToCategoryDropOperation(prefabFoldersDropData);
prefabFoldersDropOperation.Perform();
}
}
private void PerformPrefabsToCategoryDropOperation(PrefabCategory prefabCategory)
{
var prefabsDropData = new PrefabsToCategoryDropOperationData(prefabCategory);
prefabsDropData.FromLastDropOperation();
if (prefabsDropData.ValidDroppedPrefabs.Count != 0)
{
var prefabsDropOperation = new PrefabsToCategoryDropOperation(prefabsDropData);
prefabsDropOperation.Perform();
}
}
public static PrefabWithPrefabCategoryAssociation Create(Prefab prefab, PrefabCategory prefabCategory)
{
if (prefab != null && prefabCategory != null)
{
return(CreateNewAssociation(prefab, prefabCategory));
}
else
{
Debug.LogWarning("Can not create the requested prefab with prefab category association. Null prefab or prefab category was specified.");
return(null);
}
}
public PrefabCategory CreatePrefabCategory(string categoryName)
{
if (!string.IsNullOrEmpty(categoryName))
{
PrefabCategory newPrefabCategory = PrefabCategoryFactory.Create(categoryName, GetAllPrefabCategoryNames());
_prefabCategories.AddEntity(newPrefabCategory);
return(newPrefabCategory);
}
return(null);
}
public PrefabCategory GetFirstNonEmptyCategory()
{
for (int categoryIndex = 0; categoryIndex < NumberOfCategories; ++categoryIndex)
{
PrefabCategory prefabCategory = GetPrefabCategoryByIndex(categoryIndex);
if (!prefabCategory.IsEmpty)
{
return(prefabCategory);
}
}
return(null);
}
public void RemoveAndDestroyPrefabCategory(PrefabCategory prefabCategory)
{
if (CanPrefabCategoryBeRemovedFromDatabase(prefabCategory))
{
if (ContainsPrefabCategory(prefabCategory))
{
_prefabCategories.RemoveEntity(prefabCategory);
PrefabCategoryWasRemovedFromDatabaseMessage.SendToInterestedListeners(prefabCategory);
UndoEx.DestroyObjectImmediate(prefabCategory);
}
}
}
private static void ReadAllPrefabsInCategory(PrefabCategory prefabCategory, XmlNodeList prefabNodes)
{
if (prefabNodes.Count == 0)
{
return;
}
for (int prefabNodeIndex = 0; prefabNodeIndex < prefabNodes.Count; ++prefabNodeIndex)
{
XmlNode prefabNode = prefabNodes[prefabNodeIndex];
XmlNode prefabNameNode = prefabNode.SelectSingleNode(PrefabConfigXMLInfo.PrefabNameNode);
XmlNode prefabPathNode = prefabNode.SelectSingleNode(PrefabConfigXMLInfo.PrefabPathNode);
if (prefabPathNode == null)
{
continue;
}
XmlNode offsetFromGridNode = prefabNode.SelectSingleNode(PrefabConfigXMLInfo.PrefabOffsetFromGridSurfaceNode);
XmlNode offsetFromObjectNode = prefabNode.SelectSingleNode(PrefabConfigXMLInfo.PrefabOffsetFromObjectSurfaceNode);
GameObject unityPrefab = AssetDatabase.LoadAssetAtPath(prefabPathNode.InnerText, typeof(GameObject)) as GameObject;
if (unityPrefab == null)
{
continue;
}
Prefab prefab = PrefabFactory.Create(unityPrefab);
if (prefabNameNode != null && !string.IsNullOrEmpty(prefabNameNode.InnerText))
{
prefab.Name = prefabNameNode.InnerText;
}
float offsetFromGrid = 0.0f;
if (offsetFromGridNode != null)
{
try { offsetFromGrid = float.Parse(offsetFromGridNode.InnerText); }
catch (Exception) { }
}
prefab.OffsetFromGridSurface = offsetFromGrid;
float offsetFromObject = 0.0f;
if (offsetFromObjectNode != null)
{
try { offsetFromObject = float.Parse(offsetFromObjectNode.InnerText); }
catch (Exception) { }
}
prefab.OffsetFromObjectSurface = offsetFromObject;
ReadPrefabTagAssociations(prefab, prefabNode.SelectNodes(PrefabConfigXMLInfo.PrefabAssociatedTagNode));
prefabCategory.AddPrefab(prefab);
}
}
public void TransferAllPrefabsToCategory(PrefabCategory destinationCategory)
{
if (destinationCategory == this)
{
return;
}
List <Prefab> allPrefabs = GetAllPrefabs();
foreach (Prefab prefab in allPrefabs)
{
TransferPrefabToCategory(prefab, destinationCategory);
}
}
private void PerformPrefabsToCategoryDropOperation(PrefabCategory prefabCategory)
{
var prefabsDropData = new PrefabsToCategoryDropOperationData(prefabCategory);
prefabsDropData.FromLastDropOperation();
if (prefabsDropData.ValidDroppedPrefabs.Count != 0)
{
var prefabsDropOperation = new PrefabsToCategoryDropOperation(prefabsDropData);
prefabsDropOperation.Perform();
PrefabPreviewTextureCache.Get().GeneratePreviewsForPrefabCollection(prefabsDropData.ValidDroppedPrefabs, true);
}
}
private void PerformDropUsingFirstPrefabInValidUnityPrefabCollection(List <GameObject> validUnityPrefabs)
{
GameObject firstValidUnityPrefab = GetFirstUnityPrefabFromValidUnityPrefabsCollection(validUnityPrefabs);
PrefabCategory categoryWhichContainsPrefab = PrefabCategoryDatabase.Get().GetPrefabCategoryWhichContainsPrefab(firstValidUnityPrefab);
if (categoryWhichContainsPrefab != null)
{
AssignPrefabToDestinationTileConnection(categoryWhichContainsPrefab.GetPrefabByUnityPrefab(firstValidUnityPrefab));
}
else
{
Prefab firstValidPrefab = GetFirstPrefabFromValidPrefabsCollection(PrefabFactory.Create(validUnityPrefabs));
CreatePrefabToCategoryAssociationAndAssignPrefabToDestinationTileConnection(firstValidPrefab);
}
}
public void TransferPrefabToCategory(Prefab prefabToTransfer, PrefabCategory destinationCategory)
{
if (destinationCategory == this)
{
return;
}
if (ContainsPrefab(prefabToTransfer))
{
_prefabs.RemoveEntity(prefabToTransfer);
destinationCategory.AddPrefab(prefabToTransfer);
PrefabWasTransferredToCategoryMessage.SendToInterestedListeners(prefabToTransfer, this, destinationCategory);
}
}
public void AddPrefab(Prefab prefab)
{
if (!ContainsPrefab(prefab) && !ContainsPrefab(prefab.UnityPrefab))
{
if (!PrefabCategoryDatabase.Get().IsThereCategoryWhichContainsPrefab(prefab))
{
_prefabs.AddEntity(prefab);
}
else
{
PrefabCategory categoryWhichContainsPrefab = PrefabCategoryDatabase.Get().GetPrefabCategoryWhichContainsPrefab(prefab);
LogPrefabAlreadyExistsInCategoryMessage(categoryWhichContainsPrefab.Name);
}
}
}
protected override void PerformDrop()
{
if (_dropDestination == DropDestination.Element)
{
if (_destinationDecorPaintBrushElement == null)
{
return;
}
List <GameObject> validUnityPrefabsInvolvedInDropOperation = PrefabValidator.GetValidPrefabsFromEntityCollection(DragAndDrop.objectReferences, false);
if (validUnityPrefabsInvolvedInDropOperation.Count != 0)
{
PerformDropUsingFirstPrefabInValidUnityPrefabCollection(validUnityPrefabsInvolvedInDropOperation);
}
}
else
{
if (_destinationBrush == null)
{
return;
}
List <GameObject> validUnityPrefabs = PrefabValidator.GetValidPrefabsFromEntityCollection(DragAndDrop.objectReferences, false);
if (validUnityPrefabs.Count != 0)
{
UndoEx.RecordForToolAction(_destinationBrush);
foreach (GameObject unityPrefab in validUnityPrefabs)
{
DecorPaintObjectPlacementBrushElement newElement = _destinationBrush.CreateNewElement();
PrefabCategory categoryWhichContainsPrefab = PrefabCategoryDatabase.Get().GetPrefabCategoryWhichContainsPrefab(unityPrefab);
if (categoryWhichContainsPrefab != null)
{
newElement.Prefab = categoryWhichContainsPrefab.GetPrefabByUnityPrefab(unityPrefab);
}
else
{
Prefab prefab = PrefabFactory.Create(unityPrefab);
UndoEx.RecordForToolAction(_destinationBrush.DestinationCategoryForElementPrefabs);
PrefabWithPrefabCategoryAssociationQueue.Instance.Enqueue(PrefabWithPrefabCategoryAssociationFactory.Create(prefab, _destinationBrush.DestinationCategoryForElementPrefabs));
newElement.Prefab = prefab;
}
}
}
}
Octave3DWorldBuilder.ActiveInstance.RepaintAllEditorWindows();
}
