static void createTileSet(bool reImport)
{
updatedPrefabsCounter = 0;
newPrefabsCounter = 0;
tileImportProgress = 0f;
tilesetData = ScriptableObject.CreateInstance <YuME_tilesetData>();
tilesetData.tileSetName = userSettings.c_name;
GameObject[] sourcePrefabs;
sourcePrefabs = YuTools_Utils.loadDirectoryContents(userSettings.c_sourceFolder, "*.prefab");
if (sourcePrefabs.Length == 0)
{
sourcePrefabs = YuTools_Utils.loadDirectoryContents(userSettings.c_sourceFolder, "*.obj");
}
if (sourcePrefabs.Length == 0)
{
sourcePrefabs = YuTools_Utils.loadDirectoryContents(userSettings.c_sourceFolder, "*.fbx");
}
bool validTile = false;
foreach (GameObject child in sourcePrefabs)
{
// display the conversion progress based on the number of tiles found on the source tile set
EditorUtility.DisplayProgressBar("Building Tile Set", "Tile " + tileImportProgress + " / " + sourcePrefabs.Length + " being exported", (float)(tileImportProgress / sourcePrefabs.Length));
validTile = convertPrefabNew(child.gameObject, child.name, reImport);
if (!validTile)
{
Debug.Log("---- invalid Tile");
}
tileImportProgress++;
}
if (!AssetDatabase.IsValidFolder(userSettings.c_destinationFolder + "/CustomBrushes"))
{
AssetDatabase.CreateFolder(userSettings.c_destinationFolder, "CustomBrushes");
}
try
{
tilesetData.customBrushDestinationFolder = userSettings.c_destinationFolder + "/CustomBrushes";
AssetDatabase.CreateAsset(tilesetData, userSettings.c_destinationFolder + "/" + userSettings.c_name + "_tileSet.asset");
}
catch
{
Debug.Log("Destination folder is invalid. Please select a different folder.");
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(); // refesh the asset database to tell unity changes have been made
EditorUtility.ClearProgressBar();
}
public static void saveFrozenMesh(string path)
{
path = YuTools_Utils.shortenAssetPath(path);
int counter = 1;
if (YuME_mapEditor.findTileMapParent())
{
foreach (Transform child in YuME_mapEditor.tileMapParent.transform)
{
if (child.gameObject.name == "frozenMap")
{
GameObject saveMap = Instantiate(child.gameObject);
saveMap.name = YuME_mapEditor.tileMapParent.name;
if (!AssetDatabase.IsValidFolder(path + "/" + saveMap.name + "Meshes"))
{
AssetDatabase.CreateFolder(path, saveMap.name + "Meshes");
}
EditorUtility.ClearProgressBar();
foreach (Transform frozenMesh in saveMap.transform)
{
EditorUtility.DisplayProgressBar("Saving Meshes", "Saving Mesh " + (counter) + ". This might take some time", 1);
Mesh saveMesh = Object.Instantiate(frozenMesh.GetComponent <MeshFilter>().sharedMesh) as Mesh;
//Unwrapping.GenerateSecondaryUVSet(saveMesh);
AssetDatabase.CreateAsset(saveMesh, path + "/" + saveMap.name + "Meshes/" + frozenMesh.name + counter + ".asset");
frozenMesh.GetComponent <MeshFilter>().mesh = saveMesh;
counter++;
}
EditorUtility.ClearProgressBar();
Object prefabAlreadyCreated = AssetDatabase.LoadAssetAtPath(path + "/" + saveMap.name + ".prefab", typeof(GameObject));
if (prefabAlreadyCreated != null)
{
PrefabUtility.ReplacePrefab(saveMap, prefabAlreadyCreated, ReplacePrefabOptions.ReplaceNameBased);
}
else
{
PrefabUtility.CreatePrefab(path + "/" + saveMap.name + ".prefab", saveMap);
}
AssetDatabase.SaveAssets();
if (saveMap != null)
{
DestroyImmediate(saveMap);
}
}
}
AssetDatabase.Refresh();
}
}
static void OnSceneChanged()
{
if (currentScene != EditorSceneManager.GetActiveScene().name)
{
toolEnabled = false;
YuME_sceneGizmoFunctions.displayGizmoGrid();
YuTools_Utils.showUnityGrid(true);
currentScene = EditorSceneManager.GetActiveScene().name;
}
}
void OnGUI()
{
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Select Prefab Destination Folder", EditorStyles.boldLabel);
if (GUILayout.Button("Prefab Destination Folder", GUILayout.Height(30)))
{
editorData.destinationFolder = EditorUtility.OpenFolderPanel("Prefab Destination Folder", "", "");
editorData.destinationFolder = YuTools_Utils.shortenAssetPath(editorData.destinationFolder);
if (editorData.destinationFolder == "")
{
editorData.destinationFolder = "Assets/";
}
}
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Prefab Folder:", EditorStyles.boldLabel);
EditorGUILayout.LabelField(editorData.destinationFolder);
EditorGUILayout.EndVertical();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Prefab Pivot Setting:", EditorStyles.boldLabel);
editorData.yPivotType = EditorGUILayout.Popup("Pivot Setting", editorData.yPivotType, editorData.yPivotTypes);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Append Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Custom Append Label", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
editorData.appendName = EditorGUILayout.TextField("Append to Prefab Name", editorData.appendName);
EditorGUILayout.EndVertical();
EditorGUILayout.EndVertical();
if (GUI.changed)
{
SceneView.RepaintAll();
}
}
static void loadPreviewTiles()
{
try
{
string path = YuTools_Utils.getAssetPath(availableTileSets[currentTileSetIndex]);
currentTileSetObjects = YuTools_Utils.loadDirectoryContents(path, "*.prefab");
currentTile = currentTileSetObjects[0];
}
catch
{
Debug.Log("Tile Sets seem to be missing. Please reload the tile sets");
}
}
public static void createCustomBrush()
{
GameObject tileParentObject = new GameObject();
if (YuME_mapEditor.selectedTiles.Count > 0)
{
// When creating a custom brush we need to find the lowest Z transform in the selection to become the pivot transform
GameObject bottomLevelOfSelection = YuME_mapEditor.selectedTiles[0];
foreach (GameObject checkObjects in YuME_mapEditor.selectedTiles)
{
if (checkObjects.transform.position.z < bottomLevelOfSelection.transform.position.z)
{
bottomLevelOfSelection = checkObjects;
}
}
// center the parent object around the lowest block to make sure all the selected brushes are centered around the parent
tileParentObject.transform.position = bottomLevelOfSelection.transform.position;
// Build the brush by finding the parent prefab, creating an instance and then setting it to the transform of the original scene prefab
foreach (GameObject tile in YuME_mapEditor.selectedTiles)
{
GameObject newBrushObject = (GameObject)PrefabUtility.InstantiatePrefab(PrefabUtility.GetPrefabParent(tile) as GameObject);
newBrushObject.transform.position = tile.transform.position;
newBrushObject.transform.eulerAngles = tile.transform.eulerAngles;
newBrushObject.transform.localScale = tile.transform.localScale;
newBrushObject.transform.parent = tileParentObject.transform;
}
// reset the parents position so it is zero when dropped in the scene
tileParentObject.transform.position = Vector3.zero;
// Add the prefab to the project
tileParentObject.name = "CustomBrush" + YuTools_Utils.numberOfFilesInFolder(YuME_mapEditor.availableTileSets[YuME_mapEditor.currentTileSetIndex].customBrushDestinationFolder, "*_YuME.prefab") + "_YuME.prefab";
string destinationPath = YuTools_Utils.getAssetPath(YuME_mapEditor.availableTileSets[YuME_mapEditor.currentTileSetIndex]) + "CustomBrushes/";
PrefabUtility.CreatePrefab(destinationPath + tileParentObject.name, tileParentObject);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(); // refesh the asset database to tell unity changes have been made
// remove our temporary builder object
DestroyImmediate(tileParentObject);
YuME_mapEditor.selectedTiles.Clear();
// reload the custom brushes
YuME_mapEditor.loadCustomBrushes();
}
}
public static void recreateCustomBrushes(string path)
{
float customBrushCounter = 0f;
GameObject[] customBrushes = YuTools_Utils.loadDirectoryContents(path + "/CustomBrushes", "*_YuME.prefab");
if (customBrushes != null)
{
foreach (GameObject brush in customBrushes)
{
EditorUtility.DisplayProgressBar("Rebuilding Custom Brushes", "Brush " + customBrushCounter + " / " + customBrushes.Length + " being exported", (float)(customBrushCounter / customBrushes.Length));
Object prefabAlreadyCreated = AssetDatabase.LoadAssetAtPath(path + "/CustomBrushes/" + brush.name + ".prefab", typeof(GameObject));
if (prefabAlreadyCreated != null)
{
GameObject newTileParent = new GameObject();
newTileParent.transform.position = Vector3.zero;
newTileParent.name = brush.name;
newTileParent.AddComponent <YuME_tileGizmo>();
foreach (Transform tile in brush.transform)
{
string[] guids = AssetDatabase.FindAssets(tile.name);
if (guids != null)
{
GameObject sourceTile = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(guids[0]), typeof(GameObject)) as GameObject;
GameObject newTile = (GameObject)Object.Instantiate(sourceTile);
newTile.transform.position = tile.position;
newTile.transform.eulerAngles = tile.eulerAngles;
newTile.transform.parent = newTileParent.transform;
newTile.name = tile.name;
}
}
#if UNITY_2018_3_OR_NEWER
PrefabUtility.SaveAsPrefabAssetAndConnect(newTileParent, path + "/CustomBrushes/" + brush.name + ".prefab", InteractionMode.AutomatedAction);
#else
PrefabUtility.ReplacePrefab(newTileParent, prefabAlreadyCreated, ReplacePrefabOptions.ReplaceNameBased); // replace the existing prefab with the updated data
#endif
DestroyImmediate(newTileParent);
customBrushCounter++;
}
EditorUtility.ClearProgressBar();
}
}
}
static void swapTileSet()
{
string path = YuTools_Utils.getAssetPath(YuME_mapEditor.availableTileSets[swapTileSetIndex]);
swapTileSetObjects = YuTools_Utils.loadDirectoryContents(path, "*.prefab");
List <GameObject> layerTiles = new List <GameObject>();
if (swapTileSetObjects != null)
{
GameObject swapTile;
if (YuME_mapEditor.findTileMapParent())
{
Undo.RegisterFullObjectHierarchyUndo(YuME_mapEditor.tileMapParent, "Swap Tiles");
foreach (Transform layer in YuME_mapEditor.tileMapParent.transform)
{
if (layer.gameObject.name.Contains("layer"))
{
layerTiles.Clear();
foreach (Transform tile in layer)
{
layerTiles.Add(tile.gameObject);
}
for (int i = 0; i < layerTiles.Count; i++)
{
for (int swap = 0; swap < swapTileSetObjects.Length; swap++)
{
if (layerTiles[i].name == swapTileSetObjects[swap].name)
{
EditorUtility.DisplayProgressBar("Swapping Tileset", layerTiles[i].name, (float)i / (float)layerTiles.Count);
swapTile = PrefabUtility.InstantiatePrefab(swapTileSetObjects[swap] as GameObject) as GameObject;
swapTile.transform.parent = layer;
swapTile.transform.position = layerTiles[i].transform.position;
swapTile.transform.eulerAngles = layerTiles[i].transform.eulerAngles;
swapTile.transform.GetChild(0).transform.position = layerTiles[i].transform.GetChild(0).transform.position;
DestroyImmediate(layerTiles[i]);
break;
}
}
}
}
}
}
}
}
void OnEnable()
{
editorData = ScriptableObject.CreateInstance <YuME_editorData>();
AssetPreview.SetPreviewTextureCacheSize(1000);
YuTools_Utils.disableTileGizmo(showGizmos);
YuTools_Utils.addLayer("YuME_TileMap");
YuME_brushFunctions.cleanSceneOfBrushObjects();
string[] guids;
// ----------------------------------------------------------------------------------------------------
// ----- Load Editor Settings
// ----------------------------------------------------------------------------------------------------
guids = AssetDatabase.FindAssets("YuME_editorSetupData");
editorData = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(guids[0]), typeof(YuME_editorData)) as YuME_editorData;
importTileSets(false);
loadPreviewTiles();
loadCustomBrushes();
_toolEnabled = toolEnabled;
gridSceneObject = GameObject.Find("YuME_MapEditorObject");
updateGridColors();
gridHeight = 0;
YuME_brushFunctions.createBrushTile();
YuTools_Utils.showUnityGrid(true);
SceneView.RepaintAll();
// ----------------------------------------------------------------------------------------------------
// ----- Setup Scene Delegates
// ----------------------------------------------------------------------------------------------------
currentScene = EditorSceneManager.GetActiveScene().name;
SceneView.onSceneGUIDelegate -= OnSceneGUI;
SceneView.onSceneGUIDelegate += OnSceneGUI;
EditorApplication.hierarchyWindowChanged -= OnSceneChanged;
EditorApplication.hierarchyWindowChanged += OnSceneChanged;
}
bool checkForForzenMap()
{
if (findTileMapParent())
{
foreach (Transform chid in tileMapParent.transform)
{
if (chid.gameObject.name == "frozenMap")
{
toolEnabled = false;
YuTools_Utils.showUnityGrid(true);
return(true);
}
}
}
return(false);
}
public static void loadCustomBrushes()
{
try
{
string path = YuTools_Utils.getAssetPath(availableTileSets[currentTileSetIndex]) + "CustomBrushes";
if (path != null)
{
currentCustomBrushes = YuTools_Utils.loadDirectoryContents(path, "*_YuME.prefab");
if (currentCustomBrushes == null)
{
createCustomBrushFolder(path);
}
}
}
catch
{
Debug.Log("Custom Brush Folder missing");
}
}
public static void createCustomBrush(string customBrushName)
{
subMeshCount = 0;
YuME_tileFunctions.checkTileSelectionStatus();
GameObject tileParentObject = new GameObject();
tileParentObject.AddComponent <YuME_tileGizmo>();
tileParentObject.GetComponent <YuME_tileGizmo>().customBrushMeshName = new List <string>();
string customBrushGUID = Guid.NewGuid().ToString("N");
tileParentObject.name = customBrushName + "_YuME.prefab";
string destinationPath = YuTools_Utils.getAssetPath(YuME_mapEditor.availableTileSets[YuME_mapEditor.currentTileSetIndex]) + "CustomBrushes/";
if (YuME_mapEditor.selectedTiles.Count > 0)
{
// When creating a custom brush we need to find the lowest Z transform in the selection to become the pivot transform
GameObject bottomLevelOfSelection = YuME_mapEditor.selectedTiles[0];
foreach (GameObject checkObjects in YuME_mapEditor.selectedTiles)
{
if (checkObjects.transform.position.z < bottomLevelOfSelection.transform.position.z)
{
bottomLevelOfSelection = checkObjects;
}
}
// center the parent object around the lowest block to make sure all the selected brushes are centered around the parent
tileParentObject.transform.position = bottomLevelOfSelection.transform.position;
// New Custom Brush implementation. Uses a technique similar to the freeze map, except for selected tils
List <GameObject> tilesToCombine = new List <GameObject>();
List <Transform> _freezeTiles = new List <Transform>();
List <Transform> freezeTiles = new List <Transform>();
foreach (GameObject tile in YuME_mapEditor.selectedTiles)
{
tile.GetComponentsInChildren <Transform>(false, _freezeTiles);
freezeTiles.AddRange(_freezeTiles);
}
foreach (Transform tile in freezeTiles)
{
if (tile.GetComponent <MeshRenderer>())
{
tilesToCombine.Add(tile.gameObject);
}
}
tilesToCombine = tilesToCombine.OrderBy(x => x.GetComponent <MeshRenderer>().sharedMaterial.name).ToList();
Material previousMaterial = tilesToCombine[0].GetComponent <MeshRenderer>().sharedMaterial;
List <CombineInstance> combine = new List <CombineInstance>();
CombineInstance tempCombine = new CombineInstance();
int vertexCount = 0;
foreach (GameObject mesh in tilesToCombine)
{
vertexCount += mesh.GetComponent <MeshFilter>().sharedMesh.vertexCount;
if (vertexCount > 60000)
{
vertexCount = 0;
newSubMesh(combine, mesh.GetComponent <MeshRenderer>().sharedMaterial, tileParentObject, destinationPath, customBrushGUID);
combine = new List <CombineInstance>();
}
if (mesh.GetComponent <MeshRenderer>().sharedMaterial.name != previousMaterial.name)
{
newSubMesh(combine, previousMaterial, tileParentObject, destinationPath, customBrushGUID);
combine = new List <CombineInstance>();
}
tempCombine.mesh = mesh.GetComponent <MeshFilter>().sharedMesh;
tempCombine.transform = mesh.GetComponent <MeshFilter>().transform.localToWorldMatrix;
combine.Add(tempCombine);
previousMaterial = mesh.GetComponent <MeshRenderer>().sharedMaterial;
}
newSubMesh(combine, previousMaterial, tileParentObject, destinationPath, customBrushGUID);
tileParentObject.transform.position = Vector3.zero;
// Add the prefab to the project
#if UNITY_2018_3_OR_NEWER
PrefabUtility.SaveAsPrefabAsset(tileParentObject, destinationPath + tileParentObject.name);
#else
PrefabUtility.CreatePrefab(destinationPath + tileParentObject.name, tileParentObject);
#endif
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(); // refesh the asset database to tell unity changes have been made
// remove our temporary builder object
Debug.Log("Custom Brush " + tileParentObject.name + " created.");
DestroyImmediate(tileParentObject);
YuME_mapEditor.selectedTiles.Clear();
// reload the custom brushes
YuME_mapEditor.loadCustomBrushes();
}
}
// ----------------------------------------------------------------------------------------------------
// ----- Tileset functions for preview in the editor window
// ----------------------------------------------------------------------------------------------------
public static void importTileSets(bool fullRescan)
{
// find all assest of type YuME_tileSetData
string[] guids = AssetDatabase.FindAssets("t:YuME_tileSetData");
if (guids.Length > 0)
{
availableTileSets = new List <YuME_tilesetData>();
foreach (string guid in guids)
{
YuME_tilesetData tempData = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(guid), typeof(YuME_tilesetData)) as YuME_tilesetData;
if (fullRescan)
{
EditorUtility.DisplayProgressBar("Reloading Tile Set: " + tempData.name, "Note: Reimport can take some time to complete", 0f);
string path = YuTools_Utils.getAssetPath(tempData);
string[] containedPrefabs = YuTools_Utils.getDirectoryContents(YuTools_Utils.getAssetPath(tempData), "*.prefab");
if (containedPrefabs != null)
{
foreach (string prefab in containedPrefabs)
{
AssetDatabase.ImportAsset(path + prefab);
}
}
if (tempData != null)
{
path = YuTools_Utils.getAssetPath(tempData) + "CustomBrushes/";
containedPrefabs = YuTools_Utils.getDirectoryContents(YuTools_Utils.getAssetPath(tempData) + "CustomBrushes/", "*.prefab");
if (containedPrefabs != null)
{
foreach (string prefab in containedPrefabs)
{
AssetDatabase.ImportAsset(path + prefab);
}
}
}
}
availableTileSets.Add(tempData);
}
if (fullRescan)
{
EditorUtility.ClearProgressBar();
}
tileSetNames = new string[availableTileSets.Count];
for (int i = 0; i < availableTileSets.Count; i++)
{
tileSetNames[i] = availableTileSets[i].tileSetName;
}
loadPreviewTiles();
}
else
{
Debug.Log("No tile sets have been created");
}
}
// ----------------------------------------------------------------------------------------------------
// ----- Draw Scene Tools
// ----------------------------------------------------------------------------------------------------
static void OnSceneGUI(SceneView sceneView)
{
if (toolEnabled)
{
// ----------------------------------------------------------------------------------------------------
// ----- Draw Scene Editor Tools
// ----------------------------------------------------------------------------------------------------
if (selectedTool > 0 && toolEnabled)
{
controlId = GUIUtility.GetControlID(FocusType.Passive);
updateSceneMousePosition();
checkTilePositionIsValid(sceneView.position);
YuME_sceneGizmoFunctions.drawBrushGizmo();
}
// ----------------------------------------------------------------------------------------------------
// ----- Draw Editor Tool Bar
// ----------------------------------------------------------------------------------------------------
YuME_editorSceneUI.drawToolUI(sceneView);
// ----------------------------------------------------------------------------------------------------
// ----- Check Keyboard and Mouse Shortcuts
// ----------------------------------------------------------------------------------------------------
YuME_keyboardShortcuts.checkKeyboardShortcuts(Event.current);
YuME_mouseShorcuts.checkMouseShortcuts(Event.current);
foreach (GameObject selected in selectedTiles)
{
if (selected != null)
{
YuME_sceneGizmoFunctions.drawSceneGizmoCube(selected.transform.position, Vector3.one, Color.green);
}
}
// ----------------------------------------------------------------------------------------------------
// ----- Momenteray handling of the editor tool bar
// ----------------------------------------------------------------------------------------------------
switch (selectedTool)
{
case toolIcons.defaultTools:
YuME_brushFunctions.destroyBrushTile();
break;
case toolIcons.brushTool:
YuME_brushFunctions.createBrushTile();
selectedTiles.Clear();
break;
case toolIcons.pickTool:
YuME_brushFunctions.destroyBrushTile();
selectedTiles.Clear();
break;
case toolIcons.eraseTool:
YuME_brushFunctions.destroyBrushTile();
selectedTiles.Clear();
break;
case toolIcons.selectTool:
YuME_brushFunctions.destroyBrushTile();
break;
case toolIcons.copyTool:
YuME_customBrushFunctions.createCopyBrush(false);
selectedTool = toolIcons.brushTool;
break;
case toolIcons.moveTool:
YuME_customBrushFunctions.createCopyBrush(true);
selectedTool = toolIcons.brushTool;
break;
case toolIcons.trashTool:
YuME_tileFunctions.trashTiles();
selectedTool = previousSelectedTool;
break;
case toolIcons.customBrushTool:
YuME_customBrushFunctions.createCustomBrush();
selectedTool = previousSelectedTool;
break;
case toolIcons.showGizmos:
showGizmos = !showGizmos;
YuTools_Utils.disableTileGizmo(showGizmos);
selectedTool = previousSelectedTool;
break;
case toolIcons.gridUpTool:
if (Event.current.alt)
{
gridHeight += 0.25f;
}
else
{
gridHeight++;
}
selectedTool = previousSelectedTool;
break;
case toolIcons.gridDownTool:
if (Event.current.alt)
{
gridHeight -= 0.25f;
}
else
{
gridHeight--;
}
selectedTool = previousSelectedTool;
break;
case toolIcons.rotateTool:
tileRotation += 90f;
selectedTool = previousSelectedTool;
break;
case toolIcons.flipHorizontalTool:
YuME_tileFunctions.flipHorizontal();
selectedTool = previousSelectedTool;
break;
case toolIcons.flipVerticalTool:
YuME_tileFunctions.flipVertical();
selectedTool = previousSelectedTool;
break;
case toolIcons.isolateTool:
YuME_tileFunctions.isolateTilesToggle();
selectedTool = previousSelectedTool;
break;
case toolIcons.isolateLayerTool:
YuME_tileFunctions.isolateLayerToggle();
selectedTool = previousSelectedTool;
break;
case toolIcons.layerUp:
currentLayer++;
selectedTool = previousSelectedTool;
break;
case toolIcons.layerDown:
currentLayer--;
selectedTool = previousSelectedTool;
break;
}
// ----------------------------------------------------------------------------------------------------
// ----- Check Scene View Inputs for Drawing, Picking etc.
// ----------------------------------------------------------------------------------------------------
if (selectedTool > toolIcons.defaultTools)
{
if ((Event.current.type == EventType.MouseDrag || Event.current.type == EventType.MouseDown) &&
Event.current.button == 0 &&
Event.current.alt == false &&
Event.current.shift == false &&
Event.current.control == false &&
allowTileRedraw)
{
switch (selectedTool)
{
case toolIcons.brushTool:
switch (currentBrushType)
{
case brushTypes.standardBrush:
addTiles();
break;
case brushTypes.customBrush:
YuME_customBrushFunctions.pasteCustomBrush(tilePosition);
break;
case brushTypes.copyBrush:
YuME_customBrushFunctions.pasteCopyBrush(tilePosition);
break;
}
break;
case toolIcons.pickTool:
YuME_tileFunctions.pickTile(tilePosition);
break;
case toolIcons.eraseTool:
eraseTiles();
break;
case toolIcons.selectTool:
YuME_tileFunctions.selectTile(tilePosition);
break;
}
allowTileRedraw = false;
}
else if ((Event.current.type == EventType.MouseDrag || Event.current.type == EventType.MouseDown) &&
Event.current.button == 0 &&
Event.current.alt == false &&
Event.current.shift == true &&
Event.current.control == false &&
allowTileRedraw)
{
switch (selectedTool)
{
case toolIcons.brushTool:
eraseTiles();
break;
}
allowTileRedraw = false;
}
else if ((Event.current.type == EventType.MouseDrag || Event.current.type == EventType.MouseDown) &&
Event.current.button == 0 &&
Event.current.alt == false &&
Event.current.shift == false &&
Event.current.control == true &&
allowTileRedraw)
{
switch (selectedTool)
{
case toolIcons.brushTool:
YuME_tileFunctions.pickTile(tilePosition);
break;
case toolIcons.selectTool:
YuME_tileFunctions.deSelectTile(tilePosition);
break;
}
allowTileRedraw = false;
}
HandleUtility.AddDefaultControl(controlId);
}
if (showGizmos)
{
if (selectedTiles.Count > 0)
{
foreach (GameObject tile in selectedTiles)
{
YuME_sceneGizmoFunctions.handleInfo data;
data.tileName = tile.name;
data.layer = tile.transform.parent.name;
data.grid = tile.transform.position.y;
YuME_sceneGizmoFunctions.drawTileInfo(tile.transform.position, data);
}
}
}
// ----------------------------------------------------------------------------------------------------
// ----- Scene Housekeeping
// ----------------------------------------------------------------------------------------------------
YuME_brushFunctions.updateBrushPosition();
repaintSceneView();
previousSelectedTool = selectedTool;
}
}
void mainGUI()
{
if (Event.current != null)
{
// ----------------------------------------------------------------------------------------------------
// ----- Check Keyboard and Mouse Shortcuts
// ----------------------------------------------------------------------------------------------------
YuME_keyboardShortcuts.checkKeyboardShortcuts(Event.current);
YuME_mouseShorcuts.checkMouseShortcuts(Event.current);
SceneView.RepaintAll();
}
EditorGUILayout.Space();
GUILayout.Label(editorData.mapEditorHeader);
EditorGUILayout.BeginVertical("box");
if (GUILayout.Button("Get the full version of YuME", GUILayout.Height(30)))
{
Application.OpenURL("http://u3d.as/DrF");
}
EditorGUILayout.BeginHorizontal();
toolEnabled = GUILayout.Toggle(toolEnabled, "Enable YuME", "Button", GUILayout.Height(30));
if (_toolEnabled != toolEnabled)
{
if (!toolEnabled)
{
YuTools_Utils.showUnityGrid(true);
YuME_tileFunctions.restoreIsolatedGridTiles();
YuME_tileFunctions.restoreIsolatedLayerTiles();
}
else
{
setTileBrush(0);
YuTools_Utils.showUnityGrid(false);
}
SceneView.RepaintAll();
}
_toolEnabled = toolEnabled;
openConfig = GUILayout.Toggle(openConfig, editorData.configButton, "Button", GUILayout.Width(30), GUILayout.Height(30));
if (openConfig == true)
{
YuME_editorConfig editorConfig = EditorWindow.GetWindow <YuME_editorConfig>(true, "Editor Config");
editorConfig.titleContent.text = "Editor Config";
}
openConfig = false;
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
gridDimensions = EditorGUILayout.Vector2Field("Grid Dimensions", gridDimensions);
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Grid Height: " + gridHeight.ToString());
GUILayout.Label("Brush Size: (" + brushSize.x.ToString() + "," + brushSize.y.ToString() + "," + brushSize.z.ToString() + ")");
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Pick The Tile Set To Use", EditorStyles.boldLabel);
currentTileSetIndex = EditorGUILayout.Popup("Choose Tileset", currentTileSetIndex, tileSetNames);
if (currentTileSetIndex != _currentTileSetIndex)
{
loadPreviewTiles();
}
if (GUILayout.Button("Reload Available Tilesets", GUILayout.Height(30)))
{
importTileSets(true);
loadCustomBrushes();
loadPreviewTiles(); // this is in the wrong place - it needs to be triggered when the user picks a new tileset
}
EditorGUILayout.EndVertical();
EditorGUILayout.BeginVertical("box");
string[] buttonLabels = new string[] { "Tileset Brushes", "Custom Brushes" };
brushPallete = (brushOptions)GUILayout.SelectionGrid(
(int)brushPallete,
buttonLabels,
2,
EditorStyles.toolbarButton
);
EditorGUILayout.EndVertical();
drawTilePreviews();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Tile Previw Columns", EditorStyles.boldLabel);
tilePreviewColumnWidth = EditorGUILayout.IntSlider(tilePreviewColumnWidth, 1, 10);
EditorGUILayout.EndVertical();
updateGridColors();
YuME_sceneGizmoFunctions.displayGizmoGrid();
_currentTileSetIndex = currentTileSetIndex;
}
public static void saveFrozenMesh(string path)
{
path = YuTools_Utils.shortenAssetPath(path);
int counter = 1;
if (YuME_mapEditor.findTileMapParent())
{
foreach (Transform child in YuME_mapEditor.tileMapParent.transform)
{
if (child.gameObject.name == "frozenMap")
{
GameObject saveMap = Instantiate(child.gameObject);
saveMap.name = YuME_mapEditor.tileMapParent.name;
if (!AssetDatabase.IsValidFolder(path + "/" + saveMap.name + "Meshes"))
{
AssetDatabase.CreateFolder(path, saveMap.name + "Meshes");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
EditorUtility.ClearProgressBar();
foreach (Transform frozenMesh in saveMap.transform)
{
EditorUtility.DisplayProgressBar("Saving Meshes", "Saving Mesh " + (counter) + ". This might take some time", 1);
Mesh saveMesh = Object.Instantiate(frozenMesh.GetComponent <MeshFilter>().sharedMesh) as Mesh;
//Unwrapping.GenerateSecondaryUVSet(saveMesh);
try
{
AssetDatabase.CreateAsset(saveMesh, path + "/" + saveMap.name + "Meshes/" + frozenMesh.name + counter + ".asset");
}
catch
{
Debug.LogWarning("Failed to create saved map. This is likely due to a new folder being created and Unity not refreshing the asset database. Please retry saving the map.");
EditorUtility.ClearProgressBar();
return;
}
frozenMesh.GetComponent <MeshFilter>().mesh = saveMesh;
counter++;
}
EditorUtility.ClearProgressBar();
Object prefabAlreadyCreated = AssetDatabase.LoadAssetAtPath(path + "/" + saveMap.name + ".prefab", typeof(GameObject));
if (prefabAlreadyCreated != null)
#if UNITY_2018_3_OR_NEWER
{ PrefabUtility.SaveAsPrefabAssetAndConnect(saveMap, path + "/" + saveMap.name + ".prefab", InteractionMode.AutomatedAction); }
#else
{ PrefabUtility.ReplacePrefab(saveMap, prefabAlreadyCreated, ReplacePrefabOptions.ReplaceNameBased); }
#endif
else
#if UNITY_2018_3_OR_NEWER
{ PrefabUtility.SaveAsPrefabAsset(saveMap, path + "/" + saveMap.name + ".prefab"); }
#else
{ PrefabUtility.CreatePrefab(path + "/" + saveMap.name + ".prefab", saveMap); }
#endif
AssetDatabase.SaveAssets();
if (saveMap != null)
{
DestroyImmediate(saveMap);
}
}
}
AssetDatabase.Refresh();
}
void OnGUI()
{
// ----------------------------------------------------------------------------------------------------
// ------ Tile Import Data
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
GUILayout.Label(editorData.tileImporterHeader);
_scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition);
EditorGUILayout.LabelField("Tile Import Settings", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
if (userSettings.sourceTiles == null)
{
userSettings.sourceTiles = (GameObject)EditorGUILayout.ObjectField("Source Tiles Object", null, typeof(GameObject), false);
}
else
{
userSettings.sourceTiles = (GameObject)EditorGUILayout.ObjectField("Source Tiles Object", userSettings.sourceTiles, typeof(GameObject), false);
}
if (userSettings.sourceMaterial == null)
{
userSettings.sourceMaterial = (Material)EditorGUILayout.ObjectField("Source Tile Material", null, typeof(Material), false);
}
else
{
userSettings.sourceMaterial = (Material)EditorGUILayout.ObjectField("Source Tile Material", userSettings.sourceMaterial, typeof(Material), false);
}
if (userSettings.sourceTexture == null)
{
userSettings.sourceTexture = (Texture)EditorGUILayout.ObjectField("Source Tile Texture", null, typeof(Texture), false);
}
else
{
userSettings.sourceTexture = (Texture)EditorGUILayout.ObjectField("Source Tile Texture", userSettings.sourceTexture, typeof(Texture), false);
}
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Static Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Prefab Static Setting", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.tileStatic = EditorGUILayout.Toggle("Set Tiles as Static", userSettings.tileStatic);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Alt Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("ALT Tile Setting", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.altIdentifier = EditorGUILayout.TextField("Alternative Tile Identifier", userSettings.altIdentifier);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Shadow Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Prefab Shadow Setup", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.shadowCastingMode = EditorGUILayout.Popup("Cast Shadows", userSettings.shadowCastingMode, new string[] { "Off", "On", "ShadowsOnly", "TwoSided" });
userSettings.receiveShadows = EditorGUILayout.Toggle("Receive Shadows", userSettings.receiveShadows);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Collision Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Tile Collision Setup", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.bypassCollisionSetup = EditorGUILayout.Toggle("Bypass Collision Setup", userSettings.bypassCollisionSetup);
if (!userSettings.bypassCollisionSetup)
{
userSettings.importCollision = EditorGUILayout.Toggle("Custom Collision Mesh", userSettings.importCollision);
if (userSettings.importCollision)
{
userSettings.collisionIdentifier = EditorGUILayout.TextField("Collision Mesh Identifier", userSettings.collisionIdentifier);
}
}
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Bounding Box Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Tile Bounding Setup", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.importCustomBounds = EditorGUILayout.Toggle("Custom Bounds Mesh", userSettings.importCustomBounds);
if (userSettings.importCustomBounds)
{
userSettings.customBoundsIdentifier = EditorGUILayout.TextField("Custom Bounds Identifier", userSettings.customBoundsIdentifier);
}
EditorGUILayout.EndVertical();
//data.userSettings.splitByType = EditorGUI.Toggle(new Rect(3, 295, position.width - 3, 20),
// new GUIContent("Split Tiles by Type", "Checks the tile name for keywords such as 'wall', 'floor', 'corner' and puts them in seperate folders for easy navigation"),
// data.userSettings.splitByType);
// ----------------------------------------------------------------------------------------------------
// ------ Append Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Custom Append Label", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.appendName = EditorGUILayout.TextField("Append to Tile Name", userSettings.appendName);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Folder Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Select Tile Prefab Destination Folder", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Set Destination Folders");
if (GUILayout.Button("Tile Destination", GUILayout.Height(30)))
{
userSettings.destinationFolder = EditorUtility.OpenFolderPanel("Tile Prefab Destination Folder", "", "");
if (userSettings.destinationFolder == "")
{
userSettings.destinationFolder = "Assets/";
}
}
userSettings.destinationFolder = YuTools_Utils.shortenAssetPath(userSettings.destinationFolder);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Select Mesh Destination Folder");
if (GUILayout.Button("Mesh Destination", GUILayout.Height(30)))
{
userSettings.meshFolder = EditorUtility.OpenFolderPanel("Tile Mesh Destination Folder", "", "");
if (userSettings.meshFolder == "")
{
userSettings.meshFolder = "Assets/";
}
}
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
userSettings.meshFolder = YuTools_Utils.shortenAssetPath(userSettings.meshFolder);
// ----------------------------------------------------------------------------------------------------
// ------ Import Button
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
if (userSettings.sourceTiles != null)
{
if (GUILayout.Button("Import Tileset", GUILayout.Height(40)))
{
bool tileDestinationFolderWarning = true;
bool meshDestinationFolderWarning = true;
if (userSettings.destinationFolder == "Assets/")
{
tileDestinationFolderWarning = EditorUtility.DisplayDialog("Tile Prefabs will be created in the root Assets Folder",
"Are you sure you want create the tile prefabs in the root Asset/ folder?", "OK", "Cancel");
}
if (userSettings.meshFolder == "Assets/")
{
meshDestinationFolderWarning = EditorUtility.DisplayDialog("New mesh data will be created in the root Assets Folder",
"Are you sure you want create the new mesh data in the root Asset/ folder?", "OK", "Cancel");
}
if (tileDestinationFolderWarning && meshDestinationFolderWarning)
{
refreshSourceTileObject();
createTemplateMaterial();
createTemplateTileObject();
setTileShadowOptions();
createTileSet();
revertScenePrefabs();
YuME_tileConverter.recreateCustomBrushes(userSettings.destinationFolder);
cleanUpImport();
}
}
}
else
{
EditorGUILayout.HelpBox("Set a Source Tile Object To Create Tile Set", MessageType.Warning);
}
// ----------------------------------------------------------------------------------------------------
// ------ Output Folder Information
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Tile Output Folder:", EditorStyles.boldLabel);
EditorGUILayout.LabelField(userSettings.destinationFolder);
EditorGUILayout.LabelField("Mesh Output Folder:", EditorStyles.boldLabel);
EditorGUILayout.LabelField(userSettings.meshFolder);
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
// ----------------------------------------------------------------------------------------------------
// ------ GUI Changed
// ----------------------------------------------------------------------------------------------------
if (GUI.changed)
{
if (userSettings.sourceMaterial != null)
{
userSettings.sourceTexture = userSettings.sourceMaterial.mainTexture;
}
EditorUtility.SetDirty(userSettings);
}
}
void OnGUI()
{
// ----------------------------------------------------------------------------------------------------
// ------ Tile Converter Data
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
GUILayout.Label(editorData.tileconverterHeader);
_scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition);
EditorGUILayout.LabelField("Tile Converter Settings", EditorStyles.boldLabel);
// ----------------------------------------------------------------------------------------------------
// ------ Folder Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Select Tile Prefab Destination Folder", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Select Source Prefab Folders");
if (GUILayout.Button("Prefab Source Folder", GUILayout.Height(30)))
{
userSettings.c_sourceFolder = EditorUtility.OpenFolderPanel("Tile Prefab Source Folder", "", "");
if (userSettings.c_sourceFolder == "")
{
userSettings.c_sourceFolder = "Assets/";
}
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Select Tile Destination Folder");
if (GUILayout.Button("Tile Destination", GUILayout.Height(30)))
{
userSettings.c_destinationFolder = EditorUtility.OpenFolderPanel("Tile Prefab Destination Folder", "", "");
if (userSettings.c_destinationFolder == "")
{
userSettings.c_destinationFolder = "Assets/";
}
}
userSettings.c_destinationFolder = YuTools_Utils.shortenAssetPath(userSettings.c_destinationFolder);
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
userSettings.c_sourceFolder = YuTools_Utils.shortenAssetPath(userSettings.c_sourceFolder);
// ----------------------------------------------------------------------------------------------------
// ------ Name Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Tile Set Name", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.c_name = EditorGUILayout.TextField("Set Tile Set Name", userSettings.c_name);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Scale Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Scale Adjustment", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.c_scale = EditorGUILayout.FloatField("Rescale Factor", userSettings.c_scale);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Offset Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Offset Adjustment", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.c_offset = EditorGUILayout.Vector3Field("Offset Values", userSettings.c_offset);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Append Settings
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.LabelField("Custom Append Label", EditorStyles.boldLabel);
EditorGUILayout.BeginVertical("box");
userSettings.c_appendName = EditorGUILayout.TextField("Append to Tile Name", userSettings.c_appendName);
EditorGUILayout.EndVertical();
// ----------------------------------------------------------------------------------------------------
// ------ Import Button
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
if (userSettings.c_sourceFolder != "" && userSettings.c_destinationFolder != "")
{
if (GUILayout.Button("Convert Tileset", GUILayout.Height(40)))
{
bool tileDestinationFolderWarning = true;
if (userSettings.c_destinationFolder == "Assets/")
{
tileDestinationFolderWarning = EditorUtility.DisplayDialog("Tile Prefabs will be created in the root Assets Folder",
"Are you sure you want create the tile prefabs in the root Asset/ folder?", "OK", "Cancel");
}
if (tileDestinationFolderWarning)
{
createTileSet(false);
recreateCustomBrushes(userSettings.c_destinationFolder);
cleanUpImport();
}
}
}
else
{
EditorGUILayout.HelpBox("Set a source and destination directories to start conversion", MessageType.Warning);
}
// ----------------------------------------------------------------------------------------------------
// ------ Reimport Button
// ----------------------------------------------------------------------------------------------------
//EditorGUILayout.Space();
if (userSettings.c_sourceFolder != "" && userSettings.c_destinationFolder != "")
{
EditorGUILayout.HelpBox("Use reimport if you are happy with your scale settings but wish to add new tiles to the exisiting set.", MessageType.Info);
if (GUILayout.Button("Reimport Tileset", GUILayout.Height(40)))
{
bool tileDestinationFolderWarning = true;
if (userSettings.c_destinationFolder == "Assets/")
{
tileDestinationFolderWarning = EditorUtility.DisplayDialog("Tile Prefabs will be created in the root Assets Folder",
"Are you sure you want create the tile prefabs in the root Asset/ folder?", "OK", "Cancel");
}
if (tileDestinationFolderWarning)
{
createTileSet(true);
recreateCustomBrushes(userSettings.c_destinationFolder);
cleanUpImport();
}
}
}
else
{
EditorGUILayout.HelpBox("Set a source and destination directories to start conversion", MessageType.Warning);
}
// ----------------------------------------------------------------------------------------------------
// ------ Output Folder Information
// ----------------------------------------------------------------------------------------------------
EditorGUILayout.Space();
EditorGUILayout.BeginVertical("box");
EditorGUILayout.LabelField("Source Prefab Folder:", EditorStyles.boldLabel);
EditorGUILayout.LabelField(userSettings.c_sourceFolder);
EditorGUILayout.LabelField("Tile Output Folder:", EditorStyles.boldLabel);
EditorGUILayout.LabelField(userSettings.c_destinationFolder);
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
// ----------------------------------------------------------------------------------------------------
// ------ GUI Changed
// ----------------------------------------------------------------------------------------------------
if (GUI.changed)
{
EditorUtility.SetDirty(userSettings);
}
}
