BaseDynamicMeshComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Components/MeshComponent.h"
#include "InteractiveToolObjects.h"
#include "Changes/MeshVertexChange.h"
#include "Changes/MeshChange.h"
#include "Changes/MeshReplacementChange.h"
#include "MeshConversionOptions.h"
#include "DynamicMesh/DynamicMesh3.h"       // todo replace with predeclaration (lots of fallout)
#include "UDynamicMesh.h"
 
#include "BaseDynamicMeshComponent.generated.h"
 
// predecl
struct FMeshDescription;
class FMeshVertexChange;
class FMeshChange;
class FBaseDynamicMeshSceneProxy;
using UE::Geometry::FDynamicMesh3;
 
enum class EMeshRenderAttributeFlags : uint8
{
    None = 0,
    Positions = 1,
    VertexColors = 1<<1,
    VertexNormals = 1<<2,
    VertexUVs = 1<<3,
    SecondaryIndexBuffers = 1<<4,
 
    AllVertexAttribs = Positions | VertexColors | VertexNormals | VertexUVs
};
ENUM_CLASS_FLAGS(EMeshRenderAttributeFlags);
 
 
 
UENUM(BlueprintType)
enum class EDynamicMeshComponentTangentsMode : uint8
{
    NoTangents,
    AutoCalculated,
    ExternallyProvided UMETA(DisplayName = "From Dynamic Mesh"),
    Default = 255
};
 
 
UENUM(BlueprintType)
enum class EDynamicMeshComponentColorOverrideMode : uint8
{
    None,
    VertexColors,
    Polygroups,
    Constant
};
 
 
UENUM(BlueprintType)
enum class EDynamicMeshDrawPath : uint8
{
    DynamicDraw = 0,
    StaticDraw = 1
};
 
 
UENUM(BlueprintType)
enum class UE_DEPRECATED(5.0, "Dynamic Mesh distance field support has been deprecated") EDynamicMeshComponentDistanceFieldMode : uint8
{
    NoDistanceField = 0,
    AsyncCPUDistanceField = 1 UMETA(DisplayName = "Async CPU Distance Field")
};
 
