Merge remote-tracking branch 'origin/Denoising'

shaders/compute.glsl

@@ -4,6 +4,9 @@ layout(local_size_x = 16, local_size_y = 16) in;
 layout(binding = 0, rgba32f) uniform image2D output_image;
 layout(binding = 1, rgba32f) uniform image2D accumulation_image;
 
+layout(binding = 3, rgba32f) uniform image2D normal_texture;
+layout(binding = 4, rgba32f) uniform image2D position_texture;
+
 struct GPUObject {
 	mat4	rotation;
 
@@ -176,7 +179,7 @@ vec3 pathtrace(Ray ray, inout uint rng_state)
     for (int i = 0; i < camera.bounce; i++)
     {
         hitInfo hit = traceRay(ray);
-        
+
 		#if 0
 			float t_scatter = 0.0;
 			bool scatter_valid = bool(volume.enabled != 0 && atmosScatter(hit, t_scatter, rng_state));
@@ -193,6 +196,12 @@ vec3 pathtrace(Ray ray, inout uint rng_state)
 			break;
 		}
 
+		if (i == 0)
+		{
+			imageStore(normal_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.normal), 1.0));
+			imageStore(position_texture, ivec2(gl_GlobalInvocationID.xy), vec4(normalize(hit.position), 1.0));
+		}
+
         float p = max(color.r, max(color.g, color.b));
         if (randomValue(rng_state) >= p) break;
 		color /= max(p, 0.001);
@@ -238,7 +247,7 @@ void main()
 	ivec2 pixel_coords = ivec2(gl_GlobalInvocationID.xy);
 	if (pixel_coords.x >= int(u_resolution.x) || pixel_coords.y >= int(u_resolution.y)) 
 		return;
-	
+
 	if (u_pixelisation != 1 && (uint(pixel_coords.x) % u_pixelisation != 0 || uint(pixel_coords.y) % u_pixelisation != 0))
 		return;
 
@@ -247,7 +256,7 @@ void main()
 
 	vec2 jitter = randomPointInCircle(rng_state) * 1;
 
-	vec2 uv = ((vec2(pixel_coords) + jitter) / u_resolution) * 2.0 - 1.0;;
+	vec2 uv = ((vec2(pixel_coords) + jitter) / u_resolution) * 2.0 - 1.0;
 	uv.x *= u_resolution.x / u_resolution.y;
 
 	Ray ray = initRay(uv, rng_state);

shaders/denoising.glsl

@@ -0,0 +1,70 @@
+#version 430 core
+
+layout(local_size_x = 16, local_size_y = 16) in;
+layout(binding = 0, rgba32f) uniform image2D read_texture;
+layout(binding = 2, rgba32f) uniform image2D write_texture;
+
+layout(binding = 3, rgba32f) uniform image2D position_texture;
+layout(binding = 4, rgba32f) uniform image2D normal_texture;
+
+
+uniform vec2    u_resolution;
+uniform int     u_pass;
+
+uniform float   u_c_phi;
+uniform float   u_p_phi;
+uniform float   u_n_phi;
+
+void main()
+{
+	ivec2 pixel_coords = ivec2(gl_GlobalInvocationID.xy);
+	if (pixel_coords.x >= int(u_resolution.x) || pixel_coords.y >= int(u_resolution.y)) 
+		return;
+	
+	int holes = int(pow(2, u_pass));
+
+	vec4 color_center = imageLoad(read_texture, pixel_coords);
+    vec3 position_center = imageLoad(position_texture, pixel_coords).xyz;
+    vec3 normal_center = imageLoad(normal_texture, pixel_coords).xyz;
+
+    float kernel[5] = float[5](1.0/16.0, 1.0/4.0, 3.0/8.0, 1.0/4.0, 1.0/16.0);
+    
+    float totalWeight = 0.;
+	vec4 color = vec4(vec3(0.), 1.0);
+
+	for (int x = -2; x <= 2; x++)
+	{
+		for (int y = -2; y <= 2; y++)
+		{
+			ivec2 coords = pixel_coords + ivec2(x * holes, y * holes);
+			if (coords.x < 0. || coords.y < 0. || coords.x >= int(u_resolution.x) || coords.y >= int(u_resolution.y))
+				continue ;
+			// coords = clamp(coords, ivec2(-1.0), u_resolution);
+
+			vec4 color_sample = imageLoad(read_texture, coords);
+			vec3 position_sample = imageLoad(position_texture, coords).xyz;
+			vec3 normal_sample = imageLoad(normal_texture, coords).xyz;
+
+			// Calculate edge-stopping weights
+            
+            // Color weight
+            float colorDist = distance(color_center, color_sample);
+            float w_c = exp(-colorDist / u_c_phi);
+            
+            // Position weight
+            float posDist = distance(position_center, position_sample);
+            float w_p = exp(-posDist / u_p_phi);
+
+            // Normal weight
+            float normalDist = distance(normal_center, normal_sample);
+            float w_n = exp(-normalDist / u_n_phi);
+
+			float weight = kernel[x+2] * kernel[y+2] * w_c * w_p * w_n;
+			
+			color += color_sample * weight;
+			totalWeight += weight;
+		}
+	}
+
+	imageStore(write_texture, pixel_coords, color / totalWeight);
+}

shaders/light.glsl

@@ -2,7 +2,7 @@ hitInfo	traceRay(inout Ray ray);
 
 vec3 GetEnvironmentLight(Ray ray)
 {
-    // return vec3(0.);
+    return vec3(0.);
 	vec3 sun_pos = vec3(-0.5, 0.5, 0.5);
 	float SunFocus = 1.5;
 	float SunIntensity = 1.;
@@ -65,7 +65,7 @@ vec3 sampleQuadLight(vec3 position, GPUObject obj, int light_index, GPUMaterial
 
     vec3 normal = normalize(crossQuad);
     float cos_theta = max(0.0, dot(normal, -light_dir));
-    return mat.emission * mat.color / (light_dist);
+    return mat.emission * mat.color / (light_dist * light_dist) * pdf;
 }
 
 vec3 sampleLights(vec3 position, inout uint rng_state)
@@ -134,6 +134,6 @@ void    calculateLightColor(GPUMaterial mat, hitInfo hit, inout vec3 color, inou
     {
         color *= mat.color;
         light += mat.emission * mat.color;
+        // light += sampleLights(hit.position, rng_state);
     }
-    // light += sampleLights(hit.position, rng_state);
 }