GeometryCollectionObject.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Chaos/ChaosSolverActor.h"
#include "GeometryCollection/GeometryCollectionDamagePropagationData.h"
#include "GeometryCollection/GeometryCollectionSimulationTypes.h"
#include "Dataflow/DataflowInstance.h"
#include "GeometryCollection/ManagedArray.h"
#include "InstanceUniformShaderParameters.h"
#include "Interfaces/Interface_AssetUserData.h"
#include "Misc/Crc.h"
#include "Containers/Map.h"
 
#include "GeometryCollectionObject.generated.h"
 
class FGeometryCollection;
class FGeometryCollectionRenderData;
struct FGeometryCollectionSection;
struct FManagedArrayCollection;
struct FSharedSimulationParameters;
class UDataflow;
class UGeometryCollectionCache;
class UMaterial;
class UMaterialInterface;
class UPhysicalMaterial;
 
USTRUCT(BlueprintType)
struct FGeometryCollectionSource
{
    GENERATED_BODY()
 
    FGeometryCollectionSource() {}
    FGeometryCollectionSource(const FSoftObjectPath& SourceSoftObjectPath, const FTransform& ComponentTransform, const TArray<TObjectPtr<UMaterialInterface>>& SourceMaterials, bool bSplitComponents = false, bool bSetInternalFromMaterialIndex = false)
        : SourceGeometryObject(SourceSoftObjectPath), LocalTransform(ComponentTransform), SourceMaterial(SourceMaterials), bAddInternalMaterials(false), bSplitComponents(bSplitComponents), bSetInternalFromMaterialIndex(bSetInternalFromMaterialIndex)
    {
 
    }
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource", meta=(AllowedClasses="/Script/Engine.StaticMesh, /Script/Engine.SkeletalMesh, /Script/GeometryCollectionEngine.GeometryCollection"))
    FSoftObjectPath SourceGeometryObject;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource")
    FTransform LocalTransform;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource")
    TArray<TObjectPtr<UMaterialInterface>> SourceMaterial;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource|Instance")
    TArray<float> InstanceCustomData;
 
    //~ Note: bAddInternalMaterials defaults to true so a 'Reset' of a geometry collection that was created before this member was added will have consistent behavior. New geometry collections should always set bAddInternalMaterials to false.
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource", DisplayName = "(Legacy) Add Internal Materials")
    bool bAddInternalMaterials = true;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource", DisplayName = "Split Meshes")
    bool bSplitComponents = false;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource")
    bool bSetInternalFromMaterialIndex = false;
 
    // TODO: add primtive custom data
};
 
USTRUCT(BlueprintType)
struct FGeometryCollectionAutoInstanceMesh
{
    GENERATED_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Mesh instead."))
    FSoftObjectPath StaticMesh_DEPRECATED;
#endif
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "AutoInstance", meta = (AllowedClasses = "/Script/Engine.StaticMesh"))
    TObjectPtr<const UStaticMesh> Mesh;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "AutoInstance")
    TArray<TObjectPtr<UMaterialInterface>> Materials;
 
    UPROPERTY(VisibleAnywhere, Category = "AutoInstance")
    int32 NumInstances = 0;
 
    UPROPERTY(VisibleAnywhere, Category = "AutoInstance")
    TArray<float> CustomData;
 
    GEOMETRYCOLLECTIONENGINE_API int32 GetNumDataPerInstance() const;
 
    GEOMETRYCOLLECTIONENGINE_API bool operator ==(const FGeometryCollectionAutoInstanceMesh& Other) const;
};
 
USTRUCT(BlueprintType)
struct FGeometryCollectionEmbeddedExemplar
{
    GENERATED_BODY()
 
    FGeometryCollectionEmbeddedExemplar() 
        : StaticMeshExemplar(FString(TEXT("None")))
        , StartCullDistance(0.0f)
        , EndCullDistance(0.0f)
        , InstanceCount(0)
    { };
    
    FGeometryCollectionEmbeddedExemplar(FSoftObjectPath NewExemplar)
        : StaticMeshExemplar(NewExemplar)
        , StartCullDistance(0.0f)
        , EndCullDistance(0.0f)
        , InstanceCount(0)
    { }
 
