Editor: Add non-renderables in object picking

AnKi/Renderer/Dbg.cpp

@@ -539,11 +539,13 @@ void Dbg::initGizmos()
 }
 
 void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount, const RenderingContext& ctx, const ImageResource& image,
-							CommandBuffer& cmdb)
+							Bool objectPicking, RenderPassWorkContext& rgraphCtx)
 {
+	CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
 	variantInitInfo.addMutation("OBJECT_TYPE", U32(type));
-	variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "Bilboards");
+	variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, (objectPicking) ? "BilboardsPicking" : "Bilboards");
 	const ShaderProgramResourceVariant* variant;
 	m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
 	cmdb.bindShaderProgram(&variant->getProgram());
@@ -562,13 +564,17 @@ void Dbg::drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount,
 	consts.m_depthFailureVisualization = !(m_options & DbgOption::kDepthTest);
 	cmdb.setFastConstants(&consts, sizeof(consts));
 
+	if(!objectPicking)
+	{
+		rgraphCtx.bindSrv(0, 0, getGBuffer().getDepthRt());
+	}
 	cmdb.bindSrv(1, 0, getClusterBinning().getPackedObjectsBuffer(type));
 	cmdb.bindSrv(2, 0, getRenderer().getPrimaryNonRenderableVisibility().getVisibleIndicesBuffer(type));
-
-	cmdb.bindSampler(1, 0, getRenderer().getSamplers().m_trilinearRepeat.get());
 	cmdb.bindSrv(3, 0, TextureView(&image.getTexture(), TextureSubresourceDesc::all()));
 	cmdb.bindSrv(4, 0, TextureView(&m_spotLightImage->getTexture(), TextureSubresourceDesc::all()));
 
+	cmdb.bindSampler(1, 0, getRenderer().getSamplers().m_trilinearRepeat.get());
+
 	cmdb.draw(PrimitiveTopology::kTriangles, 6, objCount);
 }
 
@@ -698,13 +704,13 @@ void Dbg::populateRenderGraphMain(RenderingContext& ctx)
 		if(!!(m_options & DbgOption::kIcons))
 		{
 			drawNonRenderable(GpuSceneNonRenderableObjectType::kLight, GpuSceneArrays::Light::getSingleton().getElementCount(), ctx,
-							  *m_pointLightImage, cmdb);
+							  *m_pointLightImage, false, rgraphCtx);
 			drawNonRenderable(GpuSceneNonRenderableObjectType::kDecal, GpuSceneArrays::Decal::getSingleton().getElementCount(), ctx, *m_decalImage,
-							  cmdb);
+							  false, rgraphCtx);
 			drawNonRenderable(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe,
-							  GpuSceneArrays::GlobalIlluminationProbe::getSingleton().getElementCount(), ctx, *m_giProbeImage, cmdb);
+							  GpuSceneArrays::GlobalIlluminationProbe::getSingleton().getElementCount(), ctx, *m_giProbeImage, false, rgraphCtx);
 			drawNonRenderable(GpuSceneNonRenderableObjectType::kReflectionProbe, GpuSceneArrays::ReflectionProbe::getSingleton().getElementCount(),
-							  ctx, *m_reflectionImage, cmdb);
+							  ctx, *m_reflectionImage, false, rgraphCtx);
 		}
 
 		// Physics
@@ -874,7 +880,7 @@ void Dbg::populateRenderGraphObjectPicking(RenderingContext& ctx)
 
 			ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
 			variantInitInfo.addMutation("OBJECT_TYPE", 0);
-			variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kCompute, "PrepareRenderableUuids");
+			variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kCompute, "PrepareRenderablesPicking");
 			const ShaderProgramResourceVariant* variant;
 			m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
 			cmdb.bindShaderProgram(&variant->getProgram());
@@ -929,45 +935,57 @@ void Dbg::populateRenderGraphObjectPicking(RenderingContext& ctx)
 		depthRti.m_subresource.m_depthStencilAspect = DepthStencilAspectBit::kDepth;
 		pass.setRenderpassInfo({colorRti}, &depthRti);
 
