improve readability

Author: devshgraphicsprogramming

examples_tests/22.RaytracedAO/closestHit.comp

@@ -53,16 +53,16 @@ void main()
 		{
 			const uint triangleID = intersection.primid;
 			const nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData = InstData.data[batchInstanceGUID];
+			
+			// obtain ray incoming direction
+			normalizedV = -normalize(ray.direction);
 			// clear the hit success flag
 			intersections[vertex_depth_mod_2].data[gl_GlobalInvocationID.x].shapeid = -1;
+
 			const uvec3 indices = get_triangle_indices(batchInstanceGUID,triangleID);
 
-			// obtain ray incoming direction
-			normalizedV = -mat3(batchInstanceData.normalMatrixRow0,batchInstanceData.normalMatrixRow1,batchInstanceData.normalMatrixRow2)*ray.direction;
-			normalizedV = normalize(normalizedV);  // doesn't non-uniform scale screw up BxDF eval and generation?
-			
 			// positions
-			const vec3 last_vx_pos = load_positions(indices,batchInstanceGUID);
+			const vec3 last_vx_pos = load_positions(indices,batchInstanceData);
 			const vec3 geomNormal = cross(dPdBary[0],dPdBary[1]);
 			const bool frontfacing = dot(geomNormal,normalizedV)>0.f;
 
@@ -76,7 +76,7 @@ void main()
 				// if we ever support spatially varying emissive, we'll need to hoist barycentric computation and UV fetching to the position fetching
 				const vec2 compactBary = intersection.uvwt.xy;
 
-				const nbl_glsl_xoroshiro64star_state_t scramble_start_state = load_aux_vertex_attrs(compactBary,indices,batchInstanceGUID,material,outPixelLocation,vertex_depth
+				const nbl_glsl_xoroshiro64star_state_t scramble_start_state = load_aux_vertex_attrs(compactBary,indices,batchInstanceData,material,outPixelLocation,vertex_depth
 #ifdef TEX_PREFETCH_STREAM
 					,mat2(0.0) // TODO: Covariance Rendering
 #endif
@@ -85,8 +85,8 @@ void main()
 				const vec3 hitWorldPos = dPdBary*compactBary.xy+last_vx_pos;
 
 				generate_next_rays(
-					MAX_RAYS_GENERATED,batchInstanceData,material,frontfacing,vertex_depth,
-					scramble_start_state,sampleID,outPixelLocation,hitWorldPos,geomNormal,throughput
+					MAX_RAYS_GENERATED,material,frontfacing,vertex_depth,scramble_start_state,
+					sampleID,outPixelLocation,hitWorldPos,geomNormal,throughput
 				);
 			}
 		}

examples_tests/22.RaytracedAO/fillVisBuffer.frag

@@ -14,10 +14,10 @@ layout(location = 2) flat in uint BackfacingBit_BatchInstanceGUID;
 layout(location = 3) flat in uint drawCmdFirstIndex;
 
 uint nbl_glsl_barycentric_frag_getDrawID() {return BackfacingBit_BatchInstanceGUID&0x7fffffffu;}
-vec3 nbl_glsl_barycentric_frag_getVertexPos(in uint drawID, in uint primID, in uint primsVx)
+vec3 nbl_glsl_barycentric_frag_getVertexPos(in uint batchInstanceGUID, in uint primID, in uint primsVx)
 {
     const uint ix = nbl_glsl_VG_fetchTriangleVertexIndex(primID*3u+drawCmdFirstIndex,primsVx);
-    return nbl_glsl_fetchVtxPos(ix,drawID);
+    return nbl_glsl_fetchVtxPos(ix,InstData.data[batchInstanceGUID]);
 }
 
 

examples_tests/22.RaytracedAO/fillVisBuffer.vert

@@ -27,7 +27,7 @@ void main()
 
     const uint batchInstanceGUID = self.backfacingBit_batchInstanceGUID&0x7fffffffu;
 
-    const vec3 modelPos = nbl_glsl_fetchVtxPos(gl_VertexIndex,batchInstanceGUID);
+    const vec3 modelPos = nbl_glsl_fetchVtxPos(gl_VertexIndex,InstData.data[batchInstanceGUID]);
     nbl_glsl_barycentric_vert_set(modelPos);
     gl_Position = nbl_glsl_pseudoMul4x4with3x1(self.MVP,modelPos);
 }

