DynamicMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Changes/MeshRegionChange.h"
#include "CoreMinimal.h"
#include "BaseDynamicMeshComponent.h"
#include "MeshConversionOptions.h"
#include "Components/MeshRenderDecomposition.h"
#include "DynamicMesh/MeshTangents.h"
#include "TransformTypes.h"
#include "Async/Future.h"
#include "UDynamicMesh.h"
#include "PhysicsEngine/BodySetup.h"
 
#include "Misc/ScopeLock.h"
#include "Tasks/Task.h"
#include "Util/ProgressCancel.h"
#include "DistanceFieldAtlas.h"
 
#include "DynamicMeshComponent.generated.h"
 
// predecl
struct FMeshDescription;
 
class FDynamicMeshSceneProxy;
class FBaseDynamicMeshSceneProxy;
 
class IRenderMeshPostProcessor
{
public:
    virtual ~IRenderMeshPostProcessor() = default;
 
    virtual void ProcessMesh(const FDynamicMesh3& Mesh, FDynamicMesh3& OutRenderMesh) = 0;
};
 
 
UENUM()
enum class EDynamicMeshComponentRenderUpdateMode
{
    NoUpdate = 0,
    FullUpdate = 1,
    FastUpdate = 2
};
 
 
template<typename DataType>
struct TAsyncComponentDataComputeQueue
{
    std::atomic<int> JobCounter = 0;
    bool bIsShuttingDown = false;
 
    ~TAsyncComponentDataComputeQueue()
    {
        WaitForAllJobsDuringShutdown();
    }
 
    struct FComputeJob
    {
        UE::Tasks::FTask Task;
        int JobTimestamp = 0;
        TUniquePtr<FProgressCancel> Progress;
        bool bCancelled = false;
        bool bHasCompleted = false;
    };
 
    TArray<TUniquePtr<FComputeJob>> PendingJobs;
    FCriticalSection PendingJobsLock;
 
    // This function will be called w/ the data computed by a job
    // when it finishes, if it is still valid
    // Note this method will be run from a background thread, and should be thread-safe!
    TFunction<void(TUniquePtr<DataType> NewData)> OnComputeCompleted;
 
    void LaunchJob(const TCHAR* DebugName, TFunction<TUniquePtr<DataType>(FProgressCancel& Progress)> JobWork)
    {
        // OnComputeCompleted function must be set to something
        check(OnComputeCompleted);
 
        if (!ensure(bIsShuttingDown == false))
        {
            return;
        }
 
        JobCounter++;
        int CurrentTimestamp = JobCounter;
 
        // cancel any existing jobs and clear them out if they have returned
        {
            FScopeLock RemovePending(&PendingJobsLock);
            for (int32 k = 0; k < PendingJobs.Num(); ++k)
            {
                PendingJobs[k]->bCancelled = true;
                if (PendingJobs[k]->bHasCompleted)
                {
                    PendingJobs.RemoveAtSwap(k, 1, EAllowShrinking::No);
                    k--;        // reconsider element that was just swapped in to this position
                }
            }
        }
 
        // set up the new job
        TUniquePtr<FComputeJob> NewJob = MakeUnique<FComputeJob>();
        FComputeJob* JobPtr = NewJob.Get();
        NewJob->Progress = MakeUnique<FProgressCancel>();
        FProgressCancel* ProgressPtr = NewJob->Progress.Get();
        NewJob->Progress->CancelF = [this, JobPtr]() { return bIsShuttingDown || JobPtr->bCancelled; };
        NewJob->JobTimestamp = CurrentTimestamp;
 
        // launch it
        NewJob->Task = UE::Tasks::Launch(DebugName, 
            [this, JobWork, JobPtr]() {
                // TODO: limit the number of in-progress active jobs
                TUniquePtr<DataType> Result = JobWork( *JobPtr->Progress );
                if (JobPtr->JobTimestamp == this->JobCounter && JobPtr->bCancelled == false)
                {
                    if (!bIsShuttingDown && this->OnComputeCompleted)
                    {
                        this->OnComputeCompleted(MoveTemp(Result));
                    }
                }
                JobPtr->bHasCompleted = true;
            },
            LowLevelTasks::ETaskPriority::BackgroundNormal, 
            UE::Tasks::EExtendedTaskPriority::None );
 
        // add new job
        {
            FScopeLock AddJob(&PendingJobsLock);
            PendingJobs.Add(MoveTemp(NewJob));
        }
    }
 
 
    void WaitForAllJobsDuringShutdown()
    {
        bIsShuttingDown = true;
        FScopeLock PendingLock(&PendingJobsLock);
        for (int32 k = 0; k < PendingJobs.Num(); ++k)
        {
            UE::Tasks::Wait({PendingJobs[k]->Task});
        }
    }
 
};
 
 
 