-		pass.setWork(
-			[this, lodAndRenderableIndicesBuff, &ctx, drawIndirectArgsBuff, drawCountBuff, maxVisibleCount](RenderPassWorkContext& rgraphCtx) {
-				CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
+		pass.setWork([this, lodAndRenderableIndicesBuff, &ctx, drawIndirectArgsBuff, drawCountBuff,
+					  maxVisibleCount](RenderPassWorkContext& rgraphCtx) {
+			CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
 
-				// Set common state
-				cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x / 2, getRenderer().getInternalResolution().y / 2);
-				cmdb.setDepthCompareOperation(CompareOperation::kLess);
+			// Set common state
+			cmdb.setViewport(0, 0, getRenderer().getInternalResolution().x / 2, getRenderer().getInternalResolution().y / 2);
+			cmdb.setDepthCompareOperation(CompareOperation::kLess);
 
-				ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
-				variantInitInfo.addMutation("OBJECT_TYPE", 0);
-				variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "RenderableUuids");
-				const ShaderProgramResourceVariant* variant;
-				m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
-				cmdb.bindShaderProgram(&variant->getProgram());
+			ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
+			variantInitInfo.addMutation("OBJECT_TYPE", 0);
+			variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, "RenderablesPicking");
+			const ShaderProgramResourceVariant* variant;
+			m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
+			cmdb.bindShaderProgram(&variant->getProgram());
 
-				cmdb.bindIndexBuffer(UnifiedGeometryBuffer::getSingleton().getBufferView(), IndexType::kU16);
+			cmdb.bindIndexBuffer(UnifiedGeometryBuffer::getSingleton().getBufferView(), IndexType::kU16);
 
-				cmdb.bindSrv(0, 0, lodAndRenderableIndicesBuff);
-				cmdb.bindSrv(1, 0, GpuSceneArrays::Renderable::getSingleton().getBufferView());
-				cmdb.bindSrv(2, 0, GpuSceneArrays::MeshLod::getSingleton().getBufferView());
-				cmdb.bindSrv(3, 0, GpuSceneArrays::Transform::getSingleton().getBufferView());
-				cmdb.bindSrv(4, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR16G16B16A16_Unorm);
-				cmdb.bindSrv(5, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR8G8B8A8_Uint);
-				cmdb.bindSrv(6, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR8G8B8A8_Snorm);
-				cmdb.bindSrv(7, 0, GpuSceneBuffer::getSingleton().getBufferView());
+			cmdb.bindSrv(0, 0, lodAndRenderableIndicesBuff);
+			cmdb.bindSrv(1, 0, GpuSceneArrays::Renderable::getSingleton().getBufferView());
+			cmdb.bindSrv(2, 0, GpuSceneArrays::MeshLod::getSingleton().getBufferView());
+			cmdb.bindSrv(3, 0, GpuSceneArrays::Transform::getSingleton().getBufferView());
+			cmdb.bindSrv(4, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR16G16B16A16_Unorm);
+			cmdb.bindSrv(5, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR8G8B8A8_Uint);
+			cmdb.bindSrv(6, 0, UnifiedGeometryBuffer::getSingleton().getBufferView(), Format::kR8G8B8A8_Snorm);
+			cmdb.bindSrv(7, 0, GpuSceneBuffer::getSingleton().getBufferView());
 
-				cmdb.setFastConstants(&ctx.m_matrices.m_viewProjection, sizeof(ctx.m_matrices.m_viewProjection));
+			cmdb.setFastConstants(&ctx.m_matrices.m_viewProjection, sizeof(ctx.m_matrices.m_viewProjection));
 
-				cmdb.drawIndexedIndirectCount(PrimitiveTopology::kTriangles, drawIndirectArgsBuff, sizeof(DrawIndexedIndirectArgs), drawCountBuff,
-											  maxVisibleCount);
+			cmdb.drawIndexedIndirectCount(PrimitiveTopology::kTriangles, drawIndirectArgsBuff, sizeof(DrawIndexedIndirectArgs), drawCountBuff,
+										  maxVisibleCount);
 
-				// Draw gizmos
-				if(m_gizmos.m_enabled)
-				{
-					cmdb.setDepthCompareOperation(CompareOperation::kAlways);
-					drawGizmos(m_gizmos.m_trf, ctx, true, cmdb);
-					cmdb.setDepthCompareOperation(CompareOperation::kLess);
-				}
-			});
+			// Draw icons
+			{
+				drawNonRenderable(GpuSceneNonRenderableObjectType::kLight, GpuSceneArrays::Light::getSingleton().getElementCount(), ctx,
+								  *m_pointLightImage, true, rgraphCtx);
+				drawNonRenderable(GpuSceneNonRenderableObjectType::kDecal, GpuSceneArrays::Decal::getSingleton().getElementCount(), ctx,
+								  *m_decalImage, true, rgraphCtx);
+				drawNonRenderable(GpuSceneNonRenderableObjectType::kGlobalIlluminationProbe,
+								  GpuSceneArrays::GlobalIlluminationProbe::getSingleton().getElementCount(), ctx, *m_giProbeImage, true, rgraphCtx);
+				drawNonRenderable(GpuSceneNonRenderableObjectType::kReflectionProbe,
+								  GpuSceneArrays::ReflectionProbe::getSingleton().getElementCount(), ctx, *m_reflectionImage, true, rgraphCtx);
+			}
+
+			// Draw gizmos
+			if(m_gizmos.m_enabled)
+			{
+				cmdb.setDepthCompareOperation(CompareOperation::kAlways);
+				drawGizmos(m_gizmos.m_trf, ctx, true, cmdb);
+				cmdb.setDepthCompareOperation(CompareOperation::kLess);
+			}
+		});
 	}
 
 	// Read the UUID RT to get the UUID that is over the mouse
