GeometryCollectionISMPoolComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Components/SceneComponent.h"
#include "Containers/Map.h"
#include "InstancedStaticMeshDelegates.h"
#include "Materials/MaterialInterface.h"
#include "InstanceDataTypes.h"
 
#include "GeometryCollectionISMPoolComponent.generated.h"
 
class AActor;
class UE_DEPRECATED(5.6, "UGeometryCollectionISMPoolComponent is deprecated, please use UISMPoolComponent instead.") UGeometryCollectionISMPoolComponent;
class UInstancedStaticMeshComponent;
 
struct FInstanceGroups
{
    using FInstanceGroupId = int32;
 
    struct FInstanceGroupRange
    {
        FInstanceGroupRange(int32 InStart, int32 InCount)
            : Start(InStart)
            , Count(InCount)
        {
        }
 
        int32 Start = 0;
        int32 Count = 0;
    };
 
    void Reset()
    {
        TotalInstanceCount = 0;
        TotalFreeInstanceCount = 0;
        GroupRanges.Empty();
        FreeList.Empty();
    }
 
    bool IsEmpty() const
    {
        return GroupRanges.Num() == FreeList.Num();
    }
 
    int32 GetMaxInstanceIndex() const
    {
        return TotalInstanceCount;
    }
 
    FInstanceGroupId AddGroup(int32 Count)
    {
        // First check to see if we can recycle a group from the free list.
        for (int32 Index = 0; Index < FreeList.Num(); ++Index)
        {
            const FInstanceGroupId GroupId = FreeList[Index];
            // todo: Could also allow allocating a subrange if Count is less than the group range count.
            if (Count == GroupRanges[GroupId].Count)
            {
                TotalFreeInstanceCount -= Count;
                FreeList.RemoveAtSwap(Index, EAllowShrinking::No);
                return GroupId;
            }
        }
        
        // Create a new group.
        const int32 StartIndex = TotalInstanceCount;
        TotalInstanceCount += Count;
        const FInstanceGroupId GroupId = GroupRanges.Add(FInstanceGroupRange(StartIndex, Count));
        return GroupId;
    }
 
    void RemoveGroup(FInstanceGroupId GroupId)
    {
        // Remove the group by putting on free list for reuse.
        // Actually removing it would require too much shuffling of the render instance index remapping.
        TotalFreeInstanceCount += GroupRanges[GroupId].Count;
        FreeList.Add(GroupId);
    }
 
    int32 TotalInstanceCount = 0;
    int32 TotalFreeInstanceCount = 0;
    TArray<FInstanceGroupRange> GroupRanges;
    TArray<FInstanceGroupId> FreeList;
};
 
struct FISMComponentDescription
{
    enum EFlags
    {
        UseHISM = 1 << 1,                           // HISM is no longer supported. This flag is ignored.
        GpuLodSelection = 1 << 2,
        ReverseCulling = 1 << 3,
        StaticMobility = 1 << 4,
        WorldPositionOffsetWritesVelocity = 1 << 5,
        EvaluateWorldPositionOffset = 1 << 6,
        AffectShadow = 1 << 7,
        AffectDistanceFieldLighting = 1 << 8,
        AffectDynamicIndirectLighting = 1 << 9,
        AffectFarShadow = 1 << 10,
        DistanceCullPrimitive = 1 << 11,
    };
 
    uint32 Flags = WorldPositionOffsetWritesVelocity|EvaluateWorldPositionOffset|AffectShadow;
    int32 NumCustomDataFloats = 0;
    FVector Position = FVector::ZeroVector;
    int32 StartCullDistance = 0;
    int32 EndCullDistance = 0;
    int32 MinLod = 0;
    uint32 GroupHash = 0;   // Optional, allows identical SMs to be separated into different groups for finer grained culling
    float LodScale = 1.f;
    TArray<FName> Tags;
    FName StatsCategory;
 
    bool operator==(const FISMComponentDescription& Other) const
    {
        return Flags == Other.Flags &&
            NumCustomDataFloats == Other.NumCustomDataFloats &&
            Position == Other.Position &&
            StartCullDistance == Other.StartCullDistance &&
            EndCullDistance == Other.EndCullDistance &&
            MinLod == Other.MinLod &&
            LodScale == Other.LodScale &&
            Tags == Other.Tags &&
            GroupHash == Other.GroupHash &&
            StatsCategory == Other.StatsCategory;
    }
};
 
inline uint32 GetTypeHash(const FISMComponentDescription& Desc)
{
    uint32 Hash = HashCombineFast(GetTypeHash(Desc.Flags), GetTypeHash(Desc.NumCustomDataFloats));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.Position));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.StartCullDistance));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.EndCullDistance));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.MinLod));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.LodScale));
    Hash = HashCombineFast(Hash, GetTypeHash(Desc.GroupHash));
    Hash = HashCombineFast(Hash, GetArrayHash(Desc.Tags.GetData(), Desc.Tags.Num()));
    return HashCombineFast(Hash, GetTypeHash(Desc.StatsCategory));
}
 
