+ | Fog imGUI

shaders/compute.glsl

@@ -32,14 +32,23 @@ struct GPUMaterial
 
 struct GPUCamera
 {
-	mat4		view_matrix;
-    vec3		position;
+	mat4	view_matrix;
+    vec3	position;
+	
+	float	aperture_size;
+	float	focus_distance;
+	float	fov;
 
-	float		aperture_size;
-	float		focus_distance;
-	float		fov;
+	int		bounce;
+};
 
-	int						bounce;
+struct GPUVolume
+{
+	vec3	sigma_a;    // absorption coefficient
+	vec3	sigma_s;    // scattering coefficient
+	vec3	sigma_t;    // extinction coefficient
+	float	g;         // phase function parameter
+	bool	enabled;
 };
 
 layout(std430, binding = 1) buffer ObjectBuffer
@@ -52,11 +61,16 @@ layout(std430, binding = 2) buffer MaterialBuffer
 	GPUMaterial materials[];
 };
 
-layout(std140) uniform CameraData
+layout(std140, binding = 0) uniform CameraData
 {
     GPUCamera camera;
 };
 
+layout(std140, binding = 1) uniform VolumeData
+{
+    GPUVolume volume;
+};
+
 uniform int     u_objectsNum;
 uniform vec2    u_resolution;
 uniform int		u_pixelisation;
@@ -148,31 +162,25 @@ vec3    pathtrace(Ray ray, inout uint rng_state)
 	
 	vec3 transmittance = vec3(1.0);
 
-	VolumeProperties volume;
-    volume.sigma_a = vec3(0.0001);
-    volume.sigma_s = vec3(0.0800);
-    volume.sigma_t = volume.sigma_a + volume.sigma_s;
-    volume.g = 1.;
-
 	for (int i = 0; i < camera.bounce; i++)
 	{
 		hitInfo hit = traceRay(ray);
 
 		float t_scatter = 0.0;
-		if (atmosScatter(volume, hit, t_scatter, rng_state))
+		if (volume.enabled && atmosScatter(hit, t_scatter, rng_state))
         {
-			calculateVolumetricLight(t_scatter, volume, ray, color, light, transmittance, rng_state);
+			calculateVolumetricLight(t_scatter, ray, color, light, transmittance, rng_state);
             continue;
         }
 
 		if (hit.obj_index == -1)
 		{
 			light += transmittance * GetEnvironmentLight(ray);
-			// light += vec3(135 / 255.0f, 206 / 255.0f, 235 / 255.0f); //ambient color 
 			break;
 		}
 
-		transmittance *= exp(-volume.sigma_t * hit.t);
+		if (volume.enabled)
+			transmittance *= exp(-volume.sigma_t * hit.t);
 
 		GPUObject obj = objects[hit.obj_index];
 		GPUMaterial mat = materials[obj.mat_index];

shaders/light.glsl

@@ -1,9 +1,9 @@
 
 vec3 GetEnvironmentLight(Ray ray)
 {
-	vec3 sun_pos = vec3(-1., 1.0, 0.);
+	vec3 sun_pos = vec3(-0.5, 0.5, 0.5);
 	float SunFocus = 1.5;
-	float SunIntensity = 0.5;
+	float SunIntensity = 1.;
 
 	vec3 GroundColour = vec3(0.5, 0.5, 0.5);
 	vec3 SkyColourHorizon = vec3(135 / 255.0f, 206 / 255.0f, 235 / 255.0f);
@@ -29,7 +29,7 @@ vec3	sampleLights(vec3 position)
 		GPUObject obj = objects[i];
 		GPUMaterial mat = materials[obj.mat_index];
 
-		if (obj.type == 0 && mat.emission > 0.0)
+		if (mat.emission > 0.0)
 		{
 			vec3 light_dir = normalize(obj.position - position);
 			float light_dist = length(obj.position - position);

shaders/volumetric.glsl

@@ -1,11 +1,4 @@
 
-struct VolumeProperties {
-    vec3 sigma_a;    // absorption coefficient
-    vec3 sigma_s;    // scattering coefficient
-    vec3 sigma_t;    // extinction coefficient
-    float g;         // phase function parameter
-};
-
 float sampleHG(float g, inout uint rng_state)
 {
     if (abs(g) < 0.001)
@@ -36,17 +29,18 @@ vec3 sampleDirection(vec3 forward, float cos_theta, inout uint rng_state)
     );
 }
 
-bool atmosScatter(VolumeProperties volume, hitInfo hit, inout float t_scatter, inout uint rng_state)
+bool atmosScatter(hitInfo hit, inout float t_scatter, inout uint rng_state)
 {
-    t_scatter = -log(randomValue(rng_state)) / volume.sigma_t.x;
+    float density = volume.sigma_t.x;
+    t_scatter = -log(randomValue(rng_state)) / density;
 
-    return (t_scatter < hit.t && volume.sigma_t.x > 0.0);
+    return (t_scatter < hit.t && density > 0.0);
 }
 
-void calculateVolumetricLight(float t_scatter, VolumeProperties volume, inout Ray ray, inout vec3 color, inout vec3 light, inout vec3 transmittance, inout uint rng_state)
+void calculateVolumetricLight(float t_scatter, inout Ray ray, inout vec3 color, inout vec3 light, inout vec3 transmittance, inout uint rng_state)
 {
     vec3 scatter_pos = ray.origin + ray.direction * t_scatter;
-            
+    
     transmittance *= exp(-volume.sigma_t * t_scatter);
     color *= volume.sigma_s / volume.sigma_t;