birkeh
/
o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Change actorRenderFlag to use AZ ENUM CLASS instead of azstd::bitset (#7542)

Browse Source 
* Fixes the problem with using actor render flags in actor component

Signed-off-by: rhhong <rhhong@amazon.com>

* In progress work for actor render flag rework

Signed-off-by: rhhong <rhhong@amazon.com>

* add an utlity function to check bit

Signed-off-by: rhhong <rhhong@amazon.com>

* code cleanup

Signed-off-by: rhhong <rhhong@amazon.com>

* More CR cleanup

Signed-off-by: rhhong <rhhong@amazon.com>

* build fix

Signed-off-by: rhhong <rhhong@amazon.com>

* CR feedback

Signed-off-by: rhhong <rhhong@amazon.com>
monroegm-disable-blank-issue-2
Roman 4 years ago committed by GitHub
parent 60d7533301
commit da421b7056
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 217 additions and 168 deletions
Show Stats Download Patch File Download Diff File

30
Gems/AtomLyIntegration/EMotionFXAtom/Code/Source/AtomActorDebugDraw.cpp
Unescape Escape View File

@ -33,7 +33,7 @@ namespace AZ::Render
m_auxGeomFeatureProcessor = RPI::Scene::GetFeatureProcessorForEntity<RPI::AuxGeomFeatureProcessorInterface>(entityId); m_auxGeomFeatureProcessor = RPI::Scene::GetFeatureProcessorForEntity<RPI::AuxGeomFeatureProcessorInterface>(entityId);
} }
void AtomActorDebugDraw::DebugDraw(const EMotionFX::ActorRenderFlagBitset& renderFlags, EMotionFX::ActorInstance* instance) void AtomActorDebugDraw::DebugDraw(const EMotionFX::ActorRenderFlags& renderFlags, EMotionFX::ActorInstance* instance)
{ {
if (!m_auxGeomFeatureProcessor || !instance) if (!m_auxGeomFeatureProcessor || !instance)
{ {
@ -46,10 +46,12 @@ namespace AZ::Render
return; return;
} }
using AZ::RHI::CheckBitsAny;
// Update the mesh deformers (perform cpu skinning and morphing) when needed. // Update the mesh deformers (perform cpu skinning and morphing) when needed.
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_AABB] || renderFlags[EMotionFX::ActorRenderFlag::RENDER_FACENORMALS] || if (CheckBitsAny(renderFlags,
renderFlags[EMotionFX::ActorRenderFlag::RENDER_TANGENTS] || renderFlags[EMotionFX::ActorRenderFlag::RENDER_VERTEXNORMALS] || EMotionFX::ActorRenderFlags::AABB | EMotionFX::ActorRenderFlags::FaceNormals | EMotionFX::ActorRenderFlags::Tangents |
renderFlags[EMotionFX::ActorRenderFlag::RENDER_WIREFRAME]) EMotionFX::ActorRenderFlags::VertexNormals | EMotionFX::ActorRenderFlags::Wireframe))
{ {
instance->UpdateMeshDeformers(0.0f, true); instance->UpdateMeshDeformers(0.0f, true);
} }
@ -61,7 +63,7 @@ namespace AZ::Render
const float scaleMultiplier = CalculateScaleMultiplier(instance); const float scaleMultiplier = CalculateScaleMultiplier(instance);
// Render aabb // Render aabb
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_AABB]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::AABB))
{ {
RenderAABB(instance, RenderAABB(instance,
renderActorSettings.m_enabledNodeBasedAabb, renderActorSettings.m_nodeAABBColor, renderActorSettings.m_enabledNodeBasedAabb, renderActorSettings.m_nodeAABBColor,
@ -70,39 +72,39 @@ namespace AZ::Render
} }
// Render simple line skeleton // Render simple line skeleton
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_LINESKELETON]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::LineSkeleton))
{ {
RenderLineSkeleton(instance, renderActorSettings.m_lineSkeletonColor); RenderLineSkeleton(instance, renderActorSettings.m_lineSkeletonColor);
} }
// Render advanced skeleton // Render advanced skeleton
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_SKELETON]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::Skeleton))
{ {
RenderSkeleton(instance, renderActorSettings.m_skeletonColor); RenderSkeleton(instance, renderActorSettings.m_skeletonColor);
} }
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_NODENAMES]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::NodeNames))
{ {
RenderJointNames(instance, viewport, renderActorSettings.m_jointNameColor); RenderJointNames(instance, viewport, renderActorSettings.m_jointNameColor);
} }
// Render internal EMFX debug lines. // Render internal EMFX debug lines.
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_EMFX_DEBUG]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::EmfxDebug))
{ {
RenderEMFXDebugDraw(instance); RenderEMFXDebugDraw(instance);
} }
// Render // Render
if (renderFlags[EMotionFX::ActorRenderFlag::RENDER_NODEORIENTATION]) if (CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::NodeOrientation))
{ {
RenderNodeOrientations(instance, debugDisplay, renderActorSettings.m_nodeOrientationScale * scaleMultiplier); RenderNodeOrientations(instance, debugDisplay, renderActorSettings.m_nodeOrientationScale * scaleMultiplier);
} }
// Render vertex normal, face normal, tagent and wireframe. // Render vertex normal, face normal, tagent and wireframe.
const bool renderVertexNormals = renderFlags[EMotionFX::ActorRenderFlag::RENDER_VERTEXNORMALS]; const bool renderVertexNormals = CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::VertexNormals);
const bool renderFaceNormals = renderFlags[EMotionFX::ActorRenderFlag::RENDER_FACENORMALS]; const bool renderFaceNormals = CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::FaceNormals);
const bool renderTangents = renderFlags[EMotionFX::ActorRenderFlag::RENDER_TANGENTS]; const bool renderTangents = CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::Tangents);
const bool renderWireframe = renderFlags[EMotionFX::ActorRenderFlag::RENDER_WIREFRAME]; const bool renderWireframe = CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::Wireframe);
if (renderVertexNormals || renderFaceNormals || renderTangents || renderWireframe) if (renderVertexNormals || renderFaceNormals || renderTangents || renderWireframe)
{ {

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Source/AtomActorDebugDraw.h
Unescape Escape View File

@ -40,7 +40,7 @@ namespace AZ::Render
public: public:
AtomActorDebugDraw(AZ::EntityId entityId); AtomActorDebugDraw(AZ::EntityId entityId);
void DebugDraw(const EMotionFX::ActorRenderFlagBitset& renderFlags, EMotionFX::ActorInstance* instance); void DebugDraw(const EMotionFX::ActorRenderFlags& renderFlags, EMotionFX::ActorInstance* instance);
private: private:

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Source/AtomActorInstance.cpp
Unescape Escape View File

@ -79,7 +79,7 @@ namespace AZ::Render
UpdateBounds(); UpdateBounds();
} }
void AtomActorInstance::DebugDraw(const EMotionFX::ActorRenderFlagBitset& renderFlags) void AtomActorInstance::DebugDraw(const EMotionFX::ActorRenderFlags& renderFlags)
{ {
m_atomActorDebugDraw->DebugDraw(renderFlags, m_actorInstance); m_atomActorDebugDraw->DebugDraw(renderFlags, m_actorInstance);
} }

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Source/AtomActorInstance.h
Unescape Escape View File

@ -86,7 +86,7 @@ namespace AZ
// RenderActorInstance overrides ... // RenderActorInstance overrides ...
void OnTick(float timeDelta) override; void OnTick(float timeDelta) override;
void DebugDraw(const EMotionFX::ActorRenderFlagBitset& renderFlags); void DebugDraw(const EMotionFX::ActorRenderFlags& renderFlags);
void UpdateBounds() override; void UpdateBounds() override;
void SetMaterials(const EMotionFX::Integration::ActorAsset::MaterialList& materialPerLOD) override { AZ_UNUSED(materialPerLOD); }; void SetMaterials(const EMotionFX::Integration::ActorAsset::MaterialList& materialPerLOD) override { AZ_UNUSED(materialPerLOD); };
void SetSkinningMethod(EMotionFX::Integration::SkinningMethod emfxSkinningMethod) override; void SetSkinningMethod(EMotionFX::Integration::SkinningMethod emfxSkinningMethod) override;

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportRenderer.cpp
Unescape Escape View File

