Fixes and renaming

AnKi/Renderer/ConfigVars.defs.h

@@ -78,6 +78,6 @@ ANKI_CONFIG_VAR_U8(RFsrQuality, 1, 0, 2, "0: Use bilinear, 1: FSR low quality, 2
 ANKI_CONFIG_VAR_U8(RDlssQuality, 2, 0, 3, "0: Disabled, 1: Performance, 2: Balanced, 3: Quality")
 ANKI_CONFIG_VAR_F32(RSharpness, ((ANKI_PLATFORM_MOBILE) ? 0.0f : 0.8f), 0.0f, 1.0f, "Sharpen the image. It's a factor")
 
-// HiZ
-ANKI_CONFIG_VAR_U32(RHiZWidth, 512, 128, 4 * 1024, "HiZ map width")
-ANKI_CONFIG_VAR_U32(RHiZHeight, 256, 128, 4 * 1024, "HiZ map height")
+// HZB
+ANKI_CONFIG_VAR_U32(RHZBWidth, 512, 128, 4 * 1024, "HZB map width")
+ANKI_CONFIG_VAR_U32(RHZBHeight, 256, 128, 4 * 1024, "HZB map height")

AnKi/Renderer/GBuffer.cpp

@@ -111,12 +111,12 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias.get();
 	args.m_renderingTechinuqe = RenderingTechnique::kGBuffer;
 
-	const GpuVisibility& gpuVis = getRenderer().getGpuVisibility();
-	rgraphCtx.getBufferState(gpuVis.getMdiDrawCountsBufferHandle(), args.m_mdiDrawCountsBuffer, args.m_mdiDrawCountsBufferOffset,
+	const GPUVisibility& GPUVis = getRenderer().getGPUVisibility();
+	rgraphCtx.getBufferState(GPUVis.getMDIDrawCountsBufferHandle(), args.m_mdiDrawCountsBuffer, args.m_mdiDrawCountsBufferOffset,
 							 args.m_mdiDrawCountsBufferRange);
-	rgraphCtx.getBufferState(gpuVis.getDrawIndexedIndirectArgsBufferHandle(), args.m_drawIndexedIndirectArgsBuffer,
+	rgraphCtx.getBufferState(GPUVis.getDrawIndexedIndirectArgsBufferHandle(), args.m_drawIndexedIndirectArgsBuffer,
 							 args.m_drawIndexedIndirectArgsBufferOffset, args.m_drawIndexedIndirectArgsBufferRange);
-	rgraphCtx.getBufferState(gpuVis.getInstanceRateRenderablesBufferHandle(), args.m_instaceRateRenderablesBuffer,
+	rgraphCtx.getBufferState(GPUVis.getInstanceRateRenderablesBufferHandle(), args.m_instaceRateRenderablesBuffer,
 							 args.m_instaceRateRenderablesOffset, args.m_instaceRateRenderablesRange);
 
 	cmdb.setDepthCompareOperation(CompareOperation::kLessEqual);
@@ -208,7 +208,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 
 	// Only add one depedency to the GPU visibility. No need to track all buffers
-	pass.newBufferDependency(getRenderer().getGpuVisibility().getMdiDrawCountsBufferHandle(), BufferUsageBit::kIndirectDraw);
+	pass.newBufferDependency(getRenderer().getGPUVisibility().getMDIDrawCountsBufferHandle(), BufferUsageBit::kIndirectDraw);
 }
 
 } // end namespace anki

AnKi/Renderer/GpuVisibility.cpp

@@ -3,9 +3,9 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <AnKi/Renderer/GpuVisibility.h>
+#include <AnKi/Renderer/GPUVisibility.h>
 #include <AnKi/Renderer/Renderer.h>
-#include <AnKi/Renderer/HiZ.h>
+#include <AnKi/Renderer/HZB.h>
 #include <AnKi/Scene/RenderStateBucket.h>
 #include <AnKi/Scene/ContiguousArrayAllocator.h>
 #include <AnKi/Core/GpuMemory/GpuVisibleTransientMemoryPool.h>
@@ -17,14 +17,14 @@
 
 namespace anki {
 
-Error GpuVisibility::init()
+Error GPUVisibility::init()
 {
-	ANKI_CHECK(loadShaderProgram("ShaderBinaries/GpuVisibility.ankiprogbin", m_prog, m_grProg));
+	ANKI_CHECK(loadShaderProgram("ShaderBinaries/GPUVisibility.ankiprogbin", m_prog, m_grProg));
 
 	return Error::kNone;
 }
 
-void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
+void GPUVisibility::populateRenderGraph(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
@@ -47,17 +47,17 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 															 instanceRateRenderables.m_offset, instanceRateRenderables.m_size);
 	m_runCtx.m_drawIndexedIndirectArgs =
 		rgraph.importBuffer(indirectArgs.m_buffer, BufferUsageBit::kNone, indirectArgs.m_offset, indirectArgs.m_size);
-	m_runCtx.m_mdiDrawCounts = rgraph.importBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
+	m_runCtx.m_MDIDrawCounts = rgraph.importBuffer(&RebarTransientMemoryPool::getSingleton().getBuffer(), BufferUsageBit::kNone,
 												   mdiDrawCounts.m_offset, mdiDrawCounts.m_range);
 
 	// Create the renderpass
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("GPU occlusion GBuffer");
 
 	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
-	pass.newTextureDependency(getRenderer().getHiZ().getHiZRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(getRenderer().getHZB().getHZBRt(), TextureUsageBit::kSampledCompute);
 	pass.newBufferDependency(m_runCtx.m_instanceRateRenderables, BufferUsageBit::kStorageComputeWrite);
 	pass.newBufferDependency(m_runCtx.m_drawIndexedIndirectArgs, BufferUsageBit::kStorageComputeWrite);
-	pass.newBufferDependency(m_runCtx.m_mdiDrawCounts, BufferUsageBit::kStorageComputeWrite);
+	pass.newBufferDependency(m_runCtx.m_MDIDrawCounts, BufferUsageBit::kStorageComputeWrite);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rpass) {
 		CommandBuffer& cmdb = *rpass.m_commandBuffer;
@@ -77,7 +77,7 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
-		rpass.bindColorTexture(0, 3, getRenderer().getHiZ().getHiZRt());
+		rpass.bindColorTexture(0, 3, getRenderer().getHZB().getHZBRt());
 		cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_nearestNearestClamp.get());
 
 		rpass.bindStorageBuffer(0, 5, m_runCtx.m_instanceRateRenderables);
@@ -94,9 +94,9 @@ void GpuVisibility::populateRenderGraph(RenderingContext& ctx)
 		});
 		ANKI_ASSERT(userCount == RenderStateBucketContainer::getSingleton().getBucketsItemCount(RenderingTechnique::kGBuffer));
 
-		rpass.bindStorageBuffer(0, 8, m_runCtx.m_mdiDrawCounts);
+		rpass.bindStorageBuffer(0, 8, m_runCtx.m_MDIDrawCounts);
 
-		GpuVisibilityUniforms* unis = allocateAndBindUniforms<GpuVisibilityUniforms*>(sizeof(GpuVisibilityUniforms), cmdb, 0, 9);
+		GPUVisibilityUniforms* unis = allocateAndBindUniforms<GPUVisibilityUniforms*>(sizeof(GPUVisibilityUniforms), cmdb, 0, 9);
 
 		Array<Plane, 6> planes;
 		extractClipPlanes(ctx.m_matrices.m_viewProjection, planes);

AnKi/Renderer/GpuVisibility.h

@@ -13,7 +13,7 @@ namespace anki {
 /// @{
 
 /// XXX
-class GpuVisibility : public RendererObject
+class GPUVisibility : public RendererObject
 {
 public:
 	Error init();
@@ -21,9 +21,9 @@ public:
 	/// Populate the rendergraph.
 	void populateRenderGraph(RenderingContext& ctx);
 
-	BufferHandle getMdiDrawCountsBufferHandle() const
+	BufferHandle getMDIDrawCountsBufferHandle() const
 	{
-		return m_runCtx.m_mdiDrawCounts;
+		return m_runCtx.m_MDIDrawCounts;
 	}
 
 	BufferHandle getDrawIndexedIndirectArgsBufferHandle() const
@@ -45,7 +45,7 @@ private:
 	public:
 		BufferHandle m_instanceRateRenderables;
 		BufferHandle m_drawIndexedIndirectArgs;
-		BufferHandle m_mdiDrawCounts;
+		BufferHandle m_MDIDrawCounts;
 	} m_runCtx;
 };
 /// @}

AnKi/Renderer/HiZ.cpp → AnKi/Renderer/HZB.cpp

@@ -3,7 +3,7 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <AnKi/Renderer/HiZ.h>
+#include <AnKi/Renderer/HZB.h>
 #include <AnKi/Renderer/Renderer.h>
 #include <AnKi/Renderer/GBuffer.h>
 #include <AnKi/Core/ConfigSet.h>
@@ -27,33 +27,33 @@
 
 namespace anki {
 
-Error HiZ::init()
+Error HZB::init()
 {
-	registerDebugRenderTarget("HiZ");
+	registerDebugRenderTarget("HZB");
 
-	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/HiZReprojection.ankiprogbin", m_reproj.m_prog));
+	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/HZBReprojection.ankiprogbin", m_reproj.m_prog));
 
 	const ShaderProgramResourceVariant* variant;
 	m_reproj.m_prog->getOrCreateVariant(variant);
 	m_reproj.m_grProg.reset(&variant->getProgram());
 
-	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClearTextureCompute.ankiprogbin", m_clearHiZ.m_prog));
-	ShaderProgramResourceVariantInitInfo variantInit(m_clearHiZ.m_prog);
+	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClearTextureCompute.ankiprogbin", m_clearHZB.m_prog));
+	ShaderProgramResourceVariantInitInfo variantInit(m_clearHZB.m_prog);
 	variantInit.addMutation("TEXTURE_DIMENSIONS", 2);
 	variantInit.addMutation("COMPONENT_TYPE", 1);
-	m_clearHiZ.m_prog->getOrCreateVariant(variantInit, variant);
-	m_clearHiZ.m_grProg.reset(&variant->getProgram());
+	m_clearHZB.m_prog->getOrCreateVariant(variantInit, variant);
+	m_clearHZB.m_grProg.reset(&variant->getProgram());
 
-	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/HiZGenPyramid.ankiprogbin", m_mipmapping.m_prog));
+	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/HZBGenPyramid.ankiprogbin", m_mipmapping.m_prog));
 	m_mipmapping.m_prog->getOrCreateVariant(variant);
 	m_mipmapping.m_grProg.reset(&variant->getProgram());
 
-	m_hiZRtDescr = getRenderer().create2DRenderTargetDescription(ConfigSet::getSingleton().getRHiZWidth(), ConfigSet::getSingleton().getRHiZHeight(),
-																 Format::kR32_Uint, "HiZ U32");
-	m_hiZRtDescr.m_mipmapCount = U8(computeMaxMipmapCount2d(m_hiZRtDescr.m_width, m_hiZRtDescr.m_height, 1));
-	m_hiZRtDescr.bake();
+	m_HZBRtDescr = getRenderer().create2DRenderTargetDescription(ConfigSet::getSingleton().getRHZBWidth(), ConfigSet::getSingleton().getRHZBHeight(),
+																 Format::kR32_Uint, "HZB U32");
+	m_HZBRtDescr.m_mipmapCount = U8(computeMaxMipmapCount2d(m_HZBRtDescr.m_width, m_HZBRtDescr.m_height, 1));
+	m_HZBRtDescr.bake();
 
-	BufferInitInfo buffInit("HiZCounterBuffer");
+	BufferInitInfo buffInit("HZBCounterBuffer");
 	buffInit.m_size = sizeof(U32);
 	buffInit.m_usage = BufferUsageBit::kStorageComputeWrite | BufferUsageBit::kTransferDestination;
 	m_mipmapping.m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
@@ -61,37 +61,37 @@ Error HiZ::init()
 	return Error::kNone;
 }
 
-void HiZ::populateRenderGraph(RenderingContext& ctx)
+void HZB::populateRenderGraph(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-	m_runCtx.m_hiZRt = rgraph.newRenderTarget(m_hiZRtDescr);
+	m_runCtx.m_HZBRt = rgraph.newRenderTarget(m_HZBRtDescr);
 	TextureSubresourceInfo firstMipSubresource;
 
 	// Clear RT
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ clear");
-		pass.newTextureDependency(m_runCtx.m_hiZRt, TextureUsageBit::kImageComputeWrite, firstMipSubresource);
+		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HZB clear");
+		pass.newTextureDependency(m_runCtx.m_HZBRt, TextureUsageBit::kImageComputeWrite, firstMipSubresource);
 
 		pass.setWork([this](RenderPassWorkContext& rctx) {
 			CommandBuffer& cmdb = *rctx.m_commandBuffer;
 
-			cmdb.bindShaderProgram(m_clearHiZ.m_grProg.get());
+			cmdb.bindShaderProgram(m_clearHZB.m_grProg.get());
 
 			TextureSubresourceInfo firstMipSubresource;
-			rctx.bindImage(0, 0, m_runCtx.m_hiZRt, firstMipSubresource);
+			rctx.bindImage(0, 0, m_runCtx.m_HZBRt, firstMipSubresource);
 
 			UVec4 clearColor(0u);
 			cmdb.setPushConstants(&clearColor, sizeof(clearColor));
 
-			dispatchPPCompute(cmdb, 8, 8, 1, m_hiZRtDescr.m_width, m_hiZRtDescr.m_height, 1);
+			dispatchPPCompute(cmdb, 8, 8, 1, m_HZBRtDescr.m_width, m_HZBRtDescr.m_height, 1);
 		});
 	}
 
 	// Reproject
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ reprojection");
-		pass.newTextureDependency(m_runCtx.m_hiZRt, TextureUsageBit::kImageComputeWrite, firstMipSubresource);
+		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HZB reprojection");
+		pass.newTextureDependency(m_runCtx.m_HZBRt, TextureUsageBit::kImageComputeWrite, firstMipSubresource);
 		pass.newTextureDependency(getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rctx) {
@@ -101,7 +101,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 
 			rctx.bindTexture(0, 0, getRenderer().getGBuffer().getPreviousFrameDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			TextureSubresourceInfo firstMipSubresource;
-			rctx.bindImage(0, 1, m_runCtx.m_hiZRt, firstMipSubresource);
+			rctx.bindImage(0, 1, m_runCtx.m_HZBRt, firstMipSubresource);
 
 			cmdb.setPushConstants(&ctx.m_matrices.m_reprojection, sizeof(Mat4));
 
@@ -111,22 +111,22 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 
 	// Mipmap
 	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ mip gen");
+		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HZB mip gen");
 
-		pass.newTextureDependency(m_runCtx.m_hiZRt, TextureUsageBit::kSampledCompute, firstMipSubresource);
+		pass.newTextureDependency(m_runCtx.m_HZBRt, TextureUsageBit::kSampledCompute, firstMipSubresource);
 
-		for(U32 mip = 1; mip < m_hiZRtDescr.m_mipmapCount; ++mip)
+		for(U32 mip = 1; mip < m_HZBRtDescr.m_mipmapCount; ++mip)
 		{
 			TextureSubresourceInfo subresource;
 			subresource.m_firstMipmap = mip;
-			pass.newTextureDependency(m_runCtx.m_hiZRt, TextureUsageBit::kImageComputeWrite, subresource);
+			pass.newTextureDependency(m_runCtx.m_HZBRt, TextureUsageBit::kImageComputeWrite, subresource);
 		}
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
 			TextureSubresourceInfo firstMipSubresource;
-			const U32 mipsToCompute = m_hiZRtDescr.m_mipmapCount - 1;
+			const U32 mipsToCompute = m_HZBRtDescr.m_mipmapCount - 1;
 
 			// Zero the counter buffer once before everything else
 			if(!m_mipmapping.m_counterBufferZeroed) [[unlikely]]
@@ -145,7 +145,7 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 			varAU2(dispatchThreadGroupCountXY);
 			varAU2(workGroupOffset); // needed if Left and Top are not 0,0
 			varAU2(numWorkGroupsAndMips);
-			varAU4(rectInfo) = initAU4(0, 0, m_hiZRtDescr.m_width, m_hiZRtDescr.m_height);
+			varAU4(rectInfo) = initAU4(0, 0, m_HZBRtDescr.m_width, m_HZBRtDescr.m_height);
 			SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, mipsToCompute);
 
 			struct Uniforms
@@ -174,11 +174,11 @@ void HiZ::populateRenderGraph(RenderingContext& ctx)
 					subresource.m_firstMipmap = 1;
 				}
 
-				rgraphCtx.bindImage(0, 0, m_runCtx.m_hiZRt, subresource, mip);
+				rgraphCtx.bindImage(0, 0, m_runCtx.m_HZBRt, subresource, mip);
 			}
 
 			cmdb.bindStorageBuffer(0, 1, m_mipmapping.m_counterBuffer.get(), 0, kMaxPtrSize);
-			rgraphCtx.bindTexture(0, 2, m_runCtx.m_hiZRt, firstMipSubresource);
+			rgraphCtx.bindTexture(0, 2, m_runCtx.m_HZBRt, firstMipSubresource);
 
 			cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 		});