UCLASS(hidecategories = (LOD), meta = (BlueprintSpawnableComponent), ClassGroup = Rendering, MinimalAPI)
class UDynamicMeshComponent : public UBaseDynamicMeshComponent, public IInterface_CollisionDataProvider
{
    GENERATED_UCLASS_BODY()
 
 
 
    //===============================================================================================================
    // Mesh Access. Usage via GetDynamicMesh() or SetMesh()/ProcessMesh()/EditMesh() is preferred, the GetMesh() 
    // pointer access exist largely to support existing code from before UDynamicMesh was added.
public:
    virtual FDynamicMesh3* GetMesh() override { return MeshObject ? MeshObject->GetMeshPtr() : nullptr; }
 
    virtual const FDynamicMesh3* GetMesh() const override { return MeshObject ? MeshObject->GetMeshPtr() : nullptr; }
 
    //UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UDynamicMesh* GetDynamicMesh() override { return MeshObject; }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void SetDynamicMesh(UDynamicMesh* NewMesh);
 
    GEOMETRYFRAMEWORK_API virtual void SetMesh(UE::Geometry::FDynamicMesh3&& MoveMesh) override;
 
    GEOMETRYFRAMEWORK_API virtual void ProcessMesh(TFunctionRef<void(const UE::Geometry::FDynamicMesh3&)> ProcessFunc) const;
 
    GEOMETRYFRAMEWORK_API virtual void EditMesh(TFunctionRef<void(UE::Geometry::FDynamicMesh3&)> EditFunc,
                          EDynamicMeshComponentRenderUpdateMode UpdateMode = EDynamicMeshComponentRenderUpdateMode::FullUpdate);
 
    GEOMETRYFRAMEWORK_API virtual void ApplyTransform(const FTransform3d& Transform, bool bInvert) override;
 
 
    bool IsEditable() const { return bIsEditable; }
    void SetIsEditable(bool bInIsEditable) { bIsEditable = bInIsEditable; }
 
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    bool AllowsGeometrySelection() const { return bAllowsGeometrySelection; }
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    void SetAllowsGeometrySelection(bool bInAllowsGeometrySelection) { bAllowsGeometrySelection = bInAllowsGeometrySelection; }
 
protected:
    UPROPERTY(Instanced)
    TObjectPtr<UDynamicMesh> MeshObject;
 
 
 
 
    //===============================================================================================================
    // RenderBuffer Update API. These functions can be used by external code (and internally in some places)
    // to tell the Component that the Mesh data has been modified in some way, and that the RenderBuffers in the RenderProxy
    // need to be updated (or rebuilt entirely). On large meshes a full rebuild is expensive, so there are quite a few
    // variants that can be used to minimize the amount of data updated in different situations.
    //
public:
    GEOMETRYFRAMEWORK_API virtual void NotifyMeshUpdated() override;
 
    GEOMETRYFRAMEWORK_API void FastNotifyColorsUpdated();
 
    GEOMETRYFRAMEWORK_API void FastNotifyPositionsUpdated(bool bNormals = false, bool bColors = false, bool bUVs = false);
 
    GEOMETRYFRAMEWORK_API void FastNotifyVertexAttributesUpdated(bool bNormals, bool bColors, bool bUVs);
 
    GEOMETRYFRAMEWORK_API void FastNotifyVertexAttributesUpdated(EMeshRenderAttributeFlags UpdatedAttributes);
 
    GEOMETRYFRAMEWORK_API void FastNotifyUVsUpdated();
 
    GEOMETRYFRAMEWORK_API void FastNotifySecondaryTrianglesChanged();
 
    GEOMETRYFRAMEWORK_API void FastNotifyTriangleVerticesUpdated(const TArray<int32>& Triangles, EMeshRenderAttributeFlags UpdatedAttributes);
 
    GEOMETRYFRAMEWORK_API void FastNotifyTriangleVerticesUpdated(const TSet<int32>& Triangles, EMeshRenderAttributeFlags UpdatedAttributes);
 