struct FGeometryCollectionStaticMeshInstance
{
    TWeakObjectPtr<UStaticMesh> StaticMesh;
    TArray<TWeakObjectPtr<UMaterialInterface>> MaterialsOverrides;
    TArray<float> CustomPrimitiveData;
    FISMComponentDescription Desc;
 
    bool operator==(const FGeometryCollectionStaticMeshInstance& Other) const 
    {
        if (!(Desc == Other.Desc))
        {
            return false;
        }
        if (!StaticMesh.HasSameIndexAndSerialNumber(Other.StaticMesh))
        {
            return false;
        }
        if (MaterialsOverrides.Num() != Other.MaterialsOverrides.Num())
        {
            return false;
        }
        for (int32 MatIndex = 0; MatIndex < MaterialsOverrides.Num(); MatIndex++)
        {
            if (!MaterialsOverrides[MatIndex].HasSameIndexAndSerialNumber(Other.MaterialsOverrides[MatIndex]))
            {
                return false;
            }
        }
        if (CustomPrimitiveData.Num() != Other.CustomPrimitiveData.Num())
        {
            return false;
        }
        for (int32 DataIndex = 0; DataIndex < CustomPrimitiveData.Num(); DataIndex++)
        {
            if (CustomPrimitiveData[DataIndex] != Other.CustomPrimitiveData[DataIndex])
            {
                return false;
            }
        }
 
        return true;
    }
};
 
inline uint32 GetTypeHash(const FGeometryCollectionStaticMeshInstance& MeshInstance)
{
    uint32 CombinedHash = GetTypeHash(MeshInstance.StaticMesh);
    CombinedHash = HashCombineFast(CombinedHash, GetTypeHash(MeshInstance.MaterialsOverrides.Num()));
    for (const TWeakObjectPtr<UMaterialInterface> Material: MeshInstance.MaterialsOverrides)
    {
        CombinedHash = HashCombineFast(CombinedHash, GetTypeHash(Material));
    }
    for (const float CustomFloat : MeshInstance.CustomPrimitiveData)
    {
        CombinedHash = HashCombineFast(CombinedHash, GetTypeHash(CustomFloat));
    }
    CombinedHash = HashCombineFast(CombinedHash, GetTypeHash(MeshInstance.Desc));
    return CombinedHash;
}
 
struct FGeometryCollectionMeshInfo
{
    int32 ISMIndex;
    FInstanceGroups::FInstanceGroupId InstanceGroupIndex;
 
    TArray<float> CustomData;
    TArrayView<const float> CustomDataSlice(int32 InstanceIndex, int32 NumCustomDataFloatsPerInstance);
    void ShadowCopyCustomData(int32 InstanceCount, int32 NumCustomDataFloatsPerInstance, TArrayView<const float> CustomDataFloats);
};
 
struct FGeometryCollectionISMPool;
 
struct FGeometryCollectionMeshGroup
{
    using FMeshId = int32;
 
    FMeshId AddMesh(const FGeometryCollectionStaticMeshInstance& MeshInstance, int32 InstanceCount, const FGeometryCollectionMeshInfo& ISMInstanceInfo, TArrayView<const float> CustomDataFloats);
    bool BatchUpdateInstancesTransforms(FGeometryCollectionISMPool& ISMPool, FMeshId MeshId, int32 StartInstanceIndex, TArrayView<const FTransform> NewInstancesTransforms, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
    void BatchUpdateInstanceCustomData(FGeometryCollectionISMPool& ISMPool, int32 CustomFloatIndex, float CustomFloatValue);
 
    void RemoveAllMeshes(FGeometryCollectionISMPool& ISMPool);
 
    TArray<FGeometryCollectionMeshInfo> MeshInfos;
 
    bool bAllowPerInstanceRemoval = false;
};
 
struct FGeometryCollectionISM
{
    void CreateISM(USceneComponent* InOwningComponent);
    void InitISM(const FGeometryCollectionStaticMeshInstance& InMeshInstance, bool bKeepAlive, bool bOverrideTransformUpdates = false);
    FInstanceGroups::FInstanceGroupId AddInstanceGroup(int32 InstanceCount, TArrayView<const float> CustomDataFloats);
 
    FGeometryCollectionStaticMeshInstance MeshInstance;
    TObjectPtr<UInstancedStaticMeshComponent> ISMComponent;
    FInstanceGroups InstanceGroups;
    TArray<FPrimitiveInstanceId> InstanceIds;
};
 
struct FGeometryCollectionISMPool
{
    using FISMIndex = int32;
 