@ -191,7 +191,7 @@ namespace EMStudio
return result; return result;
} }
void AnimViewportRenderer::UpdateActorRenderFlag(EMotionFX::ActorRenderFlagBitset renderFlags) void AnimViewportRenderer::UpdateActorRenderFlag(EMotionFX::ActorRenderFlags renderFlags)
{ {
for (AZ::Entity* entity : m_actorEntities) for (AZ::Entity* entity : m_actorEntities)
{ {

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportRenderer.h
Unescape Escape View File

@ -54,7 +54,7 @@ namespace EMStudio
//! Return the center position of the existing objects. //! Return the center position of the existing objects.
AZ::Vector3 GetCharacterCenter() const; AZ::Vector3 GetCharacterCenter() const;
void UpdateActorRenderFlag(EMotionFX::ActorRenderFlagBitset renderFlags); void UpdateActorRenderFlag(EMotionFX::ActorRenderFlags renderFlags);
AZStd::shared_ptr<AzFramework::Scene> GetFrameworkScene() const; AZStd::shared_ptr<AzFramework::Scene> GetFrameworkScene() const;
AZ::EntityId GetEntityId() const; AZ::EntityId GetEntityId() const;
AzFramework::EntityContextId GetEntityContextId() const; AzFramework::EntityContextId GetEntityContextId() const;

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportRequestBus.h
Unescape Escape View File

@ -26,7 +26,7 @@ namespace EMStudio
virtual void UpdateCameraFollowUp(bool followUp) = 0; virtual void UpdateCameraFollowUp(bool followUp) = 0;
//! Update render flags //! Update render flags
virtual void UpdateRenderFlags(EMotionFX::ActorRenderFlagBitset renderFlags) = 0; virtual void UpdateRenderFlags(EMotionFX::ActorRenderFlags renderFlags) = 0;
}; };
using AnimViewportRequestBus = AZ::EBus<AnimViewportRequests>; using AnimViewportRequestBus = AZ::EBus<AnimViewportRequests>;

46
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportToolBar.cpp
Unescape Escape View File

@ -61,35 +61,35 @@ namespace EMStudio
renderOptionsButton->setIcon(QIcon(":/EMotionFXAtom/Visualization.svg")); renderOptionsButton->setIcon(QIcon(":/EMotionFXAtom/Visualization.svg"));
addWidget(renderOptionsButton); addWidget(renderOptionsButton);
CreateViewOptionEntry(contextMenu, "Solid", EMotionFX::ActorRenderFlag::RENDER_SOLID); CreateViewOptionEntry(contextMenu, "Solid", EMotionFX::ActorRenderFlagIndex::SOLID);
CreateViewOptionEntry(contextMenu, "Wireframe", EMotionFX::ActorRenderFlag::RENDER_WIREFRAME); CreateViewOptionEntry(contextMenu, "Wireframe", EMotionFX::ActorRenderFlagIndex::WIREFRAME);
// [EMFX-TODO] Add those option once implemented. // [EMFX-TODO] Add those option once implemented.
// CreateViewOptionEntry(contextMenu, "Lighting", EMotionFX::ActorRenderFlag::RENDER_LIGHTING); // CreateViewOptionEntry(contextMenu, "Lighting", EMotionFX::ActorRenderFlagIndex::RENDER_LIGHTING);
// CreateViewOptionEntry(contextMenu, "Backface Culling", EMotionFX::ActorRenderFlag::RENDER_BACKFACECULLING); // CreateViewOptionEntry(contextMenu, "Backface Culling", EMotionFX::ActorRenderFlagIndex::RENDER_BACKFACECULLING);
contextMenu->addSeparator(); contextMenu->addSeparator();
CreateViewOptionEntry(contextMenu, "Vertex Normals", EMotionFX::ActorRenderFlag::RENDER_VERTEXNORMALS); CreateViewOptionEntry(contextMenu, "Vertex Normals", EMotionFX::ActorRenderFlagIndex::VERTEXNORMALS);
CreateViewOptionEntry(contextMenu, "Face Normals", EMotionFX::ActorRenderFlag::RENDER_FACENORMALS); CreateViewOptionEntry(contextMenu, "Face Normals", EMotionFX::ActorRenderFlagIndex::FACENORMALS);
CreateViewOptionEntry(contextMenu, "Tangents", EMotionFX::ActorRenderFlag::RENDER_TANGENTS); CreateViewOptionEntry(contextMenu, "Tangents", EMotionFX::ActorRenderFlagIndex::TANGENTS);
CreateViewOptionEntry(contextMenu, "Actor Bounding Boxes", EMotionFX::ActorRenderFlag::RENDER_AABB); CreateViewOptionEntry(contextMenu, "Actor Bounding Boxes", EMotionFX::ActorRenderFlagIndex::AABB);
contextMenu->addSeparator(); contextMenu->addSeparator();
CreateViewOptionEntry(contextMenu, "Line Skeleton", EMotionFX::ActorRenderFlag::RENDER_LINESKELETON); CreateViewOptionEntry(contextMenu, "Line Skeleton", EMotionFX::ActorRenderFlagIndex::LINESKELETON);
CreateViewOptionEntry(contextMenu, "Solid Skeleton", EMotionFX::ActorRenderFlag::RENDER_SKELETON); CreateViewOptionEntry(contextMenu, "Solid Skeleton", EMotionFX::ActorRenderFlagIndex::SKELETON);
CreateViewOptionEntry(contextMenu, "Joint Names", EMotionFX::ActorRenderFlag::RENDER_NODENAMES); CreateViewOptionEntry(contextMenu, "Joint Names", EMotionFX::ActorRenderFlagIndex::NODENAMES);
CreateViewOptionEntry(contextMenu, "Joint Orientations", EMotionFX::ActorRenderFlag::RENDER_NODEORIENTATION); CreateViewOptionEntry(contextMenu, "Joint Orientations", EMotionFX::ActorRenderFlagIndex::NODEORIENTATION);
// [EMFX-TODO] Add those option once implemented. // [EMFX-TODO] Add those option once implemented.
// CreateViewOptionEntry(contextMenu, "Actor Bind Pose", EMotionFX::ActorRenderFlag::RENDER_ACTORBINDPOSE); // CreateViewOptionEntry(contextMenu, "Actor Bind Pose", EMotionFX::ActorRenderFlagIndex::RENDER_ACTORBINDPOSE);
contextMenu->addSeparator(); contextMenu->addSeparator();
CreateViewOptionEntry(contextMenu, "Hit Detection Colliders", EMotionFX::ActorRenderFlag::RENDER_HITDETECTION_COLLIDERS, true, CreateViewOptionEntry(contextMenu, "Hit Detection Colliders", EMotionFX::ActorRenderFlagIndex::HITDETECTION_COLLIDERS, true,
":/EMotionFXAtom/HitDetection.svg"); ":/EMotionFXAtom/HitDetection.svg");
CreateViewOptionEntry(contextMenu, "Ragdoll Colliders", EMotionFX::ActorRenderFlag::RENDER_RAGDOLL_COLLIDERS, true, CreateViewOptionEntry(contextMenu, "Ragdoll Colliders", EMotionFX::ActorRenderFlagIndex::RAGDOLL_COLLIDERS, true,
":/EMotionFXAtom/RagdollCollider.svg"); ":/EMotionFXAtom/RagdollCollider.svg");
CreateViewOptionEntry(contextMenu, "Ragdoll Joint Limits", EMotionFX::ActorRenderFlag::RENDER_RAGDOLL_JOINTLIMITS, true, CreateViewOptionEntry(contextMenu, "Ragdoll Joint Limits", EMotionFX::ActorRenderFlagIndex::RAGDOLL_JOINTLIMITS, true,
":/EMotionFXAtom/RagdollJointLimit.svg"); ":/EMotionFXAtom/RagdollJointLimit.svg");
CreateViewOptionEntry(contextMenu, "Cloth Colliders", EMotionFX::ActorRenderFlag::RENDER_CLOTH_COLLIDERS, true, CreateViewOptionEntry(contextMenu, "Cloth Colliders", EMotionFX::ActorRenderFlagIndex::CLOTH_COLLIDERS, true,
":/EMotionFXAtom/Cloth.svg"); ":/EMotionFXAtom/Cloth.svg");
CreateViewOptionEntry(contextMenu, "Simulated Object Colliders", EMotionFX::ActorRenderFlag::RENDER_SIMULATEDOBJECT_COLLIDERS, true, CreateViewOptionEntry(contextMenu, "Simulated Object Colliders", EMotionFX::ActorRenderFlagIndex::SIMULATEDOBJECT_COLLIDERS, true,
":/EMotionFXAtom/SimulatedObjectCollider.svg"); ":/EMotionFXAtom/SimulatedObjectCollider.svg");
CreateViewOptionEntry(contextMenu, "Simulated Joints", EMotionFX::ActorRenderFlag::RENDER_SIMULATEJOINTS); CreateViewOptionEntry(contextMenu, "Simulated Joints", EMotionFX::ActorRenderFlagIndex::SIMULATEJOINTS);
} }
// Add the camera button // Add the camera button
@ -158,7 +158,7 @@ namespace EMStudio
} }
void AnimViewportToolBar::CreateViewOptionEntry( void AnimViewportToolBar::CreateViewOptionEntry(
QMenu* menu, const char* menuEntryName, uint32_t actionIndex, bool visible, const char* iconFileName) QMenu* menu, const char* menuEntryName, AZ::u8 actionIndex, bool visible, const char* iconFileName)
{ {
QAction* action = menu->addAction( QAction* action = menu->addAction(
menuEntryName, menuEntryName,
@ -194,13 +194,13 @@ namespace EMStudio
m_manipulatorActions[mode]->setChecked(true); m_manipulatorActions[mode]->setChecked(true);
} }
const EMotionFX::ActorRenderFlagBitset renderFlags = renderOptions->GetRenderFlags(); const EMotionFX::ActorRenderFlags renderFlags = renderOptions->GetRenderFlags();
for (size_t i = 0; i < renderFlags.size(); ++i) for (uint8 i = 0; i < EMotionFX::ActorRenderFlagIndex::NUM_RENDERFLAGINDEXES; ++i)
{ {
QAction* action = m_renderActions[i]; QAction* action = m_renderActions[i];
if (action) if (action)
{ {
action->setChecked(renderFlags[i]); action->setChecked(EMotionFX::ActorRenderFlagUtil::CheckBit(renderFlags, i));
} }
} }
} }