examples_tests/22.RaytracedAO/raygen.comp

@@ -37,14 +37,15 @@ void main()
 			const uvec4 visBuffer = texelFetch(frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2,ivec2(outPixelLocation),0);
 
 			// unproject (TODO: redo)
-			vec3 hitWorldPos,V;
+			vec3 hitWorldPos;
 			{
 				const vec3 NDC = vec3(vec2(outPixelLocation)*staticViewData.rcpPixelSize+staticViewData.rcpHalfPixelSize,1.0-revdepth);
 
 				const vec4 tmp = nbl_glsl_pseudoMul4x4with3x1(pc.cummon.inverseMVP,NDC);
 				hitWorldPos = tmp.xyz/tmp.w;
 
-				V = nbl_glsl_pseudoMul3x4with3x1(pc.cummon.ndcToV,NDC);
+				const vec3 V = nbl_glsl_pseudoMul3x4with3x1(pc.cummon.ndcToV,NDC);
+				normalizedV = normalize(V);
 			}
 
 			// vis buffer decode
@@ -57,24 +58,18 @@ void main()
 			const mat2 dBarydScreen = mat2(unpackHalf2x16(visBuffer[2]),unpackHalf2x16(visBuffer[3]));
 			#endif
 
+			//
 			const nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData = InstData.data[batchInstanceGUID];
 			const uvec3 indices = get_triangle_indices(batchInstanceGUID,triangleID);
-
-			// TODO: redo
-			{
-				const mat3 batchScaleRotInv = mat3(batchInstanceData.normalMatrixRow0,batchInstanceData.normalMatrixRow1,batchInstanceData.normalMatrixRow2);
-				hitWorldPos = batchScaleRotInv*(hitWorldPos-batchInstanceData.tform[3]);
-				normalizedV = normalize(batchScaleRotInv*V); // doesn't non-uniform scale screw up BxDF eval and generation?
-			}
 
 			// get material while waiting for indices
 			const nbl_glsl_MC_oriented_material_t material = nbl_glsl_MC_material_data_t_getOriented(batchInstanceData.material,frontfacing);
 			emissive = nbl_glsl_MC_oriented_material_t_getEmissive(material);
 
 			const uint vertex_depth_mod_2 = 0x1u;
 			// load vertex data
