public void UpdateMeshData(MeshDataThread meshDataThread)
    {
        List <Vector3> vertices = new List <Vector3>();
        List <Color>   color    = new List <Color>();

        for (int i = 0; i < meshDataThread.vertices.Length; i++)
        {
            vertices.Add(meshDataThread.vertices[i].Vertice);
            color.Add(meshDataThread.vertices[i].VertColor);
        }


        meshFilter.mesh = new Mesh();

        meshFilter.mesh.vertices  = vertices.ToArray();
        meshFilter.mesh.triangles = meshDataThread.triangles;
        meshFilter.mesh.colors    = color.ToArray();

        meshFilter.mesh.RecalculateNormals();

        meshCollider.sharedMesh = meshFilter.mesh;

        meshDataThread.vertices  = null;
        meshDataThread.triangles = null;
        meshDataThread.uvs       = null;
    }
Beispiel #2
0
    private void MakeChunkMeshes()
    {
        while (WorldRuning)
        {
            while (pendingUpdateMesh.Count > 0)
            {
                Chunk chunk = GetChunkNullOption(pendingUpdateMesh.Dequeue());

                if (chunk != null)
                {
                    MeshDataThread meshDataThread = new MeshDataThread();

                    List <VertVoxel> vertices  = new List <VertVoxel>();
                    List <int>       triangles = new List <int>();
                    List <Vector2>   uvs       = new List <Vector2>();


                    for (int x = 0; x < ChunkSize; x++)
                    {
                        for (int y = 0; y < ChunkSize; y++)
                        {
                            for (int z = 0; z < ChunkSize; z++)
                            {
                                if (chunk.Blocks[x, y, z] != null)
                                {
                                    MarchCube(new Vector3Int(x, y, z), vertices, triangles, chunk, chunk.Blocks[x, y, z]);
                                }
                            }
                        }
                    }

                    meshDataThread.CurrentChunk = chunk.chunkPosition;

                    meshDataThread.vertices  = vertices.ToArray();
                    meshDataThread.triangles = triangles.ToArray();
                    meshDataThread.uvs       = uvs.ToArray();

                    vertices.Clear();
                    triangles.Clear();
                    uvs.Clear();


                    pendingUpdateMeshFinal.Enqueue(meshDataThread);
                }
            }

            Thread.Sleep(ThickRate);
        }
    }
Beispiel #3
0
    void Update()
    {
        PlayerPos = new Vector3((int)Player.position.x, (int)Player.position.y, (int)Player.position.z);

        while (pendingchunks.Count > 0)
        {
            MapData chunk = pendingchunks.Dequeue();

            if (!chunkMap.ContainsKey(chunk.position))
            {
                GameObject obj = Instantiate(ChunkGO, new Vector3(chunk.position.x, chunk.position.y, chunk.position.z), Quaternion.identity);
                obj.name = "Chunk - X:" + chunk.position.x + " Y:" + chunk.position.y + " Z:" + chunk.position.z;

                obj.GetComponent <Chunk>().MakeMesh(chunk.density);

                lock (chunkMap)
                {
                    chunkMap.Add(chunk.position, obj.GetComponent <Chunk>());
                }
            }
        }

        while (pendingDeletions.Count > 0)
        {
            Vector3 vector = pendingDeletions.Dequeue();
            if (chunkMap.TryGetValue(vector, out Chunk chunk))
            {
                Destroy(chunk.gameObject);

                lock (chunkMap)
                {
                    chunkMap.Remove(vector);
                }
            }
        }

        while (pendingUpdateMeshFinal.Count > 0)
        {
            MeshDataThread chunk = pendingUpdateMeshFinal.Dequeue();

            if (chunkMap.TryGetValue(chunk.CurrentChunk, out Chunk chunkser))
            {
                chunkser.UpdateMeshData(chunk);
            }
        }
    }