4
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportToolBar.h
Unescape Escape View File

@ -30,11 +30,11 @@ namespace EMStudio
private: private:
void CreateViewOptionEntry( void CreateViewOptionEntry(
QMenu* menu, const char* menuEntryName, uint32_t actionIndex, bool visible = true, const char* iconFileName = nullptr); QMenu* menu, const char* menuEntryName, AZ::u8 actionIndex, bool visible = true, const char* iconFileName = nullptr);
AtomRenderPlugin* m_plugin = nullptr; AtomRenderPlugin* m_plugin = nullptr;
QAction* m_manipulatorActions[RenderOptions::ManipulatorMode::NUM_MODES] = { nullptr }; QAction* m_manipulatorActions[RenderOptions::ManipulatorMode::NUM_MODES] = { nullptr };
QAction* m_renderActions[EMotionFX::ActorRenderFlag::NUM_RENDERFLAGS] = { nullptr }; QAction* m_renderActions[EMotionFX::ActorRenderFlagIndex::NUM_RENDERFLAGINDEXES] = { nullptr };
QAction* m_followCharacterAction = nullptr; QAction* m_followCharacterAction = nullptr;
}; };
} }

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportWidget.cpp
Unescape Escape View File

@ -229,7 +229,7 @@ namespace EMStudio
} }
} }
void AnimViewportWidget::UpdateRenderFlags(EMotionFX::ActorRenderFlagBitset renderFlags) void AnimViewportWidget::UpdateRenderFlags(EMotionFX::ActorRenderFlags renderFlags)
{ {
m_renderer->UpdateActorRenderFlag(renderFlags); m_renderer->UpdateActorRenderFlag(renderFlags);
} }

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AnimViewportWidget.h
Unescape Escape View File

@ -45,7 +45,7 @@ namespace EMStudio
// AnimViewportRequestBus::Handler overrides // AnimViewportRequestBus::Handler overrides
void UpdateCameraViewMode(RenderOptions::CameraViewMode mode); void UpdateCameraViewMode(RenderOptions::CameraViewMode mode);
void UpdateCameraFollowUp(bool follow); void UpdateCameraFollowUp(bool follow);
void UpdateRenderFlags(EMotionFX::ActorRenderFlagBitset renderFlags); void UpdateRenderFlags(EMotionFX::ActorRenderFlags renderFlags);
// ViewportPluginRequestBus::Handler overrides // ViewportPluginRequestBus::Handler overrides
AZ::s32 GetViewportId() const; AZ::s32 GetViewportId() const;

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AtomRenderPlugin.cpp
Unescape Escape View File

@ -300,7 +300,7 @@ namespace EMStudio
return &m_renderOptions; return &m_renderOptions;
} }
void AtomRenderPlugin::Render([[maybe_unused]]EMotionFX::ActorRenderFlagBitset renderFlags) void AtomRenderPlugin::Render([[maybe_unused]]EMotionFX::ActorRenderFlags renderFlags)
{ {
if (!m_animViewportWidget) if (!m_animViewportWidget)
{ {

2
Gems/AtomLyIntegration/EMotionFXAtom/Code/Tools/EMStudio/AtomRenderPlugin.h
Unescape Escape View File

@ -61,7 +61,7 @@ namespace EMStudio
void SaveRenderOptions(); void SaveRenderOptions();
RenderOptions* GetRenderOptions(); RenderOptions* GetRenderOptions();
void Render(EMotionFX::ActorRenderFlagBitset renderFlags) override; void Render(EMotionFX::ActorRenderFlags renderFlags) override;
void SetManipulatorMode(RenderOptions::ManipulatorMode mode); void SetManipulatorMode(RenderOptions::ManipulatorMode mode);
private: private:

2
Gems/EMotionFX/Code/EMotionFX/Tools/EMotionStudio/EMStudioSDK/Source/EMStudioPlugin.h
Unescape Escape View File

@ -96,7 +96,7 @@ namespace EMStudio
virtual void LegacyRender(RenderPlugin* renderPlugin, RenderInfo* renderInfo) { MCORE_UNUSED(renderPlugin); MCORE_UNUSED(renderInfo); } virtual void LegacyRender(RenderPlugin* renderPlugin, RenderInfo* renderInfo) { MCORE_UNUSED(renderPlugin); MCORE_UNUSED(renderInfo); }
//! Render function will call atom auxGeom internally to render. This is the replacement for LegacyRender function. //! Render function will call atom auxGeom internally to render. This is the replacement for LegacyRender function.
virtual void Render(EMotionFX::ActorRenderFlagBitset renderFlags) virtual void Render(EMotionFX::ActorRenderFlags renderFlags)
{ {
AZ_UNUSED(renderFlags); AZ_UNUSED(renderFlags);
}; };

25
Gems/EMotionFX/Code/EMotionFX/Tools/EMotionStudio/EMStudioSDK/Source/RenderPlugin/RenderOptions.cpp
Unescape Escape View File

@ -255,12 +255,7 @@ namespace EMStudio
settings->setValue("cameraFollowUp", m_cameraFollowUp); settings->setValue("cameraFollowUp", m_cameraFollowUp);
// Save render flags // Save render flags
settings->beginGroup("renderFlags"); settings->setValue("renderFlags", static_cast<AZ::u32>(m_renderFlags));
for (uint32 i = 0; i < EMotionFX::ActorRenderFlag::NUM_RENDERFLAGS; ++i)
{
settings->setValue(QString(i), (bool)m_renderFlags[i]);
}
settings->endGroup();
} }
RenderOptions RenderOptions::Load(QSettings* settings) RenderOptions RenderOptions::Load(QSettings* settings)
@ -333,14 +328,8 @@ namespace EMStudio
options.m_cameraFollowUp = settings->value("CameraFollowUp", options.m_cameraFollowUp).toBool(); options.m_cameraFollowUp = settings->value("CameraFollowUp", options.m_cameraFollowUp).toBool();
// Read render flags // Read render flags
settings->beginGroup("renderFlags"); options.m_renderFlags =
for (uint32 i = 0; i < EMotionFX::ActorRenderFlag::NUM_RENDERFLAGS; ++i) EMotionFX::ActorRenderFlags(settings->value("RenderFlags", static_cast<int>(EMotionFX::ActorRenderFlags::Default)).toInt());
{
const bool defaultValue = (i == EMotionFX::ActorRenderFlag::RENDER_SOLID);
const bool isEnabled = settings->value(QString(i), defaultValue).toBool();
options.m_renderFlags[i] = isEnabled;
}
settings->endGroup();
options.CopyToRenderActorSettings(EMotionFX::GetRenderActorSettings()); options.CopyToRenderActorSettings(EMotionFX::GetRenderActorSettings());
@ -1104,17 +1093,17 @@ namespace EMStudio
return m_cameraFollowUp; return m_cameraFollowUp;
} }
void RenderOptions::ToggerRenderFlag(int index) void RenderOptions::ToggerRenderFlag(uint8 index)
{ {
m_renderFlags[index] = !m_renderFlags[index]; m_renderFlags ^= EMotionFX::ActorRenderFlags(AZ_BIT(index));
} }
void RenderOptions::SetRenderFlags(EMotionFX::ActorRenderFlagBitset renderFlags) void RenderOptions::SetRenderFlags(EMotionFX::ActorRenderFlags renderFlags)
{ {
m_renderFlags = renderFlags; m_renderFlags = renderFlags;
} }
EMotionFX::ActorRenderFlagBitset RenderOptions::GetRenderFlags() const EMotionFX::ActorRenderFlags RenderOptions::GetRenderFlags() const
{ {
return m_renderFlags; return m_renderFlags;
} }

