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

Supply the vertex index remapping to the optimized skin weights

Browse Source 
This ensures that the optimized skin weights use the vertex indexes from
the optimized mesh

Signed-off-by: Chris Burel <burelc@amazon.com>
This commit is contained in:
Chris Burel
2021-07-08 16:16:47 -07:00
parent 7bcd4baec4
commit 9ea46bad83
2 changed files with 258 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gems/SceneProcessing/Code/Source/Generation/Components/MeshOptimizer/MeshOptimizerComponent.cpp
+93 -42
View File
@@ -97,6 +97,85 @@ 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);
@@ -107,7 +186,7 @@ namespace AZ::SceneGenerationComponents
auto* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
if (serializeContext)
{
serializeContext->Class<MeshOptimizerComponent, GenerationComponent>()->Version(3);
serializeContext->Class<MeshOptimizerComponent, GenerationComponent>()->Version(4);
}
}
@@ -116,7 +195,8 @@ namespace AZ::SceneGenerationComponents
const MeshDataType* meshData,
const SkinWeightDataView& skinWeights,
AZ::u32 maxWeightsPerVertex,
float weightThreshold)
float weightThreshold,
const Vector3Map<MeshDataType>& positionMap)
{
if (skinWeights.empty())
{
@@ -142,15 +222,12 @@ namespace AZ::SceneGenerationComponents
for (size_t linkIndex = 0; linkIndex < linkCount; ++linkIndex)
{
const ISkinWeightData::Link& link = skinData.get().GetLink(controlPointIndex, linkIndex);
skinningInfo->AddInfluence(usedPointIndex, {aznumeric_caster(link.boneId), link.weight});
skinningInfo->AddInfluence(positionMap.at(usedPointIndex), {aznumeric_caster(link.boneId), link.weight});
}
}
}
if (skinningInfo)
{
skinningInfo->Optimize(maxWeightsPerVertex, weightThreshold);
}
skinningInfo->Optimize(maxWeightsPerVertex, weightThreshold);
return skinningInfo;
}
@@ -430,16 +507,9 @@ namespace AZ::SceneGenerationComponents
const AZStd::vector<MeshBuilder::MeshBuilderVertexAttributeLayerVector3*> bitangentLayers = makeLayersForData(bitangents);
const AZStd::vector<MeshBuilder::MeshBuilderVertexAttributeLayerColor*> vertexColorLayers = makeLayersForData(vertexColors);
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));
constexpr float positionTolerance = 0.0001f;
constexpr float positionToleranceReciprocal = 1.0f / positionTolerance;
AZStd::unordered_map<AZ::Vector3, AZ::u32> positionMap{};
AZ::u32 currentOriginalVertexIndex = 0;
Vector3Map positionMap(meshData, hasBlendShapes, positionTolerance);
positionMap.reserve(vertexCount);
// Add the vertex data to all the layers
const AZ::u32 faceCount = meshData->GetFaceCount();
@@ -448,32 +518,7 @@ namespace AZ::SceneGenerationComponents
meshBuilder.BeginPolygon(baseMesh->GetFaceMaterialId(faceIndex));
for (const AZ::u32 vertexIndex : meshData->GetFaceInfo(faceIndex).vertexIndex)
{
const AZ::u32 orgVertexNumber = [&meshData, &hasBlendShapes, &vertexIndex, &positionMap, &currentOriginalVertexIndex, positionTolerance, positionToleranceReciprocal]() -> AZ::u32
{
if (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 meshData->GetUsedPointIndexForControlPoint(meshData->GetControlPointIndex(vertexIndex));
}
// Round the vertex position so that a float comparison can be made with entires in the positionMap
// pos = floor( x * 10 + 0.5) * 0.1
const AZ::Vector3 position = AZ::Vector3(
AZ::Simd::Vec3::Floor(
(meshData->GetPosition(vertexIndex) * positionToleranceReciprocal + AZ::Vector3(0.5f)).GetSimdValue()
)
) * positionTolerance;
const auto& [iter, didInsert] = positionMap.try_emplace(position, currentOriginalVertexIndex);
if (didInsert)
{
++currentOriginalVertexIndex;
}
return iter->second;
}();
const AZ::u32 orgVertexNumber = positionMap[vertexIndex];
orgVtxLayer->SetCurrentVertexValue(orgVertexNumber);
@@ -504,6 +549,12 @@ 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