Large update

Optimized and made several changes.

Author: Cutter-H

Content/CanvasManagerSettings.uasset

@@ -1,18 +1,23 @@
 Widget supports being on multiple screens as well across multiple players. Usage is simple Drag and Drop into the widget blueprint.
 
-DOES NOT CURRENTLY SUPPORT BRUSHES. The Brush in the pen settings is for future use. At the moment it is only lines of different colors.
+For documentation please see the [Wiki](https://github.com/Cutter-H/ReplicatedDrawingWidgetPlugin/wiki)
 
+If you wish for further information on the plugin's C++ related content, please see the header files, as they are thoroughly commented.
 
-### How does it replicate?
+You can find a settings data asset in the plugin's content folder. This has 2 separate variables you can use for optimization purposes. Moving or renaming the DataAsset will cause issues and it will no longer work.
 
-The plugin comes with a subsystem that spawns a replicated manager actor. It also listense for actor spawns and adds a lightweight component to player states when they are spawned. The player state component allows the widget to send information to the server. The manager actor holds all data and only 1 is created. Widgets are bound to a delegate on the replicated manager that sends out broadcasts on lines added. The widgets can also erase the data as well as refresh to match the manager to ensure no errors are present. The widgets are identified by the BoardName in the widget as well as the player drawing. 
+DOES NOT CURRENTLY SUPPORT BRUSHES. At the moment it is only lines of different colors. 
 
-There are overridable functions in the widget that allow for conditional line draws (such as if you wish to disable a player or players) and an override to get the drawer/player's name (the default is a GetPlayerName on the player state). 
+Any changes to pen data will immediately affect new lines. There are overridable functions in the widget that allow for conditional line draws (such as if you wish to disable a player or players) and an override to get the drawer/player's name (the default is a GetPlayerName on the player state). 
+
+
+## How does it replicate?
+
+Since widgets do not replicate, the plugin comes with a subsystem that spawns a replicated manager actor. It also listense for actor spawns and adds a lightweight component to player states when they are spawned. The player state component allows the widget to send information to the server. The manager actor holds all data and only 1 is created. Widgets are bound to a delegate on the replicated manager that sends out broadcasts on lines added. The widgets can also erase the data as well as refresh to match the manager to ensure no errors are present. The widgets are identified by the BoardName in the widget as well as the player drawing. 
 
 Please see the video below for an example of the usage. 
 
-This is a plugin that was done in an afternoon and is not finished, but it is in a usable state.
-Documentation and fixes/polish is planned for tomorrow.
+
 
 
 

README.md

@@ -2,31 +2,59 @@
 
 
 #include "ReplicatedCanvasWidgetBase.h"
-
-#include "EngineUtils.h"
-#include "Blueprint/WidgetBlueprintLibrary.h"
-#include "Blueprint/WidgetTree.h"
 #include "CanvasHelpers/CanvasPlayerStateHelper.h"
 #include "CanvasHelpers/ReplicatedCanvasManager.h"
 #include "CanvasHelpers/WorldCanvasSubsystem.h"
+
+#include "Blueprint/WidgetBlueprintLibrary.h"
+#include "Blueprint/WidgetTree.h"
+
 #include "Components/Border.h"
 #include "Components/Overlay.h"
 #include "Components/OverlaySlot.h"
+#include "Debug/ReporterGraph.h"
+
 #include "GameFramework/PlayerState.h"
 #include "Kismet/GameplayStatics.h"
 
 
 void UReplicatedCanvasWidgetBase::DrawLines(FPaintContext& context) const{
-	 for (const FCanvasLineData& line : LineData) {
+	for (const FCanvasLineData& line : LineData) {
 		 if(ShouldDrawLine(line)) {
-		 	FLinearColor color(line.Tint);
-		 	color *= Tint;
-		 	const float lineLife = line.GetLineLife(GetWorld());
+		 	FLinearColor color(line.PenData.Tint);
+		 	const float lineLife = line.GetLineLifetime(GetWorld());
+		 	float size = line.PenData.Size;
 		 	if (FadeDuration > 0 && EraseTime > 0 && lineLife > (EraseTime - FadeDuration)) {
-		 		const float fadeOpacity =  (EraseTime - lineLife) / FadeDuration;
-		 		color.A *= FMath::Clamp(fadeOpacity, 0.f, 1.f);
+		 		const float fadeAmount =  ( (EraseTime - lineLife) / FadeDuration);
+		 		
+		 		/* Opacity fade */ {
+		 			const auto opacityFadeType = line.PenData.OpacityFadeType;
+		 			if (opacityFadeType == EPenDataFadeType::PENFADETYPE_Linear) {
+		 				color.A *= fadeAmount;
+		 			}
+		 			if (opacityFadeType == EPenDataFadeType::PENFADETYPE_Curve) {
+		 				if (line.PenData.OpacityFadeCurve) {
+		 					color.A *= FMath::Abs(line.PenData.OpacityFadeCurve->GetFloatValue(1-fadeAmount));
+		 				}
+		 			}
+		 		
+		 		}
+		 		
+		 		/* Size Fade */ {
+		 			const auto sizeFadeType = line.PenData.SizeFadeType;
+		 			if (sizeFadeType == EPenDataFadeType::PENFADETYPE_Linear) {
+		 				size *= fadeAmount;
+		 			}
+		 			if (sizeFadeType == EPenDataFadeType::PENFADETYPE_Curve) {
+		 				if (line.PenData.SizeFadeCurve) {
+		 					size *= FMath::Abs(line.PenData.SizeFadeCurve->GetFloatValue(1-fadeAmount));
+		 				}
+		 			}
+		 		
+		 		}
 		 	}
-		 	UWidgetBlueprintLibrary::DrawSpline(context, line.StartingPoint, line.StartingDirection, line.StoppingPoint, line.StoppingDirection, color, line.Size);
+		 	UWidgetBlueprintLibrary::DrawSpline(context, line.StartingPoint, line.StartingDirection, line.StoppingPoint, line.StoppingDirection, color, size);
+		
 		 }
 	 }
  }
@@ -35,23 +63,20 @@ void UReplicatedCanvasWidgetBase::CleanupLines(){
 	if (EraseTime <= 0) {
 		return;
 	}
-	 while (LineData.Num() > 0 && LineData[0].GetLineLife(GetWorld()) > EraseTime) {
+	 while (LineData.Num() > 0 && LineData[0].GetLineLifetime(GetWorld()) > EraseTime) {
 		 LineData.RemoveAt(0);
 	 }
  }
 
-// UReplicatedCanvasWidgetBase::UReplicatedCanvasWidgetBase(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {
-// 	
-// }
-
-void UReplicatedCanvasWidgetBase::TrySetupReplicator() {
-	if (Replicator) { return; }
+void UReplicatedCanvasWidgetBase::TrySetupCanvasManager() {
+	if (CanvasManager) { return; }
 
 	if (const auto subsys = GetWorld()->GetSubsystem<UWorldCanvasSubsystem>()) {
 
-		Replicator = subsys->Replicator;
-		if (Replicator) {
-			Replicator->OnLineAdded.AddDynamic(this, &UReplicatedCanvasWidgetBase::OnLineAddedToBoard);
+		CanvasManager = subsys->CanvasManager;
+		if (CanvasManager) {
+			CanvasManager->OnLineAdded.AddDynamic(this, &UReplicatedCanvasWidgetBase::OnLineAddedToBoard);
+			RefreshFromManager();
 		}
 	}
 }
@@ -64,7 +89,7 @@ void UReplicatedCanvasWidgetBase::NativeConstruct() {
 	UOverlay* root = WidgetTree->ConstructWidget<UOverlay>(UOverlay::StaticClass(), TEXT("OverlayRoot"));
 	WidgetTree->RootWidget = root;
 
-	DrawingPad = WidgetTree->ConstructWidget<UBorder>(UBorder::StaticClass(), TEXT("DrawingPad"));
+	UBorder* DrawingPad = WidgetTree->ConstructWidget<UBorder>(UBorder::StaticClass(), TEXT("DrawingPad"));
 	DrawingPad->SetVisibility(ESlateVisibility::Visible);
 	DrawingPad->SetBrushColor(FLinearColor(0, 0, 0, 0));
 
@@ -76,12 +101,15 @@ void UReplicatedCanvasWidgetBase::NativeConstruct() {
 	SetVisibility(ESlateVisibility::Visible);
 	SetIsEnabled(true);
 	SetIsFocusable(true);
-	
+
+	if (!IsDesignTime() && BoardID == 0) {
+		BoardID = GetUniqueID();
+	}
 }
 
 void UReplicatedCanvasWidgetBase::NativeTick(const FGeometry& MyGeometry, float InDeltaTime) {
 	Super::NativeTick(MyGeometry, InDeltaTime);
-	TrySetupReplicator();
+	TrySetupCanvasManager();
 	CleanupLines();
 }
 
@@ -90,9 +118,6 @@ int32 UReplicatedCanvasWidgetBase::NativePaint(const FPaintArgs& Args, const FGe
 
 	FPaintContext context(AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
 	DrawLines(context);
-	if (ShouldDraw()) {
-		
-	}
 	return Super::NativePaint(Args, AllottedGeometry, MyCullingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
 }
 
@@ -118,7 +143,7 @@ FReply UReplicatedCanvasWidgetBase::NativeOnMouseMove(const FGeometry& InGeometr
 			currentDirection = InMouseEvent.GetGestureDelta();
 		}
 		if (bStartedDrawing) {
-			const FCanvasLineData line(GetDrawerName(), UGameplayStatics::GetTimeSeconds(GetWorld()), LastPosition, LastDirection, currentPosition, currentDirection, PenData.Size, PenData.Tint);
+			const FCanvasLineData line(GetDrawerName(), BoardID, UGameplayStatics::GetTimeSeconds(GetWorld()), LastPosition, LastDirection, currentPosition, currentDirection, PenData);
 			LineData.Add(line);
 			AddLineToState(line);
 		}
@@ -145,28 +170,25 @@ void UReplicatedCanvasWidgetBase::NativeOnMouseLeave(const FPointerEvent& InMous
 #pragma endregion Mouse Overrides
 
 void UReplicatedCanvasWidgetBase::OnLineAddedToBoard(FName board, const FCanvasLineData& line) {
-	UKismetSystemLibrary::PrintString(this, "Func Hit");
-
 	if (board != BoardName) {
 		return;
 	}
-	 if (true){//line.DrawingPlayer != GetDrawerName()) {
+	 if (line.DrawingPlayer != GetDrawerName() && BoardID != line.BoardID) {
 	 	LineData.Add(line);
-	 	UKismetSystemLibrary::PrintString(this, "Line Added");
 	 }
  }
 
-void UReplicatedCanvasWidgetBase::RefreshFromReplicator() {
+void UReplicatedCanvasWidgetBase::RefreshFromManager() {
 	LineData.Empty();
-	if (Replicator) {
-		LineData = Replicator->GetCanvasLines(BoardName);
+	if (CanvasManager) {
+		LineData = CanvasManager->GetCanvasLines(BoardName);
 	}
 }
 
 void UReplicatedCanvasWidgetBase::CleanBoard() {
 	LineData.Empty();
-	if (Replicator) {
-		Replicator->CleanBoard(BoardName);
+	if (GetPlayerStateHelper()) {
+		GetPlayerStateHelper()->CleanBoard(BoardName);
 	}
 }
 
@@ -185,7 +207,9 @@ void UReplicatedCanvasWidgetBase::AddLineToState(const FCanvasLineData& line) {
 
 FName UReplicatedCanvasWidgetBase::GetDrawerName_Implementation() {
 	if (DrawerName == FName()) {
-		DrawerName = FName(GetOwningPlayerState(true)->GetPlayerName());
+		if (GetOwningPlayerState()) {
+			DrawerName = FName(GetOwningPlayerState()->GetPlayerName());
+		}
 	}
 	return DrawerName;
 }

Source/ReplicatedDrawingWidgetPlugin/Private/Canvas/ReplicatedCanvasWidgetBase.cpp

@@ -18,77 +18,112 @@ UCLASS()
 class REPLICATEDDRAWINGWIDGETPLUGIN_API UReplicatedCanvasWidgetBase : public UUserWidget {
 	GENERATED_BODY()
 
+	// Basically a tick function that draws lines.
 	void DrawLines(FPaintContext& context) const;
+	// Tick function that deletes unused lines outside the EraseTime. 
 	void CleanupLines();
-
+	/* Tick function that attempts to set up maanger. If it's already set this does nothing. ONLY ONE CANVAS MANAGER SHOULD BE USED PER MAP. */
+	void TrySetupCanvasManager();
+	
 	bool bWantsToDraw = false;
 	bool bStartedDrawing = false;
 	TArray<FCanvasLineData> LineData;
 	FName DrawerName = FName();
 	FVector2D LastPosition = FVector2D::ZeroVector;
 	FVector2D LastDirection = FVector2D::ZeroVector;
 
-	bool LastPointValid() const { return (LastPosition + LastDirection).Length() > 0; }
-
-	void TrySetupReplicator();
 
-	AReplicatedCanvasManager* Replicator;
-	UCanvasPlayerStateHelper* StateHelper;
-protected:
+
 	UPROPERTY()
-	USizeBox* RootBox;
+	AReplicatedCanvasManager* CanvasManager;
 	UPROPERTY()
-	UBorder* DrawingPad;
-	//UReplicatedCanvasWidgetBase(const FObjectInitializer& ObjectInitializer);
-
+	UCanvasPlayerStateHelper* StateHelper;
+protected:
+	/* Buncha overrides to the parent class for alotta thangs. */
 	virtual void NativeConstruct() override;
 	virtual void NativeTick(const FGeometry& MyGeometry, float InDeltaTime) override;
 	virtual int32 NativePaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override;
-	
 	virtual FReply NativeOnMouseButtonDown( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent ) override;
 	virtual FReply NativeOnMouseMove(const FGeometry& InGeometry, const FPointerEvent& InMouseEvent) override;
 	virtual FReply NativeOnMouseButtonUp(const FGeometry& InGeometry, const FPointerEvent& InMouseEvent) override;
 	virtual void NativeOnMouseLeave(const FPointerEvent& InMouseEvent) override;
 
+	/* Sends a line to the player state helper. */
 	UFUNCTION()
 	void AddLineToState(const FCanvasLineData& line);
-	
+
+	/* Override to change how the drawer is identified. By default, GetPlayerName from the player state is used, but this is included if other means should be used. */
 	UFUNCTION(BlueprintNativeEvent)
 	FName GetDrawerName();
+	virtual FName GetDrawerName_Implementation();
+	
+	/* Override for custom logic to let the user draw. If this is false then no drawing occurs. */
 	UFUNCTION(BlueprintNativeEvent)
 	bool ShouldDraw() const;
-
+	virtual bool ShouldDraw_Implementation() const;
+	
+	/* Override for custom logic to check if a line should be drawn. */
 	UFUNCTION(BlueprintNativeEvent)
 	bool ShouldDrawLine(const FCanvasLineData& line) const;
-	bool ShouldDrawLine_Implementation(const FCanvasLineData& line) const {return true;}
+	virtual bool ShouldDrawLine_Implementation(const FCanvasLineData& line) const {return true;}
 
+	/* Used to bind to the Canvas Manager to receive newly drawn lines from other players. */
 	UFUNCTION()
 	void OnLineAddedToBoard(FName board, const FCanvasLineData& line);
 
+	/* This is the data the widget currently has of all the lines. These are ordered by time drawn. */
 	UFUNCTION(BlueprintCallable)
 	TArray<FCanvasLineData> GetLineData() const { return LineData; }
 
+
+	/* Blueprint Getter for the Canvas Manager. This is used to receive replicated data.
+	 * 	
+	 * How the Replication works.
+	 *
+	 *  CanvasManager   <------PlayerStateHelper  <--        Server Level
+	 *    |                                          \
+	 *    |                                          |
+	 *    \------->  Widget-->  PlayerStateHelper---/        Client Level
+	 */
+	UFUNCTION(BlueprintCallable)
+	AReplicatedCanvasManager* GetManagerActor() const {return CanvasManager;}
+
+	/* Blueprint Getter for the Player State component. This is used to send requests to the server.
+	 *
+	 * How the Replication works.
+	 *
+	 *  CanvasManager   <------PlayerStateHelper  <--        Server Level
+	 *    |                                          \
+	 *    |                                          |
+	 *    \------->  Widget-->  PlayerStateHelper---/        Client Level
+	 */
 	UFUNCTION(BlueprintCallable)
-	AReplicatedCanvasManager* GetReplicatorActor() const {return Replicator;}
+	UCanvasPlayerStateHelper* GetPlayerStateHelper() const {return StateHelper;}
 
+	/* Rebuilds the board to match the lines found in the Canvas Manager. */
 	UFUNCTION(BlueprintCallable)
-	void RefreshFromReplicator();
+	void RefreshFromManager();
 
+	/* Erases all lines on the board. */
 	UFUNCTION(BlueprintCallable)
 	void CleanBoard();
 
 
 public:
+	/* Used to identify this board between players. */
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing", meta=(ExposeOnSpawn = true))
 	FName BoardName;
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing", meta=(ExposeOnSpawn = true))
-	FLinearColor Tint = FLinearColor::White;
+	/* Used to identify this board between instances on the same player. If left as 0 it will be given a unique id. */
+	UPROPERTY(BlueprintReadOnly, Category="Drawing", meta=(ExposeOnSpawn = true))
+	int BoardID = 0;
+	/* This is used as parameters to draw lines. */
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing")
 	FCanvasPenData PenData;
-
+	/* Amount of time in seconds before lines disappear. */
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing")
 	float EraseTime = 0.f;
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing")
+	/* Amount of time prior to being erased where the lines will fade. */
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Drawing", meta=(EditCondition))
 	float FadeDuration = 0.f;
 };
 

Source/ReplicatedDrawingWidgetPlugin/Private/Canvas/ReplicatedCanvasWidgetBase.h

@@ -0,0 +1,23 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Engine/DataAsset.h"
+#include "CanvasManagerSettings.generated.h"
+
+/**
+ * 
+ */
+UCLASS(NotBlueprintType, NotBlueprintable)
+class REPLICATEDDRAWINGWIDGETPLUGIN_API UCanvasManagerSettings : public UDataAsset {
+	GENERATED_BODY()
+
+public:
+	/* If a board exceeds this number of lines, the oldest will be removed from the manager. Boards will still keep this line. */
+	UPROPERTY(EditAnywhere, Category = "Canvas Settings")
+	int MaxNumberOfLines = 0;
+	/* If a line's duration (in seconds) on a board exceeds this, it will be removed from the manager. Boards will still keep this line. */
+	UPROPERTY(EditAnywhere, Category = "Canvas Settings")
+	float MaxLineDuration = 0.f;
+};