8
Gems/EMotionFX/Code/EMotionFX/Tools/EMotionStudio/EMStudioSDK/Source/RenderPlugin/RenderOptions.h
Unescape Escape View File

@ -284,9 +284,9 @@ namespace EMStudio
void SetCameraFollowUp(bool followUp); void SetCameraFollowUp(bool followUp);
bool GetCameraFollowUp() const; bool GetCameraFollowUp() const;
void ToggerRenderFlag(int index); void ToggerRenderFlag(uint8 index);
void SetRenderFlags(EMotionFX::ActorRenderFlagBitset renderFlags); void SetRenderFlags(EMotionFX::ActorRenderFlags renderFlags);
EMotionFX::ActorRenderFlagBitset GetRenderFlags() const; EMotionFX::ActorRenderFlags GetRenderFlags() const;
private: private:
void OnGridUnitSizeChangedCallback() const; void OnGridUnitSizeChangedCallback() const;
@ -406,7 +406,7 @@ namespace EMStudio
ManipulatorMode m_manipulatorMode = ManipulatorMode::SELECT; ManipulatorMode m_manipulatorMode = ManipulatorMode::SELECT;
CameraViewMode m_cameraViewMode = CameraViewMode::DEFAULT; CameraViewMode m_cameraViewMode = CameraViewMode::DEFAULT;
bool m_cameraFollowUp = false; bool m_cameraFollowUp = false;
EMotionFX::ActorRenderFlagBitset m_renderFlags; EMotionFX::ActorRenderFlags m_renderFlags;
}; };
} // namespace EMStudio } // namespace EMStudio

5
Gems/EMotionFX/Code/Source/Editor/Plugins/Cloth/ClothJointInspectorPlugin.cpp
Unescape Escape View File

