Merge pull request #22 from Crisspl/spirv-optimizer

spirv-opt integration, VK->GL extensions mapping NBL_ defines, material compiler bugfixes

Author: devshgraphicsprogramming

3rdparty/CMakeLists.txt

@@ -447,7 +447,6 @@ if (NBL_COMPILE_WITH_CUDA)
 endif()
 
 set(NBL_3RDPARTY_TARGETS
-				${RADEON_RAYS_DEPENDENTS}
 				lzma
 				lz4
 				aesGladman
@@ -477,6 +476,9 @@ set(NBL_3RDPARTY_TARGETS
 if (NBL_BUILD_MITSUBA_LOADER)
 	list(APPEND NBL_3RDPARTY_TARGETS expat)
 endif()
+if (NBL_BUILD_RADEON_RAYS)
+	list(APPEND NBL_3RDPARTY_TARGETS ${RADEON_RAYS_DEPENDENTS})
+endif()
 if(ENABLE_HLSL)
 	list(APPEND NBL_3RDPARTY_TARGETS HLSL)
 endif()

examples_tests/18.MitsubaLoader/main.cpp

@@ -54,7 +54,7 @@ vec2 SampleSphericalMap(in vec3 v)
     return uv;
 }
 
-vec3 nbl_computeLighting(inout nbl_glsl_IsotropicViewSurfaceInteraction out_interaction, in mat2 dUV, in MC_precomputed_t precomp)
+vec3 nbl_computeLighting(inout nbl_glsl_IsotropicViewSurfaceInteraction out_interaction, in mat2 dUV, in nbl_glsl_MC_precomputed_t precomp)
 {
 	nbl_glsl_xoroshiro64star_state_t scramble_start_state = textureLod(scramblebuf,gl_FragCoord.xy/VIEWPORT_SZ,0).rg;
 
@@ -63,16 +63,16 @@ vec3 nbl_computeLighting(inout nbl_glsl_IsotropicViewSurfaceInteraction out_inte
 	vec3 color = vec3(0.0);
 
 #ifdef USE_ENVMAP
-	instr_stream_t gcs = getGenChoiceStream(precomp);
-	instr_stream_t rnps = getRemAndPdfStream(precomp);
+	nbl_glsl_instr_stream_t gcs = getGenChoiceStream(precomp);
+	nbl_glsl_instr_stream_t rnps = getRemAndPdfStream(precomp);
 	for (int i = 0; i < SAMPLE_COUNT; ++i)
 	{
 		nbl_glsl_xoroshiro64star_state_t scramble_state = scramble_start_state;
 
 		vec3 rand = rand3d(i,scramble_state);
 		float pdf;
 		nbl_glsl_LightSample s;
-		vec3 rem = runGenerateAndRemainderStream(precomp, gcs, rnps, rand, pdf, s);
+		vec3 rem = nbl_glsl_runGenerateAndRemainderStream(precomp, gcs, rnps, rand, pdf, s);
 
 		vec2 uv = SampleSphericalMap(s.L);
 		color += rem*textureLod(envMap, uv, 0.0).xyz;
@@ -260,6 +260,23 @@ int main()
 		params.WindowSize.Width = film.width;
 		params.WindowSize.Height = film.height;
 	}
+	else return 1; // no cameras
+
+	const auto& sensor = globalMeta->sensors.front(); //always choose frist one
+	auto isOkSensorType = [](const ext::MitsubaLoader::CElementSensor& sensor) -> bool {
+		return sensor.type == ext::MitsubaLoader::CElementSensor::Type::PERSPECTIVE || sensor.type == ext::MitsubaLoader::CElementSensor::Type::THINLENS;
+	};
+
+	if (!isOkSensorType(sensor))
+		return 1;
+
+	bool leftHandedCamera = false;
+	{
+		auto relativeTransform = sensor.transform.matrix.extractSub3x4();
+		if (relativeTransform.getPseudoDeterminant().x < 0.f)
+			leftHandedCamera = true;
+	}
+
 	params.DriverType = video::EDT_OPENGL;
 	auto device = createDeviceEx(params);
 
@@ -313,6 +330,7 @@ int main()
 	//gather all meshes into core::vector and modify their pipelines
 	core::vector<core::smart_refctd_ptr<asset::ICPUMesh>> cpumeshes;
 	cpumeshes.reserve(meshes.getSize());
+	uint32_t cc = cpumeshes.capacity();
 	for (auto it = meshes.getContents().begin(); it != meshes.getContents().end(); ++it)
 	{
 		cpumeshes.push_back(core::smart_refctd_ptr_static_cast<asset::ICPUMesh>(std::move(*it)));
@@ -394,7 +412,7 @@ int main()
 		}
 	}
 
-	constexpr uint32_t ENVMAP_SAMPLE_COUNT = 16u;
+	constexpr uint32_t ENVMAP_SAMPLE_COUNT = 64u;
 	constexpr float LIGHT_INTENSITY_SCALE = 0.01f;
 
 	core::unordered_set<const asset::ICPURenderpassIndependentPipeline*> modifiedPipelines;
@@ -418,6 +436,8 @@ 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;
 				modifiedPipelines.insert(pipeline);
 			}
 		}
