Render joint names (#5685)

* render solid skeleton option Signed-off-by: rhhong <rhhong@amazon.com> * Fix broken build Signed-off-by: rhhong <rhhong@amazon.com> * CR update Signed-off-by: rhhong <rhhong@amazon.com> * Render joint names Signed-off-by: rhhong <rhhong@amazon.com> * CR update Signed-off-by: rhhong <rhhong@amazon.com> * CR update Signed-off-by: rhhong <rhhong@amazon.com>
2021-11-18 06:42:41 -08:00
parent e2772fca21
commit e52cbd2bb3
7 changed files with 89 additions and 1 deletions
@@ -67,6 +67,9 @@ namespace AZ
            virtual ViewportContextPtr GetViewportContextByName(const Name& contextName) const = 0;
            //! Gets the registered ViewportContext with the corresponding ID, if any.
            virtual ViewportContextPtr GetViewportContextById(AzFramework::ViewportId id) const = 0;
+            //! Gets the registered ViewportContext with matching RPI::Scene, if any.
+            //! This function will return the first result.
+            virtual ViewportContextPtr GetViewportContextByScene(const Scene* scene) const = 0;
            //! Maps a ViewportContext to a new name, inheriting the View stack (if any) registered to that context name.
            //! This can be used to switch "default" viewports by registering a viewport with the default ViewportContext name
            //! but note that only one ViewportContext can be mapped to a context name at a time.
@@ -41,6 +41,7 @@ namespace AZ
            bool PopView(const Name& contextName, ViewPtr view) override;
            ViewPtr GetCurrentView(const Name& contextName) const override;
            ViewportContextPtr GetDefaultViewportContext() const override;
+            ViewportContextPtr GetViewportContextByScene(const Scene* scene) const override;

        private:
            void RegisterViewportContext(const Name& contextName, ViewportContextPtr viewportContext);
@@ -176,6 +176,20 @@ namespace AZ
            return {};
        }

+        ViewportContextPtr ViewportContextManager::GetViewportContextByScene(const Scene* scene) const
+        {
+            AZStd::lock_guard lock(m_containerMutex);
+            for (const auto& viewportData : m_viewportContexts)
+            {
+                ViewportContextPtr viewportContext = viewportData.second.context.lock();
+                if (viewportContext && viewportContext->GetRenderScene().get() == scene)
+                {
+                    return viewportContext;
+                }
+            }
+            return {};
+        }
+
        void ViewportContextManager::RenameViewportContext(ViewportContextPtr viewportContext, const Name& newContextName)
        {
            auto currentAssignedViewportContext = GetViewportContextByName(newContextName);
@@ -10,6 +10,7 @@
 #include <Atom/RPI.Public/Scene.h>
 #include <Atom/RPI.Public/AuxGeom/AuxGeomDraw.h>
 #include <Atom/RPI.Public/AuxGeom/AuxGeomFeatureProcessorInterface.h>
+#include <Atom/RPI.Public/ViewportContextBus.h>
 #include <Integration/Rendering/RenderActorInstance.h>
 #include <Integration/Rendering/RenderActorSettings.h>

@@ -41,6 +42,8 @@ namespace AZ::Render
            return;
        }

+        const RPI::Scene* scene = RPI::Scene::GetSceneForEntityId(instance->GetEntityId());
+        const RPI::ViewportContextPtr viewport = AZ::Interface<AZ::RPI::ViewportContextRequestsInterface>::Get()->GetViewportContextByScene(scene);
        const AZ::Render::RenderActorSettings& renderActorSettings = EMotionFX::GetRenderActorSettings();

        // Render aabb
@@ -55,12 +58,17 @@ namespace AZ::Render
            RenderLineSkeleton(instance, renderActorSettings.m_lineSkeletonColor);
        }

-        // Render advance skeleton
+        // Render advanced skeleton
        if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_SKELETON])
        {
            RenderSkeleton(instance, renderActorSettings.m_skeletonColor);
        }

+        if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_NODENAMES])
+        {
+            RenderJointNames(instance, viewport, renderActorSettings.m_jointNameColor);
+        }
+
        // Render internal EMFX debug lines.
        if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_EMFX_DEBUG])
        {
@@ -552,4 +560,54 @@ namespace AZ::Render
            auxGeom->DrawLines(lineArgs);
        }
    }
