I3DHDrawingEditor.h Source File

instant3Dhub: I3DHDrawingEditor.h Source File
instant3Dhub
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "I3DHDataTypes.h"
#include "I3DHDrawing.h"
#include "I3DHError.h"
#include "I3DHSplineData.h"
#include "I3DHVersion.h"
 
#include "GameFramework/Actor.h"
#include "Templates/RefCounting.h"
#include "Engine/AssetUserData.h"
 
#include "I3DHDrawingEditor.generated.h"
 
class AI3DHConnector;
 
UENUM(BlueprintType)
enum class EI3DHDrawingEditorMode : uint8
{
    None,
    Draw,
    EditDrawing,
    Finalize
};
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
DECLARE_DYNAMIC_DELEGATE_ThreeParams(FI3DHDrawingFinalizedDelegate, const FI3DHDrawingResult&, DrawingResult, const FI3DHDrawingProperties&, DrawingProperties, const TArray<FI3DHSplineData>&, Splines);
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
class INSTANT3DHUB_EXPERIMENTAL(0.0.27, "The instant3Dhub Drawings feature is available as a preview and is actively under development.") AI3DHDrawingEditor;
 
 
PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
UCLASS(Experimental, Abstract, NotPlaceable, meta = (DisplayName = "I3DH DrawingEditor (Experimental)"))
class INSTANT3DHUBDRAWINGS_API AI3DHDrawingEditor
    : public AActor
    , public II3DHEditDrawingInterface
{
PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
    GENERATED_BODY()
 
    friend class UI3DHDrawingSplineRendererBase;
    friend class UI3DHDrawingInstancedStaticMeshRenderer;
    friend class UI3DHDrawingJointMeshRenderer;
    friend class UI3DHDrawingSegmentMeshRenderer;
    friend class UI3DHDrawingControlPointRenderer;
 
public:
    AI3DHDrawingEditor();
 
    void InitializePreSpawn(AI3DHConnector* ParentHubConnector);
 
    //~ Begin AActor Interface
    virtual void Tick(float DeltaSeconds) override;
    //~ End AActor Interface
 
    //~ Begin II3DHEditDrawingInterface
    virtual void BeginEditDrawing_Implementation(
        const int32 DrawingHandle,
        const FI3DHDrawingProperties& DrawingProperties,
        const UI3DHEditDrawingGeometryProvider* GeometryProvider,
        const class AI3DHDrawing* DrawingActor) override;
    //~ End II3DHEditDrawingInterface
 
public:
    UFUNCTION(BlueprintCallable, meta = (DefaultToSelf = "HubConnector", DeterminesOutputType = "DrawingClass"), Category = "{instant3DhubDrawings}")
    static AI3DHDrawingEditor* CreateDrawingEditor(AI3DHConnector* HubConnector, TSubclassOf<AI3DHDrawingEditor> DrawingClass);
 
    UFUNCTION(BlueprintPure, Category = "{instant3DhubDrawings}")
    AI3DHConnector* GetHubConnector() const { return HubConnector; }
 
    // ----------------------------------------------------------
    // AI3DHDrawingEditor API
    // ----------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, meta = (AutoCreateRefTerm = "Color"), Category = "{instant3DhubDrawings}")
    void SetDrawingColor(const FLinearColor& Color);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    FLinearColor GetDrawingColor() const;
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void SetDrawingScale(const double& Scale);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    double GetDrawingScale() const;
 
    const FString& GetEditedDrawingName() const { return EditedDrawingName; }
 
    INSTANT3DHUB_DEPRECATED(1.1.0, "Will be removed because it is not supported for LineStrip drawings.")
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}", meta = (DisplayName = "Set Omit Stroke Start and End Joints (Deprecated)"))
    void SetOmitStrokeStartAndEndJoints(bool bNewOmitJoints);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void SetShowActiveSliceControlPoints(bool bNewShowActiveSliceControlPoints);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    bool IsEmpty() const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    int32 NumSplines() const;
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void Clear();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void Restore();
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "{instant3DhubDrawings}")
    void MoveCursorTo(const FVector& Location);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void AddPointAtCursor();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void BeginNewSplineSlice();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    UPARAM(DisplayName = "bWasLastSplineSlice") bool RemoveLastSplineSlice();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void BeginNewSpline();
 
    PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
    void FinalizeDrawing(TUniqueFunction<void(FI3DHDrawingResult)> OnComplete);
    PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
 
    void CreateHubDrawingAndDestroy(const FString& Name, TUniqueFunction<void(int32 DrawingHandle, EI3DHErrorCode ErrorCode)> OnComplete);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void SetDrawingMode(EI3DHDrawingEditorMode InDrawingMode);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    EI3DHDrawingEditorMode GetDrawingEditorMode() const { return DrawingMode; }
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    bool AddPoint(const FVector& Location, bool bIsWorldSpace = false);
 
    PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void InitFromSplines(const TArray<FI3DHSplineData>& InSplines);
    PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
    void InitFromSplines(TArray<FI3DHSplineData>&& InSplines);
 
    PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    const TArray<FI3DHSplineData>& GetSplines() const { return Splines; }
    PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    bool SelectNearestPointAtCursor();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    bool SelectNearestPoint(const FVector& Location, bool bIsWorldSpace = false);
 
    UFUNCTION(BlueprintPure, Category = "{instant3DhubDrawings}")
    int32 GetNumFinalizedSplines() const
    {
        if (GetDrawingEditorMode() != EI3DHDrawingEditorMode::Finalize) { return 0; }
        return FinalizedSplineMask.CountSetBits();
    }
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    TArray<int32> GetFinalizedSplineIndices() const
    {
        TArray<int32> Indices;
        if (GetDrawingEditorMode() != EI3DHDrawingEditorMode::Finalize) { return Indices; }
 
        const int32 Num = FinalizedSplineMask.CountSetBits();
        Indices.Reserve(Num);
        for (TConstSetBitIterator It(FinalizedSplineMask); It; ++It)
        {
            Indices.Add(It.GetIndex());
        }
        return Indices;
    }
 
    UFUNCTION(BlueprintPure, Category = "{instant3DhubDrawings}")
    bool WasSplineFinalized(int32 SplineIndex) const
    {
        if (GetDrawingEditorMode() != EI3DHDrawingEditorMode::Finalize) { return false; }
        if (!FinalizedSplineMask.IsValidIndex(SplineIndex)) { return false; }
        return FinalizedSplineMask[SplineIndex];
    }
    const TBitArray<>& GetFinalizedSplineMask() const
    {
        return FinalizedSplineMask;
    }
 
protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;
 
    virtual bool IsReadyForFinishDestroy() override { return Super::IsReadyForFinishDestroy() && (!AsyncTaskFence.IsValid() || AsyncTaskFence.GetRefCount() <= 1); }
 
private:
    bool ShouldShowCursor() const { return GetDrawingEditorMode() == EI3DHDrawingEditorMode::Draw; }
 
    void InsertPointInternal(const FVector& RelativeLocation, const int32 SplineIndex, const int32 PointIndex);
    void RemovePointsInternal(const int32 SplineIndex, const int32 StartPointIndex, const int32 NumRemovals);
 
    void CheckIsSplineDataAndStateValid() const;
 
    void UpdateRenderState();
    void UpdateHoveredState();
 
    bool ShouldCreateLineStripDrawings() const { return bCreateLineStripDrawings; }
    bool ShouldCreateCollidersForTriangleMeshDrawings() const { return bCreateCollidersForTriangleMeshDrawings; }
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}", AdvancedDisplay)
    bool bCreateLineStripDrawings{true};
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}", AdvancedDisplay, meta = (EditCondition = "!bCreateLineStripDrawings"))
    bool bCreateCollidersForTriangleMeshDrawings{false};
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}")
    double MinimumPointDistance = 3.0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}")
    double HoverPointDistance = 1.0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}")
    FString ThumbnailBase64DataURI;
 
private:
    UPROPERTY(Transient)
    TObjectPtr<AI3DHConnector> HubConnector{nullptr};
 
    UPROPERTY()
    TObjectPtr<class UStaticMeshComponent> Cursor{nullptr};
 
    UPROPERTY()
    TObjectPtr<class UStaticMeshComponent> ActiveSegment{nullptr};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    FLinearColor DefaultColor{FLinearColor::Yellow};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    double DefaultScale{1};
    
    UPROPERTY(Transient)
    TObjectPtr<class UStaticMesh> SegmentMesh{nullptr};
    
    UPROPERTY(Transient)
    TObjectPtr<class UStaticMesh> JointMesh{nullptr};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    TObjectPtr<class UStaticMesh> ControlPointMesh{nullptr};
 
    bool bOmitStrokeStartAndEndJoints{false};
 
    bool bShowActiveSliceControlPoints{false};
 
    EI3DHDrawingEditorMode DrawingMode{EI3DHDrawingEditorMode::Draw};
 
    bool bIsCursorLocationDirty{true};
 
    bool bCanCreateLineStripDrawings{false};
 
    FString EditedDrawingName;
 
    PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Transient)
    TArray<FI3DHSplineData> Splines;
 
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Transient)
    TArray<FI3DHSplineData> InitialSplines;
    PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS
 
    TOptional<FTransform> InitialTransform;
 
    TBitArray<> FinalizedSplineMask;
 
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Instanced, Transient)
    TObjectPtr<class UI3DHSplineStateObject> StateObject;
 
    TRefCountPtr<FThreadSafeRefCountedObject> AsyncTaskFence{nullptr};
};
 
UCLASS(Transient)
class UI3DHDrawingEditorTransientSplineData : public UAssetUserData
{
    GENERATED_BODY()
public:
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Transient)
    TArray<FI3DHSplineData> Splines;
};
 
UCLASS(Experimental, MinimalAPI, meta = (DisplayName = "I3DH Transient EditableDrawing (Experimental)"))
class AI3DHTransientEditableDrawing : public AI3DHDrawing
{
    GENERATED_BODY()
 
public:
    AI3DHTransientEditableDrawing();
};