Merge pull request #111 from Przemog1/mp

Mesh packer V2

Author: devshgraphicsprogramming

3rdparty/CMakeLists.txt

@@ -416,7 +416,8 @@ if (NBL_BUILD_RADEON_RAYS)
 	option(RR_NO_TESTS "RADEON_RAYS: don't do tests" ON)
 	option(RR_ENABLE_STATIC "RADEON_RAYS: compile into a static library" ON)
 	option(RR_EMBED_KERNELS "RADEON_RAYS: so we don't have to go looking for OpenCL kernel code" ON)
-	option(RR_USE_VULKAN "RADEON_RAYS: use Vulkan (only if you have RR 3.0)" OFF)
+	set(RR_USE_VULKAN OFF CACHE BOOL "RADEON_RAYS: Cannot use Vulkan for RR 2.0 the backend is broken" FORCE)
+	set(RR_ENABLE_BACKFACE_CULL OFF CACHE BOOL "RADEON_RAYS: Don't enable backface culling (we use the memory of the ray struct for something else there)." FORCE)
 	set(MSVC_USE_STATIC_CRT ON CACHE BOOL "Use /MT flag (static CRT) when compiling in MSVC")
 	add_subdirectory(radeonrays EXCLUDE_FROM_ALL)
 

examples_tests/18.MitsubaLoader/main.cpp

@@ -105,7 +105,7 @@ 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);
+	const bool front = bool((InstData.data[InstanceIndex].determinantSignBit^mix(~0u,0u,gl_FrontFacing!=PC.camTformDeterminant<0.0))&0x80000000u);
 	precomp = nbl_glsl_MC_precomputeData(front);
 	material = nbl_glsl_MC_material_data_t_getOriented(InstData.data[InstanceIndex].material,precomp.frontface);
 #ifdef TEX_PREFETCH_STREAM

examples_tests/22.RaytracedAO/Renderer.cpp