    UPROPERTY(EditAnywhere, Category = "EmbeddedExemplar", meta = (AllowedClasses = "/Script/Engine.StaticMesh"))
    FSoftObjectPath StaticMeshExemplar;
 
    UPROPERTY(EditAnywhere, Category = "EmbeddedExemplar")
    float StartCullDistance;
 
    UPROPERTY(EditAnywhere, Category = "EmbeddedExemplar")
    float EndCullDistance;
 
    UPROPERTY(VisibleAnywhere, Category = "EmbeddedExemplar")
    int32 InstanceCount;
};
 
USTRUCT()
struct FGeometryCollectionLevelSetData
{
    GENERATED_BODY()
 
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionLevelSetData();
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 5)
    */
    UPROPERTY(EditAnywhere, Category = "LevelSet")
    int32 MinLevelSetResolution;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 10)
    */
    UPROPERTY(EditAnywhere, Category = "LevelSet")
    int32 MaxLevelSetResolution;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 5)
    */
    UPROPERTY(EditAnywhere, Category = "LevelSet")
    int32 MinClusterLevelSetResolution;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 10)
    */
    UPROPERTY(EditAnywhere, Category = "LevelSet")
    int32 MaxClusterLevelSetResolution;
};
 
 
USTRUCT()
struct FGeometryCollectionCollisionParticleData
{
    GENERATED_BODY()
 
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionCollisionParticleData();
 
    UPROPERTY(EditAnywhere, Category = "Particle")
    float CollisionParticlesFraction;
 
    UPROPERTY(EditAnywhere, Category = "Particle")
    int32 MaximumCollisionParticles;
};
 
 
 
USTRUCT()
struct FGeometryCollectionCollisionTypeData
{
    GENERATED_BODY()
 
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionCollisionTypeData();
 
    /*
    *  CollisionType defines how to initialize the rigid collision structures.
    */
    UPROPERTY(EditAnywhere, Category = "Collisions")
    ECollisionTypeEnum CollisionType;
 
    /*
    *  CollisionType defines how to initialize the rigid collision structures.
    */
    UPROPERTY(EditAnywhere, Category = "Collisions")
    EImplicitTypeEnum ImplicitType;
 
    /*
    *  LevelSet Resolution data for rasterization.
    */
    UPROPERTY(EditAnywhere, Category = "Collisions", meta = (EditCondition = "ImplicitType == EImplicitTypeEnum::Chaos_Implicit_LevelSet", EditConditionHides))
    FGeometryCollectionLevelSetData LevelSet;
 
    /*
    *  Collision Particle data for surface samples during Particle-LevelSet collisions.
    */
    UPROPERTY(EditAnywhere, Category = "Collisions", meta = (EditCondition = "CollisionType == ECollisionTypeEnum::Chaos_Surface_Volumetric", EditConditionHides))
    FGeometryCollectionCollisionParticleData CollisionParticles;
 
    /*
    *  Uniform scale on the collision body. (def: 0)
    */
    UPROPERTY(EditAnywhere, Category = "Collisions")
    float CollisionObjectReductionPercentage;
 
    UPROPERTY(EditAnywhere, Category = "Collisions", meta = (EditCondition = "ImplicitType == EImplicitTypeEnum::Chaos_Implicit_Convex || ImplicitType == EImplicitTypeEnum::Chaos_Implicit_Box", EditConditionHides))
    float CollisionMarginFraction;
 
};
 
 
USTRUCT()
struct FGeometryCollectionSizeSpecificData
{
    GENERATED_BODY()
 
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionSizeSpecificData();
 
    UPROPERTY(EditAnywhere, Category = "Collisions")
    float MaxSize;
 
