birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/development' into hultonha_LY-69118_lambda_crash

Browse Source 
Signed-off-by: hultonha <hultonha@amazon.co.uk>
This commit is contained in:
hultonha
2021-07-16 10:30:37 +01:00
parent 2c9922d4b5 27407540c7
commit 5a0c1fab9f
129 changed files with 526 additions and 3800 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshOptimizerComponent.cpp
+22 -105
View File
@@ -96,85 +96,6 @@ namespace AZ::SceneGenerationComponents
namespace Containers = AZ::SceneAPI::Containers;
namespace Views = Containers::Views;
// @brief A class to map from a mesh's vertex index to it's welded vertex index
//
// When the mesh optimizer runs, it welds nearby vertices (if there are no blendshapes). This class provides a
// constant time lookup to map from an unwelded vertex index to the welded one.
// The welding works by rounding the vertex's position to the given position tolerance, then uses that rounded
// Vector3 as a key into a unordered_map.
template <class MeshDataType>
class Vector3Map
: private AZStd::unordered_map<AZ::Vector3, AZ::u32>
{
public:
Vector3Map(const MeshDataType* meshData, bool hasBlendShapes, float positionTolerance)
: m_meshData(meshData)
, m_hasBlendShapes(hasBlendShapes)
, m_positionTolerance(positionTolerance)
, m_positionToleranceReciprocal(1.0f / positionTolerance)
{
}
using AZStd::unordered_map<AZ::Vector3, AZ::u32>::reserve;
AZ::u32 operator[](const AZ::u32 vertexIndex)
{
if (m_hasBlendShapes)
{
// Don't attempt to weld similar vertices if there's blendshapes
// Welding the vertices here based on position could cause the vertices of a base shape to be welded,
// and the vertices of the blendshape to not be welded, resulting in a vertex count mismatch between
// the two
return m_meshData->GetUsedPointIndexForControlPoint(m_meshData->GetControlPointIndex(vertexIndex));
}
const auto& [iter, didInsert] = try_emplace(GetPositionForIndex(vertexIndex), m_currentOriginalVertexIndex);
if (didInsert)
{
++m_currentOriginalVertexIndex;
}
return iter->second;
}
[[nodiscard]] AZ::u32 at(const AZ::u32 vertexIndex) const
{
if (m_hasBlendShapes)
{
// Don't attempt to weld similar vertices if there's blendshapes
// Welding the vertices here based on position could cause the vertices of a base shape to be welded,
// and the vertices of the blendshape to not be welded, resulting in a vertex count mismatch between
// the two
return m_meshData->GetUsedPointIndexForControlPoint(m_meshData->GetControlPointIndex(vertexIndex));
}
auto iter = find(GetPositionForIndex(vertexIndex));
AZSTD_CONTAINER_ASSERT(iter != end(), "Element with key is not present");
return iter->second;
}
private:
AZ::Vector3 GetPositionForIndex(const AZ::u32 vertexIndex) const
{
// Round the vertex position so that a float comparison can be made with entires in the map
// pos = floor( x * 10 + 0.5) * 0.1
return AZ::Vector3(
AZ::Simd::Vec3::Floor(
(m_meshData->GetPosition(vertexIndex) * m_positionToleranceReciprocal + AZ::Vector3(0.5f)).GetSimdValue()
)
) * m_positionTolerance;
}
const MeshDataType* m_meshData;
bool m_hasBlendShapes;
float m_positionTolerance;
float m_positionToleranceReciprocal;
AZ::u32 m_currentOriginalVertexIndex = 0;
};
template<class MeshDataType>
Vector3Map(const MeshDataType*) -> Vector3Map<const MeshDataType>;
MeshOptimizerComponent::MeshOptimizerComponent()
{
BindToCall(&MeshOptimizerComponent::OptimizeMeshes);
@@ -185,7 +106,7 @@ namespace AZ::SceneGenerationComponents
auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
if (serializeContext)
{
serializeContext->Class<MeshOptimizerComponent, GenerationComponent>()->Version(4);
serializeContext->Class<MeshOptimizerComponent, GenerationComponent>()->Version(2);
}
}
@@ -194,8 +115,7 @@ namespace AZ::SceneGenerationComponents
const MeshDataType* meshData,
const SkinWeightDataView& skinWeights,
AZ::u32 maxWeightsPerVertex,
float weightThreshold,
const Vector3Map<MeshDataType>& positionMap)
float weightThreshold)
{
if (skinWeights.empty())
{
@@ -221,12 +141,15 @@ namespace AZ::SceneGenerationComponents
for (size_t linkIndex = 0; linkIndex < linkCount; ++linkIndex)
{
const ISkinWeightData::Link& link = skinData.get().GetLink(controlPointIndex, linkIndex);
skinningInfo->AddInfluence(positionMap.at(usedPointIndex), {aznumeric_caster(link.boneId), link.weight});
skinningInfo->AddInfluence(usedPointIndex, {aznumeric_caster(link.boneId), link.weight});
}
}
}
skinningInfo->Optimize(maxWeightsPerVertex, weightThreshold);
if (skinningInfo)
{
skinningInfo->Optimize(maxWeightsPerVertex, weightThreshold);
}
return skinningInfo;
}
@@ -269,12 +192,17 @@ namespace AZ::SceneGenerationComponents
const AZStd::vector<AZStd::pair<const IMeshData*, NodeIndex>> meshes = [](const SceneGraph& graph)
{
AZStd::vector<AZStd::pair<const IMeshData*, NodeIndex>> meshes;
const auto meshNodes = Containers::MakeDerivedFilterView<IMeshData>(graph.GetContentStorage());
for (auto it = meshNodes.cbegin(); it != meshNodes.cend(); ++it)
for (auto it = graph.GetContentStorage().cbegin(); it != graph.GetContentStorage().cend(); ++it)
{
// Skip anything that isn't a mesh.
const auto* mesh = azdynamic_cast<const AZ::SceneAPI::DataTypes::IMeshData*>(it->get());
if (!mesh)
{
continue;
}
// Get the mesh data and node index and store them in the vector as a pair, so we can iterate over them later.
// The sequential calls to GetBaseIterator unwrap the layers of FilterIterators from the MakeDerivedFilterView
meshes.emplace_back(&(*it), graph.ConvertToNodeIndex(it.GetBaseIterator().GetBaseIterator().GetBaseIterator()));
meshes.emplace_back(mesh, graph.ConvertToNodeIndex(it));
}
return meshes;
}(graph);
@@ -359,12 +287,6 @@ namespace AZ::SceneGenerationComponents
auto [optimizedMesh, optimizedUVs, optimizedTangents, optimizedBitangents, optimizedVertexColors, optimizedSkinWeights] = OptimizeMesh(mesh, mesh, uvDatas, tangentDatas, bitangentDatas, colorDatas, skinWeightDatas, meshGroup, hasBlendShapes);
AZ_TracePrintf(AZ::SceneAPI::Utilities::LogWindow, "Base mesh: %zu vertices, optimized mesh: %zu vertices, %0.02f%% of the original",
mesh->GetUsedControlPointCount(),
optimizedMesh->GetUsedControlPointCount(),
((float)optimizedMesh->GetUsedControlPointCount() / (float)mesh->GetUsedControlPointCount()) * 100.0f
);
const NodeIndex optimizedMeshNodeIndex = graph.AddChild(graph.GetNodeParent(nodeIndex), name.c_str(), AZStd::move(optimizedMesh));
auto addOptimizedNodes = [&graph, &optimizedMeshNodeIndex](const auto& originalNodeIndexes, auto& optimizedNodes)
@@ -506,9 +428,10 @@ namespace AZ::SceneGenerationComponents
const AZStd::vector<MeshBuilder::MeshBuilderVertexAttributeLayerVector3*> bitangentLayers = makeLayersForData(bitangents);
const AZStd::vector<MeshBuilder::MeshBuilderVertexAttributeLayerColor*> vertexColorLayers = makeLayersForData(vertexColors);
constexpr float positionTolerance = 0.0001f;
Vector3Map positionMap(meshData, hasBlendShapes, positionTolerance);
positionMap.reserve(vertexCount);
const auto* skinRule = meshGroup.GetRuleContainerConst().FindFirstByType<SceneAPI::DataTypes::ISkinRule>().get();
const AZ::u32 maxWeightsPerVertex = skinRule ? skinRule->GetMaxWeightsPerVertex() : 4;
const float weightThreshold = skinRule ? skinRule->GetWeightThreshold() : 0.001f;
meshBuilder.SetSkinningInfo(ExtractSkinningInfo(meshData, skinWeights, maxWeightsPerVertex, weightThreshold));
// Add the vertex data to all the layers
const AZ::u32 faceCount = meshData->GetFaceCount();
@@ -517,8 +440,8 @@ namespace AZ::SceneGenerationComponents
meshBuilder.BeginPolygon(baseMesh->GetFaceMaterialId(faceIndex));
for (const AZ::u32 vertexIndex : meshData->GetFaceInfo(faceIndex).vertexIndex)
{
const AZ::u32 orgVertexNumber = positionMap[vertexIndex];
const int orgVertexNumber = meshData->GetUsedPointIndexForControlPoint(meshData->GetControlPointIndex(vertexIndex));
AZ_Assert(orgVertexNumber >= 0, "Invalid vertex number");
orgVtxLayer->SetCurrentVertexValue(orgVertexNumber);
posLayer->SetCurrentVertexValue(meshData->GetPosition(vertexIndex));
@@ -548,12 +471,6 @@ namespace AZ::SceneGenerationComponents
meshBuilder.EndPolygon();
}
const auto* skinRule = meshGroup.GetRuleContainerConst().FindFirstByType<SceneAPI::DataTypes::ISkinRule>().get();
const AZ::u32 maxWeightsPerVertex = skinRule ? skinRule->GetMaxWeightsPerVertex() : 4;
const float weightThreshold = skinRule ? skinRule->GetWeightThreshold() : 0.001f;
meshBuilder.SetSkinningInfo(ExtractSkinningInfo(meshData, skinWeights, maxWeightsPerVertex, weightThreshold, positionMap));
meshBuilder.GenerateSubMeshVertexOrders();
// Create the resulting nodes