@@ -19,22 +19,18 @@
 class Renderer : public nbl::core::IReferenceCounted, public nbl::core::InterfaceUnmovable
 {
     public:
-		#include "drawCommon.glsl"
-		#include "raytraceCommon.glsl"
+		#include "rasterizationCommon.h"
+		#include "raytraceCommon.h"
 		#ifdef __cplusplus
 			#undef uint
+			#undef vec4
 			#undef mat4
 			#undef mat4x3
 		#endif
 
-		// No 8k yet, too many rays to store
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t MaxResolution[2] = {7680/2,4320/2};
-
-
 		Renderer(nbl::video::IVideoDriver* _driver, nbl::asset::IAssetManager* _assetManager, nbl::scene::ISceneManager* _smgr, bool useDenoiser = true);
 
-		void init(	const nbl::asset::SAssetBundle& meshes, nbl::core::smart_refctd_ptr<nbl::asset::ICPUBuffer>&& sampleSequence,
-					uint32_t rayBufferSize=(sizeof(::RadeonRays::ray)+sizeof(::RadeonRays::Intersection))*2u*MaxResolution[0]*MaxResolution[1]); // 2 samples for MIS, TODO: compute default buffer size
+		void init(const nbl::asset::SAssetBundle& meshes, nbl::core::smart_refctd_ptr<nbl::asset::ICPUBuffer>&& sampleSequence);
 
 		void deinit();
 
@@ -47,7 +43,7 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		uint64_t getTotalSamplesComputed() const
 		{
 			const auto samplesPerDispatch = static_cast<uint64_t>(m_staticViewData.samplesPerRowPerDispatch*m_staticViewData.imageDimensions.y);
-			const auto framesDispatched = static_cast<uint64_t>(m_raytraceCommonData.framesDispatched);
+			const auto framesDispatched = static_cast<uint64_t>(m_framesDispatched);
 			return framesDispatched*samplesPerDispatch;
 		}
 
@@ -59,7 +55,7 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 
 		struct InitializationData
 		{
-			InitializationData() : lights(),lightRadiances(),lightCDF(),globalMeta(nullptr) {}
+			InitializationData() : mdiFirstIndices(), lights(),lightRadiances(),lightCDF(),globalMeta(nullptr) {}
 			InitializationData(InitializationData&& other) : InitializationData()
 			{
 				operator=(std::move(other));
@@ -68,14 +64,15 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 
 			inline InitializationData& operator=(InitializationData&& other)
 			{
+				mdiFirstIndices = std::move(other.mdiFirstIndices);
 				lights = std::move(other.lights);
 				lightRadiances = std::move(other.lightRadiances);
 				lightCDF = std::move(other.lightCDF);
 				globalMeta = other.globalMeta;
 				return *this;
 			}
 
-
+			nbl::core::vector<uint32_t> mdiFirstIndices;
 			nbl::core::vector<SLight> lights;
 			nbl::core::vector<nbl::core::vectorSIMDf> lightRadiances;
 			union
@@ -89,7 +86,9 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		void initSceneNonAreaLights(InitializationData& initData);
 		void finalizeScene(InitializationData& initData);
 
-		nbl::core::smart_refctd_ptr<nbl::video::IGPUImageView> createScreenSizedTexture(nbl::asset::E_FORMAT format);
+		nbl::core::smart_refctd_ptr<nbl::video::IGPUImageView> createScreenSizedTexture(nbl::asset::E_FORMAT format, uint32_t layers = 0u);
+
+		void traceBounce();
 
 
 		// "constants"
@@ -111,33 +110,27 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 
 		// persistent (intialized in constructor
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSetLayout> m_cullDSLayout;
-
-		nbl::core::smart_refctd_ptr<nbl::asset::ICPUSpecializedShader> m_visibilityBufferFillShaders[2];
-		nbl::core::smart_refctd_ptr<nbl::asset::ICPUPipelineLayout> m_visibilityBufferFillPipelineLayoutCPU;
-		nbl::core::smart_refctd_ptr<nbl::video::IGPUPipelineLayout> m_visibilityBufferFillPipelineLayoutGPU;
-		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSetLayout> m_perCameraRasterDSLayout;
-
-		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSetLayout> m_commonRaytracingDSLayout, m_raygenDSLayout, m_resolveDSLayout;
+		nbl::core::smart_refctd_ptr<const nbl::video::IGPUDescriptorSetLayout> m_perCameraRasterDSLayout;
+		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSetLayout> m_rasterInstanceDataDSLayout,m_additionalGlobalDSLayout,m_commonRaytracingDSLayout,m_raygenDSLayout,m_resolveDSLayout;
+		nbl::core::smart_refctd_ptr<nbl::video::IGPURenderpassIndependentPipeline> m_visibilityBufferFillPipeline;
 
 
 		// scene specific data
-		nbl::ext::RadeonRays::MockSceneManager m_mock_smgr;
-		nbl::ext::RadeonRays::Manager::MeshBufferRRShapeCache rrShapeCache;
-		nbl::ext::RadeonRays::Manager::NblInstanceRRInstanceCache rrInstances;
+		nbl::core::vector<::RadeonRays::Shape*> rrShapes;
+		nbl::core::vector<::RadeonRays::Shape*> rrInstances;
 
 		nbl::core::matrix3x4SIMD m_prevView;
 		nbl::core::aabbox3df m_sceneBound;
 		uint32_t m_maxRaysPerDispatch;
+		uint32_t m_framesDispatched;
 		StaticViewData_t m_staticViewData;
 		RaytraceShaderCommonData_t m_raytraceCommonData;
 
+		nbl::core::smart_refctd_ptr<nbl::video::IGPUBuffer> m_indexBuffer;
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUBuffer> m_indirectDrawBuffers[2];
 		struct MDICall
 		{
-			nbl::asset::SBufferBinding<const nbl::video::IGPUBuffer> vertexBindings[nbl::video::IGPUMeshBuffer::MAX_ATTR_BUF_BINDING_COUNT];
-			nbl::core::smart_refctd_ptr<const nbl::video::IGPUBuffer> indexBuffer;
-			nbl::core::smart_refctd_ptr<const nbl::video::IGPURenderpassIndependentPipeline> pipeline;
-			uint32_t mdiOffset, mdiCount;
+			uint32_t mdiOffset,mdiCount;
 		};
 		nbl::core::vector<MDICall> m_mdiDrawCalls;
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSet> m_cullDS;
@@ -148,21 +141,21 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUPipelineLayout> m_cullPipelineLayout, m_raygenPipelineLayout, m_resolvePipelineLayout;
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUComputePipeline> m_cullPipeline, m_raygenPipeline, m_resolvePipeline;
-		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSet> m_globalBackendDataDS,m_commonRaytracingDS,m_raygenDS;
+		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSet> m_globalBackendDataDS,m_rasterInstanceDataDS,m_additionalGlobalDS,m_commonRaytracingDS,m_raygenDS;
 		uint32_t m_raygenWorkGroups[2];
 
 		struct InteropBuffer
 		{
 			nbl::core::smart_refctd_ptr<nbl::video::IGPUBuffer> buffer;
 			std::pair<::RadeonRays::Buffer*, cl_mem> asRRBuffer = { nullptr,0u };
 		};
-		InteropBuffer m_rayCountBuffer,m_rayBuffer,m_intersectionBuffer;
+		InteropBuffer m_rayCountBuffer[2];
+		InteropBuffer m_rayBuffer,m_intersectionBuffer;
 
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUDescriptorSet> m_resolveDS;
-		uint32_t m_resolveWorkGroups[2];
 
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUImageView> m_accumulation,m_tonemapOutput;
-		nbl::video::IFrameBuffer* m_visibilityBuffer,* m_colorBuffer,* tmpTonemapBuffer;
+		nbl::video::IFrameBuffer* m_visibilityBuffer,* m_colorBuffer;
 
 	#ifdef _NBL_BUILD_OPTIX_
 		nbl::core::smart_refctd_ptr<nbl::ext::OptiX::IDenoiser> m_denoiser;

examples_tests/22.RaytracedAO/Renderer.h

@@ -1,15 +1,19 @@
 #ifndef _COMMON_INCLUDED_
 #define _COMMON_INCLUDED_
 
-#define MAX_ACCUMULATED_SAMPLES (1024*1024)
+
+#define MAX_TRIANGLES_IN_BATCH 512
+#define MAX_ACCUMULATED_SAMPLES 0x10000
+
 
 #define WORKGROUP_SIZE 256
 
+
 #ifdef __cplusplus
 	#define uint uint32_t
 	struct uvec2
 	{
-		uint32_t x,y;
+		uint x,y;
 	};
 	struct vec2
 	{
@@ -24,4 +28,5 @@
 	#define mat4x3 nbl::core::matrix3x4SIMD
 #endif
 
+
 #endif

examples_tests/22.RaytracedAO/common.glsl renamed to examples_tests/22.RaytracedAO/common.h

@@ -1,7 +1,6 @@
 #version 430 core
 
-
-#include "drawCommon.glsl"
+#include "rasterizationCommon.h"
 layout(local_size_x = WORKGROUP_SIZE) in;
 
 #include <nbl/builtin/glsl/ext/MitsubaLoader/instance_data_descriptor.glsl>
@@ -37,36 +36,39 @@ layout(push_constant, row_major) uniform PushConstants
 // we just do atomic add on the instance count
 void main()
 {
-    if (gl_GlobalInvocationID.x<pc.data.maxDrawCount)
-        commandBuff[pc.data.currentCommandBufferIx^0x1u].draws[gl_GlobalInvocationID.x].instanceCount = 0u;
+    for (uint drawCommandGUID=gl_GlobalInvocationID.x; drawCommandGUID<pc.data.maxDrawCommandCount; drawCommandGUID+=gl_NumWorkGroups.x*WORKGROUP_SIZE)
+        commandBuff[pc.data.currentCommandBufferIx^0x1u].draws[drawCommandGUID].instanceCount = 0u;
 
-    uint instanceMeshBufferID = gl_GlobalInvocationID.x;
-    if (instanceMeshBufferID>=pc.data.maxObjectCount)
+    uint batchInstanceID = gl_GlobalInvocationID.x;
+    if (batchInstanceID>=pc.data.maxGlobalInstanceCount)
         return;
 
     // fetch instance data
-    const CullData_t instanceMeshBufferData = cullData[instanceMeshBufferID];
-    const uint globalObjectID = instanceMeshBufferData.globalObjectID;
+    const CullData_t batchInstanceData = cullData[batchInstanceID];
+    const uint batchInstanceGUID = batchInstanceData.batchInstanceGUID;
 
-    const mat4x3 worldMatrix = InstData.data[globalObjectID].tform;
+    const nbl_glsl_ext_Mitsuba_Loader_instance_data_t instanceData = InstData.data[batchInstanceGUID];
+    const mat4x3 worldMatrix = InstData.data[batchInstanceGUID].tform;
     const mat4 MVP = nbl_glsl_pseudoMul4x4with4x3(pc.data.viewProjMatrix,worldMatrix);
 
     // cull
-    bool notCulled;
+    bool notCulled = true;
+    if (false)
     {
-        const mat2x3 bbox = mat2x3(instanceMeshBufferData.aabbMinEdge,instanceMeshBufferData.aabbMaxEdge);
+        const mat2x3 bbox = mat2x3(batchInstanceData.aabbMinEdge,batchInstanceData.aabbMaxEdge);
         notCulled = nbl_glsl_couldBeVisible(MVP,bbox);
     }
 
     // set up MDI
     if (notCulled)
     {        
-        const uint drawID = instanceMeshBufferData.drawID;
-        const uint drawInstanceID = atomicAdd(commandBuff[pc.data.currentCommandBufferIx].draws[drawID].instanceCount,1u)
-                                                    +commandBuff[pc.data.currentCommandBufferIx].draws[drawID].baseInstance;
+        const uint drawCommandGUID = batchInstanceData.drawCommandGUID;
+        const uint drawInstanceID = commandBuff[pc.data.currentCommandBufferIx].draws[drawCommandGUID].baseInstance+
+            atomicAdd(commandBuff[pc.data.currentCommandBufferIx].draws[drawCommandGUID].instanceCount,1u);
 
         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
+        // use the MSB to denote if face orientation should be flipped
+        instanceDataPerCamera.data[drawInstanceID].backfacingBit_batchInstanceGUID = batchInstanceGUID|((instanceData.determinantSignBit^floatBitsToUint(pc.data.viewProjDeterminant))&0x80000000u);
+        instanceDataPerCamera.data[drawInstanceID].firstIndex = commandBuff[pc.data.currentCommandBufferIx].draws[drawCommandGUID].firstIndex;
     }
 }

examples_tests/22.RaytracedAO/cull.comp

@@ -1,24 +1,36 @@
 // Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
-
 #version 430 core
+#extension GL_EXT_shader_16bit_storage : require
+
 
-#include <nbl/builtin/glsl/utils/normal_encode.glsl>
+#define _NBL_GLSL_EXT_MITSUBA_LOADER_INSTANCE_DATA_BINDING_ 0
+#include "virtualGeometry.glsl"
 
 
-layout(location = 0) flat in uint BackfacingBit_ObjectID;
-layout(location = 1) in vec3 Normal;
-layout(location = 2) in vec2 UV;
+#include <nbl/builtin/glsl/barycentric/frag.glsl>
+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)
+{
+    const uint ix = nbl_glsl_VG_fetchTriangleVertexIndex(primID*3u+drawCmdFirstIndex,primsVx);
+    return nbl_glsl_fetchVtxPos(ix,drawID);
+}
+
+
+layout(location = 0) out uvec4 frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2; // should it be called backfacing or frontfacing?
 
-layout(location = 0) out uvec2 frontFacing_Object_Triangle; // should it be called backfacing or frontfacing?
-layout(location = 1) out vec2 encodedNormal;
-layout(location = 2) out vec2 uv;
 
 void main()
-{		
-	frontFacing_Object_Triangle = uvec2(BackfacingBit_ObjectID^(gl_FrontFacing ? 0x0u:0x80000000u),gl_PrimitiveID);
-	// TODO: these will disappear once we finally have MeshPackerV2 and settle on a way to obtain barycentrics
-	encodedNormal = nbl_glsl_NormalEncode_signedSpherical(normalize(Normal));
-	uv = UV;
+{
+    vec2 bary = nbl_glsl_barycentric_frag_get();
+
+    const int triangleIDBitcount = findMSB(MAX_TRIANGLES_IN_BATCH-1)+1;
+	frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2[0] = bitfieldInsert(gl_PrimitiveID,BackfacingBit_BatchInstanceGUID^(gl_FrontFacing ? 0x0u:0x80000000u),triangleIDBitcount,32-triangleIDBitcount);
+    frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2[1] = packUnorm2x16(bary);
+    frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2[2] = packHalf2x16(dFdx(bary));
+    frontFacingTriangleIDDrawID_unorm16Bary_dBarydScreenHalf2x2[3] = packHalf2x16(dFdy(bary));
 }

examples_tests/22.RaytracedAO/drawCommon.glsl

@@ -1,29 +1,33 @@
+// Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
 #version 430 core
+#extension GL_EXT_shader_16bit_storage : require
 
-#include "drawCommon.glsl"
-layout(set=1, binding=0, row_major) readonly restrict buffer PerInstancePerCamera
+#include "rasterizationCommon.h"
+
+#define _NBL_GLSL_EXT_MITSUBA_LOADER_INSTANCE_DATA_BINDING_ 0
+#include "virtualGeometry.glsl"
+
+layout(set=2, binding=0, row_major) readonly restrict buffer PerInstancePerCamera
 {
     DrawData_t data[];
 } instanceDataPerCamera;
 
-layout(location = 0) in vec3 vPosition;
-layout(location = 2) in vec2 vUV;
-layout(location = 3) in vec3 vNormal;
-
-layout(location = 0) flat out uint BackfacingBit_ObjectID;
-layout(location = 1) out vec3 Normal;
-layout(location = 2) out vec2 UV;
+#include <nbl/builtin/glsl/barycentric/vert.glsl>
+layout(location = 2) flat out uint BackfacingBit_BatchInstanceGUID;
+layout(location = 3) flat out uint drawCmdFirstIndex;
 
 #include <nbl/builtin/glsl/utils/transform.glsl>
-
 void main()
 {
     DrawData_t self = instanceDataPerCamera.data[gl_InstanceIndex];
-    BackfacingBit_ObjectID = self.backfacingBit_objectID;
+    BackfacingBit_BatchInstanceGUID = self.backfacingBit_batchInstanceGUID;
+    drawCmdFirstIndex = self.firstIndex;
 
-    gl_Position = nbl_glsl_pseudoMul4x4with3x1(self.MVP,vPosition);
+    const uint batchInstanceGUID = self.backfacingBit_batchInstanceGUID&0x7fffffffu;
 
-    Normal = normalize(vNormal);
-	
-    UV = vUV;
+    const vec3 modelPos = nbl_glsl_fetchVtxPos(gl_VertexIndex,batchInstanceGUID);
+    nbl_glsl_barycentric_vert_set(modelPos);
+    gl_Position = nbl_glsl_pseudoMul4x4with3x1(self.MVP,modelPos);
 }