AnKi/Renderer/HiZ.h → AnKi/Renderer/HZB.h

@@ -12,28 +12,28 @@ namespace anki {
 /// @addtogroup renderer
 /// @{
 
-/// Hierarchical depth generator.
-class HiZ : public RendererObject
+/// Hierarchical Z buffer generator.
+class HZB : public RendererObject
 {
 public:
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);
 
-	const RenderTargetHandle& getHiZRt() const
+	const RenderTargetHandle& getHZBRt() const
 	{
-		return m_runCtx.m_hiZRt;
+		return m_runCtx.m_HZBRt;
 	}
 
 private:
-	RenderTargetDescription m_hiZRtDescr;
+	RenderTargetDescription m_HZBRtDescr;
 
 	class
 	{
 	public:
 		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
-	} m_clearHiZ;
+	} m_clearHZB;
 
 	class
 	{
@@ -54,7 +54,7 @@ private:
 	class
 	{
 	public:
-		RenderTargetHandle m_hiZRt;
+		RenderTargetHandle m_HZBRt;
 	} m_runCtx;
 };
 /// @}

AnKi/Renderer/Renderer.cpp

@@ -44,8 +44,8 @@
 #include <AnKi/Renderer/IndirectDiffuse.h>
 #include <AnKi/Renderer/VrsSriGeneration.h>
 #include <AnKi/Renderer/PackVisibleClusteredObjects.h>
