I've been playing around with the Vulkan ray tracing. Here's an example render:

Now, I want better lighting and shadows, so I'm going to try path tracing.

Does anyone have any of their own path tracing code in GLSL?

It’s coming along, sort of.

I’m getting there. I might ask for help in a bit. LOL

I've got something working. What it is is not a final implementation. It's a bit dark.

Any suggestions?

The relevant code in the raygen shader is:

float trace_path(const int iterations, const vec3 origin, const vec3 direction, out vec3 hitPos, const int channel)
{
	float ret_colour = 0;

	vec3 o = origin;
	vec3 d = direction;

	const int samples = 10;

		for(int s = 0; s < samples; s++)
	{
		float local_colour = 1;

		for(int i = 0; i < iterations; i++)
		{
			float tmin = 0.001;
			float tmax = 1000.0;
			traceRayEXT(topLevelAS, gl_RayFlagsOpaqueEXT, 0xff, 0, 0, 0, o.xyz, tmin, d.xyz, tmax, 0);

			if(channel == red_channel)
				local_colour *= rayPayload.color.r;
			else if(channel == green_channel)
				local_colour *= rayPayload.color.g;
			else
				local_colour *= rayPayload.color.b;

			if(rayPayload.color.r == 1.0 && rayPayload.color.g == 1.0 && rayPayload.color.b == 1.0)
			{
				ret_colour = 1;
				return ret_colour;
			}

			if(rayPayload.distance == -1)
			{
				ret_colour += local_colour;
				return ret_colour;
			}
			hitPos = o + d * rayPayload.distance;

			o = hitPos + direction*0.01;

			vec3 rdir = RandomUnitVector(prng_state);

			// Stick to the correct hemisphere

			if(dot(rdir, normalize(rayPayload.normal)) < 0.0)
				rdir = -rdir;

			d = rdir;
		}

		o = origin;
		d = direction;

		ret_colour += local_colour;
	}

	return sqrt(ret_colour);// samples;
}

The full source is at:

https://github.com/sjhalayka/cornell_box_textured

From a brief reading of the shader:

• You need to divide ret_color by the number of samples for energy conservation (before the sqrt()). You should get a similar (but less noisy) image if you increase the number of samples.
• Why the sqrt() at end? Gamma conversion should be done elsewhere, using proper sRGB exponent. Best to do it by creating sRGB framebuffer so that hardware does it automatically.
• Why is color a float and not vec3? Usually RGB are all traced using same rays unless doing funky wavelength-dependent scattering or diffraction.
• What is the purpose of o = hitPos + direction*0.01;? You are biasing next ray origin using the first ray's direction. This doesn't make sense. You already can avoid ray-surface self intersections using the tmin value. If you must manually bias, use the normal vector direction instead.
• You shouldn't return directly from the inner loop. It seems like you stop ray tracing if it hits a white surface, which doesn't make sense. If ray hits nothing (I guess the distance == -1 case), then local color should be set to 0 and break from the loop (not return). You still need to trace the rest of the samples in that case.
• Your BRDF is not normalized, and this will lead to wrong lighting results because secondary bounces will be too bright. You want to implement a Lambertian BRDF, which includes 1/pi normalization and cosine-weighting of rays to get more realistic results.