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

Updated AnimNode registration in LyShine and Maestro to register to a member variable map (#6786)

Browse Source 
* Updated the Maestro MovieSystem and LyShine AnimationSystem to register
Anim Nodes and Anim Params into a member variable map

Previously the registration was occuring in a global variable map inside
of Movie.cpp and UiAnimationSystem.cpp

Rolled back the changes to update the CUiAnimNode and CAnimParamType to
use the stateless allocator in their m_name string member.
This was only needed because those types were used in global memory.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Updated the AZStd::hash specializations for basic_string and
basic_fixed_string to be transparent.

This allows hashing of types that aren't basic_string or
basic_fixed_string using the hash specializations for those types
without needing to create an instance of those types.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Adding call to disable saving of the UserSettings.xml in the DisplaySettingsPythonBindingsFixture to avoid race condition running the test in parallel

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>
This commit is contained in:
lumberyard-employee-dm
2022-01-14 11:32:29 -06:00
committed by GitHub
parent 4392c8963c
commit b62d130475
13 changed files with 227 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/LyShine/Code/Source/Animation/UiAnimationSystem.cpp
+55 -78
View File
@@ -14,77 +14,59 @@
#include "UiAnimSerialize.h"
#include <AzCore/Component/ComponentApplicationBus.h>
#include <AzCore/std/allocator_stateless.h>
#include <AzCore/std/containers/map.h>
#include <AzCore/std/containers/unordered_map.h>
#include <StlUtils.h>
#include <ISystem.h>
#include <ILog.h>
#include <IConsole.h>
//////////////////////////////////////////////////////////////////////////
namespace
{
using UiAnimParamSystemString = AZStd::basic_string<char, AZStd::char_traits<char>, AZStd::stateless_allocator>;
template <typename KeyType, typename MappedType, typename Compare = AZStd::less<KeyType>>
using UiAnimSystemOrderedMap = AZStd::map<KeyType, MappedType, Compare, AZStd::stateless_allocator>;
template <typename KeyType, typename MappedType, typename Hasher = AZStd::hash<KeyType>, typename EqualKey = AZStd::equal_to<KeyType>>
using UiAnimSystemUnorderedMap = AZStd::unordered_map<KeyType, MappedType, Hasher, EqualKey, AZStd::stateless_allocator>;
}
// Serialization for anim nodes & param types
#define REGISTER_NODE_TYPE(name) assert(!g_animNodeEnumToStringMap.contains(eUiAnimNodeType_ ## name)); \
g_animNodeEnumToStringMap[eUiAnimNodeType_ ## name] = AZ_STRINGIZE(name); \
g_animNodeStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimNodeType_ ## name;
#define REGISTER_NODE_TYPE(name) assert(!m_animNodeEnumToStringMap.contains(eUiAnimNodeType_ ## name)); \
m_animNodeEnumToStringMap[eUiAnimNodeType_ ## name] = AZ_STRINGIZE(name); \
m_animNodeStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimNodeType_ ## name;
#define REGISTER_PARAM_TYPE(name) assert(!g_animParamEnumToStringMap.contains(eUiAnimParamType_ ## name)); \
g_animParamEnumToStringMap[eUiAnimParamType_ ## name] = AZ_STRINGIZE(name); \
g_animParamStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimParamType_ ## name;
#define REGISTER_PARAM_TYPE(name) assert(!m_animParamEnumToStringMap.contains(eUiAnimParamType_ ## name)); \
m_animParamEnumToStringMap[eUiAnimParamType_ ## name] = AZ_STRINGIZE(name); \
m_animParamStringToEnumMap[UiAnimParamSystemString(AZ_STRINGIZE(name))] = eUiAnimParamType_ ## name;
namespace
// If you get an assert in this function, it means two node types have the same enum value.
void UiAnimationSystem::RegisterNodeTypes()
{
UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> g_animNodeEnumToStringMap;
UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimNodeType, stl::less_stricmp<UiAnimParamSystemString>> g_animNodeStringToEnumMap;
REGISTER_NODE_TYPE(Entity)
REGISTER_NODE_TYPE(Director)
REGISTER_NODE_TYPE(Camera)
REGISTER_NODE_TYPE(CVar)
REGISTER_NODE_TYPE(ScriptVar)
REGISTER_NODE_TYPE(Material)
REGISTER_NODE_TYPE(Event)
REGISTER_NODE_TYPE(Group)
REGISTER_NODE_TYPE(Layer)
REGISTER_NODE_TYPE(Comment)
REGISTER_NODE_TYPE(RadialBlur)
REGISTER_NODE_TYPE(ColorCorrection)
REGISTER_NODE_TYPE(DepthOfField)
REGISTER_NODE_TYPE(ScreenFader)
REGISTER_NODE_TYPE(Light)
REGISTER_NODE_TYPE(HDRSetup)
REGISTER_NODE_TYPE(ShadowSetup)
REGISTER_NODE_TYPE(Alembic)
REGISTER_NODE_TYPE(GeomCache)
REGISTER_NODE_TYPE(Environment)
REGISTER_NODE_TYPE(ScreenDropsSetup)
REGISTER_NODE_TYPE(AzEntity)
}
UiAnimSystemUnorderedMap<int, UiAnimParamSystemString> g_animParamEnumToStringMap;
UiAnimSystemOrderedMap<UiAnimParamSystemString, EUiAnimParamType, stl::less_stricmp<UiAnimParamSystemString>> g_animParamStringToEnumMap;
// If you get an assert in this function, it means two node types have the same enum value.
void RegisterNodeTypes()
{
REGISTER_NODE_TYPE(Entity)
REGISTER_NODE_TYPE(Director)
REGISTER_NODE_TYPE(Camera)
REGISTER_NODE_TYPE(CVar)
REGISTER_NODE_TYPE(ScriptVar)
REGISTER_NODE_TYPE(Material)
REGISTER_NODE_TYPE(Event)
REGISTER_NODE_TYPE(Group)
REGISTER_NODE_TYPE(Layer)
REGISTER_NODE_TYPE(Comment)
REGISTER_NODE_TYPE(RadialBlur)
REGISTER_NODE_TYPE(ColorCorrection)
REGISTER_NODE_TYPE(DepthOfField)
REGISTER_NODE_TYPE(ScreenFader)
REGISTER_NODE_TYPE(Light)
REGISTER_NODE_TYPE(HDRSetup)
REGISTER_NODE_TYPE(ShadowSetup)
REGISTER_NODE_TYPE(Alembic)
REGISTER_NODE_TYPE(GeomCache)
REGISTER_NODE_TYPE(Environment)
REGISTER_NODE_TYPE(ScreenDropsSetup)
REGISTER_NODE_TYPE(AzEntity)
}
// If you get an assert in this function, it means two param types have the same enum value.
void RegisterParamTypes()
{
REGISTER_PARAM_TYPE(Event)
REGISTER_PARAM_TYPE(Float)
REGISTER_PARAM_TYPE(TrackEvent)
REGISTER_PARAM_TYPE(AzComponentField)
}
// If you get an assert in this function, it means two param types have the same enum value.
void UiAnimationSystem::RegisterParamTypes()
{
REGISTER_PARAM_TYPE(Event)
REGISTER_PARAM_TYPE(Float)
REGISTER_PARAM_TYPE(TrackEvent)
REGISTER_PARAM_TYPE(AzComponentField)
}
//////////////////////////////////////////////////////////////////////////
@@ -98,6 +80,10 @@ UiAnimationSystem::UiAnimationSystem()
m_lastUpdateTime = AZ::Time::ZeroTimeUs;
m_nextSequenceId = 1;
DoNodeStaticInitialisation();
RegisterNodeTypes();
RegisterParamTypes();
}
//////////////////////////////////////////////////////////////////////////
@@ -1173,16 +1159,16 @@ void UiAnimationSystem::SerializeNodeType(EUiAnimNodeType& animNodeType, XmlNode
XmlString nodeTypeString;
if (xmlNode->getAttr(kType, nodeTypeString))
{
assert(g_animNodeStringToEnumMap.find(nodeTypeString.c_str()) != g_animNodeStringToEnumMap.end());
animNodeType = stl::find_in_map(g_animNodeStringToEnumMap, nodeTypeString.c_str(), eUiAnimNodeType_Invalid);
assert(m_animNodeStringToEnumMap.contains(nodeTypeString.c_str()));
animNodeType = stl::find_in_map(m_animNodeStringToEnumMap, nodeTypeString.c_str(), eUiAnimNodeType_Invalid);
}
}
}
else
{
const char* pTypeString = "Invalid";
assert(g_animNodeEnumToStringMap.find(animNodeType) != g_animNodeEnumToStringMap.end());
pTypeString = g_animNodeEnumToStringMap[animNodeType].c_str();
assert(m_animNodeEnumToStringMap.find(animNodeType) != m_animNodeEnumToStringMap.end());
pTypeString = m_animNodeEnumToStringMap[animNodeType].c_str();
xmlNode->setAttr(kType, pTypeString);
}
}
@@ -1242,8 +1228,8 @@ void UiAnimationSystem::SerializeParamType(CUiAnimParamType& animParamType, XmlN
}
else
{
assert(g_animParamStringToEnumMap.find(paramTypeString.c_str()) != g_animParamStringToEnumMap.end());
animParamType.m_type = stl::find_in_map(g_animParamStringToEnumMap, paramTypeString.c_str(), eUiAnimParamType_Invalid);
assert(m_animParamStringToEnumMap.contains(paramTypeString.c_str()));
animParamType.m_type = stl::find_in_map(m_animParamStringToEnumMap, paramTypeString.c_str(), eUiAnimParamType_Invalid);
}
}
}
@@ -1265,8 +1251,8 @@ void UiAnimationSystem::SerializeParamType(CUiAnimParamType& animParamType, XmlN
}
else
{
assert(g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end());
pTypeString = g_animParamEnumToStringMap[animParamType.m_type].c_str();
assert(m_animParamEnumToStringMap.find(animParamType.m_type) != m_animParamEnumToStringMap.end());
pTypeString = m_animParamEnumToStringMap[animParamType.m_type].c_str();
}
xmlNode->setAttr(kParamType, pTypeString);
@@ -1332,9 +1318,9 @@ const char* UiAnimationSystem::GetParamTypeName(const CUiAnimParamType& animPara
}
else
{
if (g_animParamEnumToStringMap.find(animParamType.m_type) != g_animParamEnumToStringMap.end())
if (m_animParamEnumToStringMap.find(animParamType.m_type) != m_animParamEnumToStringMap.end())
{
return g_animParamEnumToStringMap[animParamType.m_type].c_str();
return m_animParamEnumToStringMap[animParamType.m_type].c_str();
}
}
@@ -1346,15 +1332,6 @@ void UiAnimationSystem::OnCameraCut()
{
}
//////////////////////////////////////////////////////////////////////////
void UiAnimationSystem::StaticInitialize()
{
DoNodeStaticInitialisation();
RegisterNodeTypes();
RegisterParamTypes();
}
//////////////////////////////////////////////////////////////////////////
void UiAnimationSystem::Reflect(AZ::SerializeContext* serializeContext)
{
@@ -1380,13 +1357,13 @@ void UiAnimationSystem::Reflect(AZ::SerializeContext* serializeContext)
//////////////////////////////////////////////////////////////////////////
EUiAnimNodeType UiAnimationSystem::GetNodeTypeFromString(const char* pString) const
{
return stl::find_in_map(g_animNodeStringToEnumMap, pString, eUiAnimNodeType_Invalid);
return stl::find_in_map(m_animNodeStringToEnumMap, pString, eUiAnimNodeType_Invalid);
}
//////////////////////////////////////////////////////////////////////////
CUiAnimParamType UiAnimationSystem::GetParamTypeFromString(const char* pString) const
{
const EUiAnimParamType paramType = stl::find_in_map(g_animParamStringToEnumMap, pString, eUiAnimParamType_Invalid);
const EUiAnimParamType paramType = stl::find_in_map(m_animParamStringToEnumMap, pString, eUiAnimParamType_Invalid);
if (paramType != eUiAnimParamType_Invalid)
{