+
+    void AtomActorDebugDraw::RenderJointNames(EMotionFX::ActorInstance* actorInstance,
+        RPI::ViewportContextPtr viewportContext, const AZ::Color& jointNameColor)
+    {
+        if (!m_fontDrawInterface)
+        {
+            auto fontQueryInterface = AZ::Interface<AzFramework::FontQueryInterface>::Get();
+            if (!fontQueryInterface)
+            {
+                return;
+            }
+            m_fontDrawInterface = fontQueryInterface->GetDefaultFontDrawInterface();
+        }
+
+        if (!m_fontDrawInterface || !viewportContext || !viewportContext->GetRenderScene() ||
+            !AZ::Interface<AzFramework::FontQueryInterface>::Get())
+        {
+            return;
+        }
+
+        const EMotionFX::Actor* actor = actorInstance->GetActor();
+        const EMotionFX::Skeleton* skeleton = actor->GetSkeleton();
+        const EMotionFX::TransformData* transformData = actorInstance->GetTransformData();
+        const EMotionFX::Pose* pose = transformData->GetCurrentPose();
+        const size_t numEnabledNodes = actorInstance->GetNumEnabledNodes();
+
+        m_drawParams.m_drawViewportId = viewportContext->GetId();
+        AzFramework::WindowSize viewportSize = viewportContext->GetViewportSize();
+        m_drawParams.m_position = AZ::Vector3(static_cast<float>(viewportSize.m_width), 0.0f, 1.0f) +
+            TopRightBorderPadding * viewportContext->GetDpiScalingFactor();
+        m_drawParams.m_color = jointNameColor;
+        m_drawParams.m_scale = AZ::Vector2(BaseFontSize);
+        m_drawParams.m_hAlign = AzFramework::TextHorizontalAlignment::Right;
+        m_drawParams.m_monospace = false;
+        m_drawParams.m_depthTest = false;
+        m_drawParams.m_virtual800x600ScreenSize = false;
+        m_drawParams.m_scaleWithWindow = false;
+        m_drawParams.m_multiline = true;
+        m_drawParams.m_lineSpacing = 0.5f;
+
+        for (size_t i = 0; i < numEnabledNodes; ++i)
+        {
+            const EMotionFX::Node* joint = skeleton->GetNode(actorInstance->GetEnabledNode(i));
+            const size_t jointIndex = joint->GetNodeIndex();
+            const AZ::Vector3 worldPos = pose->GetWorldSpaceTransform(jointIndex).m_position;
+
+            m_drawParams.m_position = worldPos;
+            m_fontDrawInterface->DrawScreenAlignedText3d(m_drawParams, joint->GetName());
+        }
+    }
 } // namespace AZ::Render
@@ -10,8 +10,10 @@

 #include <AzCore/std/containers/vector.h>
 #include <AzCore/Math/Color.h>
+#include <AzFramework/Font/FontInterface.h>
 #include <Integration/Rendering/RenderFlag.h>
 #include <Integration/Rendering/RenderActorInstance.h>
+#include <Atom/RPI.Public/ViewportContext.h>

 namespace EMotionFX
 {
@@ -60,14 +62,21 @@ namespace AZ::Render
            const AZ::Color& tangentsColor, const AZ::Color& mirroredBitangentsColor, const AZ::Color& bitangentsColor);
        void RenderWireframe(EMotionFX::Mesh* mesh, const AZ::Transform& worldTM, float wireframeScale, float scaleMultiplier,
            const AZ::Color& wireframeColor);
+        void RenderJointNames(EMotionFX::ActorInstance* actorInstance, RPI::ViewportContextPtr viewportContext, const AZ::Color& jointNameColor);

        EMotionFX::Mesh* m_currentMesh = nullptr; /**< A pointer to the mesh whose world space positions are in the pre-calculated positions buffer.
                                           NULL in case we haven't pre-calculated any positions yet. */
        AZStd::vector<AZ::Vector3> m_worldSpacePositions; /**< The buffer used to store world space positions for rendering normals
                                                          tangents and the wireframe. */

+        static constexpr float BaseFontSize = 0.7f;
+        const Vector3 TopRightBorderPadding = AZ::Vector3(-40.0f, 22.0f, 0.0f);
+
        RPI::AuxGeomFeatureProcessorInterface* m_auxGeomFeatureProcessor = nullptr;
        AZStd::vector<AZ::Vector3> m_auxVertices;
        AZStd::vector<AZ::Color> m_auxColors;
+
+        AzFramework::TextDrawParameters m_drawParams;
+        AzFramework::FontDrawInterface* m_fontDrawInterface = nullptr;
    };
 }
@@ -1083,6 +1083,7 @@ namespace EMStudio
        settings.m_selectedClothColliderColor = m_selectedClothColliderColor;
        settings.m_simulatedObjectColliderColor = m_simulatedObjectColliderColor;
        settings.m_selectedSimulatedObjectColliderColor = m_selectedSimulatedObjectColliderColor;
+        settings.m_jointNameColor = m_nodeNameColor;
    }

    void RenderOptions::OnGridUnitSizeChangedCallback() const
@@ -1285,6 +1286,7 @@ namespace EMStudio
    void RenderOptions::OnNodeNameColorChangedCallback() const
    {
        PluginOptionsNotificationsBus::Event(s_nodeNameColorOptionName, &PluginOptionsNotificationsBus::Events::OnOptionChanged, s_nodeNameColorOptionName);
+        CopyToRenderActorSettings(EMotionFX::GetRenderActorSettings());
    }

    void RenderOptions::OnGridColorChangedCallback() const
@@ -46,5 +46,6 @@ namespace AZ::Render
        AZ::Color m_staticAABBColor{ 0.0f, 0.7f, 0.7f, 1.0f };
        AZ::Color m_lineSkeletonColor{ 0.33333f, 1.0f, 0.0f, 1.0f };
        AZ::Color m_skeletonColor{ 0.19f, 0.58f, 0.19f, 1.0f };
+        AZ::Color m_jointNameColor{ 1.0f, 1.0f, 1.0f, 1.0f };
    };
 } // namespace AZ::Render