Would it be better to write this algorithm in a vetex shader?

Unity Engine
1

Hi all.
I am making a game like minecraft.
the game has problems with loading chunks. (chunk is place in terrain 16 * 16 blocks) it works very slowly, like in old minecraft versions. I have a third diserminal array with types of the blocks. If next to the block is an air block, i add to the mesh a voxel.
This is a code:

public void Optimize()
    {  
        Mesh mesh = new Mesh();

        List<Vector3> verts = new List<Vector3>(); 
        List<int> tris = new List<int>();          
        List<Vector2> uvs = new List<Vector2>();

        //Vector3 Vplus = new Vector3(1f, 0f, 1f);

        for(int x = 1; x < 17; x++){
            for(int z = 1; z < 17; z++){
                for(int y = 1; y < maxHeight + 20; y++){
                    if(true)
                    {
                        Vector3 blockPos = new Vector3(x-1, y, z-1);
                        int numFaces = 0;
                        bool [] transparentTiles = new bool[6];
                        if(bloks[x, y, z] != BlockType.Air) {
                            transparentTiles = Block.blocks[bloks[x, y, z]].isTransparent;
                        } else {
                            transparentTiles = new bool[]{false, false, false, false, false, false};
                        }

                        BlockType thisBT = bloks[x, y, z];
                        Vector3 [] Vpos = new Vector3[4];

                        //up
                        if(!transparentTiles[2] && bloks[x, y+1, z] != BlockType.Air){
                            blockPos = new Vector3(x, y+1, z);
                            Vpos = Block.blocks[bloks[x, y+1, z]].returnVerts(1);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x, y+1, z]].bottomPos.GetUVs());
                        }

                        //bottom
                        if(!transparentTiles[0] && bloks[x, y-1, z] != BlockType.Air){
                            blockPos = new Vector3(x, y-1, z);
                            Vpos = Block.blocks[bloks[x, y-1, z]].returnVerts(0);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x, y-1, z]].topPos.GetUVs());
                        }

                        //front
                        if(!transparentTiles[2] && bloks[x, y, z-1] != BlockType.Air){
                            blockPos = new Vector3(x, y, z-1);
                            Vpos = Block.blocks[bloks[x, y, z-1]].returnVerts(4);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x, y, z-1]].sidePos.GetUVs());
                        }

                        //right
                        if(!transparentTiles[2] && bloks[x+1, y, z] != BlockType.Air){
                            blockPos = new Vector3(x+1, y, z);
                            Vpos = Block.blocks[bloks[x+1, y, z]].returnVerts(5);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x+1, y, z]].sidePos.GetUVs());
                        }

                        //back
                        if(!transparentTiles[2] && bloks[x, y, z+1] != BlockType.Air){
                            blockPos = new Vector3(x, y, z+1);
                            Vpos = Block.blocks[bloks[x, y, z+1]].returnVerts(2);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x, y, z+1]].sidePos.GetUVs());
                        }

                        //left
                        if(!transparentTiles[2] && bloks[x-1, y, z] != BlockType.Air){
                            blockPos = new Vector3(x-1, y, z);
                            Vpos = Block.blocks[bloks[x-1, y, z]].returnVerts(3);
                            verts.Add(blockPos + Vpos[0]);
                            verts.Add(blockPos + Vpos[1]);
                            verts.Add(blockPos + Vpos[2]);
                            verts.Add(blockPos + Vpos[3]);
                            numFaces++;
                            uvs.AddRange(Block.blocks[bloks[x-1, y, z]].sidePos.GetUVs());
                        }

                        int tl = verts.Count - 4 * numFaces;
                        for(int i = 0; i < numFaces; i++)
                        {
                            tris.AddRange(new int[] { tl + i * 4, tl + i * 4 + 1, tl + i * 4 + 2, tl + i * 4, tl + i * 4 + 2, tl + i * 4 + 3 });

                        }
                    }
                }
            }
        }

        mesh.vertices = verts.ToArray();
        mesh.triangles = tris.ToArray();
        mesh.uv = uvs.ToArray();

        mesh.RecalculateNormals(); //g

        GetComponent<MeshFilter>().mesh = mesh;
        GetComponent<MeshCollider>().sharedMesh = mesh;

        isOptimized = true;
    }

will it work faster if I write it in a vertex shader?

2

There are certainly other techniques and APIs to generate these kind of values for meshes more efficiently and way faster. Custom threading, JobSystem, ComputerBuffers, existing and optimized libraries…

However, these type of algorithms can still be pretty fast on a potato CPU when optimized properly.
The thing is: the code you posted is not even optimized. You’ve got lots of unnecessary allocations and operations in the most-inner loop, which already take a good amount of time for sure.