-			load_positions(indices,batchInstanceGUID);
-			const nbl_glsl_xoroshiro64star_state_t scramble_start_state = load_aux_vertex_attrs(compactBary,indices,batchInstanceGUID,material,outPixelLocation,vertex_depth_mod_2
+			load_positions(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
 #endif
@@ -85,7 +80,7 @@ void main()
 			const vec3 geomNormal = cross(dPdBary[0],dPdBary[1]);
 			const uint vertex_depth = 1u;
 			generate_next_rays(
-				staticViewData.samplesPerPixelPerDispatch,batchInstanceData,material,frontfacing,vertex_depth,
+				staticViewData.samplesPerPixelPerDispatch,material,frontfacing,vertex_depth,
 				scramble_start_state,sampleID,outPixelLocation,hitWorldPos,geomNormal,vec3(1.0)
 			);
 		}

examples_tests/22.RaytracedAO/raytraceCommon.glsl

@@ -117,15 +117,17 @@ vec3 nbl_glsl_MC_getNormalizedWorldSpaceN()
 
 #include <nbl/builtin/glsl/barycentric/utils.glsl>
 mat2x3 dPdBary;
-vec3 load_positions(in uvec3 indices, in uint batchInstanceGUID)
+vec3 load_positions(in uvec3 indices, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
 {
-	const mat3 positions = mat3(
-		nbl_glsl_fetchVtxPos(indices[0],batchInstanceGUID),
-		nbl_glsl_fetchVtxPos(indices[1],batchInstanceGUID),
-		nbl_glsl_fetchVtxPos(indices[2],batchInstanceGUID)
+	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;
+	positions = mat3(tform)*positions;
 	dPdBary = mat2x3(positions[0]-positions[2],positions[1]-positions[2]);
-	return positions[2];
+	return positions[2]+tform[3];
 }
 #ifdef TEX_PREFETCH_STREAM
 mat2x3 nbl_glsl_perturbNormal_dPdSomething()
@@ -161,13 +163,13 @@ void gen_sample_ray(
 
 	float pdf;
 	nbl_glsl_LightSample s;
-	throughput = nbl_glsl_MC_runGenerateAndRemainderStream(precomp, gcs, rnps, rand, pdf, 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 uint batchInstanceGUID,
+	in vec2 compactBary, in uvec3 indices, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData,
 	in nbl_glsl_MC_oriented_material_t material,
 	in uvec2 outPixelLocation, in uint vertex_depth_mod_2
 #ifdef TEX_PREFETCH_STREAM
@@ -178,19 +180,19 @@ nbl_glsl_xoroshiro64star_state_t load_aux_vertex_attrs(
 	// if we ever support spatially varying emissive, we'll need to hoist barycentric computation and UV fetching to the position fetching
 	#ifdef TEX_PREFETCH_STREAM
 	const mat3x2 uvs = mat3x2(
-		nbl_glsl_fetchVtxUV(indices[0],batchInstanceGUID),
-		nbl_glsl_fetchVtxUV(indices[1],batchInstanceGUID),
-		nbl_glsl_fetchVtxUV(indices[2],batchInstanceGUID)
+		nbl_glsl_fetchVtxUV(indices[0],batchInstanceData),
+		nbl_glsl_fetchVtxUV(indices[1],batchInstanceData),
+		nbl_glsl_fetchVtxUV(indices[2],batchInstanceData)
 	);
 	const nbl_glsl_MC_instr_stream_t tps = nbl_glsl_MC_oriented_material_t_getTexPrefetchStream(material);
 	#endif
 	// only needed for continuing
 	const mat3 normals = mat3(
-		nbl_glsl_fetchVtxNormal(indices[0],batchInstanceGUID),
-		nbl_glsl_fetchVtxNormal(indices[1],batchInstanceGUID),
-		nbl_glsl_fetchVtxNormal(indices[2],batchInstanceGUID)
+		nbl_glsl_fetchVtxNormal(indices[0],batchInstanceData),
+		nbl_glsl_fetchVtxNormal(indices[1],batchInstanceData),
+		nbl_glsl_fetchVtxNormal(indices[2],batchInstanceData)
 	);
-	
+
 	#ifdef TEX_PREFETCH_STREAM
 	dUVdBary = mat2(uvs[0]-uvs[2],uvs[1]-uvs[2]);
 	const vec2 UV = dUVdBary*compactBary+uvs[2];
@@ -204,16 +206,18 @@ nbl_glsl_xoroshiro64star_state_t load_aux_vertex_attrs(
 	const nbl_glsl_xoroshiro64star_state_t scramble_start_state = imageLoad(scramblebuf,ivec3(outPixelLocation,vertex_depth_mod_2)).rg;
 
 	// while waiting for the scramble state
+	normalizedN.x = dot(batchInstanceData.normalMatrixRow0,normal);
+	normalizedN.y = dot(batchInstanceData.normalMatrixRow1,normal);
+	normalizedN.z = dot(batchInstanceData.normalMatrixRow2,normal);
 	normalizedN = normalize(normal);
 
 	return scramble_start_state;
 }
 
 void generate_next_rays(
-	in uint maxRaysToGen, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData,
-	in nbl_glsl_MC_oriented_material_t material, in bool frontfacing, in uint vertex_depth,
+	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,
-	in vec3 pos, vec3 geomNormal, in vec3 prevThroughput)
+	in vec3 origin, vec3 geomNormal, in vec3 prevThroughput)
 {
 	// get material streams as well
 	const nbl_glsl_MC_instr_stream_t gcs = nbl_glsl_MC_oriented_material_t_getGenChoiceStream(material);
@@ -257,17 +261,16 @@ for (uint i=1u; i!=vertex_depth; i++)
 	// set up dispatch indirect
 	atomicMax(traceIndirect[vertex_depth_mod_2_inv].params.num_groups_x,(baseOutputID+raysToAllocate-1u)/WORKGROUP_SIZE+1u);
 
-	const mat4x3 batchWorldTform = batchInstanceData.tform;
 	uint offset = 0u;
 	for (uint i=0u; i<maxRaysToGen; i++)
 	if (maxT[i]!=0.f)
 	{
 		nbl_glsl_ext_RadeonRays_ray newRay;
 		// TODO: improve ray offsets
 		const float err = 1.f/96.f;
-		newRay.origin = mat3(batchWorldTform)*(pos+/*geomNormal/max(max(geomNormal.x,geomNormal.y),geomNormal.z)*sign(dot(geomNormal,direction[i]))*/direction[i]*err)+batchWorldTform[3];
+		newRay.origin = origin+/*geomNormal/max(max(geomNormal.x,geomNormal.y),geomNormal.z)*sign(dot(geomNormal,direction[i]))*/direction[i]*err;
 		newRay.maxT = maxT[i];
-		newRay.direction = mat3(batchWorldTform)*direction[i]; // normalize after ? (doesn't non-uniform scale screw up BxDF eval and generation?)
+		newRay.direction = direction[i]; // normalize after ? (doesn't non-uniform scale screw up BxDF eval and generation?)
 		newRay.time = packOutPixelLocation(outPixelLocation);
 		newRay.mask = -1;
 		newRay._active = 1;

examples_tests/22.RaytracedAO/virtualGeometry.glsl

@@ -20,21 +20,21 @@
 #include <nbl/builtin/glsl/ext/MitsubaLoader/instance_data_descriptor.glsl>
 
 
-vec3 nbl_glsl_fetchVtxPos(in uint vtxID, in uint drawGUID)
+vec3 nbl_glsl_fetchVtxPos(in uint vtxID, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
 {
-    nbl_glsl_VG_VirtualAttributePacked_t va = InstData.data[drawGUID].padding0;
+    nbl_glsl_VG_VirtualAttributePacked_t va = batchInstanceData.padding0;
     return nbl_glsl_VG_attribFetch_RGB32_SFLOAT(va,vtxID);
 }
 
-vec3 nbl_glsl_fetchVtxNormal(in uint vtxID, in uint drawGUID)
+vec3 nbl_glsl_fetchVtxNormal(in uint vtxID, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
 {
-    nbl_glsl_VG_VirtualAttributePacked_t va = InstData.data[drawGUID].padding1;
+    nbl_glsl_VG_VirtualAttributePacked_t va = batchInstanceData.padding1;
     return normalize(nbl_glsl_VG_attribFetch_RGB10A2_SNORM(va,vtxID).xyz);
 }
 
-vec2 nbl_glsl_fetchVtxUV(in uint vtxID, in uint drawGUID)
+vec2 nbl_glsl_fetchVtxUV(in uint vtxID, in nbl_glsl_ext_Mitsuba_Loader_instance_data_t batchInstanceData)
 {
-    nbl_glsl_VG_VirtualAttributePacked_t va = InstData.data[drawGUID].determinantSignBit;
+    nbl_glsl_VG_VirtualAttributePacked_t va = batchInstanceData.determinantSignBit;
     return nbl_glsl_VG_attribFetch_RG32_SFLOAT(va,vtxID);
 }