    /*
    * Collision Shapes allow kfor multiple collision types per rigid body. 
    */
    UPROPERTY(EditAnywhere, Category = "Collisions")
    TArray<FGeometryCollectionCollisionTypeData> CollisionShapes;
 
#if WITH_EDITORONLY_DATA
    /*
     *  CollisionType defines how to initialize the rigid collision structures.
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.CollisionType instead."))
    ECollisionTypeEnum CollisionType_DEPRECATED;
 
    /*
     *  CollisionType defines how to initialize the rigid collision structures.
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.ImplicitType instead."))
    EImplicitTypeEnum ImplicitType_DEPRECATED;
 
    /*
     *  Resolution on the smallest axes for the level set. (def: 5)
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.LevelSet.MinLevelSetResolution instead."))
    int32 MinLevelSetResolution_DEPRECATED;
 
    /*
     *  Resolution on the smallest axes for the level set. (def: 10)
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.LevelSet.MaxLevelSetResolution instead."))
    int32 MaxLevelSetResolution_DEPRECATED;
 
    /*
     *  Resolution on the smallest axes for the level set. (def: 5)
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.LevelSet.MinClusterLevelSetResolution instead."))
    int32 MinClusterLevelSetResolution_DEPRECATED;
 
    /*
     *  Resolution on the smallest axes for the level set. (def: 10)
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.LevelSet.MaxClusterLevelSetResolution instead."))
    int32 MaxClusterLevelSetResolution_DEPRECATED;
 
    /*
     *  Resolution on the smallest axes for the level set. (def: 10)
     */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.CollisionObjectReductionPercentage instead."))
    int32 CollisionObjectReductionPercentage_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.CollisionParticlesFraction instead."))
    float CollisionParticlesFraction_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use Collision.MaximumCollisionParticles instead."))
    int32 MaximumCollisionParticles_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category = "Collisions")
    int32 DamageThreshold;
 
    GEOMETRYCOLLECTIONENGINE_API bool Serialize(FArchive& Ar);
#if WITH_EDITORONLY_DATA
    GEOMETRYCOLLECTIONENGINE_API void PostSerialize(const FArchive& Ar);
#endif
};
 
template<>
struct TStructOpsTypeTraits<FGeometryCollectionSizeSpecificData> : public TStructOpsTypeTraitsBase2<FGeometryCollectionSizeSpecificData>
{
    enum
    {
        WithSerializer = true,
#if WITH_EDITORONLY_DATA
        WithPostSerialize = true
#endif
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
USTRUCT(BlueprintType)
struct FGeometryCollectionProxyMeshMaterials
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Materials")
    TArray<TObjectPtr<UMaterialInterface>> Materials;
};
 
USTRUCT(BlueprintType)
struct FGeometryCollectionProxyMeshData
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering", meta = (AllowedClasses = "/Script/Engine.StaticMesh"))
    TArray<TObjectPtr<UStaticMesh>> ProxyMeshes;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering")
    TArray<FTransform3f> MeshTransforms;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering")
    TArray<FGeometryCollectionProxyMeshMaterials> MeshOverrideMaterials;
 
    GEOMETRYCOLLECTIONENGINE_API const FTransform3f& GetMeshTransform(int32 MeshIndex) const;
 
    GEOMETRYCOLLECTIONENGINE_API void Reset();
};
 
USTRUCT()
struct FGeometryCollectionRenderResourceSizeInfo
{
    GENERATED_BODY();
 
    // Total size of the arrays for the MeshResources
    UPROPERTY()
    uint64 MeshResourcesSize = 0;
 
    // Total size of the arrays for the NaniteResources
    UPROPERTY()
    uint64 NaniteResourcesSize = 0;
};
 
