Voxel Cone Tracing Part 4 - Direct Lighting

Entry posted by Josh · June 14, 2018

3,743 views

Now that we can voxelize models, enter them into a scene voxel tree structure, and perform raycasts we can finally start calculating direct lighting. I implemented support for directional and point lights, and I will come back and add spotlights later. Here we see a shadow cast from a single directional light:

And here are two point lights, one red and one green. Notice the distance falloff creates a color gradient across the floor:

The idea here is to first calculate direct lighting using raycasts between the light position and each voxel:

Then once you have the direct lighting, you can calculate approximate global illumination by gathering a cone of samples for each voxel, which illuminates voxels not directly visible to the light source:

And if we repeat this process we can simulate a second bounce, which really fills in all the hidden surfaces:

When we convert model geometry to voxels, one of the important pieces of information we lose are normals. Without normals it is difficult to calculate damping for the direct illumination calculation. It is easy to check surrounding voxels and determine that a voxel is embedded in a floor or something, but what do we do in the situation below?

The thin wall of three voxels is illuminated, which will leak light into the enclosed room. This is not good:

My solution is to calculate and store lighting for each face of each voxel.

Vec3 normal[6] = { Vec3(-1, 0, 0), Vec3(1, 0, 0), Vec3(0, -1, 0), Vec3(0, 1, 0), Vec3(0, 0, -1), Vec3(0, 0, 1) };							
for (int i = 0; i < 6; ++i)
{
	float damping = max(0.0f,normal[i].Dot(lightdir)); //normal damping
	if (!isdirlight) damping *= 1.0f - min(p0.DistanceToPoint(lightpos) / light->range[1], 1.0f); //distance damping
	voxel->directlighting[i] += light->color[0] * damping;
}

This gives us lighting that looks more like the diagram below:

When light samples are read, the appropriate face will be chosen and read from. In the final scene lighting on the GPU, I expect to be able to use the triangle normal to determine how much influence each sample should have. I think it will look something like this in the shader:

vec4 lighting = vec4(0.0f);
lighting += max(0.0f, dot(trinormal, vec3(-1.0f, 0.0f, 0.0f)) * texture(gimap, texcoord + vec2(0.0 / texwidth, 0.0));
lighting += max(0.0f, dot(trinormal, vec3(1.0f, 0.0f, 0.0f)) * texture(gimap, texcoord + vec2(1.0 / texwidth, 0.0));
lighting += max(0.0f, dot(trinormal, vec3(0.0f, -1.0f, 0.0f)) * texture(gimap, texcoord + vec2(2.0 / texwidth, 0.0));
lighting += max(0.0f, dot(trinormal, vec3(0.0f, 1.0f, 0.0f)) * texture(gimap, texcoord + vec2(3.0 / texwidth, 0.0));
lighting += max(0.0f, dot(trinormal, vec3(0.0f, 0.0f, -1.0f)) * texture(gimap, texcoord + vec2(4.0 / texwidth, 0.0));
lighting += max(0.0f, dot(trinormal, vec3(0.0f, 0.0f, 1.0f)) * texture(gimap, texcoord + vec2(5.0 / texwidth, 0.0));

This means that to store a 256 x 256 x 256 grid of voxels we actually need a 3D RGB texture with dimensions of 256 x 256 x 1536. This is 288 megabytes. However, with DXT1 compression I estimate that number will drop to about 64 megabytes, meaning we could have eight voxel maps cascading out around the player and still only use about 512 megabytes of video memory. This is where those new 16-core CPUs will really come in handy!

I added the lighting calculation for the normal Vec3(0,1,0) into the visual representation of our voxels and lowered the resolution. Although this is still just direct lighting it is starting to look interesting:

The last step is to downsample the direct lighting to create what is basically a mipmap. We do this by taking the average values of each voxel node's children:

void VoxelTree::BuildMipmaps()
{
	if (level == 0) return;
	int contribs[6] = { 0 };
	for (int i = 0; i < 6; ++i)
	{
		directlighting[i] = Vec4(0);
	}
	for (int ix = 0; ix < 2; ++ix)
	{
		for (int iy = 0; iy < 2; ++iy)
		{
			for (int iz = 0; iz < 2; ++iz)
			{
				if (kids[ix][iy][iz] != nullptr)
				{
					kids[ix][iy][iz]->BuildMipmaps();
					for (int n = 0; n < 6; ++n)
					{
						directlighting[n] += kids[ix][iy][iz]->directlighting[n];
						contribs[n]++;
					}
				}
			}
		}
	}
	for (int i = 0; i < 6; ++i)
	{
		if (contribs[i] > 0) directlighting[i] /= float(contribs[i]);
	}
}