WorldCompositionUtility.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    WorldCompositionUtility.h: Support structures for world composition
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Math/Box.h"
#include "Math/IntPoint.h"
#include "Math/IntVector.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Serialization/StructuredArchive.h"
 
class FArchive;
 
#define WORLDTILE_LOD_PACKAGE_SUFFIX    TEXT("_LOD")
#define WORLDTILE_LOD_MAX_INDEX         4
 
class FWorldTileLayer
{
public:
    FWorldTileLayer()
        : Name(TEXT("Uncategorized"))
        , Reserved0(0)
        , Reserved1(ForceInit)
        , StreamingDistance(50000)
        , DistanceStreamingEnabled(true)
    {
    }
 
    bool operator==(const FWorldTileLayer& OtherLayer) const
    {
        return  (Name == OtherLayer.Name) && 
                (StreamingDistance == OtherLayer.StreamingDistance) &&
                (DistanceStreamingEnabled == OtherLayer.DistanceStreamingEnabled);
 
    }
 
    friend FArchive& operator<<(FArchive& Ar, FWorldTileLayer& D);
    friend void operator<<(FStructuredArchive::FSlot Slot, FWorldTileLayer& D);
 
public:
    FString                 Name;
    int32                   Reserved0;
    FIntPoint               Reserved1;
    int32                   StreamingDistance;
    bool                    DistanceStreamingEnabled;
};
 
class FWorldTileLODInfo
{
public:
    FWorldTileLODInfo()
        : RelativeStreamingDistance(10000)
        , Reserved0(0)
        , Reserved1(0)
        , Reserved2(0)
        , Reserved3(0)
    {
    }
 
    friend FArchive& operator<<(FArchive& Ar, FWorldTileLayer& D);
    friend void operator<<(FStructuredArchive::FSlot Slot, FWorldTileLayer& D);
 
    bool operator==(const FWorldTileLODInfo& OtherInfo) const
    {
        return RelativeStreamingDistance == OtherInfo.RelativeStreamingDistance;
    }
 
public:
    int32   RelativeStreamingDistance;
    
    float   Reserved0;
    float   Reserved1;
    int32   Reserved2;
    int32   Reserved3;
};
 
class FWorldTileInfo
{
public:
    FWorldTileInfo()
        : Position(0,0,0)
        , AbsolutePosition(0,0,0)
        , Bounds(ForceInit)
        , bHideInTileView(false)
        , ZOrder(0)
    {
    }
    
    friend FArchive& operator<<(FArchive& Ar, FWorldTileInfo& D) { D.StreamArchive(Ar); return Ar; }
    friend void operator<<(FStructuredArchive::FSlot Slot, FWorldTileInfo& D) { D.StreamStructuredArchive(Slot); }
 
    bool operator==(const FWorldTileInfo& OtherInfo) const
    {
        return (Position == OtherInfo.Position) &&
                (Bounds.Min.Equals(OtherInfo.Bounds.Min, 0.5f)) &&
                (Bounds.Max.Equals(OtherInfo.Bounds.Max, 0.5f)) &&
                (ParentTilePackageName == OtherInfo.ParentTilePackageName) &&
                (Layer == OtherInfo.Layer) &&
                (bHideInTileView == OtherInfo.bHideInTileView) &&
                (ZOrder == OtherInfo.ZOrder) &&
                (LODList == OtherInfo.LODList);
    }
    
    int32 GetStreamingDistance(int32 LODIndex) const
    {
        int32 Distance = Layer.StreamingDistance;
        if (LODList.IsValidIndex(LODIndex)) 
        {
            Distance+= LODList[LODIndex].RelativeStreamingDistance;
        }
        return Distance;
    }
 
    COREUOBJECT_API static bool Read(const FString& InPackageFileName, FWorldTileInfo& OutInfo);
    
public:
    FIntVector          Position; 
    FIntVector          AbsolutePosition; 
    FBox                Bounds;
    FWorldTileLayer     Layer;
    bool                bHideInTileView;
    FString             ParentTilePackageName;
    TArray<FWorldTileLODInfo> LODList;
    int32               ZOrder;
 
private:
    COREUOBJECT_API void StreamArchive(FArchive& Ar);
    COREUOBJECT_API void StreamStructuredArchive(FStructuredArchive::FSlot Slot);
};