ClothCollisionPrim.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "UObject/ObjectMacros.h"
#include "ClothCollisionPrim.generated.h"
 
USTRUCT()
struct FClothCollisionPrim_Sphere
{
    GENERATED_BODY()
 
    FClothCollisionPrim_Sphere(float InRadius = 0.0f, const FVector& InLocalPosition = FVector::ZeroVector, int32 InBoneIndex = INDEX_NONE)
        : BoneIndex(InBoneIndex)
        , Radius(InRadius)
        , LocalPosition(InLocalPosition)
    {}
 
    bool operator==(const FClothCollisionPrim_Sphere& Other) const
    {
        return
            BoneIndex == Other.BoneIndex &&
            FMath::IsNearlyEqual(Radius, Other.Radius) &&
            LocalPosition.Equals(Other.LocalPosition);
    }
 
    UPROPERTY()
    int32 BoneIndex;
 
    UPROPERTY()
    float Radius;
 
    UPROPERTY()
    FVector LocalPosition;
};
 
USTRUCT()
struct FClothCollisionPrim_SphereConnection
{
    GENERATED_BODY()
 
    FClothCollisionPrim_SphereConnection(int32 SphereIndex0 = INDEX_NONE, int32 SphereIndex1 = INDEX_NONE, const FVector& InOneSidedPlaneNormal = FVector::ZeroVector)
    {
        SphereIndices[0] = SphereIndex0;
        SphereIndices[1] = SphereIndex1;
        OneSidedPlaneNormal = InOneSidedPlaneNormal;
    }
 
    bool operator==(const FClothCollisionPrim_SphereConnection& Other) const
    {
        return
            SphereIndices[0] == Other.SphereIndices[0] &&
            SphereIndices[1] == Other.SphereIndices[1] &&
            OneSidedPlaneNormal == Other.OneSidedPlaneNormal;
    }
 
    UPROPERTY()
    int32 SphereIndices[2];
 
    /* Zero vector means this is not a one-sided capsule.*/
    UPROPERTY()
    FVector OneSidedPlaneNormal = FVector::ZeroVector;
};
 
USTRUCT()
struct FClothCollisionPrim_ConvexFace
{
    GENERATED_BODY()
 
    FClothCollisionPrim_ConvexFace(): Plane(ForceInit) {}
 
    bool operator==(const FClothCollisionPrim_ConvexFace& Other) const
    {
        return Plane.Equals(Other.Plane) && Indices == Other.Indices;
    }
 
    UPROPERTY()
    FPlane Plane;
 
    UPROPERTY()
    TArray<int32> Indices;
};
 
USTRUCT()
struct FClothCollisionPrim_Convex
{
    GENERATED_BODY()
 
    FClothCollisionPrim_Convex()
        : BoneIndex(INDEX_NONE)
    {}
 
    FClothCollisionPrim_Convex(
        TArray<FClothCollisionPrim_ConvexFace>&& InFaces,
        TArray<FVector>&& InSurfacePoints,
        int32 InBoneIndex = INDEX_NONE)
        : Faces(InFaces)
        , SurfacePoints(InSurfacePoints)
        , BoneIndex(InBoneIndex)
    {}
 
    bool operator==(const FClothCollisionPrim_Convex& Other) const
    {
        if (BoneIndex == Other.BoneIndex &&
            Faces == Other.Faces &&
            SurfacePoints.Num() == Other.SurfacePoints.Num())
        {
            for (int32 Index = 0; Index < SurfacePoints.Num(); ++Index)
            {
                if (!SurfacePoints[Index].Equals(Other.SurfacePoints[Index]))
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FPlane> Planes_DEPRECATED;
#endif
 
    UPROPERTY()
    TArray<FClothCollisionPrim_ConvexFace> Faces;
 
    UPROPERTY()
    TArray<FVector> SurfacePoints;  // Surface points, used by Chaos and also for visualization
 
    UPROPERTY()
    int32 BoneIndex;
};
 
USTRUCT()
struct FClothCollisionPrim_Box
{
    GENERATED_BODY()
 
    FClothCollisionPrim_Box(
        const FVector& InLocalPosition = FVector::ZeroVector,
        const FQuat& InLocalRotation = FQuat::Identity,
        const FVector& InHalfExtents = FVector::ZeroVector,
        int32 InBoneIndex = INDEX_NONE)
        : LocalPosition(InLocalPosition)
        , LocalRotation(InLocalRotation)
        , HalfExtents(InHalfExtents)
        , BoneIndex(InBoneIndex)
    {}
 
    bool operator==(const FClothCollisionPrim_Box& Other) const
    {
        return
            BoneIndex == Other.BoneIndex &&
            LocalPosition.Equals(Other.LocalPosition) &&
            LocalRotation.Equals(Other.LocalRotation) &&
            HalfExtents.Equals(Other.HalfExtents);
    }
 
    UPROPERTY()
    FVector LocalPosition;
 
    UPROPERTY()
    FQuat LocalRotation;
 
    UPROPERTY()
    FVector HalfExtents;
 
    UPROPERTY()
    int32 BoneIndex;
};