@ -196,10 +196,9 @@ namespace EMotionFX
renderInfo); renderInfo);
} }
void ClothJointInspectorPlugin::Render(EMotionFX::ActorRenderFlagBitset renderFlags) void ClothJointInspectorPlugin::Render(EMotionFX::ActorRenderFlags renderFlags)
{ {
const bool renderColliders = renderFlags[RENDER_CLOTH_COLLIDERS]; if (!AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::ClothColliders))
if (!renderColliders)
{ {
return; return;
} }

2
Gems/EMotionFX/Code/Source/Editor/Plugins/Cloth/ClothJointInspectorPlugin.h
Unescape Escape View File

@ -48,7 +48,7 @@ namespace EMotionFX
void OnContextMenu(QMenu* menu, const QModelIndexList& selectedRowIndices) override; void OnContextMenu(QMenu* menu, const QModelIndexList& selectedRowIndices) override;
void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override; void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override;
void Render(EMotionFX::ActorRenderFlagBitset renderFlags) override; void Render(EMotionFX::ActorRenderFlags renderFlags) override;
static bool IsJointInCloth(const QModelIndex& index); static bool IsJointInCloth(const QModelIndex& index);
public slots: public slots:

5
Gems/EMotionFX/Code/Source/Editor/Plugins/HitDetection/HitDetectionJointInspectorPlugin.cpp
Unescape Escape View File

@ -181,10 +181,9 @@ namespace EMotionFX
renderInfo); renderInfo);
} }
void HitDetectionJointInspectorPlugin::Render(EMotionFX::ActorRenderFlagBitset renderFlags) void HitDetectionJointInspectorPlugin::Render(EMotionFX::ActorRenderFlags renderFlags)
{ {
const bool renderColliders = renderFlags[EMotionFX::ActorRenderFlag::RENDER_HITDETECTION_COLLIDERS]; if (!AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::HitDetectionColliders))
if (!renderColliders)
{ {
return; return;
} }

2
Gems/EMotionFX/Code/Source/Editor/Plugins/HitDetection/HitDetectionJointInspectorPlugin.h
Unescape Escape View File

@ -44,7 +44,7 @@ namespace EMotionFX
void OnContextMenu(QMenu* menu, const QModelIndexList& selectedRowIndices) override; void OnContextMenu(QMenu* menu, const QModelIndexList& selectedRowIndices) override;
void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override; void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override;
void Render(EMotionFX::ActorRenderFlagBitset renderFlags) override; void Render(EMotionFX::ActorRenderFlags renderFlags) override;
public slots: public slots:
void OnAddCollider(); void OnAddCollider();

6
Gems/EMotionFX/Code/Source/Editor/Plugins/Ragdoll/RagdollNodeInspectorPlugin.cpp
Unescape Escape View File

@ -595,10 +595,10 @@ namespace EMotionFX
renderInfo->m_renderUtil->RenderArrow(0.1f, jointChildWorldSpaceTransformNoScale.m_position, MCore::GetRight(jointChildWorldSpaceTransformNoScale.ToAZTransform()), color); renderInfo->m_renderUtil->RenderArrow(0.1f, jointChildWorldSpaceTransformNoScale.m_position, MCore::GetRight(jointChildWorldSpaceTransformNoScale.ToAZTransform()), color);
} }
void RagdollNodeInspectorPlugin::Render(EMotionFX::ActorRenderFlagBitset renderFlags) void RagdollNodeInspectorPlugin::Render(EMotionFX::ActorRenderFlags renderFlags)
{ {
const bool renderColliders = renderFlags[RENDER_RAGDOLL_COLLIDERS]; const bool renderColliders = AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::RagdollColliders);
const bool renderJointLimits = renderFlags[RENDER_RAGDOLL_JOINTLIMITS]; const bool renderJointLimits = AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::RagdollJointLimits);
if (!renderColliders && !renderJointLimits) if (!renderColliders && !renderJointLimits)
{ {
return; return;

2
Gems/EMotionFX/Code/Source/Editor/Plugins/Ragdoll/RagdollNodeInspectorPlugin.h
Unescape Escape View File

@ -74,7 +74,7 @@ namespace EMotionFX
const MCore::RGBAColor& color); const MCore::RGBAColor& color);
//! Those function replaces legacyRender function and calls atom auxGeom render internally. //! Those function replaces legacyRender function and calls atom auxGeom render internally.
void Render(EMotionFX::ActorRenderFlagBitset renderFlags) override; void Render(EMotionFX::ActorRenderFlags renderFlags) override;
void RenderRagdoll( void RenderRagdoll(
ActorInstance* actorInstance, ActorInstance* actorInstance,
bool renderColliders, bool renderColliders,

8
Gems/EMotionFX/Code/Source/Editor/Plugins/SimulatedObject/SimulatedObjectWidget.cpp
Unescape Escape View File

@ -570,7 +570,7 @@ namespace EMotionFX
drawData->Unlock(); drawData->Unlock();
} }
void SimulatedObjectWidget::Render(EMotionFX::ActorRenderFlagBitset renderFlags) void SimulatedObjectWidget::Render(EMotionFX::ActorRenderFlags renderFlags)
{ {
if (!m_actor || !m_actorInstance) if (!m_actor || !m_actorInstance)
{ {
@ -578,9 +578,8 @@ namespace EMotionFX
} }
const AZ::Render::RenderActorSettings& settings = EMotionFX::GetRenderActorSettings(); const AZ::Render::RenderActorSettings& settings = EMotionFX::GetRenderActorSettings();
const bool renderSimulatedJoints = renderFlags[RENDER_SIMULATEJOINTS];
const AZStd::unordered_set<size_t>& selectedJointIndices = EMStudio::GetManager()->GetSelectedJointIndices(); const AZStd::unordered_set<size_t>& selectedJointIndices = EMStudio::GetManager()->GetSelectedJointIndices();
if (renderSimulatedJoints && !selectedJointIndices.empty()) if (AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::SimulatedJoints) && !selectedJointIndices.empty())
{ {
// Render the joint radius. // Render the joint radius.
const size_t actorInstanceCount = GetActorManager().GetNumActorInstances(); const size_t actorInstanceCount = GetActorManager().GetNumActorInstances();
@ -613,8 +612,7 @@ namespace EMotionFX
} }
} }
const bool renderColliders = renderFlags[RENDER_SIMULATEDOBJECT_COLLIDERS]; if (AZ::RHI::CheckBitsAny(renderFlags, EMotionFX::ActorRenderFlags::SimulatedObjectColliders))
if (renderColliders)
{ {
ColliderContainerWidget::RenderColliders(PhysicsSetup::SimulatedObjectCollider, ColliderContainerWidget::RenderColliders(PhysicsSetup::SimulatedObjectCollider,
settings.m_simulatedObjectColliderColor, settings.m_selectedSimulatedObjectColliderColor); settings.m_simulatedObjectColliderColor, settings.m_selectedSimulatedObjectColliderColor);

2
Gems/EMotionFX/Code/Source/Editor/Plugins/SimulatedObject/SimulatedObjectWidget.h
Unescape Escape View File

@ -61,7 +61,7 @@ namespace EMotionFX
void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override; void LegacyRender(EMStudio::RenderPlugin* renderPlugin, RenderInfo* renderInfo) override;
void LegacyRenderJointRadius(const SimulatedJoint* joint, ActorInstance* actorInstance, const AZ::Color& color); void LegacyRenderJointRadius(const SimulatedJoint* joint, ActorInstance* actorInstance, const AZ::Color& color);
void Render(EMotionFX::ActorRenderFlagBitset renderFlags) override; void Render(EMotionFX::ActorRenderFlags renderFlags) override;
void RenderJointRadius(const SimulatedJoint* joint, ActorInstance* actorInstance, const AZ::Color& color); void RenderJointRadius(const SimulatedJoint* joint, ActorInstance* actorInstance, const AZ::Color& color);
SimulatedObjectModel* GetSimulatedObjectModel() const; SimulatedObjectModel* GetSimulatedObjectModel() const;

46
Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.cpp
Unescape Escape View File

@ -12,6 +12,7 @@
#include <AzCore/Serialization/EditContext.h> #include <AzCore/Serialization/EditContext.h>
#include <AzCore/RTTI/BehaviorContext.h> #include <AzCore/RTTI/BehaviorContext.h>
#include <AzCore/Math/Transform.h> #include <AzCore/Math/Transform.h>
#include <AzCore/Preprocessor/EnumReflectUtils.h>
#include <AzFramework/Physics/Ragdoll.h> #include <AzFramework/Physics/Ragdoll.h>
#include <AzFramework/Physics/RagdollPhysicsBus.h> #include <AzFramework/Physics/RagdollPhysicsBus.h>
@ -131,7 +132,10 @@ namespace EMotionFX
return AZ::Edit::PropertyVisibility::Show; return AZ::Edit::PropertyVisibility::Show;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
AZ_ENUM_DEFINE_REFLECT_UTILITIES(ActorRenderFlags);
void ActorComponent::Configuration::Reflect(AZ::ReflectContext* context) void ActorComponent::Configuration::Reflect(AZ::ReflectContext* context)
{ {
BoundingBoxConfiguration::Reflect(context); BoundingBoxConfiguration::Reflect(context);
@ -139,19 +143,19 @@ namespace EMotionFX
auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context); auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
if (serializeContext) if (serializeContext)
{ {
ActorRenderFlagsReflect(*serializeContext);
serializeContext->Class<Configuration>() serializeContext->Class<Configuration>()
->Version(4) ->Version(5)
->Field("ActorAsset", &Configuration::m_actorAsset) ->Field("ActorAsset", &Configuration::m_actorAsset)
->Field("MaterialPerLOD", &Configuration::m_materialPerLOD) ->Field("MaterialPerLOD", &Configuration::m_materialPerLOD)
->Field("RenderSkeleton", &Configuration::m_renderSkeleton)
->Field("RenderCharacter", &Configuration::m_renderCharacter)
->Field("RenderBounds", &Configuration::m_renderBounds)
->Field("AttachmentType", &Configuration::m_attachmentType) ->Field("AttachmentType", &Configuration::m_attachmentType)
->Field("AttachmentTarget", &Configuration::m_attachmentTarget) ->Field("AttachmentTarget", &Configuration::m_attachmentTarget)
->Field("SkinningMethod", &Configuration::m_skinningMethod) ->Field("SkinningMethod", &Configuration::m_skinningMethod)
->Field("LODLevel", &Configuration::m_lodLevel) ->Field("LODLevel", &Configuration::m_lodLevel)
->Field("BoundingBoxConfig", &Configuration::m_bboxConfig) ->Field("BoundingBoxConfig", &Configuration::m_bboxConfig)
->Field("ForceJointsUpdateOOV", &Configuration::m_forceUpdateJointsOOV) ->Field("ForceJointsUpdateOOV", &Configuration::m_forceUpdateJointsOOV)
->Field("RenderFlags", &Configuration::m_renderFlags)
; ;
} }
} }
@ -250,8 +254,6 @@ namespace EMotionFX
{ {
m_configuration = *configuration; m_configuration = *configuration;
} }
m_debugRenderFlags[RENDER_SOLID] = true;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -344,20 +346,24 @@ namespace EMotionFX
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
bool ActorComponent::GetRenderCharacter() const bool ActorComponent::GetRenderCharacter() const
{ {
return m_configuration.m_renderCharacter; return AZ::RHI::CheckBitsAny(m_configuration.m_renderFlags, ActorRenderFlags::Solid);
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void ActorComponent::SetRenderCharacter(bool enable) void ActorComponent::SetRenderCharacter(bool enable)
{ {
if (m_configuration.m_renderCharacter != enable) if (enable)
{
m_configuration.m_renderFlags |= ActorRenderFlags::Solid;
}
else
{ {
m_configuration.m_renderCharacter = enable; m_configuration.m_renderFlags &= ~ActorRenderFlags::Solid;
}
if (m_renderActorInstance) if (m_renderActorInstance)
{ {
m_renderActorInstance->SetIsVisible(m_configuration.m_renderCharacter); m_renderActorInstance->SetIsVisible(enable);
}
} }
} }
@ -394,9 +400,9 @@ namespace EMotionFX
return m_sceneFinishSimHandler.IsConnected(); return m_sceneFinishSimHandler.IsConnected();
} }
void ActorComponent::SetRenderFlag(ActorRenderFlagBitset renderFlags) void ActorComponent::SetRenderFlag(ActorRenderFlags renderFlags)
{ {
m_debugRenderFlags = renderFlags; m_configuration.m_renderFlags = renderFlags;
} }
void ActorComponent::CheckActorCreation() void ActorComponent::CheckActorCreation()
@ -456,7 +462,7 @@ namespace EMotionFX
if (m_renderActorInstance) if (m_renderActorInstance)
{ {
m_renderActorInstance->SetIsVisible(m_configuration.m_renderCharacter); m_renderActorInstance->SetIsVisible(AZ::RHI::CheckBitsAny(m_configuration.m_renderFlags, ActorRenderFlags::Solid));
} }
} }
@ -563,22 +569,18 @@ namespace EMotionFX
m_renderActorInstance->OnTick(deltaTime); m_renderActorInstance->OnTick(deltaTime);
m_renderActorInstance->UpdateBounds(); m_renderActorInstance->UpdateBounds();
AZ::Interface<AzFramework::IEntityBoundsUnion>::Get()->RefreshEntityLocalBoundsUnion(GetEntityId()); AZ::Interface<AzFramework::IEntityBoundsUnion>::Get()->RefreshEntityLocalBoundsUnion(GetEntityId());
const bool renderActorSolid = AZ::RHI::CheckBitsAny(m_configuration.m_renderFlags, ActorRenderFlags::Solid);
// Optimization: Set the actor instance invisible when character is out of camera view. This will stop the joint transforms update, except the root joint. // Optimization: Set the actor instance invisible when character is out of camera view. This will stop the joint transforms update, except the root joint.
// Calling it after the bounds on the render actor updated. // Calling it after the bounds on the render actor updated.
if (!m_configuration.m_forceUpdateJointsOOV) if (!m_configuration.m_forceUpdateJointsOOV)
{ {
const bool isInCameraFrustum = m_renderActorInstance->IsInCameraFrustum(); const bool isInCameraFrustum = m_renderActorInstance->IsInCameraFrustum();
m_actorInstance->SetIsVisible(isInCameraFrustum && m_configuration.m_renderCharacter); m_actorInstance->SetIsVisible(isInCameraFrustum && renderActorSolid);
} }
m_renderActorInstance->SetIsVisible(m_debugRenderFlags[RENDER_SOLID]); m_renderActorInstance->SetIsVisible(renderActorSolid);
m_renderActorInstance->DebugDraw(m_configuration.m_renderFlags);
// The configuration stores some debug option. When that is enabled, we override it on top of the render flags.
m_debugRenderFlags[RENDER_AABB] = m_debugRenderFlags[RENDER_AABB] || m_configuration.m_renderBounds;
m_debugRenderFlags[RENDER_LINESKELETON] = m_debugRenderFlags[RENDER_LINESKELETON] || m_configuration.m_renderSkeleton;
m_debugRenderFlags[RENDER_EMFX_DEBUG] = true;
m_renderActorInstance->DebugDraw(m_debugRenderFlags);
} }
} }