3

what can be optimized in my loop?

How much is it possible to optimize this algorithm? I want the game to run on msi wind u160 (intel atom n450), the weakest device i have.

this is code of the class Block:

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Xml.Serialization;

public class Block
{
    public Tile top, side, bottom;

    public float height;
    public RenderType rend;
    public bool [] isTransparent = new bool[6];
    public Vector3 [] standartVerts = new Vector3 [8];

    public Vector3 [ , ] tileVerts = new Vector3 [6, 4];
    public TilePos topPos, sidePos, bottomPos;

    public Block(Tile tile, float height, RenderType Rend, bool[] transparent)
    {
        top = side = bottom = tile;
        this.isTransparent = transparent;
        GetPositions();
        GetVerticles(Rend);
    }

    public Block(Tile top, Tile side, Tile bottom, float height, RenderType Rend, bool[] transparent)
    {
        this.top = top;
        this.side = side;
        this.bottom = bottom;
        this.isTransparent = transparent;
        GetPositions();
        GetVerticles(Rend);
    }

    public Block(RenderType rend){
        this.isTransparent = new bool[]{false, false, false, false, false, false};
    }

    void GetPositions()
    {
        topPos = TilePos.tiles[top];
        sidePos = TilePos.tiles[side];
        bottomPos = TilePos.tiles[bottom];
    }

    public void GetVerticles(RenderType thisBlockRender){
        if(thisBlockRender == RenderType.fullBlock){
            standartVerts[0] = new Vector3(0, 1, 0); //0
            standartVerts[1] = new Vector3(0, 1, 1); //1
            standartVerts[2] = new Vector3(1, 1, 1); //2
            standartVerts[3] = new Vector3(1, 1, 0); //3
            standartVerts[4] = new Vector3(0, 0, 0); //4
            standartVerts[5] = new Vector3(1, 0, 0); //5
            standartVerts[6] = new Vector3(1, 0, 1); //6
            standartVerts[7] = new Vector3(0, 0, 1); //7
        } else {
            if(thisBlockRender == RenderType.transparentBlock){
                standartVerts[0] = new Vector3(0, 1, 0); //0
                standartVerts[1] = new Vector3(0, 1, 1); //1
                standartVerts[2] = new Vector3(1, 1, 1); //2
                standartVerts[3] = new Vector3(1, 1, 0); //3
                standartVerts[4] = new Vector3(0, 0, 0); //4
                standartVerts[5] = new Vector3(1, 0, 0); //5
                standartVerts[6] = new Vector3(1, 0, 1); //6
                standartVerts[7] = new Vector3(0, 0, 1); //7
            } else {
                if(thisBlockRender == RenderType.upper_halfBlock){
                    standartVerts[0] = new Vector3(0, 1, 0);
                    standartVerts[1] = new Vector3(0, 1, 1);
                    standartVerts[2] = new Vector3(1, 1, 1);
                    standartVerts[3] = new Vector3(1, 1, 0);
                    standartVerts[4] = new Vector3(0, 0.5f, 0);
                    standartVerts[5] = new Vector3(1, 0.5f, 0);
                    standartVerts[6] = new Vector3(1, 0.5f, 1);
                    standartVerts[7] = new Vector3(0, 0.5f, 1);
                } else {
                    if(thisBlockRender == RenderType.lower_halfBlock){
                        standartVerts[0] = new Vector3(0, 0.5f, 0);
                        standartVerts[1] = new Vector3(0, 0.5f, 1);
                        standartVerts[2] = new Vector3(1, 0.5f, 1);
                        standartVerts[3] = new Vector3(1, 0.5f, 0);
                        standartVerts[4] = new Vector3(0, 0, 0);
                        standartVerts[5] = new Vector3(1, 0, 0);
                        standartVerts[6] = new Vector3(1, 0, 1);
                        standartVerts[7] = new Vector3(0, 0, 1);
                    }
                }
            }
        }
       
        //up

        tileVerts[0, 0] = standartVerts[0];
        tileVerts[0, 1] = standartVerts[1];
        tileVerts[0, 2] = standartVerts[2];
        tileVerts[0, 3] = standartVerts[3];
       
        // bottom
       
        tileVerts[1, 0] = standartVerts[4];
        tileVerts[1, 1] = standartVerts[5];
        tileVerts[1, 2] = standartVerts[6];
        tileVerts[1, 3] = standartVerts[7];
       
        //front
       
        tileVerts[2, 0] = standartVerts[4];
        tileVerts[2, 1] = standartVerts[0];
        tileVerts[2, 2] = standartVerts[3];
        tileVerts[2, 3] = standartVerts[5];
       
        //right
       
        tileVerts[3, 0] = standartVerts[5];
        tileVerts[3, 1] = standartVerts[3];
        tileVerts[3, 2] = standartVerts[2];
        tileVerts[3, 3] = standartVerts[6];
       
        //back
       
        tileVerts[4, 0] = standartVerts[6];
        tileVerts[4, 1] = standartVerts[2];
        tileVerts[4, 2] = standartVerts[1];
        tileVerts[4, 3] = standartVerts[7];
       
        //left
       
        tileVerts[5, 0] = standartVerts[7];
        tileVerts[5, 1] = standartVerts[1];
        tileVerts[5, 2] = standartVerts[0];
        tileVerts[5, 3] = standartVerts[4];
       
    }
    public Vector3 [] returnVerts(int tileNum){
        Vector3 [] returnV = new Vector3[4];
        for(int i = 0; i < 4; i++){
            returnV[i] = tileVerts[tileNum, i];
        }
        return returnV;
    }

