Merge pull request #293 from Devsh-Graphics-Programming/material_compiler_point_light_fixes

Material compiler point light fixes

Author: devshgraphicsprogramming

.gitmodules

@@ -87,7 +87,7 @@
 	url = https://github.com/greg7mdp/parallel-hashmap
 [submodule "3rdparty/radeonrays"]
 	path = 3rdparty/radeonrays
-	url = https://github.com/devshgraphicsprogramming/RadeonRays_SDK.git
+	url = git@github.com:devshgraphicsprogramming/RadeonRays_SDK.git
 	branch = baw
 [submodule "3rdparty/jitify"]
 	path = 3rdparty/jitify

3rdparty/radeonrays

@@ -74,12 +74,11 @@ vec3 nbl_computeLighting(inout nbl_glsl_AnisotropicViewSurfaceInteraction out_in
 		nbl_glsl_xoroshiro64star_state_t scramble_state = scramble_start_state;
 
 		vec3 rand = rand3d(i,scramble_state);
-		float pdf;
 		nbl_glsl_LightSample s;
-		vec3 rem = nbl_glsl_MC_runGenerateAndRemainderStream(precomp, gcs, rnps, rand, pdf, s);
+		nbl_glsl_MC_quot_pdf_aov_t rem = nbl_glsl_MC_runGenerateAndRemainderStream(precomp, gcs, rnps, rand, s);
 
 		vec2 uv = SampleSphericalMap(s.L);
-		color += rem*textureLod(envMap, uv, 0.0).xyz;
+		color += rem.quotient*textureLod(envMap, uv, 0.0).xyz;
 	}
 	color /= float(SAMPLE_COUNT);
 #endif

examples_tests/18.MitsubaLoader/main.cpp

@@ -106,6 +106,7 @@ You can switch between those sensors using `PAGE UP/DOWN` Keys defined in more d
 | HOME      | Press to reset the camera to the initial view. (Usefull when you're lost and you want to go back to where you started) |
 | P         | Press to take a snapshot when moving around (will be denoised)                                                         |
 | L         | Press to log the current progress percentage and samples rendered.                                                     |
+| B         | Toggle between Path Tracing and Albedo preview, allows you to position the camera more responsively in complex scenes. |
 
 ## Denoiser Hook
 `denoiser_hook.bat` is a script that you can call to denoise your rendered images.

examples_tests/22.RaytracedAO/README.md

@@ -52,7 +52,7 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 
 		void takeAndSaveScreenShot(const std::filesystem::path& screenshotFilePath, const DenoiserArgs& denoiserArgs);
 
-		bool render(nbl::ITimer* timer);
+		bool render(nbl::ITimer* timer, const bool beauty=true);
 
 		auto* getColorBuffer() { return m_colorBuffer; }
 
@@ -65,11 +65,11 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		uint64_t getTotalSamplesPerPixelComputed() const
 		{
 			const auto framesDispatched = static_cast<uint64_t>(m_framesDispatched);
-			return framesDispatched*m_staticViewData.samplesPerPixelPerDispatch;
+			return framesDispatched*getSamplesPerPixelPerDispatch();
 		}
 		uint64_t getTotalSamplesComputed() const
 		{
-			const auto samplesPerDispatch = static_cast<uint64_t>(m_staticViewData.samplesPerPixelPerDispatch*m_staticViewData.imageDimensions.x*m_staticViewData.imageDimensions.y);
+			const auto samplesPerDispatch = static_cast<uint64_t>(getSamplesPerPixelPerDispatch()*m_staticViewData.imageDimensions.x*m_staticViewData.imageDimensions.y);
 			const auto framesDispatched = static_cast<uint64_t>(m_framesDispatched);
 			return framesDispatched*samplesPerDispatch;
 		}
@@ -78,16 +78,11 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 			return m_totalRaysCast;
 		}
 
