RT pipeline debug render by keptsecret · Pull Request #258 · Devsh-Graphics-Programming/Nabla-Examples-and-Tests

keptsecret · 2026-03-13T03:12:30Z

No description provided.

…not quite right

…rge to use compare with 0

40_PathTracer/include/renderer/shaders/pathtrace/push_constants.hlsl

…bug render

devshgraphicsprogramming · 2026-03-23T10:04:40Z

40_PathTracer/include/renderer/shaders/session.hlsl

 [[vk::binding(SensorDSBindings::UBO,SessionDSIndex)]] ConstantBuffer<SSensorUniforms> gSensor;
 // could be uint32_t2
-[[vk::binding(SensorDSBindings::ScrambleKey,SessionDSIndex)]] RWTexture2DArray<uint32_t4> gScrambleKey;
+[[vk::binding(SensorDSBindings::ScrambleKey,SessionDSIndex)]] RWTexture2D<uint32_t2> gScrambleKey;


keep it an array texture

devshgraphicsprogramming · 2026-03-23T10:06:02Z

40_PathTracer/src/renderer/CRenderer.cpp

+		// storage buffer with sobol sequence
+		OwenSampler sampler(SSensorUniforms::MaxBufferDimensions, 0xdeadbeefu);
+
+		constexpr uint32_t quantizedDimensions = SSensorUniforms::MaxBufferDimensions / 3u;
+		constexpr size_t bufferSize = quantizedDimensions * SSensorUniforms::MaxSamplesBuffer;
+		using sequence_type = hlsl::sampling::QuantizedSequence<hlsl::uint32_t2, 3>;
+		std::vector<sequence_type> data(bufferSize);
+
+		for (auto dim = 0u; dim < SSensorUniforms::MaxBufferDimensions; dim++)
+			for (uint32_t i = 0; i < SSensorUniforms::MaxSamplesBuffer; i++)
+			{
+				const uint32_t quant_dim = dim / 3u;
+				const uint32_t offset = dim % 3u;
+				auto& seq = data[i * quantizedDimensions + quant_dim];
+				const uint32_t sample = sampler.sample(dim, i);
+				seq.set(offset, sample);
+			}
+


where's the caching? you're making the example start horribly slow

devshgraphicsprogramming · 2026-03-23T10:06:33Z

40_PathTracer/src/renderer/CRenderer.cpp

+	// TODO: reset m_framesDispatched to 0 every time camera moves considerable amount
+	m_framesDispatched++;


this m_framesDispatched should live in the session!

devshgraphicsprogramming · 2026-03-23T10:09:43Z

40_PathTracer/src/renderer/CSession.cpp

 			auto mreqs = memBacked->getMemoryReqs();
 			mreqs.memoryTypeBits &= device->getPhysicalDevice()->getDeviceLocalMemoryTypeBits();
-			if (!device->allocate(mreqs,memBacked,IDeviceMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS::EMAF_NONE).isValid())
+			if (!device->allocate(mreqs,memBacked,deviceAddress ? IDeviceMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS::EMAF_DEVICE_ADDRESS_BIT : IDeviceMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS::EMAF_NONE).isValid())


you can deduce it from whether the memBacked is a GPUBuffer and if it has the shader address bit usage

devshgraphicsprogramming · 2026-03-23T10:10:58Z

40_PathTracer/src/renderer/CSession.cpp

+			immutables.scrambleKey.image = scrambleKey;
+
+			const auto& params = immutables.scrambleKey.image->getCreationParameters();
+			const auto viewFormat = params.format;
+			const auto thisFormatUsages = static_cast<core::bitflag<IGPUImage::E_USAGE_FLAGS>>(allowedFormatUsages[viewFormat]);
+			auto view = device->createImageView({
+				.subUsages = immutables.scrambleKey.image->getCreationParameters().usage & thisFormatUsages,
+				.image = immutables.scrambleKey.image,
+				.viewType = IGPUImageView::E_TYPE::ET_2D,
+				.format = viewFormat
+				});
+			string viewDebugName = "Scramble Key " + to_string(viewFormat) + " View";
+			if (!view)
+			{
+				logger.log("Failed to create Sensor \"%s\"'s \"%s\" in CSession::init()", ILogger::ELL_ERROR, m_params.name.c_str(), viewDebugName.c_str());
+				return {};
+			}
+			view->setObjectDebugName(viewDebugName.c_str());
+			immutables.scrambleKey.views[viewFormat] = std::move(view);


