1538 lines
58 KiB
C++
1538 lines
58 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "MuR/ConvertData.h"
|
|
#include "MuR/MeshPrivate.h"
|
|
|
|
#include "Math/Plane.h"
|
|
#include "Math/Ray.h"
|
|
#include "Math/NumericLimits.h"
|
|
|
|
#include "IndexTypes.h"
|
|
#include "MuR/MutableTrace.h"
|
|
#include "MuR/Operations.h"
|
|
#include "Spatial/MeshAABBTree3.h"
|
|
|
|
#include "MuR/OpMeshSmoothing.h"
|
|
|
|
// TODO: Make the handling of rotations an option. It is more expensive on CPU and memory, and for some
|
|
// cases it is not required at all.
|
|
|
|
// TODO: Face stretch to scale the deformation per-vertex?
|
|
|
|
// TODO: Support multiple binding influences per vertex, to have smoother deformations.
|
|
|
|
// TODO: Support multiple binding sets, to have different shapes deformations at once.
|
|
|
|
// TODO: Deformation mask, to select the intensisty of the deformation per-vertex.
|
|
|
|
// TODO: This is a reference implementation with ample roof for optimization.
|
|
|
|
namespace mu
|
|
{
|
|
template<class PositionCompType, class NormalCompType>
|
|
struct FShapeMeshDescriptor
|
|
{
|
|
TArray<UE::Math::TVector<PositionCompType>> Positions;
|
|
TArray<UE::Math::TVector<NormalCompType>> Normals;
|
|
TArray<UE::Geometry::FIndex3i> Triangles;
|
|
};
|
|
|
|
using FShapeMeshDescriptorBind = FShapeMeshDescriptor<double, float>;
|
|
|
|
struct FShapeMeshAdapter
|
|
{
|
|
const FShapeMeshDescriptorBind& Mesh;
|
|
|
|
FShapeMeshAdapter(const FShapeMeshDescriptorBind& InMesh )
|
|
: Mesh(InMesh)
|
|
{}
|
|
|
|
int32 MaxTriangleID() const
|
|
{
|
|
return Mesh.Triangles.Num();
|
|
}
|
|
|
|
int32 MaxVertexID() const
|
|
{
|
|
return Mesh.Positions.Num();
|
|
}
|
|
|
|
bool IsTriangle(int32 Index) const
|
|
{
|
|
return Mesh.Triangles.IsValidIndex(Index);
|
|
}
|
|
|
|
bool IsVertex(int32 Index) const
|
|
{
|
|
return Mesh.Positions.IsValidIndex(Index);
|
|
}
|
|
|
|
int32 TriangleCount() const
|
|
{
|
|
return Mesh.Triangles.Num();
|
|
}
|
|
|
|
FORCEINLINE int32 VertexCount() const
|
|
{
|
|
return Mesh.Positions.Num();
|
|
}
|
|
|
|
FORCEINLINE uint64 GetChangeStamp() const
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
FORCEINLINE UE::Geometry::FIndex3i GetTriangle(int32 Index) const
|
|
{
|
|
return Mesh.Triangles[Index];
|
|
}
|
|
|
|
FORCEINLINE FVector3d GetVertex(int32 Index) const
|
|
{
|
|
return Mesh.Positions[Index];
|
|
}
|
|
|
|
FORCEINLINE void GetTriVertices(int32 TriIndex, FVector3d& V0, FVector3d& V1, FVector3d& V2) const
|
|
{
|
|
const UE::Geometry::FIndex3i& Indices = Mesh.Triangles[TriIndex];
|
|
|
|
V0 = Mesh.Positions[Indices.A];
|
|
V1 = Mesh.Positions[Indices.B];
|
|
V2 = Mesh.Positions[Indices.C];
|
|
}
|
|
};
|
|
|
|
using FShapeMeshTree = UE::Geometry::TMeshAABBTree3<const FShapeMeshAdapter>;
|
|
|
|
// Structure used for vertex bing data in vertexbuffers for reshape operations.
|
|
struct FReshapeVertexBindingData
|
|
{
|
|
// Barycentric coordinates on the shape triangle
|
|
float S, T;
|
|
|
|
// Distance along the normals of the shape triangle.
|
|
FVector3f D;
|
|
|
|
// Index of the shape triangle.
|
|
int32 Triangle;
|
|
|
|
// Used to calculate the rotation to apply to the reshaped vertex tangent space.
|
|
float NS, NT;
|
|
FVector3f NormalD;
|
|
|
|
// Bind point, if the point belongs to a rigid cluster, the attachment point, otherwise
|
|
// the original point.
|
|
FVector3f AttachmentPoint;
|
|
|
|
// Weight of the effect for this binding. Ranged between 0 and 1 where 0 denotes no effect at all and 1
|
|
// full effect. This weight should be proportional to the confidence we have that the binding data is valid.
|
|
float Weight;
|
|
};
|
|
static_assert(sizeof(FReshapeVertexBindingData) == 4*15);
|
|
|
|
struct FReshapeVertexBindingDataBufferDescriptor
|
|
{
|
|
constexpr static int32 ElementSize = sizeof(FReshapeVertexBindingData);
|
|
constexpr static int32 Channels = 4;
|
|
constexpr static EMeshBufferSemantic Semantics[Channels] = { EMeshBufferSemantic::BarycentricCoords, EMeshBufferSemantic::Distance, EMeshBufferSemantic::TriangleIndex, EMeshBufferSemantic::Other };
|
|
constexpr static EMeshBufferFormat Formats[Channels] = { EMeshBufferFormat::Float32, EMeshBufferFormat::Float32, EMeshBufferFormat::Int32, EMeshBufferFormat::Float32 };
|
|
constexpr static int32 Components[Channels] = { 2, 3, 1, 2+3+3+1 };
|
|
constexpr static int32 Offsets[Channels] = { 0, 4*2, (2+3)*4, (2+3+1)*4};
|
|
|
|
const int32 SemanticIndices[Channels] = { 0, 0, 0, 0 };
|
|
|
|
FReshapeVertexBindingDataBufferDescriptor(int32 DataSetIndex)
|
|
: SemanticIndices{ DataSetIndex, DataSetIndex, DataSetIndex, DataSetIndex }
|
|
{
|
|
}
|
|
};
|
|
|
|
struct FReshapePointBindingData
|
|
{
|
|
float S, T;
|
|
FVector3f D;
|
|
int32 Triangle;
|
|
float Weight;
|
|
};
|
|
|
|
static_assert(sizeof(FReshapePointBindingData) == 24+4);
|
|
|
|
struct FReshapePointBindingDataBufferDescriptor
|
|
{
|
|
constexpr static int32 ElementSize = sizeof(FReshapeVertexBindingData);
|
|
constexpr static int32 Channels = 4;
|
|
constexpr static EMeshBufferSemantic Semantics[Channels] = { EMeshBufferSemantic::BarycentricCoords, EMeshBufferSemantic::Distance, EMeshBufferSemantic::TriangleIndex, EMeshBufferSemantic::Other };
|
|
constexpr static EMeshBufferFormat Formats[Channels] = { EMeshBufferFormat::Float32, EMeshBufferFormat::Float32, EMeshBufferFormat::Int32, EMeshBufferFormat::Float32 };
|
|
constexpr static int32 Components[Channels] = { 2, 3, 1, 1 };
|
|
constexpr static int32 Offsets[Channels] = { 0, 8, 20, 24 };
|
|
|
|
const int32 SemanticIndices[Channels] = { 0, 0, 0, 0 };
|
|
|
|
FReshapePointBindingDataBufferDescriptor(int32 DataSetIndex)
|
|
: SemanticIndices{ DataSetIndex, DataSetIndex, DataSetIndex, DataSetIndex }
|
|
{
|
|
}
|
|
};
|
|
|
|
struct FIntBufferDescriptor
|
|
{
|
|
constexpr static int32 ElementSize = sizeof(int32);
|
|
constexpr static int32 Channels = 1;
|
|
constexpr static EMeshBufferSemantic Semantics[Channels] = { EMeshBufferSemantic::Other };
|
|
constexpr static EMeshBufferFormat Formats[Channels] = { EMeshBufferFormat::Int32 };
|
|
constexpr static int32 Components[Channels] = { 1 };
|
|
constexpr static int32 Offsets[Channels] = { 0 };
|
|
constexpr static int32 SemanticIndices[Channels] = { 0 };
|
|
|
|
FIntBufferDescriptor()
|
|
{
|
|
}
|
|
};
|
|
|
|
using ReshapePoseBindingType = FReshapePointBindingData;
|
|
using ReshapePhysicsBindingType = FReshapePointBindingData;
|
|
|
|
// Structure used for vertex bing data in vertexbuffers for Clip deform operations.
|
|
struct FClipDeformVertexBindingData
|
|
{
|
|
// Barycentric coordinates on the shape triangle
|
|
float S, T;
|
|
|
|
// Index of the shape triangle.
|
|
int32 Triangle;
|
|
|
|
float Weight;
|
|
};
|
|
static_assert(sizeof(FClipDeformVertexBindingData) == 16);
|
|
|
|
struct FClipDeformVertexBindingDataBufferDescriptor
|
|
{
|
|
constexpr static int32 Channels = 3;
|
|
constexpr static EMeshBufferSemantic Semantics[Channels] = { EMeshBufferSemantic::BarycentricCoords, EMeshBufferSemantic::TriangleIndex, EMeshBufferSemantic::Other };
|
|
constexpr static EMeshBufferFormat Formats[Channels] = { EMeshBufferFormat::Float32, EMeshBufferFormat::Int32, EMeshBufferFormat::Float32 };
|
|
constexpr static int32 Components[Channels] = { 2, 1, 1 };
|
|
constexpr static int32 Offsets[Channels] = { 0, 8, 12 };
|
|
|
|
const int32 SemanticIndices[Channels] = { 0, 0, 0 };
|
|
|
|
FClipDeformVertexBindingDataBufferDescriptor(int32 DataSetIndex)
|
|
: SemanticIndices{ DataSetIndex, DataSetIndex, DataSetIndex }
|
|
{
|
|
}
|
|
};
|
|
|
|
struct FMeshBindColorChannelUsageMasks
|
|
{
|
|
uint32 MaskWeight = 0;
|
|
uint32 ClusterId = 0;
|
|
};
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//! Generate the mesh-shape binding data for Reshape operations
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
inline float GetVertexMaskWeight(const UntypedMeshBufferIteratorConst& ColorIter, const FMeshBindColorChannelUsageMasks& ChannelUsages)
|
|
{
|
|
check(ColorIter.GetFormat() == EMeshBufferFormat::UInt8 || ColorIter.GetFormat() == EMeshBufferFormat::NUInt8);
|
|
check(ColorIter.GetComponents() == 4);
|
|
check(ColorIter.ptr());
|
|
|
|
const uint32 Value = *reinterpret_cast<const uint32*>(ColorIter.ptr());
|
|
return static_cast<float>((Value >> FMath::CountTrailingZeros(ChannelUsages.MaskWeight) & 0xFF)) / 255.0f;
|
|
}
|
|
|
|
inline uint32 GetVertexClusterId(const UntypedMeshBufferIteratorConst& ColorIter, const FMeshBindColorChannelUsageMasks& ChannelUsages)
|
|
{
|
|
check(ColorIter.GetFormat() == EMeshBufferFormat::UInt8 || ColorIter.GetFormat() == EMeshBufferFormat::NUInt8);
|
|
check(ColorIter.GetComponents() == 4);
|
|
check(ColorIter.ptr());
|
|
|
|
const uint32 MaskedValue = *reinterpret_cast<const uint32*>(ColorIter.ptr()) & ChannelUsages.ClusterId;
|
|
// Set all unused bits to 1 so we have a consistent value, in that case white, for the non clustered vertices.
|
|
return MaskedValue | ~ChannelUsages.ClusterId;
|
|
}
|
|
|
|
|
|
FORCEINLINE FVector2f ComputeBarycentric(const FVector3f& Point, const FVector3f& A, const FVector3f& B, const FVector3f& C)
|
|
{
|
|
const FVector3f TriNorm = FVector3f::CrossProduct(B - A, C - A);
|
|
|
|
const float TriNormSizeSquared = TriNorm.SizeSquared();
|
|
// Return the center of the triangle if the area is very small.
|
|
if (TriNormSizeSquared <= UE_SMALL_NUMBER)
|
|
{
|
|
return FVector2f(1.0f/3.0f);
|
|
}
|
|
|
|
const float AreaABCInv = FMath::InvSqrt(TriNormSizeSquared);
|
|
|
|
const FVector3f N = TriNorm * AreaABCInv;
|
|
|
|
const float AreaPBC = FVector3f::DotProduct(N, FVector3f::CrossProduct(B - Point, C - Point));
|
|
const float AreaPCA = FVector3f::DotProduct(N, FVector3f::CrossProduct(C - Point, A - Point));
|
|
|
|
return FVector2f(AreaPBC, AreaPCA) * AreaABCInv;
|
|
}
|
|
|
|
inline void BindReshapePoint(
|
|
FShapeMeshTree& ShapeMeshTree,
|
|
const FVector3f& Point, const FVector3f& Normal, float MaskWeight, FReshapeVertexBindingData& OutBindData,
|
|
const float ValidityTolerance = UE_KINDA_SMALL_NUMBER)
|
|
{
|
|
|
|
const FShapeMeshDescriptorBind& ShapeMesh = ShapeMeshTree.GetMesh()->Mesh;
|
|
|
|
OutBindData.S = 0.0f;
|
|
OutBindData.T = 0.0f;
|
|
OutBindData.Triangle = -1;
|
|
OutBindData.AttachmentPoint = Point;
|
|
float Weight = MaskWeight;
|
|
|
|
if (FMath::IsNearlyZero(MaskWeight))
|
|
{
|
|
return;
|
|
}
|
|
|
|
double DistSqr = 0.0;
|
|
|
|
int32 FoundIndex = ShapeMeshTree.FindNearestTriangle(FVector3d(Point), DistSqr);
|
|
|
|
if (FoundIndex < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Calculate the binding data of the base mesh vertex to its bound shape triangle
|
|
UE::Geometry::FIndex3i Triangle = ShapeMesh.Triangles[FoundIndex];
|
|
|
|
// Project on the triangle, but using the vertex normals.
|
|
// See reference implementation for details.
|
|
FVector3f TriangleA = (FVector3f)ShapeMesh.Positions[Triangle.A];
|
|
FVector3f TriangleB = (FVector3f)ShapeMesh.Positions[Triangle.B];
|
|
FVector3f TriangleC = (FVector3f)ShapeMesh.Positions[Triangle.C];
|
|
|
|
FPlane4f TrianglePlane(TriangleA, TriangleB, TriangleC);
|
|
FVector3f PlaneNormal = TrianglePlane.GetNormal();
|
|
FPlane4f VertexPlane(Point, PlaneNormal);
|
|
FPlane4f NormalPlane(Point + Normal, PlaneNormal);
|
|
|
|
// T1 = Triangle projected on the vertex plane along the triangle vertex normals
|
|
OutBindData.D =
|
|
FVector3f
|
|
{
|
|
FMath::RayPlaneIntersectionParam(TriangleA, ShapeMesh.Normals[Triangle.A], VertexPlane),
|
|
FMath::RayPlaneIntersectionParam(TriangleB, ShapeMesh.Normals[Triangle.B], VertexPlane),
|
|
FMath::RayPlaneIntersectionParam(TriangleC, ShapeMesh.Normals[Triangle.C], VertexPlane)
|
|
};
|
|
|
|
OutBindData.NormalD =
|
|
FVector3f
|
|
{
|
|
FMath::RayPlaneIntersectionParam(TriangleA, ShapeMesh.Normals[Triangle.A], NormalPlane),
|
|
FMath::RayPlaneIntersectionParam(TriangleB, ShapeMesh.Normals[Triangle.B], NormalPlane),
|
|
FMath::RayPlaneIntersectionParam(TriangleC, ShapeMesh.Normals[Triangle.C], NormalPlane)
|
|
};
|
|
|
|
|
|
FVector2f PositionBarycentric = ComputeBarycentric(Point,
|
|
TriangleA + ShapeMesh.Normals[Triangle.A] * OutBindData.D.X,
|
|
TriangleB + ShapeMesh.Normals[Triangle.B] * OutBindData.D.Y,
|
|
TriangleC + ShapeMesh.Normals[Triangle.C] * OutBindData.D.Z);
|
|
|
|
OutBindData.S = PositionBarycentric.X;
|
|
OutBindData.T = PositionBarycentric.Y;
|
|
|
|
FVector2f NormalBarycentric = ComputeBarycentric((Point + Normal),
|
|
TriangleA + ShapeMesh.Normals[Triangle.A] * OutBindData.NormalD.X,
|
|
TriangleB + ShapeMesh.Normals[Triangle.B] * OutBindData.NormalD.Y,
|
|
TriangleC + ShapeMesh.Normals[Triangle.C] * OutBindData.NormalD.Z);
|
|
|
|
OutBindData.NS = NormalBarycentric.X;
|
|
OutBindData.NT = NormalBarycentric.Y;
|
|
|
|
OutBindData.Triangle = FoundIndex;
|
|
|
|
OutBindData.Weight = FMath::Clamp(MaskWeight, 0.0f, 1.0f);
|
|
OutBindData.Triangle = FMath::IsNearlyZero(OutBindData.Weight) ? -1 : OutBindData.Triangle;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//! Find mesh clusters.
|
|
//! Colour {1,1,1,1} is reserved for the non rigid cluster
|
|
//---------------------------------------------------------------------------------------------
|
|
|
|
inline void FindRigidClusters(const FMesh* Mesh, const FMeshBindColorChannelUsageMasks& ColorUsageMasks, TArray<TArray<int32>>& OutClusters, int32& OutNonRigidClusterIdx)
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(MeshFindRigidClusters);
|
|
|
|
constexpr uint32 NonRigidId = ~0;
|
|
|
|
OutNonRigidClusterIdx = -1;
|
|
|
|
const UntypedMeshBufferIteratorConst ItColorBase(Mesh->GetVertexBuffers(), EMeshBufferSemantic::Color);
|
|
if (ItColorBase.ptr())
|
|
{
|
|
const int32 VertexCount = Mesh->GetVertexCount();
|
|
|
|
{
|
|
int32 VertexIndex = 0;
|
|
for (; VertexIndex < VertexCount; ++VertexIndex)
|
|
{
|
|
if (NonRigidId != GetVertexClusterId(ItColorBase + VertexIndex, ColorUsageMasks))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If all equal to the non rigid we are done.
|
|
if (VertexIndex == VertexCount)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
OutClusters.Empty(16);
|
|
TArray<TArray<int32>>& ClusterData = OutClusters;
|
|
TMap<uint32, int32> ClusterSet;
|
|
|
|
for (int32 VertexIndex = 0; VertexIndex < VertexCount; ++VertexIndex)
|
|
{
|
|
const uint32 ClusterId = GetVertexClusterId(ItColorBase + VertexIndex, ColorUsageMasks);
|
|
int32& ClusterIdx = ClusterSet.FindOrAdd(ClusterId, INDEX_NONE);
|
|
TArray<int32>& Cluster = ClusterIdx < 0 ? ClusterData.Emplace_GetRef() : ClusterData[ClusterIdx];
|
|
if (ClusterIdx < 0)
|
|
{
|
|
ClusterIdx = ClusterData.Num() - 1;
|
|
Cluster.Reserve(32);
|
|
}
|
|
|
|
Cluster.Add(VertexIndex);
|
|
}
|
|
|
|
// Cluster id 0xFFFFFFFF is reserved for the nonrigid cluster. The choice if this value is not arbitrary,
|
|
// meshes without colour will get white as default.
|
|
const int32* NonRigidClusterIdxFound = ClusterSet.Find(NonRigidId);
|
|
|
|
// If not found, add an empty cluster for the non rigid id.
|
|
OutNonRigidClusterIdx = NonRigidClusterIdxFound ? *NonRigidClusterIdxFound : ClusterData.Emplace();
|
|
}
|
|
}
|
|
|
|
inline void FindBindingForCluster(
|
|
const FMesh* BaseMesh, FShapeMeshTree& ShapeMeshTree,
|
|
const TArray<int32>& Cluster, FReshapeVertexBindingData& OutBindingData, float BindTolerance)
|
|
{
|
|
const UntypedMeshBufferIteratorConst ItPositionBase(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
|
|
FBox3f ClusterBoundingBox(ForceInit);
|
|
for (const int32& V : Cluster)
|
|
{
|
|
ClusterBoundingBox += (ItPositionBase + V).GetAsVec3f();
|
|
}
|
|
|
|
FVector3f BoundPoint = ClusterBoundingBox.GetCenter();
|
|
|
|
// Mask weight is set on a vertex by vertex basis, ignore weight for the shared data.
|
|
// This will be filled in afterwards.
|
|
constexpr float MaskWeight = 1.0f;
|
|
BindReshapePoint(ShapeMeshTree, BoundPoint, FVector3f::ZAxisVector, MaskWeight, OutBindingData, BindTolerance);
|
|
}
|
|
|
|
inline TTuple<TArray<FReshapePointBindingData>, TArray<int32>, TArray<int32>> BindPhysicsBodies(
|
|
TArray<const FPhysicsBody*> PhysicsBodies, FShapeMeshTree& ShapeMeshTree, const FMesh* pMesh,
|
|
const TArray<FBoneName>& PhysicsToDeform )
|
|
{
|
|
TTuple<TArray<FReshapePointBindingData>, TArray<int32>, TArray<int32>> ReturnValue;
|
|
|
|
TArray<int32>& BodiesToDeformIndices = ReturnValue.Get<1>();
|
|
TArray<int32>& BodiesToDeformOffsets = ReturnValue.Get<2>();
|
|
|
|
const int32 NumPhysicsBodies = PhysicsBodies.Num();
|
|
|
|
BodiesToDeformIndices.Reserve(NumPhysicsBodies * PhysicsToDeform.Num());
|
|
BodiesToDeformOffsets.SetNum(NumPhysicsBodies + 1);
|
|
|
|
BodiesToDeformOffsets[0] = 0;
|
|
for (int32 PhysicsBodyIndex = 0; PhysicsBodyIndex < NumPhysicsBodies; ++PhysicsBodyIndex)
|
|
{
|
|
if (const FPhysicsBody* Body = PhysicsBodies[PhysicsBodyIndex])
|
|
{
|
|
const int32 NumBodies = PhysicsBodies[PhysicsBodyIndex]->GetBodyCount();
|
|
for (int32 BodyIndex = 0; BodyIndex < NumBodies; ++BodyIndex)
|
|
{
|
|
if (PhysicsToDeform.Contains(Body->GetBodyBoneId(BodyIndex)))
|
|
{
|
|
BodiesToDeformIndices.Add(BodyIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
BodiesToDeformOffsets[PhysicsBodyIndex + 1] = BodiesToDeformIndices.Num();
|
|
}
|
|
|
|
int32 TotalNumPoints = 0;
|
|
for (int32 PhysicsBodyIndex = 0; PhysicsBodyIndex < NumPhysicsBodies; ++PhysicsBodyIndex)
|
|
{
|
|
const int32 IndicesBegin = BodiesToDeformOffsets[PhysicsBodyIndex];
|
|
const int32 IndicesEnd = BodiesToDeformOffsets[PhysicsBodyIndex + 1];
|
|
|
|
TArrayView<int32> BodyIndices = TArrayView<int32>(
|
|
BodiesToDeformIndices.GetData() + IndicesBegin, IndicesEnd - IndicesBegin);
|
|
|
|
const FPhysicsBody* Body = PhysicsBodies[PhysicsBodyIndex];
|
|
|
|
int32 BodyNumPoints = 0;
|
|
for (const int32 I : BodyIndices)
|
|
{
|
|
BodyNumPoints += Body->GetSphereCount(I) * 6;
|
|
BodyNumPoints += Body->GetBoxCount(I) * 14;
|
|
BodyNumPoints += Body->GetSphylCount(I) * 14;
|
|
BodyNumPoints += Body->GetTaperedCapsuleCount(I) * 14;
|
|
|
|
const int32 ConvexCount = Body->GetConvexCount(I);
|
|
for (int C = 0; C < ConvexCount; ++C)
|
|
{
|
|
TArrayView<const FVector3f> Vertices;
|
|
TArrayView<const int32> Indices;
|
|
|
|
FTransform3f Transform;
|
|
Body->GetConvex(I, C, Vertices, Indices, Transform);
|
|
|
|
BodyNumPoints += Vertices.Num();
|
|
}
|
|
}
|
|
|
|
TotalNumPoints += BodyNumPoints;
|
|
}
|
|
|
|
TArray<FVector3f> Points;
|
|
Points.SetNumUninitialized(TotalNumPoints);
|
|
|
|
// Bone transform needs to be applied to the body's sample points so they are in mesh space.
|
|
|
|
// Create a point soup to be deformed based on the shapes in the aggregate.
|
|
|
|
int32 AddedPoints = 0;
|
|
|
|
for (int32 PhysicsBodyIndex = 0; PhysicsBodyIndex < NumPhysicsBodies; ++PhysicsBodyIndex)
|
|
{
|
|
const FPhysicsBody* Body = PhysicsBodies[PhysicsBodyIndex];
|
|
|
|
const int32 IndicesBegin = BodiesToDeformOffsets[PhysicsBodyIndex];
|
|
const int32 IndicesEnd = BodiesToDeformOffsets[PhysicsBodyIndex + 1];
|
|
|
|
TArrayView<int32> BodyIndices = TArrayView<int32>(
|
|
BodiesToDeformIndices.GetData() + IndicesBegin, IndicesEnd - IndicesBegin);
|
|
|
|
for (const int32 B : BodyIndices)
|
|
{
|
|
int32 BoneIndex = pMesh->FindBonePose(Body->GetBodyBoneId(B));
|
|
|
|
FTransform3f T = FTransform3f::Identity;
|
|
if (BoneIndex > 0)
|
|
{
|
|
pMesh->GetBonePoseTransform(BoneIndex, T);
|
|
}
|
|
|
|
const int32 SphereCount = Body->GetSphereCount(B);
|
|
for (int32 I = 0; I < SphereCount; ++I, AddedPoints += 6)
|
|
{
|
|
FVector3f P;
|
|
float R;
|
|
|
|
Body->GetSphere(B, I, P, R);
|
|
|
|
Points[AddedPoints + 0] = T.TransformPosition(P + FVector3f(R, 0.0f, 0.0f));
|
|
Points[AddedPoints + 1] = T.TransformPosition(P - FVector3f(R, 0.0f, 0.0f));
|
|
|
|
Points[AddedPoints + 2] = T.TransformPosition(P + FVector3f(0.0f, R, 0.0f));
|
|
Points[AddedPoints + 3] = T.TransformPosition(P - FVector3f(0.0f, R, 0.0f));
|
|
|
|
Points[AddedPoints + 4] = T.TransformPosition(P + FVector3f(0.0f, 0.0f, R));
|
|
Points[AddedPoints + 5] = T.TransformPosition(P - FVector3f(0.0f, 0.0f, R));
|
|
}
|
|
|
|
const int32 BoxCount = Body->GetBoxCount(B);
|
|
for (int32 I = 0; I < BoxCount; ++I, AddedPoints += 14)
|
|
{
|
|
FVector3f P;
|
|
FQuat4f Q;
|
|
FVector3f S;
|
|
|
|
Body->GetBox(B, I, P, Q, S);
|
|
|
|
const FVector3f BasisX = Q.RotateVector(FVector3f::UnitX());
|
|
const FVector3f BasisY = Q.RotateVector(FVector3f::UnitY());
|
|
const FVector3f BasisZ = Q.RotateVector(FVector3f::UnitZ());
|
|
|
|
Points[AddedPoints + 0] = T.TransformPosition(P + BasisX * S.X + BasisY * S.Y + BasisZ * S.Z);
|
|
Points[AddedPoints + 1] = T.TransformPosition(P + BasisX * S.X - BasisY * S.Y + BasisZ * S.Z);
|
|
Points[AddedPoints + 2] = T.TransformPosition(P - BasisX * S.X + BasisY * S.Y + BasisZ * S.Z);
|
|
Points[AddedPoints + 3] = T.TransformPosition(P - BasisX * S.X - BasisY * S.Y + BasisZ * S.Z);
|
|
|
|
Points[AddedPoints + 4] = T.TransformPosition(P + BasisX * S.X + BasisY * S.Y - BasisZ * S.Z);
|
|
Points[AddedPoints + 5] = T.TransformPosition(P + BasisX * S.X - BasisY * S.Y - BasisZ * S.Z);
|
|
Points[AddedPoints + 6] = T.TransformPosition(P - BasisX * S.X + BasisY * S.Y - BasisZ * S.Z);
|
|
Points[AddedPoints + 7] = T.TransformPosition(P - BasisX * S.X - BasisY * S.Y - BasisZ * S.Z);
|
|
|
|
Points[AddedPoints + 8] = T.TransformPosition(P + BasisX * S.X);
|
|
Points[AddedPoints + 9] = T.TransformPosition(P + BasisY * S.Y);
|
|
Points[AddedPoints + 10] = T.TransformPosition(P + BasisZ * S.Z);
|
|
|
|
Points[AddedPoints + 11] = T.TransformPosition(P - BasisX * S.X);
|
|
Points[AddedPoints + 12] = T.TransformPosition(P - BasisY * S.Y);
|
|
Points[AddedPoints + 13] = T.TransformPosition(P - BasisZ * S.Z);
|
|
}
|
|
|
|
const int32 SphylCount = Body->GetSphylCount(B);
|
|
for (int32 I = 0; I < SphylCount; ++I, AddedPoints += 14)
|
|
{
|
|
FVector3f P;
|
|
FQuat4f Q;
|
|
float R;
|
|
float L;
|
|
|
|
Body->GetSphyl(B, I, P, Q, R, L);
|
|
|
|
const float H = L * 0.5f;
|
|
|
|
const FVector3f BasisX = Q.RotateVector(FVector3f::UnitX());
|
|
const FVector3f BasisY = Q.RotateVector(FVector3f::UnitY());
|
|
const FVector3f BasisZ = Q.RotateVector(FVector3f::UnitZ());
|
|
|
|
// Top and Bottom
|
|
Points[AddedPoints + 0] = T.TransformPosition(P + BasisZ * (H + R));
|
|
Points[AddedPoints + 1] = T.TransformPosition(P - BasisZ * (H + R));
|
|
|
|
// Top ring
|
|
Points[AddedPoints + 2] = T.TransformPosition(P + BasisX * R + BasisZ * H);
|
|
Points[AddedPoints + 3] = T.TransformPosition(P - BasisX * R + BasisZ * H);
|
|
Points[AddedPoints + 4] = T.TransformPosition(P + BasisY * R + BasisZ * H);
|
|
Points[AddedPoints + 5] = T.TransformPosition(P - BasisY * R + BasisZ * H);
|
|
|
|
// Center ring
|
|
Points[AddedPoints + 6] = T.TransformPosition(P + BasisX * R);
|
|
Points[AddedPoints + 7] = T.TransformPosition(P - BasisX * R);
|
|
Points[AddedPoints + 8] = T.TransformPosition(P + BasisY * R);
|
|
Points[AddedPoints + 9] = T.TransformPosition(P - BasisY * R);
|
|
|
|
// Bottom ring
|
|
Points[AddedPoints + 10] = T.TransformPosition(P + BasisX * R - BasisZ * H);
|
|
Points[AddedPoints + 11] = T.TransformPosition(P - BasisX * R - BasisZ * H);
|
|
Points[AddedPoints + 12] = T.TransformPosition(P + BasisY * R - BasisZ * H);
|
|
Points[AddedPoints + 13] = T.TransformPosition(P - BasisY * R - BasisZ * H);
|
|
|
|
}
|
|
|
|
const int32 TaperedCapsuleCount = Body->GetTaperedCapsuleCount(B);
|
|
for (int32 I = 0; I < TaperedCapsuleCount; ++I, AddedPoints += 14)
|
|
{
|
|
FVector3f P;
|
|
FQuat4f Q;
|
|
float R0;
|
|
float R1;
|
|
float L;
|
|
|
|
Body->GetTaperedCapsule(B, I, P, Q, R0, R1, L);
|
|
|
|
const float H = L * 0.5f;
|
|
const float RCenter = (R0 + R1) * 0.5f;
|
|
|
|
const FVector3f BasisX = Q.RotateVector(FVector3f::UnitX());
|
|
const FVector3f BasisY = Q.RotateVector(FVector3f::UnitY());
|
|
const FVector3f BasisZ = Q.RotateVector(FVector3f::UnitZ());
|
|
|
|
// Top and Bottom
|
|
Points[AddedPoints + 0] = T.TransformPosition(P + BasisZ * (H + R0));
|
|
Points[AddedPoints + 1] = T.TransformPosition(P - BasisZ * (H + R1));
|
|
|
|
// Top ring
|
|
Points[AddedPoints + 2] = T.TransformPosition(P + BasisX * R0 + BasisZ * H);
|
|
Points[AddedPoints + 3] = T.TransformPosition(P - BasisX * R0 + BasisZ * H);
|
|
Points[AddedPoints + 4] = T.TransformPosition(P + BasisY * R0 + BasisZ * H);
|
|
Points[AddedPoints + 5] = T.TransformPosition(P - BasisY * R0 + BasisZ * H);
|
|
|
|
// Center ring
|
|
Points[AddedPoints + 6] = T.TransformPosition(P + BasisX * RCenter);
|
|
Points[AddedPoints + 7] = T.TransformPosition(P - BasisX * RCenter);
|
|
Points[AddedPoints + 8] = T.TransformPosition(P + BasisY * RCenter);
|
|
Points[AddedPoints + 9] = T.TransformPosition(P - BasisY * RCenter);
|
|
|
|
// Bottom ring
|
|
Points[AddedPoints + 10] = T.TransformPosition(P + BasisX * R1 - BasisZ * H);
|
|
Points[AddedPoints + 11] = T.TransformPosition(P - BasisX * R1 - BasisZ * H);
|
|
Points[AddedPoints + 12] = T.TransformPosition(P + BasisY * R1 - BasisZ * H);
|
|
Points[AddedPoints + 13] = T.TransformPosition(P - BasisY * R1 - BasisZ * H);
|
|
}
|
|
|
|
const int32 ConvexCount = Body->GetConvexCount(B);
|
|
for (int32 I = 0; I < ConvexCount; ++I)
|
|
{
|
|
|
|
TArrayView<const FVector3f> VerticesView;
|
|
TArrayView<const int32> IndicesView;
|
|
FTransform3f ConvexT;
|
|
|
|
Body->GetConvex(B, I, VerticesView, IndicesView, ConvexT);
|
|
|
|
ConvexT = T * ConvexT;
|
|
for (const FVector3f& P : VerticesView)
|
|
{
|
|
Points[AddedPoints++] = ConvexT.TransformPosition(P);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TArray<FReshapePointBindingData>& PhysicsBodyBindData = ReturnValue.Get<0>();
|
|
PhysicsBodyBindData.SetNumUninitialized(TotalNumPoints);
|
|
|
|
FReshapeVertexBindingData VertexBindData;
|
|
|
|
for (int32 PointIndex = 0; PointIndex < TotalNumPoints; ++PointIndex)
|
|
{
|
|
constexpr float MaskWeight = 1.0f;
|
|
BindReshapePoint(ShapeMeshTree, Points[PointIndex], FVector3f::ZAxisVector, MaskWeight, VertexBindData, 0.1f);
|
|
PhysicsBodyBindData[PointIndex] = FReshapePointBindingData
|
|
{ VertexBindData.S, VertexBindData.T, VertexBindData.D, VertexBindData.Triangle, VertexBindData.Weight };
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
inline TArray<FReshapeVertexBindingData> BindVerticesReshape(
|
|
const FMesh* BaseMesh, FShapeMeshTree& ShapeMeshTree, const FMeshBindColorChannelUsageMasks& ColorUsageMasks)
|
|
{
|
|
|
|
UE::Geometry::FAxisAlignedBox3d ShapeAABBox = ShapeMeshTree.GetBoundingBox();
|
|
|
|
const float BindValidityTolerance = ShapeAABBox.MaxDim() < 1.0
|
|
? UE_KINDA_SMALL_NUMBER
|
|
: static_cast<float>(ShapeAABBox.MaxDim()) * 1e-3f;
|
|
|
|
TArray<TArray<int32>> VertexClusters;
|
|
int32 NonRigidClusterIdx = -1;
|
|
|
|
if (ColorUsageMasks.ClusterId != 0)
|
|
{
|
|
FindRigidClusters(BaseMesh, ColorUsageMasks, VertexClusters, NonRigidClusterIdx);
|
|
}
|
|
|
|
// Find nearest shape triangle for each base mesh vertex
|
|
const int32 MeshVertexCount = BaseMesh->GetVertexCount();
|
|
TArray<FReshapeVertexBindingData> BindData;
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(Project);
|
|
|
|
BindData.SetNum(MeshVertexCount);
|
|
|
|
const UntypedMeshBufferIteratorConst ItPositionBase(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
const UntypedMeshBufferIteratorConst ItNormalBase(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Normal);
|
|
|
|
// Disable vertex color reads if the color is not used for mask weights.
|
|
const UntypedMeshBufferIteratorConst ItColorBase = ColorUsageMasks.MaskWeight == 0
|
|
? UntypedMeshBufferIteratorConst()
|
|
: UntypedMeshBufferIteratorConst(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Color);
|
|
|
|
// Special case for non rigid parts
|
|
|
|
// This indicates that we don't care about rigid parts,
|
|
// only one clusters is found or there is no cluster data or rigid parts is disabled.
|
|
if (NonRigidClusterIdx < 0)
|
|
{
|
|
const int32 VertexCount = BaseMesh->GetVertexCount();
|
|
for (int32 VertexIndex = 0; VertexIndex < VertexCount; ++VertexIndex)
|
|
{
|
|
const FVector3f VertexPosition = (ItPositionBase + VertexIndex).GetAsVec3f();
|
|
const FVector3f VertexNormal = ItNormalBase.ptr() ? (ItNormalBase + VertexIndex).GetAsVec3f() : FVector3f::ZAxisVector;
|
|
const float MaskWeight = ItColorBase.ptr() ? GetVertexMaskWeight(ItColorBase + VertexIndex, ColorUsageMasks) : 1.0f;
|
|
|
|
BindReshapePoint(ShapeMeshTree, VertexPosition, VertexNormal, MaskWeight, BindData[VertexIndex], BindValidityTolerance);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TArray<int32>& NonRigidCluster = VertexClusters[NonRigidClusterIdx];
|
|
const int32 NonRigidVertexCount = NonRigidCluster.Num();
|
|
|
|
for (int32 I = 0; I < NonRigidVertexCount; ++I)
|
|
{
|
|
const int32 VertexIndex = NonRigidCluster[I];
|
|
const FVector3f VertexPosition = (ItPositionBase + VertexIndex).GetAsVec3f();
|
|
const FVector3f VertexNormal = ItNormalBase.ptr() ? (ItNormalBase + VertexIndex).GetAsVec3f() : FVector3f::ZAxisVector;
|
|
const float MaskWeight = ItColorBase.ptr() ? GetVertexMaskWeight(ItColorBase + VertexIndex, ColorUsageMasks) : 1.0f;
|
|
|
|
BindReshapePoint(ShapeMeshTree, VertexPosition, VertexNormal, MaskWeight, BindData[VertexIndex], BindValidityTolerance);
|
|
}
|
|
|
|
// Remove data form the non rigid cluster so it ios not processed in the rigid parts binding step.
|
|
NonRigidCluster.Reset();
|
|
|
|
for (const TArray<int32>& RigidCluster : VertexClusters)
|
|
{
|
|
FReshapeVertexBindingData ClusterBinding;
|
|
|
|
const int32 ClusterVertexCount = RigidCluster.Num();
|
|
if (ClusterVertexCount)
|
|
{
|
|
FindBindingForCluster(BaseMesh, ShapeMeshTree, RigidCluster, ClusterBinding, BindValidityTolerance);
|
|
// Copy cluster binding to every vertex of the cluster modifing weight if the vertex color is used.
|
|
for (int32 I = 0; I < ClusterVertexCount; ++I)
|
|
{
|
|
const int32 VertexIndex = RigidCluster[I];
|
|
|
|
const float MaskWeight = ItColorBase.ptr() ? GetVertexMaskWeight(ItColorBase + VertexIndex, ColorUsageMasks) : 1.0f;
|
|
|
|
ClusterBinding.Weight = FMath::Min(ClusterBinding.Weight, MaskWeight);
|
|
// Invalidate binding for very small weights.
|
|
ClusterBinding.Triangle = FMath::IsNearlyZero(ClusterBinding.Weight) ? -1 : ClusterBinding.Triangle;
|
|
|
|
BindData[VertexIndex] = ClusterBinding;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return BindData;
|
|
}
|
|
|
|
inline void GenerateAndAddLaplacianData(FMesh& InOutMesh)
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(GenerateLaplacianData);
|
|
|
|
|
|
// Storage for buffers in a format different than the supported one.
|
|
// Not used if the buffer data is compatible. The data will always be accessed using a
|
|
// view regardless of compatibility.
|
|
TArray<FVector3f> ConvertedVerticesStorage;
|
|
TArray<uint32> ConvertedIndicesStorage;
|
|
|
|
TArrayView<const FVector3f> VerticesView;
|
|
{
|
|
const UntypedMeshBufferIteratorConst PositionBegin(InOutMesh.GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
const int32 NumVertices = InOutMesh.GetVertexBuffers().GetElementCount();
|
|
|
|
const bool bIsCompatibleBuffer =
|
|
PositionBegin.GetElementSize() == sizeof(FVector3f) &&
|
|
PositionBegin.GetFormat() == EMeshBufferFormat::Float32 &&
|
|
PositionBegin.GetComponents() == 3;
|
|
|
|
const bool bIsAlignmentGood = reinterpret_cast<UPTRINT>(PositionBegin.ptr()) % alignof(FVector3f) == 0;
|
|
|
|
if (!bIsCompatibleBuffer || !bIsAlignmentGood)
|
|
{
|
|
ConvertedVerticesStorage.SetNumUninitialized(NumVertices);
|
|
|
|
for (int32 VertexIndex = 0; VertexIndex < NumVertices; ++VertexIndex)
|
|
{
|
|
ConvertedVerticesStorage[VertexIndex] = (PositionBegin + VertexIndex).GetAsVec3f();
|
|
}
|
|
|
|
VerticesView = TArrayView<const FVector3f>(ConvertedVerticesStorage.GetData(), NumVertices);
|
|
}
|
|
else
|
|
{
|
|
VerticesView = TArrayView<const FVector3f>(reinterpret_cast<const FVector3f*>(PositionBegin.ptr()), NumVertices);
|
|
}
|
|
}
|
|
|
|
TArrayView<const uint32> IndicesView;
|
|
{
|
|
const UntypedMeshBufferIteratorConst IndicesBegin(InOutMesh.GetIndexBuffers(), EMeshBufferSemantic::VertexIndex);
|
|
const int32 NumIndices = InOutMesh.GetIndexBuffers().GetElementCount();
|
|
|
|
const bool bIsCompatibleBuffer =
|
|
IndicesBegin.GetElementSize() == sizeof(uint32) &&
|
|
IndicesBegin.GetFormat() == EMeshBufferFormat::UInt32 &&
|
|
IndicesBegin.GetComponents() == 1;
|
|
|
|
const bool bIsAlignmentGood = reinterpret_cast<UPTRINT>(IndicesBegin.ptr()) % alignof(uint32) == 0;
|
|
|
|
if (!bIsCompatibleBuffer || !bIsAlignmentGood)
|
|
{
|
|
ConvertedIndicesStorage.SetNumUninitialized(NumIndices);
|
|
for (int32 I = 0; I < NumIndices; ++I)
|
|
{
|
|
ConvertedIndicesStorage[I] = (IndicesBegin + I).GetAsUINT32();
|
|
}
|
|
|
|
IndicesView = TArrayView<uint32>(ConvertedIndicesStorage.GetData(), ConvertedIndicesStorage.Num());
|
|
}
|
|
else
|
|
{
|
|
IndicesView = TArrayView<const uint32>(reinterpret_cast<const uint32*>(IndicesBegin.ptr()), NumIndices);
|
|
}
|
|
}
|
|
|
|
TArray<int32> UniqueVertexMap = MakeUniqueVertexMap(VerticesView);
|
|
TArray<TArray<int32, TInlineAllocator<8>>> VertexFaces = BuildVertexFaces(IndicesView, UniqueVertexMap);
|
|
TMap<uint64, UE::Geometry::FIndex2i> EdgesFaces = BuildEdgesFaces(IndicesView, UniqueVertexMap);
|
|
|
|
TArray<int32> VertexRingsOffsets;
|
|
TArray<int32> VertexRingsData;
|
|
Tie(VertexRingsOffsets, VertexRingsData) = BuildVertexRings(IndicesView, UniqueVertexMap, VertexFaces, EdgesFaces);
|
|
|
|
FMeshBufferSet MeshLaplacianOffsetsBuffer;
|
|
MeshLaplacianOffsetsBuffer.SetBufferCount(1);
|
|
MeshLaplacianOffsetsBuffer.SetElementCount(VertexRingsOffsets.Num());
|
|
|
|
FMeshBufferSet MeshLaplacianDataBuffer;
|
|
MeshLaplacianDataBuffer.SetBufferCount(1);
|
|
MeshLaplacianDataBuffer.SetElementCount(VertexRingsData.Num());
|
|
|
|
// Don't add this to the vertex buffer set for now, it is currently only used for Laplacian smoothing a and it is removed
|
|
// right away after use.
|
|
FMeshBufferSet UniqueVertexMapBuffer;
|
|
UniqueVertexMapBuffer.SetBufferCount(1);
|
|
UniqueVertexMapBuffer.SetElementCount(UniqueVertexMap.Num());
|
|
|
|
const FIntBufferDescriptor BufDesc;
|
|
MeshLaplacianOffsetsBuffer.SetBuffer(0, BufDesc.ElementSize, BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components);
|
|
MeshLaplacianDataBuffer.SetBuffer(0, BufDesc.ElementSize, BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components);
|
|
UniqueVertexMapBuffer.SetBuffer(0, BufDesc.ElementSize, BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components);
|
|
|
|
// TODO: Add a way for buffers to steal memory from temporaries, so we can avoid a copy here.
|
|
FMemory::Memcpy(
|
|
UniqueVertexMapBuffer.GetBufferData(0),
|
|
UniqueVertexMap.GetData(),
|
|
UniqueVertexMapBuffer.GetDataSize());
|
|
|
|
FMemory::Memcpy(
|
|
MeshLaplacianOffsetsBuffer.GetBufferData(0),
|
|
VertexRingsOffsets.GetData(),
|
|
MeshLaplacianOffsetsBuffer.GetDataSize());
|
|
|
|
FMemory::Memcpy(
|
|
MeshLaplacianDataBuffer.GetBufferData(0),
|
|
VertexRingsData.GetData(),
|
|
MeshLaplacianDataBuffer.GetDataSize());
|
|
|
|
InOutMesh.AdditionalBuffers.Emplace(EMeshBufferType::UniqueVertexMap, MoveTemp(UniqueVertexMapBuffer));
|
|
InOutMesh.AdditionalBuffers.Emplace(EMeshBufferType::MeshLaplacianOffsets, MoveTemp(MeshLaplacianOffsetsBuffer));
|
|
InOutMesh.AdditionalBuffers.Emplace(EMeshBufferType::MeshLaplacianData, MoveTemp(MeshLaplacianDataBuffer));
|
|
}
|
|
|
|
|
|
inline TTuple<TArray<FReshapePointBindingData>, TArray<int32>> BindPose(
|
|
const FMesh* Mesh, FShapeMeshTree& ShapeMeshTree, const TArray<FBoneName>& BonesToDeform )
|
|
{
|
|
UE::Geometry::FAxisAlignedBox3d ShapeAABBox = ShapeMeshTree.GetBoundingBox();
|
|
|
|
const float BindValidityTolerance = ShapeAABBox.MaxDim() < 1.0
|
|
? UE_KINDA_SMALL_NUMBER
|
|
: static_cast<float>(ShapeAABBox.MaxDim()) * 1e-3f;
|
|
|
|
TTuple<TArray<FReshapePointBindingData>, TArray<int32>> ReturnValue;
|
|
|
|
TArray<FReshapePointBindingData>& SkeletonBindDataArray = ReturnValue.Get<0>();
|
|
TArray<int32>& BoneIndices = ReturnValue.Get<1>();
|
|
|
|
const int32 BoneCount = Mesh->GetBonePoseCount();
|
|
SkeletonBindDataArray.Reserve(BoneCount);
|
|
BoneIndices.Reserve(BoneCount);
|
|
|
|
for (int32 BoneIndex = 0; BoneIndex < BoneCount; ++BoneIndex)
|
|
{
|
|
const EBoneUsageFlags BoneUsageFlags = Mesh->BonePoses[BoneIndex].BoneUsageFlags;
|
|
|
|
if (EnumHasAnyFlags(BoneUsageFlags, EBoneUsageFlags::Root))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!BonesToDeform.Contains(Mesh->BonePoses[BoneIndex].BoneId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FReshapeVertexBindingData BindData;
|
|
constexpr float MaskWeight = 1.0f;
|
|
BindReshapePoint(ShapeMeshTree, Mesh->BonePoses[BoneIndex].BoneTransform.GetLocation(), FVector3f::ZAxisVector, MaskWeight, BindData, BindValidityTolerance);
|
|
|
|
// Only add binding if there is a chance of the bone moving.
|
|
if (BindData.Weight > UE_SMALL_NUMBER && BindData.Triangle >= 0)
|
|
{
|
|
SkeletonBindDataArray.Emplace(
|
|
FReshapePointBindingData{ BindData.S, BindData.T, BindData.D, BindData.Triangle, BindData.Weight });
|
|
BoneIndices.Add(BoneIndex);
|
|
}
|
|
}
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
inline FMeshBindColorChannelUsageMasks MakeColorChannelUsageMasks(FMeshBindColorChannelUsages Usages)
|
|
{
|
|
FMeshBindColorChannelUsageMasks Masks;
|
|
|
|
// We assume the color will have the FColor layout
|
|
Masks.MaskWeight =
|
|
(Usages.B == EMeshBindColorChannelUsage::MaskWeight ? 0x000000FF : 0) |
|
|
(Usages.G == EMeshBindColorChannelUsage::MaskWeight ? 0x0000FF00 : 0) |
|
|
(Usages.R == EMeshBindColorChannelUsage::MaskWeight ? 0x00FF0000 : 0) |
|
|
(Usages.A == EMeshBindColorChannelUsage::MaskWeight ? 0xFF000000 : 0);
|
|
|
|
Masks.ClusterId =
|
|
(Usages.B == EMeshBindColorChannelUsage::ClusterId ? 0x000000FF : 0) |
|
|
(Usages.G == EMeshBindColorChannelUsage::ClusterId ? 0x0000FF00 : 0) |
|
|
(Usages.R == EMeshBindColorChannelUsage::ClusterId ? 0x00FF0000 : 0) |
|
|
(Usages.A == EMeshBindColorChannelUsage::ClusterId ? 0xFF000000 : 0);
|
|
|
|
// Maximum one weight channel.
|
|
check(Masks.MaskWeight == 0 ||
|
|
FMath::CountLeadingZeros(Masks.MaskWeight) + FMath::CountTrailingZeros(Masks.MaskWeight) == 32 - 8);
|
|
|
|
// No overlaped channels.
|
|
check((Masks.ClusterId & Masks.MaskWeight) == 0);
|
|
|
|
return Masks;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//! Generate the mesh-shape binding data
|
|
//---------------------------------------------------------------------------------------------
|
|
inline void MeshBindShapeReshape(
|
|
FMesh* Result,
|
|
const FMesh* BaseMesh, const FMesh* ShapeMesh,
|
|
const TArray<FBoneName>& BonesToDeform, const TArray<FBoneName>& PhysicsToDeform,
|
|
EMeshBindShapeFlags BindFlags, FMeshBindColorChannelUsages ColorChannelUsages,
|
|
bool& bOutSuccess)
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(MeshBindShape);
|
|
bOutSuccess = true;
|
|
|
|
if (!BaseMesh)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
const bool bReshapeVertices = EnumHasAnyFlags(BindFlags, EMeshBindShapeFlags::ReshapeVertices);
|
|
// TODO: For now bRecomputeNormals is not used when binding, we could skip normal morph data generation.
|
|
const bool bRecomputeNormals = EnumHasAnyFlags(BindFlags, EMeshBindShapeFlags::RecomputeNormals);
|
|
const bool bApplyLaplacian = EnumHasAnyFlags(BindFlags, EMeshBindShapeFlags::ApplyLaplacian);
|
|
const bool bReshapeSkeleton = EnumHasAnyFlags(BindFlags, EMeshBindShapeFlags::ReshapeSkeleton);
|
|
const bool bReshapePhysics = EnumHasAnyFlags(BindFlags, EMeshBindShapeFlags::ReshapePhysicsVolumes);
|
|
|
|
const FMeshBindColorChannelUsageMasks ColorUsagesMasks = MakeColorChannelUsageMasks(ColorChannelUsages);
|
|
|
|
// Early out if nothing will be modified and the vertices discarted. return null in this
|
|
// case indicating nothing has modified so the Base Mesh can be reused.
|
|
const bool bSkeletonModification = BaseMesh->GetSkeleton() && bReshapeSkeleton;
|
|
const bool bPhysicsModification = (BaseMesh->GetPhysicsBody() || BaseMesh->AdditionalPhysicsBodies.Num()) && bReshapePhysics;
|
|
|
|
if (!bReshapeVertices && !bSkeletonModification && !bPhysicsModification)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
if (!ShapeMesh)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
int32 ShapeVertexCount = ShapeMesh->GetVertexCount();
|
|
int32 ShapeTriangleCount = ShapeMesh->GetFaceCount();
|
|
if (!ShapeVertexCount || !ShapeTriangleCount)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
FShapeMeshDescriptorBind ShapeMeshDescriptor;
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(GenerateVertexQueryData);
|
|
|
|
ShapeMeshDescriptor.Positions.SetNum(ShapeVertexCount);
|
|
ShapeMeshDescriptor.Normals.SetNum(ShapeVertexCount);
|
|
|
|
// \TODO: Simple but inefficient
|
|
const UntypedMeshBufferIteratorConst ItPosition(ShapeMesh->GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
const UntypedMeshBufferIteratorConst ItNormal(ShapeMesh->GetVertexBuffers(), EMeshBufferSemantic::Normal);
|
|
for (int32 ShapeVertexIndex = 0; ShapeVertexIndex < ShapeVertexCount; ++ShapeVertexIndex)
|
|
{
|
|
FVector3f Position = (ItPosition + ShapeVertexIndex).GetAsVec3f();
|
|
ShapeMeshDescriptor.Positions[ShapeVertexIndex] = static_cast<FVector3d>(Position);
|
|
|
|
FVector3f Normal = (ItNormal + ShapeVertexIndex).GetAsVec3f();
|
|
ShapeMeshDescriptor.Normals[ShapeVertexIndex] = Normal;
|
|
}
|
|
}
|
|
// Generate the temp face query data for the shape
|
|
// TODO: Index data copy may be saved in most cases.
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(GenerateTrianglesQueryData);
|
|
ShapeMeshDescriptor.Triangles.SetNum(ShapeTriangleCount);
|
|
// \TODO: Simple but inefficient
|
|
const UntypedMeshBufferIteratorConst ItIndices(ShapeMesh->GetIndexBuffers(), EMeshBufferSemantic::VertexIndex);
|
|
for (int32 TriangleIndex = 0; TriangleIndex < ShapeTriangleCount; ++TriangleIndex)
|
|
{
|
|
UE::Geometry::FIndex3i Triangle;
|
|
Triangle.A = int32((ItIndices + TriangleIndex*3 + 0).GetAsUINT32());
|
|
Triangle.B = int32((ItIndices + TriangleIndex*3 + 1).GetAsUINT32());
|
|
Triangle.C = int32((ItIndices + TriangleIndex*3 + 2).GetAsUINT32());
|
|
|
|
ShapeMeshDescriptor.Triangles[TriangleIndex] = Triangle;
|
|
}
|
|
}
|
|
|
|
FShapeMeshAdapter ShapeMeshAdapter(ShapeMeshDescriptor);
|
|
|
|
constexpr bool bAutoBuildTree = false;
|
|
FShapeMeshTree ShapeMeshTree(&ShapeMeshAdapter, bAutoBuildTree);
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(BuildShapeTree);
|
|
|
|
ShapeMeshTree.Build();
|
|
}
|
|
|
|
// If no vertices are needed, it is assumed we only want to reshape physics or skeleton.
|
|
// In that case, remove everything except physics bodies, the skeleton and pose.
|
|
if (!bReshapeVertices)
|
|
{
|
|
constexpr EMeshCopyFlags CopyFlags =
|
|
EMeshCopyFlags::WithSkeleton |
|
|
EMeshCopyFlags::WithPhysicsBody |
|
|
EMeshCopyFlags::WithPoses |
|
|
EMeshCopyFlags::WithAdditionalPhysics;
|
|
|
|
Result->CopyFrom(*BaseMesh, CopyFlags);
|
|
}
|
|
else
|
|
{
|
|
Result->CopyFrom(*BaseMesh);
|
|
}
|
|
|
|
int32 BindingDataIndex = 0;
|
|
if (bReshapeVertices)
|
|
{
|
|
TArray<FReshapeVertexBindingData> VerticesBindData = BindVerticesReshape(BaseMesh, ShapeMeshTree, ColorUsagesMasks);
|
|
|
|
// Add the binding information to the mesh
|
|
// \TODO: Check that there is no other binding data.
|
|
// \TODO: Support specifying the binding data channel for multiple binding support.
|
|
FMeshBufferSet& VB = Result->GetVertexBuffers();
|
|
int32 NewBufferIndex = VB.GetBufferCount();
|
|
VB.SetBufferCount(NewBufferIndex + 1);
|
|
|
|
FReshapeVertexBindingDataBufferDescriptor BufDesc(BindingDataIndex);
|
|
VB.SetBuffer(NewBufferIndex, sizeof(FReshapeVertexBindingData), BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components);
|
|
FMemory::Memcpy(VB.GetBufferData(NewBufferIndex), VerticesBindData.GetData(), VerticesBindData.Num() * sizeof(FReshapeVertexBindingData));
|
|
|
|
if (bApplyLaplacian)
|
|
{
|
|
GenerateAndAddLaplacianData(*Result);
|
|
}
|
|
}
|
|
|
|
// Bind the skeleton bones
|
|
// \TODO: Build bind data only for actually modified bones?
|
|
if (bReshapeSkeleton && BonesToDeform.Num())
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(BindSkeleton);
|
|
|
|
TTuple<TArray<FReshapePointBindingData>, TArray<int32>> SkeletonBindingData =
|
|
BindPose(Result, ShapeMeshTree, BonesToDeform);
|
|
const TArray<FReshapePointBindingData>& SkeletonBindDataArray = SkeletonBindingData.Get<0>();
|
|
const TArray<int32>& BoneIndices = SkeletonBindingData.Get<1>();
|
|
|
|
check(BoneIndices.Num() == SkeletonBindDataArray.Num());
|
|
|
|
const int32 NumBonesToDeform = SkeletonBindDataArray.Num();
|
|
|
|
FMeshBufferSet SkeletonBuffer;
|
|
SkeletonBuffer.SetBufferCount(2);
|
|
SkeletonBuffer.SetElementCount(SkeletonBindDataArray.Num());
|
|
|
|
FReshapePointBindingDataBufferDescriptor BufDesc(BindingDataIndex);
|
|
SkeletonBuffer.SetBuffer(0, sizeof(FReshapePointBindingData), BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components);
|
|
|
|
// Bone indices buffer
|
|
EMeshBufferSemantic BoneSemantics[1] = { EMeshBufferSemantic::Other };
|
|
EMeshBufferFormat BoneFormats[1] = { EMeshBufferFormat::Int32 };
|
|
int32 BoneSemanticIndices[1] = { 0 };
|
|
int32 BoneComponents[1] = { 1 };
|
|
int32 BoneOffsets[1] = { 0 };
|
|
|
|
SkeletonBuffer.SetBuffer(1, sizeof(int32), 1, BoneSemantics, BoneSemanticIndices, BoneFormats, BoneComponents, BoneOffsets);
|
|
|
|
FMemory::Memcpy(SkeletonBuffer.GetBufferData(0), SkeletonBindDataArray.GetData(), NumBonesToDeform * sizeof(FReshapePointBindingData));
|
|
FMemory::Memcpy(SkeletonBuffer.GetBufferData(1), BoneIndices.GetData(), NumBonesToDeform * sizeof(int32));
|
|
|
|
Result->AdditionalBuffers.Emplace(EMeshBufferType::SkeletonDeformBinding, MoveTemp(SkeletonBuffer));
|
|
}
|
|
|
|
const FPhysicsBody* ResultPhysicsBody = Result->PhysicsBody.Get();
|
|
if (bReshapePhysics && (ResultPhysicsBody || Result->AdditionalPhysicsBodies.Num()) && PhysicsToDeform.Num())
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(BindPhysicsBody);
|
|
|
|
// Gather bodies respecting order, firts main physics body then additional bodies.
|
|
// Null entries are need to be able to mantin that order.
|
|
TArray<const FPhysicsBody*> PhysicsBodiesToBind;
|
|
{
|
|
PhysicsBodiesToBind.Reserve(Result->AdditionalPhysicsBodies.Num() + 1);
|
|
|
|
PhysicsBodiesToBind.Add(ResultPhysicsBody);
|
|
for (const TSharedPtr<const FPhysicsBody>& Body : Result->AdditionalPhysicsBodies)
|
|
{
|
|
PhysicsBodiesToBind.Add(Body.Get());
|
|
}
|
|
}
|
|
|
|
TTuple<TArray<FReshapePointBindingData>, TArray<int32>, TArray<int32>> PhysicsBindingData =
|
|
BindPhysicsBodies(PhysicsBodiesToBind, ShapeMeshTree, Result, PhysicsToDeform);
|
|
|
|
const TArray<FReshapePointBindingData>& PhysicsBindDataArray = PhysicsBindingData.Get<0>();
|
|
const TArray<int32>& DeformedBodyIndices = PhysicsBindingData.Get<1>();
|
|
const TArray<int32>& DeformedBodyIndicesOffsets = PhysicsBindingData.Get<2>();
|
|
|
|
FMeshBufferSet PhysicsBodyBuffer;
|
|
PhysicsBodyBuffer.SetBufferCount(1);
|
|
PhysicsBodyBuffer.SetElementCount(PhysicsBindDataArray.Num());
|
|
|
|
constexpr int32 BindDataIndex = 0;
|
|
FReshapePointBindingDataBufferDescriptor BufDesc(BindingDataIndex);
|
|
PhysicsBodyBuffer.SetBuffer(0, sizeof(FReshapePointBindingData), BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components, BufDesc.Offsets);
|
|
FMemory::Memcpy(PhysicsBodyBuffer.GetBufferData(0), PhysicsBindDataArray.GetData(), PhysicsBindDataArray.Num() * sizeof(FReshapePointBindingData));
|
|
|
|
FIntBufferDescriptor IntBufDesc;
|
|
|
|
FMeshBufferSet PhysicsBodySelectionBuffer;
|
|
PhysicsBodySelectionBuffer.SetBufferCount(1);
|
|
PhysicsBodySelectionBuffer.SetElementCount(DeformedBodyIndices.Num());
|
|
PhysicsBodySelectionBuffer.SetBuffer(0, sizeof(int32), IntBufDesc.Channels, IntBufDesc.Semantics, IntBufDesc.SemanticIndices, IntBufDesc.Formats, IntBufDesc.Components, IntBufDesc.Offsets);
|
|
FMemory::Memcpy(PhysicsBodySelectionBuffer.GetBufferData(0), DeformedBodyIndices.GetData(), DeformedBodyIndices.Num() * sizeof(int32));
|
|
|
|
FMeshBufferSet PhysicsBodySelectionOffsetsBuffer;
|
|
PhysicsBodySelectionOffsetsBuffer.SetBufferCount(1);
|
|
PhysicsBodySelectionOffsetsBuffer.SetElementCount(DeformedBodyIndicesOffsets.Num());
|
|
PhysicsBodySelectionOffsetsBuffer.SetBuffer(0, sizeof(int32), IntBufDesc.Channels, IntBufDesc.Semantics, IntBufDesc.SemanticIndices, IntBufDesc.Formats, IntBufDesc.Components, IntBufDesc.Offsets);
|
|
FMemory::Memcpy(PhysicsBodySelectionOffsetsBuffer.GetBufferData(0), DeformedBodyIndicesOffsets.GetData(), DeformedBodyIndicesOffsets.Num() * sizeof(int32));
|
|
|
|
Result->AdditionalBuffers.Emplace(EMeshBufferType::PhysicsBodyDeformBinding, MoveTemp(PhysicsBodyBuffer));
|
|
Result->AdditionalBuffers.Emplace(EMeshBufferType::PhysicsBodyDeformSelection, MoveTemp(PhysicsBodySelectionBuffer));
|
|
Result->AdditionalBuffers.Emplace(EMeshBufferType::PhysicsBodyDeformOffsets, MoveTemp(PhysicsBodySelectionOffsetsBuffer));
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------
|
|
//! Generate the mesh-shape binding data for ClipDeform operations
|
|
//---------------------------------------------------------------------------------------------
|
|
inline void BindClipDeformPointClosestProject(
|
|
FShapeMeshTree& ShapeMeshTree,
|
|
const FVector3f& Point, FClipDeformVertexBindingData& OutBindData, float ValidityTolerance )
|
|
{
|
|
const FShapeMeshDescriptorBind& ShapeMesh = ShapeMeshTree.GetMesh()->Mesh;
|
|
|
|
OutBindData.S = 0.0f;
|
|
OutBindData.T = 0.0f;
|
|
OutBindData.Weight = 0.0f;
|
|
OutBindData.Triangle = -1;
|
|
|
|
double DistSqr = 0.0;
|
|
|
|
int32 FoundIndex = ShapeMeshTree.FindNearestTriangle( FVector3d(Point), DistSqr );
|
|
|
|
if (FoundIndex < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Calculate the binding data of the base mesh vertex to its bound shape triangle
|
|
UE::Geometry::FIndex3i TriangleIndices = ShapeMesh.Triangles[FoundIndex];
|
|
|
|
// Project on the triangle, but using the vertex normals.
|
|
// See reference implementation for details.
|
|
UE::Geometry::FTriangle3f ShapeTriangle {
|
|
(FVector3f)ShapeMesh.Positions[TriangleIndices.A],
|
|
(FVector3f)ShapeMesh.Positions[TriangleIndices.B],
|
|
(FVector3f)ShapeMesh.Positions[TriangleIndices.C] };
|
|
|
|
const FVector3f ShapeTriangleNormal = ShapeTriangle.Normal();
|
|
const FPlane4f VertexPlane(Point, ShapeTriangleNormal);
|
|
|
|
const UE::Geometry::FTriangle3f TriangleVertexPlane {
|
|
FMath::RayPlaneIntersection(ShapeTriangle.V[0], ShapeMesh.Normals[TriangleIndices.A], VertexPlane),
|
|
FMath::RayPlaneIntersection(ShapeTriangle.V[1], ShapeMesh.Normals[TriangleIndices.B], VertexPlane),
|
|
FMath::RayPlaneIntersection(ShapeTriangle.V[2], ShapeMesh.Normals[TriangleIndices.C], VertexPlane) };
|
|
|
|
FVector3f Barycentric = TriangleVertexPlane.GetBarycentricCoords(Point);
|
|
|
|
FVector3f InterpolatedShapeNormal =
|
|
ShapeMesh.Normals[TriangleIndices.A] * Barycentric.X +
|
|
ShapeMesh.Normals[TriangleIndices.B] * Barycentric.Y +
|
|
ShapeMesh.Normals[TriangleIndices.C] * Barycentric.Z;
|
|
|
|
FVector3f BindPoint = ShapeTriangle.BarycentricPoint(Barycentric);
|
|
FVector3f ProjectedToVertex = (Point - BindPoint);
|
|
|
|
// Compute reprojection value to see if the binding is valid.
|
|
const float InterpolatedNormalSizeSquared = InterpolatedShapeNormal.SizeSquared();
|
|
const float InvInterpolatedNormalSizeSquared = InterpolatedNormalSizeSquared > SMALL_NUMBER ? 1.0f / InterpolatedNormalSizeSquared : 0.0f;
|
|
float D = FVector3f::DotProduct(ProjectedToVertex, InterpolatedShapeNormal) * InvInterpolatedNormalSizeSquared;
|
|
|
|
const FVector3f ReprojectedPoint = BindPoint + InterpolatedShapeNormal * D;
|
|
|
|
const FVector3f ReprojectedVector = ReprojectedPoint - Point;
|
|
const float ErrorEstimate = (ReprojectedPoint - Point).GetAbsMax();
|
|
|
|
// If within the tolerance, 1.0, otherwise linear falloff based on the tolerance
|
|
|
|
// Arbitrary factor, a binding will be considered valid (with its corresponding weight) to ErrorFalloffFactor times the validity tolerance.
|
|
constexpr float ErrorFalloffFactor = 4.0f;
|
|
OutBindData.Weight = 1.0f - FMath::Clamp( (ErrorEstimate - ValidityTolerance) / (ValidityTolerance * ErrorFalloffFactor), 0.0f, 1.0f);
|
|
|
|
OutBindData.S = Barycentric.Y;
|
|
OutBindData.T = Barycentric.Z;
|
|
|
|
// Only move points that bind outside the shape.
|
|
OutBindData.Triangle = FVector3f::DotProduct(ShapeTriangleNormal, Point - BindPoint) < 0 ? -1 : FoundIndex;
|
|
}
|
|
|
|
inline void BindClipDeformPointClosestToSurface(
|
|
const FShapeMeshTree& ShapeMeshTree,
|
|
const FVector3f& Point, FClipDeformVertexBindingData& OutBindData)
|
|
{
|
|
const FShapeMeshDescriptorBind& ShapeMesh = ShapeMeshTree.GetMesh()->Mesh;
|
|
|
|
OutBindData.S = 0.0f;
|
|
OutBindData.T = 0.0f;
|
|
OutBindData.Weight = 1.0f;
|
|
OutBindData.Triangle = -1;
|
|
|
|
const FVector3d P = FVector3d(Point);
|
|
|
|
double DistSqr = 0;
|
|
int32 FoundTriIndex = ShapeMeshTree.FindNearestTriangle(P, DistSqr);
|
|
|
|
if (FoundTriIndex < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
check( FoundTriIndex >= 0);
|
|
|
|
UE::Geometry::FIndex3i Triangle = ShapeMesh.Triangles[FoundTriIndex];
|
|
UE::Geometry::FTriangle3d NearestShapeTriangle {
|
|
ShapeMesh.Positions[Triangle.A],
|
|
ShapeMesh.Positions[Triangle.B],
|
|
ShapeMesh.Positions[Triangle.C] };
|
|
|
|
UE::Geometry::FDistPoint3Triangle3d Dist(P, NearestShapeTriangle);
|
|
Dist.ComputeResult();
|
|
|
|
const FVector3d BindPoint = NearestShapeTriangle.BarycentricPoint(Dist.TriangleBaryCoords);
|
|
|
|
OutBindData.S = float(Dist.TriangleBaryCoords.Y);
|
|
OutBindData.T = float(Dist.TriangleBaryCoords.Z);
|
|
|
|
// Only move points that bind outside the shape.
|
|
OutBindData.Triangle = FVector3d::DotProduct(NearestShapeTriangle.Normal(), P - BindPoint) < 0 ? -1 : FoundTriIndex;
|
|
}
|
|
|
|
inline void BindClipDeformPointNormalProject(
|
|
const FShapeMeshTree& ShapeMeshTree,
|
|
const FVector3f& Point, const FVector3f& Normal, FClipDeformVertexBindingData& OutBindData)
|
|
{
|
|
const FShapeMeshDescriptorBind& ShapeMesh = ShapeMeshTree.GetMesh()->Mesh;
|
|
|
|
OutBindData.S = 0.0f;
|
|
OutBindData.T = 0.0f;
|
|
OutBindData.Weight = 1.0f;
|
|
OutBindData.Triangle = -1;
|
|
|
|
const FRay3d NormalRay = FRay3d(FVector3d(Point), FVector3d(-Normal));
|
|
double RayHitDist = 0.0;
|
|
FVector3d RayHitBarycenticCoords = FVector3d::ZeroVector;
|
|
int32 TriangleIndex = -1;
|
|
|
|
const bool bHitFound = ShapeMeshTree.FindNearestHitTriangle(NormalRay, RayHitDist, TriangleIndex, RayHitBarycenticCoords);
|
|
|
|
if (!bHitFound || TriangleIndex < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
UE::Geometry::FIndex3i ShapeTriangleIndices = ShapeMesh.Triangles[TriangleIndex];
|
|
UE::Geometry::FTriangle3d HitShapeTriangle {
|
|
ShapeMesh.Positions[ShapeTriangleIndices.A],
|
|
ShapeMesh.Positions[ShapeTriangleIndices.B],
|
|
ShapeMesh.Positions[ShapeTriangleIndices.C] };
|
|
|
|
OutBindData.S = float(RayHitBarycenticCoords.Y);
|
|
OutBindData.T = float(RayHitBarycenticCoords.Z);
|
|
|
|
OutBindData.Triangle = FVector3d::DotProduct(HitShapeTriangle.Normal(), -NormalRay.Direction) < 0 ? -1 : TriangleIndex;
|
|
}
|
|
|
|
inline TArray<FClipDeformVertexBindingData> BindVerticesClipDeform(
|
|
const FMesh* BaseMesh,
|
|
FShapeMeshTree& ShapeMeshTree,
|
|
EShapeBindingMethod BindingMethod )
|
|
{
|
|
UE::Geometry::FAxisAlignedBox3d ShapeAABBox = ShapeMeshTree.GetBoundingBox();
|
|
|
|
const float BindValidityTolerance = ShapeAABBox.MaxDim() < 1.0
|
|
? UE_KINDA_SMALL_NUMBER
|
|
: static_cast<float>(ShapeAABBox.MaxDim()) * 1e-3f;
|
|
|
|
// Find nearest shape triangle for each base mesh vertex
|
|
const int32 MeshVertexCount = BaseMesh->GetVertexCount();
|
|
TArray<FClipDeformVertexBindingData> BindData;
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(ClipDeformBind);
|
|
|
|
BindData.SetNum( MeshVertexCount );
|
|
|
|
UntypedMeshBufferIteratorConst ItPositionBase(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
UntypedMeshBufferIteratorConst ItNormalBase(BaseMesh->GetVertexBuffers(), EMeshBufferSemantic::Normal);
|
|
|
|
EShapeBindingMethod ActualBindingMethod = BindingMethod == EShapeBindingMethod::ClipDeformNormalProject && !ItNormalBase.ptr()
|
|
? EShapeBindingMethod::ClipDeformClosestToSurface
|
|
: BindingMethod;
|
|
|
|
switch ( ActualBindingMethod )
|
|
{
|
|
case EShapeBindingMethod::ClipDeformNormalProject:
|
|
{
|
|
check(ItNormalBase.ptr());
|
|
for (int32 VertexIndex = 0; VertexIndex < MeshVertexCount; ++VertexIndex)
|
|
{
|
|
FVector3f VertexPosition = (ItPositionBase + VertexIndex).GetAsVec3f();
|
|
FVector3f VertexNormal = (ItNormalBase + VertexIndex).GetAsVec3f();
|
|
BindClipDeformPointNormalProject(ShapeMeshTree, VertexPosition, VertexNormal, BindData[VertexIndex]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case EShapeBindingMethod::ClipDeformClosestToSurface:
|
|
{
|
|
for (int32 VertexIndex = 0; VertexIndex < MeshVertexCount; ++VertexIndex)
|
|
{
|
|
FVector3f VertexPosition = (ItPositionBase + VertexIndex).GetAsVec3f();
|
|
BindClipDeformPointClosestToSurface(ShapeMeshTree, VertexPosition, BindData[VertexIndex]);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case EShapeBindingMethod::ClipDeformClosestProject:
|
|
{
|
|
for (int32 VertexIndex = 0; VertexIndex < MeshVertexCount; ++VertexIndex)
|
|
{
|
|
FVector3f VertexPosition = (ItPositionBase + VertexIndex).GetAsVec3f();
|
|
BindClipDeformPointClosestProject(ShapeMeshTree, VertexPosition, BindData[VertexIndex], BindValidityTolerance);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
check(false);
|
|
}
|
|
};
|
|
}
|
|
|
|
return BindData;
|
|
}
|
|
|
|
inline void MeshBindShapeClipDeform(FMesh* Result, const FMesh* BaseMesh, const FMesh* ShapeMesh, EShapeBindingMethod BindingMethod, bool& bOutSuccess)
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(MeshBindShapeClipDeform);
|
|
|
|
bOutSuccess = true;
|
|
|
|
if (!BaseMesh)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
if (!ShapeMesh)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
int32 ShapeVertexCount = ShapeMesh->GetVertexCount();
|
|
int ShapeTriangleCount = ShapeMesh->GetFaceCount();
|
|
if (!ShapeVertexCount || !ShapeTriangleCount)
|
|
{
|
|
bOutSuccess = false;
|
|
return;
|
|
}
|
|
|
|
FShapeMeshDescriptorBind ShapeMeshDescriptor;
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(GenerateVertexQueryData);
|
|
|
|
ShapeMeshDescriptor.Positions.SetNum(ShapeVertexCount);
|
|
ShapeMeshDescriptor.Normals.SetNum(ShapeVertexCount);
|
|
|
|
// \TODO: Simple but inefficient
|
|
UntypedMeshBufferIteratorConst ItPosition(ShapeMesh->GetVertexBuffers(), EMeshBufferSemantic::Position);
|
|
UntypedMeshBufferIteratorConst ItNormal(ShapeMesh->GetVertexBuffers(), EMeshBufferSemantic::Normal);
|
|
for (int32 ShapeVertexIndex = 0; ShapeVertexIndex < ShapeVertexCount; ++ShapeVertexIndex)
|
|
{
|
|
FVector3f Position = (ItPosition + ShapeVertexIndex).GetAsVec3f();
|
|
ShapeMeshDescriptor.Positions[ShapeVertexIndex] = static_cast<FVector3d>(Position);
|
|
|
|
FVector3f Normal = (ItNormal + ShapeVertexIndex).GetAsVec3f();
|
|
ShapeMeshDescriptor.Normals[ShapeVertexIndex] = Normal;
|
|
}
|
|
}
|
|
// Generate the temp face query data for the shape
|
|
// TODO: Index data copy may be saved in most cases.
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(GenerateTrianglesQueryData);
|
|
ShapeMeshDescriptor.Triangles.SetNum(ShapeTriangleCount);
|
|
// \TODO: Simple but inefficient
|
|
const UntypedMeshBufferIteratorConst ItIndices(ShapeMesh->GetIndexBuffers(), EMeshBufferSemantic::VertexIndex);
|
|
for (int32 TriangleIndex = 0; TriangleIndex < ShapeTriangleCount; ++TriangleIndex)
|
|
{
|
|
UE::Geometry::FIndex3i Triangle;
|
|
Triangle.A = int32((ItIndices + TriangleIndex*3 + 0).GetAsUINT32());
|
|
Triangle.B = int32((ItIndices + TriangleIndex*3 + 1).GetAsUINT32());
|
|
Triangle.C = int32((ItIndices + TriangleIndex*3 + 2).GetAsUINT32());
|
|
|
|
ShapeMeshDescriptor.Triangles[TriangleIndex] = Triangle;
|
|
}
|
|
}
|
|
|
|
FShapeMeshAdapter ShapeMeshAdapter(ShapeMeshDescriptor);
|
|
|
|
constexpr bool bAutoBuildTree = false;
|
|
FShapeMeshTree ShapeMeshTree(&ShapeMeshAdapter, bAutoBuildTree);
|
|
{
|
|
MUTABLE_CPUPROFILER_SCOPE(BuildShapeTree);
|
|
|
|
ShapeMeshTree.Build();
|
|
}
|
|
|
|
Result->CopyFrom(*BaseMesh);
|
|
TArray<FClipDeformVertexBindingData> VerticesBindData = BindVerticesClipDeform(BaseMesh, ShapeMeshTree, BindingMethod);
|
|
|
|
// Add the binding information to the mesh
|
|
// \TODO: Check that there is no other binding data.
|
|
// \TODO: Support specifying the binding data channel for multiple binding support.
|
|
FMeshBufferSet& VB = Result->GetVertexBuffers();
|
|
int NewBufferIndex = VB.GetBufferCount();
|
|
VB.SetBufferCount(NewBufferIndex + 1);
|
|
|
|
// \TODO: Multiple binding dataset support
|
|
int32 BindingDataIndex = 0;
|
|
|
|
FClipDeformVertexBindingDataBufferDescriptor BufDesc(BindingDataIndex);
|
|
VB.SetBuffer(NewBufferIndex, sizeof(FClipDeformVertexBindingData), BufDesc.Channels, BufDesc.Semantics, BufDesc.SemanticIndices, BufDesc.Formats, BufDesc.Components, BufDesc.Offsets);
|
|
FMemory::Memcpy(VB.GetBufferData(NewBufferIndex), VerticesBindData.GetData(), VerticesBindData.Num()*sizeof(FClipDeformVertexBindingData));
|
|
|
|
}
|
|
}
|