InstancedSkinnedMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Components/StaticMeshComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "Rendering/NaniteInterface.h"
#include "Animation/AnimBank.h"
#include "InstanceDataSceneProxy.h"
#include "InstanceData/InstanceDataManager.h"
#include "InstancedSkinnedMeshSceneProxyDesc.h"
#include "InstancedSkinnedMeshComponent.generated.h"
 
class FPrimitiveSceneProxy;
class USkinnedMeshComponent;
class UMaterialInterface;
class UTexture;
class UAnimBank;
struct FAnimBankRecordHandle;
struct FPrimitiveSceneDesc;
 
USTRUCT()
struct FSkinnedMeshInstanceData
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, Category=Instances)
    FTransform3f Transform;
 
    UPROPERTY(EditAnywhere, Category = Animation)
    uint32 AnimationIndex;
 
    FSkinnedMeshInstanceData()
    : Transform(FTransform3f::Identity)
    , AnimationIndex(0)
    {
    }
 
    FSkinnedMeshInstanceData(const FTransform3f& InTransform, uint32 InAnimationIndex)
    : Transform(InTransform)
    , AnimationIndex(InAnimationIndex)
    {
    }
 
    friend FArchive& operator<<(FArchive& Ar, FSkinnedMeshInstanceData& InstanceData)
    {
        Ar << InstanceData.Transform;
        Ar << InstanceData.AnimationIndex;
        return Ar;
    }
};
 
UCLASS(ClassGroup=Rendering, hidecategories=(Object,Activation,Collision,"Components|Activation",Physics), editinlinenew, meta=(BlueprintSpawnableComponent), Blueprintable, MinimalAPI)
UE_EXPERIMENTAL(5.6, "This class is currently extremely experimental and should not be used at this time.")
class UInstancedSkinnedMeshComponent : public USkinnedMeshComponent
{
    GENERATED_UCLASS_BODY()
    
protected:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Animation)
    TObjectPtr<class UTransformProviderData> TransformProvider;
 
    UPROPERTY(EditAnywhere, SkipSerialization, DisplayName="Instances", Category=Instances, meta=(MakeEditWidget=true, EditFixedOrder))
    TArray<FSkinnedMeshInstanceData> InstanceData;
 
    UPROPERTY(EditAnywhere, Category=Instances, AdvancedDisplay)
    int32 NumCustomDataFloats = 0;
 
    UPROPERTY(EditAnywhere, EditFixedSize, SkipSerialization, DisplayName="Custom Data", Category=Instances, AdvancedDisplay, meta=(EditFixedOrder))
    TArray<float> InstanceCustomData;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Animation)
    float AnimationMinScreenSize = 0.0f;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Culling)
    int32 InstanceMinDrawDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Culling)
    int32 InstanceStartCullDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Culling)
    int32 InstanceEndCullDistance;
 
    UPROPERTY()
    uint8 bInheritPerInstanceData : 1;
 
    UPROPERTY()
    FBox PrimitiveBoundsOverride;
 
    UPROPERTY()
    bool bIsInstanceDataGPUOnly = false;
 
    UPROPERTY()
    int32 NumInstancesGPUOnly = 0;
 
public:
 
    ENGINE_API UInstancedSkinnedMeshComponent(FVTableHelper& Helper);
    virtual ~UInstancedSkinnedMeshComponent();
 
    //~ Begin UObject Interface
    virtual void Serialize(FArchive& Ar) override;
    virtual void PostLoad() override;
    virtual void BeginDestroy() override;
#if WITH_EDITOR
    virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    virtual void PostEditUndo() override;
    virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    virtual bool IsCachedCookedPlatformDataLoaded( const ITargetPlatform* TargetPlatform ) override;
#endif
    //~ End UObject Interface
 
    //~ Begin UActorComponent Interface
    virtual void OnRegister() override;
    virtual void SendRenderInstanceData_Concurrent() override;
    virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    virtual bool IsHLODRelevant() const override;
#if WITH_EDITOR
    virtual void ComputeHLODHash(class FHLODHashBuilder& HashBuilder) const override;
