Voxel Cone Tracing Part 3 - Raycasting

Entry posted by Josh · June 13, 2018

4,064 views

I added a raycast function to the voxel tree class and now I can perform raycasts between any two positions. This is perfect for calculating direct lighting. Shadows are calculated by performing a raycast between the voxel position and the light position, as shown in the screenshot below. Fortunately the algorithm seems to work great an there are no gaps or cracks in the shadow:

Here is the same scene using a voxel size of 10 centimeters:

If we move the light a little lower, you can see a shadow appearing near two edges of the floor:

Why is this happening? Well, the problem is that at those angles, the raycast is hitting the neighboring voxel on the floor next to the voxel we are testing:

You might think that if we just move one end of the ray up to the top of the voxel it will work fine, and you'd be right, in this situation.

But with slightly different geometry, we have a new problem.

So how do we solve this? At any given time, a voxel can have up to three faces that face the light (but it might have as few as one). In the image below I have highlighted the two voxel faces on the right-most voxel that face the light:

If we check the neighboring voxels we can see that the voxel to the left is occupied, and therefore the left face does not make a good position to test from:

But the top voxel is clear, so we will test from there:

If we apply the same logic to the other geometry configuration I showed, we also get a correct result. Of course, if both neighboring voxels were solid then we would not need to perform a raycast at all because we know the light would be completely blocked at this position.

The code to do this just checks which side of a voxel the light position is on. As it is written now, up to three raycasts may be performed per voxel:

if (lightpos.x < voxel->bounds.min.x)
{
	if (GetSolid(ix - 1, iy, iz) == false)
	{
		result = IntersectsRay(p0 - Vec3(voxelsize * 0.5f, 0.0f, 0.0f), lightpos);
	}
}
if (lightpos.x > voxel->bounds.max.x and result == false)
{
	if (GetSolid(ix + 1, iy, iz) == false)
	{
		result = IntersectsRay(p0 + Vec3(voxelsize * 0.5f, 0.0f, 0.0f), lightpos);
	}
}
if (lightpos.y < voxel->bounds.min.y and result == false)
{
	if (GetSolid(ix, iy - 1, iz) == false)
	{
		result = IntersectsRay(p0 - Vec3(0.0f, voxelsize * 0.5f, 0.0f), lightpos);
	}
}
if (lightpos.y > voxel->bounds.max.y and result == false)
{
	if (GetSolid(ix, iy + 1, iz) == false)
	{
		result = IntersectsRay(p0 + Vec3(0.0f, voxelsize * 0.5f, 0.0f), lightpos);
	}
}
if (lightpos.z < voxel->bounds.min.z and result == false)
{
	if (GetSolid(ix, iy, iz - 1) == false)
	{
		result = IntersectsRay(p0 - Vec3(0.0f, 0.0f, voxelsize * 0.5f), lightpos);
	}
}
if (lightpos.z > voxel->bounds.max.z and result == false)
{
	if (GetSolid(ix, iy, iz + 1) == false)
	{
		result = IntersectsRay(p0 + Vec3(0.0f, 0.0f, voxelsize * 0.5f), lightpos);
	}
}

.With this correction the artifact disappears:

It even works correctly at a lower resolution:

Now our voxel raycast algorithm is complete. The next step will be to calculate direct lighting on the voxelized scene using the lights that are present.