Improving Generation Performance

There are quite a few high profile games coming out in the next year or so that make use of voxels to drive dynamic content. Two in particular have really caught my attention, for different reasons. The first was Hello Games' No Man's Sky which is in a similar vein to my own project, using voxel data and Dual Contouring to generate traditional polygonal meshes.

Video update for October 2015

I've posted a new video to YouTube showing some of the speed improvements I've made recently.



Since the last video in Feburary I've moved the entire voxel -> mesh pipeline (except for the seam mesh generation) to the GPU via OpenCL and reworked how the volume is processed. I'm planning on a blog post to explain the changes but the main thing is that I no longer always sample the field at a 1:1 resolution. E.g. for a LOD1 node I now only sample a 128x128x128 volume instead of 8, and for LOD2 only 1 volume instead of 64. This has had a huge impact on the performance which has helped with other features, like the dragging operations you can see in the video.

Fixing a seams bug

I've been sitting on the "fix" for a bug with the seams for a while now, and since I can't figure out a better solution I'll share my current one.

Dual Contouring with OpenCL

I've spent the last few weeks rewriting the core component of my engine, the voxel pipeline. This encapsulates the whole process from density function to a triangle mesh. In terms of functionality the pipeline is essentially the same, but now is (almost) entirely implemented using OpenCL. In fact the OpenGL/OpenCL interop is used so that the generated mesh lives and dies exclusively on the GPU.

QEF implementations for C++/GLSL and OpenCL

I've created a github repo to hold QEF implementations. The repo currently contains a version created by Leonard Ritter (@paniq) which is a stripped down version of the original implementation by /u/unzret from my previous post. I've also forked that to create an OpenCL version, and added that to the repo too.

These implementations are completely free for any purpose which is an improvement over the reference implementation's license (which was free for non-commercial use). Moreover, this implementation is suitable for use on the GPU which is a technical improvement on the reference version.

I know a lot of people reading this blog are using C# so perhaps someone wants to contribute a C# port? Ideally the repo would be a single resource for QEF code so no one else ever has to write it!

Engine overview

This post will be describing at a fairly high level how my engine works in the last video I posted to YouTube. There are a few places where I go into some more detail as these were either requested explicitly by someone or I have been asked about them multiple times. If there's anything you'd like expanded upon let me know in the comments.

Updated Sample Application

I've updated the sample Dual Contouring implementation to use a new QEF implementation. You can now find the sample on Github.

The previous QEF implementation was from the original reference code and was under a non-commercial license. The new implementation is completely free for any purpose and is, I think, a lot more readable than the old implementation. This new implementation was written by /u/unzret who contacted me on Reddit.