ISMInstanceDataManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "SceneTypes.h"
#include "ISMInstanceDataSceneProxy.h"
#include "InstanceAttributeTracker.h"
 
class FPrimitiveSceneProxy;
class HHitProxy;
 
struct FInstanceUpdateComponentDesc
{
    FMatrix PrimitiveLocalToWorld;
    EComponentMobility::Type ComponentMobility = EComponentMobility::Movable;
    FRenderBounds StaticMeshBounds;
    FInstanceDataFlags Flags;
    FPrimitiveMaterialPropertyDescriptor PrimitiveMaterialDesc;
 
    // The number of instances that will be allocated in the proxy
    int32 NumProxyInstances = -1;
    // Number of instances in the source (e.g., the component)
    int32 NumSourceInstances = -1;
    // 
    int32 NumCustomDataFloats = 0;
 
    // Callback to fill in the required change set use with delta-update capable onwing components.
    // TODO: move elsewhere?
    TFunction<void(FISMInstanceUpdateChangeSet &ChangeSet)> BuildChangeSet;
};
 
class FPrimitiveInstanceDataManager : public FInstanceIdIndexMap
{
public:
    ENGINE_API FPrimitiveInstanceDataManager(UPrimitiveComponent* InPrimitiveComponent);
 
    enum class ETrackingState : uint8
    {
        Initial, // In the initial state, there is no proxy and therefore changes do not need to be tracked, e.g., during initial setup of an ISM component.
        Tracked,
        Disabled,
        Optimized, // In the optimized state there's no need to track any delta changes, but if anything changes at all we must rebuild.
    };
 
    enum class EMode : uint8
    {
        Default,
        Legacy, // In this mode, we create a legacy supporting proxy.
        ExternalLegacyData // In this mode, it is illegal to call the incremental state tracking methods & updates can only be sent to the proxy if there has been and extranal one queued.
    };
 
    ENGINE_API void SetMode(EMode InMode);
 
    EMode GetMode() const { return Mode; }
 
    void Add(int32 InInstanceAddAtIndex, bool bInsert);
 
    void RemoveAtSwap(int32 InstanceIndex);
    
    void RemoveAt(int32 InstanceIndex);
 
    void TransformChanged(int32 InstanceIndex);
    void TransformChanged(FPrimitiveInstanceId InstanceId);
    
    void TransformsChangedAll();
 
    void CustomDataChanged(int32 InstanceIndex);
 
    void BakedLightingDataChanged(int32 InstanceIndex);
 
    void BakedLightingDataChangedAll();
 
    void NumCustomDataChanged();
 
#if WITH_EDITOR
    void EditorDataChangedAll();
#endif
 
    void PrimitiveTransformChanged();
 
    ENGINE_API bool HasAnyInstanceChanges() const;
 
 
#if USE_NULL_RHI
    inline bool HasAnyChanges() const { return false;}
#else
    inline bool HasAnyChanges() const { return GetState() != ETrackingState::Disabled && (GetState() != ETrackingState::Tracked || HasAnyInstanceChanges());}
#endif
    bool FlushChanges(FInstanceUpdateComponentDesc &&ComponentData, bool bNewPrimitiveProxy);
 
    // 
    void PostLoad(int32 InNumInstances);
 
    void ClearIdTracking(int32 InNumInstances);
 
    void ClearChangeTracking();
 
    int32 GetMaxInstanceId() const;
 
    int32 GetMaxInstanceIndex() const;
 
    void CreateExplicitIdentityMapping();
 
    ETrackingState GetState() const { return TrackingState; }
 
    ENGINE_API TSharedPtr<FISMCInstanceDataSceneProxy, ESPMode::ThreadSafe> GetOrCreateProxy(ERHIFeatureLevel::Type InFeatureLevel);
    const TSharedPtr<FISMCInstanceDataSceneProxy, ESPMode::ThreadSafe>& GetProxy() const { return Proxy; }
    void Invalidate(int32 InNumInstances);
    
#if DO_GUARD_SLOW
    void ValidateMapping() const;
#else
    inline void ValidateMapping() const {};
#endif
 
