Some renaming

AnKi/Renderer/AccelerationStructureBuilder.cpp

@@ -42,7 +42,7 @@ void AccelerationStructureBuilder::populateRenderGraph(RenderingContext& ctx)
 	// Create the TLAS
 	AccelerationStructureInitInfo initInf("Main TLAS");
 	initInf.m_type = AccelerationStructureType::kTopLevel;
-	initInf.m_topLevel.m_indirectArgs.m_maxInstanceCount = GpuSceneArrays::RenderableAabbRt::getSingleton().getElementCount();
+	initInf.m_topLevel.m_indirectArgs.m_maxInstanceCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 	initInf.m_topLevel.m_indirectArgs.m_instancesBuffer = visOut.m_instancesBuffer.m_buffer;
 	initInf.m_topLevel.m_indirectArgs.m_instancesBufferOffset = visOut.m_instancesBuffer.m_offset;
 	m_runCtx.m_tlas = GrManager::getSingleton().newAccelerationStructure(initInf);

AnKi/Renderer/Dbg.cpp

@@ -173,7 +173,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 	// GBuffer renderables
 	{
-		const U32 allAabbCount = GpuSceneArrays::RenderableAabbGBuffer::getSingleton().getElementCount();
+		const U32 allAabbCount = GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getElementCount();
 
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_renderablesProg);
 		variantInitInfo.addMutation("DITHERED_DEPTH_TEST", U32(m_ditheredDepthTestOn != 0));
@@ -195,7 +195,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 		cmdb.setVertexAttribute(0, 0, Format::kR32G32B32_Sfloat, 0);
 		cmdb.bindIndexBuffer(m_cubeIndicesBuffer.get(), 0, IndexType::kU16);
 
-		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableAabbGBuffer::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange());
 		cmdb.bindStorageBuffer(0, 3, getRenderer().getGBuffer().getVisibleAabbsBuffer());
 
 		cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);
@@ -203,9 +203,9 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 	// Forward shading renderables
 	{
-		const U32 allAabbCount = GpuSceneArrays::RenderableAabbForward::getSingleton().getElementCount();
+		const U32 allAabbCount = GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getElementCount();
 
-		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableAabbForward::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 2, GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange());
 		cmdb.bindStorageBuffer(0, 3, getRenderer().getForwardShading().getVisibleAabbsBuffer());
 
 		cmdb.drawIndexed(PrimitiveTopology::kLines, 12 * 2, allAabbCount);

AnKi/Renderer/RtShadows.cpp

@@ -232,7 +232,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_setupBuildSbtGrProg.get());
 
-			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableAabbRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
 			cmdb.bindStorageBuffer(0, 1, sbtBuildIndirectArgsBuffer);
 
 			cmdb.dispatchCompute(1, 1, 1);
@@ -246,7 +246,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		// Allocate SBT
 		U8* sbtMem;
 		sbtBuffer = RebarTransientMemoryPool::getSingleton().allocateFrame(
-			(GpuSceneArrays::RenderableAabbRt::getSingleton().getElementCount() + 2) * m_sbtRecordSize, sbtMem);
+			(GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount() + 2) * m_sbtRecordSize, sbtMem);
 		sbtHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, sbtBuffer);
 
 		// Write the first 2 entries of the SBT
@@ -271,7 +271,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb.bindShaderProgram(m_buildSbtGrProg.get());
 
-			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableAabbRt::getSingleton().getBufferOffsetRange());
+			cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
 			cmdb.bindStorageBuffer(0, 1, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 			cmdb.bindStorageBuffer(0, 2, visibleRenderableIndicesBuff);
 			cmdb.bindStorageBuffer(0, 3, &m_rtLibraryGrProg->getShaderGroupHandlesGpuBuffer(), 0, kMaxPtrSize);
@@ -355,8 +355,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			cmdb.bindTexture(kSet, 13, &m_blueNoiseImage->getTextureView());
 
 			cmdb.traceRays(sbtBuffer.m_buffer, sbtBuffer.m_offset, m_sbtRecordSize,
-						   GpuSceneArrays::RenderableAabbRt::getSingleton().getElementCount(), 1, getRenderer().getInternalResolution().x() / 2,
-						   getRenderer().getInternalResolution().y() / 2, 1);
+						   GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount(), 1,
+						   getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, 1);
 		});
 	}
 

