ContactModification.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Chaos/Core.h"
#include "ParticleHandleFwd.h"
#include "Chaos/ImplicitFwd.h"
 
namespace
{
    // When a FContactPairModifierParticleRange is created to iterate over the contacts
    // of a particular particle, an array of relevant constraints is generated.
    //
    // So long as the number of constraints for this particle does not exceed this constant
    // value, no heap allocations will occur.
    constexpr int32 ParticleContactsStackSize = 16;
}
 
namespace Chaos
{
    class FImplicitObject;
    class FPBDCollisionConstraint;
    class FPBDCollisionConstraints;
    class FCollisionContactModifier;
    class FContactPairModifier;
    class FPerShapeData;
    class FShapeInstance;
    class FPBDCollisionConstraintContainerCookie;
 
    class FContactPairModifier
    {
    public:
        FContactPairModifier()
            : Constraint(nullptr)
            , Modifier(nullptr)
        {}
 
        FContactPairModifier(FPBDCollisionConstraint* InConstraint, FCollisionContactModifier& InModifier)
            : Constraint(InConstraint)
            , Modifier(&InModifier)
        {}
 
        CHAOS_API void Disable();
 
        CHAOS_API void Enable();
 
        CHAOS_API void ConvertToProbe();
 
        CHAOS_API void ConvertToNonProbe();
 
        CHAOS_API bool GetIsProbe() const;
 
        CHAOS_API int32 GetNumContacts() const;
 
        CHAOS_API int32 GetDeepestContactIndex() const;
 
        CHAOS_API bool GetIsInitialContact() const;
 
        CHAOS_API void SetIsInitialContact(bool bIsInitialContact) const;
 
        CHAOS_API const FImplicitObject* GetContactGeometry(int32 ParticleIdx);
 
        CHAOS_API FRigidTransform3 GetShapeToWorld(int32 ParticleIdx) const;
 
        CHAOS_API FReal GetSeparation(int32 ContactPointIdx) const;
 
        CHAOS_API FReal GetTargetSeparation(int32 ContactPointIdx) const;
 
        CHAOS_API void ModifyTargetSeparation(FReal TargetSeparation, int32 ContactPointIdx);
 
        CHAOS_API FVec3 GetWorldNormal(int32 ContactPointIdx) const;
 
        CHAOS_API void ModifyWorldNormal(const FVec3& Normal, int32 ContactPointIdx);
 
        CHAOS_API void GetWorldContactLocations(int32 ContactPointIdx, FVec3& OutLocation0, FVec3& OutLocation1)  const;
 
        CHAOS_API FVec3 GetWorldContactLocation(int32 ContactPointIdx)  const;
 
        CHAOS_API void ModifyWorldContactLocations(const FVec3& Location0, const FVec3& Location1, int32 ContactPointIdx);
 
        CHAOS_API FReal GetRestitution() const;
 
        CHAOS_API void ModifyRestitution(FReal Restitution);
 
        CHAOS_API FReal GetRestitutionThreshold() const;
 
        CHAOS_API void ModifyRestitutionThreshold(FReal Restitution);
 
        CHAOS_API FReal GetDynamicFriction() const;
 
        CHAOS_API void ModifyDynamicFriction(FReal DynamicFriction);
 
        CHAOS_API FReal GetStaticFriction() const;
 
        CHAOS_API void ModifyStaticFriction(FReal StaticFriction);
 
