Merge pull request #69 from aws-lumberyard-dev/non-uniform-scale-mesh

support for non-uniform scale component with atom mesh component

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Mesh/EditorMeshComponent.cpp

@@ -137,9 +137,12 @@ namespace AZ
             AZ::Transform transform = AZ::Transform::CreateIdentity();
             AZ::TransformBus::EventResult(transform, GetEntityId(), &AZ::TransformBus::Events::GetWorldTM);
 
+            AZ::Vector3 nonUniformScale = AZ::Vector3::CreateOne();
+            AZ::NonUniformScaleRequestBus::EventResult(nonUniformScale, GetEntityId(), &AZ::NonUniformScaleRequests::GetScale);
+
             AZ::Vector3 ignoreNormal;
 
-            return m_controller.GetModel()->RayIntersection(transform, src, dir, distance, ignoreNormal);
+            return m_controller.GetModel()->RayIntersection(transform, nonUniformScale, src, dir, distance, ignoreNormal);
         }
 
         bool EditorMeshComponent::SupportsEditorRayIntersect()

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Mesh/MeshComponentController.cpp

@@ -188,6 +188,11 @@ namespace AZ
             m_meshFeatureProcessor = RPI::Scene::GetFeatureProcessorForEntity<MeshFeatureProcessorInterface>(m_entityId);
             AZ_Error("MeshComponentController", m_meshFeatureProcessor, "Unable to find a MeshFeatureProcessorInterface on the entityId.");
 
+            m_cachedNonUniformScale = AZ::Vector3::CreateOne();
+            AZ::NonUniformScaleRequestBus::EventResult(m_cachedNonUniformScale, m_entityId, &AZ::NonUniformScaleRequests::GetScale);
+            AZ::NonUniformScaleRequestBus::Event(m_entityId, &AZ::NonUniformScaleRequests::RegisterScaleChangedEvent,
+                m_nonUniformScaleChangedHandler);
+
             MeshComponentRequestBus::Handler::BusConnect(m_entityId);
             TransformNotificationBus::Handler::BusConnect(m_entityId);
             MaterialReceiverRequestBus::Handler::BusConnect(m_entityId);
@@ -209,6 +214,8 @@ namespace AZ
             MaterialReceiverRequestBus::Handler::BusDisconnect();
             MaterialComponentNotificationBus::Handler::BusDisconnect();
 
+            m_nonUniformScaleChangedHandler.Disconnect();
+
             m_meshFeatureProcessor = nullptr;
             m_transformInterface = nullptr;
             m_entityId = AZ::EntityId(AZ::EntityId::InvalidEntityId);
@@ -229,7 +236,16 @@ namespace AZ
         {
             if (m_meshFeatureProcessor)
             {
-                m_meshFeatureProcessor->SetTransform(m_meshHandle, world);
+                m_meshFeatureProcessor->SetTransform(m_meshHandle, world, m_cachedNonUniformScale);
+            }
+        }
+
+        void MeshComponentController::HandleNonUniformScaleChange(const AZ::Vector3& nonUniformScale)
+        {
+            m_cachedNonUniformScale = nonUniformScale;
+            if (m_meshFeatureProcessor)
+            {
+                m_meshFeatureProcessor->SetTransform(m_meshHandle, m_transformInterface->GetWorldTM(), m_cachedNonUniformScale);
             }
         }
 
@@ -275,8 +291,9 @@ namespace AZ
                 m_meshHandle = m_meshFeatureProcessor->AcquireMesh(m_configuration.m_modelAsset, materials);
                 m_meshFeatureProcessor->ConnectModelChangeEventHandler(m_meshHandle, m_changeEventHandler);
 
-                const AZ::Transform& transform = m_transformInterface ? m_transformInterface->GetWorldTM() : Transform::Identity();
-                m_meshFeatureProcessor->SetTransform(m_meshHandle, transform);
+                const AZ::Transform& transform = m_transformInterface ? m_transformInterface->GetWorldTM() : AZ::Transform::CreateIdentity();
+
+                m_meshFeatureProcessor->SetTransform(m_meshHandle, transform, m_cachedNonUniformScale);
                 m_meshFeatureProcessor->SetSortKey(m_meshHandle, m_configuration.m_sortKey);
                 m_meshFeatureProcessor->SetLodOverride(m_meshHandle, m_configuration.m_lodOverride);
                 m_meshFeatureProcessor->SetExcludeFromReflectionCubeMaps(m_meshHandle, m_configuration.m_excludeFromReflectionCubeMaps);
@@ -413,7 +430,16 @@ namespace AZ
         Aabb MeshComponentController::GetLocalBounds()
         {
             const Data::Instance<RPI::Model> model = GetModel();
-            return model ? model->GetAabb() : Aabb::CreateNull();
+            if (model)
+            {
+                Aabb aabb = model->GetAabb();
+                aabb.MultiplyByScale(m_cachedNonUniformScale);
+                return aabb;
+            }
+            else
+            {
+                return Aabb::CreateNull();
+            }
         }
     } // namespace Render
 } // namespace AZ

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Mesh/MeshComponentController.h

@@ -14,6 +14,7 @@
 
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/TransformBus.h>
+#include <AzCore/Component/NonUniformScaleBus.h>
 
 #include <AtomCore/Instance/InstanceDatabase.h>
 
@@ -122,17 +123,25 @@ namespace AZ
             void UnregisterModel();
             void RefreshModelRegistration();
 
+            void HandleNonUniformScaleChange(const AZ::Vector3& nonUniformScale);
+
             Render::MeshFeatureProcessorInterface* m_meshFeatureProcessor = nullptr;
             Render::MeshFeatureProcessorInterface::MeshHandle m_meshHandle;
             TransformInterface* m_transformInterface = nullptr;
             AZ::EntityId m_entityId;
             bool m_isVisible = true;
             MeshComponentConfig m_configuration;
+            AZ::Vector3 m_cachedNonUniformScale = AZ::Vector3::CreateOne();
 
             MeshFeatureProcessorInterface::ModelChangedEvent::Handler m_changeEventHandler
             {
                 [&](Data::Instance<RPI::Model> model) { HandleModelChange(model); }
             };
+
+            AZ::NonUniformScaleChangedEvent::Handler m_nonUniformScaleChangedHandler
+            {
+                [&](const AZ::Vector3& nonUniformScale) { HandleNonUniformScaleChange(nonUniformScale); }
+            };
         };
 
     } // namespace Render