AnKi/Renderer/Utils/GpuVisibility.cpp

@@ -85,13 +85,13 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 	switch(in.m_technique)
 	{
 	case RenderingTechnique::kGBuffer:
-		aabbCount = GpuSceneArrays::RenderableAabbGBuffer::getSingleton().getElementCount();
+		aabbCount = GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getElementCount();
 		break;
 	case RenderingTechnique::kDepth:
-		aabbCount = GpuSceneArrays::RenderableAabbDepth::getSingleton().getElementCount();
+		aabbCount = GpuSceneArrays::RenderableBoundingVolumeDepth::getSingleton().getElementCount();
 		break;
 	case RenderingTechnique::kForward:
-		aabbCount = GpuSceneArrays::RenderableAabbForward::getSingleton().getElementCount();
+		aabbCount = GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getElementCount();
 		break;
 	default:
 		ANKI_ASSERT(0);
@@ -205,13 +205,13 @@ void GpuVisibility::populateRenderGraphInternal(Bool distanceBased, BaseGpuVisib
 		switch(technique)
 		{
 		case RenderingTechnique::kGBuffer:
-			aabbsBuffer = GpuSceneArrays::RenderableAabbGBuffer::getSingleton().getBufferOffsetRange();
+			aabbsBuffer = GpuSceneArrays::RenderableBoundingVolumeGBuffer::getSingleton().getBufferOffsetRange();
 			break;
 		case RenderingTechnique::kDepth:
-			aabbsBuffer = GpuSceneArrays::RenderableAabbDepth::getSingleton().getBufferOffsetRange();
+			aabbsBuffer = GpuSceneArrays::RenderableBoundingVolumeDepth::getSingleton().getBufferOffsetRange();
 			break;
 		case RenderingTechnique::kForward:
-			aabbsBuffer = GpuSceneArrays::RenderableAabbForward::getSingleton().getBufferOffsetRange();
+			aabbsBuffer = GpuSceneArrays::RenderableBoundingVolumeForward::getSingleton().getBufferOffsetRange();
 			break;
 		default:
 			ANKI_ASSERT(0);
@@ -525,7 +525,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 	}
 
 	// Allocate the transient buffers
-	const U32 aabbCount = GpuSceneArrays::RenderableAabbRt::getSingleton().getElementCount();
+	const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 
 	out.m_instancesBuffer = GpuVisibleTransientMemoryPool::getSingleton().allocate(aabbCount * sizeof(AccelerationStructureInstance));
 	out.m_someBufferHandle = rgraph.importBuffer(BufferUsageBit::kStorageComputeWrite, out.m_instancesBuffer);
@@ -570,7 +570,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 
 		cmdb.setPushConstants(&unis, sizeof(unis));
 
-		cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableAabbRt::getSingleton().getBufferOffsetRange());
+		cmdb.bindStorageBuffer(0, 0, GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getBufferOffsetRange());
 		cmdb.bindStorageBuffer(0, 1, GpuSceneArrays::Renderable::getSingleton().getBufferOffsetRange());
 		cmdb.bindStorageBuffer(0, 2, &GpuSceneBuffer::getSingleton().getBuffer(), 0, kMaxPtrSize);
 		cmdb.bindStorageBuffer(0, 3, instancesBuff);
@@ -578,7 +578,7 @@ void GpuVisibilityAccelerationStructures::pupulateRenderGraph(GpuVisibilityAccel
 		cmdb.bindStorageBuffer(0, 5, rangeBuff);
 		cmdb.bindStorageBuffer(0, 6, m_counterBuffer.get(), counterBufferOffset, sizeof(U32) * 2);
 
-		const U32 aabbCount = GpuSceneArrays::RenderableAabbRt::getSingleton().getElementCount();
+		const U32 aabbCount = GpuSceneArrays::RenderableBoundingVolumeRt::getSingleton().getElementCount();
 		dispatchPPCompute(cmdb, 64, 1, aabbCount, 1);
 	});
 

