CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Plugins/Runtime/GeometryProcessing/Source/DynamicMesh/Private/Operations/TransferBoneWeights.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

769 lines
29 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "Operations/TransferBoneWeights.h"
#include "DynamicMesh/DynamicMesh3.h"
#include "DynamicMesh/DynamicVertexSkinWeightsAttribute.h"
#include "DynamicMesh/DynamicBoneAttribute.h"
#include "DynamicMesh/DynamicMeshAttributeSet.h"
#include "DynamicMesh/DynamicMeshAABBTree3.h"
#include "DynamicMesh/MeshNormals.h"
#include "Async/ParallelFor.h"
#include "Util/ProgressCancel.h"
#include "BoneIndices.h"
#include "IndexTypes.h"
#include "TransformTypes.h"
#include "Algo/Count.h"
#include "Solvers/Internal/QuadraticProgramming.h"
#include "Solvers/LaplacianMatrixAssembly.h"
#include "Operations/SmoothBoneWeights.h"
using namespace UE::AnimationCore;
using namespace UE::Geometry;
namespace TransferBoneWeightsLocals
{
/**
* Given a triangle and point on a triangle (via barycentric coordinates), compute the bone weights for the point.
*
* @param OutWeights Interpolated weights for a vertex with Bary barycentric coordinates
* @param TriVertices The vertices of a triangle containing the point we are interpolating the weights for
* @param Bary Barycentric coordinates of the point
* @param Attribute Attribute containing bone weights of the mesh that TriVertices belong to
* @param MaxNumInfluences The maximum allowed number of influences per vertex stored in OutWeights
* @param SourceIndexToBone Optional map from bone index to bone name for the source mesh
* @param TargetBoneToIndex OPtional map from bone name to bone index for the target mesh
* @param bNormalizeToOne If true, OutWeights will be normalized to sum to 1.
*/
void InterpolateBoneWeights(FBoneWeights& OutWeights,
const FIndex3i& TriVertices,
const FVector3f& Bary,
const FDynamicMeshVertexSkinWeightsAttribute* Attribute,
const int32 MaxNumInfluences,
const TArray<FName>* SourceIndexToBone = nullptr,
const TMap<FName, FBoneIndexType>* TargetBoneToIndex = nullptr,
bool bNormalizeToOne = true)
{
FBoneWeights Weight1, Weight2, Weight3;
Attribute->GetValue(TriVertices[0], Weight1);
Attribute->GetValue(TriVertices[1], Weight2);
Attribute->GetValue(TriVertices[2], Weight3);
FBoneWeightsSettings BlendSettings;
BlendSettings.SetNormalizeType(bNormalizeToOne ? EBoneWeightNormalizeType::Always : EBoneWeightNormalizeType::None);
BlendSettings.SetBlendZeroInfluence(true);
BlendSettings.SetMaxWeightCount(MaxNumInfluences);
OutWeights = FBoneWeights::Blend(Weight1, Weight2, Weight3, Bary[0], Bary[1], Bary[2], BlendSettings);
// TODO: Blend method can potentially skip applying renormalization and prunning weights to match MaxNumInfluences
// using the BlendSettings so force renormalization. Remove this once FBoneWeights::Blend is fixed.
OutWeights.Renormalize(BlendSettings);
// Check if we need to remap the indices
if (SourceIndexToBone && TargetBoneToIndex)
{
FBoneWeightsSettings BoneSettings;
BoneSettings.SetNormalizeType(EBoneWeightNormalizeType::None);
FBoneWeights MappedWeights;
for (int32 WeightIdx = 0; WeightIdx < OutWeights.Num(); ++WeightIdx)
{
const FBoneWeight& BoneWeight = OutWeights[WeightIdx];
FBoneIndexType FromIdx = BoneWeight.GetBoneIndex();
uint16 FromWeight = BoneWeight.GetRawWeight();
checkSlow(FromIdx < SourceIndexToBone->Num());
if (FromIdx < SourceIndexToBone->Num())
{
FName BoneName = (*SourceIndexToBone)[FromIdx];
if (TargetBoneToIndex->Contains(BoneName))
{
FBoneIndexType ToIdx = (*TargetBoneToIndex)[BoneName];
FBoneWeight MappedBoneWeight(ToIdx, FromWeight);
MappedWeights.SetBoneWeight(MappedBoneWeight, BoneSettings);
}
else
{
UE_LOG(LogGeometry, Error, TEXT("FTransferBoneWeights: Bone name %s does not exist in the target mesh."), *BoneName.ToString());
}
}
}
if (MappedWeights.Num() == 0)
{
// If no bone mappings were found, add a single entry for the root bone
MappedWeights.SetBoneWeight(FBoneWeight(0, 1.0f), FBoneWeightsSettings());
}
else if (OutWeights.Num() != MappedWeights.Num() && bNormalizeToOne)
{
// In case some of the bones were not mapped we need to renormalize
MappedWeights.Renormalize(FBoneWeightsSettings());
}
OutWeights = MappedWeights;
}
}
FDynamicMeshVertexSkinWeightsAttribute* GetOrCreateSkinWeightsAttribute(FDynamicMesh3& InMesh, const FName& InProfileName)
{
checkSlow(InMesh.HasAttributes());
FDynamicMeshVertexSkinWeightsAttribute* Attribute = InMesh.Attributes()->GetSkinWeightsAttribute(InProfileName);
if (Attribute == nullptr)
{
Attribute = new FDynamicMeshVertexSkinWeightsAttribute(&InMesh);
InMesh.Attributes()->AttachSkinWeightsAttribute(InProfileName, Attribute);
}
return Attribute;
}
static FVector3f ToUENormal(const FVector3d& Normal)
{
return FVector3f((float)Normal.X, (float)Normal.Y, (float)Normal.Z);
}
}
FTransferBoneWeights::FTransferBoneWeights(const FDynamicMesh3* InSourceMesh,
const FName& InSourceProfileName,
const FDynamicMeshAABBTree3* InSourceBVH)
:
SourceMesh(InSourceMesh),
SourceProfileName(InSourceProfileName),
SourceBVH(InSourceBVH)
{
// If the BVH for the source mesh was not specified then create one
if (SourceBVH == nullptr)
{
InternalSourceBVH = MakeUnique<FDynamicMeshAABBTree3>(SourceMesh);
}
}
FTransferBoneWeights::~FTransferBoneWeights()
{
}
bool FTransferBoneWeights::Cancelled()
{
return (Progress == nullptr) ? false : Progress->Cancelled();
}
EOperationValidationResult FTransferBoneWeights::Validate()
{
if (SourceMesh == nullptr)
{
return EOperationValidationResult::Failed_UnknownReason;
}
// Either BVH was passed by the caller or was created internally in the constructor
if (SourceBVH == nullptr && InternalSourceBVH.IsValid() == false)
{
return EOperationValidationResult::Failed_UnknownReason;
}
if (SourceMesh->HasAttributes() == false)
{
return EOperationValidationResult::Failed_UnknownReason;
}
if (SourceMesh->Attributes()->GetSkinWeightsAttribute(SourceProfileName) == nullptr)
{
return EOperationValidationResult::Failed_UnknownReason;
}
if (bIgnoreBoneAttributes == false && SourceMesh->Attributes()->HasBones() == false)
{
return EOperationValidationResult::Failed_UnknownReason;
}
return EOperationValidationResult::Ok;
}
bool FTransferBoneWeights::TransferWeightsToMesh(FDynamicMesh3& InOutTargetMesh, const FName& InTargetProfileName)
{
using TransferBoneWeightsLocals::ToUENormal;
if (Validate() != EOperationValidationResult::Ok)
{
return false;
}
if (!InOutTargetMesh.HasAttributes())
{
InOutTargetMesh.EnableAttributes();
}
if (!bIgnoreBoneAttributes && !InOutTargetMesh.Attributes()->HasBones())
{
return false; // the target mesh must have bone attributes
}
// If we need to compare normals, make sure both the target and the source meshes have per-vertex normals data
TUniquePtr<FMeshNormals> InternalTargetMeshNormals;
if (NormalThreshold >= 0)
{
if (!SourceMesh->HasVertexNormals() && !InternalSourceMeshNormals)
{
// only do this once for the source mesh in case of subsequent calls to the method
InternalSourceMeshNormals = MakeUnique<FMeshNormals>(SourceMesh);
InternalSourceMeshNormals->ComputeVertexNormals();
}
if (!InOutTargetMesh.HasVertexNormals())
{
InternalTargetMeshNormals = MakeUnique<FMeshNormals>(&InOutTargetMesh);
InternalTargetMeshNormals->ComputeVertexNormals();
}
}
FDynamicMeshVertexSkinWeightsAttribute* TargetSkinWeights = TransferBoneWeightsLocals::GetOrCreateSkinWeightsAttribute(InOutTargetMesh, InTargetProfileName);
checkSlow(TargetSkinWeights);
// Map the bone name to its index for the target mesh.
// Will be null if either the target and the source skeletons are the same or the caller forced the attributes to be ignored
TUniquePtr<TMap<FName, uint16>> TargetBoneToIndex;
if (!bIgnoreBoneAttributes)
{
const TArray<FName>& SourceBoneNames = SourceMesh->Attributes()->GetBoneNames()->GetAttribValues();
const TArray<FName>& TargetBoneNames = InOutTargetMesh.Attributes()->GetBoneNames()->GetAttribValues();
if (SourceBoneNames != TargetBoneNames)
{
TargetBoneToIndex = MakeUnique<TMap<FName, uint16>>();
TargetBoneToIndex->Reserve(TargetBoneNames.Num());
for (int32 BoneID = 0; BoneID < TargetBoneNames.Num(); ++BoneID)
{
const FName& BoneName = TargetBoneNames[BoneID];
if (TargetBoneToIndex->Contains(BoneName))
{
checkSlow(false);
return false; // there should be no duplicates
}
TargetBoneToIndex->Add(BoneName, static_cast<uint16>(BoneID));
}
}
}
bool bFailed = false;
// compute the transfer only for the subset of vertices if necessary
const bool bUseSubset = !TargetVerticesSubset.IsEmpty();
const int32 NumVerticesToTransfer = bUseSubset ? TargetVerticesSubset.Num() : InOutTargetMesh.MaxVertexID();
if (TransferMethod == ETransferBoneWeightsMethod::ClosestPointOnSurface)
{
MatchedVertices.Init(false, NumVerticesToTransfer);
ParallelFor(NumVerticesToTransfer, [this, &InOutTargetMesh, &TargetBoneToIndex, &TargetSkinWeights, &InternalTargetMeshNormals, bUseSubset](int32 InVertexID)
{
if (Cancelled())
{
return;
}
const int32 VertexID = bUseSubset ? TargetVerticesSubset[InVertexID] : InVertexID;
if (InOutTargetMesh.IsVertex(VertexID))
{
const FVector3d Point = InOutTargetMesh.GetVertex(VertexID);
FVector3f Normal = FVector3f::UnitY();
if (NormalThreshold >= 0)
{
const bool bHasNormals = InOutTargetMesh.HasVertexNormals();
if (ensure(bHasNormals || InternalTargetMeshNormals))
{
Normal = bHasNormals ? InOutTargetMesh.GetVertexNormal(VertexID) : ToUENormal(InternalTargetMeshNormals->GetNormals()[VertexID]);
}
}
FBoneWeights Weights;
if (TransferWeightsToPoint(Weights, Point, TargetBoneToIndex.Get(), Normal))
{
TargetSkinWeights->SetValue(VertexID, Weights);
MatchedVertices[VertexID] = true;
}
}
}, bUseParallel ? EParallelForFlags::None : EParallelForFlags::ForceSingleThread);
// If the caller requested to simply find the closest point for all vertices then the number of matched vertices
// must be equal to the target mesh vertex count
if (SearchRadius < 0 && NormalThreshold < 0)
{
int32 NumMatched = 0;
for (bool Flag : MatchedVertices)
{
if (Flag)
{
NumMatched++;
}
}
bFailed = NumMatched != NumVerticesToTransfer;
}
}
else if (TransferMethod == ETransferBoneWeightsMethod::InpaintWeights)
{
/**
* Given two meshes, Mesh1 without weights and Mesh2 with weights, assume they are aligned in 3d space.
* For every vertex on Mesh1 find the closest point on the surface of Mesh2 within a radius R. If the difference
* between the normals of the two points is below the threshold, then it's a match. Otherwise no match.
* So now we have two sets of vertices on Mesh1. One with a match on the source mesh and one without a match.
* For all the vertices with a match, copy weights over. For all the vertices without the match, do nothing.
* Now, for all the vertices without a match, try to approximate the weights by smoothly interpolating between
* the weights at the known vertices via solving a quadratic problem.
*
* The solver minimizes an energy
* trace(W^t Q W)
* W \in R^(nxm) is a matrix where n is the number of vertices and m is the number of bones. So (i,j) entry is
* the influence (weight) of a vertex i by bone j
* Q \in R^(nxn) is a matrix that combines both Dirichlet and Laplacian energies, Q = -L + L*M^(-1)*L
* where L is a cotangent Laplacian and M is a mass matrix
*
* subject to constraints
* All weights at a single vertex sum to 1: sum(W(i,:)) = 1
* All weights must be non-negative: W(i,j) >=0 for any i, j
* Any vertex for which we found a match must have fixed weights that can't be changed,
* i.e. W(i,j) = KnownWeights(i,j) where i is a vertex for which we found a match on the body.
*/
MatchedVertices.Init(false, InOutTargetMesh.MaxVertexID());
// Check if the target mesh contains the user specifed force inpaint weight map
const FDynamicMeshWeightAttribute* ForceInpaintLayer = nullptr;
if (!ForceInpaintWeightMapName.IsNone() && (ForceInpaint.IsEmpty() || ForceInpaint.Num() != InOutTargetMesh.MaxVertexID())) // ForceInpaint array takes priority if valid
{
for (int32 Idx = 0; Idx < InOutTargetMesh.Attributes()->NumWeightLayers(); ++Idx)
{
const FDynamicMeshWeightAttribute* WeightLayer = InOutTargetMesh.Attributes()->GetWeightLayer(Idx);
if (WeightLayer && WeightLayer->GetName() == ForceInpaintWeightMapName)
{
ForceInpaintLayer = WeightLayer;
break;
}
}
}
// because the inpaint algorithm can extract data from regions outside the target vertex subset, a temporary attribute profile is used to modify the weights.
// NOTE: make sure to copy the weights of the vertex subset into the complete TargetSkinWeights attribute before exciting the function. (see CopySubsetWeightsIfNeeded)
FDynamicMeshVertexSkinWeightsAttribute SubsetTargetSkinWeights;
if (bUseSubset)
{
SubsetTargetSkinWeights.Copy(*TargetSkinWeights);
}
FDynamicMeshVertexSkinWeightsAttribute* EditedSkinWeights = bUseSubset ? &SubsetTargetSkinWeights : TargetSkinWeights;
// For every vertex on the target mesh try to find the match on the source mesh using the distance and normal checks
ParallelFor(InOutTargetMesh.MaxVertexID(), [this, &InOutTargetMesh, &ForceInpaintLayer, &TargetBoneToIndex, &EditedSkinWeights, &InternalTargetMeshNormals](int32 VertexID)
{
if (Cancelled())
{
return;
}
if (InOutTargetMesh.IsVertex(VertexID))
{
// check if we need to force the vertex to not have a match
if (ForceInpaint.Num() == InOutTargetMesh.MaxVertexID() && ForceInpaint[VertexID] != 0)
{
return;
}
else if (ForceInpaintLayer != nullptr)
{
float Value;
ForceInpaintLayer->GetValue(VertexID, &Value);
if (Value != 0)
{
return;
}
}
const FVector3d Point = InOutTargetMesh.GetVertex(VertexID);
FVector3f Normal = FVector3f::UnitY();
if (NormalThreshold >= 0)
{
const bool bHasNormals = InOutTargetMesh.HasVertexNormals();
if (ensure(bHasNormals || InternalTargetMeshNormals.IsValid()))
{
Normal = bHasNormals ? InOutTargetMesh.GetVertexNormal(VertexID) : ToUENormal(InternalTargetMeshNormals->GetNormals()[VertexID]);
}
}
FBoneWeights Weights;
if (TransferWeightsToPoint(Weights, Point, TargetBoneToIndex.Get(), Normal))
{
EditedSkinWeights->SetValue(VertexID, Weights);
MatchedVertices[VertexID] = true;
}
}
}, bUseParallel ? EParallelForFlags::None : EParallelForFlags::ForceSingleThread);
if (Cancelled())
{
return false;
}
int32 NumMatched = 0;
if (!bUseSubset)
{
for (bool Flag : MatchedVertices)
{
if (Flag)
{
NumMatched++;
}
}
}
else
{
NumMatched = (int32)Algo::CountIf(TargetVerticesSubset, [this](int32 VertexID)
{
return MatchedVertices.IsValidIndex(VertexID) && MatchedVertices[VertexID];
});
}
// If no vertices matched, we have nothing to inpaint.
if (NumMatched == 0)
{
return false;
}
auto CopySubsetWeightsIfNeeded = [Subset = TargetVerticesSubset, &EditedSkinWeights, &TargetSkinWeights, &InOutTargetMesh]()
{
if (EditedSkinWeights && EditedSkinWeights != TargetSkinWeights)
{
for (const int32 VertexID: Subset)
{
if (InOutTargetMesh.IsVertex(VertexID))
{
FBoneWeights Weights;
EditedSkinWeights->GetValue(VertexID, Weights);
TargetSkinWeights->SetValue(VertexID, Weights);
}
}
}
};
// If all vertices were matched then nothing else to do
if (NumMatched == NumVerticesToTransfer)
{
// copy weights from the subset skin weights if using subset
CopySubsetWeightsIfNeeded();
return true;
}
// Compute linearization so we can store constraints at linearized indices
FVertexLinearization VtxLinearization(InOutTargetMesh, false);
const TArray<int32>& ToMeshV = VtxLinearization.ToId();
const TArray<int32>& ToIndex = VtxLinearization.ToIndex();
// Setup the sparse matrix FixedValues of known (matched) weight values and the array (FixedIndices) of the matched vertex IDs
const int32 TargetNumBones = InOutTargetMesh.Attributes()->GetBoneNames()->GetAttribValues().Num();
FSparseMatrixD FixedValues;
FixedValues.resize(NumMatched, TargetNumBones);
std::vector<Eigen::Triplet<FSparseMatrixD::Scalar>> FixedValuesTriplets;
FixedValuesTriplets.reserve(NumMatched);
TArray<int> FixedIndices;
FixedIndices.Reserve(NumMatched);
for (int32 VertexID = 0; VertexID < InOutTargetMesh.MaxVertexID(); ++VertexID)
{
if (InOutTargetMesh.IsVertex(VertexID) && MatchedVertices[VertexID])
{
FBoneWeights Data;
EditedSkinWeights->GetValue(VertexID, Data);
const int32 NumBones = Data.Num();
checkSlow(NumBones > 0);
const int32 CurIdx = FixedIndices.Num();
for (int32 BoneID = 0; BoneID < NumBones; ++BoneID)
{
const int BoneIdx = Data[BoneID].GetBoneIndex();
const double BoneWeight = Data[BoneID].GetWeight();
FixedValuesTriplets.emplace_back(CurIdx, BoneIdx, BoneWeight);
}
checkSlow(VertexID < ToIndex.Num());
FixedIndices.Add(ToIndex[VertexID]);
}
}
FixedValues.setFromTriplets(FixedValuesTriplets.begin(), FixedValuesTriplets.end());
const int32 NumVerts = VtxLinearization.NumVerts();
FEigenSparseMatrixAssembler CotangentAssembler(NumVerts, NumVerts);
FEigenSparseMatrixAssembler LaplacianAssembler(NumVerts, NumVerts);
UE::Tasks::FTask CotangentTask, LaplacianTask;
if (bUseIntrinsicLaplacian)
{
CotangentTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&InOutTargetMesh, &VtxLinearization, &CotangentAssembler]()
{
// Construct the Cotangent weights matrix
UE::MeshDeformation::ConstructFullIDTCotangentLaplacian<double>(InOutTargetMesh, VtxLinearization, CotangentAssembler,
UE::MeshDeformation::ECotangentWeightMode::Default,
UE::MeshDeformation::ECotangentAreaMode::NoArea);
});
LaplacianTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&InOutTargetMesh, &VtxLinearization, &LaplacianAssembler]()
{
// Construct the Laplacian with cotangent weights scaled by the voronoi area (i.e. M^(-1)*L matrix where M is the mass/stiffness matrix)
UE::MeshDeformation::ConstructFullIDTCotangentLaplacian<double>(InOutTargetMesh, VtxLinearization, LaplacianAssembler,
UE::MeshDeformation::ECotangentWeightMode::Default,
UE::MeshDeformation::ECotangentAreaMode::VoronoiArea);
});
}
else
{
CotangentTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&InOutTargetMesh, &VtxLinearization, &CotangentAssembler]()
{
UE::MeshDeformation::ConstructFullCotangentLaplacian<double>(InOutTargetMesh, VtxLinearization, CotangentAssembler,
UE::MeshDeformation::ECotangentWeightMode::Default,
UE::MeshDeformation::ECotangentAreaMode::NoArea);
});
LaplacianTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&InOutTargetMesh, &VtxLinearization, &LaplacianAssembler]()
{
UE::MeshDeformation::ConstructFullCotangentLaplacian<double>(InOutTargetMesh, VtxLinearization, LaplacianAssembler,
UE::MeshDeformation::ECotangentWeightMode::Default,
UE::MeshDeformation::ECotangentAreaMode::VoronoiArea);
});
}
FSparseMatrixD CotangentMatrix, MassCotangentMatrix;
UE::Tasks::FTask CotangentExtractTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&CotangentMatrix, &CotangentAssembler]()
{
CotangentAssembler.ExtractResult(CotangentMatrix);
}, CotangentTask);
UE::Tasks::FTask LaplacianExtractTask = UE::Tasks::Launch(UE_SOURCE_LOCATION, [&MassCotangentMatrix, &LaplacianAssembler]()
{
LaplacianAssembler.ExtractResult(MassCotangentMatrix);
}, LaplacianTask);
TArray<UE::Tasks::FTask> PendingTasks = { CotangentExtractTask, LaplacianExtractTask };
UE::Tasks::Wait(PendingTasks);
// -L * L* M^(-1)*L energy
FSparseMatrixD Energy = -1*CotangentMatrix + CotangentMatrix*MassCotangentMatrix;
// Solve the QP problem with fixed constraints
FSparseMatrixD TargetWeights;
TArray<int> VaribleRows;
// We want the solution TargetWeights matrix to only contain the rows representing the variable (non-fixed) rows
constexpr bool bVariablesOnly = true;
bFailed = !FQuadraticProgramming::SolveWithFixedConstraints(Energy, nullptr, FixedIndices, FixedValues, TargetWeights, bVariablesOnly, KINDA_SMALL_NUMBER, &VaribleRows);
checkSlow((VaribleRows.Num() + FixedIndices.Num()) == Energy.rows());
if (!bFailed)
{
// Transpose so we can efficiently iterate over the col-major matrix. Each column now contains per-vertex weights.
// Otherwise, we are iterating over rows of a col-major matrix which is slow.
FSparseMatrixD TargetWeightsTransposed = TargetWeights.transpose();
FBoneWeightsSettings BoneSettings;
BoneSettings.SetNormalizeType(EBoneWeightNormalizeType::None);
FBoneWeightsSettings RenormalizeBoneSettings;
RenormalizeBoneSettings.SetMaxWeightCount(MaxNumInfluences);
// Iterate over every column containing all bone weights for the vertex
for (int32 ColIdx = 0; ColIdx < TargetWeightsTransposed.outerSize(); ++ColIdx)
{
FBoneWeights WeightArray;
// Iterate over only non-zero rows (i.e. bone indices with non-zero weights)
for (FSparseMatrixD::InnerIterator Itr(TargetWeightsTransposed, ColIdx); Itr; ++Itr)
{
const FBoneIndexType BoneIdx = static_cast<FBoneIndexType>(Itr.row());
const float Weight = static_cast<float>(Itr.value());
FBoneWeight Bweight(BoneIdx, Weight);
WeightArray.SetBoneWeight(Bweight, BoneSettings);
}
WeightArray.Renormalize(RenormalizeBoneSettings);
const int32 VertexIDLinearalized = bVariablesOnly ? static_cast<int32>(VaribleRows[ColIdx]) : ColIdx; // linearized vertex ID (matrix row) of the variable in the Energy matrix
const int32 VertexID = static_cast<int32>(ToMeshV[VertexIDLinearalized]);
EditedSkinWeights->SetValue(VertexID, WeightArray);
}
// copy weights from the subset skin weights if using subset
CopySubsetWeightsIfNeeded();
// Optional post-processing smoothing of the weights at the vertices without a match
if (NumSmoothingIterations > 0 && SmoothingStrength > 0)
{
TArray<int32> VerticesToSmooth;
const int32 NumNotMatched = InOutTargetMesh.VertexCount() - NumMatched;
VerticesToSmooth.Reserve(NumNotMatched);
for (int32 VertexID = 0; VertexID < InOutTargetMesh.MaxVertexID(); ++VertexID)
{
if (InOutTargetMesh.IsVertex(VertexID) && !MatchedVertices[VertexID])
{
VerticesToSmooth.Add(VertexID);
}
}
FSmoothDynamicMeshVertexSkinWeights SmoothWeights(&InOutTargetMesh, InTargetProfileName);
SmoothWeights.MaxNumInfluences = MaxNumInfluences;
if (ensure(SmoothWeights.Validate() == EOperationValidationResult::Ok))
{
ensure(SmoothWeights.SmoothWeightsAtVerticesWithinDistance(VerticesToSmooth, SmoothingStrength, SearchRadius, NumSmoothingIterations));
}
}
}
}
else
{
checkNoEntry(); // unsupported method
}
if (Cancelled() || bFailed)
{
return false;
}
return true;
}
bool FTransferBoneWeights::TransferWeightsToPoint(UE::AnimationCore::FBoneWeights& OutWeights,
const FVector3d& InPoint,
const TMap<FName, uint16>* TargetBoneToIndex,
const FVector3f& InNormal)
{
using TransferBoneWeightsLocals::ToUENormal;
// Find the containing triangle and the barycentric coordinates of the closest point
int32 TriID;
FVector3d Bary;
if (!FindClosestPointOnSourceSurface(InPoint, TargetToWorld, TriID, Bary))
{
return false;
}
FVector3f BaryF = FVector3f((float)Bary[0], (float)Bary[1], (float)Bary[2]);
const FIndex3i TriVertex = SourceMesh->GetTriangle(TriID);
const FDynamicMeshVertexSkinWeightsAttribute* SourceSkinWeights = SourceMesh->Attributes()->GetSkinWeightsAttribute(SourceProfileName);
const TArray<FName>* SourceBoneNames = nullptr;
if (!bIgnoreBoneAttributes)
{
SourceBoneNames = &SourceMesh->Attributes()->GetBoneNames()->GetAttribValues();
}
if (SearchRadius < 0 && NormalThreshold < 0)
{
// If the radius and normals are ignored, simply interpolate the weights and return the result
TransferBoneWeightsLocals::InterpolateBoneWeights(OutWeights, TriVertex, BaryF, SourceSkinWeights, MaxNumInfluences, SourceBoneNames, TargetBoneToIndex);
}
else
{
bool bPassedRadiusCheck = true;
if (SearchRadius >= 0)
{
const FVector3d MatchedPoint = SourceMesh->GetTriBaryPoint(TriID, Bary[0], Bary[1], Bary[2]);
bPassedRadiusCheck = (InPoint - MatchedPoint).Length() <= SearchRadius;
}
bool bPassedNormalsCheck = true;
if (NormalThreshold >= 0)
{
FVector3f Normal0 = FVector3f::UnitY();
FVector3f Normal1 = FVector3f::UnitY();
FVector3f Normal2 = FVector3f::UnitY();
const bool bHasSourceNormals = SourceMesh->HasVertexNormals();
if (ensure(bHasSourceNormals || InternalSourceMeshNormals.IsValid()))
{
Normal0 = bHasSourceNormals ? SourceMesh->GetVertexNormal(TriVertex[0]) : ToUENormal(InternalSourceMeshNormals->GetNormals()[TriVertex[0]]);
Normal1 = bHasSourceNormals ? SourceMesh->GetVertexNormal(TriVertex[1]) : ToUENormal(InternalSourceMeshNormals->GetNormals()[TriVertex[1]]);
Normal2 = bHasSourceNormals ? SourceMesh->GetVertexNormal(TriVertex[2]) : ToUENormal(InternalSourceMeshNormals->GetNormals()[TriVertex[2]]);
}
const FVector3f MatchedNormal = Normalized(BaryF[0]*Normal0 + BaryF[1]*Normal1 + BaryF[2]*Normal2);
const FVector3f InNormalNormalized = Normalized(InNormal);
const float NormalAngle = FMathf::ACos(InNormalNormalized.Dot(MatchedNormal));
bPassedNormalsCheck = (double)NormalAngle <= NormalThreshold;
if (!bPassedNormalsCheck && LayeredMeshSupport)
{
// try again with a flipped normal
bPassedNormalsCheck = (double)(TMathUtil<float>::Pi - NormalAngle) <= NormalThreshold;
}
}
if (bPassedRadiusCheck && bPassedNormalsCheck)
{
TransferBoneWeightsLocals::InterpolateBoneWeights(OutWeights, TriVertex, BaryF, SourceSkinWeights, MaxNumInfluences, SourceBoneNames, TargetBoneToIndex);
}
else
{
return false;
}
}
return true;
}
template<typename BoneIndexType, typename BoneFloatWeightType, typename PosVectorType, typename NormalVectorType>
bool FTransferBoneWeights::TransferWeightsToPoint(TArray<BoneIndexType>& OutBones,
TArray<BoneFloatWeightType>& OutWeights,
const UE::Math::TVector<PosVectorType>& InPoint,
const TMap<FName, uint16>* TargetBoneToIndex,
const UE::Math::TVector<NormalVectorType>& InNormal)
{
FBoneWeights BoneWeights;
if (!this->TransferWeightsToPoint(BoneWeights, FVector3d(InPoint.X, InPoint.Y, InPoint.Z), TargetBoneToIndex, FVector3f((float)InNormal.X, (float)InNormal.Y, (float)InNormal.Z)))
{
return false;
}
const int32 NumEntries = BoneWeights.Num();
OutBones.SetNum(NumEntries);
OutWeights.SetNum(NumEntries);
for (int32 BoneIdx = 0; BoneIdx < NumEntries; ++BoneIdx)
{
OutBones[BoneIdx] = static_cast<BoneIndexType>(BoneWeights[BoneIdx].GetBoneIndex());
OutWeights[BoneIdx] = static_cast<BoneFloatWeightType>(BoneWeights[BoneIdx].GetWeight());
}
return true;
}
bool FTransferBoneWeights::FindClosestPointOnSourceSurface(const FVector3d& InPoint, const FTransformSRT3d& InToWorld, int32& NearTriID, FVector3d& Bary)
{
IMeshSpatial::FQueryOptions Options;
double NearestDistSqr;
const FVector3d WorldPoint = InToWorld.TransformPosition(InPoint);
if (SourceBVH != nullptr)
{
NearTriID = SourceBVH->FindNearestTriangle(WorldPoint, NearestDistSqr, Options);
}
else
{
NearTriID = InternalSourceBVH->FindNearestTriangle(WorldPoint, NearestDistSqr, Options);
}
if (!ensure(NearTriID != IndexConstants::InvalidID))
{
return false;
}
const FDistPoint3Triangle3d Query = TMeshQueries<FDynamicMesh3>::TriangleDistance(*SourceMesh, NearTriID, WorldPoint);
const FVector3d NearestPnt = Query.ClosestTrianglePoint;
const FIndex3i TriVertex = SourceMesh->GetTriangle(NearTriID);
Bary = VectorUtil::BarycentricCoords(NearestPnt, SourceMesh->GetVertexRef(TriVertex.A),
SourceMesh->GetVertexRef(TriVertex.B),
SourceMesh->GetVertexRef(TriVertex.C));
return true;
}
// template instantiation
template DYNAMICMESH_API bool UE::Geometry::FTransferBoneWeights::TransferWeightsToPoint<int,float,float,float>(class TArray<int,class TSizedDefaultAllocator<32> > &,class TArray<float,class TSizedDefaultAllocator<32> > &,struct UE::Math::TVector<float> const &,class TMap<class FName,unsigned short,class FDefaultSetAllocator,struct TDefaultMapHashableKeyFuncs<class FName,unsigned short,0> > const *,struct UE::Math::TVector<float> const &);
Reference in New Issue View Git Blame Copy Permalink