Renaming

AnKi/Renderer/ClusterBinning2.cpp → AnKi/Renderer/ClusterBinning.cpp

@@ -3,7 +3,7 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Renderer/PrimaryNonRenderableVisibility.h>
 #include <AnKi/Renderer/Renderer.h>
 #include <AnKi/Renderer/ProbeReflections.h>
@@ -17,19 +17,19 @@
 
 namespace anki {
 
-ClusterBinning2::ClusterBinning2()
+ClusterBinning::ClusterBinning()
 {
 }
 
-ClusterBinning2::~ClusterBinning2()
+ClusterBinning::~ClusterBinning()
 {
 }
 
-Error ClusterBinning2::init()
+Error ClusterBinning::init()
 {
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/ClusterBinning2Setup.ankiprogbin", m_jobSetupProg, m_jobSetupGrProg));
 
-	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClusterBinning2.ankiprogbin", m_binningProg));
+	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClusterBinning.ankiprogbin", m_binningProg));
 
 	for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 	{
@@ -47,7 +47,7 @@ Error ClusterBinning2::init()
 	return Error::kNone;
 }
 
-void ClusterBinning2::populateRenderGraph(RenderingContext& ctx)
+void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 {
 	ANKI_TRACE_SCOPED_EVENT(ClusterBinning);
 
@@ -62,7 +62,7 @@ void ClusterBinning2::populateRenderGraph(RenderingContext& ctx)
 		CoreThreadHive::getSingleton().submitTask(
 			[](void* userData, [[maybe_unused]] U32 threadId, [[maybe_unused]] ThreadHive& hive,
 			   [[maybe_unused]] ThreadHiveSemaphore* signalSemaphore) {
-				static_cast<ClusterBinning2*>(userData)->writeClusterUniformsInternal();
+				static_cast<ClusterBinning*>(userData)->writeClusterUniformsInternal();
 			},
 			this);
 	}
@@ -214,7 +214,7 @@ void ClusterBinning2::populateRenderGraph(RenderingContext& ctx)
 		for(GpuSceneNonRenderableObjectType type : EnumIterable<GpuSceneNonRenderableObjectType>())
 		{
 			m_runCtx.m_packedObjectsBuffers[type] =
-				GpuVisibleTransientMemoryPool::getSingleton().allocate(kClusteredObjectSizes2[type] * kMaxVisibleClusteredObjects2[type]);
+				GpuVisibleTransientMemoryPool::getSingleton().allocate(kClusteredObjectSizes[type] * kMaxVisibleClusteredObjects[type]);
 			m_runCtx.m_packedObjectsHandles[type] = rgraph.importBuffer(BufferUsageBit::kNone, m_runCtx.m_packedObjectsBuffers[type]);
 		}
 
@@ -282,7 +282,7 @@ void ClusterBinning2::populateRenderGraph(RenderingContext& ctx)
 	}
 }
 