@@ -1013,7 +1031,7 @@ void Dbg::populateRenderGraphObjectPicking(RenderingContext& ctx)
 
 			ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
 			variantInitInfo.addMutation("OBJECT_TYPE", 0);
-			variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kCompute, "RenderableUuidsPick");
+			variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kCompute, "ReadPickingBuffer");
 			const ShaderProgramResourceVariant* variant;
 			m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
 			cmdb.bindShaderProgram(&variant->getProgram());
@@ -1083,7 +1101,7 @@ void Dbg::drawGizmos(const Mat3x4& worldTransform, const RenderingContext& ctx,
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_dbgProg);
 	variantInitInfo.addMutation("OBJECT_TYPE", 0);
-	variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, (objectPicking) ? "GizmosPick" : "Gizmos");
+	variantInitInfo.requestTechniqueAndTypes(ShaderTypeBit::kVertex | ShaderTypeBit::kPixel, (objectPicking) ? "GizmosPicking" : "Gizmos");
 	const ShaderProgramResourceVariant* variant;
 	m_dbgProg->getOrCreateVariant(variantInitInfo, variant);
 	cmdb.bindShaderProgram(&variant->getProgram());

AnKi/Renderer/Dbg.h

@@ -172,7 +172,7 @@ private:
 	void populateRenderGraphObjectPicking(RenderingContext& ctx);
 
 	void drawNonRenderable(GpuSceneNonRenderableObjectType type, U32 objCount, const RenderingContext& ctx, const ImageResource& image,
-						   CommandBuffer& cmdb);
+						   Bool objectPicking, RenderPassWorkContext& rgraphCtx);
 
 	void drawGizmos(const Mat3x4& worldTransform, const RenderingContext& ctx, Bool objectPicking, CommandBuffer& cmdb) const;
 

AnKi/Scene/Components/DecalComponent.cpp

@@ -88,6 +88,7 @@ void DecalComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 	gpuDecal.m_textureMatrix = biasedProjViewMat;
 	gpuDecal.m_sphereCenter = info.m_node->getWorldTransform().getOrigin().xyz;
 	gpuDecal.m_sphereRadius = halfBoxSize.length();
+	gpuDecal.m_sceneNodeUuid = info.m_node->getUuid();
 
 	m_gpuSceneDecal.uploadToGpuScene(gpuDecal);
 }

AnKi/Scene/Components/FogDensityComponent.cpp