7
Gems/EMotionFX/Code/Source/Integration/Components/ActorComponent.h
Unescape Escape View File

@ -82,11 +82,9 @@ namespace EMotionFX
AZ::EntityId m_attachmentTarget{}; ///< Target entity this actor should attach to. AZ::EntityId m_attachmentTarget{}; ///< Target entity this actor should attach to.
size_t m_attachmentJointIndex = InvalidIndex; ///< Index of joint on target skeleton for actor attachments. size_t m_attachmentJointIndex = InvalidIndex; ///< Index of joint on target skeleton for actor attachments.
AttachmentType m_attachmentType = AttachmentType::None; ///< Type of attachment. AttachmentType m_attachmentType = AttachmentType::None; ///< Type of attachment.
bool m_renderSkeleton = false; ///< Toggles debug rendering of the skeleton.
bool m_renderCharacter = true; ///< Toggles rendering of the character.
bool m_renderBounds = false; ///< Toggles rendering of the character bounds used for visibility testing.
SkinningMethod m_skinningMethod = SkinningMethod::DualQuat; ///< The skinning method for this actor SkinningMethod m_skinningMethod = SkinningMethod::DualQuat; ///< The skinning method for this actor
size_t m_lodLevel = 0; size_t m_lodLevel = 0;
ActorRenderFlags m_renderFlags = ActorRenderFlags::Default; ///< Actor render flag
// Force updating the joints when it is out of camera view. By // Force updating the joints when it is out of camera view. By
// default, joints level update (beside the root joint) on // default, joints level update (beside the root joint) on
@ -180,7 +178,7 @@ namespace EMotionFX
bool IsPhysicsSceneSimulationFinishEventConnected() const; bool IsPhysicsSceneSimulationFinishEventConnected() const;
AZ::Data::Asset<ActorAsset> GetActorAsset() const { return m_configuration.m_actorAsset; } AZ::Data::Asset<ActorAsset> GetActorAsset() const { return m_configuration.m_actorAsset; }
void SetRenderFlag(ActorRenderFlagBitset renderFlags); void SetRenderFlag(ActorRenderFlags renderFlags);
private: private:
// AZ::TransformNotificationBus::MultiHandler // AZ::TransformNotificationBus::MultiHandler
@ -202,7 +200,6 @@ namespace EMotionFX
AZStd::vector<AZ::EntityId> m_attachments; AZStd::vector<AZ::EntityId> m_attachments;
AZStd::unique_ptr<RenderActorInstance> m_renderActorInstance; AZStd::unique_ptr<RenderActorInstance> m_renderActorInstance;
ActorRenderFlagBitset m_debugRenderFlags; ///< Actor debug render flag
AzPhysics::SceneEvents::OnSceneSimulationFinishHandler m_sceneFinishSimHandler; AzPhysics::SceneEvents::OnSceneSimulationFinishHandler m_sceneFinishSimHandler;
}; };

45
Gems/EMotionFX/Code/Source/Integration/Editor/Components/EditorActorComponent.cpp
Unescape Escape View File

