Merge pull request #41 from Devsh-Graphics-Programming/for_merging_half_baked_crap

Bugfixes and some raytracing

Author: devshgraphicsprogramming

examples_tests/18.MitsubaLoader/main.cpp

@@ -31,6 +31,10 @@ struct SLight
 	vec3 intensity;
 };
 
+layout (push_constant) uniform Block {
+    float camTformDeterminant;
+} PC;
+
 layout (set = 2, binding = 0, std430) readonly restrict buffer Lights
 {
 	SLight lights[];
@@ -94,6 +98,29 @@ vec3 nbl_computeLighting(inout nbl_glsl_AnisotropicViewSurfaceInteraction out_in
 	return color+emissive;
 }
 )";
+constexpr const char* GLSL_FRAG_MAIN = R"(
+#define _NBL_FRAG_MAIN_DEFINED_
+void main()
+{
+	mat2 dUV = mat2(dFdx(UV),dFdy(UV));
+
+	// "The sign of this computation is negated when the value of GL_CLIP_ORIGIN (the clip volume origin, set with glClipControl) is GL_UPPER_LEFT."
+	const bool front = (!gl_FrontFacing) != (PC.camTformDeterminant*InstData.data[InstanceIndex].determinant < 0.0);
+	nbl_glsl_MC_precomputed_t precomp = nbl_glsl_precomputeData(front);
+#ifdef TEX_PREFETCH_STREAM
+	nbl_glsl_runTexPrefetchStream(getTexPrefetchStream(precomp), UV, dUV);
+#endif
+#ifdef NORM_PRECOMP_STREAM
+	nbl_glsl_runNormalPrecompStream(getNormalPrecompStream(precomp), dUV, precomp);
+#endif
+
+
+	nbl_glsl_IsotropicViewSurfaceInteraction inter;
+	vec3 color = nbl_computeLighting(inter, dUV, precomp);
+
+	OutColor = vec4(color, 1.0);
+}
+)";
 static core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedFragShader(const asset::ICPUSpecializedShader* _fs, uint32_t viewport_w, uint32_t viewport_h, uint32_t lightCnt, uint32_t smplCnt, float intensityScale)
 {
     const asset::ICPUShader* unspec = _fs->getUnspecialized();
@@ -110,6 +137,7 @@ static core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedFragSh
 		GLSL_COMPUTE_LIGHTING;
 
     glsl.insert(glsl.find("#ifndef _NBL_COMPUTE_LIGHTING_DEFINED_"), extra);
+	glsl.insert(glsl.find("#ifndef _NBL_FRAG_MAIN_DEFINED_"), GLSL_FRAG_MAIN);
 
     //auto* f = fopen("fs.glsl","w");
     //fwrite(glsl.c_str(), 1, glsl.size(), f);
@@ -273,9 +301,9 @@ int main()
 		return 1;
 
 	bool leftHandedCamera = false;
+	auto cameraTransform = sensor.transform.matrix.extractSub3x4();
 	{
-		auto relativeTransform = sensor.transform.matrix.extractSub3x4();
-		if (relativeTransform.getPseudoDeterminant().x < 0.f)
+		if (cameraTransform.getPseudoDeterminant().x < 0.f)
 			leftHandedCamera = true;
 	}
 
@@ -429,7 +457,13 @@ int main()
 		//modify pipeline layouts with our custom DS2 layout (DS2 will be used for lights buffer)
 		for (uint32_t i = 0u; i < mesh->getMeshBufferCount(); ++i)
 		{
-			auto* pipeline = mesh->getMeshBuffer(i)->getPipeline();
+			auto* meshbuffer = mesh->getMeshBuffer(i);
+			auto* pipeline = meshbuffer->getPipeline();
+
+			asset::SPushConstantRange pcr;
+			pcr.offset = 0u;
+			pcr.size = sizeof(float);
+			pcr.stageFlags = asset::ISpecializedShader::ESS_FRAGMENT;
 			if (modifiedPipelines.find(pipeline) == modifiedPipelines.end())
 			{
 				//if (!pipeline->getLayout()->getDescriptorSetLayout(2u))
@@ -443,10 +477,14 @@ int main()
 					modifiedShaders.insert({ core::smart_refctd_ptr<asset::ICPUSpecializedShader>(fs),newfs });
 					pipeline->setShaderAtStage(asset::ICPUSpecializedShader::ESS_FRAGMENT, newfs.get());
 				}
-				// invert what is recognized as frontface in case of RH camera
-				pipeline->getRasterizationParams().frontFaceIsCCW = !leftHandedCamera;
+
+				auto pc = core::make_refctd_dynamic_array<core::smart_refctd_dynamic_array<asset::SPushConstantRange>>(1u);
+				(*pc)[0] = pcr;
+				pipeline->getLayout()->setPushConstantRanges(std::move(pc));
 				modifiedPipelines.insert(pipeline);
 			}
+
+			reinterpret_cast<float*>(meshbuffer->getPushConstantsDataPtr() + pcr.offset)[0] = cameraTransform.getPseudoDeterminant().x;
 		}
 	}
 	modifiedShaders.clear();
@@ -728,7 +766,7 @@ int main()
 				const video::IGPUDescriptorSet* ds[3]{ gpuds0.get(), gpuds1.get(), gpuds2.get() };
 				driver->bindGraphicsPipeline(pipeline);
 				driver->bindDescriptorSets(video::EPBP_GRAPHICS, pipeline->getLayout(), 0u, 3u, ds, nullptr);
