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); }