@@ -46,6 +46,7 @@ void FogDensityComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 		}
 		gpuVolume.m_isBox = m_type == FogDensityComponentShape::kBox;
 		gpuVolume.m_density = m_density;
+		gpuVolume.m_sceneNodeUuid = info.m_node->getUuid();
 
 		m_gpuSceneVolume.uploadToGpuScene(gpuVolume);
 	}

AnKi/Scene/Components/GlobalIlluminationProbeComponent.cpp

@@ -147,9 +147,10 @@ void GlobalIlluminationProbeComponent::update(SceneComponentUpdateInfo& info, Bo
 		gpuProbe.m_volumeTexture = m_volTexBindlessIdx;
 		gpuProbe.m_halfTexelSizeU = 1.0f / (F32(m_cellCounts.y) * 6.0f) / 2.0f;
 		gpuProbe.m_fadeDistance = m_fadeDistance;
-		gpuProbe.m_uuid = getUuid();
+		gpuProbe.m_componentUuid = getUuid();
 		gpuProbe.m_componentArrayIndex = getArrayIndex();
 		gpuProbe.m_cpuFeedback = cpuFeedback;
+		gpuProbe.m_sceneNodeUuid = info.m_node->getUuid();
 		m_gpuSceneProbe.uploadToGpuScene(gpuProbe);
 	}
 

AnKi/Scene/Components/LightComponent.cpp

@@ -132,7 +132,8 @@ void LightComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 		gpuLight.m_shadow = reallyShadow;
 		gpuLight.m_cpuFeedback = m_shadow;
 		gpuLight.m_componentArrayIndex = getArrayIndex();
-		gpuLight.m_uuid = getUuid();
+		gpuLight.m_componentUuid = getUuid();
+		gpuLight.m_sceneNodeUuid = info.m_node->getUuid();
 		for(U32 f = 0; f < m_shadowAtlasUvViewportCount; ++f)
 		{
 			gpuLight.m_spotLightMatrixOrPointLightUvViewports[f] = m_shadowAtlasUvViewports[f];
@@ -174,7 +175,8 @@ void LightComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 		gpuLight.m_shadow = reallyShadow;
 		gpuLight.m_cpuFeedback = m_shadow;
 		gpuLight.m_componentArrayIndex = getArrayIndex();
-		gpuLight.m_uuid = getUuid();
+		gpuLight.m_componentUuid = getUuid();
+		gpuLight.m_sceneNodeUuid = info.m_node->getUuid();
 		gpuLight.m_innerCos = cos(m_spot.m_innerAngle / 2.0f);
 		gpuLight.m_direction = -m_worldTransform.getRotation().getZAxis();
 		gpuLight.m_outerCos = cos(m_spot.m_outerAngle / 2.0f);

AnKi/Scene/Components/ReflectionProbeComponent.cpp

@@ -61,9 +61,10 @@ void ReflectionProbeComponent::update(SceneComponentUpdateInfo& info, Bool& upda
 		gpuProbe.m_aabbMin = aabbWorld.getMin().xyz;
 		gpuProbe.m_aabbMax = aabbWorld.getMax().xyz;
 
-		gpuProbe.m_uuid = getUuid();
+		gpuProbe.m_componentUuid = getUuid();
 		gpuProbe.m_componentArrayIndex = getArrayIndex();
 		gpuProbe.m_cpuFeedback = m_reflectionNeedsRefresh;
+		gpuProbe.m_sceneNodeUuid = info.m_node->getUuid();
 		m_gpuSceneProbe.uploadToGpuScene(gpuProbe);
 	}
 }

AnKi/Shaders/Dbg.ankiprog

@@ -6,20 +6,22 @@
 #pragma anki mutator OBJECT_TYPE 0 1 2 3 4 // Same as GpuSceneNonRenderableObjectType
 
 #pragma anki technique RenderableBoxes vert pixel mutators
-#pragma anki technique Bilboards vert pixel
 #pragma anki technique Lines vert pixel mutators
 
-// Prepare the indirect calls for RenderableUuids
-#pragma anki technique PrepareRenderableUuids comp mutators
+#pragma anki technique Bilboards vert pixel
+#pragma anki technique BilboardsPicking vert pixel
 