-				driver->pushConstants(pipeline->getLayout(), video::IGPUSpecializedShader::ESS_VERTEX|video::IGPUSpecializedShader::ESS_FRAGMENT, 0u, sizeof(uint32_t), mb->getPushConstantsDataPtr());
+				driver->pushConstants(pipeline->getLayout(), video::IGPUSpecializedShader::ESS_VERTEX|video::IGPUSpecializedShader::ESS_FRAGMENT, 0u, sizeof(float), mb->getPushConstantsDataPtr());
 
 				driver->drawMeshBuffer(mb);
 			}

examples_tests/22.RaytracedAO/common.glsl

@@ -19,6 +19,7 @@
 	{
 		float x,y,z;
 	};
+	#define vec4 nbl::core::vectorSIMDf
 	#define mat4 nbl::core::matrix4SIMD
 	#define mat4x3 nbl::core::matrix3x4SIMD
 #endif

examples_tests/22.RaytracedAO/cull.comp

@@ -4,21 +4,18 @@
 #include "drawCommon.glsl"
 layout(local_size_x = WORKGROUP_SIZE) in;
 
+#include <nbl/builtin/glsl/ext/MitsubaLoader/instance_data_descriptor.glsl>
 
 #include <nbl/builtin/glsl/utils/indirect_commands.glsl>
-layout(set=1, binding=0, std430, row_major) restrict readonly buffer PerInstanceStatic
-{
-    ObjectStaticData_t staticData[];
-};
-layout(set=1, binding=1, row_major) writeonly restrict buffer PerInstancePerCamera
+layout(set=1, binding=0, row_major) writeonly restrict buffer PerInstancePerCamera
 {
     DrawData_t data[];
 } instanceDataPerCamera;
-layout(set=1, binding=2, std430, row_major) restrict readonly buffer PerInstanceCull
+layout(set=1, binding=1, std430, row_major) restrict readonly buffer PerInstanceCull
 {
     CullData_t cullData[];
 };
-layout(set=1, binding=3, std430) restrict coherent buffer IndirectDraws
+layout(set=1, binding=2, std430) restrict coherent buffer IndirectDraws
 {
     nbl_glsl_DrawElementsIndirectCommand_t draws[];
 } commandBuff[2];
@@ -40,33 +37,36 @@ layout(push_constant, row_major) uniform PushConstants
 // we just do atomic add on the instance count
 void main()
 {
-    uint globalObjectID = gl_GlobalInvocationID.x;
-    if (globalObjectID>=pc.data.maxObjectCount)
+    if (gl_GlobalInvocationID.x<pc.data.maxDrawCount)
+        commandBuff[pc.data.currentCommandBufferIx^0x1u].draws[gl_GlobalInvocationID.x].instanceCount = 0u;
+
+    uint instanceMeshBufferID = gl_GlobalInvocationID.x;
+    if (instanceMeshBufferID>=pc.data.maxObjectCount)
         return;
 
-    const mat4x3 worldMatrix = cullData[globalObjectID].worldMatrix;
-    const uint drawID = cullData[globalObjectID].drawID;
+    // fetch instance data
+    const CullData_t instanceMeshBufferData = cullData[instanceMeshBufferID];
+    const uint globalObjectID = instanceMeshBufferData.globalObjectID;
 
-    // clear drawcount for next buffer
-    commandBuff[pc.data.currentCommandBufferIx^0x1u].draws[drawID].instanceCount = 0u;
+    const mat4x3 worldMatrix = InstData.data[globalObjectID].tform;
+    const mat4 MVP = nbl_glsl_pseudoMul4x4with4x3(pc.data.viewProjMatrix,worldMatrix);
 
     // cull
-    const mat4 MVP = nbl_glsl_pseudoMul4x4with4x3(pc.data.viewProjMatrix,worldMatrix);
-    bool notCulled = true;
-    if (false)
+    bool notCulled;
     {
-        mat2x3 bbox;
-        bbox[0] = cullData[globalObjectID].aabbMinEdge;
-        bbox[1] = cullData[globalObjectID].aabbMaxEdge;
+        const mat2x3 bbox = mat2x3(instanceMeshBufferData.aabbMinEdge,instanceMeshBufferData.aabbMaxEdge);
         notCulled = nbl_glsl_couldBeVisible(MVP,bbox);
     }
 
+    // set up MDI
     if (notCulled)
     {        
-        const uint instanceID = atomicAdd(commandBuff[pc.data.currentCommandBufferIx].draws[drawID].instanceCount,1u)+cullData[globalObjectID].baseInstance;
+        const uint drawID = instanceMeshBufferData.drawID;
+        const uint drawInstanceID = atomicAdd(commandBuff[pc.data.currentCommandBufferIx].draws[drawID].instanceCount,1u)
+                                                    +commandBuff[pc.data.currentCommandBufferIx].draws[drawID].baseInstance;
 
-        instanceDataPerCamera.data[instanceID].MVP = MVP;
-        instanceDataPerCamera.data[instanceID].detMVP = pc.data.viewProjDeterminant*staticData[globalObjectID].detWorldMatrix;
-        instanceDataPerCamera.data[instanceID].objectID = globalObjectID;
+        instanceDataPerCamera.data[drawInstanceID].MVP = MVP;
+        float detMVP = pc.data.viewProjDeterminant*InstData.data[globalObjectID].determinant;
+        instanceDataPerCamera.data[drawInstanceID].backfacingBit_objectID = globalObjectID|(floatBitsToUint(detMVP)&0x80000000u); // use MSB to denote if face orientation should be flipped
     }
 }