Integrating latest 47acbe8

Code/Tools/SceneAPI/SceneData/Behaviors/BehaviorsMeshGroup.cpp

@@ -115,7 +115,8 @@ namespace AZ
 
             Events::ProcessingResult MeshGroup::BuildDefault(Containers::Scene& scene) const
             {
-                if (SceneHasMeshGroup(scene) || !Utilities::DoesSceneGraphContainDataLike<DataTypes::IMeshData>(scene, true) || Utilities::DoesSceneGraphContainDataLike<DataTypes::IBoneData>(scene, true))
+                if (SceneHasMeshGroup(scene) ||
+                    !Utilities::DoesSceneGraphContainDataLike<DataTypes::IMeshData>(scene, true))
                 {
                     return Events::ProcessingResult::Ignored;
                 }

Code/Tools/SceneAPI/SceneData/Behaviors/Registry.cpp

@@ -21,6 +21,7 @@
 #include <SceneAPI/SceneData/Behaviors/ScriptProcessorRuleBehavior.h>
 #include <SceneAPI/SceneData/Behaviors/SkeletonGroup.h>
 #include <SceneAPI/SceneData/Behaviors/SkinGroup.h>
+#include <SceneAPI/SceneData/Behaviors/SkinRuleBehavior.h>
 
 namespace AZ
 {
@@ -40,7 +41,8 @@ namespace AZ
                     Behaviors::MeshGroup::CreateDescriptor(),
                     Behaviors::ScriptProcessorRuleBehavior::CreateDescriptor(),
                     Behaviors::SkeletonGroup::CreateDescriptor(),
-                    Behaviors::SkinGroup::CreateDescriptor()
+                    Behaviors::SkinGroup::CreateDescriptor(),
+                    SkinRuleBehavior::CreateDescriptor()
                 });
             }
         } // SceneData

Code/Tools/SceneAPI/SceneData/Behaviors/ScriptProcessorRuleBehavior.cpp

@@ -29,6 +29,7 @@
 #include <SceneAPI/SceneCore/Containers/Views/FilterIterator.h>
 #include <SceneAPI/SceneCore/Containers/Views/PairIterator.h>
 #include <SceneAPI/SceneData/Rules/ScriptProcessorRule.h>
+#include <SceneAPI/SceneCore/Utilities/Reporting.h>
 
 namespace AZ
 {
@@ -36,6 +37,41 @@ namespace AZ
     {
         namespace Behaviors
         {
+            class EditorPythonConsoleNotificationHandler final
+                : protected AzToolsFramework::EditorPythonConsoleNotificationBus::Handler
+            {
+            public:
+                EditorPythonConsoleNotificationHandler()
+                {
+                    BusConnect();
+                }
+
+                ~EditorPythonConsoleNotificationHandler()
+                {
+                    BusDisconnect();
+                }
+
+                ////////////////////////////////////////////////////////////////////////////////////////////
+                // AzToolsFramework::EditorPythonConsoleNotifications
+                void OnTraceMessage(AZStd::string_view message) override
+                {
+                    using namespace AZ::SceneAPI::Utilities;
+                    AZ_TracePrintf(LogWindow, "%.*s \n", AZ_STRING_ARG(message));
+                }
+
+                void OnErrorMessage(AZStd::string_view message) override
+                {
+                    using namespace AZ::SceneAPI::Utilities;
+                    AZ_TracePrintf(ErrorWindow, "[ERROR] %.*s \n", AZ_STRING_ARG(message));
+                }
+
+                void OnExceptionMessage(AZStd::string_view message) override
+                {
+                    using namespace AZ::SceneAPI::Utilities;
+                    AZ_TracePrintf(ErrorWindow, "[EXCEPTION] %.*s \n", AZ_STRING_ARG(message));
+                }
+            };                        
+
             // a event bus to signal during scene building
             struct ScriptBuildingNotifications
                 : public AZ::EBusTraits
@@ -182,6 +218,7 @@ namespace AZ
                             &ScriptBuildingNotificationBus::Events::OnUpdateManifest,
                             scene);
                     };
+                    EditorPythonConsoleNotificationHandler logger;
                     m_editorPythonEventsInterface->ExecuteWithLock(executeCallback);
 
                     // attempt to load the manifest string back to a JSON-scene-manifest

Code/Tools/SceneAPI/SceneData/Behaviors/SkinRuleBehavior.cpp

@@ -0,0 +1,65 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/std/smart_ptr/make_shared.h>
+#include <SceneAPI/SceneCore/Containers/Scene.h>
+#include <SceneAPI/SceneCore/Containers/Utilities/SceneGraphUtilities.h>
+#include <SceneAPI/SceneCore/DataTypes/Groups/IMeshGroup.h>
+#include <SceneAPI/SceneCore/DataTypes/GraphData/ISkinWeightData.h>
+#include <SceneAPI/SceneData/Rules/SkinRule.h>
+#include <SceneAPI/SceneData/Behaviors/SkinRuleBehavior.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneData
+        {
+            void SkinRuleBehavior::Reflect(AZ::ReflectContext* context)
+            {
+                SkinRule::Reflect(context);
+
+                AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<SkinRuleBehavior, SceneCore::BehaviorComponent>()->Version(1);
+                }
+            }
+
+            void SkinRuleBehavior::Activate()
+            {
+                AZ::SceneAPI::Events::ManifestMetaInfoBus::Handler::BusConnect();
+            }
+
+            void SkinRuleBehavior::Deactivate()
+            {
+                AZ::SceneAPI::Events::ManifestMetaInfoBus::Handler::BusDisconnect();
+            }
+
+            void SkinRuleBehavior::InitializeObject([[maybe_unused]] const Containers::Scene& scene, DataTypes::IManifestObject& target)
+            {
+                if (azrtti_istypeof<DataTypes::IMeshGroup>(target))
+                {
+                    DataTypes::IMeshGroup* meshGroup = azrtti_cast<DataTypes::IMeshGroup*>(&target);
+
+                    AZ::SceneAPI::Containers::RuleContainer& rules = meshGroup->GetRuleContainer();
+                    // Only add the skin rule if the scene contain any skinning data.
+                    if (!rules.ContainsRuleOfType<SkinRule>() && Utilities::DoesSceneGraphContainDataLike<DataTypes::ISkinWeightData>(scene, true))
+                    {
+                        rules.AddRule(AZStd::make_shared<SkinRule>());
+                    }
+                }
+            }
+        }
+    }
+}

Code/Tools/SceneAPI/SceneData/Behaviors/SkinRuleBehavior.h

@@ -0,0 +1,43 @@
+#pragma once
+
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/Memory/Memory.h>
+#include <SceneAPI/SceneCore/Events/ManifestMetaInfoBus.h>
+#include <SceneAPI/SceneCore/Components/BehaviorComponent.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneData
+        {
+            class SkinRuleBehavior
+                : public SceneCore::BehaviorComponent
+                , public Events::ManifestMetaInfoBus::Handler
+            {
+            public:
+                AZ_COMPONENT(SkinRuleBehavior, "{B212A863-32DD-4F92-948C-FC0ADAEEAB4A}", SceneCore::BehaviorComponent);
+
+                ~SkinRuleBehavior() override = default;
+
+                // From BehaviorComponent
+                void Activate() override;
+                void Deactivate() override;
+                static void Reflect(AZ::ReflectContext* context);
+
+                void InitializeObject(const Containers::Scene& scene, DataTypes::IManifestObject& target) override;
+            };
+        }
+    }
+}

Code/Tools/SceneAPI/SceneData/GraphData/MaterialData.cpp

@@ -144,6 +144,96 @@ namespace AZ
                 return m_shininess;
             }
 