    public static Dictionary<BlockType, Block> blocks = new Dictionary<BlockType, Block>(){
        {BlockType.Air, new Block(RenderType.NORENDERING)},
        {BlockType.Grass, new Block(Tile.Grass, Tile.GrassSide, Tile.Dirt, 1.0f, RenderType.fullBlock, new bool[]{true, true, true, true, true, true})},
        {BlockType.Dirt, new Block(Tile.Dirt, 1.0f, RenderType.fullBlock, new bool[]{true, true, true, true, true, true})},
        {BlockType.Stone, new Block(Tile.Stone, 1.0f, RenderType.fullBlock, new bool[]{true, true, true, true, true, true})},
        {BlockType.Trunk, new Block(Tile.TreeCX, Tile.TreeSide, Tile.TreeCX, 1.0f, RenderType.fullBlock, new bool[]{true, true, true, true, true, true})},
        {BlockType.Leaves, new Block(Tile.Leaves, 1.0f, RenderType.transparentBlock, new bool[]{false, false, false, false, false, false})},
        {BlockType.StoneL, new Block(Tile.Stone, Tile.StoneL, Tile.Stone, 0.5f, RenderType.lower_halfBlock, new bool[]{false, false, false, true, false, false})},
        {BlockType.StoneU, new Block(Tile.Stone, Tile.StoneU, Tile.Stone, 0.5f, RenderType.upper_halfBlock, new bool[]{false, false, false, false, true, false})},
    };


    public static Dictionary<BlockType, RenderType> render = new Dictionary<BlockType, RenderType>(){
        {BlockType.Grass, RenderType.fullBlock},
        {BlockType.Dirt, RenderType.fullBlock},
        {BlockType.Stone, RenderType.fullBlock},
        {BlockType.Trunk, RenderType.fullBlock},
        {BlockType.Leaves, RenderType.transparentBlock},
        {BlockType.StoneL, RenderType.lower_halfBlock},
        {BlockType.StoneU, RenderType.upper_halfBlock},
        {BlockType.Air, RenderType.NORENDERING},
    };
}
[Serializable]
public enum BlockType {Air, Dirt, Grass, Stone, Trunk, Leaves, StoneU, StoneL}

public enum RenderType {lower_halfBlock, upper_halfBlock, fullBlock, transparentBlock, NORENDERING}
4

Probably many things, I didn’t check the entire piece of code.

Just a few basic examples:

First code snippet, line 18. An allocation of throw-away array. You never use that instance, instead you get the arrays from your blocks or re-allocate it just a few lines later in the ‘else’ case (line 22).

Here you’ve already got 1616(20+maxHeight) allocations that are simply not required.

For the else-case, you could re-use a single array that’s allocated outside of the loops, which would also reduce the number of allocations by few more thousands.

How to improve that? For instance, allocate it once and whenever you do not get the array from your blocks, use the pre-allocated array rather than allocating one again and again. That’s possible since you do not seem to use them anywhere else, and you do not pass them around so “noone relies” on them in the next iteration and you’re save to re-use it.

Similar issue in line 26: The allocation can be omitted completely, as you only get the array from your blocks. That’s another 1616(20+maxHeight) = 5120 + (256*maxHeight) allocations less.

I cannot tell how much performance that would gain, probably quite a bit already but it won’t be the only thing to look for. I also cannot tell how much performance you can gain in general. That’s something you’ll find out as you optimize it more and more…

However, let’s face reality: you need to be aware that there are also probably way more efficient ways to generate the data. Yours is rather trivial, kind of the brute-force attempt to generate all the mesh data.

Minecraft and all these type of games have usually faced many of these problems too, and hence a lot of time was spent optimizing them or even switching to different algorithms and techniques over the years. As easy as the concept might seem, there’s a lot of experience and hard work required.