PBRT method is overkill, I know the relative error of the fetched positions is constant

Author: devshgraphicsprogramming

examples_tests/22.RaytracedAO/closestHit.comp

@@ -68,7 +68,8 @@ void main()
 			const uvec3 indices = get_triangle_indices(batchInstanceGUID,triangleID);
 
 			// positions
-			const vec3 last_vx_pos = load_positions(indices,batchInstanceData);
+			mat2x3 dPdBary_error; vec3 lastVxPos_error;
+			const vec3 last_vx_pos = load_positions(dPdBary_error,lastVxPos_error,indices,batchInstanceData);
 			const vec3 geomNormal = cross(dPdBary[0],dPdBary[1]);
 			const bool frontfacing = bool((batchInstanceData.determinantSignBit^floatBitsToUint(dot(geomNormal,normalizedV)))&0x80000000u);
 

examples_tests/22.RaytracedAO/raygen.comp

@@ -54,7 +54,8 @@ void main()
 
 			const uint vertex_depth_mod_2 = 0x1u;
 			// load vertex data
-			const vec3 last_vx_pos = load_positions(indices,batchInstanceData);
+			mat2x3 dPdBary_error; vec3 lastVxPos_error;
+			const vec3 last_vx_pos = load_positions(dPdBary_error,lastVxPos_error,indices,batchInstanceData);
 			const nbl_glsl_xoroshiro64star_state_t scramble_start_state = load_aux_vertex_attrs(compactBary,indices,batchInstanceData,material,outPixelLocation,vertex_depth_mod_2
 #ifdef TEX_PREFETCH_STREAM
 				,dBarydScreen

examples_tests/22.RaytracedAO/raytraceCommon.glsl

@@ -118,47 +118,34 @@ vec3 nbl_glsl_MC_getNormalizedWorldSpaceN()
 	return normalizedN;
 }
 
-
-
-
-vec3 nbl_glsl_robust_ray_origin_fastest(in vec3 origin, in vec3 direction, float error, vec3 normal)
-{
-	// flip it in the correct direction
-	error = uintBitsToFloat(floatBitsToUint(error)^(floatBitsToUint(dot(normal,direction))&0x80000000u));
-	return origin+normal*error;
-}
-vec3 nbl_glsl_robust_ray_origin_fast(in vec3 origin, in vec3 direction, in vec3 error, in vec3 normal)
-{
-	// anticipate that the error could have increased from manipulation
-	return nbl_glsl_robust_ray_origin_fastest(origin,direction,error.x+error.y+error.z,normal);
-}
-vec3 nbl_glsl_robust_ray_origin(in vec3 origin, in vec3 direction, in vec3 error, in vec3 normal)
-{
-	const float d = dot(abs(normal),error);
-	// anticipate that the error could have increased from manipulation
-	return nbl_glsl_robust_ray_origin_fastest(origin,direction,d,normal);
-}
-
-
-
 #include <nbl/builtin/glsl/barycentric/utils.glsl>
 mat2x3 dPdBary;