UENUM(BlueprintType)
enum class EDynamicMeshVertexColorTransformMode : uint8
{
    NoTransform = 0,
    LinearToSRGB,
    SRGBToLinear UMETA(DisplayName = "SRGB To Linear")
};
 
 
UCLASS(Abstract, hidecategories = (LOD), ClassGroup = Rendering, MinimalAPI)
class UBaseDynamicMeshComponent : 
    public UMeshComponent, 
    public IToolFrameworkComponent, 
    public IMeshVertexCommandChangeTarget, 
    public IMeshCommandChangeTarget, 
    public IMeshReplacementCommandChangeTarget
{
    GENERATED_UCLASS_BODY()
 
 
    //===============================================================================================================
    // UBaseDynamicMeshComponent API. Subclasses must implement these functions
    //
public:
    virtual void SetMesh(UE::Geometry::FDynamicMesh3&& MoveMesh)
    {
        unimplemented();
    }
 
    virtual FDynamicMesh3* GetMesh()
    {
        unimplemented();
        return nullptr;
    }
 
    virtual const FDynamicMesh3* GetMesh() const
    {
        unimplemented();
        return nullptr;
    }
 
    virtual void ProcessMesh(TFunctionRef<void(const UE::Geometry::FDynamicMesh3&)> ProcessFunc) const
    {
        unimplemented();
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UDynamicMesh* GetDynamicMesh() 
    { 
        unimplemented();
        return nullptr; 
    }
 
    virtual void NotifyMeshUpdated()
    {
        unimplemented();
    }
 
    virtual void ApplyChange(const FMeshVertexChange* Change, bool bRevert) override
    {
        unimplemented();
    }
 
    virtual void ApplyChange(const FMeshChange* Change, bool bRevert) override
    {
        unimplemented();
    }
 
    virtual void ApplyChange(const FMeshReplacementChange* Change, bool bRevert) override
    {
        unimplemented();
    }
 
    virtual void ApplyTransform(const FTransform3d& Transform, bool bInvert)
    {
        unimplemented();
    }
 
 
protected:
 
    virtual FBaseDynamicMeshSceneProxy* GetBaseSceneProxy()
    {
        unimplemented();
        return nullptr;
    }
 
    virtual void NotifyMaterialSetUpdated()
    {
        unimplemented();
    }
 
 
 
    //===============================================================================================================
    // Built-in Wireframe-on-Shaded Rendering support. The wireframe looks terrible but this is a convenient 
    // way to enable/disable it.
    //
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Wireframe Overlay") )
    bool bExplicitShowWireframe = false;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual void SetEnableWireframeRenderPass(bool bEnable) { bExplicitShowWireframe = bEnable; }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual bool GetEnableWireframeRenderPass() const { return bExplicitShowWireframe; }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Wireframe Color"))
    FLinearColor WireframeColor = FLinearColor(0, 0.5f, 1.f);
 
 
    //===============================================================================================================
    // Built-in Color Rendering Support. When enabled, Color mode will override any assigned Materials.
    // VertexColor mode displays vertex colors, Polygroup mode displays mesh polygroups via vertex colors,
    // and Constant mode uses ConstantColor as the vertex color. The class-wide DefaultVertexColorMaterial
    // is used as the material that displays the vertex colors, and cannot be overridden per-instance
    // (the OverrideRenderMaterial can be used to do that)
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Color Override") )
    EDynamicMeshComponentColorOverrideMode ColorMode = EDynamicMeshComponentColorOverrideMode::None;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    GEOMETRYFRAMEWORK_API virtual void SetColorOverrideMode(EDynamicMeshComponentColorOverrideMode NewMode);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    virtual EDynamicMeshComponentColorOverrideMode GetColorOverrideMode() const { return ColorMode; }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Constant Color", EditCondition = "ColorMode==EDynamicMeshComponentColorOverrideMode::Constant"))
    FColor ConstantColor = FColor::White;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    GEOMETRYFRAMEWORK_API virtual void SetConstantOverrideColor(FColor NewColor);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    virtual FColor GetConstantOverrideColor() const { return ConstantColor; }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Vertex Color Space"))
    EDynamicMeshVertexColorTransformMode ColorSpaceMode = EDynamicMeshVertexColorTransformMode::NoTransform;
    
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    GEOMETRYFRAMEWORK_API virtual void SetVertexColorSpaceTransformMode(EDynamicMeshVertexColorTransformMode NewMode);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    virtual EDynamicMeshVertexColorTransformMode GetVertexColorSpaceTransformMode() const { return ColorSpaceMode; }
 
 
    //===============================================================================================================
    // Two-Sided rendering support. When enabled, triangles will be rendered whether they are facing the camera or not
public:
    GEOMETRYFRAMEWORK_API virtual void SetTwoSided(bool bEnable);
    virtual bool GetTwoSided() const { return bTwoSided; }
 
protected:
    UPROPERTY(EditAnywhere, Category = "Dynamic Mesh Component|Rendering");
    bool bTwoSided = false;
 
    //===============================================================================================================
    // Flat shading support. When enabled, per-triangle normals are computed automatically and used in place
    // of the mesh normals. Mesh tangents are not affected.
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "Flat Shading") )
    bool bEnableFlatShading = false;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    GEOMETRYFRAMEWORK_API virtual void SetEnableFlatShading(bool bEnable);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component|Rendering")
    virtual bool GetFlatShadingEnabled() const { return bEnableFlatShading; }
 
 
 
    //===============================================================================================================
    // API for changing Rendering settings. Although some of these settings are available publicly
    // on the Component (in some cases as public members), generally changing them requires more complex 
    // Rendering invalidation.
    //