@@ -442,7 +462,6 @@ int main()
 		}
 	}
 
-	//auto gpuVT = core::make_smart_refctd_ptr<video::IGPUVirtualTexture>(driver, globalMeta->VT.get());
 	auto gpuds0 = driver->getGPUObjectsFromAssets(&cpuds0.get(), &cpuds0.get()+1)->front();
 
     auto gpuds1layout = driver->getGPUObjectsFromAssets(&ds1layout, &ds1layout+1)->front();
@@ -572,28 +591,21 @@ int main()
 	scene::ICameraSceneNode* camera = nullptr;
 	core::recti viewport(core::position2di(0,0), core::position2di(params.WindowSize.Width,params.WindowSize.Height));
 
-	auto isOkSensorType = [](const ext::MitsubaLoader::CElementSensor& sensor) -> bool {
-		return sensor.type==ext::MitsubaLoader::CElementSensor::Type::PERSPECTIVE || sensor.type==ext::MitsubaLoader::CElementSensor::Type::THINLENS;
-	};
 //#define TESTING
 #ifdef TESTING
 	if (0)
 #else
 	if (globalMeta->sensors.size() && isOkSensorType(globalMeta->sensors.front()))
 #endif
 	{
-		const auto& sensor = globalMeta->sensors.front();
 		const auto& film = sensor.film;
 		viewport = core::recti(core::position2di(film.cropOffsetX,film.cropOffsetY), core::position2di(film.cropWidth,film.cropHeight));
 
 		auto extent = sceneBound.getExtent();
 		camera = smgr->addCameraSceneNodeFPS(nullptr,100.f,core::min(extent.X,extent.Y,extent.Z)*0.0001f);
 		// need to extract individual components
-		bool leftHandedCamera = false;
 		{
 			auto relativeTransform = sensor.transform.matrix.extractSub3x4();
-			if (relativeTransform.getPseudoDeterminant().x < 0.f)
-				leftHandedCamera = true;
 
 			auto pos = relativeTransform.getTranslation();
 			camera->setPosition(pos.getAsVector3df());
@@ -697,7 +709,7 @@ int main()
 		uboData.NormalMat[11] = camera->getPosition().Z;
 		driver->updateBufferRangeViaStagingBuffer(gpuubo.get(), 0u, sizeof(uboData), &uboData);
 
-		for (uint32_t j = 1u; j < gpumeshes->size(); ++j)
+		for (uint32_t j = 0u; j < gpumeshes->size(); ++j)
 		{
 			auto& mesh = (*gpumeshes)[j];
 

examples_tests/22.RaytracedAO/InstanceDataPerCamera.glsl

@@ -3,49 +3,24 @@
 
 #define MAX_ACCUMULATED_SAMPLES (1024*1024)
 
+#define WORKGROUP_SIZE 256
 
 #ifdef __cplusplus
-	#define mat4 nbl::core::matrix4SIMD
-	#define mat4x3 nbl::core::matrix3x4SIMD
-#endif
-
-
-struct SLight
-{
-	#ifdef __cplusplus
-	SLight() : obb() {}
-	SLight(const SLight& other) : obb(other.obb) {}
-	SLight(const nbl::core::aabbox3df& bbox, const nbl::core::matrix3x4SIMD& tform) : SLight()
+	#define uint uint32_t
+	struct uvec2
 	{
-		auto extent = bbox.getExtent();
-		obb.setScale(nbl::core::vectorSIMDf(extent.X,extent.Y,extent.Z));
-		obb.setTranslation(nbl::core::vectorSIMDf(bbox.MinEdge.X,bbox.MinEdge.Y,bbox.MinEdge.Z));
-
-		obb = nbl::core::concatenateBFollowedByA(tform,obb);
-	}
-	
-	inline SLight& operator=(SLight&& other) noexcept
+		uint32_t x,y;
+	};
+	struct vec2
 	{
-		std::swap(obb, other.obb);
-
-		return *this;
-	}
-
-	// also known as an upper bound on lumens put into the scene
-	inline float computeFluxBound(const nbl::core::vectorSIMDf& radiance) const
+		float x,y;
+	};
+	struct vec3
 	{
-		const nbl::core::vectorSIMDf rec709LumaCoeffs(0.2126f, 0.7152f, 0.0722f, 0.f);
-		const auto unitHemisphereArea = 2.f*nbl::core::PI<float>();
-				
-		const auto unitBoxScale = obb.getScale();
-		const float obbArea = 2.f*(unitBoxScale.x*unitBoxScale.y+unitBoxScale.x*unitBoxScale.z+unitBoxScale.y*unitBoxScale.z);
-				
-		return nbl::core::dot(radiance,rec709LumaCoeffs).x*unitHemisphereArea*obbArea;
-	}
-	#endif
-
-	mat4x3 obb; // needs row_major qualifier
-};
-
+		float x,y,z;
+	};
+	#define mat4 nbl::core::matrix4SIMD
+	#define mat4x3 nbl::core::matrix3x4SIMD
+#endif
 
 #endif