-void ClusterBinning2::writeClusterUniformsInternal()
+void ClusterBinning::writeClusterUniformsInternal()
 {
 	ANKI_TRACE_SCOPED_EVENT(RWriteClusterShadingObjects);
 

AnKi/Renderer/ClusterBinning2.h → AnKi/Renderer/ClusterBinning.h

@@ -13,12 +13,12 @@ namespace anki {
 /// @{
 
 /// Bins clusterer objects to the clusterer.
-class ClusterBinning2 : public RendererObject
+class ClusterBinning : public RendererObject
 {
 public:
-	ClusterBinning2();
+	ClusterBinning();
 
-	~ClusterBinning2();
+	~ClusterBinning();
 
 	Error init();
 

AnKi/Renderer/Dbg.cpp

@@ -9,7 +9,7 @@
 #include <AnKi/Renderer/LightShading.h>
 #include <AnKi/Renderer/FinalComposite.h>
 #include <AnKi/Renderer/ForwardShading.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Renderer/PrimaryNonRenderableVisibility.h>
 #include <AnKi/Scene.h>
 #include <AnKi/Util/Logger.h>
@@ -143,7 +143,7 @@ void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount,
 	unis.m_camTrf = ctx.m_matrices.m_cameraTransform;
 	cmdb.setPushConstants(&unis, sizeof(unis));
 
-	cmdb.bindStorageBuffer(0, 2, getRenderer().getClusterBinning2().getPackedObjectsBuffer(type));
+	cmdb.bindStorageBuffer(0, 2, getRenderer().getClusterBinning().getPackedObjectsBuffer(type));
 	cmdb.bindStorageBuffer(0, 3, getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
 
 	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearRepeat.get());

AnKi/Renderer/ForwardShading.cpp

@@ -10,7 +10,7 @@
 #include <AnKi/Renderer/ShadowMapping.h>
 #include <AnKi/Renderer/DepthDownscale.h>
 #include <AnKi/Renderer/LensFlare.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Renderer/LensFlare.h>
 #include <AnKi/Renderer/GBuffer.h>
 #include <AnKi/Renderer/Dbg.h>
@@ -58,14 +58,14 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 	rgraphCtx.bindTexture(set, U32(MaterialBinding::kDepthRt), getRenderer().getDepthDownscale().getRt(), DepthDownscale::kQuarterInternalResolution);
 	rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kLightVolume), getRenderer().getVolumetricLightingAccumulation().getRt());
 
-	cmdb.bindUniformBuffer(set, U32(MaterialBinding::kClusterShadingUniforms), getRenderer().getClusterBinning2().getClusteredShadingUniforms());
+	cmdb.bindUniformBuffer(set, U32(MaterialBinding::kClusterShadingUniforms), getRenderer().getClusterBinning().getClusteredShadingUniforms());
 
 	cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusterShadingLights),
-						   getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+						   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 
 	rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kClusterShadingLights) + 1, getRenderer().getShadowMapping().getShadowmapRt());
 
-	cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusters), getRenderer().getClusterBinning2().getClustersBuffer());
+	cmdb.bindStorageBuffer(set, U32(MaterialBinding::kClusters), getRenderer().getClusterBinning().getClustersBuffer());
 
 	// Draw
 	RenderableDrawerArguments args;

AnKi/Renderer/GBufferPost.cpp

@@ -6,7 +6,7 @@
 #include <AnKi/Renderer/GBufferPost.h>
 #include <AnKi/Renderer/Renderer.h>
 #include <AnKi/Renderer/GBuffer.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Util/Tracer.h>
 
 namespace anki {
@@ -76,9 +76,9 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 
 		cmdb.bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 
-		cmdb.bindUniformBuffer(0, 3, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
-		cmdb.bindStorageBuffer(0, 4, getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kDecal));
-		cmdb.bindStorageBuffer(0, 5, getRenderer().getClusterBinning2().getClustersBuffer());
+		cmdb.bindUniformBuffer(0, 3, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+		cmdb.bindStorageBuffer(0, 4, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kDecal));
+		cmdb.bindStorageBuffer(0, 5, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindAllBindless(1);
 
@@ -97,8 +97,8 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
 							   TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	rpass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
-	rpass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kDecal),
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kDecal),
 							  BufferUsageBit::kStorageFragmentRead);
 }
 

AnKi/Renderer/IndirectDiffuse.cpp

@@ -10,7 +10,7 @@
 #include <AnKi/Renderer/DownscaleBlur.h>
 #include <AnKi/Renderer/MotionVectors.h>
 #include <AnKi/Renderer/IndirectDiffuseProbes.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Util/Tracer.h>
 
@@ -265,21 +265,21 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kRead], readUsage);
 
 		prpass->newBufferDependency(
-			getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
+			getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
 			readBufferUsage);
