private static int[] ExportInteriors(BuildrData data)
{
int numberOfVolumes = data.plan.numberOfVolumes;
int[] returnNumberOfMeshes = new int[numberOfVolumes];
for (int v = 0; v < numberOfVolumes; v++)
{
DynamicMeshGenericMultiMaterialMesh INT_MESH = new DynamicMeshGenericMultiMaterialMesh();
INT_MESH.subMeshCount = data.textures.Count;
BuildrInteriors.Build(INT_MESH, data, v);
INT_MESH.Build(data.includeTangents);
List <int> unusedTextures = INT_MESH.unusedSubmeshes;
int numberOfUnpackedTextures = data.textures.Count;
List <ExportMaterial> exportTextures = new List <ExportMaterial>();
for (int t = 0; t < numberOfUnpackedTextures; t++)
{
if (unusedTextures.Contains(t))
{
continue;//skip, unused
}
ExportMaterial newTexture = new ExportMaterial();
newTexture.name = data.textures[t].name;
newTexture.material = data.textures[t].material;
newTexture.generated = false;
newTexture.filepath = data.textures[t].filePath;
exportTextures.Add(newTexture);
}
int numberOfMeshes = INT_MESH.meshCount;
for (int i = 0; i < numberOfMeshes; i++)
{
MeshUtility.Optimize(INT_MESH[i].mesh);
string VolumeSuffix = ((numberOfVolumes > 1) ? "_" + v : "");
string DetailSuffixIndex = ((numberOfMeshes > 1) ? "_" + i : "");
string DetailFileName = data.exportFilename + INTERIOR_SUFFIX + VolumeSuffix + DetailSuffixIndex;
string DetailFolder = ROOT_FOLDER + data.exportFilename + "/";
Export(DetailFileName, DetailFolder, data, INT_MESH[i].mesh, exportTextures.ToArray());
}
returnNumberOfMeshes[v] = numberOfMeshes;
}
return(returnNumberOfMeshes);
}
public static GameObject Combine(PolyGraph graph, List <GameObject> gameObjects)
{
if (!ConnectedCheck(graph, gameObjects))
{
return(null);
}
int index = NextIndex(graph.transform);
CombineInstance[] combine = new CombineInstance[gameObjects.Count];
for (int i = 0; i < combine.Length; ++i)
{
var meshFilter = gameObjects[i].GetComponent <MeshFilter>();
combine[i].mesh = meshFilter.sharedMesh;
combine[i].transform = meshFilter.transform.localToWorldMatrix;
}
var mesh = new Mesh();
mesh.name = "mesh_" + index;
mesh.CombineMeshes(combine);
Vector3 centroid;
mesh.vertices = Centralize(mesh.vertices, out centroid);
mesh.RecalculateBounds();
MeshUtility.Optimize(mesh);
string savePath = string.Format("{0}/{1}/Meshes/{2}.prefab", Paths.AssetArtworks, graph.name, mesh.name);
AssetDatabase.CreateAsset(mesh, savePath);
AssetDatabase.SaveAssets();
var go = new GameObject(
index.ToString(),
typeof(MeshFilter),
typeof(MeshRenderer),
typeof(MeshCollider));
Utils.SetupMeshRenderer(go);
go.tag = Tags.Debris;
go.layer = Layers.Debris;
go.transform.parent = graph.transform;
go.GetComponent <MeshFilter>().mesh = mesh;
go.transform.localPosition = centroid;
go.GetComponent <MeshCollider>().sharedMesh = mesh;
return(go);
}
public void SaveMesh()
{
string path = EditorUtility.SaveFilePanel("Save Mesh Asset", "Assets/", "NewMesh", "asset");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
Mesh m = GetComponent <MeshFilter>().sharedMesh;
Mesh meshSave = Object.Instantiate(m) as Mesh;
MeshUtility.Optimize(meshSave);
AssetDatabase.CreateAsset(meshSave, path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
private void MakeRope()
{
if (_meshGenerator == null)
{
Debug.LogError("MeshGenerator is not specified");
return;
}
var go = new GameObject("New Rope (" + (++_genCounter).ToString() + ")");
go.transform.localPosition = new Vector3(0, 0, 0);
go.transform.rotation = Quaternion.FromToRotation(Vector3.right, Vector3.down);
if (_parrent != null)
{
go.transform.parent = _parrent.transform;
}
var tmpRope = new RopeGenerator(_meshGenerator, go);
ApplayParams(tmpRope);
var result = tmpRope.MakeOne();
if (_optimizeMesh)
{
MeshUtility.Optimize(result.Mesh);
}
if (_saveMesh)
{
var path = EditorUtility.SaveFilePanel(
"Save mesh",
"",
"new_mesh.asset",
"asset");
path = FileUtil.GetProjectRelativePath(path);
if (path.Length != 0)
{
AssetDatabase.CreateAsset(result.Mesh, path);
AssetDatabase.SaveAssets();
}
}
}
// Save mesh as asset
public static void SaveMesh(MeshFilter mf, Mesh mesh, string name, bool makeNewInstance, bool optimize)
{
// Save path
string savePath = EditorUtility.SaveFilePanel("Save Separate Mesh Asset", "Assets/", name, "asset");
// No path
if (string.IsNullOrEmpty(savePath) == true)
{
return;
}
// Convert path
savePath = FileUtil.GetProjectRelativePath(savePath);
// Get save mesh
Mesh saveMesh = makeNewInstance == true
? UnityEngine.Object.Instantiate(mesh)
: mesh;
// Optimize
if (optimize == true)
{
MeshUtility.Optimize(saveMesh);
}
// Create asset
AssetDatabase.CreateAsset(saveMesh, savePath);
// Add all meshes
Mesh mesh2 = UnityEngine.Object.Instantiate(saveMesh);
mesh2.name = "yyy";
AssetDatabase.AddObjectToAsset(mesh2, savePath);
mf.sharedMesh = mesh2;
// Save
AssetDatabase.SaveAssets();
// Mesh tempMesh = (Mesh)UnityEngine.Object.Instantiate(originalMesh);
// Get asset
// Reference to asset
}
private void VoxelizeSprite()
{
Texture2D readableTexture = _sprite.isReadable ? _sprite : ReadTexture(_sprite);
///////////////////// Mesh Benchmark
var timer = Stopwatch.StartNew();
Mesh mesh = VoxelUtil.VoxelizeTexture2D(readableTexture, _applyColorPerVertex, _scale);
timer.Stop();
string meshName = _sprite.name + VOXEL_NAME_POST_FIX;
mesh.name = meshName;
Debug.Log(string.Format("[Voxelizer] {0}: Mesh created after {1} milliseconds", mesh.name, timer.ElapsedMilliseconds));
///////////////////////
///////////////////// Texture Benchmark
timer = Stopwatch.StartNew();
Texture2D texture = VoxelUtil.GenerateTextureMap(ref mesh, readableTexture);
timer.Stop();
Debug.Log(string.Format("[Voxelizer] {0}: Texture created after {1} milliseconds", mesh.name, timer.ElapsedMilliseconds));
///////////////////////
if (_useMeshOptimizer)
{
MeshUtility.Optimize(mesh);
}
if (_createNewGameObject)
{
CreateVoxelGameObject(mesh, texture);
}
if (_saveMesh)
{
SaveMeshToFile(mesh);
}
if (_saveTexture)
{
SaveTextureToFile(texture);
}
}
private Mesh DrawLineMesh(List <Vector3> points)
{
Mesh m = new Mesh();
m.Clear();
Vector3[] verticies = new Vector3[points.Count];
for (int i = 0; i < verticies.Length; i++)
{
verticies[i] = points[i];
}
int[] triangles = new int[((points.Count / 2) - 1) * 6];
//Works on linear patterns tn = bn+c
int position = 6;
for (int i = 0; i < (triangles.Length / 6); i++)
{
Debug.Log("Triangles are: " + i);
triangles[i * position] = 2 * i;
triangles[i * position + 3] = 2 * i;
triangles[i * position + 1] = 2 * i + 3;
triangles[i * position + 4] = (2 * i + 3) - 1;
triangles[i * position + 2] = 2 * i + 1;
triangles[i * position + 5] = (2 * i + 1) + 2;
}
m.vertices = verticies;
m.triangles = triangles;
// For Android Build
Unwrapping.GenerateSecondaryUVSet(m);
m.RecalculateNormals();
m.RecalculateBounds();
// For Android Build
MeshUtility.Optimize(m);
Debug.Log("Triangles are: " + triangles.ToString());
return(m);
}
private static void ExportLowLOD(BuildrData data)
{
DynamicMeshGenericMultiMaterialMesh dynLODMesh = new DynamicMeshGenericMultiMaterialMesh();
dynLODMesh.subMeshCount = data.textures.Count;
BuildrBuildingLowDetail2.Build(dynLODMesh, data);
dynLODMesh.CollapseSubmeshes();
EditorUtility.DisplayCancelableProgressBar(PROGRESSBAR_TEXT, "", 0.80f);
dynLODMesh.Build(data.includeTangents);
Mesh LODMesh = dynLODMesh[0].mesh;//TODO: support many meshes
MeshUtility.Optimize(LODMesh);
EditorUtility.DisplayCancelableProgressBar(PROGRESSBAR_TEXT, "", 0.90f);
string textureName = data.exportFilename + ATLASED_SUFFIX + LOD_SUFFIX;
string textureFileName = textureName + ".png";
string newDirectory = ROOT_FOLDER + data.exportFilename;
File.WriteAllBytes(newDirectory + "/" + textureFileName, data.LODTextureAtlas.EncodeToPNG());
ExportMaterial[] exportTextures = new ExportMaterial[1];
ExportMaterial newTexture = new ExportMaterial();
newTexture.name = textureName;
newTexture.filepath = textureFileName;
newTexture.generated = true;
exportTextures[0] = newTexture;
string LODFileName = data.exportFilename + LOD_SUFFIX;
string LODFolder = ROOT_FOLDER + data.exportFilename + "/";
Export(LODFileName, LODFolder, data, LODMesh, exportTextures);
if (data.placeIntoScene)
{
AssetDatabase.Refresh();//ensure the database is up to date...
string filePath = LODFolder + LODFileName + FILE_EXTENTION;
GameObject newModel = (GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadMainAssetAtPath(filePath));
newModel.transform.position = CURRENT_TRANSFORM.position;
newModel.transform.rotation = CURRENT_TRANSFORM.rotation;
}
Texture2D.DestroyImmediate(data.textureAtlas);
Texture2D.DestroyImmediate(data.LODTextureAtlas);
}
public Mesh CreateMesh(int elevation)
{
Mesh m = new Mesh();
m.Clear();
m.vertices = triangulator.get3dVertices(elevation);
triangulator.setAllPoints(triangulator.get2dVertices());
m.triangles = triangulator.get3DTriangulesFrom2D();
Unwrapping.GenerateSecondaryUVSet(m);
m.RecalculateNormals();
m.RecalculateBounds();
MeshUtility.Optimize(m);
//Debug.Log("After -> " + m.uv.Length);
return(m);
}
public static void SaveMesh(Mesh mesh, string name)
{
string path = EditorUtility.SaveFilePanel("Save Mesh Asset", "Assets/", name, "asset");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
Mesh meshToSave = Instantiate(mesh) as Mesh;
MeshUtility.Optimize(meshToSave);
AssetDatabase.CreateAsset(meshToSave, path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static void SaveMesh(UnityEngine.Mesh mesh, GameObject obj, string name)
{
// string path = EditorUtility.SaveFilePanel("Save Separate Mesh Asset", "Assets/", name, "asset");
// if (string.IsNullOrEmpty(path)) return;
// path = FileUtil.GetProjectRelativePath(path);
MeshUtility.Optimize(mesh);
string fileLocation = "Assets/cache/meshes/" + name + ".prefab";
AssetDatabase.CreateAsset(mesh, fileLocation);
AssetDatabase.SaveAssets();
string fileName = name;
fileLocation = "Assets/cache/" + fileName + ".prefab";
var emptyObj = PrefabUtility.CreateEmptyPrefab(fileLocation);
PrefabUtility.ReplacePrefab(obj, emptyObj, ReplacePrefabOptions.ConnectToPrefab);
}
public static void CreateMeshAsset(MenuCommand command)
{
MeshFilter mf = command.context as MeshFilter;
Mesh m = mf.sharedMesh;
MeshUtility.Optimize(m);
string path = EditorUtility.SaveFilePanel("Create New Mesh Asset...", "Assets/Meshes", mf.gameObject.name, "asset");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
AssetDatabase.CreateAsset(m, path);
AssetDatabase.SaveAssets();
Debug.Log("Saved mesh " + mf.gameObject.name + " to " + path);
}
private static void ExportCollider(TrackBuildR data)
{
DynamicMesh COL_MESH = new DynamicMesh();
// COL_MESH.subMeshCount = data.textures.Count;
// BuildrBuildingCollider.Build(COL_MESH, data);
// COL_MESH.CollapseSubmeshes();
COL_MESH.Build();
ExportMaterial[] exportTextures = new ExportMaterial[1];
ExportMaterial newTexture = new ExportMaterial();
newTexture.name = "blank";
newTexture.filepath = "";
newTexture.generated = true;
exportTextures[0] = newTexture;
int numberOfColliderMeshes = COL_MESH.meshCount;
Mesh[] meshes = COL_MESH.meshes;
for (int i = 0; i < numberOfColliderMeshes; i++)
{
MeshUtility.Optimize(meshes[i]);
string ColliderSuffixIndex = ((numberOfColliderMeshes > 1) ? "_" + i : "");
string ColliderFileName = data.exportFilename + COLLIDER_SUFFIX + ColliderSuffixIndex;
string ColliderFolder = ROOT_FOLDER + data.exportFilename + "/";
Export(ColliderFileName, ColliderFolder, data, meshes[i], exportTextures);
}
//string newDirectory = rootFolder+track.exportFilename;
//if(!CreateFolder(newDirectory))
// return;
// ExportMaterial[] exportTextures = new ExportMaterial[1];
// ExportMaterial newTexture = new ExportMaterial();
// newTexture.customName = "";
// newTexture.filepath = "";
// newTexture.generated = true;
// exportTextures[0] = newTexture;
// Export(track.exportFilename + COLLIDER_SUFFIX, ROOT_FOLDER + track.exportFilename + "/", track, EXPORT_MESH, exportTextures);
//
// COL_MESH = null;
// EXPORT_MESH = null;
}
/// <summary>
/// 提取动画MESH
/// </summary>
/// <param name="respath"></param>
/// <param name="saveDir"></param>
static void ExtractAnimMesh(string respath, string saveDir = null)
{
respath = GetUnityAssetPath(respath);
if (!string.IsNullOrEmpty(respath) && respath.ToLower().EndsWith(".fbx"))
{
GameObject target = AssetDatabase.LoadAssetAtPath <GameObject>(respath);
if (target != null)
{
string dir = saveDir == null?Path.GetDirectoryName(respath) : GetUnityAssetPath(saveDir);
string filename = Path.GetFileNameWithoutExtension(respath);
GameObject instance = GameObject.Instantiate <GameObject>(target);
MeshFilter[] meshes = instance.GetComponentsInChildren <MeshFilter>(true);
for (int i = 0; i < meshes.Length; i++)
{
Mesh oldmesh = meshes[i].sharedMesh;
Mesh newmesh = new Mesh();
newmesh.vertices = oldmesh.vertices;
newmesh.normals = oldmesh.normals;
newmesh.triangles = oldmesh.triangles;
newmesh.tangents = oldmesh.tangents;
newmesh.colors = oldmesh.colors;
newmesh.uv = oldmesh.uv;
newmesh.uv2 = oldmesh.uv2;
newmesh.uv3 = oldmesh.uv3;
newmesh.uv4 = oldmesh.uv4;
newmesh.uv5 = oldmesh.uv5;
newmesh.uv6 = oldmesh.uv6;
newmesh.uv7 = oldmesh.uv7;
newmesh.uv8 = oldmesh.uv8;
MeshUtility.Optimize(newmesh);
MeshUtility.SetMeshCompression(newmesh, ModelImporterMeshCompression.High);
meshes[i].sharedMesh = newmesh;
AssetDatabase.CreateAsset(newmesh, dir + "/" + filename + "_mesh_" + i + ".asset");
}
PrefabUtility.SaveAsPrefabAsset(instance, dir + "/" + filename + ".prefab");
GameObject.DestroyImmediate(instance);
}
}
AssetDatabase.Refresh();
}
public static void SaveMeshOBJ(Mesh m, string name, bool optimize)
{
string path = EditorUtility.SaveFilePanel("Save Mesh OBJ", "Assets/", name, "obj");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
Mesh meshToSave = Object.Instantiate(m) as Mesh;
if (optimize)
{
MeshUtility.Optimize(meshToSave);
}
FileStream fParameter = new FileStream(path, FileMode.Create, FileAccess.Write);
StreamWriter m_WriterParameter = new StreamWriter(fParameter);
m_WriterParameter.BaseStream.Seek(0, SeekOrigin.End);
m_WriterParameter.Write("o " + name + "\n");
m_WriterParameter.Write("g " + name + "\n");
//vn -0.0000 -0.0000 -1.0000
foreach (var v in meshToSave.vertices)
{
m_WriterParameter.Write("v " + -((float)v.x) + " " + ((float)v.y) + " " + ((float)v.z) + "\n");
}
m_WriterParameter.Write("vn 0 0 1\n");
m_WriterParameter.Write("usemtl None\n");
m_WriterParameter.Write("s off\n");
for (int i = 0; i < meshToSave.triangles.Length; i += 3)
{
//m_WriterParameter.Write("f " + (meshToSave.triangles[i]+1) + "//1 " + (meshToSave.triangles[i+1]+1) + "//1 " + (meshToSave.triangles[i+2]+1) + "//1" + "\n");
m_WriterParameter.Write("f " + (meshToSave.triangles[i + 2] + 1) + "//1 " + (meshToSave.triangles[i + 1] + 1) + "//1 " + (meshToSave.triangles[i] + 1) + "//1" + "\n");
}
m_WriterParameter.Flush();
m_WriterParameter.Close();
}
public static void SaveMesh(this Mesh mesh, string path, bool optimizeMesh = true, bool autoSave = true)
{
#if UNITY_EDITOR
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
if (optimizeMesh)
{
MeshUtility.Optimize(mesh);
}
AssetDatabase.CreateAsset(mesh, path);
if (autoSave)
{
AssetDatabase.SaveAssets();
}
#endif
}
// Use this for initialization
public Mesh ImportFile(string filePath)
{
meshStruct newMesh = createMeshStruct(filePath);
populateMeshStruct(ref newMesh);
Vector3[] newVerts = new Vector3[newMesh.faceData.Length];
Vector2[] newUVs = new Vector2[newMesh.faceData.Length];
Vector3[] newNormals = new Vector3[newMesh.faceData.Length];
int i = 0;
/* The following foreach loops through the facedata and assigns the appropriate vertex, uv, or normal
* for the appropriate Unity mesh array.
*/
foreach (Vector3 v in newMesh.faceData)
{
newVerts[i] = newMesh.vertices[(int)v.x - 1];
if (v.y >= 1)
{
newUVs[i] = newMesh.uv[(int)v.y - 1];
}
if (v.z >= 1)
{
newNormals[i] = newMesh.normals[(int)v.z - 1];
}
i++;
}
Mesh mesh = new Mesh();
mesh.vertices = newVerts;
mesh.uv = newUVs;
mesh.normals = newNormals;
mesh.triangles = newMesh.triangles;
mesh.RecalculateBounds();
MeshUtility.Optimize(mesh);
return(mesh);
}
private static void SaveMeshNewInstanceItem(MenuCommand menuCommand)
{
MeshFilter mf = menuCommand.context as MeshFilter;
Mesh m = mf.sharedMesh;
string path = EditorUtility.SaveFilePanel("Save Separate Mesh Asset", "Assets/", m.name, "asset");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
Mesh meshToSave = UnityEngine.Object.Instantiate(m) as Mesh;
MeshUtility.Optimize(meshToSave);
AssetDatabase.CreateAsset(meshToSave, path);
AssetDatabase.SaveAssets();
}
public static void SaveMesh(Mesh mesh, string name, bool makeNewInstance, bool optimizeMesh)
{
string path = EditorUtility.SaveFilePanel("Save Separate Mesh Asset", "Assets/", name, "asset");
if (string.IsNullOrEmpty(path))
{
return;
}
path = FileUtil.GetProjectRelativePath(path);
Mesh meshToSave = (makeNewInstance) ? Object.Instantiate(mesh) as Mesh : mesh;
if (optimizeMesh)
{
MeshUtility.Optimize(meshToSave);
}
AssetDatabase.CreateAsset(meshToSave, path);
AssetDatabase.SaveAssets();
}
public static void TransformAllMesh()
{
MeshFilter[] ms = Selection.activeGameObject.GetComponentsInChildren <MeshFilter>();
foreach (MeshFilter m in ms)
{
Mesh meshToSave = BlockMeshes.TranslateMesh(m.sharedMesh, m.transform.localToWorldMatrix);
string path = EditorUtility.SaveFilePanel("Save Separate Mesh Asset", "Assets/Meshes/", meshToSave.name, "asset");
if (string.IsNullOrEmpty(path))
{
continue;
}
path = FileUtil.GetProjectRelativePath(path);
MeshUtility.Optimize(meshToSave);
AssetDatabase.CreateAsset(meshToSave, path);
AssetDatabase.SaveAssets();
}
}
// copy a mesh, and bake it's vertex stream into the mesh data.
public static Mesh BakeDownMesh(Mesh mesh, VertexInstanceStream stream)
{
var copy = GameObject.Instantiate(mesh);
copy.colors = stream.colors;
if (stream.uv0 != null && stream.uv0.Count > 0)
{
copy.SetUVs(0, stream.uv0);
}
if (stream.uv1 != null && stream.uv1.Count > 0)
{
copy.SetUVs(1, stream.uv1);
}
if (stream.uv2 != null && stream.uv2.Count > 0)
{
copy.SetUVs(2, stream.uv2);
}
if (stream.uv3 != null && stream.uv3.Count > 0)
{
copy.SetUVs(3, stream.uv3);
}
if (stream.positions != null && stream.positions.Length == copy.vertexCount)
{
copy.vertices = stream.positions;
}
if (stream.normals != null && stream.normals.Length == copy.vertexCount)
{
copy.normals = stream.normals;
}
if (stream.tangents != null && stream.tangents.Length == copy.vertexCount)
{
copy.tangents = stream.tangents;
}
MeshUtility.Optimize(copy);
copy.RecalculateBounds();
copy.UploadMeshData(false);
return(copy);
}
public void OptimseMeshes()
{
#if UNITY_EDITOR
for (int i = 0; i < numberOfCurves; i++)
{
TrackBuildRPoint curve = _points[i];
Mesh[] meshes = curve.dynamicTrackMesh.meshes;
for (int m = 0; m < curve.dynamicTrackMesh.meshCount; m++)
{
MeshUtility.Optimize(meshes[m]);
}
meshes = curve.dynamicOffroadMesh.meshes;
for (int m = 0; m < curve.dynamicOffroadMesh.meshCount; m++)
{
MeshUtility.Optimize(meshes[m]);
}
meshes = curve.dynamicBumperMesh.meshes;
for (int m = 0; m < curve.dynamicBumperMesh.meshCount; m++)
{
MeshUtility.Optimize(meshes[m]);
}
meshes = curve.dynamicBoundaryMesh.meshes;
for (int m = 0; m < curve.dynamicBoundaryMesh.meshCount; m++)
{
MeshUtility.Optimize(meshes[m]);
}
meshes = curve.dynamicBottomMesh.meshes;
for (int m = 0; m < curve.dynamicBottomMesh.meshCount; m++)
{
MeshUtility.Optimize(meshes[m]);
}
}
_optimised = true;
#endif
}
public void Save()
{
Transform[] ts = transform.GetComponentsInChildren <Transform>();
foreach (var item in ts)
{
if (item.name.Contains("Combined")) //按名字匹配对应的Mesh
{
MeshFilter mesh = item.GetComponent <MeshFilter>();
if (mesh != null)
{
Mesh m = mesh.sharedMesh;
Mesh meshToSave = Object.Instantiate(m);
MeshUtility.Optimize(meshToSave);
AssetDatabase.CreateAsset(meshToSave, "Assets/Mesh/" + item.name + ".asset");
AssetDatabase.SaveAssets();
Debug.Log("Assets/Mesh" + item.name + ".asset");
}
}
}
}
Mesh CreateMesh()
{
Mesh mesh = new Mesh();
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
Vector3[] verticies = new Vector3[4 * mapSize * mapSize];
Vector2[] uv = new Vector2[4 * mapSize * mapSize];
List <int> triangles = new List <int>();
for (int i = 0; i < mapSize * mapSize; i++)
{
GenerateMeshData(i, cells[i].dungeonCellType, verticies, uv, triangles);
}
mesh.vertices = verticies;
mesh.uv = uv;
mesh.triangles = triangles.ToArray();
MeshUtility.Optimize(mesh);
return(mesh);
}
/// <summary>
/// Create a new GameObject based on the CombineInstance list
/// </summary>
/// <param name="instances"></param>
/// <param name="parent"></param>
/// <param name="number"></param>
/// <returns></returns>
private GameObject CreateCombinedSkinnedMeshGameObject(CombineInstanceID instances, Transform parent, int number, int combinedIndex)
{
GameObject combined = new GameObject(_sessionName + number.ToString());
SkinnedMeshRenderer skinnedMeshRenderer = combined.AddComponent <SkinnedMeshRenderer>();
skinnedMeshRenderer.sharedMaterial = _combinedResult._combinedMaterials[combinedIndex].material;
skinnedMeshRenderer.sharedMesh = new Mesh();
skinnedMeshRenderer.sharedMesh.name = _sessionName + "_" + _combinedResult._combinedMaterials[combinedIndex].displayedIndex + "_mesh" + number;
skinnedMeshRenderer.sharedMesh.CombineMeshes(instances._combineInstances.ToArray(), true, true);
#if UNITY_5_3_OR_NEWER
// Add blendShapes to new skinnedMesh renderer if needed
foreach (BlendShapeFrame blendShape in blendShapes.Values)
{
Vector3[] detlaVertices = new Vector3[skinnedMeshRenderer.sharedMesh.vertexCount];
Vector3[] detlaNormals = new Vector3[skinnedMeshRenderer.sharedMesh.vertexCount];
Vector3[] detlaTangents = new Vector3[skinnedMeshRenderer.sharedMesh.vertexCount];
for (int p = 0; p < blendShape._deltaVertices.Length; p++)
{
detlaVertices.SetValue(blendShape._deltaVertices[p], p + blendShape._vertexOffset);
detlaNormals.SetValue(blendShape._deltaNormals[p], p + blendShape._vertexOffset);
detlaTangents.SetValue(blendShape._deltaTangents[p], p + blendShape._vertexOffset);
}
skinnedMeshRenderer.sharedMesh.AddBlendShapeFrame(blendShape._shapeName, blendShape._frameWeight, detlaVertices, detlaNormals, detlaTangents);
}
#endif
#if UNITY_EDITOR
MeshUtility.Optimize(skinnedMeshRenderer.sharedMesh);
#endif
combined.transform.SetParent(parent);
combined.transform.localPosition = Vector3.zero;
_combinedResult._totalVertexCount += skinnedMeshRenderer.sharedMesh.vertexCount;
_combinedResult.AddCombinedMesh(skinnedMeshRenderer.sharedMesh, instances, combinedIndex);
return(combined);
}
/// <summary>
/// メッシュを保存するダイアログを表示
/// </summary>
public static void SaveMeshDialog(Mesh mesh, string dialogTitle, string defaultAssetName)
{
var savePath = EditorUtility.SaveFilePanelInProject(
dialogTitle, defaultAssetName, "asset", "Save Mesh");
if (string.IsNullOrEmpty(savePath))
{
return;
}
// clone mesh
mesh = Object.Instantiate(mesh);
MeshUtility.Optimize(mesh);
var oldAsset = AssetDatabase.LoadAssetAtPath(savePath, typeof(Object));
if (oldAsset != null)
{
// copy
EditorUtility.CopySerialized(mesh, oldAsset);
AssetDatabase.SaveAssets();
}
else
{
// create
AssetDatabase.CreateAsset(mesh, savePath);
AssetDatabase.Refresh();
}
var asset = AssetDatabase.LoadAssetAtPath(savePath, typeof(Mesh));
if (asset == null)
{
return;
}
EditorGUIUtility.PingObject(asset);
}
Mesh BuildQuadMesh()
{
vertices2 = new Vector3[10];
uv2 = new Vector2[10];
vertices = new Vector3[10] {
new Vector3(0, 0, 0),
new Vector3(0, 0, 0.5f), new Vector3(0.5f, 0, 0.5f), new Vector3(0.5f, 0, 0),
new Vector3(0.5f, 0, -0.5f), new Vector3(0, 0, -0.5f), new Vector3(-0.5f, 0, -0.5f),
new Vector3(-0.5f, 0, 0), new Vector3(-0.5f, 0, 0.5f), new Vector3(0, 0, 0.5f)
};
uv = new Vector2[10] {
new Vector2(0.5f, 0.5f),
new Vector2(0.5f, 1), new Vector2(1, 1), new Vector2(1, 0.5f),
new Vector2(1, 0), new Vector2(0.5f, 0), new Vector2(0, 0),
new Vector2(0, 0.5f), new Vector2(0, 1), new Vector2(0.5f, 1)
};
indices = new int[24] {
0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 8, 0, 8, 9
};
FillQuadData();
Mesh mesh = new Mesh();
mesh.name = "Generated Mesh";
mesh.vertices = vertices2;
mesh.triangles = indices2;
mesh.uv = uv2;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
// mesh.Optimize();
MeshUtility.Optimize(mesh);
return(mesh);
}
/// <summary>
/// Create a new GameObject based on the CombineInstance list.
/// Set its MeshFilter and MeshRenderer to the new combined Meshe/Material
/// </summary>
/// <param name="instances"></param>
/// <param name="parent"></param>
/// <param name="number"></param>
/// <returns></returns>
public GameObject CreateCombinedMeshGameObject(CombineInstanceID instances, Transform parent, int number, int combinedIndex)
{
GameObject combined;
MeshFilter meshFilter;
MeshRenderer meshRenderer;
// If parent has components MeshFilters and MeshRenderers, replace meshes and materials
if (number == 0 && parent.GetComponent <MeshFilter>() != null && parent.GetComponent <MeshRenderer>() != null)
{
combined = parent.gameObject;
meshFilter = parent.GetComponent <MeshFilter>();
meshRenderer = parent.GetComponent <MeshRenderer>();
}
else
{
combined = new GameObject(_sessionName + "_" + _combinedResult._combinedMaterials[combinedIndex].displayedIndex + "_" + number.ToString());
meshFilter = combined.AddComponent <MeshFilter>();
meshRenderer = combined.AddComponent <MeshRenderer>();
combined.transform.SetParent(parent);
combined.transform.localPosition = Vector3.zero;
}
meshRenderer.sharedMaterial = _combinedResult._combinedMaterials[combinedIndex].material;
meshFilter.mesh = new Mesh();
meshFilter.sharedMesh.name = _sessionName + "_" + _combinedResult._combinedMaterials[combinedIndex].displayedIndex + "_mesh" + number;
meshFilter.sharedMesh.CombineMeshes(instances._combineInstances.ToArray());
#if UNITY_EDITOR
MeshUtility.Optimize(meshFilter.sharedMesh);
if (_generateUv2)
{
Unwrapping.GenerateSecondaryUVSet(meshFilter.sharedMesh);
}
#endif
_combinedResult._totalVertexCount += meshFilter.sharedMesh.vertexCount;
_combinedResult.AddCombinedMesh(meshFilter.sharedMesh, instances, combinedIndex);
return(combined);
}
public void Start()
{
var filePath = Application.dataPath + "/voxmap.json";
var voxelmap = new Voxmap(size, size, size);
var loader = new FileLoader(filePath);
// var loader = new PerlinNoise();
loader.Load(voxelmap);
var chunk = new Chunk();
var renderer = new FullRenderer(chunk);
renderer.Render(voxelmap);
Mesh mesh = GetComponent <MeshFilter>().mesh;
mesh.Clear();
mesh.vertices = chunk.vertices.ToArray();
mesh.triangles = chunk.triangles.ToArray();
//mesh.RecalculateNormals();
if (optimize)
{
MeshUtility.Optimize(mesh);
}
}
/**
* Create new GameObject, part of a building
* triangleType = 0 => generate triangles via Triangulator for roofs
* = 1 => generate optimized triangles for walls = only two triangles is enough for 4 wall points
* = 2 => generate triangles for 4 point roofs
*/
private void CreateGameObject(string buildingName, Vector3[] edges, int triangleType)
{
var gameObjectArea = new GameObject(buildingName);
#if UNITY_EDITOR
const StaticEditorFlags flags = StaticEditorFlags.BatchingStatic | StaticEditorFlags.LightmapStatic;
GameObjectUtility.SetStaticEditorFlags(gameObjectArea, flags);
#endif
var meshFilter = (MeshFilter)gameObjectArea.AddComponent(typeof(MeshFilter));
var mesh = meshFilter.mesh;
mesh.Clear();
mesh.vertices = edges;
//fill area with triangles
int[] triangles = triangleType != 0 ? GenerateTrianglesFor4Points() : Triangulator.GenerateTriangleNewVersion(edges.ToList());
mesh.triangles = triangles;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
#if UNITY_EDITOR
MeshUtility.Optimize(mesh);
#endif
ChangeBuildingSurfaceColor(gameObjectArea, ColorUtils.DefaultBuilding);
BatchedBuildings.Add(gameObjectArea);
}
