Example #1
0
    public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g)
    {
        Vector3 v000 = new Vector3(x, y, z);
        Vector3 v001 = new Vector3(x, y, z + 1.0f);
        Vector3 v010 = new Vector3(x, y + 0.125f, z);
        Vector3 v011 = new Vector3(x, y + 0.125f, z + 1.0f);
        Vector3 v100 = new Vector3(x + 1.0f, y, z);
        Vector3 v101 = new Vector3(x + 1.0f, y, z + 1.0f);
        Vector3 v110 = new Vector3(x + 1.0f, y + 0.125f, z);
        Vector3 v111 = new Vector3(x + 1.0f, y + 0.125f, z + 1.0f);

        GreedyTerrainMesh terrainMesh = g.AlphaTest;

        int content = chunk.GetCellContent(x - 1, y, z);

        if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
        {
            terrainMesh.NormalQuad(v001, v011, v010, v000, TextureSlot, Color.white);
        }

        content = chunk.GetCellContent(x, y, z - 1);
        if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
        {
            terrainMesh.NormalQuad(v000, v010, v110, v100, TextureSlot, Color.white);
        }

        content = chunk.GetCellContent(x + 1, y, z);
        if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
        {
            terrainMesh.NormalQuad(v100, v110, v111, v101, TextureSlot, Color.white);
        }

        content = chunk.GetCellContent(x, y + 1, z);
        if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
        {
            terrainMesh.NormalQuad(v111, v110, v010, v011, TextureSlot, Color.white);
        }

        content = chunk.GetCellContent(x, y, z + 1);
        if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
        {
            terrainMesh.NormalQuad(v101, v111, v011, v001, TextureSlot, Color.white);
        }
    }
Example #2
0
    public void ChangeCell(int x, int y, int z, int newValue)
    {
        int index = Terrain.GetChunkIndex(x >> 4, z >> 4);

        BlockTerrain.Chunk        c     = Terrain.GetChunk(index);
        BlockTerrain.ChunkStatics state = Terrain.chunkStats.Get(index);
        if (c != null)
        {
            int cx = x & 15;
            int cz = z & 15;

            int content = c.GetCellContent(cx, y, cz);
            if (content != 0)
            {
                state.state = 3;
            }
            content = BlockTerrain.GetContent(newValue);
            if (content != 0)
            {
                state.state = 3;
            }
            c.SetCellValue(cx, y, cz, newValue);
            c.isEdited = true;
            if (cx == 0 && c.XminusOne != null)
            {
                QuqueChunkUpdate(c.XminusOne.index, 3);
            }
            else if (cx == 15 && c.XplusOne != null)
            {
                QuqueChunkUpdate(c.XplusOne.index, 3);
            }
            if (cz == 0 && c.YminusOne != null)
            {
                QuqueChunkUpdate(c.YminusOne.index, 3);
            }
            else if (cz == 15 && c.YplusOne != null)
            {
                QuqueChunkUpdate(c.YplusOne.index, 3);
            }
            QuqueChunkUpdate(c.index);
        }
    }
Example #3
0
    public void GenerateCubeBlocks(BlockTerrain.Chunk chunk)
    {
        bool[] isTransparent              = BlocksData.IsTransparent;
        IStandardCubeBlock[] cubeBlocks   = BlocksData.StandardCubeBlocks;
        INormalBlock[]       normalBlocks = BlocksData.NormalBlocks;

        for (int x = 0; x < 16; x++)
        {
            for (int z = 0; z < 16; z++)
            {
                for (int y = 0; y < 128; y++)
                {
                    int value   = chunk.GetCellValue(x, y, z);
                    int content = BlockTerrain.GetContent(value);
                    if (isTransparent[content])
                    {
                        normalBlocks[content].GenerateTerrain(x, y, z, value, chunk, this);
                    }
                    else
                    {
                        Vector3 v000 = new Vector3(x, y, z);
                        Vector3 v001 = new Vector3(x, y, z + 1.0f);
                        Vector3 v010 = new Vector3(x, y + 1.0f, z);
                        Vector3 v011 = new Vector3(x, y + 1.0f, z + 1.0f);
                        Vector3 v100 = new Vector3(x + 1.0f, y, z);
                        Vector3 v101 = new Vector3(x + 1.0f, y, z + 1.0f);
                        Vector3 v110 = new Vector3(x + 1.0f, y + 1.0f, z);
                        Vector3 v111 = new Vector3(x + 1.0f, y + 1.0f, z + 1.0f);

                        var cellFace = new CellFace();
                        var block    = cubeBlocks[content];
                        int neighbor = chunk.GetCellContent(x - 1, y, z);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.BACK, chunk, ref cellFace);
                            Terrain.NormalQuad(v000, v001, v011, v010, cellFace.TextureSlot, cellFace.Color);
                        }

                        neighbor = chunk.GetCellContent(x, y - 1, z);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.BOTTOM, chunk, ref cellFace);
                            Terrain.NormalQuad(v001, v000, v100, v101, cellFace.TextureSlot, cellFace.Color);
                        }

                        neighbor = chunk.GetCellContent(x, y, z - 1);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.LEFT, chunk, ref cellFace);
                            Terrain.NormalQuad(v100, v000, v010, v110, cellFace.TextureSlot, cellFace.Color);
                        }

                        neighbor = chunk.GetCellContent(x + 1, y, z);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.FRONT, chunk, ref cellFace);
                            Terrain.NormalQuad(v101, v100, v110, v111, cellFace.TextureSlot, cellFace.Color);
                        }

                        neighbor = chunk.GetCellContent(x, y + 1, z);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.TOP, chunk, ref cellFace);
                            Terrain.NormalQuad(v011, v111, v110, v010, cellFace.TextureSlot, cellFace.Color);
                        }

                        neighbor = chunk.GetCellContent(x, y, z + 1);
                        if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor])
                        {
                            block.GenerateTerrain(x, y, z, value, CellFace.RIGHT, chunk, ref cellFace);
                            Terrain.NormalQuad(v001, v101, v111, v011, cellFace.TextureSlot, cellFace.Color);
                        }
                    }
                }
            }
        }
    }