UnrealNetwork.h File Reference

#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/CoreNet.h"
#include "EngineLogs.h"
#include "UObject/UnrealType.h"
#include "Engine/EngineBaseTypes.h"
#include "Net/Core/Connection/NetResult.h"
#include "Net/Core/PropertyConditions/PropertyConditions.h"
#include "Net/ReplayResult.h"
#include <type_traits>

Go to the source code of this file.

Classes
struct	FNetworkReplayDelegates
struct	FDoRepLifetimeParams
struct	NetworkingPrivate::FRepPropertyDescriptor
struct	NetworkingPrivate::FRepClassDescriptor
struct	CGetFastArrayCreateReplicationFragmentFuncable

Namespaces
namespace	NetworkingPrivate

Macros
#define	DOREPLIFETIME_WITH_PARAMS_FAST(c, v, params)
#define	DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY(c, v, params)
#define	DOREPLIFETIME_WITH_PARAMS(c, v, params)
#define	DOREPLIFETIME(c, v)   DOREPLIFETIME_WITH_PARAMS(c,v,FDoRepLifetimeParams())
#define	DOREPLIFETIME_DIFFNAMES(c, v, n)
#define	DOREPLIFETIME_CONDITION(c, v, cond)
#define	DOREPLIFETIME_CONDITION_NOTIFY(c, v, cond, rncond)
#define	DOREPLIFETIME_ACTIVE_OVERRIDE_FAST(c, v, active)
#define	DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY(c, v, active)
#define	DOREPLIFETIME_ACTIVE_OVERRIDE(c, v, active)
#define	DOREPCUSTOMCONDITION_ACTIVE_FAST(c, v, active)
#define	DOREPCUSTOMCONDITION_SETACTIVE_FAST(c, v, active)
#define	DOREPCUSTOMCONDITION_SETACTIVE_FAST_STATIC_ARRAY(c, v, active)
#define	DOREPDYNAMICCONDITION_INITCONDITION_FAST(c, v, cond)
#define	DOREPDYNAMICCONDITION_SETCONDITION_FAST(c, v, cond)
#define	DISABLE_REPLICATED_PROPERTY(c, v)   DisableReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), OutLifetimeProps);
#define	DISABLE_REPLICATED_PRIVATE_PROPERTY(c, v)   DisableReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), FName(TEXT(#v)), OutLifetimeProps);
#define	DISABLE_REPLICATED_PROPERTY_FAST(c, v)
#define	DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY(c, v)
#define	DISABLE_ALL_CLASS_REPLICATED_PROPERTIES(c, SuperClassBehavior)   DisableAllReplicatedPropertiesOfClass(StaticClass(), c::StaticClass(), SuperClassBehavior, OutLifetimeProps);
#define	DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST(c, SuperClassBehavior)
#define	RESET_REPLIFETIME_CONDITION(c, v, cond)   ResetReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), cond, OutLifetimeProps);
#define	RESET_REPLIFETIME(c, v)   RESET_REPLIFETIME_CONDITION(c, v, COND_None)
#define	RESET_REPLIFETIME_CONDITION_FAST(c, v, cond)
#define	RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY(c, v, cond)
#define	RESET_REPLIFETIME_FAST(c, v)   RESET_REPLIFETIME_CONDITION_FAST(c, v, COND_None)
#define	RESET_REPLIFETIME_FAST_STATIC_ARRAY(c, v)   RESET_REPLIFETIME_FAST_STATIC_ARRAY(c, v, COND_None)
#define	RESET_REPLIFETIME_WITH_PARAMS(c, v, params)   ResetReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), params, OutLifetimeProps);
#define	RESET_REPLIFETIME_FAST_WITH_PARAMS(c, v, params)
#define	RPC_VALIDATE(expression)

Typedefs
typedef TMap< FString, TArray< uint8 > >	FDemoFrameDataMap