examples_tests/22.RaytracedAO/bin/screenshot.png

@@ -0,0 +1,72 @@
+#version 430 core
+
+
+#include "drawCommon.glsl"
+layout(local_size_x = WORKGROUP_SIZE) in;
+
+
+#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
+{
+    DrawData_t data[];
+} instanceDataPerCamera;
+layout(set=1, binding=2, std430, row_major) restrict readonly buffer PerInstanceCull
+{
+    CullData_t cullData[];
+};
+layout(set=1, binding=3, std430) restrict coherent buffer IndirectDraws
+{
+    nbl_glsl_DrawElementsIndirectCommand_t draws[];
+} commandBuff[2];
+
+
+
+layout(push_constant, row_major) uniform PushConstants
+{
+    CullShaderData_t data;
+} pc;
+
+
+
+#include <nbl/builtin/glsl/utils/culling.glsl>
+#include <nbl/builtin/glsl/utils/transform.glsl>
+
+
+// base instance remains unchanged
+// we just do atomic add on the instance count
+void main()
+{
+    uint globalObjectID = gl_GlobalInvocationID.x;
+    if (globalObjectID>=pc.data.maxObjectCount)
+        return;
+
+    const mat4x3 worldMatrix = cullData[globalObjectID].worldMatrix;
+    const uint drawID = cullData[globalObjectID].drawID;
+
+    // clear drawcount for next buffer
+    commandBuff[pc.data.currentCommandBufferIx^0x1u].draws[drawID].instanceCount = 0u;
+
+    // cull
+    const mat4 MVP = nbl_glsl_pseudoMul4x4with4x3(pc.data.viewProjMatrix,worldMatrix);
+    bool notCulled = true;
+    if (false)
+    {
+        mat2x3 bbox;
+        bbox[0] = cullData[globalObjectID].aabbMinEdge;
+        bbox[1] = cullData[globalObjectID].aabbMaxEdge;
+        notCulled = nbl_glsl_couldBeVisible(MVP,bbox);
+    }
+
+    if (notCulled)
+    {        
+        const uint instanceID = atomicAdd(commandBuff[pc.data.currentCommandBufferIx].draws[drawID].instanceCount,1u)+cullData[globalObjectID].baseInstance;
+        
+        instanceDataPerCamera.data[instanceID].MVP = MVP;
+        instanceDataPerCamera.data[instanceID].detMVP = pc.data.viewProjDeterminant*staticData[globalObjectID].detWorldMatrix;
+        instanceDataPerCamera.data[instanceID].objectID = globalObjectID;
+    }
+}