How to approach voxel graphics using the unity engine - unity3d

Question

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class VoxelRenderer : MonoBehaviour
{
public Mesh mesh;
public Material material;
[SerializeField]
public int size = 10;
[SerializeField]
public int offset = -10;
// Start is called before the first frame update
void Start()
{
}
void Update()
{
int limit = size;
for (int x = 0; x < limit; x++)
{
for (int y = 0; y < limit; y++)
{
for (int z = 0; z < limit; z++)
{
Graphics.DrawMesh(mesh, new Vector3(x*2 +offset, y*2 + offset, z * 2 + offset), Quaternion.identity, material, 0);
}
}
}
}
}
Now this renders fine for size 10~ but if i go for 100+ (which is obviously low for which is required for a planet) i get massive fps drops presumably because of 10000's of batches per frame. Am i going the wrong way here? Or is it an occlussion issue or something similar i am running into here?

Answer 1

Draw calls can really hurt your performance. You can use batching and GPU instancing, but I think the best solution is using CombineMeshes. By combining 1000s of meshes into 1, you can get that many fewer draw calls.
Unity has a limit of slightly less than 2^16=65536 vertices per mesh. This prevents you from having a giant voxel as only one mesh. I suggest that you combine groups of a few thousand meshes ("chunks") and when you need to update the voxel data, only redo the mesh groups whose data changed. This not only gets around the vertex limit, but also saves performance by recombining only the meshes that need it.
In a minecraft-like game that I worked on, I made a script that generated cube blocks without drawing any hidden faces (e.g. two blocks touching each other wouldn't generate faces between them), but this will only work if your meshes are cubes and the code is messy.
I think the best solution would be to make two MonoBehaviours.
A Chunk class could handle may voxels, but not the whole planet, and the VoxelRenderer can handle spawning as many chunks are needed to make the whole planet. Make a prefab with a MeshRenderer, this Chunk component, and the right material assigned.
Please note that this is just a quick skeleton of what you'd need.
Chunk:
public class Chunk : MonoBehaviour
{
public Mesh mesh;
// Start is called before the first frame update
void UpdateChunk()
{
CombineInstance[] ci = new CombingInstance[CHUNK_SIZE*CHUNK_SIZE*CHUNK_SIZE];
for(int x = 0; x < VoxelRenderer.CHUNK_SIZE;x++){
//add 2 more for loops for y and z
ci[x*CHUNK_SIZE*CHUNK_SIZE + y*CHUNK_SIZE + z].Transform =...
}
GetComponent<MeshFilter>().mesh = new Mesh();
GetComponent<MeshFilter>().mesh.CombineMeshes(ci);
}
VoxelRenderer:
public class VoxelRenderer : MonoBehaviour
{
public const int CHUNK_SIZE = 8;
public GameObject chunkPrefab;
[SerializeField]
public int size = 10;
[SerializeField]
public int offset = -10;
private Chunk[,,] chunks;
// Start is called before the first frame update
void Start()
{
int limit = size;
int limitDividedByChunkSize = Mathf.RountToInt(limit/(float)CHUNK_SIZE);
chunks = new Chunk[limitDividedByChunkSize,limitDividedByChunkSize,limitDividedByChunkSize];
for (int x = 0; x < limit; x+=CHUNK_SIZE)
{
for (int y = 0; y < limit; y+=CHUNK_SIZE)
{
for (int z = 0; z < limit; z+=CHUNK_SIZE)
{
GameObject g = Instantiate(chunkPrefab, new Vector3(x*2*CHUNK_SIZE +offset, y*2*CHUNK_SIZE + offset, z * 2*CHUNK_SIZE + offset));
Chunks[x,y,z] = g.GetComponent<Chunk>();
}
}
}
}
//this updates all voxel chunks, for minor changes to the voxel data use chunks[x,y,z].UpdateChunk();
void UpdateAllVoxelChunks()
{
for (int x = 0; x < chunks.Length; x++)
{
for (int y = 0; y < chunks[x].Length; y++)
{
for (int z = 0; z < chunks[y].Length; z++)
{
Chunks[x,y,z].UpdateChunk();
}
}
}
}
}