Functions
int32	BestSignedDifference (int32 Value, int32 Reference, int32 Max)
int32	MakeRelative (int32 Value, int32 Reference, int32 Max)
	DECLARE_MULTICAST_DELEGATE_OneParam (FPreActorDestroyReplayScrub, AActor *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FPreReplayScrub, UWorld *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FReplayScrubTeardown, UWorld *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnWriteGameSpecificDemoHeader, TArray< FString > &)
	DECLARE_MULTICAST_DELEGATE_TwoParams (FOnProcessGameSpecificDemoHeader, const TArray< FString > &, FString &)
	DECLARE_MULTICAST_DELEGATE_ThreeParams (FOnWriteGameSpecificFrameData, UWorld *, float, FDemoFrameDataMap &)
	DECLARE_MULTICAST_DELEGATE_ThreeParams (FOnProcessGameSpecificFrameData, UWorld *, float, const FDemoFrameDataMap &)
	DECLARE_DELEGATE_OneParam (FGetOverridableVersionDataForDemoHeaderReadDelegate, FOverridableReplayVersionData &)
	DECLARE_DELEGATE_OneParam (FGetOverridableVersionDataForDemoHeaderWriteDelegate, FOverridableReplayVersionData &)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnReplayStartedDelegate, UWorld *)
PRAGMA_DISABLE_DEPRECATION_WARNINGS	DECLARE_MULTICAST_DELEGATE_TwoParams (FOnReplayStartFailureDelegate, UWorld *, EDemoPlayFailure::Type)
PRAGMA_ENABLE_DEPRECATION_WARNINGS	DECLARE_MULTICAST_DELEGATE_TwoParams (FOnReplayPlaybackFailureDelegate, UWorld *, const UE::Net::TNetResult< EReplayResult > &)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnReplayScrubCompleteDelegate, UWorld *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnReplayPlaybackCompleteDelegate, UWorld *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnReplayRecordingStartAttemptDelegate, UWorld *)
	DECLARE_MULTICAST_DELEGATE_OneParam (FOnReplayRecordingCompleteDelegate, UWorld *)
	DECLARE_MULTICAST_DELEGATE_TwoParams (FOnPauseChannelsChangedDelegate, UWorld *, bool)
	DECLARE_MULTICAST_DELEGATE_TwoParams (FOnReplayIDChangedDelegate, UWorld *, const FString &)
