Routed skinned model picking through PickingFallback

Author: Gopmyc

Resources/Editor/Shaders/PickingFallback.ovfx

@@ -1,7 +1,12 @@
+#pass PICKING_PASS
+#feature SKINNING
+
 #shader vertex
 #version 450 core
 
 layout (location = 0) in vec3 geo_Pos;
+layout (location = 5) in vec4 geo_BoneIDs;
+layout (location = 6) in vec4 geo_BoneWeights;
 
 layout (std140) uniform EngineUBO
 {
@@ -12,9 +17,65 @@ layout (std140) uniform EngineUBO
     float   ubo_Time;
 };
 
+layout(std430, binding = 2) buffer SkinningSSBO
+{
+    mat4 ssbo_Bones[];
+};
+
+mat4 ComputeSkinningMatrix(vec4 p_boneIDs, vec4 p_boneWeights)
+{
+    const int boneCount = ssbo_Bones.length();
+
+    mat4 skinning = mat4(0.0);
+    float appliedWeight = 0.0;
+
+    #define OV_APPLY_BONE(BONE_ID, BONE_WEIGHT)                                \
+    {                                                                           \
+        const float w = (BONE_WEIGHT);                                          \
+        if (w > 0.0)                                                            \
+        {                                                                       \
+            const int index = int(floor((BONE_ID) + 0.5));                     \
+            if (index >= 0 && index < boneCount)                               \
+            {                                                                   \
+                skinning += ssbo_Bones[index] * w;                             \
+                appliedWeight += w;                                             \
+            }                                                                   \
+        }                                                                       \
+    }
+
+    OV_APPLY_BONE(p_boneIDs.x, p_boneWeights.x);
+    OV_APPLY_BONE(p_boneIDs.y, p_boneWeights.y);
+    OV_APPLY_BONE(p_boneIDs.z, p_boneWeights.z);
+    OV_APPLY_BONE(p_boneIDs.w, p_boneWeights.w);
+
+    #undef OV_APPLY_BONE
+
+    if (appliedWeight <= 0.0)
+    {
+        return mat4(1.0);
+    }
+
+    if (appliedWeight < 1.0)
+    {
+        return skinning + mat4(1.0) * (1.0 - appliedWeight);
+    }
+
+    if (appliedWeight > 1.0)
+    {
+        return skinning / appliedWeight;
+    }
+
+    return skinning;
+}
+
 void main()
 {
-    gl_Position = ubo_Projection * ubo_View * ubo_Model * vec4(geo_Pos, 1.0);
+    mat4 skinningMatrix = mat4(1.0);
+#if defined(SKINNING)
+    skinningMatrix = ComputeSkinningMatrix(geo_BoneIDs, geo_BoneWeights);
+#endif
+
+    gl_Position = ubo_Projection * ubo_View * ubo_Model * skinningMatrix * vec4(geo_Pos, 1.0);
 }
 
 #shader fragment

Sources/OvEditor/src/OvEditor/Rendering/PickingRenderPass.cpp

@@ -5,10 +5,13 @@
 */
 
 #include <ranges>
+#include <string>
 
 #include <OvCore/ECS/Components/CMaterialRenderer.h>
+#include <OvCore/ECS/Components/CSkinnedMeshRenderer.h>
 #include <OvCore/Rendering/EngineDrawableDescriptor.h>
 #include <OvCore/Rendering/FramebufferUtil.h>
+#include <OvCore/Rendering/SkinningUtils.h>
 
 #include <OvEditor/Core/EditorActions.h>
 #include <OvEditor/Rendering/DebugModelRenderFeature.h>
@@ -20,6 +23,8 @@
 
 namespace
 {
+	const std::string kPickingPassName = "PICKING_PASS";
+
 	void PreparePickingMaterial(
 		const OvCore::ECS::Actor& p_actor,
 		OvRendering::Data::Material& p_material,
@@ -161,30 +166,42 @@ void OvEditor::Rendering::PickingRenderPass::DrawPickableModels(
 	auto drawPickableModels = [&](auto drawables) {
 		for (auto& drawable : drawables)
 		{
-			const std::string pickingPassName = "PICKING_PASS";
+			const auto& actor = drawable.template GetDescriptor<OvCore::Rendering::SceneRenderer::SceneDrawableDescriptor>().actor;
+			const auto skinnedRenderer = actor.GetComponent<OvCore::ECS::Components::CSkinnedMeshRenderer>();
+			const bool hasSkinning = OvCore::Rendering::SkinningUtils::IsSkinningActive(skinnedRenderer);
+
+			if (hasSkinning)
+			{
+				auto& targetMaterial = m_actorPickingFallbackMaterial;
+
+				PreparePickingMaterial(actor, targetMaterial);
+
+				OvRendering::Entities::Drawable finalDrawable = drawable;
+				finalDrawable.material = &targetMaterial;
+				finalDrawable.stateMask = targetMaterial.GenerateStateMask();
+				finalDrawable.stateMask.frontfaceCulling = false;
+				finalDrawable.stateMask.backfaceCulling = false;
+				finalDrawable.pass = kPickingPassName;
+
+				OvCore::Rendering::SkinningUtils::ApplyToDrawable(finalDrawable, *skinnedRenderer, &targetMaterial.GetFeatures());
+				m_renderer.DrawEntity(p_pso, finalDrawable);
+				continue;
+			}
 
-			// If the material has picking pass, use it, otherwise use the picking fallback material
 			auto& targetMaterial =
-				(drawable.material && drawable.material->IsValid() && drawable.material->HasPass(pickingPassName)) ?
+				drawable.material &&
+				drawable.material->IsValid() &&
+				drawable.material->HasPass(kPickingPassName) ?
 				drawable.material.value() :
 				m_actorPickingFallbackMaterial;
 
-			const auto& actor = drawable.template GetDescriptor<OvCore::Rendering::SceneRenderer::SceneDrawableDescriptor>().actor;
-
 			PreparePickingMaterial(actor, targetMaterial);
 
-			// Prioritize using the actual material state mask.
-			auto stateMask = 
-				drawable.material && drawable.material->IsValid() ?
-				drawable.material->GenerateStateMask() :
-				targetMaterial.GenerateStateMask();
-
 			OvRendering::Entities::Drawable finalDrawable = drawable;
-			finalDrawable.material = targetMaterial;
-			finalDrawable.stateMask = stateMask;
-			finalDrawable.stateMask.frontfaceCulling = false;
-			finalDrawable.stateMask.backfaceCulling = false;
-			finalDrawable.pass = pickingPassName;
+			finalDrawable.material = &targetMaterial;
+			finalDrawable.stateMask = targetMaterial.GenerateStateMask();
+			finalDrawable.pass = kPickingPassName;
+			finalDrawable.featureSetOverride = std::nullopt;
 
 			m_renderer.DrawEntity(p_pso, finalDrawable);
 		}