-		prpass->newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), readBufferUsage);
+		prpass->newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), readBufferUsage);
 
 		prpass->setWork([this, &ctx, enableVrs](RenderPassWorkContext& rgraphCtx) {
 			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 			cmdb.bindShaderProgram(m_main.m_grProg.get());
 
-			BufferOffsetRange buff = getRenderer().getClusterBinning2().getClusteredShadingUniforms();
+			BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingUniforms();
 			cmdb.bindUniformBuffer(0, 0, buff.m_buffer, buff.m_offset, buff.m_range);
 
-			buff = getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe);
+			buff = getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe);
 			cmdb.bindStorageBuffer(0, 1, buff.m_buffer, buff.m_offset, buff.m_range);
 
-			buff = getRenderer().getClusterBinning2().getClustersBuffer();
+			buff = getRenderer().getClusterBinning().getClustersBuffer();
 			cmdb.bindStorageBuffer(0, 2, buff.m_buffer, buff.m_offset, buff.m_range);
 
 			cmdb.bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());

AnKi/Renderer/IndirectSpecular.cpp

@@ -11,7 +11,7 @@
 #include <AnKi/Renderer/ProbeReflections.h>
 #include <AnKi/Renderer/MotionVectors.h>
 #include <AnKi/Renderer/VrsSriGeneration.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Util/Tracer.h>
 
@@ -160,9 +160,9 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 		ppass->newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
 		ppass->newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(), readUsage);
 
-		ppass->newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kReflectionProbe),
+		ppass->newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kReflectionProbe),
 								   readBufferUsage);
-		ppass->newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), readBufferUsage);
+		ppass->newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), readBufferUsage);
 
 		ppass->setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			run(ctx, rgraphCtx);
@@ -211,13 +211,13 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	cmdb.bindSampler(0, 9, getRenderer().getSamplers().m_trilinearRepeat.get());
 	cmdb.bindTexture(0, 10, &m_noiseImage->getTextureView());
 
-	BufferOffsetRange buff = getRenderer().getClusterBinning2().getClusteredShadingUniforms();
+	BufferOffsetRange buff = getRenderer().getClusterBinning().getClusteredShadingUniforms();
 	cmdb.bindUniformBuffer(0, 11, buff.m_buffer, buff.m_offset, buff.m_range);
 
-	buff = getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kReflectionProbe);
+	buff = getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kReflectionProbe);
 	cmdb.bindStorageBuffer(0, 12, buff.m_buffer, buff.m_offset, buff.m_range);
 
-	buff = getRenderer().getClusterBinning2().getClustersBuffer();
+	buff = getRenderer().getClusterBinning().getClustersBuffer();
 	cmdb.bindStorageBuffer(0, 13, buff.m_buffer, buff.m_offset, buff.m_range);
 
 	cmdb.bindAllBindless(1);

AnKi/Renderer/LightShading.cpp

@@ -16,7 +16,7 @@
 #include <AnKi/Renderer/RtShadows.h>
 #include <AnKi/Renderer/IndirectDiffuse.h>
 #include <AnKi/Renderer/VrsSriGeneration.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Util/Tracer.h>
 #include <AnKi/Scene/Components/SkyboxComponent.h>
@@ -151,10 +151,10 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb.setDepthWrite(false);
 
 		// Bind all
-		cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
-		cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+		cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getShadowMapping().getShadowmapRt());
-		cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning2().getClustersBuffer());
+		cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_nearestNearestClamp.get());
 		cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClamp.get());
@@ -184,7 +184,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(2));
 		cmdb.bindTexture(0, 9, &getRenderer().getProbeReflections().getIntegrationLut());
 
-		cmdb.bindUniformBuffer(0, 10, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
+		cmdb.bindUniformBuffer(0, 10, getRenderer().getClusterBinning().getClusteredShadingUniforms());
 
 		const Vec4 pc(ctx.m_cameraNear, ctx.m_cameraFar, 0.0f, 0.0f);
 		cmdb.setPushConstants(&pc, sizeof(pc));
@@ -348,8 +348,8 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), readUsage);
 	pass.newTextureDependency(getRenderer().getShadowmapsResolve().getRt(), readUsage);
-	pass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
-	pass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
 							 BufferUsageBit::kStorageFragmentRead);
 
 	// Apply indirect