template<class BaseClass , class DerivedClass >
constexpr bool	ValidateReplicatedClassInheritance ()
FProperty *	GetReplicatedProperty (const UClass *CallingClass, const UClass *PropClass, const FName &PropName)
ENGINE_API void	RegisterReplicatedLifetimeProperty (const FProperty *ReplicatedProperty, TArray< FLifetimeProperty > &OutLifetimeProps, const FDoRepLifetimeParams &Params)
ENGINE_API void	RegisterReplicatedLifetimeProperty (const NetworkingPrivate::FRepPropertyDescriptor &PropertyDescriptor, TArray< FLifetimeProperty > &OutLifetimeProps, const FDoRepLifetimeParams &Params)
template<typename T >
TEnableIf< TModels_V< CGetFastArrayCreateReplicationFragmentFuncable, T >, constFDoRepLifetimeParams >::Type	FixupParams (const FDoRepLifetimeParams &Params)
template<typename T >
TEnableIf<!TModels_V< CGetFastArrayCreateReplicationFragmentFuncable, T >, constFDoRepLifetimeParams & >::Type	FixupParams (const FDoRepLifetimeParams &Params)
ENGINE_API void	DisableReplicatedLifetimeProperty (const UClass *ThisClass, const UClass *PropertyClass, FName PropertyName, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	DisableAllReplicatedPropertiesOfClass (const UClass *ThisClass, const UClass *ClassToDisable, EFieldIteratorFlags::SuperClassFlags SuperClassBehavior, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	DisableReplicatedLifetimeProperty (const NetworkingPrivate::FRepPropertyDescriptor &PropertyDescriptor, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	DisableAllReplicatedPropertiesOfClass (const NetworkingPrivate::FRepClassDescriptor &ClassDescriptor, EFieldIteratorFlags::SuperClassFlags SuperClassBehavior, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	ResetReplicatedLifetimeProperty (const UClass *ThisClass, const UClass *PropertyClass, FName PropertyName, ELifetimeCondition LifetimeCondition, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	ResetReplicatedLifetimeProperty (const NetworkingPrivate::FRepPropertyDescriptor &PropertyDescriptor, ELifetimeCondition LifetimeCondition, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	ResetReplicatedLifetimeProperty (const UClass *ThisClass, const UClass *PropertyClass, FName PropertyName, const FDoRepLifetimeParams &Params, TArray< FLifetimeProperty > &OutLifetimeProps)
ENGINE_API void	ResetReplicatedLifetimeProperty (const NetworkingPrivate::FRepPropertyDescriptor &PropertyDescriptor, const FDoRepLifetimeParams &Params, TArray< FLifetimeProperty > &OutLifetimeProps)

Macro Definition Documentation

DISABLE_ALL_CLASS_REPLICATED_PROPERTIES

#define DISABLE_ALL_CLASS_REPLICATED_PROPERTIES	(		c,
			SuperClassBehavior
	)		DisableAllReplicatedPropertiesOfClass(StaticClass(), c::StaticClass(), SuperClassBehavior, OutLifetimeProps);

Use this macro in GetLifetimeReplicatedProps to flag all replicated properties of a class as not-replicated. Use the EFieldIteratorFlags enum to disable all inherited properties or only those of the class specified

DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST

#define DISABLE_ALL_CLASS_REPLICATED_PROPERTIES_FAST	(		c,
			SuperClassBehavior
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), "DISABLE_ALL_CLASS_REPLICATED_PROPERTIES"); \
    const TCHAR* DoRepClassName_##c(TEXT(#c)); \
    const NetworkingPrivate::FRepClassDescriptor ClassDescriptor_##c(DoRepClassName_##c, (int32)c::ENetFields_Private::NETFIELD_REP_START, (int32)c::ENetFields_Private::NETFIELD_REP_END); \
	DisableAllReplicatedPropertiesOfClass(ClassDescriptor_##c, SuperClassBehavior, OutLifetimeProps); \
}

DISABLE_REPLICATED_PRIVATE_PROPERTY

#define DISABLE_REPLICATED_PRIVATE_PROPERTY	(		c,
			v
	)		DisableReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), FName(TEXT(#v)), OutLifetimeProps);

Use this macro to disable inherited properties that are private. Be careful since it removes a compile-time error when the variable doesn't exist

DISABLE_REPLICATED_PROPERTY

#define DISABLE_REPLICATED_PROPERTY	(		c,
			v
	)		DisableReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), OutLifetimeProps);

Use this macro in GetLifetimeReplicatedProps to flag a replicated property as not-replicated

DISABLE_REPLICATED_PROPERTY_FAST

#define DISABLE_REPLICATED_PROPERTY_FAST	(		c,
			v
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v, 1); \
	DisableReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, OutLifetimeProps); \
}

DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY

#define DISABLE_REPLICATED_PROPERTY_FAST_STATIC_ARRAY	(		c,
			v
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v##_STATIC_ARRAY, (int32)c::EArrayDims_Private::v); \
	DisableReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, OutLifetimeProps); \
}

DOREPCUSTOMCONDITION_ACTIVE_FAST

#define DOREPCUSTOMCONDITION_ACTIVE_FAST	(		c,
			v,
			active
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    OutActiveState.SetActiveState((uint16)c::ENetFields_Private::v, active); \
}

DOREPCUSTOMCONDITION_SETACTIVE_FAST

#define DOREPCUSTOMCONDITION_SETACTIVE_FAST	(		c,
			v,
			active
	)

Value:

{ \
    UE::Net::Private::FNetPropertyConditionManager::Get().SetPropertyActive(this, (uint16)c::ENetFields_Private::v, active); \
}

DOREPCUSTOMCONDITION_SETACTIVE_FAST_STATIC_ARRAY

#define DOREPCUSTOMCONDITION_SETACTIVE_FAST_STATIC_ARRAY	(		c,
			v,
			active
	)

Value:

{ \
    UE::Net::Private::FNetPropertyConditionManager& PropertyConditionManager = UE::Net::Private::FNetPropertyConditionManager::Get(); \
	for (int32 i = 0; i < (int32)c::EArrayDims_Private::v; ++i) \
    { \
        PropertyConditionManager.SetPropertyActive(this, (uint16)c::ENetFields_Private::v##_STATIC_ARRAY + i, active); \
    } \
}

DOREPDYNAMICCONDITION_INITCONDITION_FAST

#define DOREPDYNAMICCONDITION_INITCONDITION_FAST	(		c,
			v,
			cond
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    OutActiveState.SetDynamicCondition((uint16)c::ENetFields_Private::v, cond); \
}