each session should get its own Scramble Key image made when we initialize, and decouple from the renderer, because we may want to use Heitz' rank and key permutation techniques to produce blue noise

or later experiment with having a scramble key image with as many layers as we have max pixel depth, so as notto store the xoroshiro64 state in the ray payload and read from an image instead

devshgraphicsprogramming · 2026-03-23T10:13:23Z

40_PathTracer/include/renderer/shaders/pathtrace/rand_gen.hlsl

+template<typename RNG, uint16_t N>
+struct RandomUniformND
+{
+    using rng_type = RNG;
+    using return_type = vector<float32_t, N>;
+
+    static RandomUniformND<RNG,N> create(uint32_t2 seed, uint64_t pSampleSequence)
+    {
+        RandomUniformND<RNG,N> retval;
+        retval.rng = rng_type::construct(seed);
+        retval.pSampleBuffer = pSampleSequence;
+        return retval;
+    }
+
+    // baseDimension: offset index of the sequence
+    // sampleIndex: iteration number of current pixel (samples per pixel)
+    return_type operator()(uint32_t baseDimension, uint32_t sampleIndex)
+    {
+        using sequence_type = hlsl::sampling::QuantizedSequence<uint32_t2,3>;
+        uint32_t address = hlsl::glsl::bitfieldInsert<uint32_t>(baseDimension, sampleIndex, SSensorUniforms::MaxPathDepthLog2, SSensorUniforms::MaxSamplesLog2);
+        sequence_type tmpSeq = vk::RawBufferLoad<sequence_type>(pSampleBuffer + address * sizeof(sequence_type));
+        return tmpSeq.template decode<float32_t>(hlsl::random::DimAdaptorRecursive<rng_type, N>::__call(rng));
+    }
+
+    rng_type rng;
+    uint64_t pSampleBuffer;
+};


didn't we commonalize this between ex 31 and nabla master?

devshgraphicsprogramming · 2026-03-23T10:16:05Z

40_PathTracer/app_resources/pathtrace/debug.hlsl

