public static GStylizedTerrain CreateTerrainFromSource(GTerrainData srcData)
{
GEditorSettings.WizardToolsSettings settings = GEditorSettings.Instance.wizardTools;
GameObject g = new GameObject("Low Poly Terrain");
g.transform.localPosition = Vector3.zero;
g.transform.localRotation = Quaternion.identity;
g.transform.localScale = Vector3.one;
GTerrainData terrainData = GTerrainData.CreateInstance <GTerrainData>();
terrainData.Reset();
#if UNITY_EDITOR
string assetName = "TerrainData_" + terrainData.Id;
GUtilities.EnsureDirectoryExists(settings.dataDirectory);
AssetDatabase.CreateAsset(terrainData, Path.Combine(settings.dataDirectory, assetName + ".asset"));
#endif
srcData.CopyTo(terrainData);
Material mat = null;
if (srcData != null && srcData.Shading.CustomMaterial != null)
{
mat = UnityEngine.Object.Instantiate(srcData.Shading.CustomMaterial);
}
if (mat != null)
{
string matName = "TerrainMaterial_" + terrainData.Id;
mat.name = matName;
#if UNITY_EDITOR
GUtilities.EnsureDirectoryExists(settings.dataDirectory);
AssetDatabase.CreateAsset(mat, Path.Combine(settings.dataDirectory, matName + ".mat"));
#endif
terrainData.Shading.CustomMaterial = mat;
}
GStylizedTerrain terrain = g.AddComponent <GStylizedTerrain>();
terrain.GroupId = 0;
terrain.TerrainData = terrainData;
#if UNITY_EDITOR
Undo.RegisterCreatedObjectUndo(g, "Creating Low Poly Terrain");
#endif
GameObject colliderGO = new GameObject("Tree Collider");
colliderGO.transform.parent = terrain.transform;
colliderGO.transform.localPosition = Vector3.zero;
colliderGO.transform.localRotation = Quaternion.identity;
colliderGO.transform.localScale = Vector3.one;
GTreeCollider collider = colliderGO.AddComponent <GTreeCollider>();
collider.Terrain = terrain;
#if UNITY_EDITOR
Selection.activeGameObject = g;
#endif
return(terrain);
}
private void OnTerrainDataDirty(GTerrainData data, GTerrainData.DirtyFlags flag)
{
GStylizedTerrain t = GTextureToolParams.Instance.LivePreview.Terrain;
if (t == null || t.TerrainData != data)
{
return;
}
RenderPreviewTexture();
}
private void OnTerrainDataDirty(GTerrainData data, GTerrainData.DirtyFlags flag)
{
if (Terrain != null &&
Terrain.TerrainData == data)
{
if (flag == GTerrainData.DirtyFlags.All ||
flag == GTerrainData.DirtyFlags.Foliage)
{
InitTreeInstances();
}
}
}
private GStylizedTerrain CreateTerrain()
{
GameObject g = new GameObject("Stylized Terrain");
g.transform.localPosition = Vector3.zero;
g.transform.localRotation = Quaternion.identity;
g.transform.localScale = Vector3.one;
GTerrainData terrainData = GTerrainData.CreateInstance <GTerrainData>();
terrainData.Reset();
#if UNITY_EDITOR
string assetName = "TerrainData_" + terrainData.Id;
AssetDatabase.CreateAsset(terrainData, string.Format("{0}.asset", Path.Combine(DataDirectory, assetName)));
#endif
Material mat = GGriffinSettings.Instance.WizardSettings.GetClonedMaterial(GLightingModel.PBR, GTexturingModel.Splat);
if (mat == null && GGriffinSettings.Instance.TerrainDataDefault.Shading.CustomMaterial != null)
{
mat = Object.Instantiate(GGriffinSettings.Instance.TerrainDataDefault.Shading.CustomMaterial);
}
terrainData.Shading.CustomMaterial = mat;
#if UNITY_EDITOR
if (mat != null)
{
string matName = "TerrainMaterial_" + terrainData.Id;
mat.name = matName;
AssetDatabase.CreateAsset(mat, string.Format("{0}.mat", Path.Combine(DataDirectory, matName)));
}
#endif
GStylizedTerrain terrain = g.AddComponent <GStylizedTerrain>();
terrain.GroupId = 0;
terrain.TerrainData = terrainData;
GameObject colliderGO = new GameObject("Tree Collider");
colliderGO.transform.parent = terrain.transform;
colliderGO.transform.localPosition = Vector3.zero;
colliderGO.transform.localRotation = Quaternion.identity;
colliderGO.transform.localScale = Vector3.one;
GTreeCollider collider = colliderGO.AddComponent <GTreeCollider>();
collider.Terrain = terrain;
return(terrain);
}
private static void Export()
{
EditorUtility.DisplayProgressBar("Exporting", "Exporting terrain to file...", 1f);
try
{
List <Mesh> meshes = new List <Mesh>();
TerrainToFileConfig config = TerrainToFileConfig.Instance;
GStylizedTerrain terrain = config.Terrain;
GTerrainData terrainData = terrain.TerrainData;
int gridSize = terrainData.Geometry.ChunkGridSize;
int lod = config.LOD;
GTerrainChunk[] chunks = terrain.GetComponentsInChildren <GTerrainChunk>();
for (int i = 0; i < chunks.Length; ++i)
{
Mesh m = chunks[i].MeshFilterComponent.sharedMesh;
if (m != null)
{
Mesh cloneMesh = Object.Instantiate(m);
Matrix4x4 chunkToWorld = chunks[i].transform.localToWorldMatrix;
Matrix4x4 worldToTerrain = terrain.transform.worldToLocalMatrix;
Matrix4x4 matrix = chunkToWorld * worldToTerrain;
TransformMesh(cloneMesh, matrix);
meshes.Add(cloneMesh);
}
}
string fileName = string.Format("{0}_{1}_{2}",
config.Terrain.name.Replace(" ", "_"),
config.Terrain.GetInstanceID().ToString(),
"LOD" + config.LOD);
GUtilities.EnsureDirectoryExists(config.Directory);
string filePath = null;
if (config.FileType == MeshSaver.FileType.Obj)
{
filePath = MeshSaver.SaveObjMultipleMesh(meshes.ToArray(), config.Directory, fileName);
}
else if (config.FileType == MeshSaver.FileType.Fbx)
{
filePath = MeshSaver.SaveFbxMultipleMesh(meshes.ToArray(), config.Directory, fileName);
}
for (int i = 0; i < meshes.Count; ++i)
{
Object.DestroyImmediate(meshes[i]);
}
AssetDatabase.Refresh();
if (!string.IsNullOrEmpty(filePath))
{
string assetPath = filePath;
ModelImporter importer = ModelImporter.GetAtPath(assetPath) as ModelImporter;
if (importer != null)
{
importer.useFileScale = false;
importer.weldVertices = false;
importer.SaveAndReimport();
}
Object asset = AssetDatabase.LoadAssetAtPath <Object>(assetPath);
if (asset != null)
{
Selection.activeObject = asset;
EditorGUIUtility.PingObject(asset);
}
}
}
catch (System.Exception e)
{
Debug.LogError(e);
}
EditorUtility.ClearProgressBar();
}
public static List <GStylizedTerrain> CreateTerrains(GameObject root)
{
GEditorSettings.WizardToolsSettings settings = GEditorSettings.Instance.wizardTools;
List <GStylizedTerrain> terrains = new List <GStylizedTerrain>();
#if UNITY_EDITOR
if (!Application.isPlaying)
{
GUtilities.EnsureDirectoryExists(settings.dataDirectory);
}
#endif
try
{
float totalTile = settings.tileCountX * settings.tileCountZ;
float tileCount = 0;
for (int z = 0; z < settings.tileCountZ; ++z)
{
for (int x = 0; x < settings.tileCountX; ++x)
{
tileCount += 1;
#if UNITY_EDITOR
GCommonGUI.CancelableProgressBar(
"Creating Terrains",
string.Format("Creating tile ({0},{1})", x, z),
tileCount / totalTile);
#endif
GameObject g = new GameObject();
g.transform.parent = root.transform;
g.transform.position = new Vector3(x * settings.tileSize.x, 0, z * settings.tileSize.z) + settings.origin;
g.transform.rotation = Quaternion.identity;
g.transform.localScale = Vector3.one;
g.name = string.Format("{0}_({1},{2})", settings.terrainNamePrefix, x, z);
GTerrainData data = ScriptableObject.CreateInstance <GTerrainData>();
if (Application.isPlaying) //Reset() only called in edit mode
{
data.Reset();
data.Geometry.Reset();
data.Shading.Reset();
data.Rendering.Reset();
data.Foliage.Reset();
data.Mask.Reset();
}
data.name = string.Format("TerrainData_{0}", data.Id);
data.Geometry.Width = settings.tileSize.x;
data.Geometry.Height = settings.tileSize.y;
data.Geometry.Length = settings.tileSize.z;
if (settings.texturingModel == GTexturingModel.VertexColor)
{
data.Geometry.AlbedoToVertexColorMode = GAlbedoToVertexColorMode.Sharp;
}
#if UNITY_EDITOR
if (!Application.isPlaying)
{
string dataAssetPath = Path.Combine(settings.dataDirectory, data.name + ".asset");
AssetDatabase.CreateAsset(data, dataAssetPath);
}
#endif
Material material = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(
GCommon.CurrentRenderPipeline,
settings.lightingModel,
settings.texturingModel,
settings.splatsModel);
if (material != null)
{
material.name = string.Format("TerrainMaterial_{0}", data.Id);
#if UNITY_EDITOR
if (!Application.isPlaying)
{
string materialAssetPath = Path.Combine(settings.dataDirectory, material.name + ".mat");
AssetDatabase.CreateAsset(material, materialAssetPath);
}
#endif
}
data.Shading.CustomMaterial = material;
data.Shading.UpdateMaterials();
GStylizedTerrain terrain = g.AddComponent <GStylizedTerrain>();
terrain.GroupId = settings.groupId;
terrain.TerrainData = data;
#if UNITY_EDITOR
Undo.RegisterCreatedObjectUndo(g, "Creating Low Poly Terrain");
#endif
GameObject colliderGO = new GameObject("Tree Collider");
colliderGO.transform.parent = g.transform;
colliderGO.transform.localPosition = Vector3.zero;
colliderGO.transform.localRotation = Quaternion.identity;
colliderGO.transform.localScale = Vector3.one;
GTreeCollider collider = colliderGO.AddComponent <GTreeCollider>();
collider.Terrain = terrain;
}
}
}
catch (GProgressCancelledException)
{
}
GStylizedTerrain.ConnectAdjacentTiles();
#if UNITY_EDITOR
GCommonGUI.ClearProgressBar();
#endif
return(terrains);
}
private static void Export()
{
EditorUtility.DisplayProgressBar("Exporting", "Exporting terrain to file...", 1f);
try
{
List <Mesh> meshes = new List <Mesh>();
TerrainToFileConfig config = TerrainToFileConfig.Instance;
GStylizedTerrain terrain = config.Terrain;
GTerrainData terrainData = terrain.TerrainData;
int gridSize = terrainData.Geometry.ChunkGridSize;
int lod = config.LOD;
for (int z = 0; z < gridSize; ++z)
{
for (int x = 0; x < gridSize; ++x)
{
Vector2 meshIndex = new Vector2(x, z);
Mesh m = terrainData.GeometryData.GetMesh(GTerrainChunk.GetChunkMeshName(meshIndex, lod));
if (m != null)
{
meshes.Add(m);
}
}
}
string fileName = string.Format("{0}_{1}_{2}",
config.Terrain.name.Replace(" ", "_"),
config.Terrain.GetInstanceID().ToString(),
"LOD" + config.LOD);
string filePath = null;
if (config.FileType == MeshSaver.FileType.Obj)
{
filePath = MeshSaver.SaveObjMultipleMesh(meshes.ToArray(), config.Directory, fileName);
}
else if (config.FileType == MeshSaver.FileType.Fbx)
{
filePath = MeshSaver.SaveFbxMultipleMesh(meshes.ToArray(), config.Directory, fileName);
}
AssetDatabase.Refresh();
if (!string.IsNullOrEmpty(filePath))
{
string assetPath = filePath;
ModelImporter importer = ModelImporter.GetAtPath(assetPath) as ModelImporter;
if (importer != null)
{
importer.useFileScale = false;
importer.weldVertices = false;
importer.SaveAndReimport();
}
Object asset = AssetDatabase.LoadAssetAtPath <Object>(assetPath);
if (asset != null)
{
Selection.activeObject = asset;
EditorGUIUtility.PingObject(asset);
}
}
}
catch (System.Exception e)
{
Debug.LogError(e);
}
EditorUtility.ClearProgressBar();
}
private void ImportDataAndCreateTerrain()
{
GameObject terrainRoot = new GameObject(string.Format("{0}-{1}", Root.name, ConversionName));
terrainRoot.transform.parent = Root.transform.parent;
terrainRoot.transform.position = Root.transform.position;
for (int i = 0; i < Terrains.Count; ++i)
{
#if UNITY_EDITOR
GCommonGUI.CancelableProgressBar("Converting", "Converting " + Terrains[i].name, 1f);
#endif
GTerrainData data = ScriptableObject.CreateInstance <GTerrainData>();
if (DataTemplate != null)
{
DataTemplate.Geometry.CopyTo(data.Geometry);
DataTemplate.Shading.CopyTo(data.Shading);
DataTemplate.Rendering.CopyTo(data.Rendering);
DataTemplate.Foliage.CopyTo(data.Foliage);
DataTemplate.Mask.CopyTo(data.Mask);
}
else
{
if (Application.isPlaying) //Reset() only called in edit mode
{
data.Reset();
data.Geometry.Reset();
data.Shading.Reset();
data.Rendering.Reset();
data.Foliage.Reset();
data.Mask.Reset();
}
}
#if UNITY_EDITOR
if (!Application.isPlaying)
{
string assetName = "TerrainData_" + data.Id;
AssetDatabase.CreateAsset(data, string.Format("{0}.asset", Path.Combine(DataDirectory, assetName)));
}
#endif
Material templateMaterial = null;
if (DataTemplate != null)
{
templateMaterial = DataTemplate.Shading.CustomMaterial;
}
Material material = null;
if (templateMaterial != null)
{
material = new Material(templateMaterial.shader);
}
else
{
if (ImportSplats)
{
if (ImportSplatsAsAlbedo && AlbedoUsage == GAlbedoUsage.ColorMap)
{
material = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(GCommon.CurrentRenderPipeline, GLightingModel.PBR, GTexturingModel.ColorMap);
}
else if (ImportSplatsAsAlbedo && AlbedoUsage == GAlbedoUsage.VertexColor)
{
material = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(GCommon.CurrentRenderPipeline, GLightingModel.PBR, GTexturingModel.VertexColor);
data.Geometry.AlbedoToVertexColorMode = GAlbedoToVertexColorMode.Sharp;
}
else
{
GSplatPrototypeGroup splats = DataTemplate ? DataTemplate.Shading.Splats : SplatGroups[SplatGroupIndices[i]];
GSplatsModel splatModel = (splats == null || splats.Prototypes.Count <= 4) ?
GSplatsModel.Splats4Normals4 :
GSplatsModel.Splats8;
material = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(GCommon.CurrentRenderPipeline, GLightingModel.PBR, GTexturingModel.Splat, splatModel);
}
}
else
{
material = GRuntimeSettings.Instance.terrainRendering.GetClonedMaterial(GCommon.CurrentRenderPipeline, GLightingModel.PBR, GTexturingModel.Splat, GSplatsModel.Splats4);
}
}
data.Shading.CustomMaterial = material;
#if UNITY_EDITOR
if (!Application.isPlaying && material != null)
{
string matName = "TerrainMaterial_" + data.Id;
material.name = matName;
AssetDatabase.CreateAsset(material, string.Format("{0}.mat", Path.Combine(DataDirectory, matName)));
}
#endif
if (ImportSplats)
{
data.Shading.Splats = DataTemplate ? DataTemplate.Shading.Splats : SplatGroups[SplatGroupIndices[i]];
data.Shading.UpdateMaterials();
}
if (ImportTrees)
{
data.Foliage.Trees = DataTemplate ? DataTemplate.Foliage.Trees : TreeGroups[TreeGroupIndices[i]];
}
if (ImportGrasses)
{
data.Foliage.Grasses = DataTemplate ? DataTemplate.Foliage.Grasses : GrassGroups[GrassGroupIndices[i]];
}
GUnityTerrainDataImporter importer = new GUnityTerrainDataImporter();
importer.SrcData = Terrains[i].terrainData;
importer.SrcTerrain = Terrains[i];
importer.DesData = data;
importer.DesTerrain = null;
importer.ImportGeometry = ImportGeometry;
importer.UseUnityTerrainSize = true;
importer.ImportSplats = ImportSplats;
importer.ImportSplatsAsAlbedo = ImportSplatsAsAlbedo;
importer.ImportSplatControlMapsOnly = DataTemplate != null && DataTemplate.Shading.Splats != null;
importer.ImportSplatControlMapResolution = DataTemplate == null;
importer.CreateNewSplatPrototypesGroup = false;
importer.ImportTrees = ImportTrees;
importer.ImportTreeInstancesOnly = DataTemplate != null && DataTemplate.Foliage.Trees != null;
importer.CreateNewTreePrototypesGroup = false;
importer.ImportGrasses = ImportGrasses;
importer.ImportGrassInstancesOnly = DataTemplate != null && DataTemplate.Foliage.Grasses != null;
importer.CreateNewGrassPrototypesGroup = false;
importer.GrassDensity = 1;
importer.SkipFoliageSnap = SkipFoliageSnap;
importer.Import();
GStylizedTerrain t = CreateTerrain();
t.transform.parent = terrainRoot.transform;
t.transform.position = Terrains[i].transform.position;
t.name = Terrains[i].name;
#if UNITY_2018_3_OR_NEWER
t.GroupId = Terrains[i].groupingID;
#endif
t.TerrainData = data;
if (ImportTrees || ImportGrasses)
{
data.Foliage.SetTreeRegionDirty(GCommon.UnitRect);
data.Foliage.SetGrassRegionDirty(GCommon.UnitRect);
t.UpdateTreesPosition();
t.UpdateGrassPatches();
data.Foliage.ClearTreeDirtyRegions();
data.Foliage.ClearGrassDirtyRegions();
}
ConvertedTerrains.Add(t);
#if UNITY_EDITOR
//SaveAssets();
GCommonGUI.ClearProgressBar();
#endif
}
}
