Fix AssImpTransformImporter logic for bone nodes

For bone nodes, the Transform is computed by multiplying the parent offsetMatrix by the inverse of the node's offsetMatrix

Note that this currently disables the LimitBoneWeights option since that results in the removal of bone nodes that are not attached to a mesh.
Without the bones there is no way to retrieve the offsetMatrix, so the Transform cannot be computed correctly

Fixes LYN-3755

Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpTransformImporter.cpp

@@ -46,22 +46,69 @@ namespace AZ
                     serializeContext->Class<AssImpTransformImporter, SceneCore::LoadingComponent>()->Version(1);
                 }
             }
-            
+
+            void GetAllBones(const aiScene* scene, AZStd::unordered_map<AZStd::string, const aiBone*>& boneLookup)
+            {
+                for (unsigned meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex)
+                {
+                    const aiMesh* mesh = scene->mMeshes[meshIndex];
+
+                    for (unsigned boneIndex = 0; boneIndex < mesh->mNumBones; ++boneIndex)
+                    {
+                        const aiBone* bone = mesh->mBones[boneIndex];
+
+                        boneLookup[bone->mName.C_Str()] = bone;
+                    }
+                }
+            }
+
             Events::ProcessingResult AssImpTransformImporter::ImportTransform(AssImpSceneNodeAppendedContext& context)
             {
                 AZ_TraceContext("Importer", "transform");
                 const aiNode* currentNode = context.m_sourceNode.GetAssImpNode();
                 const aiScene* scene = context.m_sourceScene.GetAssImpScene();
-                
+
                 if (currentNode == scene->mRootNode || IsPivotNode(currentNode->mName))
                 {
                     return Events::ProcessingResult::Ignored;
                 }
 
-                aiMatrix4x4 combinedTransform = GetConcatenatedLocalTransform(currentNode);
+                AZStd::unordered_map<AZStd::string, const aiBone*> boneLookup;
+                GetAllBones(scene, boneLookup);
+
+                auto boneIterator = boneLookup.find(currentNode->mName.C_Str());
+                const bool isBone = boneIterator != boneLookup.end();
+
+                aiMatrix4x4 combinedTransform;
+
+                if (isBone)
+                {
+                    auto parentNode = currentNode->mParent;
+
+                    aiMatrix4x4 offsetMatrix = boneIterator->second->mOffsetMatrix;
+                    aiMatrix4x4 parentOffset {};
+
+                    auto parentBoneIterator = boneLookup.find(parentNode->mName.C_Str());
+
+                    if (parentNode && parentBoneIterator != boneLookup.end())
+                    {
+                        const auto& parentBone = parentBoneIterator->second;
+
+                        parentOffset = parentBone->mOffsetMatrix;
+                    }
+
+                    auto inverseOffset = offsetMatrix;
+                    inverseOffset.Inverse();
+
+                    combinedTransform = parentOffset * inverseOffset;
+                }
+                else
+                {
+                    combinedTransform = GetConcatenatedLocalTransform(currentNode);
+                }
 
                 DataTypes::MatrixType localTransform = AssImpSDKWrapper::AssImpTypeConverter::ToTransform(combinedTransform);
-                
+
                 context.m_sourceSceneSystem.SwapTransformForUpAxis(localTransform);
                 context.m_sourceSceneSystem.ConvertUnit(localTransform);
 
@@ -105,9 +152,7 @@ namespace AZ
                 }
                 else
                 {
-                    bool addedData = context.m_scene.GetGraph().SetContent(
-                        context.m_currentGraphPosition,
-                        transformData);
+                    bool addedData = context.m_scene.GetGraph().SetContent(context.m_currentGraphPosition, transformData);
 
                     AZ_Error(SceneAPI::Utilities::ErrorWindow, addedData, "Failed to add node data");
                     return addedData ? Events::ProcessingResult::Success : Events::ProcessingResult::Failure;

Code/Tools/SceneAPI/SDKWrapper/AssImpSceneWrapper.cpp

@@ -69,13 +69,14 @@ namespace AZ
             // aiProcess_JoinIdenticalVertices is not enabled because O3DE has a mesh optimizer that also does this,
             // this flag is disabled to keep AssImp output similar to FBX SDK to reduce downstream bugs for the initial AssImp release.
             // There's currently a minimum of properties and flags set to maximize compatibility with the existing node graph.
+
+            // aiProcess_LimitBoneWeights is not enabled because it will remove bones which are not associated with a mesh.
+            // This results in the loss of the offset matrix data for nodes without a mesh which is required for the Transform Importer.
             m_importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false);
             m_importer.SetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, false);
             m_sceneFileName = fileName;
             m_assImpScene = m_importer.ReadFile(fileName,
                 aiProcess_Triangulate //Triangulates all faces of all meshes
-                | aiProcess_LimitBoneWeights //Limits the number of bones that can affect a vertex to a maximum value
-                                             //dropping the least important and re-normalizing
                 | aiProcess_GenNormals); //Generate normals for meshes
 
 #if AZ_TRAIT_COMPILER_SUPPORT_CSIGNAL