+            void MaterialData::SetUseColorMap(bool useColorMap)
+            {
+                m_useColorMap = useColorMap;
+            }
+
+            bool MaterialData::GetUseColorMap() const
+            {
+                return m_useColorMap;
+            }
+
+            void MaterialData::SetBaseColor(const AZ::Vector3& baseColor)
+            {
+                m_baseColor = baseColor;
+            }
+
+            const AZ::Vector3& MaterialData::GetBaseColor() const
+            {
+                return m_baseColor;
+            }
+
+            void MaterialData::SetUseMetallicMap(bool useMetallicMap)
+            {
+                m_useMetallicMap = useMetallicMap;
+            }
+
+            bool MaterialData::GetUseMetallicMap() const
+            {
+                return m_useMetallicMap;
+            }
+
+            void MaterialData::SetMetallicFactor(float metallicFactor)
+            {
+                m_metallicFactor = metallicFactor;
+            }
+
+            float MaterialData::GetMetallicFactor() const
+            {
+                return m_metallicFactor;
+            }
+
+            void MaterialData::SetUseRoughnessMap(bool useRoughnessMap)
+            {
+                m_useRoughnessMap = useRoughnessMap;
+            }
+
+            bool MaterialData::GetUseRoughnessMap() const
+            {
+                return m_useRoughnessMap;
+            }
+
+            void MaterialData::SetRoughnessFactor(float roughnessFactor)
+            {
+                m_roughnessFactor = roughnessFactor;
+            }
+
+            float MaterialData::GetRoughnessFactor() const
+            {
+                return m_roughnessFactor;
+            }
+
+            void MaterialData::SetUseEmissiveMap(bool useEmissiveMap)
+            {
+                m_useEmissiveMap = useEmissiveMap;
+            }
+
+            bool MaterialData::GetUseEmissiveMap() const
+            {
+                return m_useEmissiveMap;
+            }
+
+            void MaterialData::SetEmissiveIntensity(float emissiveIntensity)
+            {
+                m_emissiveIntensity = emissiveIntensity;
+            }
+
+            float MaterialData::GetEmissiveIntensity() const
+            {
+                return m_emissiveIntensity;
+            }
+
+            void MaterialData::SetUseAOMap(bool useAOMap)
+            {
+                m_useAOMap = useAOMap;
+            }
+
+            bool MaterialData::GetUseAOMap() const
+            {
+                return m_useAOMap;
+            }
+
             uint64_t MaterialData::GetUniqueId() const
             {
                 return m_uniqueId;
@@ -154,7 +244,7 @@ namespace AZ
                 SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
                 if (serializeContext)
                 {
-                    serializeContext->Class<MaterialData>()->Version(2)
+                    serializeContext->Class<MaterialData>()->Version(4)
                         ->Field("textureMap", &MaterialData::m_textureMap)
                         ->Field("diffuseColor", &MaterialData::m_diffuseColor)
                         ->Field("specularColor", &MaterialData::m_specularColor)
@@ -162,7 +252,16 @@ namespace AZ
                         ->Field("opacity", &MaterialData::m_opacity)
                         ->Field("shininess", &MaterialData::m_shininess)
                         ->Field("noDraw", &MaterialData::m_isNoDraw)
-                        ->Field("uniqueId", &MaterialData::m_uniqueId);
+                        ->Field("uniqueId", &MaterialData::m_uniqueId)
+                        ->Field("useColorMap", &MaterialData::m_useColorMap)
+                        ->Field("baseColor", &MaterialData::m_baseColor)
+                        ->Field("useMetallicMap", &MaterialData::m_useMetallicMap)
+                        ->Field("metallicFactor", &MaterialData::m_metallicFactor)
+                        ->Field("useRoughnessMap", &MaterialData::m_useRoughnessMap)
+                        ->Field("roughnessFactor", &MaterialData::m_roughnessFactor)
+                        ->Field("useEmissiveMap", &MaterialData::m_useEmissiveMap)
+                        ->Field("emissiveIntensity", &MaterialData::m_emissiveIntensity)
+                        ->Field("useAOMap", &MaterialData::m_useAOMap);
 
                     EditContext* editContext = serializeContext->GetEditContext();
                     if (editContext)
@@ -183,7 +282,16 @@ namespace AZ
                             ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_opacity, "Opacity", "Opacity strength of the material, with 0 fully transparent and 1 fully opaque.")
                             ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_shininess, "Shininess", "The shininess strength of the material.")
                             ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_isNoDraw, "No draw", "If enabled the mesh with material will not be drawn.")
-                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_textureMap, "Texture map", "List of assigned texture slots.");
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_textureMap, "Texture map", "List of assigned texture slots.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_useColorMap, "Use Color Map", "True to use a color map, false to ignore it.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_baseColor, "Base Color", "The base color of the material.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_useMetallicMap, "Use Metallic Map", "True to use a metallic map, false to ignore it.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_metallicFactor, "Metallic Factor", "How metallic the material is.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_useRoughnessMap, "Use Roughness Map", "True to use a roughness map, false to ignore it.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_roughnessFactor, "Roughness Factor", "How rough the material is.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_useEmissiveMap, "Use Emissive Map", "True to use an emissive map, false to ignore it.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_emissiveIntensity, "Emissive Intensity", "The intensity of the emissiveness of the material.")
+                            ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialData::m_useAOMap, "Use Ambient Occlusion Map", "True to use an ambient occlusion map, false to ignore it.");
                     }
                 }
             }

Code/Tools/SceneAPI/SceneData/GraphData/MaterialData.h

@@ -47,6 +47,16 @@ namespace AZ
                 SCENE_DATA_API virtual void SetOpacity(float opacity);
                 SCENE_DATA_API virtual void SetShininess(float shininess);
                 SCENE_DATA_API virtual void SetUniqueId(uint64_t uid);
+                SCENE_DATA_API virtual void SetUseColorMap(bool useColorMap);
+                SCENE_DATA_API virtual void SetBaseColor(const AZ::Vector3& baseColor);
+                SCENE_DATA_API virtual void SetUseMetallicMap(bool useMetallicMap);
+                SCENE_DATA_API virtual void SetMetallicFactor(float metallicFactor);
+                SCENE_DATA_API virtual void SetUseRoughnessMap(bool useRoughnessMap);
+                SCENE_DATA_API virtual void SetRoughnessFactor(float roughnessFactor);
+                SCENE_DATA_API virtual void SetUseEmissiveMap(bool useEmissiveMap);
+                SCENE_DATA_API virtual void SetEmissiveIntensity(float emissiveIntensity);
+                SCENE_DATA_API virtual void SetUseAOMap(bool useAOMap);
+                
 
                 SCENE_DATA_API const AZStd::string& GetTexture(TextureMapType mapType) const override;
                 SCENE_DATA_API bool IsNoDraw() const override;
@@ -57,6 +67,15 @@ namespace AZ
                 SCENE_DATA_API float GetOpacity() const override;
                 SCENE_DATA_API float GetShininess() const override;
                 SCENE_DATA_API uint64_t GetUniqueId() const override;
+                SCENE_DATA_API bool GetUseColorMap() const override;
+                SCENE_DATA_API const AZ::Vector3& GetBaseColor() const override;
+                SCENE_DATA_API bool GetUseMetallicMap() const override;
+                SCENE_DATA_API float GetMetallicFactor() const override;
+                SCENE_DATA_API bool GetUseRoughnessMap() const override;
+                SCENE_DATA_API float GetRoughnessFactor() const override;
+                SCENE_DATA_API bool GetUseEmissiveMap() const override;
+                SCENE_DATA_API float GetEmissiveIntensity() const override;
+                SCENE_DATA_API bool GetUseAOMap() const override;
 
                 static void Reflect(ReflectContext* context);
 
@@ -66,8 +85,18 @@ namespace AZ
                 AZ::Vector3 m_diffuseColor;
                 AZ::Vector3 m_specularColor;
                 AZ::Vector3 m_emissiveColor;
+                AZ::Vector3 m_baseColor;
                 float m_opacity;
                 float m_shininess;
+                float m_metallicFactor = 0.0f;
+                float m_roughnessFactor = 0.0f;
+                float m_emissiveIntensity = 0.0f;
+
+                bool m_useColorMap = false;
+                bool m_useMetallicMap = false;
+                bool m_useRoughnessMap = false;
+                bool m_useEmissiveMap = false;
+                bool m_useAOMap = false;
 
                 bool m_isNoDraw;
 

Code/Tools/SceneAPI/SceneData/GraphData/MeshData.cpp