-// Draw the renderables to output the UUID
-#pragma anki technique RenderableUuids vert pixel mutators
+// Prepare the indirect calls for RenderablesPicking
+#pragma anki technique PrepareRenderablesPicking comp mutators
 
-// Pick one UUID at mouse position
-#pragma anki technique RenderableUuidsPick comp mutators
+// Draw the renderables to output the UUID
+#pragma anki technique RenderablesPicking vert pixel mutators
 
 #pragma anki technique Gizmos vert pixel mutators
-#pragma anki technique GizmosPick vert pixel mutators
+#pragma anki technique GizmosPicking vert pixel mutators
+
+// Pick one UUID at mouse position
+#pragma anki technique ReadPickingBuffer comp mutators
 
 #include <AnKi/Shaders/Common.hlsl>
 #include <AnKi/Shaders/Include/GpuVisibilityTypes.h>
@@ -105,9 +107,9 @@ Vec4 main(VertOut input) : SV_TARGET0
 #endif // ANKI_TECHNIQUE_RenderableBoxes
 
 // ===========================================================================
-// Bilboards                                                                 =
+// Bilboards & BilboardsPicking                                              =
 // ===========================================================================
-#if NOT_ZERO(ANKI_TECHNIQUE_Bilboards)
+#if ANKI_TECHNIQUE_Bilboards || ANKI_TECHNIQUE_BilboardsPicking
 #	include <AnKi/Shaders/ClusteredShadingFunctions.hlsl>
 #	include <AnKi/Shaders/TonemappingFunctions.hlsl>
 
@@ -139,7 +141,9 @@ typedef GpuSceneGlobalIlluminationProbe GpuSceneType;
 #		error See file
 #	endif
 
+#	if ANKI_TECHNIQUE_Bilboards
 Texture2D g_depthRt : register(t0);
+#	endif
 StructuredBuffer<GpuSceneType> g_visibleObjects : register(t1);
 StructuredBuffer<U32> g_visibleObjectCount : register(t2);
 Texture2D<Vec4> g_tex : register(t3);
@@ -147,18 +151,19 @@ Texture2D<Vec4> g_tex2 : register(t4);
 
 SamplerState g_trilinearRepeatSampler : register(s1);
 
+struct VertIn
+{
+	U32 m_svInstanceId : SV_INSTANCEID;
+	U32 m_svVertexId : SV_VERTEXID;
+};
+
 struct VertOut
 {
 	Vec4 m_svPosition : SV_POSITION;
 	Vec2 m_uv : TEXCOORD;
 	Vec3 m_colorScale : COLOR;
 	nointerpolation U32 m_textureIndex : TEX_INDEX;
-};
-
-struct VertIn
-{
-	U32 m_svInstanceId : SV_INSTANCEID;
-	U32 m_svVertexId : SV_VERTEXID;
+	nointerpolation U32 m_sceneNodeUuid : UUID;
 };
 
 #	if ANKI_VERTEX_SHADER
@@ -168,7 +173,7 @@ VertOut main(VertIn input)
 
 	output.m_colorScale = 1.0;
 	output.m_textureIndex = 0;
-
+	output.m_sceneNodeUuid = 0;
 	output.m_uv = Vec2(input.m_svVertexId & 1u, ((input.m_svVertexId + 1u) / 3u) & 1u);
 
 	const U32 objCount = g_visibleObjectCount[0];
@@ -197,6 +202,8 @@ VertOut main(VertIn input)
 		const Vec3 worldPos = mul(g_consts.m_camTrf, Vec4((output.m_uv * 2.0 - 1.0) * kBillboardScale, 0.0, 0.0)) + localPos;
 
 		output.m_svPosition = mul(g_consts.m_viewProjMat, Vec4(worldPos, 1.0));
