778 lines
21 KiB
C++
778 lines
21 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "ChaosVDCollisionDataWrappers.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "HAL/Platform.h"
|
|
|
|
#include "ChaosVDParticleDataWrapper.generated.h"
|
|
|
|
UENUM()
|
|
enum class EChaosVDParticleType : uint8
|
|
{
|
|
Static,
|
|
Kinematic,
|
|
Rigid,
|
|
Clustered,
|
|
StaticMesh,
|
|
SkeletalMesh,
|
|
GeometryCollection,
|
|
Unknown
|
|
};
|
|
|
|
UENUM()
|
|
enum class EChaosVDSleepType : uint8
|
|
{
|
|
MaterialSleep,
|
|
NeverSleep
|
|
};
|
|
|
|
UENUM()
|
|
enum class EChaosVDObjectStateType: int8
|
|
{
|
|
Uninitialized = 0,
|
|
Sleeping = 1,
|
|
Kinematic = 2,
|
|
Static = 3,
|
|
Dynamic = 4,
|
|
|
|
Count
|
|
};
|
|
|
|
/** Base struct that declares the interface to be used for any ParticleData Viewer */
|
|
USTRUCT()
|
|
struct FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
virtual ~FChaosVDWrapperDataBase() = default;
|
|
|
|
virtual bool HasValidData() const { return bHasValidData; }
|
|
|
|
void MarkAsValid() { bHasValidData = true; }
|
|
|
|
protected:
|
|
UPROPERTY()
|
|
bool bHasValidData = false;
|
|
};
|
|
|
|
enum class EChaosVDParticlePairIndex : uint8
|
|
{
|
|
Index_0,
|
|
Index_1
|
|
};
|
|
|
|
/** Base struct that declares the interface to be used for any Constraint data to be visualized */
|
|
USTRUCT()
|
|
struct FChaosVDConstraintDataWrapperBase : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
virtual ~FChaosVDConstraintDataWrapperBase() override = default;
|
|
|
|
virtual int32 GetSolverID() const { return INDEX_NONE; }
|
|
virtual int32 GetParticleIDAtSlot (EChaosVDParticlePairIndex IndexSlot) const { return INDEX_NONE;}
|
|
virtual int32 GetConstraintIndex () const { return INDEX_NONE; }
|
|
};
|
|
|
|
USTRUCT()
|
|
struct FChaosVDFRigidParticleControlFlags : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDFRigidParticleControlFlags()
|
|
: bGravityEnabled(false),
|
|
bCCDEnabled(false),
|
|
bOneWayInteractionEnabled(false),
|
|
bInertiaConditioningEnabled(false),
|
|
GravityGroupIndex(0),
|
|
bMACDEnabled(false),
|
|
bGyroscopicTorqueEnabled(false),
|
|
PositionSolverIterationCount(8),
|
|
VelocitySolverIterationCount(1),
|
|
ProjectionSolverIterationCount(1)
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
bGravityEnabled = Other.GetGravityEnabled();
|
|
bCCDEnabled = Other.GetCCDEnabled();
|
|
bOneWayInteractionEnabled = Other.GetOneWayInteractionEnabled();
|
|
bInertiaConditioningEnabled = Other.GetInertiaConditioningEnabled();
|
|
GravityGroupIndex = Other.GetGravityGroupIndex();
|
|
bMACDEnabled = Other.GetMACDEnabled();
|
|
bGyroscopicTorqueEnabled = Other.GetGyroscopicTorqueEnabled();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
Other.SetGravityEnabled(bGravityEnabled);
|
|
Other.SetCCDEnabled(bCCDEnabled);
|
|
Other.SetOneWayInteractionEnabled(bOneWayInteractionEnabled);
|
|
Other.SetInertiaConditioningEnabled(bInertiaConditioningEnabled);
|
|
Other.SetGravityGroupIndex(GravityGroupIndex);
|
|
Other.SetMACDEnabled(bMACDEnabled);
|
|
Other.SetGyroscopicTorqueEnabled(bGyroscopicTorqueEnabled);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Control Flags")
|
|
bool bGravityEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Control Flags")
|
|
bool bCCDEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Control Flags")
|
|
bool bOneWayInteractionEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
bool bInertiaConditioningEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Control Flags")
|
|
int32 GravityGroupIndex;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
bool bMACDEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
bool bGyroscopicTorqueEnabled;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
uint8 PositionSolverIterationCount;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
uint8 VelocitySolverIterationCount;
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Control Flags")
|
|
uint8 ProjectionSolverIterationCount;
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDFRigidParticleControlFlags)
|
|
|
|
template<>
|
|
struct TStructOpsTypeTraits<FChaosVDFRigidParticleControlFlags> : public TStructOpsTypeTraitsBase2<FChaosVDFRigidParticleControlFlags>
|
|
{
|
|
enum
|
|
{
|
|
WithSerializer = true,
|
|
};
|
|
};
|
|
|
|
/** Simplified UStruct version of FParticlePositionRotation.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticlePositionRotation : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticlePositionRotation()
|
|
{
|
|
}
|
|
|
|
enum class EAccessorType
|
|
{
|
|
PQ,
|
|
XR
|
|
};
|
|
|
|
template <typename OtherType, EAccessorType AccessorType>
|
|
void CopyFrom(const OtherType& Other)
|
|
{
|
|
if constexpr (AccessorType == EAccessorType::PQ)
|
|
{
|
|
MX = Other.GetP();
|
|
MR = Other.GetQ();
|
|
|
|
}
|
|
else if (AccessorType == EAccessorType::XR)
|
|
{
|
|
MX = Other.GetX();
|
|
MR = Other.GetR();
|
|
}
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename OtherType, EAccessorType AccessorType>
|
|
void CopyTo(OtherType& Other) const
|
|
{
|
|
if constexpr (AccessorType == EAccessorType::PQ)
|
|
{
|
|
Other.SetP(MX);
|
|
Other.SetQ(MR);
|
|
}
|
|
else if (AccessorType == EAccessorType::XR)
|
|
{
|
|
Other.SetX(MX);
|
|
Other.SetR(MR);
|
|
}
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Velocities")
|
|
FVector MX = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Velocities")
|
|
FQuat MR = FQuat(ForceInit);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticlePositionRotation)
|
|
|
|
/** Simplified UStruct version of FParticleVelocities.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticleVelocities : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleVelocities()
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
MV = Other.GetV();
|
|
MW = Other.GetW();
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
Other.SetV(MV);
|
|
Other.SetW(MW);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Velocities")
|
|
FVector MV = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Velocities")
|
|
FVector MW = FVector(ForceInit);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleVelocities)
|
|
|
|
USTRUCT()
|
|
struct FChaosVDParticleBounds : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleBounds()
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
MMin = Other.WorldSpaceInflatedBounds().Min();
|
|
MMax = Other.WorldSpaceInflatedBounds().Max();
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
// TODO:
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Bounds Min")
|
|
FVector MMin = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Bounds Max")
|
|
FVector MMax = FVector(ForceInit);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleBounds)
|
|
|
|
/** Simplified UStruct version of FParticleDynamics.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticleDynamics : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleDynamics()
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(TOther& Other)
|
|
{
|
|
MAcceleration = Other.Acceleration();
|
|
MAngularAcceleration = Other.AngularAcceleration();
|
|
MLinearImpulseVelocity = Other.LinearImpulseVelocity();
|
|
MAngularImpulseVelocity = Other.AngularImpulseVelocity();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
Other.SetAcceleration(MAcceleration);
|
|
Other.SetAngularAcceleration(MAngularAcceleration);
|
|
Other.SetLinearImpulseVelocity(MLinearImpulseVelocity);
|
|
Other.SetAngularImpulseVelocity(MAngularImpulseVelocity);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics")
|
|
FVector MAcceleration = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics")
|
|
FVector MAngularAcceleration = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics")
|
|
FVector MLinearImpulseVelocity = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics")
|
|
FVector MAngularImpulseVelocity = FVector(ForceInit);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleDynamics)
|
|
|
|
/** Simplified UStruct version of FParticleMassProps.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticleMassProps : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleMassProps(): MM(0), MInvM(0)
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
MCenterOfMass = Other.CenterOfMass();
|
|
MRotationOfMass = Other.RotationOfMass();
|
|
MI = FVector(Other.I());
|
|
MInvI = FVector(Other.InvI());
|
|
MM = Other.M();
|
|
MInvM = Other.InvM();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
Other.SetCenterOfMass(MCenterOfMass);
|
|
Other.SetRotationOfMass(MRotationOfMass);
|
|
Other.SetI(MI);
|
|
Other.SetInvI(MInvI);
|
|
Other.SetM(MM);
|
|
Other.SetInvM(MInvM);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
FVector MCenterOfMass = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
FQuat MRotationOfMass = FQuat(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
FVector MI = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
FVector MInvI = FVector(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
double MM = 0.0;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
double MInvM = 0.0;
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleMassProps)
|
|
|
|
/** Simplified UStruct version of FParticleDynamicMisc.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticleDynamicMisc : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleDynamicMisc(): MLinearEtherDrag(0), MAngularEtherDrag(0), MMaxLinearSpeedSq(0), MMaxAngularSpeedSq(0), MInitialOverlapDepenetrationVelocity(0), MSleepThresholdMultiplier(1),
|
|
MCollisionGroup(0), MObjectState(), MSleepType(), bDisabled(false)
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
MLinearEtherDrag = Other.LinearEtherDrag();
|
|
MAngularEtherDrag = Other.AngularEtherDrag();
|
|
MMaxLinearSpeedSq = Other.MaxLinearSpeedSq();
|
|
MMaxAngularSpeedSq = Other.MaxAngularSpeedSq();
|
|
MInitialOverlapDepenetrationVelocity = Other.InitialOverlapDepenetrationVelocity();
|
|
MSleepThresholdMultiplier = Other.SleepThresholdMultiplier();
|
|
MObjectState = static_cast<EChaosVDObjectStateType>(Other.ObjectState());
|
|
MCollisionGroup = Other.CollisionGroup();
|
|
MSleepType = static_cast<EChaosVDSleepType>(Other.SleepType());
|
|
MCollisionConstraintFlag = Other.CollisionConstraintFlags();
|
|
|
|
MControlFlags.CopyFrom(Other.ControlFlags());
|
|
|
|
bDisabled = Other.Disabled();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename OtherType, typename ControlFlagsType, typename SleepStateType>
|
|
void CopyWithoutStateTo(OtherType& Other) const
|
|
{
|
|
Other.SetLinearEtherDrag(MLinearEtherDrag);
|
|
Other.SetAngularEtherDrag(MAngularEtherDrag);
|
|
Other.SetMaxLinearSpeedSq(MMaxLinearSpeedSq);
|
|
Other.SetMaxAngularSpeedSq(MMaxAngularSpeedSq);
|
|
Other.SetInitialOverlapDepenetrationVelocity(MInitialOverlapDepenetrationVelocity);
|
|
Other.SetSleepThresholdMultiplier(MSleepThresholdMultiplier);
|
|
Other.SetCollisionGroup(MCollisionGroup);
|
|
Other.SetSleepType(static_cast<SleepStateType>(MSleepType));
|
|
Other.SetCollisionConstraintFlags(MCollisionConstraintFlag);
|
|
|
|
ControlFlagsType ControlFlags;
|
|
MControlFlags.CopyTo(ControlFlags);
|
|
|
|
Other.SetControlFlags(ControlFlags);
|
|
|
|
Other.SetDisabled(bDisabled);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
double MLinearEtherDrag;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
double MAngularEtherDrag;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
double MMaxLinearSpeedSq;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
double MMaxAngularSpeedSq;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Dynamic Misc")
|
|
float MInitialOverlapDepenetrationVelocity;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Dynamic Misc")
|
|
float MSleepThresholdMultiplier;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
int32 MCollisionGroup;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
EChaosVDObjectStateType MObjectState;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
EChaosVDSleepType MSleepType;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
uint32 MCollisionConstraintFlag = 0;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
FChaosVDFRigidParticleControlFlags MControlFlags;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamic Misc")
|
|
bool bDisabled;
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleDynamicMisc)
|
|
|
|
/** Represents the data of a connectivity Edge that CVD can use to reconstruct it during playback */
|
|
USTRUCT()
|
|
struct FChaosVDConnectivityEdge
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
UPROPERTY(VisibleAnywhere, Category=ConnectivityEdge)
|
|
int32 SiblingParticleID = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category=ConnectivityEdge)
|
|
float Strain = 0.0f;
|
|
|
|
bool Serialize(FArchive& Ar)
|
|
{
|
|
Ar << SiblingParticleID;
|
|
Ar << Strain;
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDConnectivityEdge)
|
|
|
|
/** Structure contained data from a Clustered Particle.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT()
|
|
struct FChaosVDParticleCluster : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleCluster()
|
|
{
|
|
}
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename TOther>
|
|
void CopyFrom(const TOther& Other)
|
|
{
|
|
ParentParticleID = Other.ClusterIds().Id ? Other.ClusterIds().Id->UniqueIdx().Idx : INDEX_NONE;
|
|
|
|
NumChildren = Other.ClusterIds().NumChildren;
|
|
|
|
ChildToParent = Other.ChildToParent();
|
|
ClusterGroupIndex = Other.ClusterGroupIndex();
|
|
bInternalCluster = Other.InternalCluster();
|
|
CollisionImpulse = Other.CollisionImpulses();
|
|
ExternalStrains = Other.GetExternalStrain();
|
|
InternalStrains = Other.GetInternalStrains();
|
|
Strain = Other.Strain();
|
|
|
|
|
|
ConnectivityEdges.Reserve(Other.ConnectivityEdges().Num());
|
|
for (auto& Edge : Other.ConnectivityEdges())
|
|
{
|
|
int32 SiblingId = Edge.Sibling ? Edge.Sibling->UniqueIdx().Idx : INDEX_NONE;
|
|
ConnectivityEdges.Add( { SiblingId, Edge.Strain });
|
|
}
|
|
|
|
bIsAnchored = Other.IsAnchored();
|
|
bUnbreakable = Other.Unbreakable();
|
|
bIsChildToParentLocked = Other.IsChildToParentLocked();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename TOther>
|
|
void CopyTo(TOther& Other) const
|
|
{
|
|
//TODO:
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
int32 ParentParticleID = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster | Cluster Id")
|
|
int32 NumChildren = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
FTransform ChildToParent;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
int32 ClusterGroupIndex = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
bool bInternalCluster = false;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
float CollisionImpulse = 0.0f;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
float ExternalStrains = 0.0f;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
float InternalStrains = 0.0f;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
float Strain = 0.0f;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
TArray<FChaosVDConnectivityEdge> ConnectivityEdges;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
bool bIsAnchored = false;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
bool bUnbreakable = false;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster")
|
|
bool bIsChildToParentLocked = false;
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleCluster)
|
|
|
|
UENUM()
|
|
enum class EChaosVDParticleContext
|
|
{
|
|
Invalid,
|
|
GameThread,
|
|
PhysicsThread,
|
|
};
|
|
|
|
UENUM()
|
|
enum class EChaosVDKinematicTargetMode
|
|
{
|
|
None, /** Particle does not move and no data is changed */
|
|
Reset, /** Particle does not move, velocity and angular velocity are zeroed, then mode is set to "None". */
|
|
Position, /** Particle is moved to Kinematic Target transform, velocity and angular velocity updated to reflect the change, then mode is set to "Reset". */
|
|
Velocity, /** Particle is moved based on velocity and angular velocity, mode remains as "Velocity" until changed. */
|
|
};
|
|
|
|
USTRUCT()
|
|
struct FChaosVDKinematicTarget : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename OtherType>
|
|
void CopyFrom(const OtherType& Other)
|
|
{
|
|
Mode = static_cast<EChaosVDKinematicTargetMode>(Other.GetMode());
|
|
|
|
if (Mode == EChaosVDKinematicTargetMode::Position)
|
|
{
|
|
Position = Other.GetPosition();
|
|
Rotation = FQuat(Other.GetRotation());
|
|
}
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename OtherType, class ModeType>
|
|
void CopyTo(OtherType& Other) const
|
|
{
|
|
Other.SetTargetMode(Position, Rotation);
|
|
Other.SetMode(static_cast<ModeType>(Mode));
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Kinematic Target")
|
|
FQuat Rotation = FQuat(ForceInit);
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Kinematic Target")
|
|
FVector Position = FVector(ForceInit);;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Kinematic Target")
|
|
EChaosVDKinematicTargetMode Mode = EChaosVDKinematicTargetMode::None;
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDKinematicTarget)
|
|
|
|
USTRUCT()
|
|
struct FChaosVDVSmooth : public FChaosVDWrapperDataBase
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
|
|
template <typename OtherType>
|
|
void CopyFrom(const OtherType& Other)
|
|
{
|
|
MV = Other.VSmooth();
|
|
MW = Other.WSmooth();
|
|
|
|
bHasValidData = true;
|
|
}
|
|
|
|
template <typename OtherType>
|
|
void CopyTo(OtherType& Other) const
|
|
{
|
|
Other.SetVSmooth(MV);
|
|
Other.SetWSmooth(MW);
|
|
}
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "VSmooth")
|
|
FVector MV = FVector(ForceInit);
|
|
UPROPERTY(VisibleAnywhere, Category= "VSmooth")
|
|
FVector MW = FVector(ForceInit);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDVSmooth)
|
|
|
|
/** Simplified UStruct version of FChaosVDParticleDataWrapper.
|
|
* Used to be able to show the values in the editor and allow changes via the Property Editor.
|
|
*/
|
|
USTRUCT(DisplayName="Particle Data")
|
|
struct FChaosVDParticleDataWrapper : public FChaosVDWrapperDataBase
|
|
{
|
|
virtual ~FChaosVDParticleDataWrapper() override = default;
|
|
|
|
inline static FStringView WrapperTypeName = TEXT("FChaosVDParticleDataWrapper");
|
|
|
|
GENERATED_BODY()
|
|
|
|
FChaosVDParticleDataWrapper()
|
|
{
|
|
}
|
|
|
|
UPROPERTY()
|
|
int32 DirtyFlagsBits = 0;
|
|
|
|
UPROPERTY()
|
|
EChaosVDParticleContext ParticleContext = EChaosVDParticleContext::Invalid;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "General")
|
|
uint32 GeometryHash = 0;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "General")
|
|
FString DebugName;
|
|
|
|
/** Hash used during CVD Playback to compare names */
|
|
uint64 DebugNameHash = 0;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "General")
|
|
int32 ParticleIndex = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "General")
|
|
int32 SolverID = INDEX_NONE;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "General")
|
|
EChaosVDParticleType Type = EChaosVDParticleType::Unknown;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Position Rotation")
|
|
FChaosVDParticlePositionRotation ParticlePositionRotation;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Velocities")
|
|
FChaosVDParticleVelocities ParticleVelocities;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category = "Particle Inflated Bounds")
|
|
FChaosVDParticleBounds ParticleInflatedBounds;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Kinematic Target")
|
|
FChaosVDKinematicTarget ParticleKinematicTarget;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle V/W Smooth")
|
|
FChaosVDVSmooth ParticleVWSmooth;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics")
|
|
FChaosVDParticleDynamics ParticleDynamics;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Dynamics Misc")
|
|
FChaosVDParticleDynamicMisc ParticleDynamicsMisc;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Mass Props")
|
|
FChaosVDParticleMassProps ParticleMassProps;
|
|
|
|
UPROPERTY(VisibleAnywhere, Category= "Particle Cluster Data")
|
|
FChaosVDParticleCluster ParticleCluster;
|
|
|
|
UPROPERTY()
|
|
TArray<FChaosVDShapeCollisionData> CollisionDataPerShape;
|
|
|
|
/** Only used during recording */
|
|
FString* DebugNamePtr = nullptr;
|
|
bool bHasDebugName = false;
|
|
|
|
virtual bool HasValidData() const override { return bHasValidData; }
|
|
|
|
CHAOSVDRUNTIME_API bool Serialize(FArchive& Ar);
|
|
};
|
|
|
|
CVD_IMPLEMENT_SERIALIZER(FChaosVDParticleDataWrapper)
|