AnKi/Scene/Components/ModelComponent.cpp

@@ -289,9 +289,9 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 			for(RenderingTechnique t :
 				EnumBitsIterable<RenderingTechnique, RenderingTechniqueBit>(m_patchInfos[i].m_techniques & ~RenderingTechniqueBit::kAllRt))
 			{
-				const GpuSceneRenderableAabb gpuVolume =
-					initGpuSceneRenderableAabb(aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(), m_patchInfos[i].m_gpuSceneRenderable.getIndex(),
-											   m_patchInfos[i].m_renderStateBucketIndices[t].get());
+				const GpuSceneRenderableBoundingVolume gpuVolume = initGpuSceneRenderableBoundingVolume(
+					aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(), m_patchInfos[i].m_gpuSceneRenderable.getIndex(),
+					m_patchInfos[i].m_renderStateBucketIndices[t].get());
 
 				switch(t)
 				{
@@ -313,8 +313,8 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 			if(!!(m_patchInfos[i].m_techniques & RenderingTechniqueBit::kAllRt))
 			{
 				const U32 bucket = 0;
-				const GpuSceneRenderableAabb gpuVolume = initGpuSceneRenderableAabb(aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(),
-																					m_patchInfos[i].m_gpuSceneRenderable.getIndex(), bucket);
+				const GpuSceneRenderableBoundingVolume gpuVolume = initGpuSceneRenderableBoundingVolume(
+					aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(), m_patchInfos[i].m_gpuSceneRenderable.getIndex(), bucket);
 
 				m_patchInfos[i].m_gpuSceneRenderableAabbRt.uploadToGpuScene(gpuVolume);
 			}

AnKi/Scene/Components/ModelComponent.h

@@ -52,10 +52,10 @@ private:
 
 		GpuSceneArrays::MeshLod::Allocation m_gpuSceneMeshLods;
 		GpuSceneArrays::Renderable::Allocation m_gpuSceneRenderable;
-		GpuSceneArrays::RenderableAabbGBuffer::Allocation m_gpuSceneRenderableAabbGBuffer;
-		GpuSceneArrays::RenderableAabbDepth::Allocation m_gpuSceneRenderableAabbDepth;
-		GpuSceneArrays::RenderableAabbForward::Allocation m_gpuSceneRenderableAabbForward;
-		GpuSceneArrays::RenderableAabbRt::Allocation m_gpuSceneRenderableAabbRt;
+		GpuSceneArrays::RenderableBoundingVolumeGBuffer::Allocation m_gpuSceneRenderableAabbGBuffer;
+		GpuSceneArrays::RenderableBoundingVolumeDepth::Allocation m_gpuSceneRenderableAabbDepth;
+		GpuSceneArrays::RenderableBoundingVolumeForward::Allocation m_gpuSceneRenderableAabbForward;
+		GpuSceneArrays::RenderableBoundingVolumeRt::Allocation m_gpuSceneRenderableAabbRt;
 
 		Array<RenderStateBucketIndex, U32(RenderingTechnique::kCount)> m_renderStateBucketIndices;
 		RenderingTechniqueBit m_techniques;

AnKi/Scene/Components/ParticleEmitterComponent.cpp

@@ -427,13 +427,13 @@ Error ParticleEmitterComponent::update(SceneComponentUpdateInfo& info, Bool& upd
 		m_gpuSceneParticleEmitter.uploadToGpuScene(particles);
 	}
 
-	// Upload the GpuSceneRenderableAabb always
+	// Upload the GpuSceneRenderableBoundingVolume always
 	for(RenderingTechnique t : EnumIterable<RenderingTechnique>())
 	{
 		if(!!(RenderingTechniqueBit(1 << t) & m_particleEmitterResource->getMaterial()->getRenderingTechniques()))
 		{
-			const GpuSceneRenderableAabb gpuVolume = initGpuSceneRenderableAabb(aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(),
-																				m_gpuSceneRenderable.getIndex(), m_renderStateBuckets[t].get());
+			const GpuSceneRenderableBoundingVolume gpuVolume = initGpuSceneRenderableBoundingVolume(
+				aabbWorld.getMin().xyz(), aabbWorld.getMax().xyz(), m_gpuSceneRenderable.getIndex(), m_renderStateBuckets[t].get());
 			switch(t)
 			{
 			case RenderingTechnique::kGBuffer:

AnKi/Scene/Components/ParticleEmitterComponent.h

@@ -69,9 +69,9 @@ private:
 	GpuSceneArrays::ParticleEmitter::Allocation m_gpuSceneParticleEmitter;
 	GpuSceneArrays::Renderable::Allocation m_gpuSceneRenderable;
 	GpuSceneArrays::MeshLod::Allocation m_gpuSceneMeshLods;
-	GpuSceneArrays::RenderableAabbGBuffer::Allocation m_gpuSceneRenderableAabbGBuffer;
-	GpuSceneArrays::RenderableAabbDepth::Allocation m_gpuSceneRenderableAabbDepth;
-	GpuSceneArrays::RenderableAabbForward::Allocation m_gpuSceneRenderableAabbForward;
+	GpuSceneArrays::RenderableBoundingVolumeGBuffer::Allocation m_gpuSceneRenderableAabbGBuffer;
+	GpuSceneArrays::RenderableBoundingVolumeDepth::Allocation m_gpuSceneRenderableAabbDepth;
+	GpuSceneArrays::RenderableBoundingVolumeForward::Allocation m_gpuSceneRenderableAabbForward;
 
 	Array<RenderStateBucketIndex, U32(RenderingTechnique::kCount)> m_renderStateBuckets;
 

AnKi/Scene/GpuSceneArrays.def.h

@@ -33,13 +33,13 @@ ANKI_CAT_TYPE(FogDensityVolume, GpuSceneFogDensityVolume, 0, g_minGpuSceneFogDen
 ANKI_CAT_SEPARATOR
 ANKI_CAT_TYPE(Renderable, GpuSceneRenderable, 0, g_minGpuSceneRenderablesCVar)
 ANKI_CAT_SEPARATOR
-ANKI_CAT_TYPE(RenderableAabbGBuffer, GpuSceneRenderableAabb, 0, g_minGpuSceneRenderablesCVar)
+ANKI_CAT_TYPE(RenderableBoundingVolumeGBuffer, GpuSceneRenderableBoundingVolume, 0, g_minGpuSceneRenderablesCVar)
 ANKI_CAT_SEPARATOR
-ANKI_CAT_TYPE(RenderableAabbForward, GpuSceneRenderableAabb, 1, g_minGpuSceneRenderablesCVar)
+ANKI_CAT_TYPE(RenderableBoundingVolumeForward, GpuSceneRenderableBoundingVolume, 1, g_minGpuSceneRenderablesCVar)
 ANKI_CAT_SEPARATOR
-ANKI_CAT_TYPE(RenderableAabbDepth, GpuSceneRenderableAabb, 2, g_minGpuSceneRenderablesCVar)
+ANKI_CAT_TYPE(RenderableBoundingVolumeDepth, GpuSceneRenderableBoundingVolume, 2, g_minGpuSceneRenderablesCVar)
 ANKI_CAT_SEPARATOR
-ANKI_CAT_TYPE(RenderableAabbRt, GpuSceneRenderableAabb, 3, g_minGpuSceneRenderablesCVar)
+ANKI_CAT_TYPE(RenderableBoundingVolumeRt, GpuSceneRenderableBoundingVolume, 3, g_minGpuSceneRenderablesCVar)
 
 #undef ANKI_TRF_ARR
 #undef ANKI_MESH_ARR

AnKi/Shaders/DbgRenderables.ankiprog

@@ -16,8 +16,8 @@ struct Uniforms
 
 [[vk::push_constant]] ConstantBuffer<Uniforms> g_uniforms;
 
-[[vk::binding(2)]] StructuredBuffer<GpuSceneRenderableAabb> g_aabbs;
-[[vk::binding(3)]] StructuredBuffer<U32> g_visibleAabbIndices;
+[[vk::binding(2)]] StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes;
+[[vk::binding(3)]] StructuredBuffer<U32> g_visibleRenderableBoundingVolumeIndices;
 
 struct VertOut
 {
@@ -35,12 +35,12 @@ VertOut main(VertIn input)
 {
 	VertOut output;
 
-	const U32 aabbCount = g_visibleAabbIndices[0];
+	const U32 bvolumeCount = g_visibleRenderableBoundingVolumeIndices[0];
 
-	if(input.m_svInstanceId < aabbCount)
+	if(input.m_svInstanceId < bvolumeCount)
 	{
-		const GpuSceneRenderableAabb aabb = g_aabbs[g_visibleAabbIndices[input.m_svInstanceId + 1]];
-		Vec3 localPos = input.m_position * aabb.m_aabbExtend + aabb.m_sphereCenter;
+		const GpuSceneRenderableBoundingVolume bvol = g_renderableBoundingVolumes[g_visibleRenderableBoundingVolumeIndices[input.m_svInstanceId + 1]];
+		Vec3 localPos = input.m_position * bvol.m_aabbExtend + bvol.m_sphereCenter;
 		output.m_svPosition = mul(g_uniforms.m_viewProjMat, Vec4(localPos, 1.0));
 	}
 	else

AnKi/Shaders/GpuVisibility.ankiprog

@@ -27,7 +27,7 @@ struct DrawIndirectArgsWithPadding
 };
 
 // Buffers that point to the GPU scene
-[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableAabb> g_aabbs;
+[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes;
 [[vk::binding(1)]] StructuredBuffer<GpuSceneRenderable> g_renderables;
 [[vk::binding(2)]] ByteAddressBuffer g_gpuScene;
 
@@ -62,29 +62,29 @@ struct DrawIndirectArgsWithPadding
 
 [numthreads(64, 1, 1)] void main(UVec3 svDispatchThreadId : SV_DISPATCHTHREADID)
 {
-	const U32 aabbIdx = svDispatchThreadId.x;
-	U32 aabbCount;
+	const U32 bvolumeIdx = svDispatchThreadId.x;
+	U32 bvolumeCount;
 	U32 unused;
-	g_aabbs.GetDimensions(aabbCount, unused);
-	if(aabbIdx >= aabbCount)
+	g_renderableBoundingVolumes.GetDimensions(bvolumeCount, unused);
+	if(bvolumeIdx >= bvolumeCount)
 	{
 		return;
 	}
 
-	const GpuSceneRenderableAabb aabb = g_aabbs[aabbIdx];
+	const GpuSceneRenderableBoundingVolume bvolume = g_renderableBoundingVolumes[bvolumeIdx];
 
 #if DISTANCE_TEST == 0
 	// Frustum test
 	//
-	if(!frustumTest(g_unis.m_clipPlanes, aabb.m_sphereCenter, aabb.m_sphereRadius))
+	if(!frustumTest(g_unis.m_clipPlanes, bvolume.m_sphereCenter, bvolume.m_sphereRadius))
 	{
 		return;
 	}
 
 	// Screen-space AABB calculation and checking
 	//
-	const Vec3 A = aabb.m_sphereCenter - aabb.m_aabbExtend;
-	const Vec3 B = aabb.m_sphereCenter + aabb.m_aabbExtend;
+	const Vec3 A = bvolume.m_sphereCenter - bvolume.m_aabbExtend;
+	const Vec3 B = bvolume.m_sphereCenter + bvolume.m_aabbExtend;
 	const Vec3 aabbEdges[8u] = {Vec3(A.x, A.y, A.z), Vec3(B.x, A.y, A.z), Vec3(A.x, B.y, A.z), Vec3(A.x, A.y, B.z),
 								Vec3(B.x, B.y, A.z), Vec3(B.x, A.y, B.z), Vec3(A.x, B.y, B.z), Vec3(B.x, B.y, B.z)};
 
@@ -150,7 +150,7 @@ struct DrawIndirectArgsWithPadding
 	}
 #	endif // HZB_TEST
 #else // DISTANCE_TEST == 1
-	if(!testSphereSphereCollision(aabb.m_sphereCenter, aabb.m_sphereRadius, g_unis.m_pointOfTest, g_unis.m_testRadius))
+	if(!testSphereSphereCollision(bvolume.m_sphereCenter, bvolume.m_sphereRadius, g_unis.m_pointOfTest, g_unis.m_testRadius))
 	{
 		return;
 	}
@@ -158,7 +158,7 @@ struct DrawIndirectArgsWithPadding
 
 	// Compute the LOD
 	//
-	const F32 distFromLodPoint = length(aabb.m_sphereCenter - g_unis.m_lodReferencePoint) - aabb.m_sphereRadius;
+	const F32 distFromLodPoint = length(bvolume.m_sphereCenter - g_unis.m_lodReferencePoint) - bvolume.m_sphereRadius;
 
 	U32 lod;
 	if(distFromLodPoint < g_unis.m_maxLodDistances[0])
@@ -176,8 +176,8 @@ struct DrawIndirectArgsWithPadding
 
 	// Add the drawcall
 	//
-	const U32 renderStateBucket = aabb.m_renderableIndexAndRenderStateBucket & ((1u << 12u) - 1u);
-	const U32 renderableIdx = aabb.m_renderableIndexAndRenderStateBucket >> 12u;
+	const U32 renderStateBucket = bvolume.m_renderableIndexAndRenderStateBucket & ((1u << 12u) - 1u);
+	const U32 renderableIdx = bvolume.m_renderableIndexAndRenderStateBucket >> 12u;
 
 	U32 indirectIdx;
 	InterlockedAdd(g_mdiDrawCounts[renderStateBucket], 1, indirectIdx);
@@ -252,7 +252,7 @@ struct DrawIndirectArgsWithPadding
 #if GATHER_AABBS
 	U32 index;
 	InterlockedAdd(g_visibleAabbIndices[0], 1, index);
-	g_visibleAabbIndices[index + 1] = aabbIdx;
+	g_visibleAabbIndices[index + 1] = bvolumeIdx;
 #endif
 }
 

AnKi/Shaders/GpuVisibilityAccelerationStructures.ankiprog

@@ -11,7 +11,7 @@
 #include <AnKi/Shaders/CollisionFunctions.hlsl>
 
 // Buffers that point to the GPU scene
-[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableAabb> g_aabbs;
+[[vk::binding(0)]] StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes;
 [[vk::binding(1)]] StructuredBuffer<GpuSceneRenderable> g_renderables;
 [[vk::binding(2)]] ByteAddressBuffer g_gpuScene;
 
@@ -28,18 +28,18 @@
 [numthreads(NUMTHREADS, 1, 1)] void main(U32 svDispatchThreadId : SV_DISPATCHTHREADID, U32 svGroupIndex : SV_GROUPINDEX)
 {
 	// Skip remaining threads
-	const U32 aabbIdx = svDispatchThreadId;
-	U32 aabbCount;
+	const U32 bvolumeIdx = svDispatchThreadId;
+	U32 bvolumeCount;
 	U32 unused;
-	g_aabbs.GetDimensions(aabbCount, unused);
-	Bool visible = (aabbIdx < aabbCount);
+	g_renderableBoundingVolumes.GetDimensions(bvolumeCount, unused);
+	Bool visible = (bvolumeIdx < bvolumeCount);
 
 	// Sphere test
-	GpuSceneRenderableAabb aabb;
+	GpuSceneRenderableBoundingVolume bvolume;
 	if(visible)
 	{
-		aabb = g_aabbs[aabbIdx];
-		visible = testSphereSphereCollision(aabb.m_sphereCenter, aabb.m_sphereRadius, g_unis.m_pointOfTest, aabb.m_sphereRadius);
+		bvolume = g_renderableBoundingVolumes[bvolumeIdx];
+		visible = testSphereSphereCollision(bvolume.m_sphereCenter, bvolume.m_sphereRadius, g_unis.m_pointOfTest, bvolume.m_sphereRadius);
 	}
 
 	// All good, write the instance
@@ -47,11 +47,11 @@
 	{
 		// LOD selection
 		U32 lod;
-		const Bool insideCameraFrustum = frustumTest(g_unis.m_clipPlanes, aabb.m_sphereCenter, aabb.m_sphereRadius);
+		const Bool insideCameraFrustum = frustumTest(g_unis.m_clipPlanes, bvolume.m_sphereCenter, bvolume.m_sphereRadius);
 		if(insideCameraFrustum)
 		{
 			// Visible by the camera, need to match the camera LODs
-			const F32 distFromLodPoint = length(aabb.m_sphereCenter - g_unis.m_pointOfTest) - aabb.m_sphereRadius;
+			const F32 distFromLodPoint = length(bvolume.m_sphereCenter - g_unis.m_pointOfTest) - bvolume.m_sphereRadius;
 			if(distFromLodPoint < g_unis.m_maxLodDistances[0])
 			{
 				lod = 0u;
@@ -71,7 +71,7 @@
 			lod = 2u;
 		}
 
-		const U32 renderableIdx = aabb.m_renderableIndexAndRenderStateBucket >> 12u;
+		const U32 renderableIdx = bvolume.m_renderableIndexAndRenderStateBucket >> 12u;
 		const GpuSceneRenderable renderable = g_renderables[renderableIdx];
 
 		const U32 meshLodOffset = renderable.m_meshLodsOffset + sizeof(GpuSceneMeshLod) * lod;
@@ -103,7 +103,7 @@
 		{
 			U32 threadgroupIdx;
 			InterlockedAdd(g_counterBuffer[1], 1, threadgroupIdx);
-			const U32 threadgroupCount = (aabbCount + NUMTHREADS - 1) / NUMTHREADS;
+			const U32 threadgroupCount = (bvolumeCount + NUMTHREADS - 1) / NUMTHREADS;
 			lastThreadgroupExecuting = (threadgroupIdx + 1 == threadgroupCount);
 		}
 

AnKi/Shaders/Include/GpuSceneFunctions.h

@@ -19,9 +19,9 @@ inline GpuSceneRenderableVertex unpackGpuSceneRenderableVertex(UVec4 x)
 	return o;
 }
 
-inline GpuSceneRenderableAabb initGpuSceneRenderableAabb(Vec3 aabbMin, Vec3 aabbMax, U32 renderableIndex, U32 renderStateBucket)
+inline GpuSceneRenderableBoundingVolume initGpuSceneRenderableBoundingVolume(Vec3 aabbMin, Vec3 aabbMax, U32 renderableIndex, U32 renderStateBucket)
 {
-	GpuSceneRenderableAabb gpuVolume;
+	GpuSceneRenderableBoundingVolume gpuVolume;
 
 	gpuVolume.m_sphereCenter = (aabbMin + aabbMax) * 0.5f;
 	gpuVolume.m_aabbExtend = aabbMax - gpuVolume.m_sphereCenter;

AnKi/Shaders/Include/GpuSceneTypes.h

@@ -39,7 +39,7 @@ struct GpuSceneRenderableVertex
 static_assert(sizeof(GpuSceneRenderableVertex) == sizeof(UVec4));
 
 /// Used in visibility testing.
-struct GpuSceneRenderableAabb
+struct GpuSceneRenderableBoundingVolume
 {
 	Vec3 m_sphereCenter ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
 	F32 m_sphereRadius ANKI_CPP_CODE(= 0.0f);
@@ -47,7 +47,7 @@ struct GpuSceneRenderableAabb
 	Vec3 m_aabbExtend ANKI_CPP_CODE(= Vec3(0.0f));
 	U32 m_renderableIndexAndRenderStateBucket; ///< High 20bits point to a GpuSceneRenderable. Rest 12bits are the render state bucket idx.
 };
-static_assert(sizeof(GpuSceneRenderableAabb) == sizeof(Vec4) * 2);
+static_assert(sizeof(GpuSceneRenderableBoundingVolume) == sizeof(Vec4) * 2);
 
 /// Represents the geometry data of a single LOD of an indexed mesh.
 struct GpuSceneMeshLod