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