@ -124,12 +124,12 @@ namespace EMotionFX
->Attribute(AZ::Edit::Attributes::AutoExpand, true) ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
->DataElement(0, &EditorActorComponent::m_renderCharacter, ->DataElement(0, &EditorActorComponent::m_renderCharacter,
"Draw character", "Toggles rendering of character mesh.") "Draw character", "Toggles rendering of character mesh.")
->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnDebugDrawFlagChanged) ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnRenderFlagChanged)
->DataElement(0, &EditorActorComponent::m_renderSkeleton, ->DataElement(0, &EditorActorComponent::m_renderSkeleton,
"Draw skeleton", "Toggles rendering of skeleton.") "Draw skeleton", "Toggles rendering of skeleton.")
->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnDebugDrawFlagChanged) ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnRenderFlagChanged)
->DataElement(0, &EditorActorComponent::m_renderBounds, "Draw bounds", "Toggles rendering of world space bounding boxes.") ->DataElement(0, &EditorActorComponent::m_renderBounds, "Draw bounds", "Toggles rendering of world space bounding boxes.")
->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnDebugDrawFlagChanged) ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnRenderFlagChanged)
->DataElement(AZ::Edit::UIHandlers::ComboBox, &EditorActorComponent::m_skinningMethod, ->DataElement(AZ::Edit::UIHandlers::ComboBox, &EditorActorComponent::m_skinningMethod,
"Skinning method", "Choose the skinning method this actor is using") "Skinning method", "Choose the skinning method this actor is using")
->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnSkinningMethodChanged) ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorActorComponent::OnSkinningMethodChanged)
@ -180,7 +180,6 @@ namespace EMotionFX
, m_lodLevel(0) , m_lodLevel(0)
, m_actorAsset(AZ::Data::AssetLoadBehavior::NoLoad) , m_actorAsset(AZ::Data::AssetLoadBehavior::NoLoad)
{ {
m_debugRenderFlags[RENDER_SOLID] = true;
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -198,6 +197,7 @@ namespace EMotionFX
{ {
AzToolsFramework::Components::EditorComponentBase::Activate(); AzToolsFramework::Components::EditorComponentBase::Activate();
UpdateRenderFlags();
LoadActorAsset(); LoadActorAsset();
const AZ::EntityId entityId = GetEntityId(); const AZ::EntityId entityId = GetEntityId();
@ -363,8 +363,9 @@ namespace EMotionFX
} }
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void EditorActorComponent::OnDebugDrawFlagChanged() void EditorActorComponent::OnRenderFlagChanged()
{ {
UpdateRenderFlags();
if (m_renderSkeleton || m_renderBounds || m_renderCharacter) if (m_renderSkeleton || m_renderBounds || m_renderCharacter)
{ {
AZ::TickBus::Handler::BusConnect(); AZ::TickBus::Handler::BusConnect();
@ -573,6 +574,23 @@ namespace EMotionFX
ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::InvalidatePropertyDisplay, Refresh_EntireTree); ToolsApplicationEvents::Bus::Broadcast(&ToolsApplicationEvents::InvalidatePropertyDisplay, Refresh_EntireTree);
} }
void EditorActorComponent::UpdateRenderFlags()
{
m_renderFlags = ActorRenderFlags::None;
if (m_renderCharacter)
{
m_renderFlags |= ActorRenderFlags::Solid;
}
if (m_renderBounds)
{
m_renderFlags |= ActorRenderFlags::AABB;
}
if (m_renderSkeleton)
{
m_renderFlags |= ActorRenderFlags::LineSkeleton;
}
}
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
void EditorActorComponent::OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world) void EditorActorComponent::OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world)
{ {
@ -616,22 +634,16 @@ namespace EMotionFX
{ {
m_renderActorInstance->OnTick(deltaTime); m_renderActorInstance->OnTick(deltaTime);
m_renderActorInstance->UpdateBounds(); m_renderActorInstance->UpdateBounds();
m_renderActorInstance->DebugDraw(m_renderFlags);
m_debugRenderFlags[RENDER_AABB] = m_renderBounds;
m_debugRenderFlags[RENDER_LINESKELETON] = m_renderSkeleton;
m_debugRenderFlags[RENDER_EMFX_DEBUG] = true;
m_renderActorInstance->DebugDraw(m_debugRenderFlags);
} }
} }
void EditorActorComponent::BuildGameEntity(AZ::Entity* gameEntity) void EditorActorComponent::BuildGameEntity(AZ::Entity* gameEntity)
{ {
UpdateRenderFlags();
ActorComponent::Configuration cfg; ActorComponent::Configuration cfg;
cfg.m_actorAsset = m_actorAsset; cfg.m_actorAsset = m_actorAsset;
cfg.m_materialPerLOD = m_materialPerLOD; cfg.m_materialPerLOD = m_materialPerLOD;
cfg.m_renderSkeleton = m_renderSkeleton;
cfg.m_renderCharacter = m_renderCharacter;
cfg.m_renderBounds = m_renderBounds;
cfg.m_attachmentType = m_attachmentType; cfg.m_attachmentType = m_attachmentType;
cfg.m_attachmentTarget = m_attachmentTarget; cfg.m_attachmentTarget = m_attachmentTarget;
cfg.m_attachmentJointIndex = m_attachmentJointIndex; cfg.m_attachmentJointIndex = m_attachmentJointIndex;
@ -639,6 +651,7 @@ namespace EMotionFX
cfg.m_skinningMethod = m_skinningMethod; cfg.m_skinningMethod = m_skinningMethod;
cfg.m_bboxConfig = m_bboxConfig; cfg.m_bboxConfig = m_bboxConfig;
cfg.m_forceUpdateJointsOOV = m_forceUpdateJointsOOV; cfg.m_forceUpdateJointsOOV = m_forceUpdateJointsOOV;
cfg.m_renderFlags = m_renderFlags;
gameEntity->AddComponent(aznew ActorComponent(&cfg)); gameEntity->AddComponent(aznew ActorComponent(&cfg));
} }
@ -861,7 +874,7 @@ namespace EMotionFX
void EditorActorComponent::CheckActorCreation() void EditorActorComponent::CheckActorCreation()
{ {
// Enable/disable debug drawing. // Enable/disable debug drawing.
OnDebugDrawFlagChanged(); OnRenderFlagChanged();
// Create actor instance. // Create actor instance.
auto* actorAsset = m_actorAsset.GetAs<ActorAsset>(); auto* actorAsset = m_actorAsset.GetAs<ActorAsset>();
@ -964,9 +977,9 @@ namespace EMotionFX
} }
} }
void EditorActorComponent::SetRenderFlag(ActorRenderFlagBitset renderFlags) void EditorActorComponent::SetRenderFlag(ActorRenderFlags renderFlags)
{ {
m_debugRenderFlags = renderFlags; m_renderFlags = renderFlags;
} }
} //namespace Integration } //namespace Integration
} // namespace EMotionFX } // namespace EMotionFX

7
Gems/EMotionFX/Code/Source/Integration/Editor/Components/EditorActorComponent.h
Unescape Escape View File

@ -104,7 +104,7 @@ namespace EMotionFX
ActorComponent::GetRequiredServices(required); ActorComponent::GetRequiredServices(required);
} }
void SetRenderFlag(ActorRenderFlagBitset renderFlags); void SetRenderFlag(ActorRenderFlags renderFlags);
static void Reflect(AZ::ReflectContext* context); static void Reflect(AZ::ReflectContext* context);
@ -114,7 +114,7 @@ namespace EMotionFX
void OnMaterialChanged(); void OnMaterialChanged();
void OnMaterialPerActorChanged(); void OnMaterialPerActorChanged();
void OnLODLevelChanged(); void OnLODLevelChanged();
void OnDebugDrawFlagChanged(); void OnRenderFlagChanged();
void OnSkinningMethodChanged(); void OnSkinningMethodChanged();
AZ::Crc32 OnAttachmentTypeChanged(); AZ::Crc32 OnAttachmentTypeChanged();
AZ::Crc32 OnAttachmentTargetChanged(); AZ::Crc32 OnAttachmentTargetChanged();
@ -124,6 +124,7 @@ namespace EMotionFX
bool AttachmentTargetJointVisibility(); bool AttachmentTargetJointVisibility();
AZStd::string AttachmentJointButtonText(); AZStd::string AttachmentJointButtonText();
void InitializeMaterial(ActorAsset& actorAsset); void InitializeMaterial(ActorAsset& actorAsset);
void UpdateRenderFlags();
void LaunchAnimationEditor(const AZ::Data::AssetId& assetId, const AZ::Data::AssetType&); void LaunchAnimationEditor(const AZ::Data::AssetId& assetId, const AZ::Data::AssetType&);
@ -164,7 +165,7 @@ namespace EMotionFX
size_t m_lodLevel; size_t m_lodLevel;
ActorComponent::BoundingBoxConfiguration m_bboxConfig; ActorComponent::BoundingBoxConfiguration m_bboxConfig;
bool m_forceUpdateJointsOOV = false; bool m_forceUpdateJointsOOV = false;
ActorRenderFlagBitset m_debugRenderFlags; ///< Actor debug render flag ActorRenderFlags m_renderFlags; ///< Actor render flag
// \todo attachmentTarget node nr // \todo attachmentTarget node nr
// Note: LOD work in progress. For now we use one material instead of a list of material, because we don't have the support for LOD with multiple scene files. // Note: LOD work in progress. For now we use one material instead of a list of material, because we don't have the support for LOD with multiple scene files.

2
Gems/EMotionFX/Code/Source/Integration/Rendering/RenderActorInstance.h
Unescape Escape View File