AnKi/Renderer/Renderer.cpp

@@ -43,7 +43,7 @@
 #include <AnKi/Renderer/IndirectDiffuse.h>
 #include <AnKi/Renderer/VrsSriGeneration.h>
 #include <AnKi/Renderer/PrimaryNonRenderableVisibility.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 
 namespace anki {
 
@@ -263,7 +263,7 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	m_motionVectors.reset(newInstance<MotionVectors>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_motionVectors->init());
 
-	m_clusterBinning2.reset(newInstance<ClusterBinning2>(RendererMemoryPool::getSingleton()));
+	m_clusterBinning2.reset(newInstance<ClusterBinning>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_clusterBinning2->init());
 
 	m_primaryNonRenderableVisibility.reset(newInstance<PrimaryNonRenderableVisibility>(RendererMemoryPool::getSingleton()));

AnKi/Renderer/RendererObject.def.h

@@ -30,4 +30,4 @@ ANKI_RENDERER_OBJECT_DEF(Scale, scale)
 ANKI_RENDERER_OBJECT_DEF(IndirectDiffuse, indirectDiffuse)
 ANKI_RENDERER_OBJECT_DEF(VrsSriGeneration, vrsSriGeneration)
 ANKI_RENDERER_OBJECT_DEF(PrimaryNonRenderableVisibility, primaryNonRenderableVisibility)
-ANKI_RENDERER_OBJECT_DEF(ClusterBinning2, clusterBinning2)
+ANKI_RENDERER_OBJECT_DEF(ClusterBinning, clusterBinning2)

AnKi/Renderer/RtShadows.cpp

@@ -10,7 +10,7 @@
 #include <AnKi/Renderer/AccelerationStructureBuilder.h>
 #include <AnKi/Renderer/MotionVectors.h>
 #include <AnKi/Renderer/DepthDownscale.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Util/Tracer.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Shaders/Include/MaterialTypes.h>
@@ -305,7 +305,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kImageTraceRaysWrite);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageTraceRaysRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageTraceRaysRead);
 
 		rpass.setWork([this, sbtBuffer](RenderPassWorkContext& rgraphCtx) {
 			ANKI_TRACE_SCOPED_EVENT(RtShadows);
@@ -337,8 +337,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			constexpr U32 kSet = 2;
 
-			cmdb.bindUniformBuffer(kSet, 0, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
-			cmdb.bindStorageBuffer(kSet, 1, getRenderer().getClusterBinning2().getClustersBuffer());
+			cmdb.bindUniformBuffer(kSet, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+			cmdb.bindStorageBuffer(kSet, 1, getRenderer().getClusterBinning().getClustersBuffer());
 
 			cmdb.bindSampler(kSet, 2, getRenderer().getSamplers().m_trilinearRepeat.get());
 

AnKi/Renderer/ShadowMapping.cpp

@@ -261,7 +261,7 @@ TileAllocatorResult2 ShadowMapping::allocateAtlasTiles(U32 lightUuid, U32 compon
 
 	for(U32 i = 0; i < faceCount; ++i)
 	{
-		TileAllocator2::ArrayOfLightUuids kickedOutLights(&getRenderer().getFrameMemoryPool());
+		TileAllocator::ArrayOfLightUuids kickedOutLights(&getRenderer().getFrameMemoryPool());
 
 		Array<U32, 4> tileViewport;
 		const TileAllocatorResult2 result = m_tileAlloc.allocate(

AnKi/Renderer/ShadowMapping.h

@@ -8,7 +8,7 @@
 #include <AnKi/Renderer/RendererObject.h>
 #include <AnKi/Gr.h>
 #include <AnKi/Resource/ImageResource.h>
-#include <AnKi/Renderer/Utils/TileAllocator2.h>
+#include <AnKi/Renderer/Utils/TileAllocator.h>
 
 namespace anki {
 
@@ -36,7 +36,7 @@ public:
 private:
 	class ViewportWorkItem;
 
-	TileAllocator2 m_tileAlloc;
+	TileAllocator m_tileAlloc;
 	static constexpr U32 kTileAllocHierarchyCount = 4;
 	static constexpr U32 kPointLightMaxTileAllocHierarchy = 1;
 	static constexpr U32 kSpotLightMaxTileAllocHierarchy = 1;

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -8,7 +8,7 @@
 #include <AnKi/Renderer/GBuffer.h>
 #include <AnKi/Renderer/ShadowMapping.h>
 #include <AnKi/Renderer/DepthDownscale.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Renderer/RtShadows.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Util/Tracer.h>
@@ -82,8 +82,8 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 								   TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
-		rpass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
 								  BufferUsageBit::kStorageComputeRead);
 
 		if(getRenderer().getRtShadowsEnabled())
@@ -105,8 +105,8 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 								   TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
 		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
 
-		rpass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
-		rpass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageFragmentRead);
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
 								  BufferUsageBit::kStorageFragmentRead);
 
 		if(getRenderer().getRtShadowsEnabled())
@@ -123,10 +123,10 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 
 	cmdb.bindShaderProgram(m_grProg.get());
 
-	cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
-	cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+	cmdb.bindUniformBuffer(0, 0, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+	cmdb.bindStorageBuffer(0, 1, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 	rgraphCtx.bindColorTexture(0, 2, getRenderer().getShadowMapping().getShadowmapRt());
-	cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning2().getClustersBuffer());
+	cmdb.bindStorageBuffer(0, 3, getRenderer().getClusterBinning().getClustersBuffer());
 
 	cmdb.bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp.get());
 	cmdb.bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClampShadow.get());

AnKi/Renderer/Utils/TileAllocator2.cpp → AnKi/Renderer/Utils/TileAllocator.cpp

@@ -3,11 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include <AnKi/Renderer/Utils/TileAllocator2.h>
+#include <AnKi/Renderer/Utils/TileAllocator.h>
 
 namespace anki {
 
-class TileAllocator2::Tile
+class TileAllocator::Tile
 {
 public:
 	Timestamp m_lastUsedTimestamp = 0; ///< The last timestamp this tile was used.
@@ -18,15 +18,15 @@ public:
 	U8 m_lightHierarchy = 0;
 };
 
-TileAllocator2::TileAllocator2()
+TileAllocator::TileAllocator()
 {
 }
 
-TileAllocator2::~TileAllocator2()
+TileAllocator::~TileAllocator()
 {
 }
 
-void TileAllocator2::init(U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching)
+void TileAllocator::init(U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching)
 {
 	// Preconditions
 	ANKI_ASSERT(tileCountX > 0);
@@ -101,7 +101,7 @@ void TileAllocator2::init(U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bo
 	}
 }
 
-void TileAllocator2::updateSubTiles(const Tile& updateFrom, U64 crntLightUuid, ArrayOfLightUuids& kickedOutLights)
+void TileAllocator::updateSubTiles(const Tile& updateFrom, U64 crntLightUuid, ArrayOfLightUuids& kickedOutLights)
 {
 	if(updateFrom.m_subTiles[0] == kMaxU32)
 	{
@@ -123,7 +123,7 @@ void TileAllocator2::updateSubTiles(const Tile& updateFrom, U64 crntLightUuid, A
 	}
 }
 
-void TileAllocator2::updateSuperTiles(const Tile& updateFrom, U64 crntLightUuid, ArrayOfLightUuids& kickedOutLights)
+void TileAllocator::updateSuperTiles(const Tile& updateFrom, U64 crntLightUuid, ArrayOfLightUuids& kickedOutLights)
 {
 	if(updateFrom.m_superTile != kMaxU32)
 	{
@@ -138,8 +138,8 @@ void TileAllocator2::updateSuperTiles(const Tile& updateFrom, U64 crntLightUuid,
 	}
 }
 
-Bool TileAllocator2::searchTileRecursively(U32 crntTileIdx, U32 crntTileHierarchy, U32 allocationHierarchy, Timestamp crntTimestamp,
-										   U32& emptyTileIdx, U32& toKickTileIdx, Timestamp& tileToKickMinTimestamp) const
+Bool TileAllocator::searchTileRecursively(U32 crntTileIdx, U32 crntTileHierarchy, U32 allocationHierarchy, Timestamp crntTimestamp, U32& emptyTileIdx,
+										  U32& toKickTileIdx, Timestamp& tileToKickMinTimestamp) const
 {
 	const Tile& tile = m_allTiles[crntTileIdx];
 
@@ -175,8 +175,8 @@ Bool TileAllocator2::searchTileRecursively(U32 crntTileIdx, U32 crntTileHierarch
 	return false;
 }
 
-Bool TileAllocator2::evaluateCandidate(U32 tileIdx, Timestamp crntTimestamp, U32& emptyTileIdx, U32& toKickTileIdx,
-									   Timestamp& tileToKickMinTimestamp) const
+Bool TileAllocator::evaluateCandidate(U32 tileIdx, Timestamp crntTimestamp, U32& emptyTileIdx, U32& toKickTileIdx,
+									  Timestamp& tileToKickMinTimestamp) const
 {
 	const Tile& tile = m_allTiles[tileIdx];
 
@@ -207,8 +207,8 @@ Bool TileAllocator2::evaluateCandidate(U32 tileIdx, Timestamp crntTimestamp, U32
 	return false;
 }
 
-TileAllocatorResult2 TileAllocator2::allocate(Timestamp crntTimestamp, U64 lightUuid, U32 hierarchy, Array<U32, 4>& tileViewport,
-											  ArrayOfLightUuids& kickedOutLightUuids)
+TileAllocatorResult2 TileAllocator::allocate(Timestamp crntTimestamp, U64 lightUuid, U32 hierarchy, Array<U32, 4>& tileViewport,
+											 ArrayOfLightUuids& kickedOutLightUuids)
 {
 	// Preconditions
 	ANKI_ASSERT(crntTimestamp > 0);
@@ -322,7 +322,7 @@ TileAllocatorResult2 TileAllocator2::allocate(Timestamp crntTimestamp, U64 light
 	return TileAllocatorResult2::kAllocationSucceded;
 }
 
-void TileAllocator2::invalidateCache(U64 lightUuid)
+void TileAllocator::invalidateCache(U64 lightUuid)
 {
 	ANKI_ASSERT(m_cachingEnabled);
 	ANKI_ASSERT(lightUuid > 0);

AnKi/Renderer/Utils/TileAllocator2.h → AnKi/Renderer/Utils/TileAllocator.h

@@ -22,18 +22,18 @@ enum class TileAllocatorResult2 : U8
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(TileAllocatorResult2)
 
 /// Allocates tiles out of a tilemap suitable for shadow mapping.
-class TileAllocator2
+class TileAllocator
 {
 public:
 	using ArrayOfLightUuids = DynamicArray<U64, MemoryPoolPtrWrapper<StackMemoryPool>>;
 
-	TileAllocator2();
+	TileAllocator();
 
-	TileAllocator2(const TileAllocator2&) = delete; // Non-copyable
+	TileAllocator(const TileAllocator&) = delete; // Non-copyable
 
-	~TileAllocator2();
+	~TileAllocator();
 
-	TileAllocator2& operator=(const TileAllocator2&) = delete; // Non-copyable
+	TileAllocator& operator=(const TileAllocator&) = delete; // Non-copyable
 
 	/// Initialize the allocator.
 	/// @param tileCountX The size of the smallest tile (0 hierarchy level).

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -7,7 +7,7 @@
 #include <AnKi/Renderer/ShadowMapping.h>
 #include <AnKi/Renderer/IndirectDiffuseProbes.h>
 #include <AnKi/Renderer/Renderer.h>
-#include <AnKi/Renderer/ClusterBinning2.h>
+#include <AnKi/Renderer/ClusterBinning.h>
 #include <AnKi/Resource/ImageResource.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Scene/Components/SkyboxComponent.h>
@@ -83,13 +83,13 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kImageComputeWrite);
 	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-	pass.newBufferDependency(getRenderer().getClusterBinning2().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
-	pass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kLight),
 							 BufferUsageBit::kStorageComputeRead);
 	pass.newBufferDependency(
-		getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
+		getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe),
 		BufferUsageBit::kStorageComputeRead);
-	pass.newBufferDependency(getRenderer().getClusterBinning2().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kFogDensityVolume),
+	pass.newBufferDependency(getRenderer().getClusterBinning().getPackedObjectsBufferHandle(GpuSceneNonRenderableObjectType::kFogDensityVolume),
 							 BufferUsageBit::kStorageComputeRead);
 
 	if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
@@ -114,13 +114,13 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 		rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_rts[0]);
 
-		cmdb.bindUniformBuffer(0, 6, getRenderer().getClusterBinning2().getClusteredShadingUniforms());
-		cmdb.bindStorageBuffer(0, 7, getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
+		cmdb.bindUniformBuffer(0, 6, getRenderer().getClusterBinning().getClusteredShadingUniforms());
+		cmdb.bindStorageBuffer(0, 7, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kLight));
 		rgraphCtx.bindColorTexture(0, 8, getRenderer().getShadowMapping().getShadowmapRt());
 		cmdb.bindStorageBuffer(0, 9,
-							   getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
-		cmdb.bindStorageBuffer(0, 10, getRenderer().getClusterBinning2().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kFogDensityVolume));
-		cmdb.bindStorageBuffer(0, 11, getRenderer().getClusterBinning2().getClustersBuffer());
+							   getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe));
+		cmdb.bindStorageBuffer(0, 10, getRenderer().getClusterBinning().getPackedObjectsBuffer(GpuSceneNonRenderableObjectType::kFogDensityVolume));
+		cmdb.bindStorageBuffer(0, 11, getRenderer().getClusterBinning().getClustersBuffer());
 
 		cmdb.bindAllBindless(1);
 

AnKi/Shaders/ClusterBinning2.ankiprog → AnKi/Shaders/ClusterBinning.ankiprog

@@ -64,7 +64,7 @@ constexpr UVec2 kSampleLocations[kSampleCount] = {LOCATION(1, -3), LOCATION(-1,
 	const U32 tileIdx = dispatchThreadIdX / kSampleCount;
 	const U32 sampleIdx = dispatchThreadIdX % kSampleCount;
 	const U32 visibleObjectIdx = svDispatchThreadId.y;
-	ANKI_ASSERT(visibleObjectIdx < kMaxVisibleClusteredObjects2[OBJECT_TYPE]);
+	ANKI_ASSERT(visibleObjectIdx < kMaxVisibleClusteredObjects[OBJECT_TYPE]);
 
 	const UVec2 tileXY = UVec2(tileIdx % g_unis.m_tileCountX, tileIdx / g_unis.m_tileCountX);
 

AnKi/Shaders/ClusterBinning2PackVisibles.ankiprog → AnKi/Shaders/ClusterBinningPackVisibles.ankiprog

@@ -37,7 +37,7 @@ typedef GpuSceneGlobalIlluminationProbe GpuSceneType;
 
 [numthreads(THREAD_GROUP_SIZE, 1, 1)] void main(UVec3 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
-	const U32 visibleObjCount = min(g_visibles[0], kMaxVisibleClusteredObjects2[OBJECT_TYPE]);
+	const U32 visibleObjCount = min(g_visibles[0], kMaxVisibleClusteredObjects[OBJECT_TYPE]);
 	const U32 idxOut = svDispatchThreadId.x;
 	if(idxOut >= visibleObjCount)
 	{

AnKi/Shaders/ClusterBinning2Setup.ankiprog → AnKi/Shaders/ClusterBinningSetup.ankiprog

@@ -38,7 +38,7 @@ constexpr U32 kPackVisiblesThreadgroupSize = 64;
 		// First threads set the dispatch args of cluster binning
 
 		const GpuSceneNonRenderableObjectType type = (GpuSceneNonRenderableObjectType)svDispatchThreadId;
-		const U32 objCount = min(kMaxVisibleClusteredObjects2[(U32)type], g_visibleIndices[(U32)type][0]);
+		const U32 objCount = min(kMaxVisibleClusteredObjects[(U32)type], g_visibleIndices[(U32)type][0]);
 
 		DispatchIndirectArgs args;
 		args.m_threadGroupCountX = (g_unis.m_tileCount * kSampleCount + kClusterBinningThreadgroupSize - 1) / kClusterBinningThreadgroupSize;
@@ -53,7 +53,7 @@ constexpr U32 kPackVisiblesThreadgroupSize = 64;
 
 		const GpuSceneNonRenderableObjectType type =
 			(GpuSceneNonRenderableObjectType)(svDispatchThreadId - (U32)GpuSceneNonRenderableObjectType::kCount);
-		const U32 objCount = min(kMaxVisibleClusteredObjects2[(U32)type], g_visibleIndices[(U32)type][0]);
+		const U32 objCount = min(kMaxVisibleClusteredObjects[(U32)type], g_visibleIndices[(U32)type][0]);
 
 		DispatchIndirectArgs args;
 		args.m_threadGroupCountX = (objCount + kPackVisiblesThreadgroupSize - 1) / kPackVisiblesThreadgroupSize;

AnKi/Shaders/Include/ClusteredShadingTypes.h

@@ -193,10 +193,10 @@ struct Cluster
 	U32 m_giProbesMask;
 };
 
-constexpr ANKI_ARRAY(U32, GpuSceneNonRenderableObjectType::kCount, kClusteredObjectSizes2) = {
+constexpr ANKI_ARRAY(U32, GpuSceneNonRenderableObjectType::kCount, kClusteredObjectSizes) = {
 	sizeof(LightUnion), sizeof(Decal), sizeof(FogDensityVolume), sizeof(ReflectionProbe), sizeof(GlobalIlluminationProbe)};
 
-constexpr ANKI_ARRAY(U32, GpuSceneNonRenderableObjectType::kCount, kMaxVisibleClusteredObjects2) = {
+constexpr ANKI_ARRAY(U32, GpuSceneNonRenderableObjectType::kCount, kMaxVisibleClusteredObjects) = {
 	kMaxVisibleLights, kMaxVisibleDecals, kMaxVisibleFogDensityVolumes, kMaxVisibleReflectionProbes, kMaxVisibleGlobalIlluminationProbes};
 
 ANKI_END_NAMESPACE

Tests/Renderer/TileAllocator.cpp

@@ -4,7 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include <Tests/Framework/Framework.h>
-#include <AnKi/Renderer/Utils/TileAllocator2.h>
+#include <AnKi/Renderer/Utils/TileAllocator.h>
 
 ANKI_TEST(Renderer, TileAllocator)
 {
@@ -14,9 +14,9 @@ ANKI_TEST(Renderer, TileAllocator)
 		StackMemoryPool pool;
 		pool.init(allocAligned, nullptr, 1024);
 
-		TileAllocator2::ArrayOfLightUuids kickedOutUuids(&pool);
+		TileAllocator::ArrayOfLightUuids kickedOutUuids(&pool);
 
-		TileAllocator2 talloc;
+		TileAllocator talloc;
 		talloc.init(8, 8, 3, true);
 
 		Array<U32, 4> viewport;
@@ -82,7 +82,7 @@ ANKI_TEST(Renderer, TileAllocator)
 		++crntTimestamp;
 
 		// Allocate 16 small
-		TileAllocator2::ArrayOfLightUuids allKicked(&pool);
+		TileAllocator::ArrayOfLightUuids allKicked(&pool);
 		for(U i = 0; i < 16; ++i)
 		{
 			res = talloc.allocate(crntTimestamp, lightUuid + 10 + i, kSmallTile, viewport, kickedOutUuids);