public:
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetShadowsEnabled(bool bEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual bool GetShadowsEnabled() const { return CastShadow; }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetViewModeOverridesEnabled(bool bEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual bool GetViewModeOverridesEnabled() const { return bEnableViewModeOverrides; }
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering", meta = (DisplayName = "View Mode Overrides") )
    bool bEnableViewModeOverrides = true;
 
 
    //===============================================================================================================
    // Override rendering material support. If an Override material is set, then it
    // will be used during drawing of all mesh buffers except Secondary buffers.
    //
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetOverrideRenderMaterial(UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void ClearOverrideRenderMaterial();
    
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual bool HasOverrideRenderMaterial(int k) const
    {
        return OverrideRenderMaterial != nullptr;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UMaterialInterface* GetOverrideRenderMaterial(int MaterialIndex) const
    {
        return OverrideRenderMaterial;
    }
 
protected:
    UPROPERTY()
    TObjectPtr<UMaterialInterface> OverrideRenderMaterial = nullptr;
 
 
 
 
 
    //===============================================================================================================
    // Secondary Render Buffers support. This requires implementation in subclasses. It allows
    // a subset of the mesh triangles to be moved to a separate set of render buffers, which
    // can then have a separate material (eg to highlight faces), or be shown/hidden independently.
    // 
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetSecondaryRenderMaterial(UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void ClearSecondaryRenderMaterial();
 
    virtual bool HasSecondaryRenderMaterial() const
    {
        return SecondaryRenderMaterial != nullptr;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UMaterialInterface* GetSecondaryRenderMaterial() const
    {
        return SecondaryRenderMaterial;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetSecondaryBuffersVisibility(bool bSetVisible);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual bool GetSecondaryBuffersVisibility() const;
 
protected:
    UPROPERTY()
    TObjectPtr<UMaterialInterface> SecondaryRenderMaterial = nullptr;
 
    bool bDrawSecondaryBuffers = true;
 
 
    //===============================================================================================================
    // Wireframe Material Override Support : Allow to override default wireframe material
    // 
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetOverrideWireframeRenderMaterial(UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void ClearOverrideWireframeRenderMaterial();
 
    virtual bool HasOverrideWireframeRenderMaterial() const
    {
        return WireframeMaterialOverride != nullptr;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UMaterialInterface* GetOverrideWireframeRenderMaterial() const
    {
        return WireframeMaterialOverride;
    }
 
protected:
    UPROPERTY();
    TObjectPtr<UMaterialInterface> WireframeMaterialOverride = nullptr;
 
 
    //===============================================================================================================
    // Wireframe Material Secondary Override Support : Allow to override default secondary wireframe material
    // 
public:
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetOverrideSecondaryWireframeRenderMaterial(UMaterialInterface* Material);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void ClearOverrideSecondaryWireframeRenderMaterial();
 
    virtual bool HasOverrideSecondaryWireframeRenderMaterial() const
    {
        return SecondaryWireframeMaterialOverride != nullptr;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    virtual UMaterialInterface* GetOverrideSecondaryWireframeRenderMaterial() const
    {
        return SecondaryWireframeMaterialOverride;
    }
 
protected:
    UPROPERTY();
    TObjectPtr<UMaterialInterface> SecondaryWireframeMaterialOverride = nullptr;
 
 
    //===============================================================================================================
    // Raytracing support. Must be enabled for various rendering effects. 
    // However, note that in actual "dynamic" contexts (ie where the mesh is changing every frame),
    // enabling Raytracing support has additional renderthread performance costs and does
    // not currently support partial updates in the SceneProxy.
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Dynamic Mesh Component|Rendering")
    bool bEnableRaytracing = true;
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetEnableRaytracing(bool bSetEnabled);
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual bool GetEnableRaytracing() const;
 
protected:
    GEOMETRYFRAMEWORK_API virtual void OnRenderingStateChanged(bool bForceImmedateRebuild);
 
 
 
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadWrite,
                BlueprintSetter=SetMeshDrawPath, BlueprintGetter=GetMeshDrawPath,
                 Category = "Dynamic Mesh Component|Rendering")
    EDynamicMeshDrawPath DrawPath = EDynamicMeshDrawPath::DynamicDraw;
 
    // Whether the fast update paths will be used for the mesh.
    // If false, fast update methods can still be called, but will fall back to recreating the render proxy
    virtual bool AllowFastUpdate()
    {
        // note: fast update is not compatible with static draw path
        return DrawPath == EDynamicMeshDrawPath::DynamicDraw;
    }
    
public:
 
    UFUNCTION(BlueprintCallable, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual void SetMeshDrawPath(EDynamicMeshDrawPath NewDrawPath);
 
    UFUNCTION(BlueprintPure, Category = "Dynamic Mesh Component")
    GEOMETRYFRAMEWORK_API virtual EDynamicMeshDrawPath GetMeshDrawPath() const;
 
PRAGMA_DISABLE_DEPRECATION_WARNINGS
protected:
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    UPROPERTY(meta = (DeprecatedProperty, DeprecationMessage = "Dynamic Mesh distance field support has been deprecated"))
    EDynamicMeshComponentDistanceFieldMode DistanceFieldMode_DEPRECATED = EDynamicMeshComponentDistanceFieldMode::NoDistanceField;
 
public:
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    UFUNCTION(Category = "Dynamic Mesh Component", meta = (DeprecatedFunction, DeprecationMessage = "Dynamic Mesh distance field support has been deprecated"))
    virtual void SetDistanceFieldMode(EDynamicMeshComponentDistanceFieldMode NewDistFieldMode) {}
 
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    UFUNCTION(Category = "Dynamic Mesh Component", meta = (DeprecatedFunction, DeprecationMessage = "Dynamic Mesh distance field support has been deprecated"))
    virtual EDynamicMeshComponentDistanceFieldMode GetDistanceFieldMode() const { return EDynamicMeshComponentDistanceFieldMode::NoDistanceField; }
PRAGMA_ENABLE_DEPRECATION_WARNINGS
    
protected:
    // this will be called if a change to distance field mode is detected
    UE_DEPRECATED(5.6, "Dynamic Mesh distance field support has been deprecated")
    GEOMETRYFRAMEWORK_API virtual void OnNewDistanceFieldMode() {}
 
 
 
    //===============================================================================================================
    // Standard Component interfaces
    //
public:
 
    // UMeshComponent Interface.
    GEOMETRYFRAMEWORK_API virtual int32 GetNumMaterials() const override;
    GEOMETRYFRAMEWORK_API virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const override;
    UE_DEPRECATED(5.7, "Please use GetMaterialRelevance with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    GEOMETRYFRAMEWORK_API virtual FMaterialRelevance GetMaterialRelevance(ERHIFeatureLevel::Type InFeatureLevel) const override;
    GEOMETRYFRAMEWORK_API virtual FMaterialRelevance GetMaterialRelevance(EShaderPlatform InShaderPlatform) const override;
    GEOMETRYFRAMEWORK_API virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
    GEOMETRYFRAMEWORK_API virtual void GetUsedMaterials(TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false) const override;
 
    GEOMETRYFRAMEWORK_API virtual void SetNumMaterials(int32 NumMaterials);
 
    //~ Dynamic Mesh component just has an array of materials without managing slot names, but some methods expect
    //~ to access materials via slot name, so we still implement the UPrimitiveComponent interface to do so
    // @return an array of slot names generated from the current materials
    GEOMETRYFRAMEWORK_API virtual TArray<FName> GetMaterialSlotNames() const override;
    // @return true if the dynamic mesh has a material with this slot name
    GEOMETRYFRAMEWORK_API virtual bool IsMaterialSlotNameValid(FName MaterialSlotName) const override;
    // @return a material on this component with this slot name, or null not found
    GEOMETRYFRAMEWORK_API virtual UMaterialInterface* GetMaterialByName(FName MaterialSlotName) const override;
 
    //~ UObject Interface.
#if WITH_EDITOR
    GEOMETRYFRAMEWORK_API void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
    UPROPERTY()
    TArray<TObjectPtr<UMaterialInterface>> BaseMaterials;
 
 
 
 
 
    //===============================================================================================================
    // Class-wide Default Materials used for Wireframe and VertexColor display mode.
    // These are configured for the Editor when the module loads, defaulting to built-in Engine wireframe and
    // vertex color materials. 
    // Note that the ModelingComponents module in the MeshModelingToolset plugin (usually enabled in the UE Editor) 
    // will set a new VertexColor material from that plugins Content. 
    // Client code can further configure these materials as necessary using the static functions below.
public:
    static GEOMETRYFRAMEWORK_API void SetDefaultWireframeMaterial(UMaterialInterface* Material);
 
    static GEOMETRYFRAMEWORK_API void SetDefaultVertexColorMaterial(UMaterialInterface* Material);
 
protected:
    static GEOMETRYFRAMEWORK_API void InitializeDefaultMaterials();
    friend class FGeometryFrameworkModule;          // FGeometryFrameworkModule needs to call the above function
 
    static GEOMETRYFRAMEWORK_API UMaterialInterface* GetDefaultWireframeMaterial_RenderThread();
    static GEOMETRYFRAMEWORK_API UMaterialInterface* GetDefaultVertexColorMaterial_RenderThread();
    friend class FBaseDynamicMeshSceneProxy;        // FBaseDynamicMeshSceneProxy needs to call these functions...
 
private:
    // these Materials are used by the render thread. Once the engine is running they should not be modified without 
    // using SetDefaultWireframeMaterial/SetDefaultVertexColorMaterial
    static GEOMETRYFRAMEWORK_API UMaterialInterface* DefaultWireframeMaterial;
    static GEOMETRYFRAMEWORK_API UMaterialInterface* DefaultVertexColorMaterial;
};