UCLASS(BlueprintType, customconstructor, MinimalAPI)
class UGeometryCollection : 
    public UObject, 
    public IInterface_AssetUserData, 
    public IDataflowContentOwner,
    public IDataflowInstanceInterface
{
    GENERATED_UCLASS_BODY()
 
public:
    GEOMETRYCOLLECTIONENGINE_API UGeometryCollection(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
#if WITH_EDITOR
    GEOMETRYCOLLECTIONENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    GEOMETRYCOLLECTIONENGINE_API virtual void PostEditUndo() override;
    GEOMETRYCOLLECTIONENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
#endif
    GEOMETRYCOLLECTIONENGINE_API virtual void PostInitProperties() override;
    GEOMETRYCOLLECTIONENGINE_API virtual void PreSave(FObjectPreSaveContext SaveContext) override;
    GEOMETRYCOLLECTIONENGINE_API virtual void PostLoad() override;
    GEOMETRYCOLLECTIONENGINE_API virtual void BeginDestroy() override;
    GEOMETRYCOLLECTIONENGINE_API virtual bool IsReadyForFinishDestroy() override;
    GEOMETRYCOLLECTIONENGINE_API void Serialize(FArchive& Ar);
 
#if WITH_EDITOR
    GEOMETRYCOLLECTIONENGINE_API static void AppendToClassSchema(FAppendToClassSchemaContext& Context);
    GEOMETRYCOLLECTIONENGINE_API void EnsureDataIsCooked(bool bInitResources, bool bIsTransacting, bool bIsPersistant, bool bAllowCopyFromDDC = true);
#endif
 
    void SetGeometryCollection(TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe> GeometryCollectionIn) { GeometryCollection = GeometryCollectionIn; }
    TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe>       GetGeometryCollection() { return GeometryCollection; }
    const TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe> GetGeometryCollection() const { return GeometryCollection; }
 
    GEOMETRYCOLLECTIONENGINE_API bool IsEmpty() const;
 
    GEOMETRYCOLLECTIONENGINE_API void Reset();
 
    GEOMETRYCOLLECTIONENGINE_API void ResetFrom(const FManagedArrayCollection& InCollection, const TArray<UMaterial*>& InMaterials, bool bHasInternalMaterials);
    GEOMETRYCOLLECTIONENGINE_API void ResetFrom(const FManagedArrayCollection& InCollection, const TArray<UMaterialInterface*>& InMaterialInstances, bool bHasInternalMaterials);
    
    GEOMETRYCOLLECTIONENGINE_API int32 AppendGeometry(const UGeometryCollection & Element, bool ReindexAllMaterials = false, const FTransform& TransformRoot = FTransform::Identity);
    GEOMETRYCOLLECTIONENGINE_API int32 NumElements(const FName& Group) const;
    GEOMETRYCOLLECTIONENGINE_API void RemoveElements(const FName& Group, const TArray<int32>& SortedDeletionList);
 
    GEOMETRYCOLLECTIONENGINE_API bool HasMeshData() const;
    GEOMETRYCOLLECTIONENGINE_API bool HasNaniteData() const;
 
    GEOMETRYCOLLECTIONENGINE_API uint32 GetNaniteResourceID() const;
    GEOMETRYCOLLECTIONENGINE_API uint32 GetNaniteHierarchyOffset() const;
    GEOMETRYCOLLECTIONENGINE_API uint32 GetNaniteHierarchyOffset(int32 GeometryIndex, bool bFlattened = false) const;
 
    GEOMETRYCOLLECTIONENGINE_API void ReindexMaterialSections();
 
    GEOMETRYCOLLECTIONENGINE_API void InitializeMaterials(bool bHasLegacyInternalMaterialsPairs = false);
 
    GEOMETRYCOLLECTIONENGINE_API int32 AddNewMaterialSlot(bool bCopyLastMaterial = true);
 
    GEOMETRYCOLLECTIONENGINE_API bool RemoveLastMaterialSlot();
 
 
    GEOMETRYCOLLECTIONENGINE_API bool HasVisibleGeometry() const;
 
    GEOMETRYCOLLECTIONENGINE_API void InvalidateCollection();
 
    GEOMETRYCOLLECTIONENGINE_API bool IsSimulationDataDirty() const;
 
    GEOMETRYCOLLECTIONENGINE_API int32 AttachEmbeddedGeometryExemplar(const UStaticMesh* Exemplar);
 
    GEOMETRYCOLLECTIONENGINE_API void RemoveExemplars(const TArray<int32>& SortedRemovalIndices);
 
    GEOMETRYCOLLECTIONENGINE_API const FGeometryCollectionAutoInstanceMesh& GetAutoInstanceMesh(int32 AutoInstanceMeshIndex) const;
 
    GEOMETRYCOLLECTIONENGINE_API void SetAutoInstanceMeshes(const TArray<FGeometryCollectionAutoInstanceMesh>& InAutoInstanceMeshes);
    
    GEOMETRYCOLLECTIONENGINE_API int32 FindOrAddAutoInstanceMesh(const FGeometryCollectionAutoInstanceMesh& AutoInstanceMesh);
 
    GEOMETRYCOLLECTIONENGINE_API int32 FindOrAddAutoInstanceMesh(const UStaticMesh* StaticMesh, const TArray<UMaterialInterface*>& Materials);
 
    GEOMETRYCOLLECTIONENGINE_API TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe> GenerateMinimalGeometryCollection() const;
 
    static GEOMETRYCOLLECTIONENGINE_API TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe> CopyCollectionAndRemoveGeometry(const TSharedPtr<const FGeometryCollection, ESPMode::ThreadSafe>& CollectionToCopy);
 
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionRenderResourceSizeInfo GetRenderResourceSizeInfo() const;
 
#if WITH_EDITOR
    bool bManualDataCreate;
    
    GEOMETRYCOLLECTIONENGINE_API void CreateSimulationData();
 
    GEOMETRYCOLLECTIONENGINE_API void CreateSimulationDataIfNeeded();
 
    GEOMETRYCOLLECTIONENGINE_API void RebuildRenderData();
 
    GEOMETRYCOLLECTIONENGINE_API void PropagateMarkDirtyToComponents() const;
 
    GEOMETRYCOLLECTIONENGINE_API void PropagateTransformUpdateToComponents() const;
 
    GEOMETRYCOLLECTIONENGINE_API void SetRootProxiesFromGeometrySources();
 
#endif
 
    GEOMETRYCOLLECTIONENGINE_API void InitResources();
    GEOMETRYCOLLECTIONENGINE_API void ReleaseResources();
    
    GEOMETRYCOLLECTIONENGINE_API void GetSharedSimulationParams(FSharedSimulationParameters& OutParams) const;
 
    GEOMETRYCOLLECTIONENGINE_API float GetMassOrDensity(bool& bOutIsDensity) const;
 
    /*
    * cache the material density used to compute attribute
    * Warning : this should only be called after recomputing the mass based on those values
    */
    GEOMETRYCOLLECTIONENGINE_API void CacheMaterialDensity();
 
    GEOMETRYCOLLECTIONENGINE_API FGuid GetIdGuid() const;
    GEOMETRYCOLLECTIONENGINE_API FGuid GetStateGuid() const;
 
    int32 GetRootIndex() const { return RootIndex; }
 
    TUniquePtr<FGeometryCollectionRenderData> RenderData;
 
    UPROPERTY(EditAnywhere, Category = "Clustering")
    bool EnableClustering;
 
    UPROPERTY(EditAnywhere, Category = "Clustering")
    int32 ClusterGroupIndex;
 
    UPROPERTY(EditAnywhere, Category = "Clustering")
    int32 MaxClusterLevel;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Damage")
    EDamageModelTypeEnum DamageModel;
 
    UPROPERTY(EditAnywhere, Category = "Damage", meta = (EditCondition = "!bUseSizeSpecificDamageThreshold && DamageModel == EDamageModelTypeEnum::Chaos_Damage_Model_UserDefined_Damage_Threshold"))
    TArray<float> DamageThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Damage", meta = (EditCondition = "DamageModel == EDamageModelTypeEnum::Chaos_Damage_Model_UserDefined_Damage_Threshold"))
    bool bUseSizeSpecificDamageThreshold;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Damage", meta = (EditCondition = "DamageModel == EDamageModelTypeEnum::Chaos_Damage_Model_UserDefined_Damage_Threshold"))
    bool bUseMaterialDamageModifiers;
 
    UPROPERTY(EditAnywhere, Category = "Compatibility")
    bool PerClusterOnlyDamageThreshold;
 
    UPROPERTY(EditAnywhere, Category = "Damage")
    FGeometryCollectionDamagePropagationData DamagePropagationData;
 
    UPROPERTY(EditAnywhere, Category = "Clustering")
    EClusterConnectionTypeEnum ClusterConnectionType;
 
    UPROPERTY(EditAnywhere, Category = "Clustering")
    float ConnectionGraphBoundsFilteringMargin;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "GeometrySource")
    TArray<FGeometryCollectionSource> GeometrySource;
#endif
 
    UPROPERTY(EditAnywhere, Category = "Materials")
    TArray<TObjectPtr<UMaterialInterface>> Materials;
 
    UPROPERTY(EditAnywhere, Category = "EmbeddedGeometry")
    TArray<FGeometryCollectionEmbeddedExemplar> EmbeddedGeometryExemplar;
 
    UPROPERTY(EditAnywhere, Category = "Rendering")
    bool bUseFullPrecisionUVs = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering", meta = (DisplayName = "Strip Source Data On Cook"))
    bool bStripOnCook;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering")
    bool bStripRenderDataOnCook;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Rendering", meta = (MustImplement = "/Script/GeometryCollectionEngine.GeometryCollectionExternalRenderInterface"))
    TObjectPtr<UClass> CustomRendererType;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Rendering")
    FGeometryCollectionProxyMeshData RootProxyData;
 
    UPROPERTY(EditAnywhere, Category = "Rendering")
    TArray<FGeometryCollectionAutoInstanceMesh> AutoInstanceMeshes;
 
    UFUNCTION(BlueprintCallable, Category = "Nanite")
    GEOMETRYCOLLECTIONENGINE_API void SetEnableNanite(bool bValue);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetEnableNanite, Category = "Nanite")
    bool EnableNanite;
 
    UPROPERTY(EditAnywhere, Category = "Nanite", Meta = (EditCondition = "EnableNanite"))
    bool bEnableNaniteFallback;
 
    UPROPERTY(EditAnywhere, Category = "Nanite", Meta = (EditCondition = "EnableNanite", DisplayName = "Nanite Minimum Residency"))
    uint32 NaniteMinimumResidencyInKB;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    GEOMETRYCOLLECTIONENGINE_API void SetConvertVertexColorsToSRGB(bool bValue);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetConvertVertexColorsToSRGB, Category = "Rendering")
    bool bConvertVertexColorsToSRGB = true;
 
