I3DHInteractiveSplineDrawing.h Source File

instant3Dhub: I3DHInteractiveSplineDrawing.h Source File
instant3Dhub
 
#pragma once
 
#include "CoreMinimal.h"
 
#include "I3DHError.h"
#include "I3DHVersion.h"
 
#include "Components/SplineComponent.h"
#include "Components/SplineMeshComponent.h"
#include "GameFramework/Actor.h"
#include "Templates/RefCounting.h"
#include "UObject/StrongObjectPtr.h"
 
#include "I3DHInteractiveSplineDrawing.generated.h"
 
class AI3DHConnector;
 
DECLARE_DYNAMIC_DELEGATE_TwoParams(FSplineDrawingCreatedDelegate, const FI3DHDrawingResult&, DrawingResult, const FI3DHDrawingProperties&, DrawingProperties);
 
class INSTANT3DHUB_EXPERIMENTAL(0.0.27, "The instant3Dhub Drawings feature is available as a preview and is actively under development.") AI3DHInteractiveSplineDrawing;
 
UCLASS(Experimental, Abstract, NotPlaceable, meta = (DisplayName = "I3DH Interactive SplineDrawing (Experimental)"))
class INSTANT3DHUBDRAWINGS_API AI3DHInteractiveSplineDrawing : public AActor
{
    GENERATED_BODY()
 
public:
    // Sets default values for this actor's properties
    AI3DHInteractiveSplineDrawing();
 
    UFUNCTION(BlueprintCallable, meta = (DefaultToSelf = "HubConnector", DeterminesOutputType = "DrawingClass"), Category = "{instant3DhubDrawings}")
    static AI3DHInteractiveSplineDrawing* CreateInteractiveSplineDrawing(AI3DHConnector* HubConnector, TSubclassOf<AI3DHInteractiveSplineDrawing> DrawingClass);
 
    void InitializePreSpawn(AI3DHConnector* ParentHubConnector);
 
    UFUNCTION(BlueprintPure, Category = "{instant3DhubDrawings}")
    AI3DHConnector* GetHubConnector() const { return HubConnector; }
 
    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 FVector2D& Scale);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    FVector2D GetDrawingScale() const;
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void SetCursorHiddenInGame(bool bIsHiddenInGame);
 
    UFUNCTION(BlueprintCallable, BlueprintPure, Category = "{instant3DhubDrawings}")
    bool IsEmpty() const;
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void Clear();
 
    UFUNCTION(BlueprintCallable, BlueprintPure = false, Category = "{instant3DhubDrawings}")
    void MoveCursorTo(const FVector& Location, const FVector& Normal);
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void AddSplinePointAtCursor();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void RemoveLastSegmentFromActiveSpline();
 
    UFUNCTION(BlueprintCallable, Category = "{instant3DhubDrawings}")
    void FinishActiveSpline();
 
    void FinalizeDrawing(TUniqueFunction<void(FI3DHDrawingResult)> OnComplete);
 
    void CreateHubDrawingAndDestroy(const FString& Name, TUniqueFunction<void(int DrawingHandle, EI3DHErrorCode ErrorCode)> OnComplete);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}")
    double CursorNormalOffset = 0.01;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "{instant3DhubDrawings}")
    FString ThumbnailBase64DataURI;
 
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:
    // Updates the active spline to end at the new location. Its last segment is updated to spawn from the second-last
    // point in the spline to the last.
    bool UpdateActiveSplineEndSegment(const FVector& NewEndLocation, const FVector& NewEndUpVector);
 
    void RemoveLastSegmentFromActiveSpline_Internal(bool bAttachNewEndToCursor);
 
    UPROPERTY()
    AI3DHConnector* HubConnector;
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    UStaticMeshComponent* Cursor;
 
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    FLinearColor DefaultColor = FLinearColor::Yellow;
 
    // Mesh used to render a single segment of the splines.
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    UStaticMesh* SegmentMesh;
 
    // Length of the tangents of segments. Length == 0 scales with the length of the segment.
    UPROPERTY(EditDefaultsOnly, Category = "{instant3DhubDrawings}")
    double WorldSpaceTangentLength = 5;
 
    // We don't use a USTRUCT here so we can keep the struct private.
    // This means we have to use ObjectPtr for memory management.
    struct InteractiveSplineData
    {
        // Immediately destroy all components. Call this before the struct is destroyed!
        void DestroyAllComponents()
        {
            if (Spline.IsValid() && !Spline->IsBeingDestroyed())
            {
                Spline->DestroyComponent();
            }
 
            for (const TStrongObjectPtr<USplineMeshComponent>& SplineSegment : Segments)
            {
                if (SplineSegment.IsValid() && !SplineSegment->IsBeingDestroyed())
                {
                    SplineSegment->DestroyComponent();
                }
            }
        }
 
        TStrongObjectPtr<USplineComponent> Spline;
 
        TArray<TStrongObjectPtr<USplineMeshComponent>> Segments;
    };
 
    // Store pointer instead of value so we can hold a pointer to the active spline without having to worry about it
    // being invalidated by operations to the array.
    TArray<TSharedPtr<InteractiveSplineData>> SplineDataStore;
 
    // Points to the active spline's data. The active spline is the one whose end follows the cursor.
    TSharedPtr<InteractiveSplineData> ActiveSplineData = nullptr;
 
    FVector2D ActiveScale{ 1, 1 };
 
    bool bIsFinalized{ false };
 
    TRefCountPtr<FThreadSafeRefCountedObject> AsyncTaskFence{nullptr};
};