    GEOMETRYFRAMEWORK_API TFuture<bool> FastNotifyTriangleVerticesUpdated_TryPrecompute(const TArray<int32>& Triangles, TArray<int32>& UpdateSetsOut, UE::Geometry::FAxisAlignedBox3d& BoundsOut);
 
    GEOMETRYFRAMEWORK_API void FastNotifyTriangleVerticesUpdated_ApplyPrecompute(const TArray<int32>& Triangles, EMeshRenderAttributeFlags UpdatedAttributes,
        TFuture<bool>& Precompute, const TArray<int32>& UpdateSets, const UE::Geometry::FAxisAlignedBox3d& UpdateSetBounds);
 
 
    //===============================================================================================================
    // RenderBuffer Update Blueprint API. 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering", DisplayName = "Notify Mesh Updated")
    GEOMETRYFRAMEWORK_API virtual void NotifyMeshModified();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering", DisplayName = "Notify Vertex Attributes Updated")
    GEOMETRYFRAMEWORK_API virtual void NotifyMeshVertexAttributesModified(
        bool bPositions = true, 
        bool bNormals = true,
        bool bUVs = true,
        bool bColors = true);
 
    //===============================================================================================================
    // Change Support. These changes are primarily used for Undo/Redo, however there is no strict assumption
    // about this internally, objects of these change types could also be used to perform more structured editing.
    // (Note that these functions simply forward the change events to the child UDynamicMesh, which will
    //  post a mesh-change event that 
    //
public:
    GEOMETRYFRAMEWORK_API virtual void ApplyChange(const FMeshVertexChange* Change, bool bRevert) override;
 
    GEOMETRYFRAMEWORK_API virtual void ApplyChange(const FMeshChange* Change, bool bRevert) override;
 
    GEOMETRYFRAMEWORK_API virtual void ApplyChange(const FMeshReplacementChange* Change, bool bRevert) override;
 
    FSimpleMulticastDelegate OnMeshChanged;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FMeshVerticesModified, UDynamicMeshComponent*, const FMeshVertexChange*, bool);
    FMeshVerticesModified OnMeshVerticesChanged;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FMeshRegionModified, UDynamicMeshComponent*, const FMeshRegionChangeBase*, bool);
    FMeshRegionModified OnMeshRegionChanged;
 
    GEOMETRYFRAMEWORK_API void SetInvalidateProxyOnChangeEnabled(bool bEnabled);
 
    bool GetInvalidateProxyOnChangeEnabled() const { return bInvalidateProxyOnChange; }
 
protected:
    bool bInvalidateProxyOnChange = true;
 
    FDelegateHandle MeshObjectChangedHandle;
 
    GEOMETRYFRAMEWORK_API void OnMeshObjectChanged(UDynamicMesh* ChangedMeshObject, FDynamicMeshChangeInfo ChangeInfo);
 
    bool bIsEditable = true;
 
private:
    UPROPERTY()
    bool bAllowsGeometrySelection = true;
 
 
 
    //===============================================================================================================
    // Support for specifying per-triangle colors as vertex colors. This allows external code to dynamically override 
    // the vertex colors on the rendered mesh. The lambda that is passed is held for the lifetime of the Component and
    // must remain valid. A Material that uses the vertex colors must be applied, otherwise setting this override will
    // have no visible effect. If the colors change externally, FastNotifyColorsUpdated() can be used to do the 
    // minimal vertex buffer updates necessary in the RenderProxy
    //
public:
    GEOMETRYFRAMEWORK_API virtual void SetTriangleColorFunction(TUniqueFunction<FColor(const FDynamicMesh3*, int)> TriangleColorFuncIn,
                                          EDynamicMeshComponentRenderUpdateMode UpdateMode = EDynamicMeshComponentRenderUpdateMode::FastUpdate);
 
    GEOMETRYFRAMEWORK_API virtual void ClearTriangleColorFunction(EDynamicMeshComponentRenderUpdateMode UpdateMode = EDynamicMeshComponentRenderUpdateMode::FastUpdate);
 
    GEOMETRYFRAMEWORK_API virtual bool HasTriangleColorFunction();
 
protected:
    TUniqueFunction<FColor(const FDynamicMesh3*, int)> TriangleColorFunc = nullptr;
 
    GEOMETRYFRAMEWORK_API FColor GetTriangleColor(const FDynamicMesh3* Mesh, int TriangleID);
 
    GEOMETRYFRAMEWORK_API FColor GetGroupColor(const FDynamicMesh3* Mesh, int TriangleID) const;
 
 
    //===============================================================================================================
    // Support for Vertex Color remapping/filtering. This allows external code to modulate the existing 
    // Vertex Colors on the rendered mesh. The remapping is only applied to FVector4f Color Overlay attribute buffers.
    // The lambda that is passed is held for the lifetime of the Component and
    // must remain valid. If the Vertex Colors are modified, FastNotifyColorsUpdated() can be used to do the 
    // minimal vertex buffer updates necessary in the RenderProxy
