UDynamicMesh.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "DynamicMesh/DynamicMesh3.h"
 
#include "Changes/MeshVertexChange.h"
#include "Changes/MeshChange.h"
#include "Changes/MeshReplacementChange.h"
 
#include "UDynamicMesh.generated.h"
 
 
 
UCLASS(Abstract, MinimalAPI)
class UDynamicMeshGenerator : public UObject
{
    GENERATED_BODY()
public:
    virtual void Generate(FDynamicMesh3& MeshInOut) { };
};
 
 
 
 
 
UENUM(BlueprintType)
enum class EDynamicMeshChangeType : uint8
{
    GeneralEdit = 0,
    MeshChange = 1,
    MeshReplacementChange = 2,
    MeshVertexChange = 3,
    
    DeformationEdit = 4,
    AttributeEdit = 5
};
 
UENUM(BlueprintType)
enum class EDynamicMeshAttributeChangeFlags : uint8
{
    Unknown = 0,
    MeshTopology = 1 << 0,
 
    VertexPositions = 1 << 1,
    NormalsTangents = 1 << 2,
    VertexColors = 1 << 3,
    UVs = 1 << 4,
    TriangleGroups = 1 << 5
};
ENUM_CLASS_FLAGS(EDynamicMeshAttributeChangeFlags)
 
 
USTRUCT(BlueprintType)
struct FDynamicMeshChangeInfo
{
    GENERATED_BODY()
 
    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "DynamicMeshChangeInfo")
    EDynamicMeshChangeType Type = EDynamicMeshChangeType::GeneralEdit;
 
    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "DynamicMeshChangeInfo")
    EDynamicMeshAttributeChangeFlags Flags = EDynamicMeshAttributeChangeFlags::Unknown;
 
    // for changes that are an FChange, indicates whether this is an 'Apply' or 'Revert' of the FChange
    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category = "DynamicMeshChangeInfo")
    bool bIsRevertChange = false;
 
    // return the single valid FChange, or null
    const FMeshRegionChangeBase* GetChange() const
    {
        if (MeshChange)
        {
            ensure(!ReplaceChange && !VertexChange); // not valid to have multiple non-null FChanges
            return MeshChange;
        }
        else if (ReplaceChange)
        {
            ensure(!VertexChange); // not valid to have multiple non-null FChanges
            return ReplaceChange;
        }
        else
        {
            return VertexChange;
        }
    }
 
    //
    // internals
    //
    const FMeshChange* MeshChange = nullptr;
    const FMeshReplacementChange* ReplaceChange = nullptr;
    const FMeshVertexChange* VertexChange = nullptr;
};
 
// These delegates are used by UDynamicMesh
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnDynamicMeshChanged, UDynamicMesh*, FDynamicMeshChangeInfo);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnDynamicMeshModifiedBP, UDynamicMesh*, Mesh);
 
 
 
