617 lines
24 KiB
C++
617 lines
24 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "ReplicatedTestObject.h"
|
|
#include "ReplicatedTestObjectFactory.h"
|
|
#include "NetworkAutomationTest.h"
|
|
#include "NetworkAutomationTestMacros.h"
|
|
#include "Iris/ReplicationState/PropertyReplicationState.h"
|
|
#include "Iris/ReplicationSystem/NetRefHandle.h"
|
|
#include "Iris/ReplicationSystem/RepTag.h"
|
|
#include "Iris/ReplicationSystem/ReplicationProtocol.h"
|
|
#include "Iris/ReplicationSystem/ReplicationBridge.h"
|
|
#include "Iris/ReplicationSystem/ReplicationSystem.h"
|
|
#include "Iris/ReplicationSystem/ReplicationSystemInternal.h"
|
|
#include "Iris/ReplicationState/InternalPropertyReplicationState.h"
|
|
#include "Iris/ReplicationSystem/ReplicationFragmentUtil.h"
|
|
#include "Iris/ReplicationState/ReplicationStateDescriptorBuilder.h"
|
|
#include "Iris/ReplicationState/ReplicationStateDescriptorImplementationMacros.h"
|
|
#include "Iris/Serialization/NetBitStreamWriter.h"
|
|
#include "Iris/Serialization/NetBitStreamReader.h"
|
|
#include "Iris/Serialization/NetSerializers.h"
|
|
#include "Iris/Core/MemoryLayoutUtil.h"
|
|
#include "Templates/SharedPointer.h"
|
|
#include "Containers/Map.h"
|
|
#include "UObject/StrongObjectPtr.h"
|
|
#include "Net/Core/PushModel/PushModel.h"
|
|
#include "Net/UnrealNetwork.h"
|
|
#include "Iris/Serialization/NetBitStreamUtil.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UReplicatedTestObjectBridge
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
UReplicatedTestObjectBridge::UReplicatedTestObjectBridge()
|
|
: UObjectReplicationBridge()
|
|
{
|
|
|
|
}
|
|
|
|
void UReplicatedTestObjectBridge::Initialize(UReplicationSystem* InReplicationSystem)
|
|
{
|
|
Super::Initialize(InReplicationSystem);
|
|
|
|
ReplicatedObjectFactoryId = UE::Net::FNetObjectFactoryRegistry::GetFactoryIdFromName(UReplicatedTestObjectFactory::GetFactoryName());
|
|
check(ReplicatedObjectFactoryId != UE::Net::InvalidNetObjectFactoryId);
|
|
}
|
|
|
|
const UE::Net::FReplicationInstanceProtocol* UReplicatedTestObjectBridge::GetReplicationInstanceProtocol(FNetRefHandle Handle) const
|
|
{
|
|
const UE::Net::Private::FNetRefHandleManager* LocalNetRefHandleManager = &GetReplicationSystem()->GetReplicationSystemInternal()->GetNetRefHandleManager();
|
|
|
|
if (uint32 InternalObjectIndex = LocalNetRefHandleManager->GetInternalIndex(Handle))
|
|
{
|
|
return LocalNetRefHandleManager->GetReplicatedObjectDataNoCheck(InternalObjectIndex).InstanceProtocol;
|
|
}
|
|
|
|
return nullptr;
|
|
};
|
|
|
|
UE::Net::FNetRefHandle UReplicatedTestObjectBridge::BeginReplication(UReplicatedTestObject* Instance)
|
|
{
|
|
// Create NetRefHandle for the registered fragments
|
|
FRootObjectReplicationParams Params;
|
|
FNetRefHandle Handle = StartReplicatingRootObject(Instance, Params, ReplicatedObjectFactoryId);
|
|
|
|
// This is optional but typically we want to cache at least the NetRefHandle in the game instance to avoid doing map lookups to find it
|
|
if (Handle.IsValid())
|
|
{
|
|
Instance->NetRefHandle = Handle;
|
|
}
|
|
|
|
return Handle;
|
|
}
|
|
|
|
UE::Net::FNetRefHandle UReplicatedTestObjectBridge::BeginReplication(UReplicatedTestObject* Instance, const UObjectReplicationBridge::FRootObjectReplicationParams& Params)
|
|
{
|
|
// Create NetRefHandle for the registered fragments
|
|
FNetRefHandle Handle = Super::StartReplicatingRootObject(Instance, Params, ReplicatedObjectFactoryId);
|
|
|
|
// This is optional but typically we want to cache at least the NetRefHandle in the game instance to avoid doing map lookups to find it
|
|
if (Handle.IsValid())
|
|
{
|
|
Instance->NetRefHandle = Handle;
|
|
}
|
|
|
|
return Handle;
|
|
}
|
|
|
|
UE::Net::FNetRefHandle UReplicatedTestObjectBridge::BeginReplication(FNetRefHandle OwnerHandle, UReplicatedTestObject* SubObjectInstance, FNetRefHandle InsertRelativeToSubObjectHandle, ESubObjectInsertionOrder InsertionOrder)
|
|
{
|
|
check(OwnerHandle.IsValid());
|
|
|
|
// Create NetRefHandle for the registered fragments
|
|
const FSubObjectReplicationParams Params { .RootObjectHandle = OwnerHandle, .InsertRelativeToSubObjectHandle = InsertRelativeToSubObjectHandle, .InsertionOrder = InsertionOrder };
|
|
FNetRefHandle Handle = Super::StartReplicatingSubObject(SubObjectInstance, Params, ReplicatedObjectFactoryId);
|
|
|
|
if (Handle.IsValid())
|
|
{
|
|
// This is optional but typically we want to cache at least the NetRefHandle in the game instance to avoid doing map lookups to find it
|
|
SubObjectInstance->NetRefHandle = Handle;
|
|
SubObjectInstance->bIsSubObject = true;
|
|
}
|
|
|
|
return Handle;
|
|
}
|
|
|
|
void UReplicatedTestObjectBridge::EndReplication(UReplicatedTestObject* Instance, EEndReplicationFlags Flags)
|
|
{
|
|
StopReplicatingNetObject(Instance, Flags);
|
|
}
|
|
|
|
|
|
bool UReplicatedTestObjectBridge::IsAllowedToDestroyInstance(const UObject* Instance) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void UReplicatedTestObjectBridge::SetExternalWorldLocationUpdateFunctor(TFunction<void(FNetRefHandle NetHandle, const UObject* ReplicatedObject, FVector& OutLocation, float& OutCullDistance)> LocUpdateFunctor)
|
|
{
|
|
UReplicatedTestObjectFactory* TestFactory = CastChecked<UReplicatedTestObjectFactory>(GetNetFactory(ReplicatedObjectFactoryId));
|
|
TestFactory->SetWorldUpdateFunctor(LocUpdateFunctor);
|
|
}
|
|
|
|
void UReplicatedTestObjectBridge::SetExternalPreUpdateFunctor(TFunction<void(TArrayView<UObject*>, const UReplicationBridge*)> PreUpdateFunctor)
|
|
{
|
|
SetInstancePreUpdateFunction(PreUpdateFunctor);
|
|
}
|
|
|
|
void UReplicatedTestObjectBridge::SetCreatedObjectsOnNode(TArray<TStrongObjectPtr<UObject>>* InCreatedObjectsOnNode)
|
|
{
|
|
using namespace UE::Net;
|
|
UNetObjectFactory* Factory = GetNetFactory(ReplicatedObjectFactoryId);
|
|
if (ensure(Factory))
|
|
{
|
|
CastChecked<UReplicatedTestObjectFactory>(Factory)->SetCreatedObjectsOnNode(InCreatedObjectsOnNode);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisPropertyComponent
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisPropertyComponent::UTestReplicatedIrisPropertyComponent() : UObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisPropertyComponent::GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const
|
|
{
|
|
DOREPLIFETIME(UTestReplicatedIrisPropertyComponent, IntA);
|
|
DOREPLIFETIME(UTestReplicatedIrisPropertyComponent, StructWithStructWithTag);
|
|
DOREPLIFETIME_CONDITION(UTestReplicatedIrisPropertyComponent, IntB, COND_InitialOnly);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisPushModelComponentWithObjectReference
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisPushModelComponentWithObjectReference::UTestReplicatedIrisPushModelComponentWithObjectReference() : UObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisPushModelComponentWithObjectReference::GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const
|
|
{
|
|
FDoRepLifetimeParams LifetimeParams;
|
|
LifetimeParams.bIsPushBased = true;
|
|
|
|
DOREPLIFETIME_WITH_PARAMS(ThisClass, IntA, LifetimeParams);
|
|
DOREPLIFETIME_WITH_PARAMS(ThisClass, RawObjectPtrRef, LifetimeParams);
|
|
DOREPLIFETIME_WITH_PARAMS(ThisClass, WeakObjectPtrObjectRef, LifetimeParams);
|
|
}
|
|
|
|
void UTestReplicatedIrisPushModelComponentWithObjectReference::ModifyIntA()
|
|
{
|
|
IntA += 1;
|
|
MARK_PROPERTY_DIRTY_FROM_NAME(ThisClass, IntA, this);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisDynamicStatePropertyComponent
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisDynamicStatePropertyComponent::UTestReplicatedIrisDynamicStatePropertyComponent() : UObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisDynamicStatePropertyComponent::GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const
|
|
{
|
|
DOREPLIFETIME(UTestReplicatedIrisDynamicStatePropertyComponent, IntArray);
|
|
DOREPLIFETIME(UTestReplicatedIrisDynamicStatePropertyComponent, IntStaticArray);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisLifetimeConditionalsPropertyState
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisLifetimeConditionalsPropertyState::UTestReplicatedIrisLifetimeConditionalsPropertyState() : UObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisLifetimeConditionalsPropertyState::GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const
|
|
{
|
|
DOREPLIFETIME_CONDITION(ThisClass, ToOwnerA, COND_OwnerOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, ToOwnerB, COND_OwnerOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, ReplayOrOwner, COND_ReplayOrOwner);
|
|
|
|
DOREPLIFETIME_CONDITION(ThisClass, SkipOwnerA, COND_SkipOwner);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SkipOwnerB, COND_SkipOwner);
|
|
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOnlyInt, COND_SimulatedOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, AutonomousOnlyInt, COND_AutonomousOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOrPhysicsInt, COND_SimulatedOrPhysics);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOnlyNoReplayInt, COND_SimulatedOnlyNoReplay);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOrPhysicsNoReplayInt, COND_SimulatedOrPhysicsNoReplay);
|
|
DOREPLIFETIME_CONDITION(ThisClass, NoneInt, COND_None);
|
|
DOREPLIFETIME_CONDITION(ThisClass, NeverInt, COND_Never);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SkipReplayInt, COND_SkipReplay);
|
|
DOREPLIFETIME_CONDITION(ThisClass, ReplayOnlyInt, COND_ReplayOnly);
|
|
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOnlyIntArray, COND_SimulatedOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, AutonomousOnlyIntArray, COND_AutonomousOnly);
|
|
DOREPLIFETIME_CONDITION(ThisClass, SimulatedOrPhysicsIntArray, COND_SimulatedOrPhysics);
|
|
DOREPLIFETIME_CONDITION(ThisClass, OwnerOnlyIntArray, COND_OwnerOnly);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicationSystem_TestIrisComponent
|
|
//////////////////////////////////////////////////////////////////////////
|
|
FTestReplicatedIrisComponent::FTestReplicatedIrisComponent()
|
|
: ReplicationFragment(*this, ReplicationState)
|
|
{
|
|
}
|
|
|
|
void FTestReplicatedIrisComponent::ApplyReplicationState(const FFakeGeneratedReplicationState& State, UE::Net::FReplicationStateApplyContext& Context)
|
|
{
|
|
ReplicationState = State;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisObject
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisObject::UTestReplicatedIrisObject()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
|
|
{
|
|
FDoRepLifetimeParams Params;
|
|
Params.bIsPushBased = false;
|
|
|
|
Params.Condition = COND_None;
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, IntA, Params);
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, IntB, Params);
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, IntC, Params);
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, IntDWithOnRep, Params);
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, StructD, Params);
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::OnRep_IntD()
|
|
{
|
|
bIntDHitOnRep = true;
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::AddComponents(const UTestReplicatedIrisObject::FComponents& InComponents)
|
|
{
|
|
check(!NetRefHandle.IsValid())
|
|
for (uint32 It = 0; It < InComponents.PropertyComponentCount; ++It)
|
|
{
|
|
Components.Emplace(NewObject<UTestReplicatedIrisPropertyComponent>());
|
|
}
|
|
|
|
for (uint32 It = 0; It < InComponents.IrisComponentCount; ++It)
|
|
{
|
|
IrisComponents.Emplace(TUniquePtr<FTestReplicatedIrisComponent>(new FTestReplicatedIrisComponent()));
|
|
}
|
|
|
|
for (uint32 It = 0; It < InComponents.DynamicStateComponentCount; ++It)
|
|
{
|
|
DynamicStateComponents.Emplace(NewObject<UTestReplicatedIrisDynamicStatePropertyComponent>());
|
|
}
|
|
|
|
for (uint32 It = 0; It < InComponents.ConnectionFilteredComponentCount; ++It)
|
|
{
|
|
ConnectionFilteredComponents.Emplace(NewObject<UTestReplicatedIrisLifetimeConditionalsPropertyState>());
|
|
}
|
|
|
|
for (uint32 It = 0; It < InComponents.ObjectReferenceComponentCount; ++It)
|
|
{
|
|
ObjectReferenceComponents.Emplace(NewObject<UTestReplicatedIrisPushModelComponentWithObjectReference>());
|
|
}
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::AddComponents(uint32 PropertyComponentCount, uint32 IrisComponentCount)
|
|
{
|
|
check(!NetRefHandle.IsValid())
|
|
// Setup a few components
|
|
for (uint32 It = 0; It < PropertyComponentCount; ++It)
|
|
{
|
|
Components.Emplace(NewObject<UTestReplicatedIrisPropertyComponent>());
|
|
}
|
|
|
|
// Setup a few components
|
|
for (uint32 It = 0; It < IrisComponentCount; ++It)
|
|
{
|
|
IrisComponents.Emplace(TUniquePtr<FTestReplicatedIrisComponent>(new FTestReplicatedIrisComponent()));
|
|
}
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::AddDynamicStateComponents(uint32 DynamicStateComponentCount)
|
|
{
|
|
check(!NetRefHandle.IsValid())
|
|
for (uint32 It = 0; It < DynamicStateComponentCount; ++It)
|
|
{
|
|
DynamicStateComponents.Emplace(NewObject<UTestReplicatedIrisDynamicStatePropertyComponent>());
|
|
}
|
|
}
|
|
|
|
void UTestReplicatedIrisObject::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
using namespace UE::Net;
|
|
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
|
|
// Register components from "Components" as well, in this case we let the replication system own the fragments
|
|
for (const auto& Component : Components)
|
|
{
|
|
Component->ReplicationFragments.Reset();
|
|
FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(Component.Get(), Context, RegistrationFlags, &Component->ReplicationFragments);
|
|
}
|
|
|
|
// Register components from "IrisComponents" as well
|
|
for (const auto& Component : IrisComponents)
|
|
{
|
|
Component->ReplicationFragment.Register(Context);
|
|
}
|
|
|
|
// Register components from "DynamicStateComponents"
|
|
for (const auto& Component : DynamicStateComponents)
|
|
{
|
|
Component->ReplicationFragments.Reset();
|
|
FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(Component.Get(), Context, RegistrationFlags, &Component->ReplicationFragments);
|
|
}
|
|
|
|
// Register components from "ConnectionFilteredComponents"
|
|
for (const auto& Component : ConnectionFilteredComponents)
|
|
{
|
|
Component->ReplicationFragments.Reset();
|
|
FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(Component.Get(), Context, RegistrationFlags, &Component->ReplicationFragments);
|
|
}
|
|
|
|
// Register components from "ObjectReferenceComponents"
|
|
for (const auto& Component : ObjectReferenceComponents)
|
|
{
|
|
Component->ReplicationFragments.Reset();
|
|
FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(Component.Get(), Context, RegistrationFlags, &Component->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisObjectWithObjectReference
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void UTestReplicatedIrisObjectWithObjectReference::GetLifetimeReplicatedProps( TArray< class FLifetimeProperty > & OutLifetimeProps ) const
|
|
{
|
|
DOREPLIFETIME(ThisClass, IntA);
|
|
DOREPLIFETIME(ThisClass, IntB);
|
|
DOREPLIFETIME(ThisClass, IntC);
|
|
DOREPLIFETIME(ThisClass, RawObjectPtrRef);
|
|
DOREPLIFETIME(ThisClass, WeakObjectPtrObjectRef);
|
|
DOREPLIFETIME(ThisClass, SoftObjectPtrRef);
|
|
}
|
|
|
|
UTestReplicatedIrisObjectWithObjectReference::UTestReplicatedIrisObjectWithObjectReference()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithObjectReference::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
uint32 UReplicatedSubObjectOrderObject::RepOrderCounter = 0U;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisObjectWithNoReplicatedMembers
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisObjectWithNoReplicatedMembers::UTestReplicatedIrisObjectWithNoReplicatedMembers()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithNoReplicatedMembers::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Fragments, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
Fragments.SetIsFragmentlessNetObject(true);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UReplicatedSubObjectOrderObject
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UReplicatedSubObjectOrderObject::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty >& OutLifetimeProps) const
|
|
{
|
|
DOREPLIFETIME(UReplicatedSubObjectOrderObject, IntA);
|
|
DOREPLIFETIME(UReplicatedSubObjectOrderObject, OtherSubObject);
|
|
}
|
|
|
|
UReplicatedSubObjectOrderObject::UReplicatedSubObjectOrderObject()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UReplicatedSubObjectOrderObject::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
void UReplicatedSubObjectDestroyOrderObject::SetObjectExpectedToBeDestroyed(UReplicatedSubObjectDestroyOrderObject* OtherObject)
|
|
{
|
|
ObjectToWatch = MakeWeakObjectPtr(OtherObject);
|
|
}
|
|
|
|
void UReplicatedSubObjectDestroyOrderObject::BeginDestroy()
|
|
{
|
|
Super::BeginDestroy();
|
|
}
|
|
|
|
void UReplicatedSubObjectDestroyOrderObject::PreNetReceive()
|
|
{
|
|
Super::PreNetReceive();
|
|
|
|
bObjectExistedInPreNetReceive = ObjectToWatch.IsSet() && ObjectToWatch.GetValue().IsValid();
|
|
}
|
|
|
|
void UReplicatedSubObjectDestroyOrderObject::PostNetReceive()
|
|
{
|
|
Super::PostNetReceive();
|
|
|
|
bObjectExistedInPostNetReceive = ObjectToWatch.IsSet() && ObjectToWatch.GetValue().IsValid();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedObjectWithRepNotifies
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UTestReplicatedObjectWithRepNotifies::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty >& OutLifetimeProps) const
|
|
{
|
|
DOREPLIFETIME_CONDITION_NOTIFY(UTestReplicatedObjectWithRepNotifies, IntA, COND_None, REPNOTIFY_Always);
|
|
DOREPLIFETIME_CONDITION_NOTIFY(UTestReplicatedObjectWithRepNotifies, IntB, COND_None, REPNOTIFY_Always);
|
|
DOREPLIFETIME(UTestReplicatedObjectWithRepNotifies, IntC);
|
|
}
|
|
|
|
UTestReplicatedObjectWithRepNotifies::UTestReplicatedObjectWithRepNotifies()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedObjectWithRepNotifies::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
void UTestReplicatedObjectWithRepNotifies::OnRep_IntA(int32 OldInt)
|
|
{
|
|
PrevIntAStoredInOnRep = OldInt;
|
|
}
|
|
|
|
void UTestReplicatedObjectWithRepNotifies::OnRep_IntB(int32 OldInt)
|
|
{
|
|
PrevIntBStoredInOnRep = OldInt;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisPushModelObject
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UTestReplicatedIrisPushModelObject::GetLifetimeReplicatedProps(TArray< class FLifetimeProperty >& OutLifetimeProps) const
|
|
{
|
|
FDoRepLifetimeParams Params{ .bIsPushBased = true };
|
|
DOREPLIFETIME_WITH_PARAMS(UTestReplicatedIrisPushModelObject, IntA, Params);
|
|
DOREPLIFETIME_WITH_PARAMS(UTestReplicatedIrisPushModelObject, IntB, Params);
|
|
}
|
|
|
|
void UTestReplicatedIrisPushModelObject::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
|
|
void UTestReplicatedIrisPushModelObject::SetIntA(int32 InValue)
|
|
{
|
|
IntA = InValue;
|
|
MARK_PROPERTY_DIRTY_FROM_NAME(UTestReplicatedIrisPushModelObject, IntA, this);
|
|
}
|
|
|
|
int32 UTestReplicatedIrisPushModelObject::GetIntA() const
|
|
{
|
|
return IntA;
|
|
}
|
|
|
|
void UTestReplicatedIrisPushModelObject::SetIntB(int32 InValue)
|
|
{
|
|
IntB = InValue;
|
|
MARK_PROPERTY_DIRTY_FROM_NAME(UTestReplicatedIrisPushModelObject, IntB, this);
|
|
}
|
|
|
|
int32 UTestReplicatedIrisPushModelObject::GetIntB() const
|
|
{
|
|
return IntB;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation for UTestReplicatedIrisObjectWithDynamicCondition
|
|
//////////////////////////////////////////////////////////////////////////
|
|
UTestReplicatedIrisObjectWithDynamicCondition::UTestReplicatedIrisObjectWithDynamicCondition()
|
|
: UReplicatedTestObject()
|
|
{
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithDynamicCondition::RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags)
|
|
{
|
|
Super::RegisterReplicationFragments(Context, RegistrationFlags);
|
|
|
|
// Base object owns the fragment in this case
|
|
{
|
|
this->ReplicationFragments.Reset();
|
|
UE::Net::FReplicationFragmentUtil::CreateAndRegisterFragmentsForObject(this, Context, RegistrationFlags, &this->ReplicationFragments);
|
|
}
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithDynamicCondition::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
|
|
{
|
|
FDoRepLifetimeParams Params;
|
|
Params.bIsPushBased = false;
|
|
|
|
Params.Condition = COND_Dynamic;
|
|
DOREPLIFETIME_WITH_PARAMS_FAST(ThisClass, DynamicConditionInt, Params);
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithDynamicCondition::SetDynamicCondition(ELifetimeCondition Condition)
|
|
{
|
|
DOREPDYNAMICCONDITION_SETCONDITION_FAST(ThisClass, DynamicConditionInt, Condition);
|
|
}
|
|
|
|
void UTestReplicatedIrisObjectWithDynamicCondition::SetDynamicConditionCustomCondition(bool bActive)
|
|
{
|
|
DOREPCUSTOMCONDITION_SETACTIVE_FAST(ThisClass, DynamicConditionInt, bActive);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// THIS SECTION WILL BE GENERATED FROM UHT
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// FFakeGeneratedReplicationState
|
|
const UE::Net::FRepTag RepTag_FakeGeneratedReplicationState_IntB = UE::Net::MakeRepTag("FakeGeneratedReplicationState_IntB");
|
|
|
|
constexpr UE::Net::FReplicationStateMemberChangeMaskDescriptor FFakeGeneratedReplicationState::sReplicationStateChangeMaskDescriptors[3];
|
|
|
|
IRIS_BEGIN_SERIALIZER_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_SERIALIZER_DESCRIPTOR(UE::Net::FInt32NetSerializer, nullptr)
|
|
IRIS_SERIALIZER_DESCRIPTOR(UE::Net::FInt32NetSerializer, nullptr)
|
|
IRIS_SERIALIZER_DESCRIPTOR(UE::Net::FInt32NetSerializer, nullptr)
|
|
IRIS_END_SERIALIZER_DESCRIPTOR()
|
|
|
|
// Member traits
|
|
IRIS_BEGIN_TRAITS_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_TRAITS_DESCRIPTOR(UE::Net::EReplicationStateMemberTraits::None)
|
|
IRIS_TRAITS_DESCRIPTOR(UE::Net::EReplicationStateMemberTraits::None)
|
|
IRIS_TRAITS_DESCRIPTOR(UE::Net::EReplicationStateMemberTraits::None)
|
|
IRIS_END_TRAITS_DESCRIPTOR()
|
|
|
|
// This is required to work around issues with static initialization order
|
|
IRIS_BEGIN_INTERNAL_TYPE_INFO(FFakeGeneratedReplicationState)
|
|
IRIS_INTERNAL_TYPE_INFO(UE::Net::FInt32NetSerializer)
|
|
IRIS_INTERNAL_TYPE_INFO(UE::Net::FInt32NetSerializer)
|
|
IRIS_INTERNAL_TYPE_INFO(UE::Net::FInt32NetSerializer)
|
|
IRIS_END_INTERNAL_TYPE_INFO()
|
|
|
|
IRIS_BEGIN_MEMBER_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_MEMBER_DESCRIPTOR(FFakeGeneratedReplicationState, IntA, 0)
|
|
IRIS_MEMBER_DESCRIPTOR(FFakeGeneratedReplicationState, IntB, 1)
|
|
IRIS_MEMBER_DESCRIPTOR(FFakeGeneratedReplicationState, IntC, 2)
|
|
IRIS_END_MEMBER_DESCRIPTOR()
|
|
|
|
IRIS_BEGIN_MEMBER_DEBUG_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_MEMBER_DEBUG_DESCRIPTOR(FFakeGeneratedReplicationState, IntA)
|
|
IRIS_MEMBER_DEBUG_DESCRIPTOR(FFakeGeneratedReplicationState, IntB)
|
|
IRIS_MEMBER_DEBUG_DESCRIPTOR(FFakeGeneratedReplicationState, IntC)
|
|
IRIS_END_MEMBER_DEBUG_DESCRIPTOR()
|
|
|
|
IRIS_BEGIN_TAG_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_TAG_DESCRIPTOR(RepTag_FakeGeneratedReplicationState_IntB, 1)
|
|
IRIS_END_TAG_DESCRIPTOR()
|
|
|
|
IRIS_BEGIN_FUNCTION_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_END_FUNCTION_DESCRIPTOR()
|
|
|
|
IRIS_BEGIN_REFERENCE_DESCRIPTOR(FFakeGeneratedReplicationState)
|
|
IRIS_END_REFERENCE_DESCRIPTOR()
|
|
|
|
IRIS_IMPLEMENT_CONSTRUCT_AND_DESTRUCT(FFakeGeneratedReplicationState)
|
|
IRIS_IMPLEMENT_REPLICATIONSTATEDESCRIPTOR(FFakeGeneratedReplicationState)
|