public:
    GEOMETRYFRAMEWORK_API virtual void SetVertexColorRemappingFunction(TUniqueFunction<void(FVector4f&)> ColorMapFuncIn,
        EDynamicMeshComponentRenderUpdateMode UpdateMode = EDynamicMeshComponentRenderUpdateMode::FastUpdate);
 
    GEOMETRYFRAMEWORK_API virtual void ClearVertexColorRemappingFunction(EDynamicMeshComponentRenderUpdateMode UpdateMode = EDynamicMeshComponentRenderUpdateMode::FastUpdate);
 
    GEOMETRYFRAMEWORK_API virtual bool HasVertexColorRemappingFunction();
 
protected:
    TUniqueFunction<void(FVector4f&)> VertexColorMappingFunc = nullptr;
 
    GEOMETRYFRAMEWORK_API void RemapVertexColor(FVector4f& VertexColorInOut);
 
 
 
    //===============================================================================================================
    // Support for Secondary triangle index buffers. When this is configured, then triangles identified
    // by the filtering predicate function will be placed in a second set of RenderBuffers at the SceneProxy level.
    // This can be combined with the SecondaryRenderMaterial support in UBaseDynamicMeshComponent to draw
    // that triangle set with a different material, to efficiently accomplish UI features like highlighting a
    // subset of mesh triangles.
    //
public:
    GEOMETRYFRAMEWORK_API virtual void EnableSecondaryTriangleBuffers(TUniqueFunction<bool(const FDynamicMesh3*, int32)> SecondaryTriFilterFunc);
 
    GEOMETRYFRAMEWORK_API virtual void DisableSecondaryTriangleBuffers();
 
protected:
    TUniqueFunction<bool(const FDynamicMesh3*, int32)> SecondaryTriFilterFunc = nullptr;
 
 
 
 
    //===============================================================================================================
    // Support for a Render Decomposition, which is basically a segmentation of the mesh triangles into
    // subsets which will be turned into separate RenderBuffers in the Render Proxy. If this is configured,
    // then various of the FastNotifyXYZUpdated() functions above will only need to rebuild the RenderBuffers
    // that include affected triangles. The FMeshRenderDecomposition implementation has various options for
    // building decompositions based on material, spatial clustering, etc.
    //
public:
    GEOMETRYFRAMEWORK_API virtual void SetExternalDecomposition(TUniquePtr<FMeshRenderDecomposition> Decomposition);
 
protected:
    TUniquePtr<FMeshRenderDecomposition> Decomposition;
 
 
 
 
    //===============================================================================================================
    // IRenderMeshPostProcessor Support. If a RenderMesh Postprocessor is configured, then instead of directly 
    // passing the internal mesh to the RenderProxy, IRenderMeshPostProcessor::PostProcess is applied to populate
    // the internal RenderMesh which is passed instead. This allows things like Displacement or Subdivision to be 
    // done on-the-fly at the rendering level (which is potentially more efficient).
    //
public:
    GEOMETRYFRAMEWORK_API virtual void SetRenderMeshPostProcessor(TUniquePtr<IRenderMeshPostProcessor> Processor);
 
    GEOMETRYFRAMEWORK_API virtual FDynamicMesh3* GetRenderMesh();
 
    GEOMETRYFRAMEWORK_API virtual const FDynamicMesh3* GetRenderMesh() const;
 
protected:
    TUniquePtr<IRenderMeshPostProcessor> RenderMeshPostProcessor;
    TUniquePtr<FDynamicMesh3> RenderMesh;
 
 
 
 
    //===============================================================================================================
    // Support for Component attachment change notifications via delegates. Standard UE
    // Actor/Component hierarchy does not generally provide these capabilities, but in some use
    // cases (eg procedural mesh Actors) we need to know things like when the Component set inside
    // an Actor is modified.
public:
    DECLARE_MULTICAST_DELEGATE_TwoParams(FComponentChildrenChangedDelegate, USceneComponent*, bool);
 
    FComponentChildrenChangedDelegate OnChildAttachmentModified;
 
 
 
    //===============================================================================================================
    // Material Set API. DynamicMeshComponent supports changing the Material Set dynamically, even at Runtime.
