PushModel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "PushModelMacros.h"
 
#if WITH_PUSH_MODEL
 
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "UObject/ObjectKey.h"
 
#if 0
USTRUCT()
struct FMyAwesomeStruct
{
    UPROPERTY()
    int32 SomeReplicatedProperty;
 
    UPROPERTY()
    bool bSomeOtherReplicatedProperty;
}
 
UCLASS()
class AMyAwesomeActor : public AActor
{
    GENERATED_BODY()
 
    
    void SetMyReplicatedBool(const bool bNewValue)
    {
        bMyReplicatedBool = bNewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, bMyReplicatedBool, this);
    }
 
    UFUNCTION(BlueprintCallable)
    void SetMyBlueprintProperty(const int32 NewValue)
    {
        MyBlueprintProperty = NewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, MyBlueprintProperty, this);
    }
 
    void MySetter(const FString& NewValue)
    {
        MyBlueprintSetterProperty = NewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, MyBlueprintSetterProperty, this);
    }
 
    void SetStaticArrayValue(const int32 NewValue, const int32 Index)
    {
        MyStaticArray[Index] = NewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX(AMyAwesomeActor, MyStaticArray, Index, this);
    }
 
    void SetEntireStaticArray(const int32 NewArray[4])
    {
        MyStaticArray = NewArray;
        MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY(AMyAwesomeActor, MyStaticArray, this);
    }
 
    void UpdateMyStruct(int32 NewValue)
    {
        MyStruct.SomeReplicatedProperty = NewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, MyStruct, this);
    }
 
    void UpdateMyStruct(bool bNewValue)
    {
        MyStruct.bSomeOtherReplicatedProperty = bNewValue;
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, MyStruct, this);
    }
 
    FMyAwesomeStruct& GetMyStruct_Mutable()
    {
        MARK_PROPERTY_DIRTY_FROM_NAME(AMyAwesomeActor, MyStruct, this);
        return MyStruct;
    }
 
    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override
    {
        Super::GetLifetimeReplicatedProps(OutLifetimeProps);
 
        FDoRepLifetimeParams Params;
 
        Params.bIsPushBased = true;
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, bMyReplicatedBool, Params);
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, MyBlueprintProperty, Params);
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, MyBlueprintSetterProperty, Params);
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, MyStruct, Params);
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, MyStaticArray, Params);
 
        Params.bIsPushBased = false;
        DOREPLIFETIME_WITH_PARAMS_FAST(AMyAwesomeActor, NonPushModelProperty, Params);
    }
 
private:
 
    UPROPERTY(Replicated)
    bool bMyReplicatedBool;
 
    UPROPERTY(Replicated, BlueprintReadWrite, Meta=(AllowPrivateAccess="true"))
    int32 MyBlueprintProperty;
 
    UPROPERTY(Replicated, BlueprintSetter=SetMyBlueprintSetterProperty, Meta = (AllowPrivateAccess = "true"))
    FString MyBlueprintSetterProperty;
 
    UPROPERTY(Replicated)
    FMyAwesomeStruct MyStruct;
 
    UPROPERTY(Replicated)
    int32 MyStaticArray[4];
 
    UPROPERTY(Replicated)
    int32 NonPushModelProperty;
};
#endif
 
// DO NOT USE METHODS IN THIS NAMESPACE DIRECTLY
// Use the Macros instead, as they respect conditional compilation.
// See PushModelMarcos.h
namespace UEPushModelPrivate
{
    //~ Using int32 isn't very forward looking, but for now GUObjectArray also uses int32
    //~ so we're probably safe.
 
    using FNetPushPerNetDriverId = int32;
    using FNetLegacyPushObjectId = int32;
    using FNetIrisPushObjectId = uint64;
 
    // The ID need to be able to handle both Iris and non-Iris replication.
    struct FNetPushObjectId
    {
        FNetPushObjectId() : Value(0xFFFFFFFFFFFFFFFFULL) {}
        explicit FNetPushObjectId(FNetLegacyPushObjectId Id) { Value = 0xFFFFFFFF00000000ULL | uint32(Id); }
        explicit FNetPushObjectId(FNetIrisPushObjectId Id) { Value = Id; }
 
        bool IsValid() const { return Value != 0xFFFFFFFFFFFFFFFFULL; }
        bool IsIrisId() const { return uint32(Value >> 32U) != 0xFFFFFFFFU; }
        uint64 GetValue() const { return Value; }
 
        FNetLegacyPushObjectId GetLegacyPushObjectId() const { return FNetLegacyPushObjectId(Value & 0xFFFFFFFFU);}
        FNetIrisPushObjectId GetIrisPushObjectId() const { return Value;}
 
    private:
        uint64 Value;
    };
 
    struct FPushModelPerNetDriverHandle
    {
        FPushModelPerNetDriverHandle(const FNetPushPerNetDriverId InNetDriverId, const FNetLegacyPushObjectId InObjectId)
            : NetDriverId(InNetDriverId)
            , ObjectId(InObjectId)
        {
            // They should either both be valid, or both invalid.
            check((INDEX_NONE == ObjectId) == (INDEX_NONE == NetDriverId));
        }
 