#if WITH_EDITORONLY_DATA
    /*
    *  CollisionType defines how to initialize the rigid collision structures.
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    ECollisionTypeEnum CollisionType_DEPRECATED;
 
    /*
    *  CollisionType defines how to initialize the rigid collision structures.
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    EImplicitTypeEnum ImplicitType_DEPRECATED;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 5)
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    int32 MinLevelSetResolution_DEPRECATED;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 10)
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    int32 MaxLevelSetResolution_DEPRECATED;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 5)
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    int32 MinClusterLevelSetResolution_DEPRECATED;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 10)
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    int32 MaxClusterLevelSetResolution_DEPRECATED;
 
    /*
    *  Resolution on the smallest axes for the level set. (def: 10)
    */
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    float CollisionObjectReductionPercentage_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use RootProxyData instead."))
    FSoftObjectPath RootProxy_DEPRECATED;
#endif
    
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Collisions")
    TObjectPtr<UPhysicalMaterial> PhysicsMaterial;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collisions", meta = (EditCondition = "PhysicsMaterial != nullptr"))
    bool bDensityFromPhysicsMaterial;
 
    UPROPERTY()
    float CachedDensityFromPhysicsMaterialInGCm3;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collisions", meta = (EditCondition = "!bDensityFromPhysicsMaterial"))
    bool bMassAsDensity;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collisions", meta = (EditCondition = "!bDensityFromPhysicsMaterial"))
    float Mass;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Collisions")
    float MinimumMassClamp;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collisions")
    bool bImportCollisionFromSource;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Collisions")
    bool bOptimizeConvexes = true;
    
