ReplicatedState.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "Engine/NetSerialization.h"
#include "ReplicatedState.generated.h"
 
UENUM()
enum class EVectorQuantization : uint8
{
    RoundWholeNumber,
    RoundOneDecimal,
    RoundTwoDecimals
};
 
UENUM()
enum class ERotatorQuantization : uint8
{
    ByteComponents,
    ShortComponents
};
 
USTRUCT()
struct FRepAttachment
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TObjectPtr<class AActor> AttachParent;
 
    UPROPERTY()
    FVector_NetQuantize100 LocationOffset;
 
    UPROPERTY()
    FVector_NetQuantize100 RelativeScale3D;
 
    UPROPERTY()
    FRotator RotationOffset;
 
    UPROPERTY()
    FName AttachSocket;
 
    UPROPERTY()
    TObjectPtr<class USceneComponent> AttachComponent;
 
    FRepAttachment()
        : AttachParent(nullptr)
        , LocationOffset(ForceInit)
        , RelativeScale3D(ForceInit)
        , RotationOffset(ForceInit)
        , AttachSocket(NAME_None)
        , AttachComponent(nullptr)
    { }
};
 
namespace ERigidBodyFlags
{
    enum Type
    {
        None = 0x00,
        Sleeping = 0x01,
        NeedsUpdate = 0x02,
        RepPhysics = 0x04 // This RigidBody was replicated from the server with simulating physics
    };
}
 
USTRUCT()
struct FRigidBodyState
{
    GENERATED_BODY()
 
    UPROPERTY()
    FVector_NetQuantize100 Position;
 
    UPROPERTY()
    FQuat Quaternion;
 
    UPROPERTY()
    FVector_NetQuantize100 LinVel;
 
    UPROPERTY()
    FVector_NetQuantize100 AngVel;
 
    UPROPERTY()
    uint8 Flags;
 
    FRigidBodyState()
        : Position(ForceInit)
        , Quaternion(ForceInit)
        , LinVel(ForceInit)
        , AngVel(ForceInit)
        , Flags(0)
    { }
};
 
USTRUCT()
struct FRepMovement
{
    GENERATED_BODY()
 
    
    UPROPERTY(Transient)
    FVector LinearVelocity;
 
    UPROPERTY(Transient)
    FVector AngularVelocity;
    
    UPROPERTY(Transient)
    FVector Location;
 
    UPROPERTY(Transient)
    FRotator Rotation;
 
    UPROPERTY(Transient)
    FVector Acceleration;
 
    UPROPERTY(Transient)
    uint8 bSimulatedPhysicSleep : 1;
 
    UPROPERTY(Transient)
    uint8 bRepPhysics : 1;
 
    UPROPERTY(Transient)
    uint8 bRepAcceleration : 1;
 
    UPROPERTY(Transient)
    int32 ServerFrame;
 
    UPROPERTY(Transient)
    int32 ServerPhysicsHandle = INDEX_NONE;
 
    UPROPERTY(EditDefaultsOnly, Category=Replication, AdvancedDisplay)
    EVectorQuantization LocationQuantizationLevel;
 
    UPROPERTY(EditDefaultsOnly, Category=Replication, AdvancedDisplay)
    EVectorQuantization VelocityQuantizationLevel;
 
    UPROPERTY(EditDefaultsOnly, Category=Replication, AdvancedDisplay)
    ERotatorQuantization RotationQuantizationLevel;
 
    ENGINE_API FRepMovement();
 
    ENGINE_API bool SerializeQuantizedVector(FArchive& Ar, FVector& Vector, EVectorQuantization QuantizationLevel);
 
    ENGINE_API bool NetSerialize(FArchive& Ar, class UPackageMap* Map, bool& bOutSuccess);
 
    void FillFrom(const FRigidBodyState& RBState, const AActor* const Actor = nullptr, int32 InServerFrame = 0)
    {
        Location = RebaseOntoZeroOrigin(RBState.Position, Actor);
        Rotation = RBState.Quaternion.Rotator();
        LinearVelocity = RBState.LinVel;
        AngularVelocity = RBState.AngVel;
        bSimulatedPhysicSleep = (RBState.Flags & ERigidBodyFlags::Sleeping) != 0;
        bRepPhysics = true;
        ServerFrame = InServerFrame;
    }
 
    void CopyTo(FRigidBodyState& RBState, const AActor* const Actor = nullptr) const
    {
        RBState.Position = RebaseOntoLocalOrigin(Location, Actor);
        RBState.Quaternion = Rotation.Quaternion();
        RBState.LinVel = LinearVelocity;
        RBState.AngVel = AngularVelocity;
        RBState.Flags = 
            (decltype(FRigidBodyState::Flags))(bSimulatedPhysicSleep ? ERigidBodyFlags::Sleeping : ERigidBodyFlags::None)
            | ERigidBodyFlags::NeedsUpdate
            | (decltype(FRigidBodyState::Flags))(bRepPhysics ? ERigidBodyFlags::RepPhysics : ERigidBodyFlags::None);
    }
 
    bool operator==(const FRepMovement& Other) const
    {
        if ( LinearVelocity != Other.LinearVelocity )
        {
            return false;
        }
 
        if ( AngularVelocity != Other.AngularVelocity )
        {
            return false;
        }
 
        if ( Location != Other.Location )
        {
            return false;
        }
 
        if ( Rotation != Other.Rotation )
        {
            return false;
        }
 
        if (bRepAcceleration && (Acceleration != Other.Acceleration))
        {
            return false;
        }
 
        if ( bSimulatedPhysicSleep != Other.bSimulatedPhysicSleep )
        {
            return false;
        }
 
        if ( bRepPhysics != Other.bRepPhysics )
        {
            return false;
        }
 
        if ( bRepAcceleration != Other.bRepAcceleration )
        {
            return false;
        }
 
        return true;
    }
 
    bool operator!=(const FRepMovement& Other) const
    {
        return !(*this == Other);
    }
 
    static ENGINE_API int32 EnableMultiplayerWorldOriginRebasing;
 
    static ENGINE_API FVector RebaseOntoLocalOrigin(const FVector& Location, const FIntVector& LocalOrigin);
 
    static ENGINE_API FVector RebaseOntoZeroOrigin(const FVector& Location, const FIntVector& LocalOrigin);
 
    static ENGINE_API FVector RebaseOntoLocalOrigin(const FVector& Location, const AActor* const WorldContextActor);
 
    static ENGINE_API FVector RebaseOntoZeroOrigin(const FVector& Location, const AActor* const WorldContextActor);
 
    static ENGINE_API FVector RebaseOntoLocalOrigin(const FVector& Location, const class UActorComponent* const WorldContextActorComponent);
 
    static ENGINE_API FVector RebaseOntoZeroOrigin(const FVector& Location, const class UActorComponent* const WorldContextActorComponent);
};
 
template<>
struct TStructOpsTypeTraits<FRepMovement> : public TStructOpsTypeTraitsBase2<FRepMovement>
{
    enum
    {
        WithNetSerializer = true,
        WithNetSharedSerialization = true,
    };
};