ColliderMesh.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "IndexTypes.h"
#include "Math/Ray.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Misc/AssertionMacros.h"
#include "Spatial/MeshAABBTree3.h"
#include "Spatial/SpatialInterfaces.h"
#include "Templates/Function.h"
#include "VectorUtil.h"
 
namespace UE
{
namespace Geometry
{
 
class FDynamicMesh3;
 
class FColliderMesh
{
public:
    struct FBuildOptions
    {
        FBuildOptions()
        {
            bBuildAABBTree = true;
            bBuildVertexMap = false;
            bBuildTriangleMap = false;
        }
 
        bool bBuildAABBTree;
        bool bBuildVertexMap;
        bool bBuildTriangleMap;
    };
 
public:
    GEOMETRYCORE_API FColliderMesh();
    GEOMETRYCORE_API FColliderMesh(const FDynamicMesh3& SourceMesh, const FBuildOptions& BuildOptions = FBuildOptions());
 
    GEOMETRYCORE_API void Initialize(const FDynamicMesh3& SourceMesh, const FBuildOptions& BuildOptions = FBuildOptions());
 
    GEOMETRYCORE_API void Reset(EAllowShrinking AllowShrinking);
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("Reset")
    FORCEINLINE void Reset(bool bReleaseMemory)
    {
        Reset(bReleaseMemory ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    // mesh API required for TMeshAABBTree3
    bool IsTriangle(int32 TriangleID) const { return TriangleID >= 0 && TriangleID < Triangles.Num(); }
    bool IsVertex(int32 VertexID) const { return VertexID >= 0 && VertexID < Vertices.Num(); }
    int32 MaxTriangleID() const { return Triangles.Num(); }
    int32 MaxVertexID() const { return Vertices.Num(); }
    int32 TriangleCount() const { return Triangles.Num(); }
    int32 VertexCount() const { return Vertices.Num(); }
    uint64 GetChangeStamp() const { return 0; }
    FIndex3i GetTriangle(int32 TriangleID) const { return Triangles[TriangleID]; }
    FVector3d GetVertex(int32 VertexID) const { return Vertices[VertexID]; }
 
    void GetTriVertices(int32 TriangleID, FVector3d& V0, FVector3d& V1, FVector3d& V2) const
    {
        FIndex3i Tri = Triangles[TriangleID];
        V0 = Vertices[Tri.A];
        V1 = Vertices[Tri.B];
        V2 = Vertices[Tri.C];
    }
 
    FVector3d GetTriNormal(int32 TriangleID) const
    {
        FIndex3i Tri = Triangles[TriangleID];
        return VectorUtil::Normal(Vertices[Tri.A], Vertices[Tri.B], Vertices[Tri.C]);
    }
 
    bool SourceWasCompactV() const { return bSourceWasCompactV; }
    bool HasVertexIDMap() const { return SourceVertexIDs.Num() > 0 && SourceVertexIDs.Num() == Vertices.Num(); }
    GEOMETRYCORE_API int32 GetSourceVertexID(int32 VertexID) const;
    bool SourceWasCompactT() const { return bSourceWasCompactT; }
    bool HasTriangleIDMap() const { return SourceTriangleIDs.Num() > 0 && SourceTriangleIDs.Num() == Triangles.Num(); }
    GEOMETRYCORE_API int32 GetSourceTriangleID(int32 TriangleID) const;
 
    // spatial APIs
 
    GEOMETRYCORE_API bool FindNearestHitTriangle( const FRay3d& Ray, double& RayParameterOut, int& HitTriangleIDOut, FVector3d& BaryCoordsOut, const IMeshSpatial::FQueryOptions& Options = IMeshSpatial::FQueryOptions() ) const;
 
 
    GEOMETRYCORE_API int FindNearestTriangle( const FVector3d& Point, double& NearestDistSqrOut, const IMeshSpatial::FQueryOptions& Options = IMeshSpatial::FQueryOptions() ) const;
 
 
    GEOMETRYCORE_API TMeshAABBTree3<FColliderMesh>* GetRawAABBTreeUnsafe();
 
 
 
 
protected:
    // For large meshes it might be better to optionally use TDynamicVector here (but keeping the TArray for
    // small meshes is still also desirable due to minimum-size). Adds a branch to every access, though.
    TArray<FVector3d> Vertices;
    TArray<FIndex3i> Triangles;
 
    TArray<int32> SourceVertexIDs;
    bool bSourceWasCompactV;
    TArray<int32> SourceTriangleIDs;
    bool bSourceWasCompactT;
 
    TMeshAABBTree3<FColliderMesh> AABBTree;
 
};
 
 
class FColliderMeshProjectionTarget : public IOrientedProjectionTarget
{
public:
    FColliderMesh* ColliderMesh = nullptr;
 
    FColliderMeshProjectionTarget()
    {
        ColliderMesh = nullptr;
    }
 
    FColliderMeshProjectionTarget(FColliderMesh* ColliderMeshIn)
    {
        check(ColliderMeshIn);
        ColliderMesh = ColliderMeshIn;
    }
 
    virtual ~FColliderMeshProjectionTarget() {}
 
    GEOMETRYCORE_API virtual FVector3d Project(const FVector3d& Point, int Identifier = -1) override;
    GEOMETRYCORE_API virtual FVector3d Project(const FVector3d& Point, FVector3d& ProjectNormalOut, int Identifier = -1) override;
};
 
 
 
} // end namespace UE::Geometry
} // end namespace UE