@@ -12,15 +12,65 @@
 
 #include <SceneAPI/SceneData/GraphData/MeshData.h>
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 
 namespace AZ
 {
+    AZ_TYPE_INFO_SPECIALIZE(AZ::SceneAPI::DataTypes::IMeshData::Face, "{F9F49C1A-014F-46F5-A46F-B56D8CB46C2B}");
+
     namespace SceneData
     {
         namespace GraphData
         {
             namespace DataTypes = AZ::SceneAPI::DataTypes;
 
+            void MeshData::Reflect(ReflectContext* context)
+            {
+                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<MeshData>()->Version(1);
+                }
+
+                BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                if (behaviorContext)
+                {
+                    behaviorContext->Class<SceneAPI::DataTypes::IMeshData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetUnitSizeInMeters", &MeshData::GetUnitSizeInMeters)
+                        ->Method("GetOriginalUnitSizeInMeters", &MeshData::GetOriginalUnitSizeInMeters);
+
+                    behaviorContext->Class<MeshData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetSdkMeshIndex", &MeshData::GetSdkMeshIndex)
+                        ->Method("GetControlPointIndex", &MeshData::GetControlPointIndex)
+                        ->Method("GetUsedControlPointCount", &MeshData::GetUsedControlPointCount)
+                        ->Method("GetUsedPointIndexForControlPoint", &MeshData::GetUsedPointIndexForControlPoint)
+                        ->Method("GetVertexCount", &MeshData::GetVertexCount)
+                        ->Method("HasNormalData", &MeshData::HasNormalData)
+                        ->Method("GetPosition", &MeshData::GetPosition)
+                        ->Method("GetNormal", &MeshData::GetNormal)
+                        ->Method("GetFaceCount", &MeshData::GetFaceCount)
+                        ->Method("GetFaceInfo", &MeshData::GetFaceInfo)
+                        ->Method("GetFaceMaterialId", &MeshData::GetFaceMaterialId)
+                        ->Method("GetVertexIndex", &MeshData::GetVertexIndex);
+
+                    behaviorContext->Class<SceneAPI::DataTypes::IMeshData::Face>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetVertexIndex", [](const SceneAPI::DataTypes::IMeshData::Face& self, int index)
+                        {
+                            if (index >= 0 && index < 3)
+                            {
+                                return self.vertexIndex[index];
+                            }
+                            return aznumeric_cast<unsigned int>(0);
+                        });
+                }
+            }
 
             MeshData::~MeshData() = default;
 

Code/Tools/SceneAPI/SceneData/GraphData/MeshData.h

@@ -32,6 +32,8 @@ namespace AZ
             public:
                 AZ_RTTI(MeshData, "{a2589bd4-42fb-40ba-a38d-cfcd6e9ea169}", AZ::SceneAPI::DataTypes::IMeshData)
 
+                static void Reflect(ReflectContext* context);
+
                 SCENE_DATA_API ~MeshData() override;
                 //assumes 1 to 1 mapping for these position, normal, color, uv
                 //positions with more than one normal or uv (seam) will duplicate shared values in multiple verts

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexBitangentData.cpp

@@ -11,6 +11,8 @@
 */
 
 #include <SceneAPI/SceneData/GraphData/MeshVertexBitangentData.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 
 namespace AZ
 {
@@ -18,6 +20,29 @@ namespace AZ
     {
         namespace GraphData
         {
+            void MeshVertexBitangentData::Reflect(ReflectContext* context)
+            {
+                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<MeshVertexBitangentData>()->Version(1);
+                }
+
+                BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                if (behaviorContext)
+                {
+                    behaviorContext->Class<MeshVertexBitangentData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetCount", &MeshVertexBitangentData::GetCount)
+                        ->Method("GetBitangent", &MeshVertexBitangentData::GetBitangent)
+                        ->Method("GetBitangentSetIndex", &MeshVertexBitangentData::GetBitangentSetIndex)
+                        ->Method("GetTangentSpace", &MeshVertexBitangentData::GetTangentSpace)
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::EMotionFX>("EMotionFX")
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::FromFbx>("FromFbx")
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::MikkT>("MikkT");
+                }
+            }
 
             size_t MeshVertexBitangentData::GetCount() const
             {

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexBitangentData.h

@@ -32,6 +32,8 @@ namespace AZ
             public:                
                 AZ_RTTI(MeshVertexBitangentData, "{F56FB088-4C92-4453-AFE9-4E820F03FA90}", AZ::SceneAPI::DataTypes::IMeshVertexBitangentData);
 
+                static void Reflect(ReflectContext* context);
+
                 SCENE_DATA_API ~MeshVertexBitangentData() override = default;
 
                 SCENE_DATA_API size_t GetCount() const override;

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexColorData.cpp

@@ -11,13 +11,45 @@
 */
 
 #include <SceneAPI/SceneData/GraphData/MeshVertexColorData.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 
 namespace AZ
 {
+    AZ_TYPE_INFO_SPECIALIZE(SceneAPI::DataTypes::Color, "{937E3BF8-5204-4D40-A8DA-C8F083C89F9F}");
+
     namespace SceneData
     {
         namespace GraphData
         {
+            void MeshVertexColorData::Reflect(ReflectContext* context)
+            {
+                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<MeshVertexColorData>()->Version(1);
+                }
+
+                BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                if (behaviorContext)
+                {
+                    behaviorContext->Class<MeshVertexColorData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetCustomName", [](const MeshVertexColorData& self) { return self.GetCustomName().GetCStr(); })
+                        ->Method("GetCount", &MeshVertexColorData::GetCount )
+                        ->Method("GetColor", &MeshVertexColorData::GetColor);
+
+                    behaviorContext->Class<AZ::SceneAPI::DataTypes::Color>("MeshVertexColor")
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Property("red", BehaviorValueGetter(&AZ::SceneAPI::DataTypes::Color::red), nullptr)
+                        ->Property("green", BehaviorValueGetter(&AZ::SceneAPI::DataTypes::Color::green), nullptr)
+                        ->Property("blue", BehaviorValueGetter(&AZ::SceneAPI::DataTypes::Color::blue), nullptr)
+                        ->Property("alpha", BehaviorValueGetter(&AZ::SceneAPI::DataTypes::Color::alpha), nullptr);
+                }
+            }
+
             const AZ::Name& MeshVertexColorData::GetCustomName() const
             {
                 return m_customName;

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexColorData.h

@@ -28,6 +28,8 @@ namespace AZ
             public:
                 AZ_RTTI(MeshVertexColorData, "{17477B86-B163-4574-8FB2-4916BC218B3D}", AZ::SceneAPI::DataTypes::IMeshVertexColorData);
 
+                static void Reflect(ReflectContext* context);
+
                 SCENE_DATA_API ~MeshVertexColorData() override = default;
 
                 SCENE_DATA_API const AZ::Name& GetCustomName() const override;

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexTangentData.cpp

@@ -11,6 +11,8 @@
 */
 
 #include <SceneAPI/SceneData/GraphData/MeshVertexTangentData.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 
 namespace AZ
 {
@@ -18,6 +20,29 @@ namespace AZ
     {
         namespace GraphData
         {
+            void MeshVertexTangentData::Reflect(ReflectContext* context)
+            {
+                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<MeshVertexTangentData>()->Version(1);
+                }
+
+                BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                if (behaviorContext)
+                {
+                    behaviorContext->Class<MeshVertexTangentData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetCount", &MeshVertexTangentData::GetCount)
+                        ->Method("GetTangent", &MeshVertexTangentData::GetTangent)
+                        ->Method("GetTangentSetIndex", &MeshVertexTangentData::GetTangentSetIndex)
+                        ->Method("GetTangentSpace", &MeshVertexTangentData::GetTangentSpace)
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::EMotionFX>("EMotionFX")
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::FromFbx>("FromFbx")
+                        ->Enum<(int)SceneAPI::DataTypes::TangentSpace::MikkT>("MikkT");
+                }
+            }
 
             size_t MeshVertexTangentData::GetCount() const
             {

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexTangentData.h

@@ -31,6 +31,8 @@ namespace AZ
             public:                
                 AZ_RTTI(MeshVertexTangentData, "{C16F0F38-8F8F-45A2-A33B-F2758922A7C4}", AZ::SceneAPI::DataTypes::IMeshVertexTangentData);
 
+                static void Reflect(ReflectContext* context);
+
                 SCENE_DATA_API ~MeshVertexTangentData() override = default;
 
                 SCENE_DATA_API size_t GetCount() const override;

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexUVData.cpp

@@ -11,6 +11,8 @@
 */
 
 #include <SceneAPI/SceneData/GraphData/MeshVertexUVData.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
 
 namespace AZ
 {
@@ -18,6 +20,26 @@ namespace AZ
     {
         namespace GraphData
         {
+            void MeshVertexUVData::Reflect(ReflectContext* context)
+            {
+                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
+                if (serializeContext)
+                {
+                    serializeContext->Class<MeshVertexUVData>()->Version(1);
+                }
+
+                BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                if (behaviorContext)
+                {
+                    behaviorContext->Class<MeshVertexUVData>()
+                        ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                        ->Attribute(AZ::Script::Attributes::Module, "scene")
+                        ->Method("GetCustomName",[](const MeshVertexUVData& self) { return self.GetCustomName().GetCStr(); })
+                        ->Method("GetCount", &MeshVertexUVData::GetCount)
+                        ->Method("GetUV", &MeshVertexUVData::GetUV);
+                }
+            }
+
             const AZ::Name& MeshVertexUVData::GetCustomName() const
             {
                 return m_customName;
@@ -49,7 +71,6 @@ namespace AZ
                 m_uvs.push_back(uv);
             }
 
-
             void MeshVertexUVData::GetDebugOutput(AZ::SceneAPI::Utilities::DebugOutput& output) const
             {
                 output.Write("UVs", m_uvs);

Code/Tools/SceneAPI/SceneData/GraphData/MeshVertexUVData.h

@@ -30,6 +30,8 @@ namespace AZ
             public:
                 AZ_RTTI(MeshVertexUVData, "{B435C091-482C-4EB9-B1F4-FA5B480796DA}", AZ::SceneAPI::DataTypes::IMeshVertexUVData);
 
+                static void Reflect(ReflectContext* context);
+
                 SCENE_DATA_API ~MeshVertexUVData() override = default;
 
                 SCENE_DATA_API const AZ::Name& GetCustomName() const override;

Code/Tools/SceneAPI/SceneData/ManifestMetaInfoHandler.cpp

@@ -26,10 +26,11 @@
 #include <SceneAPI/SceneData/Rules/LodRule.h>
 #include <SceneAPI/SceneData/Rules/MaterialRule.h>
 #include <SceneAPI/SceneData/Rules/StaticMeshAdvancedRule.h>
-#include <SceneAPI/SceneData/Rules/OriginRule.h>
 #include <SceneAPI/SceneData/Rules/ScriptProcessorRule.h>
 #include <SceneAPI/SceneData/Rules/SkeletonProxyRule.h>
 #include <SceneAPI/SceneData/Rules/SkinMeshAdvancedRule.h>
+#include <SceneAPI/SceneData/Rules/SkinRule.h>
+#include <SceneAPI/SceneData/Rules/CoordinateSystemRule.h>
 
 namespace AZ
 {
@@ -79,9 +80,13 @@ namespace AZ
                     {
                         modifiers.push_back(SceneData::StaticMeshAdvancedRule::TYPEINFO_Uuid());
                     }
-                    if (existingRules.find(SceneData::OriginRule::TYPEINFO_Uuid()) == existingRules.end())
+                    if (existingRules.find(SceneData::SkinRule::TYPEINFO_Uuid()) == existingRules.end())
                     {
-                        modifiers.push_back(SceneData::OriginRule::TYPEINFO_Uuid());
+                        modifiers.push_back(SceneData::SkinRule::TYPEINFO_Uuid());
+                    }
+                    if (existingRules.find(azrtti_typeid<CoordinateSystemRule>()) == existingRules.end())
+                    {
+                        modifiers.push_back(azrtti_typeid<CoordinateSystemRule>());
                     }
                 }
                 else if (target.RTTI_IsTypeOf(DataTypes::ISkinGroup::TYPEINFO_Uuid()))

Code/Tools/SceneAPI/SceneData/ReflectionRegistrar.cpp

@@ -20,11 +20,11 @@
 #include <SceneAPI/SceneData/Rules/LodRule.h>
 #include <SceneAPI/SceneData/Rules/StaticMeshAdvancedRule.h>
 #include <SceneAPI/SceneData/Rules/SkinMeshAdvancedRule.h>
-#include <SceneAPI/SceneData/Rules/OriginRule.h>
 #include <SceneAPI/SceneData/Rules/MaterialRule.h>
 #include <SceneAPI/SceneData/Rules/ScriptProcessorRule.h>
 #include <SceneAPI/SceneData/Rules/SkeletonProxyRule.h>
 #include <SceneAPI/SceneData/Rules/TangentsRule.h>
+#include <SceneAPI/SceneData/Rules/CoordinateSystemRule.h>
 
 #include <SceneAPI/SceneData/ManifestBase/SceneNodeSelectionList.h>
 
@@ -70,12 +70,12 @@ namespace AZ
             SceneData::CommentRule::Reflect(context);
             SceneData::LodRule::Reflect(context);
             SceneData::StaticMeshAdvancedRule::Reflect(context);
-            SceneData::OriginRule::Reflect(context);
             SceneData::MaterialRule::Reflect(context);
             SceneData::ScriptProcessorRule::Reflect(context);
             SceneData::SkeletonProxyRule::Reflect(context);
             SceneData::SkinMeshAdvancedRule::Reflect(context);
             SceneData::TangentsRule::Reflect(context);
+            SceneData::CoordinateSystemRule::Reflect(context);
 
             // Utility
             SceneData::SceneNodeSelectionList::Reflect(context);
@@ -85,11 +85,11 @@ namespace AZ
             context->Class<AZ::SceneData::GraphData::BlendShapeData>()->Version(1);
             AZ::SceneData::GraphData::BoneData::Reflect(context);
             AZ::SceneData::GraphData::MaterialData::Reflect(context);
-            context->Class<AZ::SceneData::GraphData::MeshData>()->Version(1);
-            context->Class<AZ::SceneData::GraphData::MeshVertexColorData>()->Version(1);
-            context->Class<AZ::SceneData::GraphData::MeshVertexUVData>()->Version(1);
-            context->Class<AZ::SceneData::GraphData::MeshVertexTangentData>()->Version(1);
-            context->Class<AZ::SceneData::GraphData::MeshVertexBitangentData>()->Version(1);
+            AZ::SceneData::GraphData::MeshData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexColorData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexUVData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexTangentData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexBitangentData::Reflect(context);
             AZ::SceneData::GraphData::RootBoneData::Reflect(context);
             context->Class<AZ::SceneData::GraphData::SkinMeshData>()->Version(1);
             context->Class<AZ::SceneData::GraphData::SkinWeightData>()->Version(1);
@@ -102,6 +102,11 @@ namespace AZ
             AZ::SceneData::GraphData::MaterialData::Reflect(context);
             AZ::SceneData::GraphData::RootBoneData::Reflect(context);
             AZ::SceneData::GraphData::TransformData::Reflect(context);
+            AZ::SceneData::GraphData::MeshData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexColorData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexUVData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexTangentData::Reflect(context);
+            AZ::SceneData::GraphData::MeshVertexBitangentData::Reflect(context);
         }
     } // namespace SceneAPI
 } // namespace AZ

Code/Tools/SceneAPI/SceneData/Rules/CoordinateSystemRule.cpp

@@ -0,0 +1,158 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/std/smart_ptr/make_shared.h>
+#include <AzCore/RTTI/ReflectContext.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <SceneAPI/SceneCore/Containers/RuleContainer.h>
+#include <SceneAPI/SceneCore/Utilities/Reporting.h>
+#include <SceneAPI/SceneData/Rules/CoordinateSystemRule.h>
+
+namespace AZ::SceneAPI::SceneData
+{
+    AZ_CLASS_ALLOCATOR_IMPL(CoordinateSystemRule, AZ::SystemAllocator, 0)
+
+    CoordinateSystemRule::CoordinateSystemRule()
+        : m_targetCoordinateSystem(ZUpPositiveYForward)
+    {
+    }
+
+    void CoordinateSystemRule::UpdateCoordinateSystemConverter()
+    {
+        switch (m_targetCoordinateSystem)
+        {
+            case ZUpPositiveYForward:
+            {
+                // Source coordinate system, use identity for now, which will currently just assume LY's coordinate system.
+                const AZ::Vector3 sourceBasisVectors[3] = { AZ::Vector3( 1.0f, 0.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 1.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 0.0f, 1.0f) };
+
+                // The target coordinate system, with X and Y inverted (rotate 180 degrees over Z)
+                const AZ::Vector3 targetBasisVectors[3] = { AZ::Vector3(-1.0f, 0.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f,-1.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 0.0f, 1.0f) };
+
+                // X, Y and Z are all at the same indices inside the target coordinate system, compared to the source coordinate system.
+                const AZ::u32 targetBasisIndices[3] = { 0, 1, 2 };
+
+                m_coordinateSystemConverter = CoordinateSystemConverter::CreateFromBasisVectors(sourceBasisVectors, targetBasisVectors, targetBasisIndices);                                             
+            }
+            break;
+
+            case ZUpNegativeYForward:
+            {
+                // Source coordinate system, use identity for now, which will currently just assume LY's coordinate system.
+                const AZ::Vector3 sourceBasisVectors[3] = { AZ::Vector3( 1.0f, 0.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 1.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 0.0f, 1.0f) };
+
+                // The target coordinate system, which is the same as the source, so basically we won't do anything here.
+                const AZ::Vector3 targetBasisVectors[3] = { AZ::Vector3( 1.0f, 0.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 1.0f, 0.0f), 
+                                                            AZ::Vector3( 0.0f, 0.0f, 1.0f) };
+
+                // X, Y and Z are all at the same indices inside the target coordinate system, compared to the source coordinate system.
+                const AZ::u32 targetBasisIndices[3] = { 0, 1, 2 };
+
+                m_coordinateSystemConverter = CoordinateSystemConverter::CreateFromBasisVectors(sourceBasisVectors, targetBasisVectors, targetBasisIndices);                                             
+            }
+            break;
+
+            default:
+                AZ_Assert(false, "Unsupported coordinate system conversion");
+        };
+    }
+
+    void CoordinateSystemRule::SetTargetCoordinateSystem(CoordinateSystem targetCoordinateSystem)
+    {
+        m_targetCoordinateSystem = targetCoordinateSystem;
+        UpdateCoordinateSystemConverter();
+    }
+
+    CoordinateSystemRule::CoordinateSystem CoordinateSystemRule::GetTargetCoordinateSystem() const
+    {
+        return m_targetCoordinateSystem;
+    }
+
+    void CoordinateSystemRule::Reflect(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
+        if (!serializeContext)
+        {
+            return;
+        }
+
+        serializeContext->Class<CoordinateSystemRule, IRule>()->Version(1)
+            ->Field("targetCoordinateSystem", &CoordinateSystemRule::m_targetCoordinateSystem);
+
+        AZ::EditContext* editContext = serializeContext->GetEditContext();
+        if (editContext)
+        {
+            editContext->Class<CoordinateSystemRule>("Coordinate system change", "Modify the target coordinate system, applying a transformation to all data (transforms and vertex data if it exists).")
+                ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->Attribute(AZ::Edit::Attributes::NameLabelOverride, "")
+                ->DataElement(AZ::Edit::UIHandlers::ComboBox, &CoordinateSystemRule::m_targetCoordinateSystem, "Facing direction", "Change the direction the actor/motion will face by applying a post transformation to the data.")
+                    ->EnumAttribute(CoordinateSystem::ZUpNegativeYForward, "Do nothing")
+                    ->EnumAttribute(CoordinateSystem::ZUpPositiveYForward, "Rotate 180 degrees around the up axis");
+        }
+    }
+
+    bool CoordinateSystemRule::ConvertLegacyCoordinateSystemRule(AZ::SerializeContext& serializeContext,
+        AZ::SerializeContext::DataElementNode& classElement)
+    {
+        AZ::SerializeContext::DataElementNode* ruleContainerNode = classElement.FindSubElement(AZ_CRC("rules", 0x899a993c));
+        if (!ruleContainerNode)
+        {
+            AZ_TracePrintf(AZ::SceneAPI::Utilities::ErrorWindow, "Can't find rule container.\n");
+            return false;
+        }
+
+        AZ::SerializeContext::DataElementNode* rulesNode = ruleContainerNode->FindSubElement(AZ_CRC("rules", 0x899a993c));
+        if (!rulesNode)
+        {
+            AZ_TracePrintf(AZ::SceneAPI::Utilities::ErrorWindow, "Can't find rules within rule container.\n");
+            return false;
+        }
+
+        const AZ::Uuid oldCoordSysRuleId("{603207E2-4F55-4C33-9AAB-98CA75C1E351}");
+        const int numRules = rulesNode->GetNumSubElements();
+        for (int i = 0; i < numRules; ++i)
+        {
+            AZ::SerializeContext::DataElementNode& sharedPointerNode = rulesNode->GetSubElement(i);
+            if (sharedPointerNode.GetNumSubElements() == 1)
+            {
+                AZ::SerializeContext::DataElementNode& currentRuleNode = sharedPointerNode.GetSubElement(0);
+
+                // Convert the coordinate system rule
+                if (currentRuleNode.GetId() == oldCoordSysRuleId)
+                {
+                    int targetCoordinateSystem = 0;
+                    currentRuleNode.FindSubElementAndGetData(AZ_CRC("targetCoordinateSystem"), targetCoordinateSystem);
+
+                    AZStd::shared_ptr<CoordinateSystemRule> coordSysRule = AZStd::make_shared<CoordinateSystemRule>();
+                    coordSysRule->SetTargetCoordinateSystem(static_cast<AZ::SceneAPI::DataTypes::ICoordinateSystemRule::CoordinateSystem>(targetCoordinateSystem));
+
+                    rulesNode->RemoveElement(i);
+                    rulesNode->AddElementWithData<AZStd::shared_ptr<AZ::SceneAPI::DataTypes::IRule>>(serializeContext, "element", coordSysRule);
+
+                    return true;
+                }
+            }
+        }
+
+        return true;
+    }
+} // namespace AZ::SceneAPI::SceneData

Code/Tools/SceneAPI/SceneData/Rules/CoordinateSystemRule.h

@@ -0,0 +1,50 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <SceneAPI/SceneCore/DataTypes/Rules/ICoordinateSystemRule.h>
+#include <SceneAPI/SceneData/SceneDataConfiguration.h>
+
+namespace AZ
+{
+    class ReflectContext;
+}
+
+namespace AZ::SceneAPI::SceneData
+{
+    class SCENE_DATA_CLASS CoordinateSystemRule
+        : public DataTypes::ICoordinateSystemRule
+    {
+    public:
+        AZ_RTTI(CoordinateSystemRule, "{53ECEEEA-C489-46DF-9FDB-05251AD960F4}", AZ::SceneAPI::DataTypes::ICoordinateSystemRule);
+        AZ_CLASS_ALLOCATOR_DECL
+
+        SCENE_DATA_API CoordinateSystemRule();
+        SCENE_DATA_API ~CoordinateSystemRule() override = default;
+
+        SCENE_DATA_API void UpdateCoordinateSystemConverter() override;
+
+        SCENE_DATA_API void SetTargetCoordinateSystem(CoordinateSystem targetCoordinateSystem) override;
+        SCENE_DATA_API CoordinateSystem GetTargetCoordinateSystem() const override;
+
+        SCENE_DATA_API const CoordinateSystemConverter& GetCoordinateSystemConverter() const override { return m_coordinateSystemConverter; }
+
+        static void Reflect(AZ::ReflectContext* context);
+        SCENE_DATA_API static bool ConvertLegacyCoordinateSystemRule(AZ::SerializeContext& serializeContext,
+            AZ::SerializeContext::DataElementNode& classElement);
+
+    protected:
+        CoordinateSystemConverter   m_coordinateSystemConverter;
+        CoordinateSystem            m_targetCoordinateSystem;
+    };
+} // namespace AZ::SceneAPI::SceneData

Code/Tools/SceneAPI/SceneData/Rules/OriginRule.cpp

@@ -1,119 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include <AzCore/RTTI/ReflectContext.h>
-#include <AzCore/Memory/SystemAllocator.h>
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Serialization/EditContext.h>
-#include <SceneAPI/SceneData/Rules/OriginRule.h>
-
-namespace AZ
-{
-    namespace SceneAPI
-    {
-        namespace SceneData
-        {
-            const AZStd::string OriginRule::c_defaultWorldUIString = "World";
-
-            AZ_CLASS_ALLOCATOR_IMPL(OriginRule, SystemAllocator, 0)
-
-            OriginRule::OriginRule()
-                : m_rotation(Quaternion::CreateIdentity())
-                , m_translation(Vector3::CreateZero())
-                , m_scale(1.0f)
-            {
-            }
-
-            const AZStd::string& OriginRule::GetOriginNodeName() const
-            {
-                return m_originNodeName;
-            }
-
-            bool OriginRule::UseRootAsOrigin() const
-            {
-                return m_originNodeName == c_defaultWorldUIString;
-            }
-
-            const Quaternion& OriginRule::GetRotation() const
-            {
-                return m_rotation;
-            }
-
-            const Vector3& OriginRule::GetTranslation() const
-            {
-                return m_translation;
-            }
-
-            float OriginRule::GetScale() const
-            {
-                return m_scale;
-            }
-
-            void  OriginRule::SetOriginNodeName(const AZStd::string& originNodeName)
-            {
-                m_originNodeName = originNodeName;
-            }
-
-            void  OriginRule::SetRotation(const Quaternion& rotation)
-            {
-                m_rotation = rotation;
-            }
-
-            void  OriginRule::SetTranslation(const Vector3& translation)
-            {
-                m_translation = translation;
-            }
-
-            void  OriginRule::SetScale(float scale)
-            {
-                m_scale = scale;
-            }
-
-            void OriginRule::Reflect(ReflectContext* context)
-            {
-                SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
-                if (!serializeContext)
-                {
-                    return;
-                }
-                
-                serializeContext->Class<OriginRule, DataTypes::IOriginRule>()->Version(1)
-                    ->Field("originNodeName", &OriginRule::m_originNodeName)
-                    ->Field("translation", &OriginRule::m_translation)
-                    ->Field("rotation", &OriginRule::m_rotation)
-                    ->Field("scale", &OriginRule::m_scale);
-
-                EditContext* editContext = serializeContext->GetEditContext();
-                if (editContext)
-                {
-                    editContext->Class<OriginRule>("Origin", "Configure where the mesh will load relative to world origin.")
-                        ->ClassElement(Edit::ClassElements::EditorData, "")
-                            ->Attribute("AutoExpand", true)
-                            ->Attribute(AZ::Edit::Attributes::NameLabelOverride, "")
-                        ->DataElement("NodeListSelection", &OriginRule::m_originNodeName, "Relative Origin Node",
-                            "Select a Node from the scene as the origin for this export. 'World' will export from the Root Scene Node.")
-                            ->Attribute("DisabledOption", c_defaultWorldUIString)
-                            ->Attribute("DefaultToDisabled", true)
-                            ->Attribute("ExcludeEndPoints", true)
-                        ->DataElement(Edit::UIHandlers::Default, &OriginRule::m_translation, "Translation", "Moves the group along the given vector.")
-                        ->DataElement(Edit::UIHandlers::Default, &OriginRule::m_rotation, "Rotation", "Rotates the group after translation.")
-                            ->Attribute(Edit::Attributes::LabelForX, "P")
-                            ->Attribute(Edit::Attributes::LabelForY, "R")
-                            ->Attribute(Edit::Attributes::LabelForZ, "Y")
-                        ->DataElement(Edit::UIHandlers::Default, &OriginRule::m_scale, "Scale", "Scales the group up or down after translation and rotation.")
-                            ->Attribute(Edit::Attributes::Min, 0.0001)
-                            ->Attribute(Edit::Attributes::Max, 1000.0);
-                }
-            }
-        } // SceneData
-    } // SceneAPI
-} // AZ

Code/Tools/SceneAPI/SceneData/Rules/OriginRule.h

@@ -1,66 +0,0 @@
-#pragma once
-
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include <AzCore/Memory/Memory.h>
-#include <AzCore/Math/Vector3.h>
-#include <AzCore/Math/Quaternion.h>
-#include <AzCore/std/string/string.h>
-#include <SceneAPI/SceneCore/DataTypes/Rules/IOriginRule.h>
-
-namespace AZ
-{
-    class ReflectContext;
-
-    namespace SceneAPI
-    {
-        namespace Containers
-        {
-            class Scene;
-        }
-        namespace SceneData
-        {
-            class OriginRule
-                : public DataTypes::IOriginRule
-            {
-            public:
-                AZ_RTTI(OriginRule, "{90AECE4A-58D4-411C-9CDE-59B54C59354E}", DataTypes::IOriginRule);
-                AZ_CLASS_ALLOCATOR_DECL
-
-                OriginRule();
-                ~OriginRule() override = default;
-
-                const AZStd::string& GetOriginNodeName() const override;
-                bool UseRootAsOrigin() const override;
-                const Quaternion& GetRotation() const override;
-                const Vector3& GetTranslation() const override;
-                float GetScale() const override;
-
-                void SetOriginNodeName(const AZStd::string& originNodeName);
-                void SetRotation(const Quaternion& rotation);
-                void SetTranslation(const Vector3& translation);
-                void SetScale(float scale);
-
-                static void Reflect(ReflectContext* context);
-                
-                static const AZStd::string c_defaultWorldUIString;
-
-            protected:
-                AZStd::string m_originNodeName;
-                Quaternion m_rotation;
-                Vector3 m_translation;
-                float m_scale;
-            };
-        } // SceneData
-    } // SceneAPI
-} // AZ

Code/Tools/SceneAPI/SceneData/Rules/SkinRule.cpp

@@ -0,0 +1,76 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/RTTI/ReflectContext.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <SceneAPI/SceneData/Rules/SkinRule.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace SceneData
+        {
+            AZ_CLASS_ALLOCATOR_IMPL(SkinRule, AZ::SystemAllocator, 0)
+
+            SkinRule::SkinRule()
+                : m_maxWeightsPerVertex(4)
+                , m_weightThreshold(0.001f)
+            {
+            }
+            AZ::u32 SkinRule::GetMaxWeightsPerVertex() const
+            {
+                return m_maxWeightsPerVertex;
+            }
+
+            float SkinRule::GetWeightThreshold() const
+            {
+                return m_weightThreshold;
+            }
+
+            void SkinRule::Reflect(AZ::ReflectContext* context)
+            {
+                AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
+                if (!serializeContext)
+                {
+                    return;
+                }
+
+                serializeContext->Class<ISkinRule, AZ::SceneAPI::DataTypes::IRule>()->Version(1);
+
+                serializeContext->Class<SkinRule, ISkinRule>()->Version(2)
+                    ->Field("maxWeightsPerVertex", &SkinRule::m_maxWeightsPerVertex)
+                    ->Field("weightThreshold", &SkinRule::m_weightThreshold);
+
+                AZ::EditContext* editContext = serializeContext->GetEditContext();
+                if (editContext)
+                {
+                    editContext->Class<SkinRule>("Skin", "")
+                        ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                        ->Attribute("AutoExpand", true)
+                        ->Attribute(AZ::Edit::Attributes::NameLabelOverride, "")
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &SkinRule::m_maxWeightsPerVertex, "Max weights per vertex", "The maximum number of joints that can influence a single vertex.")
+                        ->Attribute(AZ::Edit::Attributes::Min, 1)
+                        ->Attribute(AZ::Edit::Attributes::Max, 32)
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &SkinRule::m_weightThreshold, "Weight threshold", "Weight value less than this will be ignored during import.")
+                        ->Attribute(AZ::Edit::Attributes::Min, 0.0f)
+                        ->Attribute(AZ::Edit::Attributes::Max, 0.01f)
+                        ->Attribute(AZ::Edit::Attributes::Step, 0.0001f)
+                        ->Attribute(AZ::Edit::Attributes::Decimals, 6)
+                        ->Attribute(AZ::Edit::Attributes::DisplayDecimals, 6);
+                }
+            }
+        } // Rule
+    } // Pipeline
+} // EMotionFX

Code/Tools/SceneAPI/SceneData/Rules/SkinRule.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/Memory/Memory.h>
+#include <SceneAPI/SceneCore/DataTypes/Rules/ISkinRule.h>
+
+namespace AZ
+{
+    class ReflectContext;
+
+    namespace SceneAPI
+    {
+        namespace SceneData
+        {
+            class SkinRule
+                : public DataTypes::ISkinRule
+            {
+            public:
+                AZ_RTTI(SkinRule, "{B26E7FC9-86A1-4711-8415-8BE4861C08BA}", ISkinRule);
+                AZ_CLASS_ALLOCATOR_DECL
+
+                SkinRule();
+                ~SkinRule() override = default;
+
+                AZ::u32 GetMaxWeightsPerVertex() const override;
+                float GetWeightThreshold() const override;
+
+                static void Reflect(AZ::ReflectContext* context);
+
+            protected:
+                AZ::u32 m_maxWeightsPerVertex;
+                float m_weightThreshold;
+            };
+        }
+    }
+}

Code/Tools/SceneAPI/SceneData/SceneData_files.cmake

@@ -36,6 +36,8 @@ set(FILES
     Behaviors/LodRuleBehavior.cpp
     Behaviors/BlendShapeRuleBehavior.h
     Behaviors/BlendShapeRuleBehavior.cpp
+    Behaviors/SkinRuleBehavior.h
+    Behaviors/SkinRuleBehavior.cpp
     Behaviors/ScriptProcessorRuleBehavior.h
     Behaviors/ScriptProcessorRuleBehavior.cpp
     Groups/MeshGroup.h
@@ -54,10 +56,10 @@ set(FILES
     Rules/CommentRule.cpp
     Rules/LodRule.h
     Rules/LodRule.cpp
+    Rules/CoordinateSystemRule.h
+    Rules/CoordinateSystemRule.cpp
     Rules/StaticMeshAdvancedRule.h
     Rules/StaticMeshAdvancedRule.cpp
-    Rules/OriginRule.h
-    Rules/OriginRule.cpp
     Rules/MaterialRule.h
     Rules/MaterialRule.cpp
     Rules/ScriptProcessorRule.h
@@ -66,6 +68,8 @@ set(FILES
     Rules/SkeletonProxyRule.cpp
     Rules/SkinMeshAdvancedRule.h
     Rules/SkinMeshAdvancedRule.cpp
+    Rules/SkinRule.h
+    Rules/SkinRule.cpp
     Rules/TangentsRule.h
     Rules/TangentsRule.cpp
     GraphData/MeshData.h

Code/Tools/SceneAPI/SceneData/SceneData_testing_files.cmake

@@ -13,4 +13,5 @@ set(FILES
     Tests/TestsMain.cpp
     Tests/GraphData/MeshDataTests.cpp
     Tests/GraphData/MeshDataPrimitiveUtilsTests.cpp
+    Tests/GraphData/GraphDataBehaviorTests.cpp
 )

Code/Tools/SceneAPI/SceneData/Tests/GraphData/GraphDataBehaviorTests.cpp

@@ -0,0 +1,301 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include <AzCore/Component/ComponentApplication.h>
+#include <AzCore/Math/MathReflection.h>
+#include <AzCore/Name/NameDictionary.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/RTTI/ReflectionManager.h>
+#include <AzCore/Serialization/Json/RegistrationContext.h>
+#include <AzCore/std/smart_ptr/make_shared.h>
+#include <AzCore/std/smart_ptr/shared_ptr.h>
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzTest/AzTest.h>
+
+#include <SceneAPI/SceneCore/DataTypes/IGraphObject.h>
+#include <SceneAPI/SceneCore/DataTypes/GraphData/IMeshData.h>
+#include <SceneAPI/SceneData/ReflectionRegistrar.h>
+#include <SceneAPI/SceneData/GraphData/MeshData.h>
+#include <SceneAPI/SceneData/GraphData/MeshVertexBitangentData.h>
+#include <SceneAPI/SceneData/GraphData/MeshVertexColorData.h>
+#include <SceneAPI/SceneData/GraphData/MeshVertexTangentData.h>
+#include <SceneAPI/SceneData/GraphData/MeshVertexUVData.h>
+
+namespace AZ
+{
+    namespace SceneAPI
+    {
+        namespace Containers
+        {
+            struct MockGraphData final
+            {
+                AZ_TYPE_INFO(MockGraphData, "{06996B36-E204-4ECC-9F3C-3D644B8CAE07}");
+
+                MockGraphData() = default;
+                ~MockGraphData() = default;
+
+                static bool FillData(AZStd::any& data)
+                {
+                    if (data.get_type_info().m_id == azrtti_typeid<AZ::SceneData::GraphData::MeshData>())
+                    {
+                        auto* meshData = AZStd::any_cast<AZ::SceneData::GraphData::MeshData>(&data);
+                        meshData->AddPosition(Vector3{1.0f, 1.1f, 2.2f});
+                        meshData->AddPosition(Vector3{2.0f, 2.1f, 3.2f});
+                        meshData->AddPosition(Vector3{3.0f, 3.1f, 4.2f});
+                        meshData->AddPosition(Vector3{4.0f, 4.1f, 5.2f});
+                        meshData->AddNormal(Vector3{0.1f, 0.2f, 0.3f});
+                        meshData->AddNormal(Vector3{0.4f, 0.5f, 0.6f});
+                        meshData->SetOriginalUnitSizeInMeters(10.0f);
+                        meshData->SetSdkMeshIndex(1337);
+                        meshData->SetUnitSizeInMeters(0.5f);
+                        meshData->SetVertexIndexToControlPointIndexMap(0, 10);
+                        meshData->SetVertexIndexToControlPointIndexMap(1, 11);
+                        meshData->SetVertexIndexToControlPointIndexMap(2, 12);
+                        meshData->SetVertexIndexToControlPointIndexMap(3, 13);
+                        meshData->AddFace({0, 1, 2}, 1);
+                        meshData->AddFace({3, 4, 5}, 2);
+                        meshData->AddFace({6, 7, 8}, 3);
+                        return true;
+                    }
+                    else if (data.get_type_info().m_id == azrtti_typeid<AZ::SceneData::GraphData::MeshVertexColorData>())
+                    {
+                        auto* colorData = AZStd::any_cast<AZ::SceneData::GraphData::MeshVertexColorData>(&data);
+                        colorData->SetCustomName("mesh_vertex_color_data");
+                        colorData->AppendColor(AZ::SceneAPI::DataTypes::Color{0.1f, 0.2f, 0.3f, 0.4f});
+                        colorData->AppendColor(AZ::SceneAPI::DataTypes::Color{0.5f, 0.6f, 0.7f, 0.8f});
+                        return true;
+                    }
+                    else if (data.get_type_info().m_id == azrtti_typeid<AZ::SceneData::GraphData::MeshVertexUVData>())
+                    {
+                        auto* uvData = AZStd::any_cast<AZ::SceneData::GraphData::MeshVertexUVData>(&data);
+                        uvData->SetCustomName("mesh_vertex_uv_data");
+                        uvData->AppendUV(AZ::Vector2{0.1f, 0.2f});
+                        uvData->AppendUV(AZ::Vector2{0.3f, 0.4f});
+                        return true;
+                    }
+                    else if (data.get_type_info().m_id == azrtti_typeid<AZ::SceneData::GraphData::MeshVertexBitangentData>())
+                    {
+                        auto* bitangentData = AZStd::any_cast<AZ::SceneData::GraphData::MeshVertexBitangentData>(&data);
+                        bitangentData->AppendBitangent(AZ::Vector3{0.12f, 0.34f, 0.56f});
+                        bitangentData->AppendBitangent(AZ::Vector3{0.77f, 0.88f, 0.99f});
+                        bitangentData->SetTangentSpace(AZ::SceneAPI::DataTypes::TangentSpace::FromFbx);
+                        bitangentData->SetBitangentSetIndex(1);
+                        return true;
+                    }
+                    else if (data.get_type_info().m_id == azrtti_typeid<AZ::SceneData::GraphData::MeshVertexTangentData>())
+                    {
+                        auto* tangentData = AZStd::any_cast<AZ::SceneData::GraphData::MeshVertexTangentData>(&data);
+                        tangentData->AppendTangent(AZ::Vector4{0.12f, 0.34f, 0.56f, 0.78f});
+                        tangentData->AppendTangent(AZ::Vector4{0.18f, 0.28f, 0.19f, 0.29f});
+                        tangentData->AppendTangent(AZ::Vector4{0.21f, 0.43f, 0.65f, 0.87f});
+                        tangentData->SetTangentSpace(AZ::SceneAPI::DataTypes::TangentSpace::EMotionFX);
+                        tangentData->SetTangentSetIndex(2);
+                        return true;
+                    }
+                    return false;
+                }
+
+                static void Reflect(ReflectContext* context)
+                {
+                    BehaviorContext* behaviorContext = azrtti_cast<BehaviorContext*>(context);
+                    if (behaviorContext)
+                    {
+                        behaviorContext->Class<MockGraphData>()
+                            ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                            ->Attribute(AZ::Script::Attributes::Module, "scene")
+                            ->Method("FillData", &MockGraphData::FillData);
+                    }
+                }
+            };
+
+            class GrapDatahBehaviorScriptTest
+                : public UnitTest::AllocatorsFixture
+            {
+            public:
+                AZStd::unique_ptr<AZ::ScriptContext> m_scriptContext;
+                AZStd::unique_ptr<AZ::BehaviorContext> m_behaviorContext;
+                AZStd::unique_ptr<AZ::SerializeContext> m_serializeContext;
+
+                static void TestExpectTrue(bool value)
+                {
+                    EXPECT_TRUE(value);
+                }
+
+                static void TestExpectIntegerEquals(AZ::s64 lhs, AZ::s64 rhs)
+                {
+                    EXPECT_EQ(lhs, rhs);
+                }
+
+                static void TestExpectFloatEquals(float lhs, float rhs)
+                {
+                    EXPECT_EQ(lhs, rhs);
+                }
+
+                void SetUp() override
+                {
+                    UnitTest::AllocatorsFixture::SetUp();
+                    AZ::NameDictionary::Create();
+
+                    m_serializeContext = AZStd::make_unique<AZ::SerializeContext>();
+                    AZ::SceneAPI::RegisterDataTypeReflection(m_serializeContext.get());
+
+                    m_behaviorContext = AZStd::make_unique<AZ::BehaviorContext>();
+                    m_behaviorContext->Method("TestExpectTrue", &TestExpectTrue);
+                    m_behaviorContext->Method("TestExpectIntegerEquals", &TestExpectIntegerEquals);
+                    m_behaviorContext->Method("TestExpectFloatEquals", &TestExpectFloatEquals);
+                    MockGraphData::Reflect(m_behaviorContext.get());
+                    AZ::MathReflect(m_behaviorContext.get());
+                    AZ::SceneAPI::RegisterDataTypeBehaviorReflection(m_behaviorContext.get());
+
+                    m_scriptContext = AZStd::make_unique<AZ::ScriptContext>();
+                    m_scriptContext->BindTo(m_behaviorContext.get());
+                }
+
+                void TearDown() override
+                {
+                    m_scriptContext.reset();
+                    m_serializeContext.reset();
+                    m_behaviorContext.reset();
+
+                    AZ::NameDictionary::Destroy();
+                    UnitTest::AllocatorsFixture::TearDown();
+                }
+
+                void ExpectExecute(AZStd::string_view script)
+                {
+                    EXPECT_TRUE(m_scriptContext->Execute(script.data()));
+                }
+            };
+
+            TEST_F(GrapDatahBehaviorScriptTest, SceneGraph_MeshData_AccessWorks)
+            {
+                ExpectExecute("meshData = MeshData()");
+                ExpectExecute("TestExpectTrue(meshData ~= nil)");
+                ExpectExecute("MockGraphData.FillData(meshData)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexCount(), 4)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(0).x, 1.0)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(0).y, 1.1)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(0).z, 2.2)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(1).x, 2.0)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(1).y, 2.1)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(1).z, 3.2)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(2).x, 3.0)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(2).y, 3.1)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(2).z, 4.2)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(3).x, 4.0)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(3).y, 4.1)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetPosition(3).z, 5.2)");
+                ExpectExecute("TestExpectTrue(meshData:HasNormalData())");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(0).x, 0.1)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(0).y, 0.2)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(0).z, 0.3)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(1).x, 0.4)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(1).y, 0.5)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetNormal(1).z, 0.6)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetOriginalUnitSizeInMeters(), 10.0)");
+                ExpectExecute("TestExpectFloatEquals(meshData:GetUnitSizeInMeters(), 0.5)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetSdkMeshIndex(), 1337)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedControlPointCount(), 4)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetControlPointIndex(0), 10)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetControlPointIndex(1), 11)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetControlPointIndex(2), 12)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetControlPointIndex(3), 13)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedPointIndexForControlPoint(10), 0)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedPointIndexForControlPoint(11), 1)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedPointIndexForControlPoint(12), 2)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedPointIndexForControlPoint(13), 3)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetUsedPointIndexForControlPoint(0), -1)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceCount(), 3)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(0, 0), 0)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(0, 1), 1)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(0, 2), 2)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(2, 0), 6)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(2, 1), 7)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetVertexIndex(2, 2), 8)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceMaterialId(2), 3)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceMaterialId(1), 2)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceMaterialId(0), 1)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceInfo(0):GetVertexIndex(0), 0)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceInfo(0):GetVertexIndex(1), 1)");
+                ExpectExecute("TestExpectIntegerEquals(meshData:GetFaceInfo(0):GetVertexIndex(2), 2)");
+            }
+
+            TEST_F(GrapDatahBehaviorScriptTest, SceneGraph_MeshVertexColorData_AccessWorks)
+            {
+                ExpectExecute("meshVertexColorData = MeshVertexColorData()");
+                ExpectExecute("TestExpectTrue(meshVertexColorData ~= nil)");
+                ExpectExecute("MockGraphData.FillData(meshVertexColorData)");
+                ExpectExecute("TestExpectTrue(meshVertexColorData:GetCustomName() == 'mesh_vertex_color_data')");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexColorData:GetCount(), 2)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexColorData:GetColor(0).red, 0.1)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexColorData:GetColor(0).green, 0.2)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexColorData:GetColor(0).blue, 0.3)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexColorData:GetColor(0).alpha, 0.4)");
+                ExpectExecute("colorOne = meshVertexColorData:GetColor(1)");
+                ExpectExecute("TestExpectFloatEquals(colorOne.red, 0.5)");
+                ExpectExecute("TestExpectFloatEquals(colorOne.green, 0.6)");
+                ExpectExecute("TestExpectFloatEquals(colorOne.blue, 0.7)");
+                ExpectExecute("TestExpectFloatEquals(colorOne.alpha, 0.8)");
+            }
+
+            TEST_F(GrapDatahBehaviorScriptTest, SceneGraph_MeshVertexUVData_AccessWorks)
+            {
+                ExpectExecute("meshVertexUVData = MeshVertexUVData()");
+                ExpectExecute("TestExpectTrue(meshVertexUVData ~= nil)");
+                ExpectExecute("MockGraphData.FillData(meshVertexUVData)");
+                ExpectExecute("TestExpectTrue(meshVertexUVData:GetCustomName() == 'mesh_vertex_uv_data')");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexUVData:GetCount(), 2)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexUVData:GetUV(0).x, 0.1)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexUVData:GetUV(0).y, 0.2)");
+                ExpectExecute("uvOne = meshVertexUVData:GetUV(1)");
+                ExpectExecute("TestExpectFloatEquals(uvOne.x, 0.3)");
+                ExpectExecute("TestExpectFloatEquals(uvOne.y, 0.4)");
+            }
+
+            TEST_F(GrapDatahBehaviorScriptTest, SceneGraph_MeshVertexBitangentData_AccessWorks)
+            {
+                ExpectExecute("meshVertexBitangentData = MeshVertexBitangentData()");
+                ExpectExecute("TestExpectTrue(meshVertexBitangentData ~= nil)");
+                ExpectExecute("MockGraphData.FillData(meshVertexBitangentData)");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexBitangentData:GetCount(), 2)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexBitangentData:GetBitangent(0).x, 0.12)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexBitangentData:GetBitangent(0).y, 0.34)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexBitangentData:GetBitangent(0).z, 0.56)");
+                ExpectExecute("bitangentData = meshVertexBitangentData:GetBitangent(1)");
+                ExpectExecute("TestExpectFloatEquals(bitangentData.x, 0.77)");
+                ExpectExecute("TestExpectFloatEquals(bitangentData.y, 0.88)");
+                ExpectExecute("TestExpectFloatEquals(bitangentData.z, 0.99)");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexBitangentData:GetBitangentSetIndex(), 1)");
+                ExpectExecute("TestExpectTrue(meshVertexBitangentData:GetTangentSpace(), MeshVertexBitangentData.FromFbx)");
+            }
+
+            TEST_F(GrapDatahBehaviorScriptTest, SceneGraph_MeshVertexTangentData_AccessWorks)
+            {
+                ExpectExecute("meshVertexTangentData = MeshVertexTangentData()");
+                ExpectExecute("TestExpectTrue(meshVertexTangentData ~= nil)");
+                ExpectExecute("MockGraphData.FillData(meshVertexTangentData)");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexTangentData:GetCount(), 3)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexTangentData:GetTangent(0).x, 0.12)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexTangentData:GetTangent(0).y, 0.34)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexTangentData:GetTangent(0).z, 0.56)");
+                ExpectExecute("TestExpectFloatEquals(meshVertexTangentData:GetTangent(0).w, 0.78)");
+                ExpectExecute("tangentData = meshVertexTangentData:GetTangent(1)");
+                ExpectExecute("TestExpectFloatEquals(tangentData.x, 0.18)");
+                ExpectExecute("TestExpectFloatEquals(tangentData.y, 0.28)");
+                ExpectExecute("TestExpectFloatEquals(tangentData.z, 0.19)");
+                ExpectExecute("TestExpectFloatEquals(tangentData.w, 0.29)");
+                ExpectExecute("TestExpectIntegerEquals(meshVertexTangentData:GetTangentSetIndex(), 2)");
+                ExpectExecute("TestExpectTrue(meshVertexTangentData:GetTangentSpace(), MeshVertexTangentData.EMotionFX)");
+            }
+        }
+    }
+}