Integrating latest 47acbe8

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;