NetObjectFactory.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
 
#include "Iris/ReplicationSystem/NetObjectFactoryRegistry.h"
#include "Iris/ReplicationSystem/ReplicationBridgeTypes.h"
#include "Iris/ReplicationSystem/NetRefHandle.h"
 
#include "Misc/EnumClassFlags.h"
#include "Misc/Optional.h"
 
#include "NetObjectFactory.generated.h"
 
class UObjectReplicationBridge;
class UNetObjectFactory;
 
namespace UE::Net
{
    class FNetSerializationContext;
 
    struct FNetObjectResolveContext;
 
    typedef uint32 FReplicationProtocolIdentifier;
}
 
namespace UE::Net
{
 
struct FCreationHeaderContext
{
    FNetRefHandle Handle;
    UObjectReplicationBridge* Bridge;
    UNetObjectFactory* Factory;
    FNetSerializationContext& Serialization;
 
    FCreationHeaderContext(FNetRefHandle InHandle, UObjectReplicationBridge* InBridge, UNetObjectFactory* InFactory, FNetSerializationContext& InSerialization) : Handle(InHandle), Bridge(InBridge), Factory(InFactory), Serialization(InSerialization) {}
};
 
/*
 * Class holding the raw information allowing any client from retrieving or allocating a replicated UObject instance.
 * Can also implement the serialization of it's data into a bitstream
 */ 
class FNetObjectCreationHeader
{
public:
 
    virtual ~FNetObjectCreationHeader() {};
 
    void SetProtocolId(uint32 InId) { ProtocolIdentifier = InId; }
    void SetFactoryId(FNetObjectFactoryId InId) { FactoryId = InId; }
 
    FReplicationProtocolIdentifier GetProtocolId() const { return ProtocolIdentifier; }
    FNetObjectFactoryId GetNetFactoryId() const { return FactoryId; }
 
    virtual FString ToString() const { return TEXT("NotImplemented"); }
 
private:
 
    FReplicationProtocolIdentifier ProtocolIdentifier = 0;
    FNetObjectFactoryId  FactoryId = InvalidNetObjectFactoryId;
};
 
} // end namespace UE::Net
 
UCLASS(MinimalAPI, transient, abstract)
class UNetObjectFactory : public UObject
{
    GENERATED_BODY()
 
public:
 
    void Init(UE::Net::FNetObjectFactoryId InId, UObjectReplicationBridge* InBridge);
    void Deinit();
    void PostReceiveUpdate();
 
    struct FInstantiateResult;
    struct FInstantiateContext;
    struct FPostInstantiationContext;
    struct FPostInitContext;
    struct FDestroyedContext;
    struct FWorldInfoContext;
    struct FWorldInfoData;
 
    TUniquePtr<UE::Net::FNetObjectCreationHeader> CreateHeader(UE::Net::FNetRefHandle Handle, UE::Net::FReplicationProtocolIdentifier ProtocolId);
 
    bool WriteHeader(UE::Net::FNetRefHandle Handle, UE::Net::FNetSerializationContext& Serialization, const UE::Net::FNetObjectCreationHeader* Header);
 
    TUniquePtr<UE::Net::FNetObjectCreationHeader> ReadHeader(UE::Net::FNetRefHandle Handle, UE::Net::FNetSerializationContext& Serialization);
 
    virtual FInstantiateResult InstantiateReplicatedObjectFromHeader(const FInstantiateContext& Context, const UE::Net::FNetObjectCreationHeader* Header) PURE_VIRTUAL(UNetObjectFactory::InstantiateReplicatedObjectFromHeader, return FInstantiateResult(););
 
    virtual void PostInstantiation(const FPostInstantiationContext& Context) {}
 
    virtual void PostInit(const FPostInitContext& Context) {}
 
    virtual void DetachedFromReplication(const FDestroyedContext& Context) PURE_VIRTUAL(UNetObjectFactory::DetachedFromReplication, );
 
    UE_DEPRECATED(5.7, "Replaced by DetachedFromReplication")
    virtual void DestroyReplicatedObject(const FDestroyedContext& Context) final {}
 
    virtual void SubObjectCreatedFromReplication(UE::Net::FNetRefHandle RootObject, UE::Net::FNetRefHandle SubObjectCreated) {}
 
