public void UpdateMesh() { MeshData data = new MeshData(blocks); if (data._vertices.Count > 0) { if (ChunkMesh != null) { ChunkMesh.Dispose(); } ChunkMesh = new Mesh(data._vertices.ToArray(), data._UVs.ToArray(), data._colors.ToArray(), data._triangles.ToArray()); VoxelMesh mesh = data.MakeWatersMehs(blocks); WaterMesh = new Mesh(mesh.verts, mesh.uvs, mesh.colors, mesh.indices); lock (LockActionUpdateMEsh) { ActionUpdateMesh.Enqueue(() => SMakeMesh()); } } data.Dispose(); }
public void EnableMesh(VoxelMesh m) { if (!m_enabledMeshes.Contains(m)) { m_enabledMeshes.Add(m); } }
public static void SaveVoxelStruct(VoxelMesh vm) { string path = EditorUtility.SaveFilePanel("Save Voxel Mesh Asset", "Assets/MeshStruct/", "", "vxl"); //Homemade extension VoxelFile.Save(vm.Mesh, path); }
public void StartUp(VoxelMap map) { voxelMap = map; mainCamera = Camera.main; terrainMap = FindObjectOfType <TerrainMap>(); voxelMesh = FindObjectOfType <VoxelMesh>(); chunkCollider = FindObjectOfType <ChunkCollider>(); worldManager = FindObjectOfType <WorldManager>(); uiHotBar = FindObjectOfType <UI_HotBar>(); var blockCollection = BlockManager.Read(); if (worldManager.creativeMode) { foreach (var block in blockCollection.blocks) { fillTypeNames.Add(block.blockType.ToString()); } } boxCollider = gameObject.GetComponent <BoxCollider>(); if (boxCollider != null) { DestroyImmediate(boxCollider); } boxCollider = gameObject.AddComponent <BoxCollider>(); boxCollider.size = new Vector3((voxelMap.chunkResolution - voxelMap.viewDistance) * voxelMap.voxelResolution, (voxelMap.chunkResolution - voxelMap.viewDistance) * voxelMap.voxelResolution); }
public void Startup(VoxelMap map) { var blockTypeNames = System.Enum.GetNames(typeof(BlockType)); foreach (var blockType in blockTypeNames) { FillTypeNames.Add(blockType); } voxelResolution = map.voxelResolution; chunkResolution = map.chunkResolution; viewDistance = map.viewDistance; existingChunks = map.existingChunks; voxelMap = map; mainCamera = Camera.main; terrainMap = FindObjectOfType <TerrainMap>(); voxelMesh = FindObjectOfType <VoxelMesh>(); chunkCollider = FindObjectOfType <ChunkCollider>(); box = gameObject.GetComponent <BoxCollider>(); if (box != null) { DestroyImmediate(box); } box = gameObject.AddComponent <BoxCollider>(); box.center = Vector3.one * (voxelResolution / 2f); box.size = new Vector3((chunkResolution - viewDistance) * voxelResolution, (chunkResolution - viewDistance) * voxelResolution); }
public void emission(VoxelMesh mesh, int count = 80, GDGeek.Tween.Method method = GDGeek.Tween.Method.easeOutQuad) { for (int i = 0; i < count; ++i) { GameObject obj = _pool.create(); Voxel voxel = obj.GetComponent <Voxel>(); obj.SetActive(true); VoxelProperty begin = new VoxelProperty(); begin.color = RandomColor(mesh); begin.position = RandomPosition(mesh); begin.scale = Vector3.one * 2.0f; VoxelProperty end = new VoxelProperty(); end.color = begin.color; end.position = begin.position + Random.insideUnitSphere * 100.0f; end.scale = Vector3.one * 4.0f; voxel.property = begin; Tween tween = TweenVoxel.Begin(obj, Random.Range(0.5f, 0.9f), end); tween.method = method; tween.onFinished = delegate { obj.SetActive(false); }; } }
private void CreateVoxelizedMesh() { selectedObject = (Selection.activeObject != null) ? (GameObject)Selection.activeObject : null; Mesh mesh; MeshFilter meshFilter = selectedObject.GetComponent <MeshFilter>(); if (meshFilter != null) { mesh = meshFilter.sharedMesh; } else { mesh = selectedObject.GetComponent <SkinnedMeshRenderer>().sharedMesh; } List <Voxel_t> voxels; CPUVoxelizer.Voxelize( mesh, // a target mesh resolution, // # of voxels for largest AABB bounds out voxels, out float unit ); // build voxel cubes integrated mesh GameObject parent = new GameObject("Voxelized"); parent.AddComponent <MeshRenderer>(); parent.GetComponent <MeshFilter>().sharedMesh = VoxelMesh.Build(voxels.ToArray(), unit, useUv); }
public static Color RandomColor(VoxelMesh mesh) { VoxelData data = mesh.vs.datas[Random.Range(0, mesh.vs.datas.Count)]; return(data.color); //return Color.white; }
private void CreateVoxelizedMultibody() { selectedObject = (Selection.activeObject != null) ? (GameObject)Selection.activeObject : null; Mesh mesh; MeshFilter meshFilter = selectedObject.GetComponent <MeshFilter>(); if (meshFilter != null) { mesh = meshFilter.sharedMesh; } else { mesh = selectedObject.GetComponent <SkinnedMeshRenderer>().sharedMesh; } List <Voxel_t> voxels; CPUVoxelizer.Voxelize( mesh, // a target mesh resolution, // # of voxels for largest AABB bounds out voxels, out float unit ); // build gameobject with individual, colliding voxel cube objects Material material = selectedObject.GetComponent <MeshRenderer>().sharedMaterial; GameObject go = VoxelMesh.BuildObject(voxels.ToArray(), unit, material, folderName, useUv); go.GetComponent <MeshRenderer>().material = material; }
public void setupVoxelize() { cleanUpVoxel(); treeObject.SetActive(false); voxelTree = new GameObject(); voxelTree.name = "Voxel Tree"; voxelTree.transform.position = SCData.rootPos * SCData.scaleFactor; voxelTree.transform.localScale = SCData.scaleFactor * Vector3.one; MeshRenderer renderer = voxelTree.AddComponent <MeshRenderer>(); renderer.material = new Material(Shader.Find("Standard")); renderer.material.color = SCData.branchColor; MeshFilter filter = voxelTree.AddComponent <MeshFilter>(); filter.mesh = new Mesh(); var data = GPUVoxelizer.Voxelize( voxelizer, treeObject.GetComponent <MeshFilter>().mesh, SCData.resolution, true); filter.sharedMesh = VoxelMesh.Build(data.GetData(), data.UnitLength, false); data.Dispose(); }
public void StartUp(VoxelMap map, WorldScriptableObject worldObject) { voxelMesh = FindObjectOfType <VoxelMesh>(); terrainNoise = FindObjectOfType <TerrainNoise>(); terrainMap = FindObjectOfType <TerrainMap>(); chunkCollider = FindObjectOfType <ChunkCollider>(); recycleableChunks = map.recycleableChunks; regionResolution = map.regionResolution; chunkResolution = map.chunkResolution; voxelResolution = map.voxelResolution; viewDistance = map.viewDistance; chunks = map.chunks; existingChunks = map.existingChunks; useVoxelReferences = map.useVoxelReferences; colliderRadius = map.colliderRadius; useColliders = map.useColliders; player = map.player; chunkSaveLoadManager = map.chunkSaveLoadManager; worldScriptableObject = worldObject; playerRb = player.GetComponent <Rigidbody2D>(); terrainNoise.seed = worldScriptableObject.seed; terrainNoise.Startup(voxelResolution, chunkResolution); voxelMesh.Startup(voxelResolution, chunkResolution, viewDistance, useColliders, colliderRadius); InvokeRepeating(nameof(UpdateMap), 0.0f, terrainMap.updateInterval); }
void Start() { var data = GPUVoxelizer.Voxelize(voxelizer, mesh, resolution, (type == MeshType.Volume)); GetComponent <MeshFilter>().sharedMesh = VoxelMesh.Build(data.GetData(), data.UnitLength, useUV); data.Dispose(); }
private IEnumerator BuildMesh() { Stopwatch timer = new Stopwatch(); timer.Start(); Stopwatch yieldTimer = new Stopwatch(); yieldTimer.Start(); Debug.Log("Building Mesh..."); // Work our which faces we need. We do this by checking to see if a two voxels share and adjacent // side. ProgressMonitor.Begin("Building Mesh", VoxelMap.Size); VoxelMesh voxelMesh = new VoxelMesh(); voxelMaterials = new Dictionary <int, Material>(); foreach (var voxel in VoxelMap) { ProgressMonitor.Worked(1); if (NeedsYield(yieldTimer)) { yield return(null); } if (voxel.Value == 0) { continue; } Material material = GetMaterial(voxel.Value); foreach (FaceDirection dir in directions) { if (GetAdjacentVoxel(VoxelMap, voxel.Key, dir) == 0) { // Add the face VoxelFace face = new VoxelFace(voxel.Key, dir, halfScale); voxelMesh.Add(face, material); } // else don't need a face here } } // Update and parent the meshes voxelMesh.Update(); foreach (var meshGO in voxelMesh.GetGameObjects()) { meshGO.transform.parent = gameObject.transform; meshGO.transform.localPosition = VoxelMap.Offset; // Not sure this is right...should it be scaled? meshGO.transform.localRotation = Quaternion.identity; } // We're done! ProgressMonitor.Finished(); VoxelMesh = voxelMesh; Debug.Log($"Completed in {timer.ElapsedMilliseconds / 1000.0f:F2}s"); }
void UpdateVisualChunk(VoxelMesh vm) { if (vm != null && vm.needsRegen) { vm.RegenerateVisualMesh(voxelScale); --m_needsRegenCount; } }
private void CreatePreview() { GPUVoxelData data = GPUVoxelizer.Voxelize(shader, selectedMesh, resolution, false, false); previewMesh = VoxelMesh.Build(data.GetData(), data.UnitLength, true); selectedVoxelInfo = BuildVoxInfo(data.GetData(), data.UnitLength); CreatePreviewPalette(); }
public void DrawMesh(VoxelMesh voxelMesh, Vector3 position, Layer layer) { foreach (Voxel voxel in voxelMesh.voxels) { Vector3 v3 = voxel.position - new Vector3(voxelMesh.width / 2, voxelMesh.height / 2, voxelMesh.depth / 2); SetVoxel(v3 + position, voxel.color, layer); } }
Mesh Voxelize(Mesh source) { List <Voxel_t> voxels; float size; CPUVoxelizer.Voxelize(source, resolution, out voxels, out size, surfaceOnly); return(VoxelMesh.Build(voxels.ToArray(), size)); }
public static Vector3 RandomPosition(VoxelMesh mesh) { var box = mesh.collider; return(box.bounds.center + new Vector3(Random.Range(-box.bounds.size.x / 2, box.bounds.size.x / 2), Random.Range(-box.bounds.size.y / 2, box.bounds.size.y / 2), Random.Range(-box.bounds.size.z / 2, box.bounds.size.z / 2))); }
void MarkChunkForRegen(VoxelMesh vm) { if (vm != null && !vm.needsRegen) { vm.needsRegen = true; ++m_needsRegenCount; } }
// Use this for initialization. void Start() { //Creat new VoxelRender with 192x192x64 resolution. voxelRender = new VoxelRender(192, 192, 64); //Load voxel mesh from file. voxelMesh = new VoxelMesh("Knight"); //Load palette from mesh to VoxelRender. voxelRender.LoadPaletteFromMesh(voxelMesh); }
public VoxelMesh MakeWaterMesh(Block[,] tile) { Vector3[] vertices; List <Vector2> uvs = new List <Vector2>(); int[] triangles; List <Color4> colors = new List <Color4>(); VoxelMesh mesh = new VoxelMesh(); int widh = MidleWorld.ChunkSize + 1; vertices = new Vector3[widh * widh]; for (int y = 0; y < widh; y++) { for (int x = 0; x < widh; x++) { vertices[x + y * widh] = new Vector3(x, 0.0f, y); colors.Add(new Color4(1, 1, 1, 1)); uvs.AddRange(AssetsManager.GetTileUV("Water")); } } triangles = new int[3 * 2 * (widh * widh - widh - widh + 1)]; int triangleVertexCount = 0; for (int vertex = 0; vertex < widh * widh - widh; vertex++) { if (vertex % widh != (widh - 1)) { // First triangle int A = vertex; int B = A + widh; int C = B + 1; triangles[triangleVertexCount] = A; triangles[triangleVertexCount + 1] = B; triangles[triangleVertexCount + 2] = C; //Second triangle B += 1; C = A + 1; triangles[triangleVertexCount + 3] = A; triangles[triangleVertexCount + 4] = B; triangles[triangleVertexCount + 5] = C; triangleVertexCount += 6; } } mesh.verts = vertices; mesh.uvs = uvs.ToArray(); mesh.indices = triangles; mesh.colors = colors.ToArray(); return(mesh); }
/// <summary> /// Copy constructor /// Initializes a new instance of the <see cref="VoxelMesh"/> struct. /// </summary> /// <param name="mesh">Mesh.</param> public VoxelMesh(VoxelMesh mesh) { size = new Vector3Int(mesh.size.x, mesh.size.y, mesh.size.z); scale = mesh.scale; data = new int[size.x * size.y * size.z]; for (int i = 0; i < data.Length; i++) { this.data [i] = data [i]; } }
void Start() { var filter = GetComponent <MeshFilter>(); var data = GPUVoxelizer.Voxelize(voxelizer, source, resolution); var voxels = data.GetData(); filter.sharedMesh = VoxelMesh.Build(voxels, data.UnitLength); data.Dispose(); }
public void Build() { mesh = new VoxelMesh(generator.GetVoxels()); mesh.Transform = this.Transform; mesh.Build(); Renderer renderer = (Renderer)AddComponent <Renderer>(ComponentType.Renderer); renderer.mesh = mesh; }
private NavmeshTile CreateTile(Voxelize vox, VoxelMesh mesh, int x, int z, int threadIndex) { if (mesh.tris == null) { throw new ArgumentNullException("mesh.tris"); } if (mesh.verts == null) { throw new ArgumentNullException("mesh.verts"); } if (mesh.tris.Length % 3 != 0) { throw new ArgumentException("Indices array's length must be a multiple of 3 (mesh.tris)"); } if (mesh.verts.Length >= 4095) { if (this.tileXCount * this.tileZCount == 1) { throw new ArgumentException("Too many vertices per tile (more than " + 4095 + ").\n<b>Try enabling tiling in the recast graph settings.</b>\n"); } throw new ArgumentException("Too many vertices per tile (more than " + 4095 + ").\n<b>Try reducing tile size or enabling ASTAR_RECAST_LARGER_TILES under the 'Optimizations' tab in the A* Inspector</b>"); } else { NavmeshTile navmeshTile = new NavmeshTile { x = x, z = z, w = 1, d = 1, tris = mesh.tris, bbTree = new BBTree() }; navmeshTile.vertsInGraphSpace = Utility.RemoveDuplicateVertices(mesh.verts, navmeshTile.tris); navmeshTile.verts = (Int3[])navmeshTile.vertsInGraphSpace.Clone(); this.transform.Transform(navmeshTile.verts); uint num = (uint)(this.active.data.graphs.Length + threadIndex); if (num > 255u) { throw new Exception("Graph limit reached. Multithreaded recast calculations cannot be done because a few scratch graph indices are required."); } int num2 = x + z * this.tileXCount; num2 <<= 12; TriangleMeshNode.SetNavmeshHolder((int)num, navmeshTile); object active = this.active; lock (active) { navmeshTile.nodes = base.CreateNodes(navmeshTile.tris, num2, num); } navmeshTile.bbTree.RebuildFrom(navmeshTile.nodes); NavmeshBase.CreateNodeConnections(navmeshTile.nodes); TriangleMeshNode.SetNavmeshHolder((int)num, null); return(navmeshTile); } }
void OnGUI() { if (Selection.activeGameObject != null && voxelMesh == null) { voxelMesh = Selection.activeGameObject.GetComponent <VoxelMesh>(); tool.SetVoxelMesh(voxelMesh); } if (voxelMesh != null) { GUILayout.Label(voxelMesh.gameObject.name); EditorGUILayout.BeginHorizontal(); GUILayout.Label(mode.ToString()); EditorGUI.BeginDisabledGroup(mode == Tool.ToolMode.Add); if (GUILayout.Button("Add")) { mode = Tool.ToolMode.Add; } EditorGUI.EndDisabledGroup(); EditorGUI.BeginDisabledGroup(mode == Tool.ToolMode.Sub); if (GUILayout.Button("Sub")) { mode = Tool.ToolMode.Sub; } EditorGUI.EndDisabledGroup(); EditorGUI.BeginDisabledGroup(mode == Tool.ToolMode.Paint); if (GUILayout.Button("Paint")) { mode = Tool.ToolMode.Paint; } EditorGUI.EndDisabledGroup(); EditorGUILayout.EndHorizontal(); GUIToolSelection(); GUIColorPalette(); GUIExport(); } else { GUILayout.Label("No VoxelMesh Selected"); } //Debug.Log("Fonction"); }
void Start() { List <Voxel_t> voxels; float unit; CPUVoxelizer.Voxelize(mesh, resolution, out voxels, out unit); var filter = GetComponent <MeshFilter>(); filter.sharedMesh = VoxelMesh.Build(voxels.ToArray(), unit, useUV); }
public override void CreateOrUpdateMesh(BufferUsageHint bufferUsage) { if (Mesh == null) { Mesh = new VoxelMesh(bufferUsage, backMeshBuilder); } else { Mesh.Update(backMeshBuilder); } }
public static Color RandomColor(VoxelMesh mesh) { //Debug.Log (mesh); //Debug.Log ( mesh.vs); //Debug.Log (mesh.vs.datas); //mesh.filter.get //VoxelData data = mesh.vs.datas[ Random.Range (0, mesh.vs.datas.Count)]; //return data.color; //Debug.Log(mesh.filter.mesh.colors[ Random.Range (0, mesh.filter.mesh.colors.Length)]); return(mesh.filter.mesh.colors[Random.Range(0, mesh.filter.mesh.colors.Length)]); }
public VoxelMesh MakeWatersMehs(Block[,] tile) { _vertices = new List <Vector3>(); _UVs = new List <Vector2>(); _triangles = new List <int>(); _colors = new List <Color4>(); VoxelMesh mesh = new VoxelMesh(); int verticesNum = 0; for (int x = 0; x < MidleWorld.ChunkSize; x++) { for (int z = 0; z < MidleWorld.ChunkSize; z++) { if (tile[x, z].Type == TypeBlock.Sand) { _vertices.Add(new Vector3(x, -1f, z)); _vertices.Add(new Vector3(x + 1, -1, z)); _vertices.Add(new Vector3(x, -1, z + 1)); _vertices.Add(new Vector3(x + 1, -1, z + 1)); _triangles.Add(0 + verticesNum); _triangles.Add(1 + verticesNum); _triangles.Add(2 + verticesNum); _triangles.Add(2 + verticesNum); _triangles.Add(1 + verticesNum); _triangles.Add(3 + verticesNum); verticesNum += 4; _colors.Add(new Color4(1, 1, 1, 1)); _colors.Add(new Color4(1, 1, 1, 1)); _colors.Add(new Color4(1, 1, 1, 1)); _colors.Add(new Color4(1, 1, 1, 1)); _UVs.AddRange(AssetsManager.GetTileUV("Water")); } } } mesh.verts = _vertices.ToArray(); mesh.uvs = _UVs.ToArray(); mesh.indices = _triangles.ToArray(); mesh.colors = _colors.ToArray(); return(mesh); }
void Start() { VoxelMesh m = new VoxelMesh(3, 3, 3, 1); m.Set(0, 0, 0, 0); m.Set(1, 0, 0, 1); m.Set(2, 0, 0, 2); m.Set(0, 1, 0, 3); m.Set(2, 1, 0, 4); m.Set(0, 0, 1, 5); m.Set(1, 1, 1, 6); m.Set(2, 2, 2, 7); filter = GetComponent <MeshFilter> (); filter.mesh = m.ToMesh(); }
//public Transform _offset = null; public void push(VoxelMesh mesh) { if (mesh_ != null) { GameObject.DestroyImmediate(mesh_.gameObject); } Debug.Log (mesh.max); Debug.Log (mesh.min); mesh_ = mesh; mesh_.gameObject.transform.parent = this.transform; float max = Mathf.Max (mesh.max.x, Mathf.Max (mesh.max.y, mesh.max.z)); mesh_.transform.localScale = Vector3.one / (max+1); mesh_.transform.localPosition = Vector3.zero; mesh_.transform.localRotation = new Quaternion (); BoxCollider box = mesh.gameObject.GetComponent<BoxCollider> (); if (box != null) { box.enabled = false; } }
//Nvp = Maximum allowed vertices per polygon public void BuildPolyMesh (VoxelContourSet cset, int nvp, out VoxelMesh mesh) { nvp = 3; int maxVertices = 0; int maxTris = 0; int maxVertsPerCont = 0; for (int i = 0; i < cset.conts.Length; i++) { // Skip null contours. if (cset.conts[i].nverts < 3) continue; maxVertices += cset.conts[i].nverts; maxTris += cset.conts[i].nverts - 2; maxVertsPerCont = Mathfx.Max (maxVertsPerCont, cset.conts[i].nverts); } if (maxVertices >= 65534) { Debug.LogWarning ("To many vertices for unity to render - Unity might screw up rendering, but hopefully the navmesh will work ok"); //mesh = new VoxelMesh (); //yield break; //return; } //int[] vflags = new int[maxVertices]; Int3[] verts = new Int3[maxVertices]; int[] polys = new int[maxTris*nvp];//@Why *2*2 //int[] regs = new int[maxTris]; //int[] areas = new int[maxTris]; #if ASTAR_MEMCPY Pathfinding.Util.Memory.MemSet<int> (polys, 0xff, sizeof(int)); #else for (int i=0;i<polys.Length;i++) { polys[i] = 0xff; } #endif //int[] nexVert = new int[maxVertices]; //int[] firstVert = new int[VERTEX_BUCKET_COUNT]; int[] indices = new int[maxVertsPerCont]; int[] tris = new int[maxVertsPerCont*3]; //ushort[] polys int vertexIndex = 0; int polyIndex = 0; for (int i=0;i<cset.conts.Length;i++) { VoxelContour cont = cset.conts[i]; //Skip null contours if (cont.nverts < 3) { continue; } for (int j=0; j < cont.nverts;j++) { indices[j] = j; cont.verts[j*4+2] /= voxelArea.width; } //yield return (GameObject.FindObjectOfType (typeof(MonoBehaviour)) as MonoBehaviour).StartCoroutine ( //Triangulate (cont.nverts, cont.verts, indices, tris); int ntris = Triangulate (cont.nverts, cont.verts, ref indices, ref tris); /*if (ntris > cont.nverts-2) { Debug.LogError (ntris + " "+cont.nverts+" "+cont.verts.Length+" "+(cont.nverts-2)); } if (ntris > maxVertsPerCont) { Debug.LogError (ntris*3 + " "+maxVertsPerCont); } int tmp = polyIndex; Debug.Log (maxTris + " "+polyIndex+" "+polys.Length+" "+ntris+" "+(ntris*3) + " " + cont.nverts);*/ int startIndex = vertexIndex; for (int j=0;j<ntris*3; polyIndex++, j++) { //@Error sometimes polys[polyIndex] = tris[j]+startIndex; } /*int tmp2 = polyIndex; if (tmp+ntris*3 != tmp2) { Debug.LogWarning (tmp+" "+(tmp+ntris*3)+" "+tmp2+" "+ntris*3); }*/ for (int j=0;j<cont.nverts; vertexIndex++, j++) { verts[vertexIndex] = new Int3(cont.verts[j*4],cont.verts[j*4+1],cont.verts[j*4+2]); } } mesh = new VoxelMesh (); //yield break; Int3[] trimmedVerts = new Int3[vertexIndex]; for (int i=0;i<vertexIndex;i++) { trimmedVerts[i] = verts[i]; } int[] trimmedTris = new int[polyIndex]; #if ASTAR_MEMCPY System.Buffer.BlockCopy (polys, 0, trimmedTris, 0, polyIndex*sizeof(int)); #else for (int i=0;i<polyIndex;i++) { trimmedTris[i] = polys[i]; } #endif mesh.verts = trimmedVerts; mesh.tris = trimmedTris; /*for (int i=0;i<mesh.tris.Length/3;i++) { int p = i*3; int p1 = mesh.tris[p]; int p2 = mesh.tris[p+1]; int p3 = mesh.tris[p+2]; //Debug.DrawLine (ConvertPosCorrZ (mesh.verts[p1].x,mesh.verts[p1].y,mesh.verts[p1].z),ConvertPosCorrZ (mesh.verts[p2].x,mesh.verts[p2].y,mesh.verts[p2].z),Color.yellow); //Debug.DrawLine (ConvertPosCorrZ (mesh.verts[p1].x,mesh.verts[p1].y,mesh.verts[p1].z),ConvertPosCorrZ (mesh.verts[p3].x,mesh.verts[p3].y,mesh.verts[p3].z),Color.yellow); //Debug.DrawLine (ConvertPosCorrZ (mesh.verts[p3].x,mesh.verts[p3].y,mesh.verts[p3].z),ConvertPosCorrZ (mesh.verts[p2].x,mesh.verts[p2].y,mesh.verts[p2].z),Color.yellow); //Debug.DrawLine (ConvertPosCorrZ (verts[p1],0,verts[p1+2]),ConvertPosCorrZ (verts[p2],0,verts[p2+2]),Color.blue); //Debug.DrawLine (ConvertPosCorrZ (verts[p1],0,verts[p1+2]),ConvertPosCorrZ (verts[p3],0,verts[p3+2]),Color.blue); //Debug.DrawLine (ConvertPosCorrZ (verts[p2],0,verts[p2+2]),ConvertPosCorrZ (verts[p3],0,verts[p3+2]),Color.blue); }*/ }