Integrating latest 47acbe8

Gems/NvCloth/Code/Tests/ActorHelper.cpp

@@ -13,11 +13,15 @@
 #include <ActorHelper.h>
 
 #include <AzCore/std/smart_ptr/make_shared.h>
+#include <AzCore/std/algorithm.h>
 
-#include <EMotionFX/Source/Node.h>
-#include <EMotionFX/Source/MeshBuilder.h>
 #include <EMotionFX/Source/Mesh.h>
+#include <EMotionFX/Source/Node.h>
+#include <EMotionFX/Source/SkinningInfoVertexAttributeLayer.h>
+#include <EMotionFX/Source/SubMesh.h>
+#include <EMotionFX/Source/VertexAttributeLayerAbstractData.h>
 #include <Integration/Assets/ActorAsset.h>
+#include <Tests/TestAssetCode/MeshFactory.h>
 
 #include <NvCloth/ITangentSpaceHelper.h>
 
@@ -119,117 +123,27 @@ namespace UnitTest
     }
 
     EMotionFX::Mesh* CreateEMotionFXMesh(
-        AZ::u32 nodeIndex,
         const AZStd::vector<AZ::Vector3>& vertices,
         const AZStd::vector<AZ::u32>& indices,
         const AZStd::vector<VertexSkinInfluences>& skinningInfo,
         const AZStd::vector<AZ::Vector2>& uvs,
         const AZStd::vector<AZ::Color>& clothData)
     {
-        const AZ::u32 vertCount = aznumeric_cast<AZ::u32>(vertices.size());
-        const AZ::u32 faceCount = aznumeric_cast<AZ::u32>(indices.size()) / 3;
-
-        AZStd::unique_ptr<EMotionFX::MeshBuilder> meshBuilder = AZStd::make_unique<EMotionFX::MeshBuilder>(nodeIndex, vertCount);
-
-        // Skinning info
-        if (!skinningInfo.empty() && skinningInfo.size() == vertices.size())
-        {
-            EMotionFX::MeshBuilderSkinningInfo* skinningInfoBuilder = EMotionFX::MeshBuilderSkinningInfo::Create(vertCount);
-            for (size_t vertex = 0; vertex < skinningInfo.size(); ++vertex)
-            {
-                for (const auto& influence : skinningInfo[vertex])
-                {
-                    skinningInfoBuilder->AddInfluence(static_cast<AZ::u32>(vertex), influence);
-                }
-            }
-            skinningInfoBuilder->Optimize();
-
-            meshBuilder->SetSkinningInfo(skinningInfoBuilder);
-        }
-
-        // Original vertex numbers
-        EMotionFX::MeshBuilderVertexAttributeLayerUInt32* orgVtxLayer = EMotionFX::MeshBuilderVertexAttributeLayerUInt32::Create(
-            vertCount,
-            EMotionFX::Mesh::ATTRIB_ORGVTXNUMBERS,
-            false,
-            false
-        );
-        meshBuilder->AddLayer(orgVtxLayer);
-
-        // The positions layer
-        EMotionFX::MeshBuilderVertexAttributeLayerVector3* posLayer = EMotionFX::MeshBuilderVertexAttributeLayerVector3::Create(
-            vertCount,
-            EMotionFX::Mesh::ATTRIB_POSITIONS,
-            false,
-            true
-        );
-        meshBuilder->AddLayer(posLayer);
-
-        // The normals layer
-        EMotionFX::MeshBuilderVertexAttributeLayerVector3* normalsLayer = EMotionFX::MeshBuilderVertexAttributeLayerVector3::Create(
-            vertCount,
-            EMotionFX::Mesh::ATTRIB_NORMALS,
-            false,
-            true
-        );
-        meshBuilder->AddLayer(normalsLayer);
-
-        // The UVs layer.
-        EMotionFX::MeshBuilderVertexAttributeLayerVector2* uvsLayer = nullptr;
-        if (!uvs.empty() && uvs.size() == vertices.size())
-        {
-            uvsLayer = EMotionFX::MeshBuilderVertexAttributeLayerVector2::Create(vertCount, EMotionFX::Mesh::ATTRIB_UVCOORDS, false, false);
-            meshBuilder->AddLayer(uvsLayer);
-        }
-
-        // The cloth layer.
-        EMotionFX::MeshBuilderVertexAttributeLayerUInt32* clothLayer = nullptr;
-        if (!clothData.empty() && clothData.size() == vertices.size())
-        {
-            clothLayer = EMotionFX::MeshBuilderVertexAttributeLayerUInt32::Create(vertCount, EMotionFX::Mesh::ATTRIB_CLOTH_DATA, false, false);
-            meshBuilder->AddLayer(clothLayer);
-        }
-
-        const int materialId = 0;
-
-        AZStd::vector<AZ::Vector3> normals;
+        // Generate the normals for this mesh
         AZStd::vector<AZ::Vector4> particles(vertices.size());
-        for (size_t i = 0; i < vertices.size(); ++i)
-        {
-            particles[i] = AZ::Vector4::CreateFromVector3(vertices[i]);
-        }
+        AZStd::transform(vertices.begin(), vertices.end(), particles.begin(), [](const AZ::Vector3& vertex) { return AZ::Vector4::CreateFromVector3(vertex); } );
+        AZStd::vector<AZ::Vector3> normals;
         AZ::Interface<NvCloth::ITangentSpaceHelper>::Get()->CalculateNormals(
             particles, indices,
             normals);
 
-        for (AZ::u32 faceNum = 0; faceNum < faceCount; ++faceNum)
-        {
-            meshBuilder->BeginPolygon(materialId);
-            for (AZ::u32 vertexOfFace = 0; vertexOfFace < 3; ++vertexOfFace)
-            {
-                AZ::u32 vertexNum = faceNum * 3 + vertexOfFace;
-                AZ::u32 vertexIndex = indices[vertexNum];
-
-                orgVtxLayer->SetCurrentVertexValue(&vertexNum);
-                posLayer->SetCurrentVertexValue(&vertices[vertexIndex]);
-                normalsLayer->SetCurrentVertexValue(&normals[vertexIndex]);
-
-                if (!uvs.empty())
-                {
-                    uvsLayer->SetCurrentVertexValue(&uvs[vertexIndex]);
-                }
-
-                if (!clothData.empty())
-                {
-                    const AZ::u32 clothVertexDataU32 = clothData[vertexIndex].ToU32();
-                    clothLayer->SetCurrentVertexValue(&clothVertexDataU32);
-                }
-
-                meshBuilder->AddPolygonVertex(vertexNum);
-            }
-            meshBuilder->EndPolygon();
-        }
-
-        return EMotionFX::Mesh::CreateFromMeshBuilder(meshBuilder.get());
+        return EMotionFX::MeshFactory::Create(
+            indices,
+            vertices,
+            normals,
+            uvs,
+            clothData,
+            skinningInfo
+        );
     }
 } // namespace UnitTest