-#include <AnKi/Renderer/HiZ.h>
-#include <AnKi/Renderer/GpuVisibility.h>
+#include <AnKi/Renderer/HZB.h>
+#include <AnKi/Renderer/GPUVisibility.h>
 
 namespace anki {
 
@@ -247,11 +247,11 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	m_packVisibleClustererObjects.reset(newInstance<PackVisibleClusteredObjects>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_packVisibleClustererObjects->init());
 
-	m_hiZ.reset(newInstance<HiZ>(RendererMemoryPool::getSingleton()));
-	ANKI_CHECK(m_hiZ->init());
+	m_HZB.reset(newInstance<HZB>(RendererMemoryPool::getSingleton()));
+	ANKI_CHECK(m_HZB->init());
 
-	m_gpuVisibility.reset(newInstance<GpuVisibility>(RendererMemoryPool::getSingleton()));
-	ANKI_CHECK(m_gpuVisibility->init());
+	m_GPUVisibility.reset(newInstance<GPUVisibility>(RendererMemoryPool::getSingleton()));
+	ANKI_CHECK(m_GPUVisibility->init());
 
 	// Init samplers
 	{
@@ -347,9 +347,9 @@ Error Renderer::populateRenderGraph(RenderingContext& ctx)
 	m_gbuffer->importRenderTargets(ctx);
 
 	// Populate render graph. WARNING Watch the order
-	m_hiZ->populateRenderGraph(ctx);
+	m_HZB->populateRenderGraph(ctx);
 	gpuSceneCopy(ctx);
-	m_gpuVisibility->populateRenderGraph(ctx);
+	m_GPUVisibility->populateRenderGraph(ctx);
 	m_packVisibleClustererObjects->populateRenderGraph(ctx);
 	m_genericCompute->populateRenderGraph(ctx);
 	m_clusterBinning->populateRenderGraph(ctx);

AnKi/Renderer/RendererObject.defs.h

@@ -32,5 +32,5 @@ ANKI_RENDERER_OBJECT_DEF(Scale, scale)
 ANKI_RENDERER_OBJECT_DEF(IndirectDiffuse, indirectDiffuse)
 ANKI_RENDERER_OBJECT_DEF(VrsSriGeneration, vrsSriGeneration)
 ANKI_RENDERER_OBJECT_DEF(PackVisibleClusteredObjects, packVisibleClustererObjects)
-ANKI_RENDERER_OBJECT_DEF(HiZ, hiZ)
-ANKI_RENDERER_OBJECT_DEF(GpuVisibility, gpuVisibility)
+ANKI_RENDERER_OBJECT_DEF(HZB, HZB)
+ANKI_RENDERER_OBJECT_DEF(GPUVisibility, GPUVisibility)

AnKi/Shaders/GpuVisibility.ankiprog

@@ -10,11 +10,11 @@
 #include <AnKi/Shaders/CollisionFunctions.hlsl>
 
 // Buffers that point to the GPU scene
-[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableAabb> g_aabbs;
+[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableAabb> g_AABBs;
 [[vk::binding(1)]] StructuredBuffer<GpuSceneRenderable> g_renderables;
-[[vk::binding(2)]] ByteAddressBuffer g_gpuScene;
+[[vk::binding(2)]] ByteAddressBuffer g_GPUScene;
 
-[[vk::binding(3)]] Texture2D<U32> g_hiZTex;
+[[vk::binding(3)]] Texture2D<U32> g_HZBTex;
 [[vk::binding(4)]] SamplerState g_nearestAnyClampSampler;
 
 // These 2 have the same size
@@ -24,9 +24,9 @@
 // Index pointing to the above arrays. One for each render state bucket
 [[vk::binding(7)]] StructuredBuffer<U32> g_drawIndirectArgsOffsets;
 // The MDI counts. One for each render state bucket
-[[vk::binding(8)]] RWStructuredBuffer<U32> g_mdiDrawCounts;
+[[vk::binding(8)]] RWStructuredBuffer<U32> g_MDIDrawCounts;
 
-[[vk::binding(9)]] ConstantBuffer<GpuVisibilityUniforms> g_unis;
+[[vk::binding(9)]] ConstantBuffer<GPUVisibilityUniforms> g_unis;
 
 [numthreads(64, 1, 1)] void main(UVec3 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
@@ -36,7 +36,7 @@
 		return;
 	}
 
-	const GpuSceneRenderableAabb aabb = g_aabbs[aabbIdx];
+	const GpuSceneRenderableAabb aabb = g_AABBs[aabbIdx];
 
 	// Frustum test
 	//
@@ -85,7 +85,7 @@
 	// Compute the mip
 	Vec2 texSize;
 	F32 mipCount;
-	g_hiZTex.GetDimensions(0, texSize.x, texSize.y, mipCount);
+	g_HZBTex.GetDimensions(0, texSize.x, texSize.y, mipCount);
 
 	const Vec2 minUv = saturate(ndcToUv(minNdc));
 	const Vec2 maxUv = saturate(ndcToUv(maxNdc));
@@ -108,10 +108,10 @@
 
 	// Sample mip
 	Vec4 depths;
-	depths[0] = asfloat(g_hiZTex.SampleLevel(g_nearestAnyClampSampler, minUv, mip));
-	depths[1] = asfloat(g_hiZTex.SampleLevel(g_nearestAnyClampSampler, maxUv, mip));
-	depths[2] = asfloat(g_hiZTex.SampleLevel(g_nearestAnyClampSampler, Vec2(minUv.x, maxUv.y), mip));
-	depths[3] = asfloat(g_hiZTex.SampleLevel(g_nearestAnyClampSampler, Vec2(maxUv.x, minUv.y), mip));
+	depths[0] = asfloat(g_HZBTex.SampleLevel(g_nearestAnyClampSampler, minUv, mip));
+	depths[1] = asfloat(g_HZBTex.SampleLevel(g_nearestAnyClampSampler, maxUv, mip));
+	depths[2] = asfloat(g_HZBTex.SampleLevel(g_nearestAnyClampSampler, Vec2(minUv.x, maxUv.y), mip));
+	depths[3] = asfloat(g_HZBTex.SampleLevel(g_nearestAnyClampSampler, Vec2(maxUv.x, minUv.y), mip));
 
 	const F32 maxDepth = max(depths[0], max(depths[1], max(depths[2], depths[3])));
 
@@ -145,12 +145,12 @@
 	const U32 renderableIdx = aabb.m_renderableIndexAndRenderStateBucket >> 12u;
 
 	U32 indirectIdx;
-	InterlockedAdd(g_mdiDrawCounts[renderStateBucket], 1, indirectIdx);
+	InterlockedAdd(g_MDIDrawCounts[renderStateBucket], 1, indirectIdx);
 	indirectIdx += g_drawIndirectArgsOffsets[renderStateBucket];
 
 	const GpuSceneRenderable renderableIn = g_renderables[renderableIdx];
 	const U32 meshLodOffset = renderableIn.m_geometryOffset + sizeof(GpuSceneMeshLod) * lod;
-	const GpuSceneMeshLod meshLod = g_gpuScene.Load<GpuSceneMeshLod>(meshLodOffset);
+	const GpuSceneMeshLod meshLod = g_GPUScene.Load<GpuSceneMeshLod>(meshLodOffset);
 
 	DrawIndexedIndirectArgs indirect;
 	indirect.m_indexCount = meshLod.m_indexCount;

AnKi/Shaders/HiZGenPyramid.ankiprog → AnKi/Shaders/HZBGenPyramid.ankiprog

@@ -18,7 +18,7 @@ struct Uniforms
 
 [[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
 
-[[vk::binding(0)]] globallycoherent RWTexture2D<UVec4> g_dstUavs[12u];
+[[vk::binding(0)]] globallycoherent RWTexture2D<UVec4> g_dstUAVs[12u];
 [[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
 [[vk::binding(2)]] Texture2D<UVec4> g_srcTex;
 
@@ -40,14 +40,14 @@ AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
 AF4 SpdLoad(AU2 p, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	const U32 u = g_dstUavs[5][p].r;
+	const U32 u = g_dstUAVs[5][p].r;
 	return AF4(asfloat(u), 0.0, 0.0, 0.0);
 }
 
 void SpdStore(AU2 p, AF4 value, AU1 mip, AU1 slice)
 {
 	ANKI_MAYBE_UNUSED(slice);
-	g_dstUavs[mip][p] = Vec4(asuint(value.x), 0.0, 0.0, 0.0);
+	g_dstUAVs[mip][p] = Vec4(asuint(value.x), 0.0, 0.0, 0.0);
 }
 
 void SpdIncreaseAtomicCounter(AU1 slice)

AnKi/Shaders/HiZReprojection.ankiprog → AnKi/Shaders/HZBReprojection.ankiprog

@@ -8,7 +8,7 @@
 #include <AnKi/Shaders/Common.hlsl>
 
 [[vk::binding(0)]] Texture2D g_inputDepthTex;
-[[vk::binding(1), vk::image_format("r32ui")]] RWTexture2D<U32> g_hiZUavTex;
+[[vk::binding(1), vk::image_format("r32ui")]] RWTexture2D<U32> g_HZBUAVTex;
 
 [[vk::push_constant]] ConstantBuffer<Mat4> g_reprojectionMat;
 
@@ -32,19 +32,15 @@
 	const Vec2 newUv = ndcToUv(newNdc);
 
 	// Store
-	Vec2 hiZTexSize;
-	g_hiZUavTex.GetDimensions(hiZTexSize.x, hiZTexSize.y);
-	const Vec2 texCoordsf = newUv * hiZTexSize;
-	if(any(texCoordsf < Vec2(0.0f, 0.0f)) || any(texCoordsf >= hiZTexSize))
+	Vec2 HZBTexSize;
+	g_HZBUAVTex.GetDimensions(HZBTexSize.x, HZBTexSize.y);
+	const Vec2 texCoordsf = newUv * HZBTexSize;
+	if(any(texCoordsf < Vec2(0.0f, 0.0f)) || any(texCoordsf >= HZBTexSize))
 	{
 		return;
 	}
 
-	U32 v;
-	if(svDispatchThreadId.x > 3440 / 2)
-		InterlockedMax(g_hiZUavTex[IVec2(texCoordsf)], asuint(depth), v);
-	else
-		InterlockedMax(g_hiZUavTex[IVec2(uv * hiZTexSize)], asuint(depth), v);
+	InterlockedMax(g_HZBUAVTex[IVec2(texCoordsf)], asuint(depth));
 }
 
 #pragma anki end

AnKi/Shaders/Include/MiscRendererTypes.h

@@ -147,7 +147,7 @@ struct SpotLightExtra
 	Mat4 m_textureMatrix;
 };
 
-struct GpuVisibilityUniforms
+struct GPUVisibilityUniforms
 {
 	Vec4 m_clipPlanes[6u];