    FGeometryCollectionISMPool();
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FISMIndex GetOrAddISM(UGeometryCollectionISMPoolComponent* OwningComponent, const FGeometryCollectionStaticMeshInstance& MeshInstance, bool& bOutISMCreated);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    void RemoveISM(FISMIndex ISMIndex, bool bKeepAlive, bool bRecycle);
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FGeometryCollectionMeshInfo AddInstancesToISM(UGeometryCollectionISMPoolComponent* OwningComponent, const FGeometryCollectionStaticMeshInstance& MeshInstance, int32 InstanceCount, TArrayView<const float> CustomDataFloats);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    void RemoveInstancesFromISM(const FGeometryCollectionMeshInfo& MeshInfo);
    bool BatchUpdateInstancesTransforms(FGeometryCollectionMeshInfo& MeshInfo, int32 StartInstanceIndex, TArrayView<const FTransform> NewInstancesTransforms, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport, bool bAllowPerInstanceRemoval);
    void BatchUpdateInstanceCustomData(FGeometryCollectionMeshInfo const& MeshInfo, int32 CustomFloatIndex, float CustomFloatValue);
 
    void Clear();
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    void Tick(UGeometryCollectionISMPoolComponent* OwningComponent);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    void RequestPreallocateMeshInstance(const FGeometryCollectionStaticMeshInstance& MeshInstances);
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    void ProcessPreallocationRequests(UGeometryCollectionISMPoolComponent* OwningComponent, int32 MaxPreallocations);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    void UpdateAbsoluteTransforms(const FTransform& BaseTransform, EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport);
 
    TArray<FGeometryCollectionISM> ISMs;
    TMap<FGeometryCollectionStaticMeshInstance, FISMIndex> MeshToISMIndex;
    
    TSet<FGeometryCollectionStaticMeshInstance> PrellocationQueue;
 
    TArray<int32> FreeList;
    TArray<int32> FreeListISM;
 
    // Cached state of lifecycle cvars from the last Tick()
    bool bCachedKeepAlive = false;
    bool bCachedRecycle = false;
 
    // Whether we force ISMs to use parent bounds and disable transform updates
    bool bDisableBoundsAndTransformUpdate = false;
};
 
 
class UE_DEPRECATED(5.6, "UGeometryCollectionISMPoolDebugDrawComponent is deprecated, please use UISMPoolDebugDrawComponent instead.") UGeometryCollectionISMPoolDebugDrawComponent;
 
UCLASS(meta = (BlueprintSpawnableComponent), MinimalAPI)
class UE_DEPRECATED(5.6, "UGeometryCollectionISMPoolComponent is deprecated, please use UISMPoolComponent instead.") UGeometryCollectionISMPoolComponent: public USceneComponent
{
    GENERATED_UCLASS_BODY()
 
public:
    using FMeshGroupId = int32;
    using FMeshId = int32;
 
    //~ Begin UActorComponent Interface
    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UActorComponent Interface
 
    GEOMETRYCOLLECTIONENGINE_API FMeshGroupId CreateMeshGroup(bool bAllowPerInstanceRemoval = false);
 
    GEOMETRYCOLLECTIONENGINE_API void DestroyMeshGroup(FMeshGroupId MeshGroupId);
 
    GEOMETRYCOLLECTIONENGINE_API FMeshId AddMeshToGroup(FMeshGroupId MeshGroupId, const FGeometryCollectionStaticMeshInstance& MeshInstance, int32 InstanceCount, TArrayView<const float> CustomDataFloats);
 
    GEOMETRYCOLLECTIONENGINE_API bool BatchUpdateInstancesTransforms(FMeshGroupId MeshGroupId, FMeshId MeshId, int32 StartInstanceIndex, TArrayView<const FTransform> NewInstancesTransforms, bool bWorldSpace = false, bool bMarkRenderStateDirty = false, bool bTeleport = false);
 
    UE_DEPRECATED(5.3, "BatchUpdateInstancesTransforms Array parameter version is deprecated, use the TArrayView version instead")
    GEOMETRYCOLLECTIONENGINE_API bool BatchUpdateInstancesTransforms(FMeshGroupId MeshGroupId, FMeshId MeshId, int32 StartInstanceIndex, const TArray<FTransform>& NewInstancesTransforms, bool bWorldSpace = false, bool bMarkRenderStateDirty = false, bool bTeleport = false);
 
    GEOMETRYCOLLECTIONENGINE_API bool BatchUpdateInstanceCustomData(FMeshGroupId MeshGroupId, int32 CustomFloatIndex, float CustomFloatValue);
 
    GEOMETRYCOLLECTIONENGINE_API void PreallocateMeshInstance(const FGeometryCollectionStaticMeshInstance& MeshInstance);
 
    GEOMETRYCOLLECTIONENGINE_API void SetTickablePoolManagement(bool bEnablePoolManagement);
 
    GEOMETRYCOLLECTIONENGINE_API void SetOverrideTransformUpdates(bool bOverrideUpdates);
 
    GEOMETRYCOLLECTIONENGINE_API void UpdateAbsoluteTransforms(const FTransform& BaseTransform, EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport);
 
private:
    uint32 NextMeshGroupId = 0;
    TMap<FMeshGroupId, FGeometryCollectionMeshGroup> MeshGroups;
    FGeometryCollectionISMPool Pool;
 
    // Expose internals for debug draw support.
PRAGMA_DISABLE_DEPRECATION_WARNINGS
    friend UGeometryCollectionISMPoolDebugDrawComponent;
PRAGMA_ENABLE_DEPRECATION_WARNINGS
};