    virtual void SubObjectDetachedFromReplication(const FDestroyedContext& Context) {}
 
    virtual TOptional<FWorldInfoData> GetWorldInfo(const FWorldInfoContext& Context) const PURE_VIRTUAL(UNetObjectFactory::GetWorldInfo, return NullOpt;);
 
    virtual float GetPollFrequency(UE::Net::FNetRefHandle RootObjectHandle, UObject* RootObjectInstance) PURE_VIRTUAL(UNetObjectFactory::GetPollFrequency, return 100.f;);
 
public:
 
    struct FInstantiateResult
    {
        UObject* Instance = nullptr;
        UObject* Template = nullptr;
        EReplicationBridgeCreateNetRefHandleResultFlags Flags = EReplicationBridgeCreateNetRefHandleResultFlags::None;
    };
 
    struct FInstantiateContext
    {
        UE::Net::FNetRefHandle Handle;
 
        const UE::Net::FNetObjectResolveContext& ResolveContext;
 
        UE::Net::FNetRefHandle RootObjectOfSubObject;
 
        FInstantiateContext(UE::Net::FNetRefHandle InHandle, const UE::Net::FNetObjectResolveContext& InResolveContext, UE::Net::FNetRefHandle InRootObjectHandle) : Handle(InHandle), ResolveContext(InResolveContext), RootObjectOfSubObject(InRootObjectHandle) {}
 
        bool IsRootObject() const { return !RootObjectOfSubObject.IsValid(); }
        bool IsSubObject() const { return !IsRootObject(); }
    };
 
    struct FPostInstantiationContext
    {
        UObject* Instance = nullptr;
        const UE::Net::FNetObjectCreationHeader* Header = nullptr;
        uint32 ConnectionId = 0;
    };
 
    struct FPostInitContext
    {
        UObject* Instance = nullptr;
        UE::Net::FNetRefHandle Handle;
    };
 
    struct FDestroyedContext
    {
        UObject* DestroyedInstance = nullptr;
        UObject* RootObject = nullptr;
        EReplicationBridgeDestroyInstanceReason DestroyReason = EReplicationBridgeDestroyInstanceReason::DoNotDestroy;
        EReplicationBridgeDestroyInstanceFlags DestroyFlags = EReplicationBridgeDestroyInstanceFlags::None;
    };
 
    enum class EWorldInfoRequested : uint32
    {
        None = 0x0000,
        Location = 0x0001,
        CullDistance = 0x0002,
        All = Location | CullDistance,
    };
 
    struct FWorldInfoContext
    {
        UObject* Instance = nullptr;
 
        UE::Net::FNetRefHandle Handle;
 
        EWorldInfoRequested InfoRequested = EWorldInfoRequested::All;
    };
 
    struct FWorldInfoData
    {
        FVector WorldLocation = FVector::ZeroVector;
 
        float CullDistance = 0.0f;
    };
 
protected:
 
    virtual void OnInit() {}
 
    virtual void OnDeinit() {}
 
    virtual void OnPostReceiveUpdate() {}
 
    virtual TUniquePtr<UE::Net::FNetObjectCreationHeader> CreateAndFillHeader(UE::Net::FNetRefHandle Handle) PURE_VIRTUAL(UNetObjectFactory::CreateAndFillHeader, return nullptr;);
 
    virtual bool SerializeHeader(const UE::Net::FCreationHeaderContext& Context, const UE::Net::FNetObjectCreationHeader* Header) PURE_VIRTUAL(UNetObjectFactory::SerializeHeader, return false;);
 
    virtual TUniquePtr<UE::Net::FNetObjectCreationHeader> CreateAndDeserializeHeader(const UE::Net::FCreationHeaderContext& Context) PURE_VIRTUAL(UNetObjectFactory::CreateAndDeserializeHeader, return nullptr;);
 
protected:
 
    UObjectReplicationBridge* Bridge = nullptr;
    UE::Net::FNetObjectFactoryId FactoryId = UE::Net::InvalidNetObjectFactoryId;
 
};
 
ENUM_CLASS_FLAGS(UNetObjectFactory::EWorldInfoRequested);