#if WITH_EDITORONLY_DATA
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    float CollisionParticlesFraction_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "This property is deprecated. Use the default SizeSpecificData instead."))
    int32 MaximumCollisionParticles_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Removal)
    bool bScaleOnRemoval;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (DisplayName = "Remove on Sleep"))
    bool bRemoveOnMaxSleep;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (EditCondition = "bRemoveOnMaxSleep"))
    bool bAutomaticCrumblePartialClusters;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (DisplayName = "Sleep Min Max", EditCondition="bRemoveOnMaxSleep"))
    FVector2D MaximumSleepTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (DisplayName = "Removal Duration", EditCondition="bRemoveOnMaxSleep"))
    FVector2D RemovalDuration;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (DisplayName = "Slow-Moving as sleeping", EditCondition="bRemoveOnMaxSleep"))
    bool bSlowMovingAsSleeping;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Removal, meta = (DisplayName = "Slow-Moving Velocity Threshold", EditCondition="bRemoveOnMaxSleep && bSlowMovingAsSleeping"))
    float SlowMovingVelocityThreshold;
    
    /*
    * Size Specfic Data reflects the default geometry to bind to rigid bodies smaller
    * than the max size volume. This can also be empty to reflect no collision geometry
    * for the collection. 
    */
    UPROPERTY(EditAnywhere, Category = "Collisions")
    TArray<FGeometryCollectionSizeSpecificData> SizeSpecificData;
 
    GEOMETRYCOLLECTIONENGINE_API int GetDefaultSizeSpecificDataIndex() const;
    GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionSizeSpecificData& GetDefaultSizeSpecificData();
    GEOMETRYCOLLECTIONENGINE_API const FGeometryCollectionSizeSpecificData& GetDefaultSizeSpecificData() const;
    static GEOMETRYCOLLECTIONENGINE_API FGeometryCollectionSizeSpecificData GeometryCollectionSizeSpecificDataDefaults();
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use remove on break feature instead ( Fracture editor tools )."))
    bool EnableRemovePiecesOnFracture_DEPRECATED;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Use remove on break feature instead ( Fracture editor tools )."))
    TArray<TObjectPtr<UMaterialInterface>> RemoveOnFractureMaterials_DEPRECATED;
 
    UE_DEPRECATED(5.5, "Bone Selected Material does not have a material index anymore.")
    FORCEINLINE const int32 GetBoneSelectedMaterialIndex() const { return BoneSelectedMaterialIndex; }
 
    // Get the material to use for rendering bone selections in the editor, or nullptr
    static UMaterialInterface* GetBoneSelectedMaterial();
 
    static GEOMETRYCOLLECTIONENGINE_API const TCHAR* GetSelectedMaterialPath();
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Instanced, Category = ImportSettings)
    TObjectPtr<class UAssetImportData> AssetImportData;
 
    UPROPERTY(VisibleAnywhere, Instanced, AdvancedDisplay, Category = GeometryCollection)
    TObjectPtr<class UThumbnailInfo> ThumbnailInfo;