+
+		output.m_sceneNodeUuid = obj.m_sceneNodeUuid;
 	}
 	else
 	{
@@ -209,7 +216,12 @@ VertOut main(VertIn input)
 #	endif // ANKI_VERTEX_SHADER
 
 #	if ANKI_PIXEL_SHADER
-Vec4 main(VertOut input) : SV_TARGET0
+#		if ANKI_TECHNIQUE_Bilboards
+Vec4
+#		else
+U32
+#		endif
+main(VertOut input) : SV_TARGET0
 {
 	ANKI_MAYBE_UNUSED(input);
 
@@ -226,6 +238,7 @@ Vec4 main(VertOut input) : SV_TARGET0
 
 	color.xyz *= input.m_colorScale;
 
+#		if ANKI_TECHNIQUE_Bilboards
 	if(g_consts.m_depthFailureVisualization)
 	{
 		Vec2 texSize;
@@ -240,6 +253,14 @@ Vec4 main(VertOut input) : SV_TARGET0
 	}
 
 	return color;
+#		else
+	if(color.a <= 0.1)
+	{
+		discard;
+	}
+
+	return input.m_sceneNodeUuid;
+#		endif
 }
 #	endif // ANKI_PIXEL_SHADER
 #endif // ANKI_TECHNIQUE_Bilboards
@@ -315,9 +336,9 @@ Vec4 main() : SV_TARGET0
 #endif
 
 // ===========================================================================
-// GizmosPick                                                                =
+// GizmosPicking                                                             =
 // ===========================================================================
-#if ANKI_TECHNIQUE_GizmosPick
+#if ANKI_TECHNIQUE_GizmosPicking
 
 struct Consts
 {
@@ -346,9 +367,9 @@ U32 main() : SV_TARGET0
 #endif
 
 // ===========================================================================
-// PrepareRenderableUuids                                                    =
+// PrepareRenderablesPicking                                                  =
 // ===========================================================================
-#if ANKI_TECHNIQUE_PrepareRenderableUuids
+#if ANKI_TECHNIQUE_PrepareRenderablesPicking
 
 StructuredBuffer<GpuSceneRenderableBoundingVolume> g_renderableBoundingVolumes : register(t0);
 StructuredBuffer<GpuSceneRenderable> g_renderables : register(t1);
@@ -402,9 +423,9 @@ RWStructuredBuffer<U32> g_lodAndRenderableIndices : register(u2);
 #endif
 
 // ===========================================================================
-// RenderableUuids                                                           =
+// RenderablesPicking                                                         =
 // ===========================================================================
-#if ANKI_TECHNIQUE_RenderableUuids
+#if ANKI_TECHNIQUE_RenderablesPicking
 
 StructuredBuffer<U32> g_lodAndRenderableIndices : register(t0);
 StructuredBuffer<GpuSceneRenderable> g_renderables : register(t1);
@@ -483,9 +504,9 @@ U32 main(VertOut input) : SV_TARGET0
 #endif
 
 // ===========================================================================
-// RenderableUuidsPick                                                       =
+// ReadPickingBuffer                                                         =
 // ===========================================================================
-#if ANKI_TECHNIQUE_RenderableUuidsPick
+#if ANKI_TECHNIQUE_ReadPickingBuffer
 
 Texture2D<UVec4> g_uuidsTex : register(t0);
 

AnKi/Shaders/GpuVisibilityNonRenderables.ankiprog

@@ -140,7 +140,7 @@ Vec4 getSphere(GpuSceneGlobalIlluminationProbe l)
 		U32 idx;
 		InterlockedAdd(g_counterBuffer[0].m_feedbackObjectCount, 1, idx);
 
-		g_cpuFeedbackBuffer[idx * 2 + 1] = g_objects[svDispatchThreadId].m_uuid;
+		g_cpuFeedbackBuffer[idx * 2 + 1] = g_objects[svDispatchThreadId].m_componentUuid;
 		g_cpuFeedbackBuffer[idx * 2 + 2] = g_objects[svDispatchThreadId].m_componentArrayIndex;
 	}
 #endif

AnKi/Shaders/Include/GpuSceneTypes.h

@@ -135,9 +135,9 @@ struct GpuSceneLight
 	U32 m_isSpotLight : 1;
 	U32 m_shadow : 1;
 	U32 m_cpuFeedback : 1; // If true the GPU visibility will inform the CPU about it
-	U32 m_padding : 28;
+	U32 m_sceneNodeUuid : 28; // For object picking
 	U32 m_componentArrayIndex; // Array index of the LightComponent in the CPU scene.
-	U32 m_uuid; // The UUID of the LightComponent
+	U32 m_componentUuid; // The UUID of the LightComponent
 	F32 m_innerCos; // Only for spot light.
 
 	Vec3 m_direction; // Only for spot light. Light direction.
@@ -148,6 +148,7 @@ struct GpuSceneLight
 
 	Vec4 m_edgePoints[4u]; // Edge points in world space. Only for spot light.
 };
