KinematicTargets.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
// HEADER_UNIT_SKIP - Internal
 
#include "Chaos/ChaosArchive.h"
#include "Chaos/Transform.h"
#include "UObject/FortniteMainBranchObjectVersion.h"
#include "UObject/FortniteReleaseBranchCustomObjectVersion.h"
#include "UObject/PhysicsObjectVersion.h"
 
namespace Chaos
{
    enum class EKinematicTargetMode
    {
        None,           
        Reset,          
        Position,       
        Velocity,       
    };
 
    class FKinematicTarget;
 
    template<class T, int d>
    using TKinematicTarget UE_DEPRECATED(5.5, "Deprecated. this class is to be deleted, use class FKinematicTarget instead") = FKinematicTarget;
 
    class FKinematicTarget
    {
    public:
 
        static FKinematicTarget MakePositionTarget(const FRigidTransform3& InTransform)
        {
            return FKinematicTarget(InTransform);
        }
 
        static FKinematicTarget MakePositionTarget(const FVec3& InPosition, const FRotation3f& InRotation)
        {
            return FKinematicTarget(InPosition, InRotation);
        }
 
        FKinematicTarget()
            : Rotation(FRotation3f::FromIdentity())
            , Position(0)
            , Mode(EKinematicTargetMode::None)
        {
        }
 
        bool IsSet() const { return (Mode == EKinematicTargetMode::Position) || (Mode == EKinematicTargetMode::Velocity); }
 
        EKinematicTargetMode GetMode() const { return Mode; }
 
        UE_DEPRECATED(5.5, "This method is Deprecated and it will be removed in a future release. Use GetTransform instead")
        FRigidTransform3 GetTarget() const { check(Mode == EKinematicTargetMode::Position); return {Position, Rotation}; }
 
        UE_DEPRECATED(5.5, "This method is Deprecated and it will be removed in a future release. Use GetPosition instead")
        FVec3 GetTargetPosition() const { check(Mode == EKinematicTargetMode::Position); return Position; }
 
        UE_DEPRECATED(5.5, "This method is Deprecated and it will be removed in a future release. Use GetRotation instead")
        FRotation3 GetTargetRotation() const { check(Mode == EKinematicTargetMode::Position); return Rotation; }
 
        FRigidTransform3 GetTransform() const { check(Mode == EKinematicTargetMode::Position); return {Position, Rotation}; }
 
        FVec3 GetPosition() const { check(Mode == EKinematicTargetMode::Position); return Position; }
 
        FRotation3f GetRotation() const { check(Mode == EKinematicTargetMode::Position); return Rotation; }
 
        void Clear()
        {
            Position = FVec3();
            Rotation = FRotation3f();
            Mode = EKinematicTargetMode::None;
        }
 
        void SetTargetMode(const FVec3& X, const FRotation3f& R)
        {
            Position = X;
            Rotation = R;
            Mode = EKinematicTargetMode::Position;
        }
 
        void SetTargetMode(const FRigidTransform3& InTarget)
        {
            Position = InTarget.GetLocation();
            Rotation = InTarget.GetRotation();
            Mode = EKinematicTargetMode::Position;
        }
 
        void SetVelocityMode() { Mode = EKinematicTargetMode::Velocity; }
 
        // For internal use only
        void SetMode(EKinematicTargetMode InMode) { Mode = InMode; }
 
        friend FChaosArchive& operator<<(FChaosArchive& Ar, FKinematicTarget& KinematicTarget)
        {
            Ar.UsingCustomVersion(FFortniteReleaseBranchCustomObjectVersion::GUID);
            Ar.UsingCustomVersion(FPhysicsObjectVersion::GUID);
            Ar.UsingCustomVersion(FFortniteMainBranchObjectVersion::GUID);
 
            const bool bRemovedScaleFN = (Ar.CustomVer(FFortniteReleaseBranchCustomObjectVersion::GUID) >= FFortniteReleaseBranchCustomObjectVersion::ChaosKinematicTargetRemoveScale);
            const bool bRemovedScaleUE4 = (Ar.CustomVer(FPhysicsObjectVersion::GUID) >= FPhysicsObjectVersion::ChaosKinematicTargetRemoveScale);
            const bool bRotationStoredAsSinglePrecision = (Ar.CustomVer(FFortniteMainBranchObjectVersion::GUID) >= FFortniteMainBranchObjectVersion::ChaosStoreKinematicTargetRotationAsSinglePrecision);
 
            if (bRemovedScaleFN || bRemovedScaleUE4)
            {
                Ar << KinematicTarget.Position;
 
                if (bRotationStoredAsSinglePrecision)
                {
                    Ar << KinematicTarget.Rotation;
                }
                else
                {
                    FRotation3 RotationDoublePrecision;
                    if (Ar.IsLoading())
                    {
                        Ar << RotationDoublePrecision;
                        KinematicTarget.Rotation = RotationDoublePrecision;
                    }
                    else
                    {
                        RotationDoublePrecision = KinematicTarget.Rotation;
                        Ar << RotationDoublePrecision;
                    }
                }
                
                Ar << KinematicTarget.Mode;
            }
            else
            {
                FRigidTransform3 Transform;
                Ar << Transform << KinematicTarget.Mode;
 
                KinematicTarget.Position = FVec3(Transform.GetLocation());
                KinematicTarget.Rotation = TRotation3<FRealSingle>(Transform.GetRotation());
            }
 
            return Ar;
        }
 
        bool IsEqual(const FKinematicTarget& other) const
        {
            return (
                Mode == other.Mode &&
                Position == other.Position &&
                Rotation == other.Rotation
                );
        }
 
        template <typename TOther>
        bool IsEqual(const TOther& other) const
        {
            return IsEqual(other.KinematicTarget());
        }
 
        bool operator==(const FKinematicTarget& other) const
        {
            return IsEqual(other);
        }
 
        template <typename TOther>
        void CopyFrom(const TOther& Other)
        {
            Position = Other.KinematicTarget().Position;
            Rotation = Other.KinematicTarget().Rotation;
            Mode = Other.KinematicTarget().Mode;
        }
 
        static FKinematicTarget ZeroValue()
        {
            return FKinematicTarget();
        }
 
    private:
        explicit FKinematicTarget(const FRigidTransform3& InTransform)
            : Rotation(InTransform.GetRotation())
            , Position(InTransform.GetTranslation())
            , Mode(EKinematicTargetMode::Position)
        {
        }
 
        FKinematicTarget(const FVec3& InPosition, const FRotation3f& InRotation)
            : Rotation(InRotation)
            , Position(InPosition)
            , Mode(EKinematicTargetMode::Position)
        {
        }
 
        FRotation3f Rotation;
        FVec3 Position;
        EKinematicTargetMode Mode;
    };
 
}