#endif // WITH_EDITORONLY_DATA
 
    /*
    * Update the convex geometry on the collection.
    */
    GEOMETRYCOLLECTIONENGINE_API void UpdateConvexGeometry();
    GEOMETRYCOLLECTIONENGINE_API void UpdateConvexGeometryIfMissing();
    
    /*
     * Update properties that depend on the geometry and clustering: Proximity, Convex Hulls, Volume and Size data.
     */
    GEOMETRYCOLLECTIONENGINE_API void UpdateGeometryDependentProperties();
 
 
    //~ Begin IInterface_AssetUserData Interface
    GEOMETRYCOLLECTIONENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    GEOMETRYCOLLECTIONENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    GEOMETRYCOLLECTIONENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    GEOMETRYCOLLECTIONENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
 
    //
    // Dataflow
    //
#if WITH_EDITORONLY_DATA
    // this is deprecated data replaced with Setter and Getter but it is exposed to blueprint 
    // so we use the Setter/Getter to make sure the blueprint will use them 
    UPROPERTY(BlueprintReadWrite, BlueprintSetter=SetDataflowAsset, BlueprintGetter = GetDataflowAsset, Category = "Dataflow")
    TObjectPtr<UDataflow> DataflowAsset;
 
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Dataflow terminal name is now stored in DataflowInstance"))
    FString DataflowTerminal_DEPRECATED = "GeometryCollectionTerminal";
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dataflow", DisplayName = "DataFlow Overrides", meta = (DisplayAfter = "DataflowInstance"))
    TMap<FString, FString> Overrides;
 
    UPROPERTY(EditAnywhere, Category = "Dataflow")
    FDataflowInstance DataflowInstance;
 
    UFUNCTION(BlueprintCallable, Category = "Dataflow")
    void SetDataflowAsset(UDataflow* InDataflowAsset);
 
    UFUNCTION(BlueprintCallable, Category = "Dataflow")
    UDataflow* GetDataflowAsset() const;
 
    //~ Begin IDataflowGeneratedAssetInterface
    virtual const FDataflowInstance& GetDataflowInstance() const override { return DataflowInstance; };
    virtual FDataflowInstance& GetDataflowInstance() override { return DataflowInstance; };
    //~ End IDataflowGeneratedAssetInterface
 
    //~ Begin IDataflowContentOwner interface
    virtual TObjectPtr<UDataflowBaseContent> CreateDataflowContent() override;
    virtual void WriteDataflowContent(const TObjectPtr<UDataflowBaseContent>& DataflowContent) const override;
    virtual void ReadDataflowContent(const TObjectPtr<UDataflowBaseContent>& DataflowContent) override;
    //~ End IDataflowContentOwner interface
 
    const TArray<int32>& GetBreadthFirstTransformIndices() const { return BreadthFirstTransformIndices; }
 
    const TArray<int32>& GetAutoInstanceTransformRemapIndices() const { return AutoInstanceTransformRemapIndices; }
 