-		//! Brief guideline to good path depth limits
-		// Want to see stuff with indirect lighting on the other side of a pane of glass
-		// 5 = glass frontface->glass backface->diffuse surface->diffuse surface->light
-		// Want to see through a glass box, vase, or office 
-		// 7 = glass frontface->glass backface->glass frontface->glass backface->diffuse surface->diffuse surface->light
-		// pick higher numbers for better GI and less bias
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t MaxPathDepth = 8u;
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t RandomDimsPerPathVertex = 3u;
-		// one less because the first path vertex is rasterized
-		_NBL_STATIC_INLINE_CONSTEXPR uint32_t MaxDimensions = RandomDimsPerPathVertex*(MaxPathDepth-1u);
+		// The primary limiting factor is the precision of turning a fixed point grid sample to IEEE754 32bit float in the [0,1] range.
+		// Mantissa is only 23 bits, and primary sample space low discrepancy sequence will start to produce duplicates
+		// near 1.0 with exponent -1 after the sample count passes 2^24 elements.
+		// Another limiting factor is our encoding of sample sequences, we only use 21bits per channel, so no duplicates till 2^21 samples.
+		static inline constexpr uint32_t MaxSamples = 0x10000u;// 0x200000;
 
 		//
 		static constexpr inline uint32_t AntiAliasingSequenceLength = 1024;
@@ -126,7 +121,8 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUImageView> createScreenSizedTexture(nbl::asset::E_FORMAT format, uint32_t layers = 0u);
 
 		//
-		bool Renderer::traceBounce(uint32_t & inoutRayCount);
+		void preDispatch(const nbl::video::IGPUPipelineLayout* layout, nbl::video::IGPUDescriptorSet*const *const lastDS);
+		bool traceBounce(uint32_t& inoutRayCount);
 
 		//
 		const nbl::ext::MitsubaLoader::CMitsubaMetadata* m_globalMeta = nullptr;
@@ -141,11 +137,6 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		nbl::scene::ISceneManager* m_smgr;
 
 		nbl::core::smart_refctd_ptr<nbl::ext::RadeonRays::Manager> m_rrManager;
-#ifdef _NBL_BUILD_OPTIX_
-		nbl::core::smart_refctd_ptr<nbl::ext::OptiX::Manager> m_optixManager;
-		CUstream m_cudaStream;
-		nbl::core::smart_refctd_ptr<nbl::ext::OptiX::IContext> m_optixContext;
-#endif
 
 
 		// persistent (intialized in constructor
@@ -219,22 +210,6 @@ class Renderer : public nbl::core::IReferenceCounted, public nbl::core::Interfac
 		nbl::core::smart_refctd_ptr<nbl::video::IGPUImageView> m_finalEnvmap;
 
 		std::future<bool> compileShadersFuture;
-
-	#ifdef _NBL_BUILD_OPTIX_
-		nbl::core::smart_refctd_ptr<nbl::ext::OptiX::IDenoiser> m_denoiser;
-		OptixDenoiserSizes m_denoiserMemReqs;
-		nbl::cuda::CCUDAHandler::GraphicsAPIObjLink<nbl::video::IGPUBuffer> m_denoiserInputBuffer,m_denoiserStateBuffer,m_denoisedBuffer,m_denoiserScratchBuffer;
-
-		enum E_DENOISER_INPUT
-		{
-			EDI_COLOR,
-			EDI_ALBEDO,
-			EDI_NORMAL,
-			EDI_COUNT
-		};
-		OptixImage2D m_denoiserOutput;
-		OptixImage2D m_denoiserInputs[EDI_COUNT];
-	#endif
 };
 
 #endif

examples_tests/22.RaytracedAO/Renderer.cpp