-vec3 load_positions(in uvec3 indices, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
+vec3 load_positions(out mat2x3 dPdBary_error, out vec3 lastVxPos_error,in uvec3 indices, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
 {
 	mat3 positions = mat3(
 		nbl_glsl_fetchVtxPos(indices[0],batchInstanceData),
 		nbl_glsl_fetchVtxPos(indices[1],batchInstanceData),
 		nbl_glsl_fetchVtxPos(indices[2],batchInstanceData)
 	);
 	const mat4x3 tform = batchInstanceData.tform;
-	mat3 error;
+	mat3 positions_error;
 	// for when we quantize positions to RGB21_UNORM
-	//const float quantizationError = nbl_glsl_numeric_limits_float_epsilon(1u);
-	positions = nbl_glsl_mul_with_bounds(error,mat3(tform),positions/*,positions*quantizationError*/);
+	const float quantizationError = exp2(-16.f);// nbl_glsl_numeric_limits_float_epsilon(1u);
+	positions = nbl_glsl_mul_with_bounds_wo_gamma(positions_error,mat3(tform),positions,quantizationError);
 	//
-	dPdBary = mat2x3(positions[0]-positions[2],positions[1]-positions[2]);
-	return positions[2]+tform[3];
+	const float accum_error_factor = nbl_glsl_ieee754_gamma(2u)+nbl_glsl_ieee754_gamma(3u);
+	for (int i=0; i<2; i++)
+	{
+		dPdBary[i] = positions[i]-positions[2];
+		dPdBary_error[i] = abs(dPdBary[i])*nbl_glsl_ieee754_gamma(1u);
+		dPdBary_error[i] += (positions_error[i]+positions_error[2])*accum_error_factor;
+	}
+	const vec3 lastVx = positions[2]+tform[3];
+	lastVxPos_error = abs(positions[2])*quantizationError;
+	lastVxPos_error += (abs(lastVx)+lastVxPos_error[2])*nbl_glsl_ieee754_gamma(1u);
+	return lastVx;
 }
+
 #ifdef TEX_PREFETCH_STREAM
 mat2x3 nbl_glsl_perturbNormal_dPdSomething()
 {
@@ -173,31 +160,6 @@ mat2 nbl_glsl_perturbNormal_dUVdSomething()
 #define _NBL_USER_PROVIDED_MATERIAL_COMPILER_GLSL_BACKEND_FUNCTIONS_
 #include <nbl/builtin/glsl/material_compiler/common.glsl>
 
-
-vec3 rand3d(inout nbl_glsl_xoroshiro64star_state_t scramble_state, in int _sample, in int depth)
-{
-	uvec3 seqVal = texelFetch(sampleSequence,int(_sample)+(depth-1)*MAX_ACCUMULATED_SAMPLES).xyz;
-	seqVal ^= uvec3(nbl_glsl_xoroshiro64star(scramble_state),nbl_glsl_xoroshiro64star(scramble_state),nbl_glsl_xoroshiro64star(scramble_state));
-    return vec3(seqVal)*uintBitsToFloat(0x2f800004u);
-}
-
-void gen_sample_ray(
-	out float maxT, out vec3 direction, out vec3 throughput,
-	inout nbl_glsl_xoroshiro64star_state_t scramble_state, in uint sampleID, in uint depth,
-	in nbl_glsl_MC_precomputed_t precomp, in nbl_glsl_MC_instr_stream_t gcs, in nbl_glsl_MC_instr_stream_t rnps
-)
-{
-	maxT = nbl_glsl_FLT_MAX;
-	
-	vec3 rand = rand3d(scramble_state,int(sampleID),int(depth));
-	
-	float pdf;
-	nbl_glsl_LightSample s;
-	throughput = nbl_glsl_MC_runGenerateAndRemainderStream(precomp,gcs,rnps,rand,pdf,s);
-
-	direction = s.L;
-}
-
 nbl_glsl_xoroshiro64star_state_t load_aux_vertex_attrs(
 	in vec2 compactBary, in uvec3 indices, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData,
 	in nbl_glsl_MC_oriented_material_t material,
@@ -244,6 +206,56 @@ nbl_glsl_xoroshiro64star_state_t load_aux_vertex_attrs(
 	return scramble_start_state;
 }
 
+// TODO MOVE to some other header!
+vec3 nbl_glsl_interpolate_with_bounds(out vec3 error, in mat2x3 triangleEdges, in mat2x3 triangleEdges_error, in vec3 origin, in vec3 origin_error, in vec2 compactBary)
+{
+	return triangleEdges*compactBary+origin;
+}
+// robust ray origins
+vec3 nbl_glsl_robust_ray_origin_fastest(in vec3 origin, in vec3 direction, float error, vec3 normal)
+{
+	// flip it in the correct direction
+	error = uintBitsToFloat(floatBitsToUint(error)^(floatBitsToUint(dot(normal,direction))&0x80000000u));
+	return origin+normal*error;
+}
+vec3 nbl_glsl_robust_ray_origin_fast(in vec3 origin, in vec3 direction, in vec3 error, in vec3 normal)
+{
+	// anticipate that the error could have increased from manipulation
+	return nbl_glsl_robust_ray_origin_fastest(origin,direction,error.x+error.y+error.z,normal);
+}
+vec3 nbl_glsl_robust_ray_origin(in vec3 origin, in vec3 direction, in vec3 error, in vec3 normal)
+{
+	const float d = dot(abs(normal),error);
+	// anticipate that the error could have increased from manipulation
+	return nbl_glsl_robust_ray_origin_fastest(origin,direction,d,normal);
+}
+
+
+vec3 rand3d(inout nbl_glsl_xoroshiro64star_state_t scramble_state, in int _sample, in int depth)
+{
+	uvec3 seqVal = texelFetch(sampleSequence,int(_sample)+(depth-1)*MAX_ACCUMULATED_SAMPLES).xyz;
+	seqVal ^= uvec3(nbl_glsl_xoroshiro64star(scramble_state),nbl_glsl_xoroshiro64star(scramble_state),nbl_glsl_xoroshiro64star(scramble_state));
+    return vec3(seqVal)*uintBitsToFloat(0x2f800004u);
+}
+
+void gen_sample_ray(
+	out float maxT, out vec3 direction, out vec3 throughput,
+	inout nbl_glsl_xoroshiro64star_state_t scramble_state, in uint sampleID, in uint depth,
+	in nbl_glsl_MC_precomputed_t precomp, in nbl_glsl_MC_instr_stream_t gcs, in nbl_glsl_MC_instr_stream_t rnps
+)
+{
+	maxT = nbl_glsl_FLT_MAX;
+	
+	vec3 rand = rand3d(scramble_state,int(sampleID),int(depth));
+	
+	float pdf;
+	nbl_glsl_LightSample s;
+	throughput = nbl_glsl_MC_runGenerateAndRemainderStream(precomp,gcs,rnps,rand,pdf,s);
+
+	direction = s.L;
+}
+
+
 void generate_next_rays(
 	in uint maxRaysToGen, in nbl_glsl_MC_oriented_material_t material, in bool frontfacing, in uint vertex_depth,
 	in nbl_glsl_xoroshiro64star_state_t scramble_start_state, in uint sampleID, in uvec2 outPixelLocation,

include/nbl/builtin/glsl/utils/transform.glsl

@@ -5,55 +5,32 @@
 #ifndef _NBL_BUILTIN_GLSL_UTILS_TRANSFORM_INCLUDED_
 #define _NBL_BUILTIN_GLSL_UTILS_TRANSFORM_INCLUDED_
 
-mat3 nbl_glsl_mul_with_bounds_wo_gamma(out mat3 error, in mat3 a, in mat3 b, in mat3 b_error)
+mat3 nbl_glsl_mul_with_bounds_wo_gamma(out mat3 error, in mat3 a, in mat3 b, in float b_relative_error)
 {
     mat3 retval;
     for (int i=0; i<3; i++)
     {
         vec3 tmp = a[0]*b[i][0];
         retval[i] = tmp;
         error[i] = abs(tmp);
-        vec3 additional_error = abs(a[0]*b_error[i][0]);
         for (int j=1; j<3; j++)
         {
             tmp = a[j]*b[i][j];
             retval[i] += tmp;
             error[i] += abs(tmp);
-            additional_error += abs(a[j]*b_error[i][j]);
         }
-        additional_error *= nbl_glsl_ieee754_rcpgamma(2u)+1.f;
-        error[i] += additional_error;
     }
+    const float error_factor = 1.f+b_relative_error/nbl_glsl_numeric_limits_float_epsilon(2);
+    error *= error_factor;
     return retval;
 }
-mat3 nbl_glsl_mul_with_bounds_wo_gamma(out mat3 error, in mat3 a, in mat3 b)
+mat3 nbl_glsl_mul_with_bounds(out mat3 error, in mat3 a, in mat3 b, in float b_relative_error)
 {
-    mat3 retval;
-    for (int i=0; i<3; i++)
-    {
-        vec3 tmp = a[0]*b[i][0];
-        retval[i] = tmp;
-        error[i] = abs(tmp);
-        for (int j=1; j<3; j++)
-        {
-            tmp = a[j]*b[i][j];
-            retval[i] += tmp;
-            error[i] += abs(tmp);
-        }
-    }
+    mat3 retval = nbl_glsl_mul_with_bounds_wo_gamma(error,a,b,b_relative_error);
+    error *= nbl_glsl_ieee754_gamma(2u);
     return retval;
 }
 
-mat3 nbl_glsl_mul_with_bounds(out mat3 error, in mat3 a, in mat3 b, in mat3 b_error)
-{
-    return nbl_glsl_mul_with_bounds_wo_gamma(error,a,b,b_error);
-}
-
-mat3 nbl_glsl_mul_with_bounds(out mat3 error, in mat3 a, in mat3 b)
-{
-    return nbl_glsl_mul_with_bounds_wo_gamma(error,a,b);
-}
-
 
 vec4 nbl_glsl_pseudoMul4x4with3x1(in mat4 m, in vec3 v)
 {