public:
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void ConfigureMaterialSet(const TArray<UMaterialInterface*>& NewMaterialSet, bool bDeleteExtraSlots = true);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API bool ValidateMaterialSlots(bool bCreateIfMissing = true, bool bDeleteExtraSlots = true);
 
 
    //===============================================================================================================
    // Triangle-Vertex Tangents support. The default behavior is to use the provided external Tangents.
    // If TangentsType == EDynamicMeshComponentTangentsMode::ExternallyProvided, the Tangent and Bitangent attributes of
    //   the FDynamicMesh3 AttributeSet are used at the SceneProxy level, the Component is not involved
    // If TangentsType == EDynamicMeshComponentTangentsMode::AutoCalculated, the Tangents are computed internally using
    //   a fast MikkT approximation via FMeshTangentsf. They will be recomputed when the mesh is modified, however
    //   they are *not* recomputed when using the Fast Update functions above (in that case InvalidateAutoCalculatedTangents() 
    //   can be used to force recomputation)
    // If TangentsType == EDynamicMeshComponentTangentsMode::NoTangents, the Component will not use Tangents, which will
    //   lead to incorrect rendering for any material with Normal Maps and some other shaders.
    //
private:
    // Default what the 'Default' tangent type should map to
    static constexpr EDynamicMeshComponentTangentsMode UseDefaultTangentsType = EDynamicMeshComponentTangentsMode::ExternallyProvided;
 
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void SetTangentsType(EDynamicMeshComponentTangentsMode NewTangentsType);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    EDynamicMeshComponentTangentsMode GetTangentsType() const
    {
        return TangentsType == EDynamicMeshComponentTangentsMode::Default ? UseDefaultTangentsType : TangentsType;
    }
 
private:
    // pure version of GetTangentsType, so it can be used as a getter below (getters must be BlueprintPure)
    UFUNCTION(BlueprintCallable, BlueprintPure, BlueprintInternalUseOnly, Category = "Dynamic Mesh Component")
    EDynamicMeshComponentTangentsMode GetTangentsTypePure() const
    {
        return GetTangentsType();
    }
 
public:
 
    GEOMETRYFRAMEWORK_API virtual void InvalidateAutoCalculatedTangents();
 
    GEOMETRYFRAMEWORK_API const UE::Geometry::FMeshTangentsf* GetAutoCalculatedTangents();
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetTangentsType, BlueprintGetter=GetTangentsTypePure, Category = "Dynamic Mesh Component|Rendering")
    EDynamicMeshComponentTangentsMode TangentsType = EDynamicMeshComponentTangentsMode::Default;
 
    bool bAutoCalculatedTangentsValid = false;
 
    UE::Geometry::FMeshTangentsf AutoCalculatedTangents;
 
    GEOMETRYFRAMEWORK_API void UpdateAutoCalculatedTangents();
 
 
    //===============================================================================================================
    //
    // Distance Field Support
    //
protected:
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    FCriticalSection DistanceFieldLock;
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    TSharedPtr<FDistanceFieldVolumeData> CurrentDistanceField;
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    virtual void UpdateDistanceField() {}
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    TAsyncComponentDataComputeQueue<FDistanceFieldVolumeData> DistanceFieldComputeQueue;
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    virtual void OnNewDistanceFieldData_Async(TUniquePtr<FDistanceFieldVolumeData> NewData) {}
 
 
 
    //===============================================================================================================
    //
    // Physics APIs
    //
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void EnableComplexAsSimpleCollision();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void SetComplexAsSimpleCollisionEnabled(bool bEnabled, bool bImmediateUpdate = true);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API void SetDeferredCollisionUpdatesEnabled(bool bEnabled, bool bImmediateUpdate = true);
 
 
    GEOMETRYFRAMEWORK_API virtual bool GetPhysicsTriMeshData(struct FTriMeshCollisionData* CollisionData, bool InUseAllTriData) override;
    GEOMETRYFRAMEWORK_API virtual bool GetTriMeshSizeEstimates(struct FTriMeshCollisionDataEstimates& OutTriMeshEstimates, bool bInUseAllTriData) const override;
    GEOMETRYFRAMEWORK_API virtual bool ContainsPhysicsTriMeshData(bool InUseAllTriData) const override;
    GEOMETRYFRAMEWORK_API virtual bool WantsNegXTriMesh() override;
 
    virtual const UBodySetup* GetBodySetup() const { return MeshBodySetup; }
    GEOMETRYFRAMEWORK_API virtual UBodySetup* GetBodySetup() override;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void UpdateCollision(bool bOnlyIfPending = true);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Collision")
    TEnumAsByte<enum ECollisionTraceFlag> CollisionType = ECollisionTraceFlag::CTF_UseSimpleAsComplex;
 
    GEOMETRYFRAMEWORK_API virtual void SetSimpleCollisionShapes(const struct FKAggregateGeom& AggGeom, bool bUpdateCollision);
 
    const FKAggregateGeom& GetSimpleCollisionShapes() const
    {
        return AggGeom;
    }
 
    GEOMETRYFRAMEWORK_API virtual void ClearSimpleCollisionShapes(bool bUpdateCollision);
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Dynamic Mesh Component|Collision")
    bool bUseAsyncCooking = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Collision");
    bool bEnableComplexCollision = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Collision");
    bool bDeferCollisionUpdates = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Collision");
    bool bDisableMeshUVHitResults = false;
 
    GEOMETRYFRAMEWORK_API void SetTransientDeferCollisionUpdates(bool bEnabled);
 