@@ -36,7 +36,6 @@ void main()
 	{
 		// basic reads
 		const uint vertex_depth = get_path_vertex_depth();
-		const uint vertex_depth_mod_2 = vertex_depth&0x1u;
 		const nbl_glsl_ext_RadeonRays_Intersection intersection = intersections[gl_GlobalInvocationID.x];
 		const nbl_glsl_ext_RadeonRays_ray ray = sourceRays[gl_GlobalInvocationID.x];
 
@@ -78,15 +77,19 @@ void main()
 			const nbl_glsl_MC_oriented_material_t material = nbl_glsl_MC_material_data_t_getOriented(batchInstanceData.material,frontfacing);
 			contrib.color = contrib.albedo = nbl_glsl_MC_oriented_material_t_getEmissive(material);
 
-			const bool _continue = vertex_depth!=MAX_PATH_DEPTH && ray.maxT==nbl_glsl_FLT_MAX; // last vertex or was a NEE path
+			const uint pathDepth = bitfieldExtract(staticViewData.pathDepth_noRussianRouletteDepth_samplesPerPixelPerDispatch,0,8);
+			const bool _continue = vertex_depth!=pathDepth && ray.maxT==nbl_glsl_FLT_MAX; // not last vertex and not NEE path
 			if (_continue)
 			{
 				// if we ever support spatially varying emissive, we'll need to hoist barycentric computation and UV fetching to the position fetching
-				const vec2 compactBary = vec2(1.f-intersection.uvwt.x-intersection.uvwt.y,intersection.uvwt.x); // radeon rays is a special boy
+				const vec2 compactBary = vec2(1.f-intersection.uv.x-intersection.uv.y,intersection.uv.x); // radeon rays is a special boy and does its barycentrics weird
 
-				const nbl_glsl_xoroshiro64star_state_t scramble_start_state = load_aux_vertex_attrs(
-					batchInstanceData,indices,compactBary,geomDenormal,
-					material,outPixelLocation,vertex_depth
+				//
+				const nbl_glsl_xoroshiro64star_state_t scramble_start_state = nbl_glsl_xoroshiro64star_state_t(ray.mask,ray._active);
+				
+				//
+				normalizedN = load_normal_and_prefetch_textures(
+					batchInstanceData,indices,compactBary,geomDenormal,material
 #ifdef TEX_PREFETCH_STREAM
 					,mat2(0.0) // TODO: Covariance Rendering
 #endif
@@ -107,7 +110,8 @@ void main()
 
 		Contribution_normalizeAoV(contrib);
 
-		const uvec3 accumulationLocation = uvec3(outPixelLocation,sampleID%staticViewData.samplesPerPixelPerDispatch);
+		const uint samplesPerPixelPerDispatch = bitfieldExtract(staticViewData.pathDepth_noRussianRouletteDepth_samplesPerPixelPerDispatch,16,16);
+		const uvec3 accumulationLocation = uvec3(outPixelLocation,sampleID%samplesPerPixelPerDispatch);
 		const vec3 acc_emissive = fetchAccumulation(accumulationLocation);
 		const vec3 acc_albedo = fetchAlbedo(accumulationLocation);
 		const vec3 acc_worldspaceNormal = fetchWorldspaceNormal(accumulationLocation);

examples_tests/22.RaytracedAO/Renderer.h

@@ -6,7 +6,18 @@
 #define RAYCOUNT_N_BUFFERING_MASK (RAYCOUNT_N_BUFFERING-1)
 
 #define MAX_TRIANGLES_IN_BATCH 16384
-#define MAX_ACCUMULATED_SAMPLES 0x10000
+
+//! Brief guideline to good path depth limits
+// Want to see stuff with indirect lighting on the other side of a pane of glass
+// 5 = glass frontface->glass backface->diffuse surface->diffuse surface->light
+// Want to see through a glass box, vase, or office 
+// 7 = glass frontface->glass backface->glass frontface->glass backface->diffuse surface->diffuse surface->light
+// pick higher numbers for better GI and less bias
+#define MAX_PATH_DEPTH 35
+// need to bump to 2 in case of NEE + MIS, 3 in case of Path Guiding
+#define SAMPLING_STRATEGY_COUNT 1
+// One less because the first vertex is rasterized
+#define QUANTIZED_DIMENSIONS_PER_SAMPLE ((MAX_PATH_DEPTH-1)*SAMPLING_STRATEGY_COUNT)
 
 
 #define WORKGROUP_SIZE 256

examples_tests/22.RaytracedAO/closestHit.comp

@@ -23,14 +23,9 @@ using namespace core;
 class RaytracerExampleEventReceiver : public nbl::IEventReceiver
 {
 	public:
-		RaytracerExampleEventReceiver() 
-			: running(true)
-			, skipKeyPressed(false)
-			, resetViewKeyPressed(false)
-			, nextKeyPressed(false)
-			, previousKeyPressed(false)
-			, screenshotKeyPressed(false)
+		RaytracerExampleEventReceiver() : running(true), renderingBeauty(true)
 		{
+			resetKeys();
 		}
 
 		bool OnEvent(const nbl::SEvent& event)
@@ -57,6 +52,9 @@ class RaytracerExampleEventReceiver : public nbl::IEventReceiver
 					case SkipKey:
 						skipKeyPressed = true;
 						break;
+					case BeautyKey:
+						renderingBeauty = !renderingBeauty;
+						break;
 					case QuitKey:
 						running = false;
 						return true;
@@ -82,6 +80,8 @@ class RaytracerExampleEventReceiver : public nbl::IEventReceiver
 
 		inline bool isLogProgressKeyPressed() const { return logProgressKeyPressed; }
 
+		inline bool isRenderingBeauty() const { return renderingBeauty; }
+
 		inline void resetKeys()
 		{
 			skipKeyPressed = false;
@@ -100,15 +100,17 @@ class RaytracerExampleEventReceiver : public nbl::IEventReceiver
 		static constexpr nbl::EKEY_CODE PreviousKey = nbl::KEY_NEXT; // PAGE_DOWN
 		static constexpr nbl::EKEY_CODE ScreenshotKey = nbl::KEY_KEY_P;
 		static constexpr nbl::EKEY_CODE LogProgressKey = nbl::KEY_KEY_L;
+		static constexpr nbl::EKEY_CODE BeautyKey = nbl::KEY_KEY_B;
 
-		bool running = false;
-		bool skipKeyPressed = false;
-		bool resetViewKeyPressed = false;
-		bool nextKeyPressed = false;
-		bool previousKeyPressed = false;
-		bool screenshotKeyPressed = false;
-		bool logProgressKeyPressed = false;
+		bool running;
+		bool renderingBeauty;
 
+		bool skipKeyPressed;
+		bool resetViewKeyPressed;
+		bool nextKeyPressed;
+		bool previousKeyPressed;
+		bool screenshotKeyPressed;
+		bool logProgressKeyPressed;
 };
 
 int main(int argc, char** argv)
@@ -556,40 +558,47 @@ int main(int argc, char** argv)
 	auto driver = device->getVideoDriver();
 
 	core::smart_refctd_ptr<Renderer> renderer = core::make_smart_refctd_ptr<Renderer>(driver,device->getAssetManager(),smgr);
-	constexpr uint32_t MaxSamples = MAX_ACCUMULATED_SAMPLES;
-	auto sampleSequence = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(uint32_t)*MaxSamples*Renderer::MaxDimensions);
+	auto sampleSequence = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(uint64_t)*Renderer::MaxSamples*QUANTIZED_DIMENSIONS_PER_SAMPLE);
 	{
 		bool generateNewSamples = true;
 
 		io::IReadFile* cacheFile = device->getFileSystem()->createAndOpenFile("../../tmp/rtSamples.bin");
 		if (cacheFile)
 		{
-			if (cacheFile->getSize()>=sampleSequence->getSize()) // light validation
+			if (cacheFile->getSize()==sampleSequence->getSize()) // light validation
 			{
 				cacheFile->read(sampleSequence->getPointer(),sampleSequence->getSize());
-				generateNewSamples = false;
+				//generateNewSamples = false;
 			}
 			cacheFile->drop();
 		}
 
 		if (generateNewSamples)
 		{
-			/** TODO: move into the renderer and redo the sampling (compress into R21G21B21_UINT)
-			Locality Level 0: the 3 dimensions consumed for a BxDF or NEE sample
-			Locality Level 1: the k = 3 (1 + NEE) samples which will be consumed in the same invocation
-			Locality Level 2-COMP: the N = k dispatchSPP Resolution samples consumed by a raygen dispatch (another TODO: would be order CS and everything in a morton curve)
-			Locality Level 2-RTX: the N = k Depth samples consumed as we recurse deeper
-			Locality Level 3: the D = k dispatchSPP Resolution Depth samples consumed as we accumuate more samples
-			**/
-			constexpr uint32_t Channels = 3u;
-			static_assert(Renderer::MaxDimensions%Channels==0u,"We cannot have this!");
-			core::OwenSampler sampler(Renderer::MaxDimensions,0xdeadbeefu);
-
-			uint32_t (&out)[][Channels] = *reinterpret_cast<uint32_t(*)[][Channels]>(sampleSequence->getPointer());
-			for (auto realdim=0u; realdim<Renderer::MaxDimensions/Channels; realdim++)
-			for (auto c=0u; c<Channels; c++)
-			for (uint32_t i=0; i<MaxSamples; i++)
-				out[realdim*MaxSamples+i][c] = sampler.sample(realdim*Channels+c,i);
+			constexpr auto DimensionsPerQuanta = 3u;
+			core::OwenSampler sampler(QUANTIZED_DIMENSIONS_PER_SAMPLE*DimensionsPerQuanta,0xdeadbeefu);
+
+			// Memory Order: 3 Dimensions, then multiple of sampling stragies per vertex, then depth, then sample ID
+			uint32_t(&pout)[][2] = *reinterpret_cast<uint32_t(*)[][2]>(sampleSequence->getPointer());
+			// the horrible order of iteration over output memory is caused by the fact that certain samplers like the 
+			// Owen Scramble sampler, have a large cache which needs to be generated separately for each dimension.
+			for (auto metadim=0u; metadim<QUANTIZED_DIMENSIONS_PER_SAMPLE; metadim++)
+			{
+				const auto trudim = metadim*DimensionsPerQuanta;
+				for (uint32_t i=0; i<Renderer::MaxSamples; i++)
+					pout[i*QUANTIZED_DIMENSIONS_PER_SAMPLE+metadim][0] = sampler.sample(trudim+0u,i);
+				for (uint32_t i=0; i<Renderer::MaxSamples; i++)
+					pout[i*QUANTIZED_DIMENSIONS_PER_SAMPLE+metadim][1] = sampler.sample(trudim+1u,i);
+				for (uint32_t i=0; i<Renderer::MaxSamples; i++)
+				{
+					const auto sample = sampler.sample(trudim+2u,i);
+					const auto out = pout[i*QUANTIZED_DIMENSIONS_PER_SAMPLE+metadim];
+					out[0] &= 0xFFFFF800u;
+					out[0] |= sample>>21;
+					out[1] &= 0xFFFFF800u;
+					out[1] |= (sample>>10)&0x07FFu;
+				}
+			}
 
 			io::IWriteFile* cacheFile = device->getFileSystem()->createAndWriteFile("../../tmp/rtSamples.bin");
 			if (cacheFile)
@@ -659,7 +668,7 @@ int main(int argc, char** argv)
 		prevHeight = sensorData.height;
 
 		renderer->resetSampleAndFrameCounters(); // so that renderer->getTotalSamplesPerPixelComputed is 0 at the very beginning
-		if(needsReinit)
+		if(needsReinit) 
 		{
 			renderer->deinitScreenSizedResources();
 			renderer->initScreenSizedResources(sensorData.width, sensorData.height, std::move(sampleSequence));
@@ -817,8 +826,7 @@ int main(int argc, char** argv)
 			}
 
 			driver->beginScene(false, false);
-			
-			if(!renderer->render(device->getTimer()))
+			if(!renderer->render(device->getTimer(),receiver.isRenderingBeauty()))
 			{
 				renderFailed = true;
 				driver->endScene();
@@ -838,8 +846,10 @@ int main(int argc, char** argv)
 				std::wostringstream str;
 				auto samples = renderer->getTotalSamplesComputed();
 				auto rays = renderer->getTotalRaysCast();
-				str << L"Raytraced Shadows Demo - Nabla Engine   MegaSamples: " << samples/1000000ull << "   MRay/s: "
-					<< double(rays)/double(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now()-start).count());
+				const double microsecondsElapsed = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now()-start).count();
+				str << L"Raytraced Shadows Demo - Nabla Engine   MegaSamples: " << samples/1000000ull
+					<< "   MSample/s: " << double(samples)/microsecondsElapsed
+					<< "   MRay/s: " << double(rays)/microsecondsElapsed;
 
 				device->setWindowCaption(str.str());
 				lastFPSTime = time;