To be used in a UObject's GetReplicatedCustomConditionState for example.

DOREPDYNAMICCONDITION_SETCONDITION_FAST

#define DOREPDYNAMICCONDITION_SETCONDITION_FAST	(		c,
			v,
			cond
	)

Value:

{ \
    UE::Net::Private::FNetPropertyConditionManager::Get().SetPropertyDynamicCondition(this, (uint16)c::ENetFields_Private::v, cond); \
}

To be used when a condition is to be changed. This should be called as soon as the condition changes, not during PreReplication.

Note

Changing the condition of a custom delta property, such as a FastArraySerializer, after it has replicated can result in unexpected behavior.

DOREPLIFETIME

#define DOREPLIFETIME	(		c,
			v
	)		DOREPLIFETIME_WITH_PARAMS(c,v,FDoRepLifetimeParams())

DOREPLIFETIME_ACTIVE_OVERRIDE

#define DOREPLIFETIME_ACTIVE_OVERRIDE	(		c,
			v,
			active
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    static FProperty* sp##v = GetReplicatedProperty(StaticClass(), c::StaticClass(),GET_MEMBER_NAME_CHECKED(c,v)); \
    UE::Net::Private::FNetPropertyConditionManager& PropertyConditionManager = UE::Net::Private::FNetPropertyConditionManager::Get(); \
	for (int32 i = 0; i < sp##v->ArrayDim; i++) \
    { \
        PropertyConditionManager.SetPropertyActiveOverride(this, sp##v->RepIndex + i, active); \
    } \
}

DOREPLIFETIME_ACTIVE_OVERRIDE_FAST

#define DOREPLIFETIME_ACTIVE_OVERRIDE_FAST	(		c,
			v,
			active
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    UE::Net::Private::FNetPropertyConditionManager::Get().SetPropertyActiveOverride(this, (int32)c::ENetFields_Private::v, active); \
}

DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY

#define DOREPLIFETIME_ACTIVE_OVERRIDE_FAST_STATIC_ARRAY	(		c,
			v,
			active
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    UE::Net::Private::FNetPropertyConditionManager& PropertyConditionManager = UE::Net::Private::FNetPropertyConditionManager::Get(); \
	for (int32 i = 0; i < (int32)c::EArrayDims_Private::v; ++i) \
    { \
        PropertyConditionManager.SetPropertyActiveOverride(this, (int32)c::ENetFields_Private::v##_STATIC_ARRAY + i, active); \
    } \
}

DOREPLIFETIME_CONDITION

#define DOREPLIFETIME_CONDITION	(		c,
			v,
			cond
	)

Value:

{ \
	static_assert(cond != COND_NetGroup, "COND_NetGroup cannot be used on replicated properties. Only when registering subobjects"); \
    FDoRepLifetimeParams LocalDoRepParams; \
    LocalDoRepParams.Condition = cond; \
	DOREPLIFETIME_WITH_PARAMS(c,v,LocalDoRepParams); \
}

DOREPLIFETIME_CONDITION_NOTIFY

#define DOREPLIFETIME_CONDITION_NOTIFY	(		c,
			v,
			cond,
			rncond
	)

Value:

{ \
	static_assert(cond != COND_NetGroup, "COND_NetGroup cannot be used on replicated properties. Only when registering subobjects"); \
    FDoRepLifetimeParams LocalDoRepParams; \
    LocalDoRepParams.Condition = cond; \
    LocalDoRepParams.RepNotifyCondition = rncond; \
	DOREPLIFETIME_WITH_PARAMS(c,v,LocalDoRepParams); \
}

Allows gamecode to specify RepNotify condition: REPNOTIFY_OnChanged (default) or REPNOTIFY_Always for when repnotify function is called

DOREPLIFETIME_DIFFNAMES

#define DOREPLIFETIME_DIFFNAMES	(		c,
			v,
			n
	)

Value:

{ \
    static TWeakFieldPtr<FProperty> __swp##v{};                         \
    const FProperty* sp##v = __swp##v.Get();                                \
	if (nullptr == sp##v)                                                  \
    {                                                                       \
        sp##v = GetReplicatedProperty(StaticClass(), c::StaticClass(), n);  \
        __swp##v = sp##v;                                                   \
    }                                                                       \
	for ( int32 i = 0; i < sp##v->ArrayDim; i++ )                          \
    {                                                                       \
        OutLifetimeProps.AddUnique( FLifetimeProperty( sp##v->RepIndex + i ) ); \
    }                                                                       \
}

This macro is used by nativized code (DynamicClasses), so the Property may be recreated.

DOREPLIFETIME_WITH_PARAMS

#define DOREPLIFETIME_WITH_PARAMS	(		c,
			v,
			params
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    FProperty* ReplicatedProperty = GetReplicatedProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v)); \
	PRAGMA_DISABLE_DEPRECATION_WARNINGS \
	RegisterReplicatedLifetimeProperty(ReplicatedProperty, OutLifetimeProps, FixupParams<decltype(c::v)>(params)); \
    PRAGMA_ENABLE_DEPRECATION_WARNINGS \
}

DOREPLIFETIME_WITH_PARAMS_FAST

#define DOREPLIFETIME_WITH_PARAMS_FAST	(		c,
			v,
			params
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v, 1); \
\
	PRAGMA_DISABLE_DEPRECATION_WARNINGS \
	RegisterReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, OutLifetimeProps, FixupParams<decltype(c::v)>(params)); \
    PRAGMA_ENABLE_DEPRECATION_WARNINGS \
}

DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY

#define DOREPLIFETIME_WITH_PARAMS_FAST_STATIC_ARRAY	(		c,
			v,
			params
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v##_STATIC_ARRAY, (int32)c::EArrayDims_Private::v); \
	RegisterReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, OutLifetimeProps, params); \
}

RESET_REPLIFETIME

#define RESET_REPLIFETIME	(		c,
			v
	)		RESET_REPLIFETIME_CONDITION(c, v, COND_None)

RESET_REPLIFETIME_CONDITION

#define RESET_REPLIFETIME_CONDITION	(		c,
			v,
			cond
	)		ResetReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), cond, OutLifetimeProps);

RESET_REPLIFETIME_CONDITION_FAST

#define RESET_REPLIFETIME_CONDITION_FAST	(		c,
			v,
			cond
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v, 1); \
	ResetReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, cond, OutLifetimeProps); \
}

RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY

#define RESET_REPLIFETIME_CONDITION_FAST_STATIC_ARRAY	(		c,
			v,
			cond
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v##_STATIC_ARRAY, (int32)c::EArrayDims_Private::v); \
	ResetReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, cond, OutLifetimeProps); \
}

RESET_REPLIFETIME_FAST

#define RESET_REPLIFETIME_FAST	(		c,
			v
	)		RESET_REPLIFETIME_CONDITION_FAST(c, v, COND_None)

RESET_REPLIFETIME_FAST_STATIC_ARRAY

#define RESET_REPLIFETIME_FAST_STATIC_ARRAY	(		c,
			v
	)		RESET_REPLIFETIME_FAST_STATIC_ARRAY(c, v, COND_None)

RESET_REPLIFETIME_FAST_WITH_PARAMS

#define RESET_REPLIFETIME_FAST_WITH_PARAMS	(		c,
			v,
			params
	)

Value:

{ \
	static_assert(ValidateReplicatedClassInheritance<c, ThisClass>(), #c "." #v " is not accessible from this class."); \
    const TCHAR* DoRepPropertyName_##c_##v(TEXT(#v)); \
    const NetworkingPrivate::FRepPropertyDescriptor PropertyDescriptor_##c_##v(DoRepPropertyName_##c_##v, (int32)c::ENetFields_Private::v, 1); \
	ResetReplicatedLifetimeProperty(PropertyDescriptor_##c_##v, params, OutLifetimeProps); \
}

RESET_REPLIFETIME_WITH_PARAMS

#define RESET_REPLIFETIME_WITH_PARAMS	(		c,
			v,
			params
	)		ResetReplicatedLifetimeProperty(StaticClass(), c::StaticClass(), GET_MEMBER_NAME_CHECKED(c,v), params, OutLifetimeProps);

RPC_VALIDATE

#define RPC_VALIDATE

(

expression

)

Value:

    if ( !( expression ) )                              \
    {                                                   \
		UE_LOG( LogNet, Warning,                      \
        TEXT("RPC_VALIDATE Failed: ")                   \
        TEXT( PREPROCESSOR_TO_STRING( expression ) )    \
        TEXT(" File: ")                                 \
        TEXT( PREPROCESSOR_TO_STRING( __FILE__ ) )      \
        TEXT(" Line: ")                                 \
        TEXT( PREPROCESSOR_TO_STRING( __LINE__ ) ) );   \
        return false;                                   \
    }

Typedef Documentation

FDemoFrameDataMap

typedef TMap<FString, TArray<uint8> > FDemoFrameDataMap

Function Documentation

BestSignedDifference()

int32 BestSignedDifference ( int32  Value, int32  Reference, int32  Max  )

inline

DECLARE_DELEGATE_OneParam() [1/2]

DECLARE_DELEGATE_OneParam	(	FGetOverridableVersionDataForDemoHeaderReadDelegate	,
		FOverridableReplayVersionData &
	)

DECLARE_DELEGATE_OneParam() [2/2]

DECLARE_DELEGATE_OneParam	(	FGetOverridableVersionDataForDemoHeaderWriteDelegate	,
		FOverridableReplayVersionData &
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [1/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnReplayPlaybackCompleteDelegate	,
		UWorld *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [2/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnReplayRecordingCompleteDelegate	,
		UWorld *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [3/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnReplayRecordingStartAttemptDelegate	,
		UWorld *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [4/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnReplayScrubCompleteDelegate	,
		UWorld *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [5/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnReplayStartedDelegate	,
		UWorld *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [6/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FOnWriteGameSpecificDemoHeader	,
		TArray< FString > &
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [7/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FPreActorDestroyReplayScrub	,
		AActor *
	)

DECLARE_MULTICAST_DELEGATE_OneParam() [8/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FPreReplayScrub	,
		UWorld *
	)

Fired at the start of replay checkpoint loading

DECLARE_MULTICAST_DELEGATE_OneParam() [9/9]

DECLARE_MULTICAST_DELEGATE_OneParam	(	FReplayScrubTeardown	,
		UWorld *
	)

Fired mid-checkpoint load after the previous game state is torn down, and prior to any GC

DECLARE_MULTICAST_DELEGATE_ThreeParams() [1/2]

DECLARE_MULTICAST_DELEGATE_ThreeParams	(	FOnProcessGameSpecificFrameData	,
		UWorld *	,
		float	,
		const FDemoFrameDataMap &
	)

DECLARE_MULTICAST_DELEGATE_ThreeParams() [2/2]

DECLARE_MULTICAST_DELEGATE_ThreeParams	(	FOnWriteGameSpecificFrameData	,
		UWorld *	,
		float	,
		FDemoFrameDataMap &
	)

DECLARE_MULTICAST_DELEGATE_TwoParams() [1/5]

DECLARE_MULTICAST_DELEGATE_TwoParams	(	FOnPauseChannelsChangedDelegate	,
		UWorld *	,
		bool
	)

DECLARE_MULTICAST_DELEGATE_TwoParams() [2/5]

DECLARE_MULTICAST_DELEGATE_TwoParams	(	FOnProcessGameSpecificDemoHeader	,
		const TArray< FString > &	,
		FString &
	)

DECLARE_MULTICAST_DELEGATE_TwoParams() [3/5]

DECLARE_MULTICAST_DELEGATE_TwoParams	(	FOnReplayIDChangedDelegate	,
		UWorld *	,
		const FString &
	)

DECLARE_MULTICAST_DELEGATE_TwoParams() [4/5]

PRAGMA_ENABLE_DEPRECATION_WARNINGS DECLARE_MULTICAST_DELEGATE_TwoParams	(	FOnReplayPlaybackFailureDelegate	,
		UWorld *	,
		const UE::Net::TNetResult< EReplayResult > &
	)

DECLARE_MULTICAST_DELEGATE_TwoParams() [5/5]

PRAGMA_DISABLE_DEPRECATION_WARNINGS DECLARE_MULTICAST_DELEGATE_TwoParams	(	FOnReplayStartFailureDelegate	,
		UWorld *	,
		EDemoPlayFailure::Type
	)

DisableAllReplicatedPropertiesOfClass() [1/2]

ENGINE_API void DisableAllReplicatedPropertiesOfClass	(	const NetworkingPrivate::FRepClassDescriptor &	ClassDescriptor,
		EFieldIteratorFlags::SuperClassFlags	SuperClassBehavior,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

DisableAllReplicatedPropertiesOfClass() [2/2]

ENGINE_API void DisableAllReplicatedPropertiesOfClass	(	const UClass *	ThisClass,
		const UClass *	ClassToDisable,
		EFieldIteratorFlags::SuperClassFlags	SuperClassBehavior,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

DisableReplicatedLifetimeProperty() [1/2]

ENGINE_API void DisableReplicatedLifetimeProperty	(	const NetworkingPrivate::FRepPropertyDescriptor &	PropertyDescriptor,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

DisableReplicatedLifetimeProperty() [2/2]

ENGINE_API void DisableReplicatedLifetimeProperty	(	const UClass *	ThisClass,
		const UClass *	PropertyClass,
		FName	PropertyName,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

FixupParams() [1/2]

template<typename T >

TEnableIf< TModels_V< CGetFastArrayCreateReplicationFragmentFuncable, T >, constFDoRepLifetimeParams >::Type FixupParams ( const FDoRepLifetimeParams &  Params )

inline

FixupParams() [2/2]

template<typename T >

TEnableIf<!TModels_V< CGetFastArrayCreateReplicationFragmentFuncable, T >, constFDoRepLifetimeParams & >::Type FixupParams ( const FDoRepLifetimeParams &  Params )

inline

GetReplicatedProperty()

FProperty * GetReplicatedProperty ( const UClass *  CallingClass, const UClass *  PropClass, const FName &  PropName  )

inline

wrapper to find replicated properties that also makes sure they're valid

MakeRelative()

int32 MakeRelative ( int32  Value, int32  Reference, int32  Max  )

inline

RegisterReplicatedLifetimeProperty() [1/2]

ENGINE_API void RegisterReplicatedLifetimeProperty	(	const FProperty *	ReplicatedProperty,
		TArray< FLifetimeProperty > &	OutLifetimeProps,
		const FDoRepLifetimeParams &	Params
	)

RegisterReplicatedLifetimeProperty() [2/2]

ENGINE_API void RegisterReplicatedLifetimeProperty	(	const NetworkingPrivate::FRepPropertyDescriptor &	PropertyDescriptor,
		TArray< FLifetimeProperty > &	OutLifetimeProps,
		const FDoRepLifetimeParams &	Params
	)

ResetReplicatedLifetimeProperty() [1/4]

ENGINE_API void ResetReplicatedLifetimeProperty	(	const NetworkingPrivate::FRepPropertyDescriptor &	PropertyDescriptor,
		const FDoRepLifetimeParams &	Params,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

ResetReplicatedLifetimeProperty() [2/4]

ENGINE_API void ResetReplicatedLifetimeProperty	(	const NetworkingPrivate::FRepPropertyDescriptor &	PropertyDescriptor,
		ELifetimeCondition	LifetimeCondition,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

ResetReplicatedLifetimeProperty() [3/4]

ENGINE_API void ResetReplicatedLifetimeProperty	(	const UClass *	ThisClass,
		const UClass *	PropertyClass,
		FName	PropertyName,
		const FDoRepLifetimeParams &	Params,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

ResetReplicatedLifetimeProperty() [4/4]

ENGINE_API void ResetReplicatedLifetimeProperty	(	const UClass *	ThisClass,
		const UClass *	PropertyClass,
		FName	PropertyName,
		ELifetimeCondition	LifetimeCondition,
		TArray< FLifetimeProperty > &	OutLifetimeProps
	)

ValidateReplicatedClassInheritance()

template<class BaseClass , class DerivedClass >

constexpr bool ValidateReplicatedClassInheritance ( )

constexpr