InstancedStaticMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "EngineDefines.h"
#include "HitProxies.h"
#include "Misc/Guid.h"
#include "Engine/TextureStreamingTypes.h"
#include "Components/StaticMeshComponent.h"
#include "Elements/SMInstance/SMInstanceManager.h"
#include "InstanceDataSceneProxy.h"
#include "InstancedStaticMesh/ISMInstanceDataManager.h"
#include "StaticMeshResources.h"
#include "InstancedStaticMeshComponent.generated.h"
 
class FLightingBuildOptions;
class FPrimitiveSceneProxy;
class FStaticLightingBuildContext;
class FStaticLightingTextureMapping_InstancedStaticMesh;
class ULightComponent;
struct FNavigableGeometryExport;
struct FNavigationRelevantData;
struct FPerInstanceRenderData;
struct FStaticLightingPrimitiveInfo;
 
DECLARE_STATS_GROUP(TEXT("Foliage"), STATGROUP_Foliage, STATCAT_Advanced);
 
class FStaticLightingTextureMapping_InstancedStaticMesh;
class FInstancedLightMap2D;
class FInstancedShadowMap2D;
class FStaticMeshInstanceData;
class FISMInstanceUpdateChangeSet;
struct FInstanceUpdateComponentDesc;
 
USTRUCT()
struct FInstancedStaticMeshInstanceData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=Instances)
    FMatrix Transform;
 
    FInstancedStaticMeshInstanceData()
        : Transform(FMatrix::Identity)
    {
    }
 
    FInstancedStaticMeshInstanceData(const FMatrix& InTransform)
        : Transform(InTransform)
    {
    }
 
    friend FArchive& operator<<(FArchive& Ar, FInstancedStaticMeshInstanceData& InstanceData)
    {
        // @warning BulkSerialize: FInstancedStaticMeshInstanceData is serialized as memory dump
        // See TArray::BulkSerialize for detailed description of implied limitations.
        Ar << InstanceData.Transform;
        return Ar;
    }
};
 
USTRUCT()
struct FInstancedStaticMeshMappingInfo
{
    GENERATED_USTRUCT_BODY()
 
    FStaticLightingTextureMapping_InstancedStaticMesh* Mapping;
 
    FInstancedStaticMeshMappingInfo()
        : Mapping(nullptr)
    {
    }
};
 
USTRUCT()
struct FInstancedStaticMeshRandomSeed
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    int32 StartInstanceIndex = 0;
 
    UPROPERTY()
    int32 RandomSeed = 0;
 
    friend FArchive& operator<<(FArchive& Ar, FInstancedStaticMeshRandomSeed& InstanceData)
    {
        Ar << InstanceData.StartInstanceIndex;
        Ar << InstanceData.RandomSeed;
        return Ar;
    }
};
 
USTRUCT()
struct FBoundsCacheElement
{
    GENERATED_USTRUCT_BODY()
 
    FBoundsCacheElement()
        : bIsValid(false)
        , Hash(0)
        , Value(ForceInit)
    {
    }
 
    void Invalidate()
    {
        bIsValid = false;
    }
 
    bool IsValid() const
    {
        return bIsValid;
    }
 
    void CacheValue(const FBoxSphereBounds& InValue, uint32 InHash = 0)
    {
        bIsValid = true;
        Value = InValue;
        Hash = InHash;
    }
 
    const FBoxSphereBounds& GetValue(bool bCheckValid = true) const
    {
        ensure(!bCheckValid || bIsValid);
        return Value;
    }
 
    bool operator == (uint32 InHash) const
    {
        return bIsValid && (Hash == InHash);
    }
 
    bool operator != (uint32 InHash) const
    {
        return !(*this == InHash);
    }
 
    static uint32 GetHash(const FTransform& InBoundTransform, const FBox& InInstanceBounds);
 
private:
    UPROPERTY()
    bool bIsValid;
 
    UPROPERTY()
    uint32 Hash;
 
    UPROPERTY()
    FBoxSphereBounds Value;
};
 