+static_assert(sizeof(GpuSceneLight) % sizeof(Vec4) == 0);
 
 // Representation of a reflection probe.
 struct GpuSceneReflectionProbe
@@ -157,19 +158,23 @@ struct GpuSceneReflectionProbe
 	U32 m_cpuFeedback : 1;
 
 	Vec3 m_aabbMin ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
-	U32 m_uuid; // The UUID of that probe
+	U32 m_componentUuid; // The UUID of the ReflectionProbeComponent
 
 	Vec3 m_aabbMax ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
 	U32 m_componentArrayIndex; // Array in the CPU scene.
+
+	U32 m_sceneNodeUuid; // For object picking
+	U32 m_padding1;
+	U32 m_padding2;
+	U32 m_padding3;
 };
-constexpr U32 kSizeof_GpuSceneReflectionProbe = 3u * sizeof(Vec4);
-static_assert(sizeof(GpuSceneReflectionProbe) == kSizeof_GpuSceneReflectionProbe);
+static_assert(sizeof(GpuSceneReflectionProbe) % sizeof(Vec4) == 0);
 
 // Global illumination probe
 struct GpuSceneGlobalIlluminationProbe
 {
 	Vec3 m_aabbMin ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
-	U32 m_uuid; // The UUID of that probe
+	U32 m_componentUuid; // The UUID of the GlobalIlluminationProbeComponent
 
 	Vec3 m_aabbMax ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
 	U32 m_componentArrayIndex; // Array in the CPU scene.
@@ -177,7 +182,8 @@ struct GpuSceneGlobalIlluminationProbe
 	U32 m_volumeTexture; // Bindless index of the irradiance volume texture.
 	F32 m_halfTexelSizeU; // (1.0 / textureSize(texArr[textureIndex]).x) / 2.0
 	F32 m_fadeDistance; // Used to calculate a factor that is zero when fragPos is close to AABB bounds and 1.0 at fadeDistance and less
-	U32 m_cpuFeedback;
+	U32 m_cpuFeedback : 1;
+	U32 m_sceneNodeUuid : 31; // For object picking
 };
 constexpr U32 kSizeof_GpuSceneGlobalIlluminationProbe = 3u * sizeof(Vec4);
 static_assert(sizeof(GpuSceneGlobalIlluminationProbe) == kSizeof_GpuSceneGlobalIlluminationProbe);
@@ -194,15 +200,20 @@ struct GpuSceneDecal
 
 	Vec3 m_sphereCenter ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
 	F32 m_sphereRadius ANKI_CPP_CODE(= 0.0f);
+
+	U32 m_sceneNodeUuid; // For object picking
+	U32 m_padding1;
+	U32 m_padding2;
+	U32 m_padding3;
 };
-constexpr U32 kSizeof_GpuSceneDecal = 2u * sizeof(Vec4) + 1u * sizeof(Mat4);
-static_assert(sizeof(GpuSceneDecal) == kSizeof_GpuSceneDecal);
+static_assert(sizeof(GpuSceneDecal) % sizeof(Vec4) == 0);
 
 // Fog density volume
 struct GpuSceneFogDensityVolume
 {
 	Vec3 m_aabbMinOrSphereCenter ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
-	U32 m_isBox ANKI_CPP_CODE(= 1);
+	U32 m_isBox : 1 ANKI_CPP_CODE(= 1);
+	U32 m_sceneNodeUuid : 30; // For object picking
 
 	Vec3 m_aabbMaxOrSphereRadius ANKI_CPP_CODE(= Vec3(kSomeFarDistance));
 	F32 m_density;