InstanceDataManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "SceneTypes.h"
#include "InstanceDataSceneProxy.h"
#include "InstancedStaticMesh/InstanceAttributeTracker.h"
 
class FPrimitiveSceneProxy;
class HHitProxy;
class FPrecomputedInstanceSpatialHashData;
class FInstanceUpdateChangeSet;
using FPrecomputedInstanceSpatialHashDataPtr = TSharedPtr<const FPrecomputedInstanceSpatialHashData, ESPMode::ThreadSafe>;
 
struct FInstanceDataManagerSourceDataDesc
{
    FMatrix PrimitiveLocalToWorld;
    EComponentMobility::Type ComponentMobility = EComponentMobility::Movable;
    FRenderBounds MeshBounds;
    FInstanceDataFlags Flags;
 
    FPrimitiveMaterialPropertyDescriptor PrimitiveMaterialDesc;
 
    // Number of instances in the source arrays (e.g., in the component)
    int32 NumInstances = -1;
 
    // 
    int32 NumCustomDataFloats = 0;
 
    // Callback to fill in the required change set with source data.
    TFunction<void(FInstanceUpdateChangeSet& ChangeSet)> BuildChangeSet;
};
 
class InstanceDataManagerSourceInterface
{
public:
 
    enum class FDirtyType
    {
        Incremental,
        Full,
    };
 
    virtual void InstanceDataManagerMarkDirty(FDirtyType DirtyFlags) = 0;
 
    virtual FInstanceDataManagerSourceDataDesc GetInstanceDataSourceDesc() = 0;
};
 
class FInstanceDataManager : public FInstanceIdIndexMap
{
public:
    //ENGINE_API FInstanceDataManager(IInstanceDataProvider* InInstanceDataProvider);
    ENGINE_API FInstanceDataManager(UPrimitiveComponent* InPrimitiveComponent);
 
    enum class ETrackingState : uint8
    {
        // 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.
        Initial, 
        // Tracking changes to send on next flush
        Tracked,
        // Prevent any changes from being tracked (e.g., if we have no renderer)
        Disabled,
        // In the optimized state there's no need to track any delta changes, but if anything changes at all we must rebuild.
        Optimized, 
    };
 
    FPrimitiveInstanceId Add(int32 InInstanceAddAtIndex);
    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();
 
    void ClearInstances();
 
    ENGINE_API bool HasAnyInstanceChanges() const;
 
    inline bool HasAnyChanges() const { return GetState() != ETrackingState::Disabled && (GetState() != ETrackingState::Tracked || HasAnyInstanceChanges());}
 
    ENGINE_API bool FlushChanges(FInstanceDataManagerSourceDataDesc&& ComponentData);
 
    void ClearChangeTracking();
 
    int32 GetMaxAllocatedInstanceId() const;
 
    ETrackingState GetState() const { return TrackingState; }
 
    ENGINE_API TSharedPtr<FInstanceDataSceneProxy, ESPMode::ThreadSafe> GetOrCreateProxy();
    ENGINE_API TSharedPtr<FInstanceDataSceneProxy, ESPMode::ThreadSafe> GetProxy();
 
#if DO_GUARD_SLOW
    void ValidateMapping() const;
#else
    inline void ValidateMapping() const {};
#endif
 
#if WITH_EDITOR
    void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform, FInstanceDataManagerSourceDataDesc&& ComponentData);
    void WriteCookedRenderData(FArchive& Ar, FInstanceDataManagerSourceDataDesc&& ComponentData);
#endif
    void ReadCookedRenderData(FArchive& Ar);
 
    void Serialize(FArchive& Ar, bool bCooked);
 
    TArray<int32> Optimize(FInstanceDataManagerSourceDataDesc&& ComponentData, bool bShouldRetainIdMap);
 
    ENGINE_API SIZE_T GetAllocatedSize() const;
 
protected:
    static bool ShouldUsePrecomputed();
 
    void CreateExplicitIdentityMapping();
 
    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 GatherDefaultData(const FInstanceDataManagerSourceDataDesc& ComponentData, FInstanceUpdateChangeSet& ChangeSet) const;
 
    void InitChangeSet(const FInstanceDataManagerSourceDataDesc &ComponentData, FInstanceUpdateChangeSet& ChangeSet) const;
 
    void InitChangeSet(const struct FChangeDesc2 &ChangeDesc, const FInstanceDataManagerSourceDataDesc& ComponentData, FInstanceUpdateChangeSet& ChangeSet);
 
#if WITH_EDITOR
    // TODO: implement
    bool ShouldWriteCookedData(const ITargetPlatform* TargetPlatform, int32 NumInstancesToBuildFor);
 
    FPrecomputedInstanceSpatialHashData PrecomputeOptimizationData(FInstanceDataManagerSourceDataDesc&& ComponentData);
 
    static FPrecomputedInstanceSpatialHashData PrecomputeOptimizationData(FInstanceUpdateChangeSet& ChangeSet);
 
#endif
    TSharedPtr<class FUpdatableInstanceDataSceneProxy, ESPMode::ThreadSafe> GetOrCreateProxyInternal();
 
    // Change set.
    FInstanceAttributeTracker InstanceUpdateTracker;
 
    // Id allocation tracking
    TBitArray<> ValidInstanceIdMask;
    int32 IdSearchStartIndex = 0;
 
    ETrackingState TrackingState = ETrackingState::Initial;
    FInstanceDataFlags AllChangedFlags;
    uint8 bNumCustomDataChanged : 1;
    uint8 bTransformChangedAllInstances : 1;
    uint8 bPrimitiveTransformChanged : 1;
    uint8 bAnyInstanceChange : 1;
 
    TSharedPtr<class FUpdatableInstanceDataSceneProxy, ESPMode::ThreadSafe> InstanceDataProxy;
    TWeakObjectPtr<UPrimitiveComponent> PrimitiveComponent = nullptr;
 
    FPrecomputedInstanceSpatialHashDataPtr PrecomputedOptimizationData;
 
    // Must track this to detect changes 
    FInstanceDataFlags Flags;
    int32 NumCustomDataFloats = 0;
    float AbsMaxDisplacement = 0.0f;
    FRenderBounds MeshBounds;
};