+    uint32_t sampleCount = pc.sensorDynamics.maxSPP;
+    float rcpSampleCount = 1.0 / float(sampleCount);
+    for (uint32_t i = 0; i < sampleCount; i++)
+    {


maxSpp shouldn't be used, rather spp per frame

devshgraphicsprogramming · 2026-03-23T10:16:37Z

40_PathTracer/app_resources/pathtrace/debug.hlsl

+    const bool firstFrame = pc.sensorDynamics.rcpFramesDispatched == 1.0;
+    // clear accumulations totally if beginning a new frame
+    if (firstFrame)
+    {
+        gAlbedo[launchID] = float32_t4(acc_albedo * rcpSampleCount, 1.0);
+        gNormal[launchID] = float32_t4(acc_normal * rcpSampleCount, 1.0);
+    }
+    else
+    {
+        float32_t3 prev_albedo = gAlbedo[launchID];
+        float32_t3 delta = (acc_albedo * rcpSampleCount - prev_albedo) * pc.sensorDynamics.rcpFramesDispatched;
+        if (hlsl::any(delta > hlsl::promote<float32_t3>(1.0/1024.0)))
+            gAlbedo[launchID] = float32_t4(prev_albedo + delta, 1.0);
+
+        float32_t3 prev_normal = gNormal[launchID];
+        delta = (acc_normal * rcpSampleCount - prev_normal) * pc.sensorDynamics.rcpFramesDispatched;
+        if (hlsl::any(delta > hlsl::promote<float32_t3>(1.0/512.0)))
+            gNormal[launchID] = float32_t4(prev_normal + delta, 1.0);
+    }


this time I want the accumulation to be done variably per pixel which is why I added a pixel count texture

devshgraphicsprogramming · 2026-03-23T10:18:59Z

40_PathTracer/include/renderer/shaders/pathtrace/push_constants.hlsl

 	hlsl::float32_t2x3 ndcToRay;
 	hlsl::float32_t nearClip;
 	hlsl::float32_t tMax;
+	hlsl::float32_t rcpFramesDispatched;


shouldn't exist

devshgraphicsprogramming · 2026-03-23T10:19:11Z

40_PathTracer/include/renderer/shaders/pathtrace/push_constants.hlsl

 	hlsl::float32_t nearClip;
 	hlsl::float32_t tMax;
+	hlsl::float32_t rcpFramesDispatched;
+	uint64_t pSampleSequence;


this should be in the gSensor UBO, not the push constant

devshgraphicsprogramming · 2026-03-23T10:22:11Z

40_PathTracer/include/renderer/shaders/pathtrace/push_constants.hlsl

 	uint32_t minSPP : MAX_SPP_LOG2;
 	uint32_t maxSPP : MAX_SPP_LOG2;


I've set aside this texture

Nabla-Examples-and-Tests/40_PathTracer/include/renderer/shaders/session.hlsl

Line 94 in 080e1d5

[[vk::binding(SensorDSBindings::SampleCount,SessionDSIndex)]] RWTexture2DArray<uint32_t4> gSampleCount;

To keep the count on the number of samples in a particular pixel, each frame we do 1spp (or 2 spp) but then the job is to arrive at maxSPP at each pixel (for now)

devshgraphicsprogramming · 2026-03-23T10:23:17Z

40_PathTracer/main.cpp

 					{
-						return session->init(info.getCommandBufferForRecording()->cmdbuf);
+						const auto& params = m_renderer->getConstructionParams();
+						return session->init(info.getCommandBufferForRecording()->cmdbuf, smart_refctd_ptr(params.sampleSequenceBuffer), smart_refctd_ptr(params.scrambleKey));


sampleSquenceBuffer should be passed to session during session create, not init

Init is only for making resources that are tied to the session and VRAM heavy.

keptsecret added 7 commits March 10, 2026 12:11

added closest hit shader to draw albedo (as white), ndc to ray still …

7dc5d93

…not quite right

ray trace albedo and normal, look angle still kinda weird

225a529

added unit test for pseudoInverse3x4

2e63a67

fix some matrix calculations, storing normals vis

046236f

disable orthogonality check for now, wait for sampling refactor pr me…

9079b2f

…rge to use compare with 0

removed one too many lines, needed for next check

41ebd0a

Merge branch 'master' into rt_pipeline_debug_render

147b5d1

devshgraphicsprogramming reviewed Mar 13, 2026

View reviewed changes

40_PathTracer/include/renderer/shaders/pathtrace/push_constants.hlsl Outdated Show resolved Hide resolved

keptsecret added 7 commits March 17, 2026 10:31

Merge branch 'master' into rt_pipeline_debug_render

b71ee98

add sobol sequence buffer, fill scramble key with noise and use in de…

480060c

…bug render

write the correct scramble key image

51aceb4

moved sequence buffer and scramble key into CRenderer

2d45d4a

Merge branch 'master' into rt_pipeline_debug_render

a306806

sample multiple samples with minSPP

19be252

add temporal accumulation for debug render

080e1d5

devshgraphicsprogramming reviewed Mar 23, 2026

View reviewed changes

		// TODO: reset m_framesDispatched to 0 every time camera moves considerable amount
		m_framesDispatched++;

		uint32_t minSPP : MAX_SPP_LOG2;
		uint32_t maxSPP : MAX_SPP_LOG2;

Conversation

keptsecret commented Mar 13, 2026

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Mar 23, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

devshgraphicsprogramming Mar 23, 2026 •

edited

Loading