        const FNetPushPerNetDriverId NetDriverId;
        
        const FNetLegacyPushObjectId ObjectId;
 
        const bool IsValid() const
        {
            return INDEX_NONE != ObjectId;
        }
 
        static FPushModelPerNetDriverHandle MakeInvalidHandle()
        {
            return FPushModelPerNetDriverHandle(INDEX_NONE, INDEX_NONE);
        }
    };
 
    extern NETCORE_API bool bIsPushModelEnabled;
    extern NETCORE_API bool bMakeBpPropertiesPushModel;
 
    static const bool IsPushModelEnabled()
    {
        return bIsPushModelEnabled;
    }
 
    static const bool MakeBpPropertiesPushModel()
    {
        return bMakeBpPropertiesPushModel;
    }
 
    NETCORE_API bool IsHandleCreationAllowed();
 
    NETCORE_API void SetHandleCreationAllowed(bool bAllow);
    
    static FString ToString(const FNetPushObjectId Id)
    {
        return FString::Printf(TEXT("0x%" UINT64_X_FMT), Id.GetValue());
    }
 
    NETCORE_API void MarkPropertyDirty(const UObject* Object, const FNetPushObjectId ObjectId, const int32 RepIndex);
 
    NETCORE_API void MarkPropertyDirty(const UObject* Object, const FNetPushObjectId ObjectId, const int32 StartRepIndex, const int32 EndRepIndex);
 
    //~ As the comments above state, none of the methods in this namespace should be invoked directly.
    //~ Particularly, the methods below are **only** needed by internal systems.
    //~ When Push Model is enabled, registration is handled automatically by the networking system, so no
    //~ extra dev work is required.
 
    NETCORE_API const FPushModelPerNetDriverHandle AddPushModelObject(const FObjectKey ObjectId, const uint16 NumberOfReplicatedProperties);
    NETCORE_API void RemovePushModelObject(const FPushModelPerNetDriverHandle Handle);
 
    NETCORE_API class FPushModelPerNetDriverState* GetPerNetDriverState(const FPushModelPerNetDriverHandle Handle);
 
    NETCORE_API bool DoesHaveDirtyPropertiesOrRecentlyCollectedGarbage(const FPushModelPerNetDriverHandle Handle);
 
    NETCORE_API bool ValidateObjectIdReassignment(FNetLegacyPushObjectId CurrentId, FNetLegacyPushObjectId NewId);
 
    NETCORE_API void LogMemory(FOutputDevice& Ar);
 
    // For internal use only.
    DECLARE_DELEGATE_ThreeParams(FIrisMarkPropertyDirty, const UObject*, UEPushModelPrivate::FNetIrisPushObjectId, const int32);
    DECLARE_DELEGATE_FourParams(FIrisMarkPropertiesDirty, const UObject*, UEPushModelPrivate::FNetIrisPushObjectId, const int32, const int32);
 
    NETCORE_API void SetIrisMarkPropertyDirtyDelegate(const FIrisMarkPropertyDirty& Delegate);
    NETCORE_API void SetIrisMarkPropertiesDirtyDelegate(const FIrisMarkPropertiesDirty& Delegate);
}
 
 
#define CONDITIONAL_ON_PUSH_MODEL(Work) if (UEPushModelPrivate::IsPushModelEnabled()) { Work; }
#define IS_PUSH_MODEL_ENABLED() UEPushModelPrivate::IsPushModelEnabled()
#define PUSH_MAKE_BP_PROPERTIES_PUSH_MODEL() (UEPushModelPrivate::IsPushModelEnabled() && UEPushModelPrivate::MakeBpPropertiesPushModel())
 
#define GET_PROPERTY_REP_INDEX(ClassName, PropertyName) (int32)ClassName::ENetFields_Private::PropertyName
#define GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START(ClassName, PropertyName) ((int32)ClassName::ENetFields_Private::PropertyName ## _STATIC_ARRAY)
#define GET_PROPERTY_REP_INDEX_STATIC_ARRAY_END(ClassName, PropertyName) ((int32)ClassName::ENetFields_Private::PropertyName ## _STATIC_ARRAY_END)
#define GET_PROPERTY_REP_INDEX_STATIC_ARRAY_INDEX(ClassName, PropertyName, ArrayIndex) (GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START(ClassName, PropertyName) + ArrayIndex)
 
#define IS_PROPERTY_REPLICATED(Property) (0 != (EPropertyFlags::CPF_Net & Property->PropertyFlags))
 
#define CONDITIONAL_ON_OBJECT_NET_ID(Object, Work) { const UEPushModelPrivate::FNetPushObjectId PrivatePushId(Object->GetNetPushId()); Work; }
#define CONDITIONAL_ON_OBJECT_NET_ID_DYNAMIC(Object, Work) { const UEPushModelPrivate::FNetPushObjectId PrivatePushId(Object->GetNetPushIdDynamic()); Work; }
#define CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID(Object, Property, Work) if (IS_PROPERTY_REPLICATED(Property)) { const UEPushModelPrivate::FNetPushObjectId PrivatePushId(Object->GetNetPushIdDynamic()); Work; }
 
