I3DHDrawingEditor.h Source File

instant3Dhub: I3DHDrawingEditor.h Source File
instant3Dhub
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "I3DHDataTypes.h"
#include "I3DHError.h"
#include "I3DHSplineData.h"
#include "I3DHVersion.h"
 
#include "GameFramework/Actor.h"
#include "Templates/RefCounting.h"
 
#include "I3DHDrawingEditor.generated.h"
 
class AI3DHConnector;
 
UENUM(BlueprintType)
enum class EI3DHDrawingEditorMode : uint8
{
    None,
    Draw,
    EditDrawing,
    Finalize
};
 
DECLARE_DYNAMIC_DELEGATE_ThreeParams(FI3DHDrawingFinalizedDelegate, const FI3DHDrawingResult&, DrawingResult, const FI3DHDrawingProperties&, DrawingProperties, const TArray<FI3DHSplineData>&, Splines);
 
class INSTANT3DHUB_EXPERIMENTAL(0.0.27, "The instant3Dhub Drawings feature is available as a preview and is actively under development.") AI3DHDrawingEditor;
 
UCLASS(Experimental, Abstract, NotPlaceable, meta = (DisplayName = "I3DH DrawingEditor (Experimental)"))
class INSTANT3DHUBDRAWINGS_API AI3DHDrawingEditor : public AActor
{
    GENERATED_BODY()
 
    friend class UI3DHDrawingSplineRendererBase;
    friend class UI3DHDrawingInstancedStaticMeshRenderer;
    friend class UI3DHDrawingJointMeshRenderer;
    friend class UI3DHDrawingSegmentMeshRenderer;
    friend class UI3DHDrawingControlPointRenderer;
 
public:
    // Sets default values for this actor's properties
    AI3DHDrawingEditor();
 
    // Call before (deferred) spawning.
    void InitializePreSpawn(AI3DHConnector* ParentHubConnector);
 
    virtual void Tick(float DeltaSeconds) override;
 
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, meta = (AutoCreateRefTerm = "Color"), Category = "{instant3DhubDrawings}")
    void SetDrawingScale(const double& Scale);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    double GetDrawingScale() const;
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    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, 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();
 
    INSTANT3DHUB_EXPERIMENTAL(0.0.25, "The handling of SplineData is not yet finalized, the callback signature might change.")
    void FinalizeDrawing(TUniqueFunction<void(FI3DHDrawingResult, TArray<FI3DHSplineData> OutSplines)> OnComplete);
 
    void CreateHubDrawingAndDestroy(const FString& Name, TUniqueFunction<void(int 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);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void InitFromSplines(const TArray<FI3DHSplineData>& InSplines);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    const TArray<FI3DHSplineData>& GetSplines() const { return Splines; }
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    bool SelectNearestPointAtCursor();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    bool SelectNearestPoint(const FVector& Location, bool bIsWorldSpace = false);
 
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 DrawingMode == 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();
 
public:
    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(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    TObjectPtr<class UStaticMeshComponent> Cursor{nullptr};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    TObjectPtr<class UStaticMeshComponent> ActiveSegment{nullptr};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    FLinearColor DefaultColor{FLinearColor::Yellow};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    double DefaultScale{1};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    TObjectPtr<class UStaticMesh> SegmentMesh{nullptr};
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    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};
 
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Transient)
    TArray<FI3DHSplineData> Splines;
 
    UPROPERTY(Category = "{instant3DhubDrawings}", VisibleAnywhere, Instanced, Transient)
    TObjectPtr<class UI3DHSplineStateObject> StateObject;
 
    TRefCountPtr<FThreadSafeRefCountedObject> AsyncTaskFence{nullptr};
};