        CHAOS_API FVec3 GetParticleVelocity(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyParticleVelocity(FVec3 Velocity, int32 ParticleIdx);
 
        CHAOS_API FVec3 GetParticleAngularVelocity(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyParticleAngularVelocity(FVec3 AngularVelocity, int32 ParticleIdx);
 
        CHAOS_API FVec3 GetParticlePosition(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyParticlePosition(FVec3 Position, bool bMaintainVelocity, int32 ParticleIdx);
 
        CHAOS_API FRotation3 GetParticleRotation(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyParticleRotation(FRotation3 Rotation, bool bMaintainVelocity, int32 ParticleIdx);
 
        CHAOS_API FReal GetInvInertiaScale(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyInvInertiaScale(FReal InvInertiaScale, int32 ParticleIdx);
 
        CHAOS_API FReal GetInvMassScale(int32 ParticleIdx) const;
 
        CHAOS_API void ModifyInvMassScale(FReal InvMassScale, int32 ParticleIdx);
 
        /*
        * Get the other particle in the constraint - if the input particle isn't in the constraint,
        * get null
        */
        CHAOS_API FGeometryParticleHandle* GetOtherParticle(FGeometryParticleHandle* Particle) const;
 
        /*
        * Retrieve physics handles for particles in contact pair.
        */
        CHAOS_API TVec2<FGeometryParticleHandle*> GetParticlePair() const;
 
        /*
        * Get shape pair from constraint.
        */
        CHAOS_API TVec2<const FPerShapeData*> GetShapePair() const;
 
        /*
        * Get one of the particle's shapes.
        */
        CHAOS_API const FShapeInstance* GetShape(int32 ParticleIdx) const;
 
        /*
        * Get one of the particle's implicit objects.
        */
        CHAOS_API const FConstImplicitObjectRef GetImplicit(int32 ParticleIdx) const;
 
        /*
        * Whether this contact was generated from a CCD hit. Even if CCD is enabled for the bodies,
        * the hit may be a non-CCD contact if they are moving slowly.
        * NOTE: You can disable CCD in a MidPhase Modifier, but it is too late to do that here.
        */
        CHAOS_API bool GetIsCCD() const;
 
        /*
        * Check to see if a contact point index is an edge contact.
        */
        CHAOS_API bool IsEdgeContactPoint(int32 ContactPointIdx) const;
 
        /*
        * Check to see if a contact point index is disabled.
        */
        CHAOS_API bool IsContactPointDisabled(int32 ContactPointIdx) const;
 
        /*
        * Set a contact point disabled.
        */
        CHAOS_API void SetContactPointDisabled(int32 ContactPointIdx) const;
 
    private:
 
        /*
        * Get direct const access to the index of this constraint container cookie
        */
        CHAOS_API const FPBDCollisionConstraintContainerCookie& GetConstraintContainerCookie() const;
 
        CHAOS_API void UpdateConstraintShapeTransforms();
 
        FPBDCollisionConstraint* Constraint;
        FCollisionContactModifier* Modifier;
 
        friend class FVisitedContactPairsTracker;
    };
 
    class FContactPairModifierIterator
    {
    public:
        FContactPairModifierIterator() { SetToEnd(); }
 
        FContactPairModifierIterator(FCollisionContactModifier& InModifier)
            : ConstraintIdx(0)
            , Modifier(&InModifier)
            , PairModifier()
        {
            // Initialize modifier at idx 0 or move to end.
            SeekValidContact();
        }
 
        FContactPairModifier& operator*()
        {
            // Make sure we are not returning invalid modifier if at End.
            EnsureValid();
 
            return PairModifier;
        }
 
        FContactPairModifier* operator->()
        {
            // Make sure we are not returning invalid modifier if at End.
            EnsureValid();
 
            return &PairModifier;
        }
 
        FContactPairModifierIterator& operator++()
        {
            ++ConstraintIdx;
            SeekValidContact();
            return *this;
        }
 
        explicit operator bool() const
        {
            return IsValid();
        }
 
        bool operator==(const FContactPairModifierIterator& Value) const
        {
            // All other data should match if index matches.
            return ConstraintIdx == Value.ConstraintIdx;
        }
 
        bool operator!=(const FContactPairModifierIterator& Value) const
        {
            return !(*this == Value);
        }
 
        bool IsValid() const
        {
            return ConstraintIdx != INDEX_NONE ;
        }
 
    private:
 
        void SetToEnd()
        {
            ConstraintIdx = INDEX_NONE;
            Modifier = nullptr;
        }
 
        void EnsureValid() const
        {
            ensure(IsValid());
        }
 
        // Moves to constraint at ConstraintIdx, or finds next valid constraint. Moves to end if no remaining valid constraints.
        CHAOS_API void SeekValidContact();
 
        int32 ConstraintIdx;
        FCollisionContactModifier* Modifier;
        FContactPairModifier PairModifier;
    };
 
    /*
    * Iterator for FContactPairModifierParticleRange
    */
    class FContactPairModifierParticleRangeIterator
    {
    public:
 
        FContactPairModifier& operator*()
        {
            return PairModifier;
        }
 
        FContactPairModifier* operator->()
        {
            return &PairModifier;
        }
 
        FContactPairModifierParticleRangeIterator& operator++()
        {
            ++Index;
 
            PairModifier
                = IsValid()
                ? FContactPairModifier(Constraints[Index], *Modifier)
                : FContactPairModifier();
 
            return *this;
        }
 
        bool operator==(const FContactPairModifierParticleRangeIterator& Other)
        {
            return
                &Constraints == &Other.Constraints &&
                Index == Other.Index;
        }
 
        bool operator!=(const FContactPairModifierParticleRangeIterator& Other)
        {
            return !(*this == Other);
        }
 
        bool IsValid() const
        {
            return 0 <= Index && Index < Constraints.Num();
        }
 
    private:
        FContactPairModifierParticleRangeIterator(FCollisionContactModifier* InModifier, TArray<FPBDCollisionConstraint*, TInlineAllocator<ParticleContactsStackSize>>& InConstraints, int32 InIndex)
            : Modifier(InModifier)
            , Constraints(InConstraints)
            , Index(InIndex)
        {
            PairModifier
                = IsValid()
                ? FContactPairModifier(Constraints[Index], *Modifier)
                : FContactPairModifier();
        }
 
        FCollisionContactModifier* Modifier;
        FContactPairModifier PairModifier;
 
        TArray<FPBDCollisionConstraint*, TInlineAllocator<ParticleContactsStackSize>>& Constraints;
        int32 Index;
 
        // Befriend the range object so that it can create iterators
        friend class FContactPairModifierParticleRange;
    };
 
    /*
    * Interface for iterating over a range of contacts for a particular particle
    */
    class FContactPairModifierParticleRange
    {
    public:
        CHAOS_API FContactPairModifierParticleRangeIterator begin();
        CHAOS_API FContactPairModifierParticleRangeIterator end();
 
        FContactPairModifierParticleRange(FContactPairModifierParticleRange&& Other)
            : Modifier(Other.Modifier)
            , Particle(Other.Particle)
            , Constraints(MoveTemp(Other.Constraints))
        { }
 
    private:
        FContactPairModifierParticleRange(FCollisionContactModifier* InModifier, FGeometryParticleHandle* InParticle);
        FCollisionContactModifier* Modifier;
        FGeometryParticleHandle* Particle;
        TArray<FPBDCollisionConstraint*, TInlineAllocator<ParticleContactsStackSize>> Constraints;
 
        // Befriend the modifier so that it can create ranges
        friend class FCollisionContactModifier;
    };
 
    /*
    * Utility for tracking visited contact pair modifiers so that clients can avoid processing duplicates
    */
    class FVisitedContactPairsTracker
    {
    public:
 
        // If a contact pair was not already visited, mark it visited and return true. Otherwise return false.
        CHAOS_API bool Visit(const FContactPairModifier& ContactPair);
 
    private:
        FVisitedContactPairsTracker(const TArrayView<FPBDCollisionConstraint* const>& InConstraints)
            : Constraints(InConstraints)
            , VisitedContacts(false, Constraints.Num())
        { }
 
        TArrayView<FPBDCollisionConstraint* const> Constraints;
        TBitArray<> VisitedContacts;
 
        // Befriend the modifier so that it can create these
        friend class FCollisionContactModifier;
    };
 
    /*
    *  Provides interface for iterating over modifiable contact pairs
    */
    class FCollisionContactModifier
    {
    public:
        friend FContactPairModifier;
        friend FContactPairModifierIterator;
        friend FPBDCollisionConstraints; // Calls UpdateConstraintManifolds after callback.
 
 
        FCollisionContactModifier(const TArrayView<FPBDCollisionConstraint* const>& InConstraints, FReal InDt)
            : Constraints(InConstraints)
            , Dt(InDt)
        {}
 
        FContactPairModifierIterator Begin() { return FContactPairModifierIterator(*this); }
        FContactPairModifierIterator begin() { return FContactPairModifierIterator(*this); }
 
        FContactPairModifierIterator End() const { return FContactPairModifierIterator(); }
        FContactPairModifierIterator end() const { return FContactPairModifierIterator(); }
 
        CHAOS_API FContactPairModifierParticleRange GetContacts(FGeometryParticleHandle* Particle);
 
        CHAOS_API FVisitedContactPairsTracker MakeVisitedContactPairsTracker() const;
 
    private:
        CHAOS_API TArrayView<FPBDCollisionConstraint* const>& GetConstraints();
        CHAOS_API void DisableConstraint(FPBDCollisionConstraint& Constraint);
        CHAOS_API void EnableConstraint(FPBDCollisionConstraint& Constraint);
 
        // Turn this constraint into a probe. It will still generate hit events,
        // but will not produce impulses
        CHAOS_API void ConvertToProbeConstraint(FPBDCollisionConstraint& Constraint);
 
        // Turn this constraint from a probe into a regular constraint
        CHAOS_API void ConvertToNonProbeConstraint(FPBDCollisionConstraint& Constraint);
 
        CHAOS_API void MarkConstraintForManifoldUpdate(FPBDCollisionConstraint& Constraint);
 
        // Update manifolds of modified constraints.
        CHAOS_API void UpdateConstraintManifolds();
 
        TArrayView<FPBDCollisionConstraint* const> Constraints;
 
        // Constraints that should update manifold from contact points.
        TSet<FPBDCollisionConstraint*> NeedsManifoldUpdate;
 
        FReal Dt;
    };
 
    using FCollisionModifierCallback = TFunction<void(const FCollisionContactModifier&)>;
}