WorldLocations.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/ChunkedArray.h"
#include "Iris/Core/NetChunkedArray.h"
#include "Net/Core/NetBitArray.h"
#include "Math/Vector.h"
#include "Misc/Optional.h"
#include "WorldLocations.generated.h"
 
class UReplicationSystem;
 
namespace UE::Net::Private
{
    typedef uint32 FInternalNetRefIndex;
    class FNetRefHandleManager;
}
 
UCLASS(Config=Engine)
class UWorldLocationsConfig : public UObject
{
    GENERATED_BODY()
 
public:
    UPROPERTY(Config)
    FVector MinPos = { -0.5f * 2097152.0f, -0.5f * 2097152.0f, -0.5f * 2097152.0f };
 
    UPROPERTY(Config)
    FVector MaxPos = { +0.5f * 2097152.0f, +0.5f * 2097152.0f, +0.5f * 2097152.0f };
 
    UPROPERTY(Config)
    float MaxNetCullDistance = 150000.f;
};
 
namespace UE::Net
{
 
struct FWorldLocationsInitParams
{
    TObjectPtr<UReplicationSystem> ReplicationSystem = nullptr;
 
    UE::Net::Private::FInternalNetRefIndex MaxInternalNetRefIndex = 0;
 
    uint32 PreallocatedStorageCount = 0;
};
 
class FWorldLocations
{
public: 
 
    struct FWorldInfo
    {
        FVector WorldLocation = FVector::ZeroVector;
 
        float CullDistance = 0.0f;
    };
 
public:
 
    void Init(const FWorldLocationsInitParams& InitParams);
    void PostSendUpdate();
 
    bool HasInfoForObject(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
    {
        return ValidInfoIndexes.IsBitSet(ObjectIndex);
    }
 
    inline FVector GetWorldLocation(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const;
 
    inline float GetCullDistance(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const;
 
    inline TOptional<FWorldLocations::FWorldInfo> GetWorldInfo(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const;
 
    void SetObjectInfo(UE::Net::Private::FInternalNetRefIndex ObjectIndex, const FVector& Location, float NetCullDistance);
    
    void InitObjectInfoCache(UE::Net::Private::FInternalNetRefIndex ObjectIndex);
 
    void RemoveObjectInfoCache(UE::Net::Private::FInternalNetRefIndex ObjectIndex);
 
    void SetObjectRequiresFrequentWorldLocationUpdate(UE::Net::Private::FInternalNetRefIndex ObjectIndex, bool bRequiresFrequentUpdate)
    {
        ObjectsRequiringFrequentWorldLocationUpdate.SetBitValue(ObjectIndex, ValidInfoIndexes.GetBit(ObjectIndex) && bRequiresFrequentUpdate);
    }
 
    bool GetObjectRequiresFrequentWorldLocationUpdate(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
    {
        return ObjectsRequiringFrequentWorldLocationUpdate.GetBit(ObjectIndex);
    }
 
    bool SetCullDistanceOverride(UE::Net::Private::FInternalNetRefIndex ObjectIndex, float CullDistance);
 
    bool ClearCullDistanceOverride(UE::Net::Private::FInternalNetRefIndex ObjectIndex);
 
    bool HasCullDistanceOverride(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
    {
        return ValidInfoIndexes.IsBitSet(ObjectIndex) ? GetObjectInfo(ObjectIndex).CullDistanceOverride != FLT_MAX : false;
    }
 
    const FNetBitArrayView GetObjectsRequiringFrequentWorldLocationUpdate() const { return MakeNetBitArrayView(ObjectsRequiringFrequentWorldLocationUpdate); }
 
    const FNetBitArrayView GetObjectsWithDirtyInfo() const { return MakeNetBitArrayView(ObjectsWithDirtyInfo); }
 
    const FNetBitArrayView GetObjectsWithWorldInfo() const { return MakeNetBitArrayView(ValidInfoIndexes); }
 
    void ResetObjectsWithDirtyInfo();
 
    void LockDirtyInfoList(bool bLock);
 
    const FVector& GetWorldMinPos() const { return MinWorldPos; };
    const FVector& GetWorldMaxPos() const { return MaxWorldPos; };
    
    FVector ClampPositionToBoundary(const FVector& Position) const
    {
        return Position.BoundToBox(GetWorldMinPos(), GetWorldMaxPos());
    }
 
    bool IsValidLocation(const FVector& Location) const
    {
        return (Location.X >= MinWorldPos.X && Location.Y >= MinWorldPos.Y && Location.Z >= MinWorldPos.Z &&
                Location.X <= MaxWorldPos.X && Location.Y <= MaxWorldPos.Y && Location.Z <= MaxWorldPos.Z);
    }
 
    void OnMaxInternalNetRefIndexIncreased(UE::Net::Private::FInternalNetRefIndex NewMaxInternalIndex);
 
private:
 
    struct FObjectInfo
    {
        FVector WorldLocation = FVector::ZeroVector;
 
        float CullDistance = 0.0f;
 
        float CullDistanceOverride = FLT_MAX;
    };
 
    enum : uint32
    {
        StorageElementsPerChunk = 65536U / sizeof(FObjectInfo),
    };
 
private:
 
    const int32 GetStorageIndex(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
    {
        return StorageIndexes[ObjectIndex];
    }
 
    const FObjectInfo& GetObjectInfo(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
    {
        return StoredObjectInfo[GetStorageIndex(ObjectIndex)];
    }
 
    FObjectInfo& GetObjectInfo(UE::Net::Private::FInternalNetRefIndex ObjectIndex)
    {
        return StoredObjectInfo[GetStorageIndex(ObjectIndex)];
    }
 
private:
 
    FNetBitArray ValidInfoIndexes;
    
    FNetBitArray ObjectsWithDirtyInfo;
    
    FNetBitArray ObjectsRequiringFrequentWorldLocationUpdate;
 
    TArray<int32> StorageIndexes;
 
    FNetBitArray ReservedStorageSlot;
 
    TNetChunkedArray<FObjectInfo, StorageElementsPerChunk> StoredObjectInfo;
 
    const UE::Net::Private::FNetRefHandleManager* NetRefHandleManager = nullptr;
 
    FVector MinWorldPos;
    FVector MaxWorldPos;
    float MaxNetCullDistance;
 
    bool bLockdownDirtyList = false;
};
 
inline FVector FWorldLocations::GetWorldLocation(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
{
    return ValidInfoIndexes.IsBitSet(ObjectIndex) ? GetObjectInfo(ObjectIndex).WorldLocation : FVector::Zero();
}
 
inline float FWorldLocations::GetCullDistance(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
{
    if (ValidInfoIndexes.IsBitSet(ObjectIndex))
    {
        const FObjectInfo& Info = GetObjectInfo(ObjectIndex);
        return Info.CullDistanceOverride == FLT_MAX ? Info.CullDistance : Info.CullDistanceOverride;
    }
 
    return 0.0f;
}
 
inline TOptional<FWorldLocations::FWorldInfo> FWorldLocations::GetWorldInfo(UE::Net::Private::FInternalNetRefIndex ObjectIndex) const
{
    if (ValidInfoIndexes.IsBitSet(ObjectIndex))
    {
        const FObjectInfo& Info = GetObjectInfo(ObjectIndex);
        return FWorldInfo
        { 
            .WorldLocation = Info.WorldLocation, 
            .CullDistance = Info.CullDistanceOverride == FLT_MAX ? Info.CullDistance : Info.CullDistanceOverride,
        };
    }
 
    return NullOpt;
}
 
} // end namespace UE::Net