@ -34,7 +34,7 @@ namespace EMotionFX
virtual ~RenderActorInstance() = default; virtual ~RenderActorInstance() = default;
virtual void OnTick(float timeDelta) = 0; virtual void OnTick(float timeDelta) = 0;
virtual void DebugDraw(const EMotionFX::ActorRenderFlagBitset& renderFlags) = 0; virtual void DebugDraw(const EMotionFX::ActorRenderFlags& renderFlags) = 0;
SkinningMethod GetSkinningMethod() const; SkinningMethod GetSkinningMethod() const;
virtual void SetSkinningMethod(SkinningMethod skinningMethod); virtual void SetSkinningMethod(SkinningMethod skinningMethod);

105
Gems/EMotionFX/Code/Source/Integration/Rendering/RenderFlag.h
Unescape Escape View File

@ -7,38 +7,87 @@
*/ */
#pragma once #pragma once
#include <AzCore/std/containers/bitset.h> #include <AzCore/Preprocessor/Enum.h>
#include <Atom/RHI.Reflect/Bits.h>
namespace EMotionFX namespace EMotionFX
{ {
enum ActorRenderFlag // The index of the render flag which is 0, 1, 2, 3.. based.
// Do not confuse this with the actual ActorRenderFlags::Type which is 1, 2, 4, 8.. based.
enum ActorRenderFlagIndex : AZ::u8
{ {
RENDER_SOLID = 0, SOLID = 0,
RENDER_WIREFRAME = 1, WIREFRAME = 1,
RENDER_LIGHTING = 2, LIGHTING = 2,
RENDER_SHADOWS = 3, SHADOWS = 3,
RENDER_FACENORMALS = 4, FACENORMALS = 4,
RENDER_VERTEXNORMALS = 5, VERTEXNORMALS = 5,
RENDER_TANGENTS = 6, TANGENTS = 6,
RENDER_AABB = 7, AABB = 7,
RENDER_SKELETON = 8, SKELETON = 8,
RENDER_LINESKELETON = 9, LINESKELETON = 9,
RENDER_NODEORIENTATION = 10, NODEORIENTATION = 10,
RENDER_NODENAMES = 11, NODENAMES = 11,
RENDER_GRID = 12, GRID = 12,
RENDER_BACKFACECULLING = 13, BACKFACECULLING = 13,
RENDER_ACTORBINDPOSE = 14, ACTORBINDPOSE = 14,
RENDER_RAGDOLL_COLLIDERS = 15, RAGDOLL_COLLIDERS = 15,
RENDER_RAGDOLL_JOINTLIMITS = 16, RAGDOLL_JOINTLIMITS = 16,
RENDER_HITDETECTION_COLLIDERS = 17, HITDETECTION_COLLIDERS = 17,
RENDER_USE_GRADIENTBACKGROUND = 18, USE_GRADIENTBACKGROUND = 18,
RENDER_MOTIONEXTRACTION = 19, MOTIONEXTRACTION = 19,
RENDER_CLOTH_COLLIDERS = 20, CLOTH_COLLIDERS = 20,
RENDER_SIMULATEDOBJECT_COLLIDERS = 21, SIMULATEDOBJECT_COLLIDERS = 21,
RENDER_SIMULATEJOINTS = 22, SIMULATEJOINTS = 22,
RENDER_EMFX_DEBUG = 23, EMFX_DEBUG = 23,
NUM_RENDERFLAGS = 24 NUM_RENDERFLAGINDEXES = 24
}; };
using ActorRenderFlagBitset = AZStd::bitset<ActorRenderFlag::NUM_RENDERFLAGS>; //! A set of combinable flags which indicate which render option in turned on for the actor.
AZ_ENUM_CLASS_WITH_UNDERLYING_TYPE(ActorRenderFlags, AZ::u32,
(None, 0),
(Solid, AZ_BIT(ActorRenderFlagIndex::SOLID)),
(Wireframe, AZ_BIT(ActorRenderFlagIndex::WIREFRAME)),
(Lighting, AZ_BIT(ActorRenderFlagIndex::LIGHTING)),
(Default, Solid | Lighting),
(Shadows, AZ_BIT(ActorRenderFlagIndex::SHADOWS)),
(FaceNormals, AZ_BIT(ActorRenderFlagIndex::FACENORMALS)),
(VertexNormals, AZ_BIT(ActorRenderFlagIndex::VERTEXNORMALS)),
(Tangents, AZ_BIT(ActorRenderFlagIndex::TANGENTS)),
(AABB, AZ_BIT(ActorRenderFlagIndex::AABB)),
(Skeleton, AZ_BIT(ActorRenderFlagIndex::SKELETON)),
(LineSkeleton, AZ_BIT(ActorRenderFlagIndex::LINESKELETON)),
(NodeOrientation, AZ_BIT(ActorRenderFlagIndex::NODEORIENTATION)),
(NodeNames, AZ_BIT(ActorRenderFlagIndex::NODENAMES)),
(Grid, AZ_BIT(ActorRenderFlagIndex::GRID)),
(BackfaceCulling, AZ_BIT(ActorRenderFlagIndex::BACKFACECULLING)),
(ActorBindPose, AZ_BIT(ActorRenderFlagIndex::ACTORBINDPOSE)),
(RagdollColliders, AZ_BIT(ActorRenderFlagIndex::RAGDOLL_COLLIDERS)),
(RagdollJointLimits, AZ_BIT(ActorRenderFlagIndex::RAGDOLL_JOINTLIMITS)),
(HitDetectionColliders, AZ_BIT(ActorRenderFlagIndex::HITDETECTION_COLLIDERS)),
(UseGradientBackground, AZ_BIT(ActorRenderFlagIndex::USE_GRADIENTBACKGROUND)),
(MotionExtraction, AZ_BIT(ActorRenderFlagIndex::MOTIONEXTRACTION)),
(ClothColliders, AZ_BIT(ActorRenderFlagIndex::CLOTH_COLLIDERS)),
(SimulatedObjectColliders, AZ_BIT(ActorRenderFlagIndex::SIMULATEDOBJECT_COLLIDERS)),
(SimulatedJoints, AZ_BIT(ActorRenderFlagIndex::SIMULATEJOINTS)),
(EmfxDebug, AZ_BIT(ActorRenderFlagIndex::EMFX_DEBUG))
);
AZ_DEFINE_ENUM_BITWISE_OPERATORS(ActorRenderFlags);
class ActorRenderFlagUtil
{
public:
// Check the bit value with the offset start at 0 from the right.
// CheckBit(flags, 0) means check the last digit of the flags, CheckBit(flags, 1) means the second digit from right, etc.
static bool CheckBit(ActorRenderFlags flags, AZ::u8 offset)
{
return (flags & ActorRenderFlags(AZ_BIT(offset))) != ActorRenderFlags(0);
}
};
}
namespace AZ
{
AZ_TYPE_INFO_SPECIALIZE(EMotionFX::ActorRenderFlags, "{2D2187FA-2C1A-4485-AF7C-AD34C0514105}");
} }

2
Gems/EMotionFX/Code/Tests/RenderBackendManagerTests.cpp
Unescape Escape View File

@ -65,7 +65,7 @@ namespace EMotionFX
} }
MOCK_METHOD1(OnTick, void(float)); MOCK_METHOD1(OnTick, void(float));
MOCK_METHOD1(DebugDraw, void(const EMotionFX::ActorRenderFlagBitset&)); MOCK_METHOD1(DebugDraw, void(const EMotionFX::ActorRenderFlags&));
MOCK_CONST_METHOD0(IsVisible, bool()); MOCK_CONST_METHOD0(IsVisible, bool());
MOCK_METHOD1(SetIsVisible, void(bool)); MOCK_METHOD1(SetIsVisible, void(bool));
MOCK_METHOD1(SetMaterials, void(const ActorAsset::MaterialList&)); MOCK_METHOD1(SetMaterials, void(const ActorAsset::MaterialList&));

Write Preview
Loading…
Cancel
Save