This is part 2 of 2. These posts are meant to give a basic introduction to voxel engines. In later posts I will dig into optimization techniques and benchmarking.
In part 1 I touched on the basics of polygon mesh and voxel graphics. I also touched how a voxel world can be represented in memory to bypass some limits. In this post I will briefly touch on how rendering would work.
I’ll be using Unity 3D, but any 3D rendering system that accepts basic triangle polygon mesh will do the job.
If we assume a 1-1 relationship between a chunk and a Unity Game Object it makes things easier. The reason is that each chunk gets a separate Mesh-object where vertices and triangles can be set.
Voxel rendering
As already covered in part 1 the voxel data must be converted to polygon mesh for rendering. We’ll call this process “RenderToMesh”. Doing this is actually fairly easy.
Set up Unity
First off, we set up a Unity 3D project with code from part 1 copied into its respective .cs-files. So “Chunk” ends up in “Chunk.cs”, “World” ends up in “World.cs”, “ChunkId” ends up in “ChunkId.cs”.
Second we have Chunk inherit from MonoBehavior by changing “public class Chunk” to “public class Chunk : MonoBehavior”. We do this because its easier to associate a chunk with its Mesh if the chunk itself is on a GameObject that contains a MeshFilter and MeshRenderer. I usually have a looser coupling here, but this is fine for our example.
For the Chunk we also want Unity to both add Mesh and we want a reference of that during starutp. So Chunk.cs now looks like:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
[RequireComponent(typeof(MeshFilter))] [RequireComponent(typeof(MeshRenderer))] public class Chunk : MonoBehaviour { private UInt16[] _voxels = new ushort[16 * 16 * 16]; private MeshFilter _meshFilter; public UInt16 this[int x, int y, int z] { get { return _voxels[x * 16 * 16 + y * 16 + z]; } set { _voxels[x * 16 * 16 + y * 16 + z] = value; } } // Start is called before the first frame update void Start() { _meshFilter = GetComponent<MeshFilter>(); } } |
To test our new memory system we will create a VoxelEngine.cs that has World and adds a chunk to it. It will also update a random voxel in the chunk on every Update().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
public class VoxelEngine : MonoBehaviour { private World _world = new World(); private System.Random _random = new System.Random(); // Start is called before the first frame update void Start() { // Create GameObject that will hold a Chunk var chunkGameObject = new GameObject("Chunk 0, 0, 0"); chunkGameObject.transform.parent = transform.parent; // Add Chunk to GameObject var chunk = chunkGameObject.AddComponent<Chunk>(); // Add chunk to world at position 0, 0, 0 _world.Chunks.Add(new ChunkId(0, 0, 0), chunk); } // Update is called once per frame void Update() { // Update a random block to random type var x = _random.Next(0, 16); var y = _random.Next(0, 16); var z = _random.Next(0, 16); var voxelType = (UInt16)_random.Next(0, 2); _world[x, y, z] = voxelType; } } |
To set this up we add an empty GameObject to the scene and add VoxelEngine to it.
Simple renderer
We’ll start by making a very simple renderer. We will assume that voxel type 0 is air, and voxel type 1 is solid. We are setting the voxels randomly to this in VoxelEngine on every update.
Normally we would have a dirty-flag that indicates if we really need to render. If no change has happened, then we don’t need to render. But for simplicity we’ll just render on every Update().
So VoxelEngine will modify a voxel. The Chunk will convert from voxel data to mesh in RenderToMesh. Then finally Unity and the graphics card will render the final 3D image that the user can see.
To do this we need to loop over every voxel we have in the chunk to check if it is air or solid. If it is solid, we will copy the vertices and triangles required to form a cube. We also have to position the new vertices correctly, and the triangle references positions in the vertices list so that has to be scewed.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
public void RenderToMesh() { var vertices = new List<Vector3>(); var triangles = new List<int>(); for (var x = 0; x < 16; x++) { for (var y = 0; y < 16; y++) { for (var z = 0; z < 16; z++) { var voxelType = this[x, y, z]; // If it is air we ignore this block if (voxelType == 0) continue; var pos = new Vector3(x, y, z); // Remember current position in vertices list so we can add triangles relative to that var verticesPos = vertices.Count; foreach (var vert in _cubeVertices) vertices.Add(pos + vert); // Voxel postion + cubes vertex foreach (var tri in _cubeTriangles) triangles.Add(verticesPos + tri); // Position in vertices list for new vertex we just added } } } // Apply new mesh to MeshFilter var mesh = new Mesh(); mesh.SetVertices(vertices); mesh.SetTriangles(triangles.ToArray(), 0); _meshFilter.mesh = mesh; } |
If we run the code our result will be something like this.
The color is because we are missing material. If we apply a material to the chunk and look in Shaded Wireframe mode we can see that we are successfully generating 3D polygon mesh from our chunk of 3D voxel data.
If we want the model to receive light and cast shadow we would have to add normals to the mesh. This is basically just adding one vector3.up to a normals array for every vertex. I’ve included material and normals in source code linked to at the end of this post.
Remaining optimization
Although performance may look acceptable at first glance this is not a very efficient way to do things.
There are a couple of very basic things that must be done to get any performance out of this at all:
- When a chunk is modified a “dirty” flag should be set. Chunk should only render itself if it is dirty.
- When to adjacent voxels are solid their sides should not render.
These are so-called “quick wins”. Without these you will be using a lot of unnecessary resources.
Summary
We set up a simple Unity project and associated our code from part 1 with Unity game objects so that we could render mesh. We set up a simple test script that randomly changed the voxels, and made a simple renderer that scans the chunk and writes to mesh
Source code for what we have done so far can be found here.
Although this method describes the basics of rendering voxels, it does not scale well.
in the method Chunk::RenderToMest() the variable _cubeVertices and _cubeTriagles() are never declared, but are used in a foreach loop. It is not apparent how these variables were loaded with data. Please elaborate on these variables, and how they came to receive data that can be iterated over.
Thank you for pointing that out. It refers to the variables set up in part 1. I’ve changed the names in part 1 to match the for loop. 🙂 Working code can be found <a href="https://github.com/tedd/BlogSamples/blob/master/Tedd.VoxelEngineExample/VoxelEngineExample%20Unity%20Project/Assets/Code/Chunk.cs" rel="nofollow ugc">here</a>.