UCLASS(ClassGroup = Rendering, meta = (BlueprintSpawnableComponent), Blueprintable, MinimalAPI)
class UInstancedStaticMeshComponent : public UStaticMeshComponent, public ISMInstanceManager
{
    GENERATED_UCLASS_BODY()
 
    
    ENGINE_API UInstancedStaticMeshComponent(FVTableHelper& Helper);
    ENGINE_API virtual ~UInstancedStaticMeshComponent();
    
    UPROPERTY(EditAnywhere, SkipSerialization, DisplayName="Instances", Category=Instances, meta=(MakeEditWidget=true, EditFixedOrder))
    TArray<FInstancedStaticMeshInstanceData> PerInstanceSMData;
    
    // TODO: KevinO cleanup
    UPROPERTY(Transient)
    TArray<FMatrix> PerInstancePrevTransform;
 
    UPROPERTY(Transient)
    FTransform PreviousComponentTransform;
 
    UPROPERTY(EditAnywhere, Category=Instances, AdvancedDisplay)
    int32 NumCustomDataFloats;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=InstancedStaticMeshComponent)
    int32 InstancingRandomSeed=0;
 
    UPROPERTY(EditAnywhere, EditFixedSize, SkipSerialization, DisplayName="Custom data", Category=Instances, AdvancedDisplay, meta=(EditFixedOrder))
    TArray<float> PerInstanceSMCustomData;
 
    UPROPERTY()
    TArray<FInstancedStaticMeshRandomSeed> AdditionalRandomSeeds;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Culling)
    float InstanceLODDistanceScale = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Culling)
    int32 InstanceMinDrawDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Culling)
    int32 InstanceStartCullDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Culling)
    int32 InstanceEndCullDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Culling)
    uint8 bUseGpuLodSelection : 1;
 
    UPROPERTY()
    uint8 bInheritPerInstanceData : 1;
 
    UPROPERTY()
    uint8 bDisableCollision : 1;
 
    uint8 bSupportRemoveAtSwap : 1;
 
protected:
    uint8 bIsInstanceDataApplyCompleted : 1;
 
private:
    uint8 bHasPreviousTransforms : 1;
 
    uint8 bUseConservativeBounds : 1;
 
    uint8 bIsUpdatingBounds : 1;
 