UCLASS(BlueprintType, MinimalAPI)
class UDynamicMesh : public UObject,
    public IMeshVertexCommandChangeTarget, 
    public IMeshCommandChangeTarget, 
    public IMeshReplacementCommandChangeTarget
{
    GENERATED_UCLASS_BODY()
public:
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh", meta = (Keywords = "Clear Empty Delete"))
    GEOMETRYFRAMEWORK_API UPARAM(DisplayName = "Target") UDynamicMesh* Reset();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API UPARAM(DisplayName = "Target") UDynamicMesh* ResetToCube();
 
    //
    // Native access/modification functions
    //
 
    GEOMETRYFRAMEWORK_API virtual void InitializeMesh();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API bool IsEmpty() const;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API UPARAM(DisplayName = "Triangle Count") int32 GetTriangleCount() const;
 
 
    const UE::Geometry::FDynamicMesh3& GetMeshRef() const { return *Mesh; }
    const UE::Geometry::FDynamicMesh3* GetMeshPtr() const { return Mesh.Get(); }
 
    UE::Geometry::FDynamicMesh3& GetMeshRef() { return *Mesh; }
    UE::Geometry::FDynamicMesh3* GetMeshPtr() { return Mesh.Get(); }
 
 
    GEOMETRYFRAMEWORK_API void SetMesh(const UE::Geometry::FDynamicMesh3& MoveMesh);
 
    GEOMETRYFRAMEWORK_API void SetMesh(UE::Geometry::FDynamicMesh3&& MoveMesh);
 
    GEOMETRYFRAMEWORK_API void ProcessMesh(TFunctionRef<void(const UE::Geometry::FDynamicMesh3&)> ProcessFunc) const;
 
    GEOMETRYFRAMEWORK_API void EditMesh(TFunctionRef<void(UE::Geometry::FDynamicMesh3&)> EditFunc,
                  EDynamicMeshChangeType ChangeType = EDynamicMeshChangeType::GeneralEdit,
                  EDynamicMeshAttributeChangeFlags ChangeFlags = EDynamicMeshAttributeChangeFlags::Unknown,
                  bool bDeferChangeEvents = false);
 
    GEOMETRYFRAMEWORK_API TUniquePtr<UE::Geometry::FDynamicMesh3> ExtractMesh();
 
 
    //
    // Change support
    //
 
 
    // IMeshVertexCommandChangeTarget implementation, allows a FVertexChange to be applied to the mesh
    GEOMETRYFRAMEWORK_API void ApplyChange(const FMeshVertexChange* Change, bool bRevert);
 
    // IMeshCommandChangeTarget implementation, allows a FMeshChange to be applied to the mesh
    GEOMETRYFRAMEWORK_API void ApplyChange(const FMeshChange* Change, bool bRevert);
 
    // IMeshReplacementCommandChangeTarget implementation, allows a FMeshReplacementChange to be applied to the mesh
    GEOMETRYFRAMEWORK_API void ApplyChange(const FMeshReplacementChange* Change, bool bRevert);
 
 
    //
    // Event support
    //
protected:
    FOnDynamicMeshChanged PreMeshChangedEvent;
    FOnDynamicMeshChanged MeshChangedEvent;
 
public:
    FOnDynamicMeshChanged& OnPreMeshChanged() { return PreMeshChangedEvent; }
    FOnDynamicMeshChanged& OnMeshChanged() { return MeshChangedEvent; }
 
public:
    UPROPERTY(BlueprintAssignable, meta = (DisplayName = "MeshModified"))
    FOnDynamicMeshModifiedBP MeshModifiedBPEvent;
 
 
    //
    // Realtime Update support.
    // This is intended to be used in situations where the internal mesh is being
    // modified directly, ie instead of via EditMesh(), and we would like to
    // notify listeners of these changes. Generally EditMesh() is preferred but in certain
    // cases (eg like 3D sculpting) it is too complex to refactor all the mesh updates
    // into EditMesh() calls (eg some are done async/etc). So, code that does those
    // kinds of modifications can call PostRealtimeUpdate() to let any interested
    // parties know that the mesh is actively changing.
    //
public:
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnMeshRealtimeUpdate, UDynamicMesh*);
 
    FOnMeshRealtimeUpdate& OnMeshRealtimeUpdate() { return MeshRealtimeUpdateEvent; }
 
    GEOMETRYFRAMEWORK_API virtual void PostRealtimeUpdate();
 
protected:
    FOnMeshRealtimeUpdate MeshRealtimeUpdateEvent;
 
 
 
protected:
    TUniquePtr<UE::Geometry::FDynamicMesh3> Mesh;
 
    GEOMETRYFRAMEWORK_API void InitializeNewMesh();
 
    GEOMETRYFRAMEWORK_API void EditMeshInternal(TFunctionRef<void(UE::Geometry::FDynamicMesh3&)> EditFunc, const FDynamicMeshChangeInfo& ChangeInfo, bool bDeferChangeEvents = false);
 
 
public:
    // serialize Mesh to an Archive
    GEOMETRYFRAMEWORK_API virtual void Serialize(FArchive& Archive) override;
 
    // serialize Mesh to/from T3D
    GEOMETRYFRAMEWORK_API virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent) override;
    GEOMETRYFRAMEWORK_API virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) override;
 
 
 
    //
    // (Preliminary) Procedural Generator support. If a Generator is configured, then each
    // time this mesh is Reset(), it will call MeshGenerator->Generate(). The idea is that 
    // generator will be set to something that emits a new mesh based on external data,
    // for example a procedural primitive Actor/Component could configure a Generator that
    // generates the primitive mesh based on Actor settings.
    //
 
protected:
 
    UPROPERTY(Instanced)
    TObjectPtr<UDynamicMeshGenerator> MeshGenerator;
 
public:
 
    UPROPERTY(EditAnywhere, Category = "Dynamic Mesh")
    bool bEnableMeshGenerator = false;
 
    GEOMETRYFRAMEWORK_API virtual void SetMeshGenerator(TObjectPtr<UDynamicMeshGenerator> NewGenerator);
 
    GEOMETRYFRAMEWORK_API virtual void ClearMeshGenerator();
 
    GEOMETRYFRAMEWORK_API virtual void Regenerate();
 
};
 
 
 
 
 
 
UCLASS(BlueprintType, Transient, MinimalAPI)
class UDynamicMeshPool : public UObject
{
    GENERATED_BODY()
public:
    UFUNCTION(BlueprintCallable, Category="Dynamic Mesh")
    GEOMETRYFRAMEWORK_API UDynamicMesh* RequestMesh();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API void ReturnMesh(UDynamicMesh* Mesh);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API void ReturnAllMeshes();
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh")
    GEOMETRYFRAMEWORK_API void FreeAllMeshes();
 
protected:
    UPROPERTY()
    TArray<TObjectPtr<UDynamicMesh>> CachedMeshes;
 
    UPROPERTY()
    TArray<TObjectPtr<UDynamicMesh>> AllCreatedMeshes;
 
private:
    // Typically the mesh pool is used from the game thread, but 
    // in case it is not, we protect pool access w/ this critical section
    mutable FCriticalSection PoolAccessCs;
};