#if WITH_EDITOR
    virtual bool CanEditChange(const FProperty* InProperty) const override;
#endif // WITH_EDITOR
 
private:
#if WITH_EDITOR
    GEOMETRYCOLLECTIONENGINE_API void CreateSimulationDataImp(bool bCopyFromDDC);
    GEOMETRYCOLLECTIONENGINE_API void CreateRenderDataImp(bool bCopyFromDDC);
 
    GEOMETRYCOLLECTIONENGINE_API void EnsureSimulationDataIsCooked(bool bIsTransacting, bool bAllowCopyFromDDC);
    GEOMETRYCOLLECTIONENGINE_API void EnsureRenderDataIsCooked(bool bInitResources);
 
#endif
 
    /*
    * Used to transfer deprecated properties to the size specific structures during serialization
    * and to add back the default size specific data when deleted.
    */
    GEOMETRYCOLLECTIONENGINE_API void ValidateSizeSpecificDataDefaults();
 
    // update cached root index using the current hierarchy setup
    GEOMETRYCOLLECTIONENGINE_API void UpdateRootIndex();
 
    // fill instanced mesh instance count from geometry collection data if not done yet 
    GEOMETRYCOLLECTIONENGINE_API void FillAutoInstanceMeshesInstancesIfNeeded();
 
    void CacheBreadthFirstTransformIndices();
    void CacheAutoInstanceTransformRemapIndices();
 
private:
    UPROPERTY()
    FGuid PersistentGuid;
 
    UPROPERTY()
    FGuid StateGuid;
 
#if WITH_EDITOR
    //Used to determine whether we need to cook simulation data
    FGuid LastBuiltSimulationDataGuid;
    //Used to determine whether we need to regenerate simulation data
    FGuid SimulationDataGuid;
 
    //Used to determine whether we need to cook render data
    FGuid LastBuiltRenderDataGuid;
    //Used to determine whether we need to regenerate render data
    FGuid RenderDataGuid;
#endif
 
    // cached root index for faster queries
    UPROPERTY(VisibleAnywhere, Category = "Clustering")
    int32 RootIndex = INDEX_NONE;
 
    // cache transform indices in breadth-first order
    UPROPERTY(VisibleAnywhere, Transient, Category = "Clustering")
    TArray<int32> BreadthFirstTransformIndices;
 
    // cache transform remapping for instanced meshes indices
    UPROPERTY(VisibleAnywhere, Transient, Category = "Clustering")
    TArray<int32> AutoInstanceTransformRemapIndices;
 
    // Legacy index of the bone selected material in the object's Materials array, or INDEX_NONE if it is not stored there.
    // Note for new objects the bone selected material should not be stored in the Materials array, so this should be INDEX_NONE
    // The property is kept solely to support deletion of the bone selected material from the materials list of legacy assets
    UPROPERTY()
    int32 BoneSelectedMaterialIndex = INDEX_NONE;
 
    TSharedPtr<FGeometryCollection, ESPMode::ThreadSafe> GeometryCollection;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = AssetUserData)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
    FRenderCommandFence RenderResourceReleaseFence;
 
    float GetMassOrDensityInternal(bool& bOutIsDensity, bool bCached) const;
 
    void MigrateDeprecatedRootProxyData();
    void MigrateDeprecatedDataflowData();
};