fixed nan and accumulation going black problem

keptsecret · keptsecret · commit 6abb635b5d47 · 2025-03-13T15:56:08.000+07:00
diff --git a/31_HLSLPathTracer/app_resources/hlsl/common.hlsl b/31_HLSLPathTracer/app_resources/hlsl/common.hlsl
@@ -18,7 +18,7 @@ namespace hlsl
 namespace ext
 {
 
-template<typename T>
+template<typename T>    // TODO make type T Spectrum
 struct Payload
 {
     using this_t = Payload<T>;
@@ -85,6 +85,14 @@ struct Light
 
     NBL_CONSTEXPR_STATIC_INLINE uint32_t INVALID_ID = 0xffffu;
 
+    static Light<spectral_type> create(NBL_CONST_REF_ARG(spectral_type) radiance, uint32_t objId, uint32_t mode, ProceduralShapeType shapeType)
+    {
+        Light<spectral_type> retval;
+        retval.radiance = radiance;
+        retval.objectID = ObjectID::create(objId, mode, shapeType);
+        return retval;
+    }
+
     static Light<spectral_type> create(NBL_CONST_REF_ARG(spectral_type) radiance, NBL_CONST_REF_ARG(ObjectID) objectID)
     {
         Light<spectral_type> retval;
diff --git a/31_HLSLPathTracer/app_resources/hlsl/next_event_estimator.hlsl b/31_HLSLPathTracer/app_resources/hlsl/next_event_estimator.hlsl
@@ -89,7 +89,7 @@ struct Estimator
 
     static spectral_type deferredEvalAndPdf(NBL_REF_ARG(scalar_type) pdf, NBL_CONST_REF_ARG(light_type) light, NBL_CONST_REF_ARG(ray_type) ray, NBL_CONST_REF_ARG(Event) event)
     {
-        const uint32_t mode = event.mode;
+        const IntersectMode mode = (IntersectMode)event.mode;
         switch (mode)
         {
             case IM_RAY_QUERY:
@@ -192,7 +192,7 @@ struct Estimator
         }
 
         newRayMaxT *= Tolerance<scalar_type>::getEnd(depth);
-        pdf *= 1.0 / lightCount;
+        pdf *= 1.0 / scalar_type(lightCount);
         spectral_type quo = light.radiance / pdf;
         quotient_pdf = quotient_pdf_type::create(quo, pdf);
 
@@ -201,7 +201,7 @@ struct Estimator
 
     static sample_type generate_and_quotient_and_pdf(NBL_REF_ARG(quotient_pdf_type) quotient_pdf, NBL_REF_ARG(scalar_type) newRayMaxT, NBL_CONST_REF_ARG(light_type) light, NBL_CONST_REF_ARG(vector3_type) origin, NBL_CONST_REF_ARG(interaction_type) interaction, bool isBSDF, NBL_CONST_REF_ARG(vector3_type) xi, uint32_t depth, NBL_CONST_REF_ARG(Event) event)
     {
-        const uint32_t mode = event.mode;
+        const IntersectMode mode = (IntersectMode)event.mode;
         sample_type L;
         switch (mode)
         {
diff --git a/31_HLSLPathTracer/app_resources/hlsl/pathtracer.hlsl b/31_HLSLPathTracer/app_resources/hlsl/pathtracer.hlsl
@@ -79,13 +79,12 @@ struct Unidirectional
     //                     NextEventEstimator nee)
     // {}
 
-    static this_t create(NBL_CONST_REF_ARG(PathTracerCreationParams<create_params_type, scalar_type>) params, Buffer<uint3> sampleSequence)
+    static this_t create(NBL_CONST_REF_ARG(PathTracerCreationParams<create_params_type, scalar_type>) params)
     {
         this_t retval;
         retval.randGen = randgen_type::create(params.rngState);
         retval.rayGen = raygen_type::create(params.pixOffsetParam, params.camPos, params.NDC, params.invMVP);
         retval.materialSystem = material_system_type::create(params.diffuseParams, params.conductorParams, params.dielectricParams);
-        retval.sampleSequence = sampleSequence;
         return retval;
     }
 
@@ -170,14 +169,14 @@ struct Unidirectional
         scalar_type rcpChoiceProb;
         if (!math::partitionRandVariable(neeProbability, eps0.z, rcpChoiceProb) && depth < 2u)
         {
+            uint32_t randLightID = uint32_t(float32_t(randGen().x) / numeric_limits<uint32_t>::max) * scene.lightCount;
             quotient_pdf_type neeContrib_pdf;
             scalar_type t;
             sample_type nee_sample = nee.generate_and_quotient_and_pdf(
                 neeContrib_pdf, t,
-                scene.lights[lightID], intersection, interaction,
-                isBSDF, eps0, depth, scene.toNextEvent(lightID)
+                scene.lights[randLightID], intersection, interaction,
+                isBSDF, eps0, depth, scene.toNextEvent(randLightID)
             );
-            //printf("%f %f %f\n", nee_sample.L.direction.x, nee_sample.L.direction.y, nee_sample.L.direction.z);
 
             // We don't allow non watertight transmitters in this renderer
             bool validPath = nee_sample.NdotL > numeric_limits<scalar_type>::min;
@@ -233,8 +232,7 @@ struct Unidirectional
                     // }
 
                     quotient_pdf_type bsdf_quotient_pdf = materialSystem.quotient_and_pdf(material, bxdf.params, params);
-                    bsdf_quotient_pdf.quotient *= bxdf.albedo * throughput;
-                    neeContrib_pdf.quotient *= bsdf_quotient_pdf.quotient;
+                    neeContrib_pdf.quotient *= bxdf.albedo * throughput * bsdf_quotient_pdf.quotient;
                     const scalar_type otherGenOverChoice = bsdf_quotient_pdf.pdf * rcpChoiceProb;
                     const scalar_type otherGenOverLightAndChoice = otherGenOverChoice / bsdf_quotient_pdf.pdf;
                     neeContrib_pdf.quotient *= otherGenOverChoice / (1.f + otherGenOverLightAndChoice * otherGenOverLightAndChoice);   // balance heuristic
@@ -252,7 +250,7 @@ struct Unidirectional
             }
         }
 
-        //return false;   // NEE only
+        // return false;   // NEE only
 
         // sample BSDF
         scalar_type bxdfPdf;
@@ -312,8 +310,8 @@ struct Unidirectional
         if (bxdfPdf > bxdfPdfThreshold && getLuma(throughput) > lumaThroughputThreshold)
         {
             ray.payload.throughput = throughput;
-            ray.payload.otherTechniqueHeuristic = neeProbability / bxdfPdf; // numerically stable, don't touch
-            ray.payload.otherTechniqueHeuristic *= ray.payload.otherTechniqueHeuristic;
+            scalar_type otherTechniqueHeuristic = neeProbability / bxdfPdf; // numerically stable, don't touch
+            ray.payload.otherTechniqueHeuristic = otherTechniqueHeuristic * otherTechniqueHeuristic;
 
             // trace new ray
             ray.origin = intersection + bxdfSample * (1.0/*kSceneSize*/) * Tolerance<scalar_type>::getStart(depth);
@@ -354,7 +352,7 @@ struct Unidirectional
             // bounces
             bool hit = true;
             bool rayAlive = true;
-            for (int d = 1; d <= depth && hit && rayAlive; d += 2)
+            for (int d = 1; (d <= depth) && hit && rayAlive; d += 2)
             {
                 ray.intersectionT = numeric_limits<scalar_type>::max;
                 ray.objectID = intersector_type::traceRay(ray, scene);
@@ -385,8 +383,6 @@ struct Unidirectional
     raygen_type rayGen;
     material_system_type materialSystem;
     nee_type nee;
-
-    Buffer<uint3> sampleSequence;
 };
 
 }
diff --git a/31_HLSLPathTracer/app_resources/hlsl/render.comp.hlsl b/31_HLSLPathTracer/app_resources/hlsl/render.comp.hlsl
@@ -6,6 +6,7 @@
 #include "nbl/builtin/hlsl/bxdf/reflection.hlsl"
 #include "nbl/builtin/hlsl/bxdf/transmission.hlsl"
 
+#include "render_common.hlsl"
 #include "pathtracer.hlsl"
 
 // add these defines (one at a time) using -D argument to dxc
@@ -26,25 +27,6 @@ NBL_CONSTEXPR uint32_t WorkgroupSize = 32;
 NBL_CONSTEXPR uint32_t MAX_DEPTH_LOG2 = 4;
 NBL_CONSTEXPR uint32_t MAX_SAMPLES_LOG2 = 10;
 
-struct SPushConstants
-{
-    float32_t4x4 invMVP;
-    int sampleCount;
-    int depth;
-};
-
-[[vk::push_constant]] SPushConstants pc;
-
-[[vk::combinedImageSampler]][[vk::binding(0, 2)]] Texture2D<float3> envMap;      // unused
-[[vk::combinedImageSampler]][[vk::binding(0, 2)]] SamplerState envSampler;
-
-[[vk::binding(1, 2)]] Buffer<uint3> sampleSequence;
-
-[[vk::combinedImageSampler]][[vk::binding(2, 2)]] Texture2D<uint2> scramblebuf; // unused
-[[vk::combinedImageSampler]][[vk::binding(2, 2)]] SamplerState scrambleSampler;
-
-[[vk::image_format("rgba16f")]][[vk::binding(0, 0)]] RWTexture2D<float32_t4> outImage;
-
 int32_t2 getCoordinates()
 {
     return int32_t2(glsl::gl_GlobalInvocationID().xy);
@@ -115,7 +97,7 @@ static const ext::Shape<ext::PST_RECTANGLE> rectangles[RECTANGLE_COUNT] = {
 
 #define LIGHT_COUNT 1
 static const light_type lights[LIGHT_COUNT] = {
-    light_type::create(spectral_t(30.0,25.0,15.0), ext::ObjectID::create(8u, ext::IntersectMode::IM_PROCEDURAL, LIGHT_TYPE))
+    light_type::create(spectral_t(30.0,25.0,15.0), 8u, ext::IntersectMode::IM_PROCEDURAL, LIGHT_TYPE)
 };
 
 #define BXDF_COUNT 7
@@ -154,7 +136,7 @@ void main(uint32_t3 threadID : SV_DispatchThreadID)
 
     // set up path tracer
     ext::PathTracer::PathTracerCreationParams<create_params_t, float> ptCreateParams;
-    ptCreateParams.rngState = pcg();
+    ptCreateParams.rngState = scramblebuf[coords].rg;
 
     uint2 scrambleDim;
     scramblebuf.GetDimensions(scrambleDim.x, scrambleDim.y);
@@ -174,7 +156,7 @@ void main(uint32_t3 threadID : SV_DispatchThreadID)
     ptCreateParams.conductorParams = bxdfs[3].params;
     ptCreateParams.dielectricParams = bxdfs[6].params;
 
-    pathtracer_type pathtracer = pathtracer_type::create(ptCreateParams, sampleSequence);
+    pathtracer_type pathtracer = pathtracer_type::create(ptCreateParams);
 
     // set up scene (can do as global var?)
     ext::Scene<light_type, bxdfnode_type> scene;
diff --git a/31_HLSLPathTracer/app_resources/hlsl/render_common.hlsl b/31_HLSLPathTracer/app_resources/hlsl/render_common.hlsl
@@ -0,0 +1,23 @@
+#ifndef _NBL_HLSL_PATHTRACER_RENDER_COMMON_INCLUDED_
+#define _NBL_HLSL_PATHTRACER_RENDER_COMMON_INCLUDED_
+
+struct SPushConstants
+{
+    float32_t4x4 invMVP;
+    int sampleCount;
+    int depth;
+};
+
+[[vk::push_constant]] SPushConstants pc;
+
+[[vk::combinedImageSampler]][[vk::binding(0, 2)]] Texture2D<float3> envMap;      // unused
+[[vk::combinedImageSampler]][[vk::binding(0, 2)]] SamplerState envSampler;
+
+[[vk::binding(1, 2)]] Buffer<uint3> sampleSequence;
+
+[[vk::combinedImageSampler]][[vk::binding(2, 2)]] Texture2D<uint2> scramblebuf; // unused
+[[vk::combinedImageSampler]][[vk::binding(2, 2)]] SamplerState scrambleSampler;
+
+[[vk::image_format("rgba16f")]][[vk::binding(0, 0)]] RWTexture2D<float32_t4> outImage;
+
+#endif
diff --git a/31_HLSLPathTracer/main.cpp b/31_HLSLPathTracer/main.cpp
@@ -74,6 +74,13 @@ class HLSLComputePathtracer final : public examples::SimpleWindowedApplication,
 
 		inline bool isComputeOnly() const override { return false; }
 
+		//inline video::IAPIConnection::SFeatures getAPIFeaturesToEnable() override
+		//{
+		//	auto retval = device_base_t::getAPIFeaturesToEnable();
+		//	retval.synchronizationValidation = true;
+		//	return retval;
+		//}
+
 		inline core::vector<video::SPhysicalDeviceFilter::SurfaceCompatibility> getSurfaces() const override
 		{
 			if (!m_surface)
@@ -359,11 +366,11 @@ class HLSLComputePathtracer final : public examples::SimpleWindowedApplication,
 					options.stage = IShader::E_SHADER_STAGE::ESS_COMPUTE;	// should be compute
 					options.targetSpirvVersion = m_device->getPhysicalDevice()->getLimits().spirvVersion;
 					options.spirvOptimizer = nullptr;
-#ifndef _NBL_DEBUG
-					ISPIRVOptimizer::E_OPTIMIZER_PASS optPasses = ISPIRVOptimizer::EOP_STRIP_DEBUG_INFO;
-					auto opt = make_smart_refctd_ptr<ISPIRVOptimizer>(std::span<ISPIRVOptimizer::E_OPTIMIZER_PASS>(&optPasses, 1));
-					options.spirvOptimizer = opt.get();
-#endif
+//#ifndef _NBL_DEBUG
+//					ISPIRVOptimizer::E_OPTIMIZER_PASS optPasses = ISPIRVOptimizer::EOP_STRIP_DEBUG_INFO;
+//					auto opt = make_smart_refctd_ptr<ISPIRVOptimizer>(std::span<ISPIRVOptimizer::E_OPTIMIZER_PASS>(&optPasses, 1));
+//					options.spirvOptimizer = opt.get();
+//#endif
 					options.debugInfoFlags |= IShaderCompiler::E_DEBUG_INFO_FLAGS::EDIF_SOURCE_BIT;
 					options.preprocessorOptions.sourceIdentifier = source->getFilepathHint();
 					options.preprocessorOptions.logger = m_logger.get();
@@ -1343,7 +1350,7 @@ class HLSLComputePathtracer final : public examples::SimpleWindowedApplication,
 		int PTPipline = E_LIGHT_GEOMETRY::ELG_SPHERE;
 		int renderMode = E_RENDER_MODE::ERM_HLSL;
 		int spp = 32;
-		int depth = 3;
+		int depth = 1;
 
 		bool m_firstFrame = true;
 		IGPUCommandBuffer::SClearColorValue clearColor = { .float32 = {0.f,0.f,0.f,1.f} };

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ struct Estimator`
`89`	`89`
`90`	`90`	`static spectral_type deferredEvalAndPdf(NBL_REF_ARG(scalar_type) pdf, NBL_CONST_REF_ARG(light_type) light, NBL_CONST_REF_ARG(ray_type) ray, NBL_CONST_REF_ARG(Event) event)`
`91`	`91`	`{`
`92`		`- const uint32_t mode = event.mode;`
	`92`	`+ const IntersectMode mode = (IntersectMode)event.mode;`
`93`	`93`	`switch (mode)`
`94`	`94`	`{`
`95`	`95`	`case IM_RAY_QUERY:`
`@@ -192,7 +192,7 @@ struct Estimator`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`newRayMaxT *= Tolerance<scalar_type>::getEnd(depth);`
`195`		`- pdf *= 1.0 / lightCount;`
	`195`	`+ pdf *= 1.0 / scalar_type(lightCount);`
`196`	`196`	`spectral_type quo = light.radiance / pdf;`
`197`	`197`	`quotient_pdf = quotient_pdf_type::create(quo, pdf);`
`198`	`198`
`@@ -201,7 +201,7 @@ struct Estimator`
`201`	`201`
`202`	`202`	`static sample_type generate_and_quotient_and_pdf(NBL_REF_ARG(quotient_pdf_type) quotient_pdf, NBL_REF_ARG(scalar_type) newRayMaxT, NBL_CONST_REF_ARG(light_type) light, NBL_CONST_REF_ARG(vector3_type) origin, NBL_CONST_REF_ARG(interaction_type) interaction, bool isBSDF, NBL_CONST_REF_ARG(vector3_type) xi, uint32_t depth, NBL_CONST_REF_ARG(Event) event)`
`203`	`203`	`{`
`204`		`- const uint32_t mode = event.mode;`
	`204`	`+ const IntersectMode mode = (IntersectMode)event.mode;`
`205`	`205`	`sample_type L;`
`206`	`206`	`switch (mode)`
`207`	`207`	`{`