protected:
    UPROPERTY(Instanced)
    TObjectPtr<UBodySetup> MeshBodySetup;
 
    GEOMETRYFRAMEWORK_API virtual void InvalidatePhysicsData();
    GEOMETRYFRAMEWORK_API virtual void RebuildPhysicsData();
 
    bool bTransientDeferCollisionUpdates = false;
    bool bCollisionUpdatePending = false;
 
protected:
 
    //
    // standard Component internals, for computing bounds and managing the SceneProxy
    //
 
    UE::Geometry::FAxisAlignedBox3d LocalBounds;
 
    GEOMETRYFRAMEWORK_API void UpdateLocalBounds();
 
    //
    // Internals for managing collision representation and setup
    //
 
    UPROPERTY(EditAnywhere, Category = BodySetup, meta = (DisplayName = "Primitives", NoResetToDefault))
    struct FKAggregateGeom AggGeom;
 
    UPROPERTY(transient)
    TArray<TObjectPtr<UBodySetup>> AsyncBodySetupQueue;
 
    GEOMETRYFRAMEWORK_API virtual void FinishPhysicsAsyncCook(bool bSuccess, UBodySetup* FinishedBodySetup);
 
    GEOMETRYFRAMEWORK_API virtual UBodySetup* CreateBodySetupHelper();
    
    GEOMETRYFRAMEWORK_API virtual void SetBodySetup(UBodySetup* NewSetup);
 
    GEOMETRYFRAMEWORK_API virtual void NotifyMaterialSetUpdated();
 
    bool bProxyValid = false;
 
    bool bProxyVerifyUsedMaterials = true;
 
    virtual FBaseDynamicMeshSceneProxy* GetBaseSceneProxy() override { return (FBaseDynamicMeshSceneProxy*)GetCurrentSceneProxy(); }
 
    GEOMETRYFRAMEWORK_API FDynamicMeshSceneProxy* GetCurrentSceneProxy();
 
 
    GEOMETRYFRAMEWORK_API void ResetProxy();
 
    //~ Begin UPrimitiveComponent Interface.
    GEOMETRYFRAMEWORK_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
 
    //~ USceneComponent Interface.
    GEOMETRYFRAMEWORK_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    GEOMETRYFRAMEWORK_API virtual void OnChildAttached(USceneComponent* ChildComponent) override;
    GEOMETRYFRAMEWORK_API virtual void OnChildDetached(USceneComponent* ChildComponent) override;
 
    //~ UObject Interface.
    GEOMETRYFRAMEWORK_API virtual void Serialize(FArchive& Ar) override;
    GEOMETRYFRAMEWORK_API virtual void PostLoad() override; // called after load
    GEOMETRYFRAMEWORK_API virtual void PostEditImport() override; // called after duplicate/copy
    GEOMETRYFRAMEWORK_API virtual void BeginDestroy() override;
#if WITH_EDITOR
    GEOMETRYFRAMEWORK_API void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
public:
    GEOMETRYFRAMEWORK_API void SetSceneProxyVerifyUsedMaterials(bool bState);
 
 
private:
    // Internal helper to be called when mesh data is updated
    void InternalOnMeshUpdated();
 
    void BroadcastMeshPropertyChangeEvent();
 
};