//~ For these macros, we won't bother checking if Push Model is enabled. Instead, we'll just check to see whether or not the Custom ID is valid.
 
// Marks a property dirty by RepIndex without doing additional rep index validation.
#define MARK_PROPERTY_DIRTY_UNSAFE(Object, RepIndex) CONDITIONAL_ON_OBJECT_NET_ID_DYNAMIC(Object, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, RepIndex))
 
// Marks a property dirty by UProperty*, validating that it's actually a replicated property.
#define MARK_PROPERTY_DIRTY(Object, Property) CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID(Object, Property, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, Property->RepIndex))
 
 
// Marks a static array property dirty given, the Object, UProperty*, and Index.
#define MARK_PROPERTY_DIRTY_STATIC_ARRAY_INDEX(Object, Property, ArrayIndex) CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID(Object, Property, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, Property->RepIndex + ArrayIndex))
 
// Marks all elements of a static array property dirty, given the Object and UProperty*
#define MARK_PROPERTY_DIRTY_STATIC_ARRAY(Object, Property) CONDITIONAL_ON_REP_INDEX_AND_OBJECT_NET_ID(Object, Property, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, Property->RepIndex, Property->RepIndex + Property->ArrayDim - 1))
 
 
// Marks a property dirty, given the Class Name, Property Name, and Object. This will fail to compile if the Property or Class aren't valid.
#define MARK_PROPERTY_DIRTY_FROM_NAME(ClassName, PropertyName, Object) CONDITIONAL_ON_OBJECT_NET_ID(Object, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, GET_PROPERTY_REP_INDEX(ClassName, PropertyName)))
 
// Marks a static array property dirty, given the Class Name, Property Name, Index, and Object. This will fail to compile if the Property and Class aren't valid. Callers are responsible for validating the index.
#define MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX(ClassName, PropertyName, ArrayIndex, Object) CONDITIONAL_ON_OBJECT_NET_ID(Object, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, GET_PROPERTY_REP_INDEX_STATIC_ARRAY_INDEX(ClassName, PropertyName, ArrayIndex)))
 
// Marks an entire static array property dirty, given the Class Name, Property Name, and Object. This will fail to compile if the Property or Class aren't valid.
#define MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY(ClassName, PropertyName, Object) CONDITIONAL_ON_OBJECT_NET_ID(Object, UEPushModelPrivate::MarkPropertyDirty(Object, PrivatePushId, GET_PROPERTY_REP_INDEX_STATIC_ARRAY_START(ClassName, PropertyName), GET_PROPERTY_REP_INDEX_STATIC_ARRAY_END(ClassName, PropertyName)))
 
#define COMPARE_ASSIGN_AND_MARK_PROPERTY_DIRTY(ClassName, PropertyName, NewValue, Object) \
    if (NewValue != PropertyName) { PropertyName = NewValue; MARK_PROPERTY_DIRTY_FROM_NAME(ClassName, PropertyName, Object); }
 
#define UE_NET_SET_IRIS_MARK_PROPERTY_DIRTY_DELEGATE(Delegate) UEPushModelPrivate::SetIrisMarkPropertyDirtyDelegate(Delegate)
#define UE_NET_SET_IRIS_MARK_PROPERTIES_DIRTY_DELEGATE(Delegate) UEPushModelPrivate::SetIrisMarkPropertiesDirtyDelegate(Delegate)
 
#else // WITH_PUSH_MODEL
 
#define MARK_PROPERTY_DIRTY_UNSAFE(Object, RepIndex)
#define MARK_PROPERTY_DIRTY(Object, Property) 
#define MARK_PROPERTY_DIRTY_STATIC_ARRAY_INDEX(Object, RepIndex, ArrayIndex) 
#define MARK_PROPERTY_DIRTY_STATIC_ARRAY(Object, RepIndex, ArrayIndex) 
 
#define MARK_PROPERTY_DIRTY_FROM_NAME(ClassName, PropertyName, Object) 
#define MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY_INDEX(ClassName, PropertyName, ArrayIndex, Object) 
#define MARK_PROPERTY_DIRTY_FROM_NAME_STATIC_ARRAY(ClassName, PropertyName, ArrayIndex, Object) 
 
 
#define GET_PROPERTY_REP_INDEX(ClassName, PropertyName) INDEX_NONE
#define GET_PROPERTY_REP_INDEX_STATIC_ARRAY(ClassName, PropertyName, ArrayIndex) INDEX_NONE
 
#define IS_PUSH_MODEL_ENABLED() false
#define PUSH_MAKE_BP_PROPERTIES_PUSH_MODEL() false
 
#define COMPARE_ASSIGN_AND_MARK_PROPERTY_DIRTY(ClassName, PropertyName, NewValue, Object) \
    if (NewValue != PropertyName) { PropertyName = NewValue; }
 
#define UE_NET_SET_IRIS_MARK_PROPERTY_DIRTY_DELEGATE(...)
#define UE_NET_SET_IRIS_MARK_PROPERTIES_DIRTY_DELEGATE(...)
 
#endif