public:
    UPROPERTY()
    TArray<int32> InstanceReorderTable;
    
    SIZE_T ProxySize;
 
    inline int32 GetRenderIndex(int32 InInstanceIndex) const { return InstanceReorderTable.IsValidIndex(InInstanceIndex) ? InstanceReorderTable[InInstanceIndex] : InInstanceIndex; }
 
    UFUNCTION(BlueprintCallable, Category="Components|InstancedStaticMesh")
    ENGINE_API virtual int32 AddInstance(const FTransform& InstanceTransform, bool bWorldSpace = false);
 
    UFUNCTION(BlueprintCallable, Category="Components|InstancedStaticMesh")
    ENGINE_API virtual TArray<int32> AddInstances(const TArray<FTransform>& InstanceTransforms, bool bShouldReturnIndices, bool bWorldSpace = false, bool bUpdateNavigation = true);
 
    UE_DEPRECATED(5.0, "Use AddInstance or AddInstances with bWorldSpace set to true.")
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh", meta=(DeprecatedFunction, DeprecationMessage="Use 'Add Instance' or 'Add Instances' with 'World Space' set to true."))
    int32 AddInstanceWorldSpace(const FTransform& WorldTransform)
    {
        return AddInstance(WorldTransform, /*bWorldSpace*/true);
    }
 
    int32 GetNumInstances() const { return PerInstanceSMData.Num(); }
 
    ENGINE_API TArray<FPrimitiveInstanceId> AddInstancesById(const TArrayView<const FTransform>& InstanceTransforms, bool bWorldSpace = false, bool bUpdateNavigation = true);
    ENGINE_API FPrimitiveInstanceId AddInstanceById(const FTransform& InstanceTransforms, bool bWorldSpace = false);
    ENGINE_API void SetCustomDataById(const TArrayView<const FPrimitiveInstanceId> &InstanceIds, TArrayView<const float> CustomDataFloats); 
    inline void SetCustomDataById(FPrimitiveInstanceId InstanceId, TArrayView<const float> CustomDataFloats) { SetCustomDataById(MakeArrayView(&InstanceId, 1), CustomDataFloats); }
    ENGINE_API void SetCustomDataValueById(FPrimitiveInstanceId InstanceId, int32 CustomDataIndex, float CustomDataValue);
 
    ENGINE_API virtual void RemoveInstancesById(const TArrayView<const FPrimitiveInstanceId> &InstanceIds, bool bUpdateNavigation = true);
    inline void RemoveInstanceById(FPrimitiveInstanceId InstanceId) { RemoveInstancesById(MakeArrayView(&InstanceId, 1)); }
    ENGINE_API void UpdateInstanceTransformById(FPrimitiveInstanceId InstanceId, const FTransform& NewInstanceTransform, bool bWorldSpace=false, bool bTeleport=false);
    ENGINE_API void SetPreviousTransformById(FPrimitiveInstanceId InstanceId, const FTransform& NewPrevInstanceTransform, bool bWorldSpace=false);
    ENGINE_API bool IsValidId(FPrimitiveInstanceId InstanceId);
    
    inline int32 GetInstanceIndexForId(FPrimitiveInstanceId InstanceId) const { return PrimitiveInstanceDataManager.IdToIndex(InstanceId); }
 
    ENGINE_API void SetHasPerInstancePrevTransforms(bool bInHasPreviousTransforms);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool SetCustomDataValue(int32 InstanceIndex, int32 CustomDataIndex, float CustomDataValue, bool bMarkRenderStateDirty = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual void SetNumCustomDataFloats(int32 InNumCustomDataFloats);
 
    ENGINE_API virtual bool SetCustomData(int32 InstanceIndex, TArrayView<const float> CustomDataFloats, bool bMarkRenderStateDirty = false);
    ENGINE_API virtual bool SetCustomData(int32 InstanceIndexStart, int32 InstanceIndexEnd, TConstArrayView<float> CustomDataFloats, bool bMarkRenderStateDirty = false);
 
    ENGINE_API virtual void PreAllocateInstancesMemory(int32 AddedInstanceCount);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API bool GetInstanceTransform(int32 InstanceIndex, FTransform& OutInstanceTransform, bool bWorldSpace = false) const;
    
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    float GetLODDistanceScale() const { return InstanceLODDistanceScale; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API void SetLODDistanceScale(float InLODDistanceScale);
 
    // TODO: KevinO cleanup
    ENGINE_API bool GetInstancePrevTransform(int32 InstanceIndex, FTransform& OutInstanceTransform, bool bWorldSpace = false) const;
 
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) override;
    ENGINE_API void UpdateComponentTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport);
 
    ENGINE_API virtual float GetTextureStreamingTransformScale() const override;
    ENGINE_API virtual bool GetMaterialStreamingData(int32 MaterialIndex, FPrimitiveMaterialInfo& MaterialData) const override;
    ENGINE_API virtual bool BuildTextureStreamingDataImpl(ETextureStreamingBuildType BuildType, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, TSet<FGuid>& DependentResources, bool& bOutSupportsBuildTextureStreamingData) override;
    ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool UpdateInstanceTransform(int32 InstanceIndex, const FTransform& NewInstanceTransform, bool bWorldSpace=false, bool bMarkRenderStateDirty=false, bool bTeleport=false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool BatchUpdateInstancesTransforms(int32 StartInstanceIndex, const TArray<FTransform>& NewInstancesTransforms, bool bWorldSpace=false, bool bMarkRenderStateDirty=false, bool bTeleport=false);
 
    ENGINE_API virtual bool BatchUpdateInstancesTransforms(int32 StartInstanceIndex, TArrayView<const FTransform> NewInstancesTransforms, bool bWorldSpace = false, bool bMarkRenderStateDirty = false, bool bTeleport = false);
 
    // TODO: KevinO cleanup
    ENGINE_API virtual bool BatchUpdateInstancesTransforms(int32 StartInstanceIndex, const TArray<FTransform>& NewInstancesTransforms, const TArray<FTransform>& NewInstancesPrevTransforms, bool bWorldSpace = false, bool bMarkRenderStateDirty = false, bool bTeleport = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool BatchUpdateInstancesTransform(int32 StartInstanceIndex, int32 NumInstances, const FTransform& NewInstancesTransform, bool bWorldSpace=false, bool bMarkRenderStateDirty=false, bool bTeleport=false);
 
    ENGINE_API virtual bool BatchUpdateInstancesData(int32 StartInstanceIndex, int32 NumInstances, FInstancedStaticMeshInstanceData* StartInstanceData, bool bMarkRenderStateDirty = false, bool bTeleport = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool RemoveInstance(int32 InstanceIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual bool RemoveInstances(const TArray<int32>& InstancesToRemove);
 
    ENGINE_API virtual bool RemoveInstances(const TArray<int32>& InstancesToRemove, bool bInstanceArrayAlreadySortedInReverseOrder);
 
    UFUNCTION(BlueprintCallable, Category="Components|InstancedStaticMesh")
    ENGINE_API virtual void ClearInstances();
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API int32 GetInstanceCount() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API bool IsValidInstance(int32 InstanceIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API void SetCullDistances(int32 StartCullDistance, int32 EndCullDistance);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    void GetCullDistances(int32& OutStartCullDistance, int32& OutEndCullDistance) const { OutStartCullDistance = InstanceStartCullDistance; OutEndCullDistance = InstanceEndCullDistance; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual TArray<int32> GetInstancesOverlappingSphere(const FVector& Center, float Radius, bool bSphereInWorldSpace=true) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedStaticMesh")
    ENGINE_API virtual TArray<int32> GetInstancesOverlappingBox(const FBox& Box, bool bBoxInWorldSpace=true) const;
 
    ENGINE_API virtual bool ShouldCreatePhysicsState() const override;
 
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister() override;
    
    void SetRemoveSwap() { bSupportRemoveAtSwap = true; }
    ENGINE_API virtual bool SupportsRemoveSwap() const;
 
    void SetUseConservativeBounds(bool bValue) { bUseConservativeBounds = bValue; CachedConservativeInstanceBounds.Init(); }
 
#if WITH_EDITOR
    ENGINE_API virtual bool ComponentIsTouchingSelectionBox(const FBox& InSelBBox, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
    ENGINE_API virtual bool ComponentIsTouchingSelectionFrustum(const FConvexVolume& InFrustum, const bool bConsiderOnlyBSP, const bool bMustEncompassEntireComponent) const override;
 
    ENGINE_API virtual bool IsInstanceTouchingSelectionBox(int32 InstanceIndex, const FBox& InBox, const bool bMustEncompassEntireInstance) const;
    ENGINE_API virtual bool IsInstanceTouchingSelectionFrustum(int32 InstanceIndex, const FConvexVolume& InFrustum, const bool bMustEncompassEntireInstance) const;
 
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
 
    ENGINE_API virtual void ComputeHLODHash(class FHLODHashBuilder& HashBuilder) const override;
#endif
 
    // Helper function to construct a base-set of instance data flags that in
    ENGINE_API FInstanceDataFlags MakeInstanceDataFlags(bool bAnyMaterialHasPerInstanceRandom, bool bAnyMaterialHasPerInstanceCustomData) const;
 
private:
    FBox CachedConservativeInstanceBounds;
 
    TArray<FBodyInstance*> AsyncDestroyPhysicsStatePayload;
public:
 
#if WITH_EDITOR
    TBitArray<> SelectedInstances;
 
    bool bForceShowAllInstancesDetails = false;
 
    enum class EInstanceDeletionReason : uint8
    {
        NotDeleting, 
        EntryAlreadyRemoved, 
        EntryRemoval, 
        Clearing 
    };
    EInstanceDeletionReason DeletionState = EInstanceDeletionReason::NotDeleting;
#endif
    TArray<FBodyInstance*> InstanceBodies;
 
    //~ Begin UActorComponent Interface
    ENGINE_API virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    ENGINE_API virtual void GetComponentChildElements(TArray<FTypedElementHandle>& OutElementHandles, const bool bAllowCreate = true) override;
    ENGINE_API virtual bool IsHLODRelevant() const override;
    ENGINE_API virtual void SendRenderInstanceData_Concurrent() override;
    //~ End UActorComponent Interface
 
    //~ Begin UPrimitiveComponent Interface
    ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    ENGINE_API virtual FMatrix GetRenderMatrix() const override;
    ENGINE_API virtual FBodyInstance* GetBodyInstance(FName BoneName = NAME_None, bool bGetWelded = true, int32 Index = INDEX_NONE) const override;
    ENGINE_API virtual void RecreateInstanceBody(int32 InstanceBodyIndex) override;
protected:
    ENGINE_API virtual void OnCreatePhysicsState() override;
    ENGINE_API virtual void OnDestroyPhysicsState() override;
    ENGINE_API virtual bool OnAsyncDestroyPhysicsState(const UE::FTimeout& Timeout) override;
    ENGINE_API virtual void OnAsyncDestroyPhysicsStateBegin_GameThread() override;
 
public:
    ENGINE_API virtual bool CanEditSimulatePhysics() override;
 
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& BoundTransform) const override;
    ENGINE_API virtual void UpdateBounds() override;
 
    virtual bool SupportsStaticLighting() const override { return true; }
#if WITH_EDITOR
    ENGINE_API virtual void GetStaticLightingInfo(FStaticLightingPrimitiveInfo& OutPrimitiveInfo,const TArray<ULightComponent*>& InRelevantLights,const FLightingBuildOptions& Options) override;
    ENGINE_API virtual FBox GetStreamingBounds() const override;
#endif
    ENGINE_API virtual void GetLightAndShadowMapMemoryUsage( int32& LightMapMemoryUsage, int32& ShadowMapMemoryUsage ) const override;
 
    ENGINE_API virtual bool DoCustomNavigableGeometryExport(FNavigableGeometryExport& GeomExport) const override;
 
    ENGINE_API virtual bool LineTraceComponent(FHitResult& OutHit, const FVector Start, const FVector End, const FCollisionQueryParams& Params) override;
    ENGINE_API virtual bool SweepComponent(FHitResult& OutHit, const FVector Start, const FVector End, const FQuat& ShapRotation, const FCollisionShape& CollisionShape, bool bTraceComplex = false) override;
    ENGINE_API virtual bool OverlapComponent(const FVector& Pos, const FQuat& Rot, const FCollisionShape& CollisionShape) const override;
protected:
    ENGINE_API virtual bool ComponentOverlapComponentImpl(class UPrimitiveComponent* PrimComp, const FVector Pos, const FQuat& Quat, const FCollisionQueryParams& Params) override;
    ENGINE_API virtual bool ComponentOverlapMultiImpl(TArray<struct FOverlapResult>& OutOverlaps, const class UWorld* InWorld, const FVector& Pos, const FQuat& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const override;
    //~ End UPrimitiveComponent Interface
 
    //~ Begin IPhysicsComponent Interface.
public:
    ENGINE_API virtual Chaos::FPhysicsObject* GetPhysicsObjectById(Chaos::FPhysicsObjectId Id) const override;
    ENGINE_API virtual TArray<Chaos::FPhysicsObject*> GetAllPhysicsObjects() const override;
    //~ End IPhysicsComponent Interface.
 
    //~ Begin UStaticMeshComponentInterface
protected:
    ENGINE_API virtual FPrimitiveSceneProxy* CreateStaticMeshSceneProxy(Nanite::FMaterialAudit& NaniteMaterials, bool bCreateNanite) override;
    //~ End UStaticMeshComponentInterface
 
    //~ Begin UNavRelevantInterface Interface
public:
    ENGINE_API virtual void GetNavigationData(FNavigationRelevantData& Data) const override;
    ENGINE_API virtual FBox GetNavigationBounds() const override;
    ENGINE_API virtual bool IsNavigationRelevant() const override;
    ENGINE_API virtual bool ShouldSkipDirtyAreaOnAddOrRemove() const override;
    //~ End UNavRelevantInterface Interface
 
    //~ Begin UObject Interface
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#if WITH_EDITOR
    ENGINE_API virtual void PostStaticMeshCompilation() override;
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual void BeginCacheForCookedPlatformData( const ITargetPlatform* TargetPlatform ) override;
    
    ENGINE_API virtual bool IsCachedCookedPlatformDataLoaded( const ITargetPlatform* TargetPlatform ) override;
 
#endif
    //~ End UObject Interface
 
    virtual FVector GetTranslatedInstanceSpaceOrigin() const { return FVector::Zero(); }
 
    ENGINE_API void PreApplyComponentInstanceData(struct FInstancedStaticMeshComponentInstanceData* ComponentInstanceData);
 
    ENGINE_API virtual void ApplyComponentInstanceData(struct FInstancedStaticMeshComponentInstanceData* ComponentInstanceData);
 
    ENGINE_API bool IsInstanceSelected(int32 InInstanceIndex) const;
 
    ENGINE_API void SelectInstance(bool bInSelected, int32 InInstanceIndex, int32 InInstanceCount = 1);
 
    ENGINE_API void ClearInstanceSelection();
 
    ENGINE_API virtual void CollectPSOPrecacheData(const FPSOPrecacheParams& BasePrecachePSOParams, FMaterialInterfacePSOPrecacheParamsList& OutParams) override;
    
    // Number of instances in the render-side instance buffer
    virtual int32 GetNumRenderInstances() const { return PerInstanceSMData.Num(); }
 
    ENGINE_API virtual void PropagateLightingScenarioChange() override;
 
    ENGINE_API void GetInstancesMinMaxScale(FVector& MinScale, FVector& MaxScale) const;
 
 
    UE_DEPRECATED(5.4, "This function has been added only for the purposes of moving LWI code outside of the engine. Don't use it, it will be removed soon.")
    void OnPostPopulatePerInstanceData() { OnPostLoadPerInstanceData(); }
    ENGINE_API virtual void PartialNavigationUpdate(int32 InstanceIdx);
 
    ENGINE_API virtual void PartialNavigationUpdates(TConstArrayView<FTransform> InstanceTransforms);
 
    ENGINE_API TSharedPtr<FISMCInstanceDataSceneProxy, ESPMode::ThreadSafe> GetOrCreateInstanceDataSceneProxy();
    ENGINE_API const TSharedPtr<FISMCInstanceDataSceneProxy, ESPMode::ThreadSafe>& GetInstanceDataSceneProxy() const;
 
    ENGINE_API void SetBakedLightingDataChanged(int32 InInstanceIndex);
 
    ENGINE_API void SetBakedLightingDataChangedAll();
 
    ENGINE_API void InvalidateInstanceDataTracking();
 
    // Deprecated in 5.7
    inline FPrimitiveMaterialPropertyDescriptor GetUsedMaterialPropertyDesc(EShaderPlatform ShaderPlatform) const
    {
        return UPrimitiveComponent::GetUsedMaterialPropertyDesc(ShaderPlatform);
    }
 
    UE_DEPRECATED(5.7, "Please use GetUsedMaterialPropertyDesc with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    inline FPrimitiveMaterialPropertyDescriptor GetUsedMaterialPropertyDesc(ERHIFeatureLevel::Type FeatureLevel) const
    {
        return GetUsedMaterialPropertyDesc(GetFeatureLevelShaderPlatform(FeatureLevel));
    }
 
private:
    ENGINE_API void ApplyInheritedPerInstanceData(const UInstancedStaticMeshComponent* InArchetype);
    ENGINE_API bool ShouldInheritPerInstanceData(const UInstancedStaticMeshComponent* InArchetype) const;
    ENGINE_API bool ShouldInheritPerInstanceData() const;
 
    void PartialNavigateUpdateForCurrentInstances();
 
    ENGINE_API void SetupNewInstanceData(FInstancedStaticMeshInstanceData& InOutNewInstanceData, int32 InInstanceIndex, const FTransform& InInstanceTransform);
 
    ENGINE_API void UpdateInstanceBodyTransform(int32 InstanceIndex, const FTransform& WorldSpaceInstanceTransform, bool bTeleport);
 
    ENGINE_API bool BatchUpdateInstancesTransformsInternal(int32 StartInstanceIndex, TArrayView<const FTransform> NewInstancesTransforms, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport);
 
protected:
 
    UPROPERTY(Transient, DuplicateTransient, TextExportTransient)
    int32 NumPendingLightmaps;
 
    FPrimitiveInstanceDataManager PrimitiveInstanceDataManager;
 
    void InvalidateCachedBounds();
 
    ENGINE_API void CalcAndCacheNavigationBounds();
 
    ENGINE_API void CreateAllInstanceBodies();
 
    ENGINE_API void ClearAllInstanceBodies();
 
    ENGINE_API virtual void FullNavigationUpdate();
 
    enum class EBoundsCacheType : uint8
    {
        Component,
        Navigation,
        Local,
        Count,
        Other
    };
 
    UE_DEPRECATED(5.5, "Use version with FBox")
    FBoxSphereBounds CalcBoundsImpl(const FTransform& BoundTransform, bool bForNavigation) const;
 
    FBoxSphereBounds CalcBoundsImpl(const FTransform& BoundTransform, const FBox& InstanceBounds) const;
    
    virtual bool SupportsPartialNavigationUpdate() const { return true; }
 
    ENGINE_API int32 AddInstanceInternal(int32 InstanceIndex, FInstancedStaticMeshInstanceData* InNewInstanceData, const FTransform& InstanceTransform, bool bWorldSpace);
 
    ENGINE_API TArray<int32> AddInstancesInternal(TConstArrayView<FTransform> InstanceTransforms, bool bShouldReturnIndices, bool bWorldSpace, bool bUpdateNavigation = true);
 
    ENGINE_API bool RemoveInstanceInternal(int32 InstanceIndex, bool InstanceAlreadyRemoved, bool bForceRemoveAtSwap = false, bool bUpdateNavigation = true);
 
    FBox GetInstanceNavigationBounds() const;
    
    ENGINE_API virtual void GetNavigationPerInstanceTransforms(const FBox& AreaBox, TArray<FTransform>& InstanceData) const;
 
    ENGINE_API void InitInstanceBody(int32 InstanceIdx, FBodyInstance* InBodyInstance);
 
    ENGINE_API void InitInstanceBody(int32 InstanceIdx, FBodyInstance* InstanceBodyInstance, FBodyInstance* ReferenceBodyInstance, bool bRuntimeBodyInstance, UBodySetup* BodySetup);
 
    UPROPERTY(Transient, DuplicateTransient, TextExportTransient)
    TArray<FInstancedStaticMeshMappingInfo> CachedMappings;
 
    ENGINE_API void ApplyLightMapping(FStaticLightingTextureMapping_InstancedStaticMesh* InMapping, const FStaticLightingBuildContext* LightingContext);
    
    ENGINE_API void CreateHitProxyData(TArray<TRefCountPtr<HHitProxy>>& HitProxies);
 
    ENGINE_API void BuildLegacyRenderData(FStaticMeshInstanceData& OutData);
    ENGINE_API void SerializeRenderData(FArchive& Ar);
    
    ENGINE_API virtual void OnPostLoadPerInstanceData();
 
    // Helper to collect the base delta data from the ISM *notably not transforms*
    ENGINE_API void BuildInstanceDataDeltaChangeSetCommon(FISMInstanceUpdateChangeSet &ChangeSet);
 
    UE_DEPRECATED(5.7, "Please use BuildComponentInstanceData with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual void BuildComponentInstanceData(ERHIFeatureLevel::Type FeatureLevel, FInstanceUpdateComponentDesc& OutData);
    ENGINE_API virtual void BuildComponentInstanceData(EShaderPlatform InShaderPlatform, FInstanceUpdateComponentDesc& OutData);
 
    //~ ISMInstanceManager interface
    ENGINE_API virtual bool CanEditSMInstance(const FSMInstanceId& InstanceId) const override;
    ENGINE_API virtual bool CanMoveSMInstance(const FSMInstanceId& InstanceId, const ETypedElementWorldType InWorldType) const override;
    ENGINE_API virtual bool GetSMInstanceTransform(const FSMInstanceId& InstanceId, FTransform& OutInstanceTransform, bool bWorldSpace = false) const override;
    ENGINE_API virtual bool SetSMInstanceTransform(const FSMInstanceId& InstanceId, const FTransform& InstanceTransform, bool bWorldSpace = false, bool bMarkRenderStateDirty = false, bool bTeleport = false) override;
    ENGINE_API virtual void NotifySMInstanceMovementStarted(const FSMInstanceId& InstanceId) override;
    ENGINE_API virtual void NotifySMInstanceMovementOngoing(const FSMInstanceId& InstanceId) override;
    ENGINE_API virtual void NotifySMInstanceMovementEnded(const FSMInstanceId& InstanceId) override;
    ENGINE_API virtual void NotifySMInstanceSelectionChanged(const FSMInstanceId& InstanceId, const bool bIsSelected) override;
    ENGINE_API virtual bool DeleteSMInstances(TArrayView<const FSMInstanceId> InstanceIds) override;
    ENGINE_API virtual bool DuplicateSMInstances(TArrayView<const FSMInstanceId> InstanceIds, TArray<FSMInstanceId>& OutNewInstanceIds) override;
 
    void InitializeInstancingRandomSeed(const bool bAllowRandomSeedValue = false);
 
    friend FStaticLightingTextureMapping_InstancedStaticMesh;
    friend FInstancedLightMap2D;
    friend FInstancedShadowMap2D;
 
#if STATS
    TStatId StatId;
#endif
 
private:
 
    FBoxSphereBounds GetOrCalcBounds(const FTransform& InBoundTransform, EBoundsCacheType InType) const;
 
    UPROPERTY()
    mutable FBoundsCacheElement CachedBounds[(int)EBoundsCacheType::Count];
 
    bool bNavigationCachedBoundsUpdated = false;
};
 
struct HInstancedStaticMeshInstance : public HHitProxy
{
    TObjectPtr<UInstancedStaticMeshComponent> Component;
    int32 InstanceIndex;
 
    DECLARE_HIT_PROXY(ENGINE_API);
    HInstancedStaticMeshInstance(UInstancedStaticMeshComponent* InComponent, int32 InInstanceIndex) : HHitProxy(HPP_World), Component(InComponent), InstanceIndex(InInstanceIndex) {}
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    virtual FTypedElementHandle GetElementHandle() const override;
    virtual EMouseCursor::Type GetMouseCursor() override;
};
 
USTRUCT()
struct FInstancedStaticMeshLightMapInstanceData
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FTransform Transform;
 
    UPROPERTY()
    TArray<FGuid> MapBuildDataIds;
};
 
USTRUCT()
struct FInstancedStaticMeshComponentInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
public:
    FInstancedStaticMeshComponentInstanceData() = default;
    FInstancedStaticMeshComponentInstanceData(const UInstancedStaticMeshComponent* InComponent)
        : FSceneComponentInstanceData(InComponent)
        , StaticMesh(InComponent->GetStaticMesh())
    {}
    virtual ~FInstancedStaticMeshComponentInstanceData() = default;
 
    virtual bool ContainsData() const override
    {
        return true;
    }
 
    virtual void ApplyToComponent(UActorComponent* Component, const ECacheApplyPhase CacheApplyPhase) override
    {
        // The Super::ApplyToComponent will cause the scene proxy to be recreated, so we must do what we can to make sure the state is ok before that.
        CastChecked<UInstancedStaticMeshComponent>(Component)->PreApplyComponentInstanceData(this);
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<UInstancedStaticMeshComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        Super::AddReferencedObjects(Collector);
        Collector.AddReferencedObject(StaticMesh);
    }
 
public:
    UPROPERTY()
    TObjectPtr<UStaticMesh> StaticMesh = nullptr;
 
    // Static lighting info
    UPROPERTY()
    FInstancedStaticMeshLightMapInstanceData CachedStaticLighting;
    UPROPERTY()
    TArray<FInstancedStaticMeshInstanceData> PerInstanceSMData;
 
    TBitArray<> SelectedInstances;
 
    /* The cached random seed */
    UPROPERTY()
    int32 InstancingRandomSeed = 0;
 
    /* Additional random seeds */
    UPROPERTY()
    TArray<FInstancedStaticMeshRandomSeed> AdditionalRandomSeeds;
 
    UPROPERTY()
    bool bHasPerInstanceHitProxies = false;
};