#endif
    virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    virtual void DestroyRenderState_Concurrent() override;
 
    virtual TStructOnScope<FActorComponentInstanceData> GetComponentInstanceData() const override;
    //~ End UActorComponent Interface
 
    //~ Begin USceneComponent Interface
    virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) override;
    //~ End USceneComponent Interface
 
    //~ Begin USkinnedMeshComponent Interface
    virtual const Nanite::FResources* GetNaniteResources() const;
    virtual void RefreshBoneTransforms(FActorComponentTickFunction* TickFunction = nullptr) override;
#if WITH_EDITOR
    virtual void PostAssetCompilation();
 
#endif
    //~ End USkinnedMeshComponent Interface
 
public:
    void SetNumGPUInstances(int32 InCount);
 
    bool UsesGPUOnlyInstances() const { return bIsInstanceDataGPUOnly; }
 
    FBox GetPrimitiveBoundsOverride() const { return PrimitiveBoundsOverride; }
    void SetPrimitiveBoundsOverride(const FBox& InBounds) { PrimitiveBoundsOverride = InBounds; }
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API FPrimitiveInstanceId AddInstance(const FTransform& InstanceTransform, int32 AnimationIndex, bool bWorldSpace = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API TArray<FPrimitiveInstanceId> AddInstances(const TArray<FTransform>& Transforms, const TArray<int32>& AnimationIndices, bool bShouldReturnIds, bool bWorldSpace = false);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API bool SetCustomDataValue(FPrimitiveInstanceId InstanceId, int32 CustomDataIndex, float CustomDataValue);
 
    ENGINE_API bool SetCustomData(FPrimitiveInstanceId InstanceId, TArrayView<const float> CustomDataFloats);
 
    ENGINE_API bool GetCustomData(FPrimitiveInstanceId InstanceId, TArrayView<float> CustomDataFloats) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API void SetNumCustomDataFloats(int32 InNumCustomDataFloats);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API bool GetInstanceTransform(FPrimitiveInstanceId InstanceId, FTransform& OutInstanceTransform, bool bWorldSpace = false) const;
 
    ENGINE_API bool GetInstanceAnimationIndex(FPrimitiveInstanceId InstanceId, int32& OutAnimationIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API bool RemoveInstance(FPrimitiveInstanceId InstanceId);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API void RemoveInstances(const TArray<FPrimitiveInstanceId>& InstancesToRemove);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API void ClearInstances();
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API class UTransformProviderData* GetTransformProvider() const;
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API void SetTransformProvider(class UTransformProviderData* InTransformProvider);
 
    UFUNCTION(BlueprintCallable, Category = "Components|InstancedSkinnedMesh")
    ENGINE_API void OptimizeInstanceData(bool bShouldRetainIdMap = false);
 
    ENGINE_API bool IsEnabled() const;
    ENGINE_API int32 GetInstanceCount() const;
 
    int32 GetNumCustomDataFloats() const { return NumCustomDataFloats; }
    const TArray<float>& GetInstanceCustomData() const { return InstanceCustomData; }
    const TArray<FSkinnedMeshInstanceData>& GetInstanceData() const { return InstanceData; }
 
    int32 GetInstanceCountGPUOnly() const { return NumInstancesGPUOnly; }
 
    int32 GetMinDrawDistance() const { return InstanceMinDrawDistance; }
    void GetCullDistances(int32& OutStartCullDistance, int32& OutEndCullDistance) const { OutStartCullDistance = InstanceStartCullDistance; OutEndCullDistance = InstanceEndCullDistance; }
    ENGINE_API void SetCullDistances(int32 StartCullDistance, int32 EndCullDistance);
protected:
 
    void PreApplyComponentInstanceData(struct FInstancedSkinnedMeshComponentInstanceData* ComponentInstanceData);
 
    void ApplyComponentInstanceData(struct FInstancedSkinnedMeshComponentInstanceData* ComponentInstanceData);
 
    FInstanceDataManagerSourceDataDesc GetComponentDesc(EShaderPlatform InShaderPlatform);
 
#if WITH_EDITOR
    TBitArray<> SelectedInstances;
#endif
 
    bool bIsInstanceDataApplyCompleted = true;
 
    void CreateHitProxyData(TArray<TRefCountPtr<HHitProxy>>& HitProxies);
 
    FPrimitiveInstanceId AddInstanceInternal(int32 InstanceIndex, const FTransform& InstanceTransform, int32 AnimationIndex, bool bWorldSpace);
 
    bool RemoveInstanceInternal(int32 InstanceIndex, bool InstanceAlreadyRemoved);
 
private:
    void ApplyInheritedPerInstanceData(const UInstancedSkinnedMeshComponent* InArchetype);
    bool ShouldInheritPerInstanceData(const UInstancedSkinnedMeshComponent* InArchetype) const;
    bool ShouldInheritPerInstanceData() const;
 
    void SetInstanceDataGPUOnly(bool bInInstancesGPUOnly);
 
    void SetupNewInstanceData(FSkinnedMeshInstanceData& InOutNewInstanceData, int32 InInstanceIndex, const FTransform3f& InInstanceTransform, int32 AnimationIndex);
 
    static ENGINE_API bool ShouldForceRefPose();
    static ENGINE_API bool ShouldUseAnimationBounds();
 
    static ENGINE_API FSkeletalMeshObject* CreateMeshObject(const FInstancedSkinnedMeshSceneProxyDesc& InMeshDesc, TObjectPtr<UTransformProviderData> InTransformProvider, FSkeletalMeshRenderData* InRenderData, ERHIFeatureLevel::Type InFeatureLevel);
    static ENGINE_API FPrimitiveSceneProxy* CreateSceneProxy(const FInstancedSkinnedMeshSceneProxyDesc& Desc, bool bHideSkin, bool bShouldNaniteSkin, bool bIsEnabled, int32 MinLODIndex);
 
    TSharedPtr<FInstanceDataSceneProxy, ESPMode::ThreadSafe> GetOrCreateInstanceDataSceneProxy();
 
    TSharedPtr<FInstanceDataSceneProxy, ESPMode::ThreadSafe> GetInstanceDataSceneProxy() const;
 
    TSharedPtr<FInstanceDataSceneProxy, ESPMode::ThreadSafe> CreateInstanceDataProxyGPUOnly() const;
 
    FInstanceDataManager InstanceDataManager;
 
    friend class FInstancedSkinnedMeshSceneProxy;
    friend class FInstancedSkinnedMeshComponentHelper;
    friend struct FInstancedSkinnedMeshComponentInstanceData;
    friend struct FInstancedSkinnedMeshSceneProxyDesc;
    friend struct FSkinnedMeshComponentDescriptorBase;
 
private:
    void SetSkinnedAssetCallback();
 
public:
    UE_DEPRECATED(5.7, "Method removed.")
    void BuildSceneDesc(FPrimitiveSceneProxyDesc* InSceneProxyDesc, FPrimitiveSceneDesc& OutPrimitiveSceneDesc) {}
};
 
USTRUCT()
struct FInstancedSkinnedMeshComponentInstanceData : public FSceneComponentInstanceData
{
    GENERATED_BODY()
 
public:
    FInstancedSkinnedMeshComponentInstanceData() = default;
    
    FInstancedSkinnedMeshComponentInstanceData(const UInstancedSkinnedMeshComponent* InComponent)
        : FSceneComponentInstanceData(InComponent)
        , SkinnedAsset(InComponent->GetSkinnedAsset())
        , PrimitiveBoundsOverride(InComponent->GetPrimitiveBoundsOverride())
        , bIsInstanceDataGPUOnly(InComponent->UsesGPUOnlyInstances())
        , NumInstancesGPUOnly(InComponent->GetInstanceCountGPUOnly())
    {
    }
 
    virtual ~FInstancedSkinnedMeshComponentInstanceData() = 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<UInstancedSkinnedMeshComponent>(Component)->PreApplyComponentInstanceData(this);
        Super::ApplyToComponent(Component, CacheApplyPhase);
        CastChecked<UInstancedSkinnedMeshComponent>(Component)->ApplyComponentInstanceData(this);
    }
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override
    {
        Super::AddReferencedObjects(Collector);
        Collector.AddReferencedObject(SkinnedAsset);
    }
 
public:
    UPROPERTY()
    TObjectPtr<USkinnedAsset> SkinnedAsset = nullptr;
 
    UPROPERTY()
    TArray<FSkinnedMeshInstanceData> InstanceData;
 
    TBitArray<> SelectedInstances;
 
    UPROPERTY()
    bool bHasPerInstanceHitProxies = false;
 
    UPROPERTY()
    FBox PrimitiveBoundsOverride;
 
    UPROPERTY()
    bool bIsInstanceDataGPUOnly = false;
 
    UPROPERTY()
    int32 NumInstancesGPUOnly = 0;
};