    ENGINE_API void MarkForRebuildFromLegacy(TUniquePtr<FStaticMeshInstanceData> &&LegacyInstanceData, const TArray<int32> &InstanceReorderTable, const TArray<TRefCountPtr<HHitProxy>> &HitProxies);
 
    ENGINE_API SIZE_T GetAllocatedSize() const;
 
 
    inline void ResetComponentDirtyTracking() { bComponentMarkedDirty = false; }
 
    void OnRegister(int32 InNumInstances);
 
#if WITH_EDITOR
    // Early out test to save performance if no features are enabled that require BeginCacheForCookedPlatformData to be called
    bool ShouldWriteCookedData(const ITargetPlatform* TargetPlatform, int32 NumInstancesToBuildFor);
 
    void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform, FInstanceUpdateComponentDesc &&ComponentData, TStridedView<FMatrix> InstanceTransforms);
 
    void WriteCookedRenderData(FArchive& Ar, FInstanceUpdateComponentDesc &&ComponentData, TStridedView<FMatrix> InstanceTransforms);
#endif
    void ReadCookedRenderData(FArchive& Ar);
 
private:
    static bool ShouldUsePrecomputed();
 
    using EChangeFlag = FInstanceAttributeTracker::EFlag;
 
    template<EChangeFlag Flag>
    inline void MarkChangeHelper(int32 InstanceIndex);
    template<EChangeFlag Flag>
    inline void MarkChangeHelper(FPrimitiveInstanceId InstanceId);
 
    void MarkComponentRenderInstancesDirty();
 
    bool HasIdentityMapping() const;
 
    void FreeInstanceId(FPrimitiveInstanceId InstanceId);
 
    void InitChangeSet(const union FChangeDesc &ChangeDesc, const FInstanceUpdateComponentDesc &ComponentData, FISMInstanceUpdateChangeSet &ChangeSet);
 
#if WITH_EDITOR
    static FISMPrecomputedSpatialHashData PrecomputeOptimizationData(FInstanceUpdateComponentDesc &&ComponentData, TStridedView<FMatrix> InstanceTransforms);
#endif
 
    // Change set.
    FInstanceAttributeTracker InstanceUpdateTracker;
 
    // Id allocation tracking
    TBitArray<> ValidInstanceIdMask;
    int32 IdSearchStartIndex = 0;
 
    EMode Mode = EMode::Default;
    ETrackingState TrackingState = ETrackingState::Initial;
 
    uint8 bNumCustomDataChanged : 1;
    uint8 bBakedLightingDataChanged : 1;
    uint8 bTransformChangedAllInstances : 1;
#if WITH_EDITOR
    uint8 bAnyEditorDataChanged : 1;
#endif  
    uint8 bPrimitiveTransformChanged : 1;
    uint8 bAnyInstanceChange : 1;
 
    uint8 bComponentMarkedDirty : 1;
    uint8 bEnableTracking : 1;
    uint8 bFirstFlush : 1;
 
    TSharedPtr<FISMCInstanceDataSceneProxy, ESPMode::ThreadSafe> Proxy;
    TWeakObjectPtr<UPrimitiveComponent> PrimitiveComponent = nullptr;
 
    TPimplPtr<struct FLegacyBuildData> LegacyBuildData;
 
    using PrecomputedOptimizationDataPtr = FISMCInstanceDataSceneProxy::FISMPrecomputedSpatialHashDataPtr;
 
    PrecomputedOptimizationDataPtr PrecomputedOptimizationData;
 
    // Must track this to detect changes 
    // TODO: make event driven and save the storage?
    FMatrix PrimitiveLocalToWorld;
    FInstanceDataFlags Flags;
    int32 NumCustomDataFloats = 0;
    float AbsMaxDisplacement = 0.0f;
    FRenderBounds StaticMeshBounds;
};