CogDebug: Refactor debug settings for easier serialization

CogDebug: Move DebugGizmo to CogDebug

Plugins/Cog/Source/CogDebug/Private/CogDebugDraw.cpp

@@ -33,7 +33,7 @@ void FCogDebugDraw::String2D(const FLogCategoryBase& LogCategory, const UObject*
         FCogImguiHelper::ToImU32(Color),
         true,
         FCogDebugSettings::GetDebugDuration(Persistent),
-        FCogDebugSettings::Fade2D);
+        FCogDebugSettings::Data.Fade2D);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -50,7 +50,7 @@ void FCogDebugDraw::Segment2D(const FLogCategoryBase& LogCategory, const UObject
         FCogImguiHelper::ToImU32(Color),
         FCogDebugSettings::GetDebugThickness(0),
         FCogDebugSettings::GetDebugDuration(Persistent),
-        FCogDebugSettings::Fade2D);
+        FCogDebugSettings::Data.Fade2D);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -68,7 +68,7 @@ void FCogDebugDraw::Circle2D(const FLogCategoryBase& LogCategory, const UObject*
         FCogDebugSettings::GetDebugSegments(),
         FCogDebugSettings::GetDebugThickness(0),
         FCogDebugSettings::GetDebugDuration(Persistent),
-        FCogDebugSettings::Fade2D);
+        FCogDebugSettings::Data.Fade2D);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -87,7 +87,7 @@ void FCogDebugDraw::Rect2D(const FLogCategoryBase& LogCategory, const UObject* W
         0.0f,
         FCogDebugSettings::GetDebugThickness(0),
         FCogDebugSettings::GetDebugDuration(Persistent),
-        FCogDebugSettings::Fade2D);
+        FCogDebugSettings::Data.Fade2D);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -114,8 +114,8 @@ void FCogDebugDraw::String(const FLogCategoryBase& LogCategory, const UObject* W
         nullptr,
         NewColor,
         FCogDebugSettings::GetDebugTextDuration(Persistent),
-        FCogDebugSettings::TextShadow,
+        FCogDebugSettings::Data.TextShadow,
-        FCogDebugSettings::TextSize);
+        FCogDebugSettings::Data.TextSize);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -142,7 +142,7 @@ void FCogDebugDraw::Point(const FLogCategoryBase& LogCategory, const UObject* Wo
         FCogDebugSettings::GetDebugDuration(Persistent),
         FCogDebugSettings::GetDebugDepthPriority(DepthPriority));
 
-    ReplicateShape(WorldContextObject, FCogDebugShape::MakePoint(Location, Size, NewColor, Persistent, FCogDebugSettings::DepthPriority));
+    ReplicateShape(WorldContextObject, FCogDebugShape::MakePoint(Location, Size, NewColor, Persistent, FCogDebugSettings::Data.DepthPriority));
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -235,14 +235,14 @@ void FCogDebugDraw::Arrow(const FLogCategoryBase& LogCategory, const UObject* Wo
         World,
         SegmentStart,
         SegmentEnd,
-        FCogDebugSettings::ArrowSize,
+        FCogDebugSettings::Data.ArrowSize,
         NewColor,
         FCogDebugSettings::GetDebugPersistent(Persistent),
         FCogDebugSettings::GetDebugDuration(Persistent),
         FCogDebugSettings::GetDebugDepthPriority(DepthPriority),
         FCogDebugSettings::GetDebugThickness(0));
 
-    ReplicateShape(WorldContextObject, FCogDebugShape::MakeArrow(SegmentStart, SegmentEnd, FCogDebugSettings::ArrowSize, NewColor, 0.0f, Persistent, DepthPriority));
+    ReplicateShape(WorldContextObject, FCogDebugShape::MakeArrow(SegmentStart, SegmentEnd, FCogDebugSettings::Data.ArrowSize, NewColor, 0.0f, Persistent, DepthPriority));
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -268,13 +268,13 @@ void FCogDebugDraw::Axis(const FLogCategoryBase& LogCategory, const UObject* Wor
         World,
         AxisLoc,
         AxisRot,
-        Scale * FCogDebugSettings::AxesScale,
+        Scale * FCogDebugSettings::Data.AxesScale,
         FCogDebugSettings::GetDebugPersistent(Persistent),
         FCogDebugSettings::GetDebugDuration(Persistent),
         FCogDebugSettings::GetDebugDepthPriority(DepthPriority),
         FCogDebugSettings::GetDebugThickness(0));
 
-    ReplicateShape(WorldContextObject, FCogDebugShape::MakeAxes(AxisLoc, AxisRot, FCogDebugSettings::ArrowSize, FColor::Red, 0.0f, Persistent, DepthPriority));
+    ReplicateShape(WorldContextObject, FCogDebugShape::MakeAxes(AxisLoc, AxisRot, FCogDebugSettings::Data.ArrowSize, FColor::Red, 0.0f, Persistent, DepthPriority));
 }
 
 //--------------------------------------------------------------------------------------------------------------------------

Plugins/Cog/Source/CogDebug/Private/CogDebugGizmo.cpp

@@ -0,0 +1,285 @@
+#include "CogDebugGizmo.h"
+
+#include "CogDebugDrawHelper.h"
+#include "CogDebugSettings.h"
+#include "CogImGuiHelper.h"
+#include "Components/PrimitiveComponent.h"
+#include "Components/SceneComponent.h"
+#include "GameFramework/PlayerController.h"
+#include "imgui.h"
+#include "Kismet/GameplayStatics.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+float PointDistanceToQuad(const APlayerController& InPlayerController, const FVector2D& Point, const FVector& QuadPosition, const FQuat& QuadRotation, const FVector2D& QuadExtents)
+{
+    const FVector U = QuadRotation.GetAxisZ() * QuadExtents.X;
+    const FVector V = QuadRotation.GetAxisY() * QuadExtents.Y;
+
+    const FVector V0 = QuadPosition + U + V;
+    const FVector V1 = QuadPosition + U - V;
+    const FVector V2 = QuadPosition - U - V;
+    const FVector V3 = QuadPosition - U + V;
+
+    FVector2D P0, P1, P2, P3;
+    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, V0, P0);
+    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, V1, P1);
+    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, V2, P2);
+    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, V3, P3);
+
+    const FVector B0 = FMath::GetBaryCentric2D(Point, P0, P1, P2);
+    const FVector B1 = FMath::GetBaryCentric2D(Point, P0, P2, P3);
+
+    const bool Inside0 = B0.X > 0.0f && B0.Y > 0.0f && B0.Z > 0.0f;
+    const bool Inside1 = B1.X > 0.0f && B1.Y > 0.0f && B1.Z > 0.0f;
+
+    const float D = (Inside0 || Inside1) ? 0.0f : FLT_MAX;
+    return D;
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+void FCogDebug_Gizmo::Draw(const APlayerController& InPlayerController, FTransform& InOutTransform)
+{
+    UWorld* World = InPlayerController.GetWorld();
+
+    const ImGuiViewport* Viewport = ImGui::GetMainViewport();
+    if (Viewport == nullptr)
+    {
+        return;
+    }
+
+    const FVector GizmoCenter = InOutTransform.GetTranslation();
+
+    FVector2D Center2D;
+    if (UGameplayStatics::ProjectWorldToScreen(&InPlayerController, GizmoCenter, Center2D) == false)
+    {
+        return;
+    }
+
+    const FCogDebugData& Debug = FCogDebugSettings::Data;
+
+    FVector CenterProjection, CenterDirection, AxisProjection, AxisDirection;
+    UGameplayStatics::DeprojectScreenToWorld(&InPlayerController, Center2D, CenterProjection, CenterDirection);
+    UGameplayStatics::DeprojectScreenToWorld(&InPlayerController, Center2D + FVector2d(0, 1.0f), AxisProjection, AxisDirection);
+    const FVector CameraLocation = InPlayerController.PlayerCameraManager->GetCameraLocation();
+    const float Sc = FVector::Dist(AxisProjection, CenterProjection) * FVector::Dist(CameraLocation, GizmoCenter) / FVector::Dist(CameraLocation, CenterProjection);
+    const float Scale = Debug.GizmoScale * Sc;
+
+    const FQuat RotX = InOutTransform.GetRotation();
+    const FQuat RotY = RotX * FQuat(FVector(0.0f, 0.0f, 1.0f), UE_HALF_PI);
+    const FQuat RotZ = RotX * FQuat(FVector(0.0f, 1.0f, 0.0f), UE_HALF_PI);
+
+    const FVector UnitAxisX = RotX.GetAxisX();
+    const FVector UnitAxisY = RotX.GetAxisY();
+    const FVector UnitAxisZ = RotX.GetAxisZ();
+
+    const FVector AxisX = GizmoCenter + UnitAxisX * Debug.GizmoAxisLength * Scale;
+    const FVector AxisY = GizmoCenter + UnitAxisY * Debug.GizmoAxisLength * Scale;
+    const FVector AxisZ = GizmoCenter + UnitAxisZ * Debug.GizmoAxisLength * Scale;
+
+    const FVector PlaneXY = GizmoCenter + ((UnitAxisX + UnitAxisY) * Debug.GizmoPlaneOffset * Scale);
+    const FVector PlaneXZ = GizmoCenter + ((UnitAxisX + UnitAxisZ) * Debug.GizmoPlaneOffset * Scale);
+    const FVector PlaneYZ = GizmoCenter + ((UnitAxisY + UnitAxisZ) * Debug.GizmoPlaneOffset * Scale);
+
+    const float AdjustedScaleBoxExtent = Debug.GizmoScaleBoxExtent * Scale;
+    const float AdjustedPlaneExtent = Debug.GizmoPlaneExtent * Scale;
+    const float AdjustedThicknessZLow = Debug.GizmoThicknessZLow * Scale;
+    const float AdjustedThicknessZHigh = Debug.GizmoThicknessZHigh * Scale;
+
+    const ImVec2 ImMousePos = ImGui::GetMousePos() - Viewport->Pos;
+    const FVector2D MousePos = FCogImguiHelper::ToFVector2D(ImMousePos);
+
+    const FColor GizmoAxisColorsZLow[]      = { Debug.GizmoAxisColorsZLowX,         Debug.GizmoAxisColorsZLowY,         Debug.GizmoAxisColorsZLowZ,         Debug.GizmoAxisColorsZLowW };
+    const FColor GizmoAxisColorsZHigh[]     = { Debug.GizmoAxisColorsZHighX,        Debug.GizmoAxisColorsZHighY,        Debug.GizmoAxisColorsZHighZ,        Debug.GizmoAxisColorsZHighW };
+    const FColor GizmoAxisColorsSelection[] = { Debug.GizmoAxisColorsSelectionX,    Debug.GizmoAxisColorsSelectionY,    Debug.GizmoAxisColorsSelectionZ,    Debug.GizmoAxisColorsSelectionW };
+
+    FCogDebug_GizmoElement GizmoElements[ECogDebug_GizmoElementType::MAX];
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveX]    = { ECogDebug_GizmoType::MoveAxis,       ECogDebug_GizmoAxis::X,    FVector::XAxisVector,     UnitAxisX,            FQuat::Identity,    AxisX };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveY]    = { ECogDebug_GizmoType::MoveAxis,       ECogDebug_GizmoAxis::Y,    FVector::YAxisVector,     UnitAxisY,            FQuat::Identity,    AxisY };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveZ]    = { ECogDebug_GizmoType::MoveAxis,       ECogDebug_GizmoAxis::Z,    FVector::ZAxisVector,     UnitAxisZ,            FQuat::Identity,    AxisZ };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveXY]   = { ECogDebug_GizmoType::MovePlane,      ECogDebug_GizmoAxis::Z,    FVector::ZAxisVector,     UnitAxisZ,            RotZ,               PlaneXY };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveXZ]   = { ECogDebug_GizmoType::MovePlane,      ECogDebug_GizmoAxis::Y,    FVector::YAxisVector,     UnitAxisY,            RotY,               PlaneXZ };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::MoveYZ]   = { ECogDebug_GizmoType::MovePlane,      ECogDebug_GizmoAxis::X,    FVector::XAxisVector,     UnitAxisX,            RotX,               PlaneYZ };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::RotateX]  = { ECogDebug_GizmoType::Rotate,         ECogDebug_GizmoAxis::X,    FVector::XAxisVector,     UnitAxisX,            RotX,               AxisX };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::RotateY]  = { ECogDebug_GizmoType::Rotate,         ECogDebug_GizmoAxis::Y,    FVector::YAxisVector,     UnitAxisY,            RotY,               AxisY };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::RotateZ]  = { ECogDebug_GizmoType::Rotate,         ECogDebug_GizmoAxis::Z,    FVector::ZAxisVector,     UnitAxisZ,            RotZ,               AxisZ };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::ScaleXYZ] = { ECogDebug_GizmoType::ScaleUniform,   ECogDebug_GizmoAxis::MAX,  FVector::OneVector,       FVector::OneVector,   RotX,               GizmoCenter };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::ScaleX]   = { ECogDebug_GizmoType::ScaleAxis,      ECogDebug_GizmoAxis::X,    FVector::XAxisVector,     UnitAxisX,            RotX,               AxisX };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::ScaleY]   = { ECogDebug_GizmoType::ScaleAxis,      ECogDebug_GizmoAxis::Y,    FVector::YAxisVector,     UnitAxisY,            RotY,               AxisY };
+    GizmoElements[(uint8)ECogDebug_GizmoElementType::ScaleZ]   = { ECogDebug_GizmoType::ScaleAxis,      ECogDebug_GizmoAxis::Z,    FVector::ZAxisVector,     UnitAxisZ,            RotZ,               AxisZ };
+
+    ECogDebug_GizmoElementType HoveredElementType = ECogDebug_GizmoElementType::MAX;
+    if (DraggedElementType != ECogDebug_GizmoElementType::MAX)
+    {
+        HoveredElementType = DraggedElementType;
+    }
+    else
+    {
+        float MinDistanceToMouse = FLT_MAX;
+        for (uint8 i = (uint8)ECogDebug_GizmoElementType::MoveX; i < (uint8)ECogDebug_GizmoElementType::MAX; ++i)
+        {
+            FCogDebug_GizmoElement& Elm = GizmoElements[i];
+            float DistanceToMouse = FLT_MAX;
+
+            switch (Elm.Type)
+            {
+                case ECogDebug_GizmoType::MoveAxis:
+                {
+                    FVector2D ElementLocation2D;
+                    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, Elm.Location, ElementLocation2D);
+                    const FVector2D ClosestPoint = FMath::ClosestPointOnSegment2D(MousePos, Center2D, ElementLocation2D);
+                    DistanceToMouse = (ClosestPoint - MousePos).Length();
+                    break;
+                }
+
+                case ECogDebug_GizmoType::MovePlane:
+                {
+                    DistanceToMouse = PointDistanceToQuad(InPlayerController, MousePos, Elm.Location, Elm.Rotation, FVector2D(AdjustedPlaneExtent, AdjustedPlaneExtent));
+                    break;
+                }
+
+                case ECogDebug_GizmoType::ScaleUniform:
+                case ECogDebug_GizmoType::ScaleAxis:
+                {
+                    FVector2D ElementLocation2D;
+                    UGameplayStatics::ProjectWorldToScreen(&InPlayerController, Elm.Location, ElementLocation2D);
+                    DistanceToMouse = FVector2D::Distance(ElementLocation2D, MousePos) - Debug.GizmoScaleBoxExtent;
+                    break;
+                }
+            }
+
+            if (DistanceToMouse < Debug.GizmoMouseMaxDistance && DistanceToMouse < MinDistanceToMouse)
+            {
+                HoveredElementType = (ECogDebug_GizmoElementType)i;
+                MinDistanceToMouse = DistanceToMouse;
+            }
+        }
+    }
+
+    for (uint8 i = (uint8)ECogDebug_GizmoElementType::MoveX; i < (uint8)ECogDebug_GizmoElementType::MAX; ++i)
+    {
+        const FCogDebug_GizmoElement& Elm = GizmoElements[i];
+        const bool IsClosestToMouse = i == (uint8)HoveredElementType;
+        const uint8 AxisIndex = (uint8)Elm.AxisType;
+        const FColor ZLowColor = IsClosestToMouse ? GizmoAxisColorsSelection[AxisIndex] : GizmoAxisColorsZLow[AxisIndex];
+        const FColor ZHighColor = IsClosestToMouse ? GizmoAxisColorsSelection[AxisIndex] : GizmoAxisColorsZHigh[AxisIndex];
+
+        switch (Elm.Type)
+        {
+            case ECogDebug_GizmoType::MoveAxis:
+            {
+                DrawDebugLine(World, GizmoCenter, Elm.Location, ZLowColor, false, 0.0f, Debug.GizmoZLow, AdjustedThicknessZLow);
+                DrawDebugLine(World, GizmoCenter, Elm.Location, ZHighColor, false, 0.0f, Debug.GizmoZHigh, Debug.GizmoThicknessZHigh);
+                break;
+            }
+
+            case ECogDebug_GizmoType::MovePlane:
+            {
+                FCogDebugDrawHelper::DrawQuad(World, Elm.Location, Elm.Rotation, FVector2D(AdjustedPlaneExtent, AdjustedPlaneExtent), ZLowColor, false, 0.0f, Debug.GizmoZLow, AdjustedThicknessZLow);
+                FCogDebugDrawHelper::DrawQuad(World, Elm.Location, Elm.Rotation, FVector2D(AdjustedPlaneExtent, AdjustedPlaneExtent), ZHighColor, false, 0.0f, Debug.GizmoZHigh, AdjustedThicknessZHigh);
+                FCogDebugDrawHelper::DrawSolidQuad(World, Elm.Location, Elm.Rotation, FVector2D(AdjustedPlaneExtent, AdjustedPlaneExtent), ZLowColor, false, 0.0f, Debug.GizmoZLow);
+                break;
+            }
+
+            case ECogDebug_GizmoType::Rotate:
+            {
+                FRotationTranslationMatrix Matrix(FRotator(Elm.Rotation), Elm.Location);
+                DrawDebugCircle(World, Matrix, Debug.GizmoRotationRadius, Debug.GizmoRotationSegments, ZLowColor, false, 0.0f, Debug.GizmoZLow, AdjustedThicknessZLow, false);
+                DrawDebugCircle(World, Matrix, Debug.GizmoRotationRadius, Debug.GizmoRotationSegments, ZHighColor, false, 0.0f, Debug.GizmoZHigh, AdjustedThicknessZHigh, false);
+                break;
+            }
+
+            case ECogDebug_GizmoType::ScaleUniform:
+            case ECogDebug_GizmoType::ScaleAxis:
+            {
+                DrawDebugBox(World, Elm.Location, FVector::OneVector * AdjustedScaleBoxExtent, Elm.Rotation, ZLowColor, false, 0.0f, Debug.GizmoZLow, AdjustedThicknessZLow);
+                DrawDebugBox(World, Elm.Location, FVector::OneVector * AdjustedScaleBoxExtent, Elm.Rotation, ZHighColor, false, 0.0f, Debug.GizmoZHigh, AdjustedThicknessZHigh);
+                DrawDebugSolidBox(World, Elm.Location, FVector::OneVector * AdjustedScaleBoxExtent, Elm.Rotation, ZLowColor, false, 0.0f, Debug.GizmoZLow);
+                break;
+            }
+        }
+    }
+
+    if (ImGui::IsMouseReleased(ImGuiMouseButton_Left))
+    {
+        DraggedElementType = ECogDebug_GizmoElementType::MAX;
+    }
+    else if (DraggedElementType != ECogDebug_GizmoElementType::MAX)
+    {
+        if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, 4.0f))
+        {
+            FVector MouseWorldOrigin, MouseWorldDirection;
+            UGameplayStatics::DeprojectScreenToWorld(&InPlayerController, MousePos - CursorOffset, MouseWorldOrigin, MouseWorldDirection);
+
+            FCogDebug_GizmoElement& DraggedElement = GizmoElements[(uint8)DraggedElementType];
+
+            switch (DraggedElement.Type)
+            {
+                case ECogDebug_GizmoType::MoveAxis: 
+                {
+                    FVector Pa, Pb;
+                    FMath::SegmentDistToSegmentSafe(
+                        GizmoCenter - DraggedElement.Direction * 10000, 
+                        GizmoCenter + DraggedElement.Direction * 10000, 
+                        MouseWorldOrigin - MouseWorldDirection * 10000,
+                        MouseWorldOrigin + MouseWorldDirection * 10000, 
+                        Pa, Pb);
+                    InOutTransform.SetLocation(Pa);
+                    break;
+                }
+
+                case ECogDebug_GizmoType::MovePlane:
+                {
+                    const FPlane Plane(GizmoCenter, DraggedElement.Direction);
+                    const FVector PlaneIntersection = FMath::RayPlaneIntersection(MouseWorldOrigin, MouseWorldDirection, Plane);
+                    InOutTransform.SetLocation(PlaneIntersection);
+                    break;
+                }
+
+                case ECogDebug_GizmoType::ScaleAxis:
+                {
+                    FVector Pa, Pb;
+                    FMath::SegmentDistToSegmentSafe(
+                        GizmoCenter - DraggedElement.Direction * 10000,
+                        GizmoCenter + DraggedElement.Direction * 10000,
+                        MouseWorldOrigin - MouseWorldDirection * 10000,
+                        MouseWorldOrigin + MouseWorldDirection * 10000,
+                        Pa, Pb);
+
+                    const float Sign = FMath::Sign(FVector::DotProduct(DraggedElement.Direction, Pa - GizmoCenter));
+                    const float Delta = (Pa - GizmoCenter).Length() * Sign;
+                    FVector NewScale = InitialScale + (DraggedElement.Axis * Delta * Debug.GizmoScaleSpeed);
+                    NewScale.X = FMath::Max(NewScale.X, Debug.GizmoScaleMin);
+                    NewScale.Y = FMath::Max(NewScale.Y, Debug.GizmoScaleMin);
+                    NewScale.Z = FMath::Max(NewScale.Z, Debug.GizmoScaleMin);
+                    InOutTransform.SetScale3D(NewScale);
+                    break;
+                }
+
+                case ECogDebug_GizmoType::ScaleUniform:
+                {
+                    const FVector2D DragDelta = FCogImguiHelper::ToFVector2D(ImGui::GetMouseDragDelta(ImGuiMouseButton_Left));
+                    FVector NewScale = InitialScale + (DraggedElement.Axis * (DragDelta.X - DragDelta.Y) * Debug.GizmoScaleSpeed);
+                    NewScale.X = FMath::Max(NewScale.X, Debug.GizmoScaleMin);
+                    NewScale.Y = FMath::Max(NewScale.Y, Debug.GizmoScaleMin);
+                    NewScale.Z = FMath::Max(NewScale.Z, Debug.GizmoScaleMin);
+                    InOutTransform.SetScale3D(NewScale);
+                    break;
+                }
+
+                default: 
+                    break;
+            }
+            
+        }
+    }
+    else if (ImGui::IsMouseDown(ImGuiMouseButton_Left))
+    {
+        DraggedElementType = HoveredElementType;
+
+        if (HoveredElementType != ECogDebug_GizmoElementType::MAX)
+        {
+            CursorOffset = MousePos - Center2D;
+            InitialScale = InOutTransform.GetScale3D();
+        }
+    }
+}

Plugins/Cog/Source/CogDebug/Private/CogDebugSettings.cpp

@@ -7,65 +7,12 @@
 
 //--------------------------------------------------------------------------------------------------------------------------
 TWeakObjectPtr<AActor> FCogDebugSettings::Selection;
-bool FCogDebugSettings::bIsFilteringBySelection = true;
+FCogDebugData FCogDebugSettings::Data = FCogDebugData();
-bool FCogDebugSettings::Persistent = false;
-bool FCogDebugSettings::TextShadow = true;
-bool FCogDebugSettings::Fade2D = true;
-float FCogDebugSettings::Duration = 3.0f;
-int FCogDebugSettings::DepthPriority = 0;
-int FCogDebugSettings::Segments = 12;
-float FCogDebugSettings::Thickness = 0.0f;
-float FCogDebugSettings::ServerThickness = 2.0f;
-float FCogDebugSettings::ServerColorMultiplier = 0.8f;
-float FCogDebugSettings::ArrowSize = 10.0f;
-float FCogDebugSettings::AxesScale = 1.0f;
-float FCogDebugSettings::GradientColorIntensity = 0.0f;
-float FCogDebugSettings::GradientColorSpeed = 2.0f;
-float FCogDebugSettings::TextSize = 1.0f;
-TArray<FString> FCogDebugSettings::SecondaryBoneWildcards = 
-{ 
-    "interaction", 
-    "center_of_mass", 
-    "ik_*", 
-    "index_*", 
-    "middle_*",  
-    "pinky_*", 
-    "ring_*", 
-    "thumb_*", 
-    "wrist_*", 
-    "*_bck_*",
-    "*_fwd_*",
-    "*_in_*",
-    "*_out_*",
-    "*_pec_*",
-    "*_scap_*",
-    "*_bicep_*",
-    "*_tricep_*",
-    "*ankle*",
-    "*knee*", 
-    "*corrective*",
-    "*twist*",
-    "*latissimus*",
-};
 
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogDebugSettings::Reset()
 {
-    bIsFilteringBySelection = true;
+    Data = FCogDebugData();
-    Persistent = false;
-    TextShadow = true;
-    Fade2D = true;
-    Duration = 3.0f;
-    DepthPriority = 0;
-    Segments = 12;
-    Thickness = 0.0f;
-    ServerThickness = 2.0f;
-    ServerColorMultiplier = 0.8f;
-    ArrowSize = 10.0f;
-    AxesScale = 1.0f;
-    GradientColorIntensity = 0.0f;
-    GradientColorSpeed = 2.0f;
-    TextSize = 1.0f;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -82,7 +29,7 @@ bool FCogDebugSettings::IsDebugActiveForObject(const UObject* WorldContextObject
         return true;
     }
 
-    bool Result = IsDebugActiveForObject_Internal(WorldContextObject, Selection.Get(), bIsFilteringBySelection);
+    bool Result = IsDebugActiveForObject_Internal(WorldContextObject, Selection.Get(), Data.bIsFilteringBySelection);
 
     return Result;
 }
@@ -160,13 +107,13 @@ void FCogDebugSettings::SetSelection(UWorld* World, AActor* Value)
 //--------------------------------------------------------------------------------------------------------------------------
 bool FCogDebugSettings::GetIsFilteringBySelection()
 {
-    return bIsFilteringBySelection;
+    return Data.bIsFilteringBySelection;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 void FCogDebugSettings::SetIsFilteringBySelection(UWorld* World, bool Value)
 {
-    bIsFilteringBySelection = Value;
+    Data.bIsFilteringBySelection = Value;
 
     if (World != nullptr && World->GetNetMode() == NM_Client)
     {
@@ -180,13 +127,13 @@ void FCogDebugSettings::SetIsFilteringBySelection(UWorld* World, bool Value)
 //--------------------------------------------------------------------------------------------------------------------------
 bool FCogDebugSettings::GetDebugPersistent(bool bPersistent)
 {
-    return Persistent && bPersistent;
+    return Data.Persistent && bPersistent;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 float FCogDebugSettings::GetDebugDuration(bool bPersistent)
 {
-    return bPersistent == false ? 0.0f : Duration;
+    return bPersistent == false ? 0.0f : Data.Duration;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -194,7 +141,7 @@ float FCogDebugSettings::GetDebugTextDuration(bool bPersistent)
 {
     if (bPersistent)
     {
-        return Persistent ? 100 : Duration;
+        return Data.Persistent ? 100 : Data.Duration;
     }
     else
     {
@@ -205,31 +152,31 @@ float FCogDebugSettings::GetDebugTextDuration(bool bPersistent)
 //--------------------------------------------------------------------------------------------------------------------------
 int FCogDebugSettings::GetDebugSegments()
 {
-    return Segments;
+    return Data.Segments;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 int FCogDebugSettings::GetCircleSegments()
 {
-    return (Segments * 2) + 2; // because DrawDebugCircle does Segments = FMath::Max((Segments - 2) / 2, 4) for some reason
+    return (Data.Segments * 2) + 2; // because DrawDebugCircle does Segments = FMath::Max((Segments - 2) / 2, 4) for some reason
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 float FCogDebugSettings::GetDebugThickness(float InThickness)
 {
-    return (Thickness + InThickness);
+    return (Data.Thickness + InThickness);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 float FCogDebugSettings::GetDebugServerThickness(float InThickness)
 {
-    return (ServerThickness + InThickness);
+    return (Data.ServerThickness + InThickness);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 uint8 FCogDebugSettings::GetDebugDepthPriority(float InDepthPriority)
 {
-    return (DepthPriority + InDepthPriority);
+    return (Data.DepthPriority + InDepthPriority);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -252,8 +199,8 @@ FColor FCogDebugSettings::ModulateDebugColor(const UWorld* World, const FColor&
 
     ComplementaryColor = ComplementaryColor.HSVToLinearRGB();
 
-    const FLinearColor GradientColor = FLinearColor::LerpUsingHSV(FLinearColor(Color), ComplementaryColor, FMath::Cos(GradientColorSpeed * Time));
+    const FLinearColor GradientColor = FLinearColor::LerpUsingHSV(FLinearColor(Color), ComplementaryColor, FMath::Cos(Data.GradientColorSpeed * Time));
-    const FLinearColor FBlendColor = BaseColor * (1.0f - FCogDebugSettings::GradientColorIntensity) + GradientColor * GradientColorIntensity;
+    const FLinearColor FBlendColor = BaseColor * (1.0f - Data.GradientColorIntensity) + GradientColor * Data.GradientColorIntensity;
     return FBlendColor.ToFColor(true);
 }
 
@@ -262,9 +209,9 @@ FColor FCogDebugSettings::ModulateDebugColor(const UWorld* World, const FColor&
 FColor FCogDebugSettings::ModulateServerColor(const FColor& Color)
 {
     FColor ServerColor(
-        Color.R * ServerColorMultiplier,
+        Color.R * Data.ServerColorMultiplier,
-        Color.G * ServerColorMultiplier,
+        Color.G * Data.ServerColorMultiplier,
-        Color.B * ServerColorMultiplier,
+        Color.B * Data.ServerColorMultiplier,
         Color.A);
 
     return ServerColor;
@@ -275,7 +222,7 @@ bool FCogDebugSettings::IsSecondarySkeletonBone(FName BoneName)
 {
     FString BoneString = BoneName.ToString().ToLower();
 
-    for (const FString& Wildcard : SecondaryBoneWildcards)
+    for (const FString& Wildcard : Data.SecondaryBoneWildcards)
     {
         if (BoneString.MatchesWildcard(Wildcard))
         {

Plugins/Cog/Source/CogDebug/Public/CogDebugGizmo.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "CogDebugGizmo.generated.h"
+
+//--------------------------------------------------------------------------------------------------------------------------
+UENUM()
+enum class ECogDebug_GizmoType : uint8
+{
+    MoveAxis,
+    MovePlane,
+    Rotate,
+    ScaleAxis,
+    ScaleUniform,
+    MAX,
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UENUM()
+enum class ECogDebug_GizmoAxis : uint8
+{
+    X,
+    Y,
+    Z,
+    MAX,
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+UENUM()
+enum class ECogDebug_GizmoElementType : uint8
+{
+    MoveX,
+    MoveY,
+    MoveZ,
+    MoveXY,
+    MoveXZ,
+    MoveYZ,
+    RotateX,
+    RotateY,
+    RotateZ,
+    ScaleXYZ,
+    ScaleX,
+    ScaleY,
+    ScaleZ,
+    MAX,
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+struct FCogDebug_GizmoElement
+{
+    ECogDebug_GizmoType Type;
+    ECogDebug_GizmoAxis AxisType;
+    FVector Axis;
+    FVector Direction;
+    FQuat Rotation;
+    FVector Location;
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+struct COGDEBUG_API FCogDebug_Gizmo
+{
+    void Draw(const APlayerController& InPlayerController, FTransform& InOutTransform);
+
+    ECogDebug_GizmoElementType DraggedElementType = ECogDebug_GizmoElementType::MAX;
+    FVector2D CursorOffset = FVector2D::ZeroVector;
+    FVector InitialScale = FVector::OneVector;
+};

Plugins/Cog/Source/CogDebug/Public/CogDebugSettings.h

@@ -2,11 +2,167 @@
 
 #include "CoreMinimal.h"
 #include "UObject/WeakObjectPtrTemplates.h"
+#include "CogDebugSettings.generated.h"
 
 class UObject;
 class AActor;
 class UWorld;
 
+USTRUCT()
+struct FCogDebugData
+{
+    GENERATED_BODY()
+
+    UPROPERTY(Config)
+    bool bIsFilteringBySelection = true;
+
+    UPROPERTY(Config)
+    bool Persistent = false;
+
+    UPROPERTY(Config)
+    bool TextShadow = true;
+
+    UPROPERTY(Config)
+    bool Fade2D = true;
+
+    UPROPERTY(Config)
+    float Duration = 3.0f;
+
+    UPROPERTY(Config)
+    int DepthPriority = 0;
+
+    UPROPERTY(Config)
+    int Segments = 12;
+
+    UPROPERTY(Config)
+    float Thickness = 0.0f;
+
+    UPROPERTY(Config)
+    float ServerThickness = 2.0f;
+
+    UPROPERTY(Config)
+    float ServerColorMultiplier = 0.8f;
+
+    UPROPERTY(Config)
+    float ArrowSize = 10.0f;
+
+    UPROPERTY(Config)
+    float AxesScale = 1.0f;
+
+    UPROPERTY(Config)
+    float GradientColorIntensity = 0.0f;
+
+    UPROPERTY(Config)
+    float GradientColorSpeed = 2.0f;
+
+    UPROPERTY(Config)
+    float TextSize = 1.0f;
+
+    UPROPERTY(Config)
+    float GizmoScale = 1.0f;
+
+    UPROPERTY(Config)
+    float GizmoAxisLength = 50.0f;
+
+    UPROPERTY(Config)
+    int GizmoZLow = 0;
+
+    UPROPERTY(Config)
+    int GizmoZHigh = 100;
+
+    UPROPERTY(Config)
+    float GizmoThicknessZLow = 1.0f;
+
+    UPROPERTY(Config)
+    float GizmoThicknessZHigh = 0.0f;
+
+    UPROPERTY(Config)
+    float GizmoMouseMaxDistance = 5.0f;
+
+    UPROPERTY(Config)
+    float GizmoPlaneOffset = 25.0f;
+
+    UPROPERTY(Config)
+    float GizmoPlaneExtent = 5.0f;
+
+    UPROPERTY(Config)
+    float GizmoScaleBoxExtent = 2.0f;
+
+    UPROPERTY(Config)
+    float GizmoScaleSpeed = 0.5f;
+
+    UPROPERTY(Config)
+    float GizmoScaleMin = 0.001f;
+
+    UPROPERTY(Config)
+    float GizmoRotationRadius = 15.0f;
+
+    UPROPERTY(Config)
+    int GizmoRotationSegments = 32;
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZHighX = FColor(255, 50, 50, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZHighY = FColor(50, 255, 50, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZHighZ = FColor(50, 50, 255, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZHighW = FColor(255, 255, 255, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZLowX = FColor(128, 0, 0, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZLowY = FColor(0, 128, 0, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZLowZ = FColor(0, 0, 128, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsZLowW = FColor(128, 128, 128, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsSelectionX = FColor(255, 255, 0, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsSelectionY = FColor(255, 255, 0, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsSelectionZ = FColor(255, 255, 0, 255);
+
+    UPROPERTY(Config)
+    FColor GizmoAxisColorsSelectionW = FColor(255, 255, 0, 255);
+
+    UPROPERTY(Config)
+    TArray<FString> SecondaryBoneWildcards = {
+    "interaction",
+    "center_of_mass",
+    "ik_*",
+    "index_*",
+    "middle_*",
+    "pinky_*",
+    "ring_*",
+    "thumb_*",
+    "wrist_*",
+    "*_bck_*",
+    "*_fwd_*",
+    "*_in_*",
+    "*_out_*",
+    "*_pec_*",
+    "*_scap_*",
+    "*_bicep_*",
+    "*_tricep_*",
+    "*ankle*",
+    "*knee*",
+    "*corrective*",
+    "*twist*",
+    "*latissimus*",
+    };
+};
+
 struct COGDEBUG_API FCogDebugSettings
 {
 public:
@@ -48,41 +204,11 @@ public:
 
     static void Reset();
 
-    static bool Persistent;
+    static FCogDebugData Data;
-
-    static bool TextShadow;
-
-    static bool Fade2D;
-
-    static float Duration;
-
-    static int DepthPriority;
-
-    static int Segments;
-
-    static float Thickness;
-
-    static float ServerThickness;
-
-    static float ServerColorMultiplier;
-
-    static float ArrowSize;
-
-    static float AxesScale;
-
-    static float GradientColorIntensity;
-
-    static float GradientColorSpeed;
-
-    static float TextSize;
-
-    static TArray<FString> SecondaryBoneWildcards;
 
 private:
 
     static bool IsDebugActiveForObject_Internal(const UObject* WorldContextObject, const AActor* InSelection, bool InIsFilteringBySelection);
 
     static TWeakObjectPtr<AActor> Selection;
-
-    static bool bIsFilteringBySelection;
 };

Plugins/Cog/Source/CogEngine/Private/CogEngineWindow_CollisionTester.cpp

@@ -4,13 +4,9 @@
 #include "CogDebugSettings.h"
 #include "CogEngineDataAsset.h"
 #include "CogImGuiHelper.h"
-#include "CogWindowHelper.h"
 #include "CogWindowWidgets.h"
-#include "Components/BoxComponent.h"
-#include "Components/CapsuleComponent.h"
 #include "Components/PrimitiveComponent.h"
 #include "Components/SceneComponent.h"
-#include "Components/SphereComponent.h"
 #include "imgui.h"
 #include "Kismet/GameplayStatics.h"
 
@@ -242,24 +238,24 @@ void FCogEngineWindow_CollisionTester::RenderContent()
             case ECogEngine_CollisionQueryShape::Sphere:
             {
                 FCogWindowWidgets::SetNextItemToShortWidth();
-                ImGui::DragFloat("Sphere Radius", &Config->SphereRadius, 0.1f, 0, 100.0f, "%.1f");
+                ImGui::DragFloat("Sphere Radius", &Config->ShapeExtent.X, 0.1f, 0, 100.0f, "%.1f");
                 break;
             }
 
             case ECogEngine_CollisionQueryShape::Box:
             {
                 FCogWindowWidgets::SetNextItemToShortWidth();
-                ImGui::DragFloat3("Box Extent", &Config->BoxExtent.X, 0.1f, 0, 100.0f, "%.1f");
+                ImGui::DragFloat3("Box Extent", &Config->ShapeExtent.X, 0.1f, 0, 100.0f, "%.1f");
                 break;
             }
 
             case ECogEngine_CollisionQueryShape::Capsule:
             {
                 FCogWindowWidgets::SetNextItemToShortWidth();
-                ImGui::DragFloat("Capsule Radius", &Config->CapsuleRadius, 0.1f, 0, 100.0f, "%.1f");
+                ImGui::DragFloat("Capsule Radius", &Config->ShapeExtent.X, 0.1f, 0, 100.0f, "%.1f");
 
                 FCogWindowWidgets::SetNextItemToShortWidth();
-                ImGui::DragFloat("Capsule Half Height", &Config->CapsuleHalfHeight, 0.1f, 0, 100.0f, "%.1f");
+                ImGui::DragFloat("Capsule Half Height", &Config->ShapeExtent.Z, 0.1f, 0, 100.0f, "%.1f");
                 break;
             }
         }
@@ -343,9 +339,9 @@ void FCogEngineWindow_CollisionTester::Query()
     {
         switch (Config->Shape)
         {
-            case ECogEngine_CollisionQueryShape::Sphere:    QueryShape.SetSphere(Config->SphereRadius); break;
+            case ECogEngine_CollisionQueryShape::Sphere:    QueryShape.SetSphere(Config->ShapeExtent.X); break;
-            case ECogEngine_CollisionQueryShape::Capsule:   QueryShape.SetCapsule(Config->CapsuleRadius, Config->CapsuleHalfHeight); break;
+            case ECogEngine_CollisionQueryShape::Capsule:   QueryShape.SetCapsule(Config->ShapeExtent.X, Config->ShapeExtent.Z); break;
-            case ECogEngine_CollisionQueryShape::Box:       QueryShape.SetBox(Config->BoxExtent); break;
+            case ECogEngine_CollisionQueryShape::Box:       QueryShape.SetBox(Config->ShapeExtent); break;
         }
     }
 
@@ -519,7 +515,7 @@ void FCogEngineWindow_CollisionTester::Query()
             GetWorld(),
             QueryStart,
             QueryEnd,
-            FCogDebugSettings::ArrowSize,
+            FCogDebugSettings::Data.ArrowSize,
             Color,
             false,
             0.0f,
@@ -577,7 +573,7 @@ void FCogEngineWindow_CollisionTester::Query()
                 GetWorld(),
                 Hit.Location,
                 Hit.Location + Hit.Normal * 20.0f,
-                FCogDebugSettings::ArrowSize,
+                FCogDebugSettings::Data.ArrowSize,
                 FLinearColor(Config->NormalColor).ToFColor(true),
                 false,
                 0.0f,
@@ -591,7 +587,7 @@ void FCogEngineWindow_CollisionTester::Query()
                 GetWorld(),
                 Hit.ImpactPoint,
                 Hit.ImpactPoint + Hit.ImpactNormal * 20.0f,
-                FCogDebugSettings::ArrowSize,
+                FCogDebugSettings::Data.ArrowSize,
                 FLinearColor(Config->ImpactNormalColor).ToFColor(true),
                 false,
                 0.0f,
@@ -605,10 +601,20 @@ void FCogEngineWindow_CollisionTester::Query()
         }
     }
 
-    FTransform Transform1(QueryRotation, QueryStart, FVector::OneVector);
+    if (const APlayerController* LocalPlayerController = GetLocalPlayerController())
-    DrawTransformGizmos(GetWorld(), Transform1);
+    {
-    FTransform Transform2(QueryRotation, QueryEnd, FVector::OneVector);
+        FVector ScaleStart(Config->ShapeExtent);
-    DrawTransformGizmos(GetWorld(), Transform2);
+        FTransform TransformStart(QueryRotation, QueryStart, ScaleStart);
+        GizmoStart.Draw(*LocalPlayerController, TransformStart);
+        Config->LocationStart = FVector3f(TransformStart.GetLocation());
+        Config->ShapeExtent = FVector3f(TransformStart.GetScale3D());
+
+        FVector ScaleEnd(Config->ShapeExtent);
+        FTransform TransformEnd(QueryRotation, QueryEnd, ScaleEnd);
+        GizmoEnd.Draw(*LocalPlayerController, TransformEnd);
+        Config->LocationEnd = FVector3f(TransformEnd.GetLocation());
+        Config->ShapeExtent = FVector3f(TransformEnd.GetScale3D());
+    }
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -638,7 +644,7 @@ void FCogEngineWindow_CollisionTester::DrawPrimitive(const UPrimitiveComponent*
             if (AlreadyDrawnActors.Contains(Actor) == false)
             {
                 FColor TextColor = Color.WithAlpha(255);
-                DrawDebugString(GetWorld(), Actor->GetActorLocation(), GetNameSafe(Actor->GetClass()), nullptr, FColor::White, 0.0f, FCogDebugSettings::TextShadow, FCogDebugSettings::TextSize);
+                DrawDebugString(GetWorld(), Actor->GetActorLocation(), GetNameSafe(Actor->GetClass()), nullptr, FColor::White, 0.0f, FCogDebugSettings::Data.TextShadow, FCogDebugSettings::Data.TextSize);
                 AlreadyDrawnActors.Add(Actor);
             }
         }
@@ -693,7 +699,7 @@ void FCogEngineWindow_CollisionTester::DrawShape(const FCollisionShape& Shape, c
     case ECollisionShape::Sphere:
     {
         //--------------------------------------------------
-        // see UCapsuleComponent::GetScaledCapsuleRadius()
+        // see USphereComponent::GetScaledSphereRadius()
         //--------------------------------------------------
         const float RadiusScale = FMath::Min(Scale.X, FMath::Min(Scale.Y, Scale.Z));
         const float Radius = Shape.Sphere.Radius * RadiusScale;
@@ -758,198 +764,3 @@ void FCogEngineWindow_CollisionTester::SetAsset(const UCogEngineDataAsset* Value
         Channel.Color = AssetChannel.Color.ToFColor(true);
     }
 }
-
-//--------------------------------------------------------------------------------------------------------------------------
-static void FindSegmentPointDistance(const FVector2D& Segment1, const FVector2D& Segment2, const FVector2D& Point, FVector2D& Projection, float& Time, float& Distance)
-{
-    const float DistSquared = FVector2D::DistSquared(Segment1, Segment2);
-    if (FMath::IsNearlyZero(DistSquared))
-    {
-        Time = 0.0f;
-        Projection = Segment1;
-        Distance = FVector2D::Distance(Point, Segment1);
-    }
-    else
-    {
-        Time = FMath::Max(0.0f, FMath::Min(1.0f, FVector2D::DotProduct(Point - Segment1, Segment2 - Segment1) / DistSquared));
-        Projection = Segment1 + Time * (Segment2 - Segment1);
-        Distance = FVector2D::Distance(Point, Projection);
-    }
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-static float FindSegmentPointDistance2(const FVector2D& Segment1, const FVector2D& Segment2, const FVector2D& Point)
-{
-    FVector2D Projection;
-    float Time, Distance;
-    FindSegmentPointDistance(Segment1, Segment2, Point, Projection, Time, Distance);
-    return Distance;
-}
-
-//--------------------------------------------------------------------------------------------------------------------------
-void FCogEngineWindow_CollisionTester::DrawTransformGizmos(const UWorld* InWorld, FTransform& InTransform)
-{
-    APlayerController* PlayerController = GetLocalPlayerController();
-    if (PlayerController == nullptr)
-    {
-        return;
-    }
-
-    const ImGuiViewport* Viewport = ImGui::GetMainViewport();
-    if (Viewport == nullptr)
-    {
-        return;
-    }
-
-    const uint8 ZLow = 0;
-    const uint8 ZHigh = 100;
-    const float ThicknessZLow = 1.0f;
-    const float ThicknessZHigh = 0.0f;
-    const float AxisLength = 50.0f;
-    const float PlaneOffset = 25.0f;
-    const FVector2D PlaneExtent(10.0f, 10.0f);
-    const FVector BoxExtent(2.0f, 2.0f, 2.0f);
-    const float MaxMouseDistance = 5.0f;
-    const float RotationRadius = 15.0f;
-    const int32 RotationSegments = 32;
-    
-    const FColor AxisColorsZHigh [] = { FColor(255, 50, 50, 255), FColor(50, 255, 50, 255), FColor(50, 50, 255, 255), FColor(255, 255, 255, 255) };
-    const FColor AxisColorsZLow  [] = { FColor(128, 0, 0, 255), FColor(0, 128, 0, 255), FColor(0, 0, 128, 255), FColor(128, 128, 128, 255) };
-
-    const FColor SelectionColor = FColor(255, 255, 0, 255);
-
-    const FVector Center = InTransform.GetTranslation();
-    const FQuat RotX = InTransform.GetRotation();
-    const FQuat RotY = RotX * FQuat(FVector(0.0f, 0.0f, 1.0f), UE_HALF_PI);
-    const FQuat RotZ = RotX * FQuat(FVector(0.0f, 1.0f, 0.0f), UE_HALF_PI);
-    
-    const FVector UnitAxisX = RotX.GetAxisX();
-    const FVector UnitAxisY = RotX.GetAxisY();
-    const FVector UnitAxisZ = RotX.GetAxisZ();
-
-    const FVector AxisX = Center + UnitAxisX * AxisLength;
-    const FVector AxisY = Center + UnitAxisY * AxisLength;
-    const FVector AxisZ = Center + UnitAxisZ * AxisLength;
-
-    const FVector PlaneXY = Center + ((UnitAxisX + UnitAxisY) * PlaneOffset);
-    const FVector PlaneXZ = Center + ((UnitAxisX + UnitAxisZ) * PlaneOffset);
-    const FVector PlaneYZ = Center + ((UnitAxisY + UnitAxisZ) * PlaneOffset);
-
-    const ImVec2 ImMousePos = ImGui::GetMousePos() - Viewport->Pos;
-    const FVector2D MousePos = FCogImguiHelper::ToFVector2D(ImMousePos);
-
-    FVector2D ScreenGizmoCenter;
-    if (UGameplayStatics::ProjectWorldToScreen(PlayerController, Center, ScreenGizmoCenter) == false)
-    {
-        return;
-    }
-
-    FCogEngine_GizmoElement GizmoElements[ECogEngine_GizmoElementType::MAX];
-
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveX]    = FCogEngine_GizmoElement { ECogEngine_GizmoType::MoveAxis,     ECogEngine_GizmoAxis::X, FQuat::Identity, AxisX };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveY]    = FCogEngine_GizmoElement { ECogEngine_GizmoType::MoveAxis,     ECogEngine_GizmoAxis::Y, FQuat::Identity, AxisY };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveZ]    = FCogEngine_GizmoElement { ECogEngine_GizmoType::MoveAxis,     ECogEngine_GizmoAxis::Z, FQuat::Identity, AxisZ };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveXY]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::MovePlane,    ECogEngine_GizmoAxis::Z, RotZ, PlaneXY };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveXZ]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::MovePlane,    ECogEngine_GizmoAxis::Y, RotY, PlaneXZ };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::MoveYZ]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::MovePlane,    ECogEngine_GizmoAxis::X, RotX, PlaneYZ };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::RotateX]  = FCogEngine_GizmoElement { ECogEngine_GizmoType::Rotate,       ECogEngine_GizmoAxis::X, RotX, AxisX };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::RotateY]  = FCogEngine_GizmoElement { ECogEngine_GizmoType::Rotate,       ECogEngine_GizmoAxis::Y, RotY, AxisY };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::RotateZ]  = FCogEngine_GizmoElement { ECogEngine_GizmoType::Rotate,       ECogEngine_GizmoAxis::Z, RotZ, AxisZ };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::ScaleXYZ] = FCogEngine_GizmoElement { ECogEngine_GizmoType::ScaleUniform, ECogEngine_GizmoAxis::MAX, RotX, Center };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::ScaleX]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::ScaleAxis,    ECogEngine_GizmoAxis::X, RotX, AxisX };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::ScaleY]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::ScaleAxis,    ECogEngine_GizmoAxis::Y, RotY, AxisY };
-    GizmoElements[(int32)ECogEngine_GizmoElementType::ScaleZ]   = FCogEngine_GizmoElement { ECogEngine_GizmoType::ScaleAxis,    ECogEngine_GizmoAxis::Z, RotZ, AxisZ };
-
-    float MinDistanceToMouse = FLT_MAX;
-    ECogEngine_GizmoElementType ClosestGizmoElementType = ECogEngine_GizmoElementType::MAX;
-    for (uint8 i = (uint8)ECogEngine_GizmoElementType::MoveX; i < (uint8)ECogEngine_GizmoElementType::MAX; ++i)
-    {
-        FCogEngine_GizmoElement& Elm = GizmoElements[i];
-        float DistanceToMouse = FLT_MAX;
-
-        switch (Elm.Type)
-        {
-            case ECogEngine_GizmoType::MoveAxis:
-            {
-                FVector2D ScreenElementLocation;
-                UGameplayStatics::ProjectWorldToScreen(PlayerController, Elm.Location, ScreenElementLocation);
-                DistanceToMouse = FindSegmentPointDistance2(ScreenGizmoCenter, ScreenElementLocation, MousePos);
-                break;
-            }
-
-            case ECogEngine_GizmoType::MovePlane:
-            {
-                //DistanceToMouse = 
-                break;
-            }
-        }
-
-        if (DistanceToMouse < MaxMouseDistance && DistanceToMouse < MinDistanceToMouse)
-        {
-            ClosestGizmoElementType = (ECogEngine_GizmoElementType)i;
-            MinDistanceToMouse = DistanceToMouse;
-        }
-    }
-
-    for (uint8 i = (uint8)ECogEngine_GizmoElementType::MoveX; i < (uint8)ECogEngine_GizmoElementType::MAX; ++i)
-    {
-        const FCogEngine_GizmoElement& Elm = GizmoElements[i];
-        const bool IsClosestToMouse = i == (uint8)ClosestGizmoElementType;
-
-        switch (Elm.Type)
-        {
-            case ECogEngine_GizmoType::MoveAxis:
-            {
-                DrawDebugLine(InWorld, Center, Elm.Location, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZLow, ThicknessZLow);
-                DrawDebugLine(InWorld, Center, Elm.Location, IsClosestToMouse ? SelectionColor : AxisColorsZHigh[(uint8)Elm.Axis], false, 0.0f, ZHigh, ThicknessZHigh);
-                break;
-            }
-
-            case ECogEngine_GizmoType::MovePlane:
-            {
-                FCogDebugDrawHelper::DrawQuad(InWorld, Elm.Location, Elm.Rotation, PlaneExtent, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZLow, ThicknessZLow);
-                FCogDebugDrawHelper::DrawQuad(InWorld, Elm.Location, Elm.Rotation, PlaneExtent, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZHigh, ThicknessZHigh);
-                FCogDebugDrawHelper::DrawSolidQuad(InWorld, Elm.Location, Elm.Rotation, PlaneExtent, IsClosestToMouse ? SelectionColor : AxisColorsZHigh[(uint8)Elm.Axis], false, 0.0f, ZHigh);
-                break;
-            }
-
-            case ECogEngine_GizmoType::Rotate:
-            {
-                //FRotationTranslationMatrix Matrix(FRotator(Elm.Rotation), Elm.Location);
-                //DrawDebugCircle(InWorld, Matrix, RotationRadius, RotationSegments, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZLow, ThicknessZLow, false);
-                //DrawDebugCircle(InWorld, Matrix, RotationRadius, RotationSegments, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZHigh, ThicknessZHigh, false);
-                break;
-            }
-
-            case ECogEngine_GizmoType::ScaleUniform:
-            case ECogEngine_GizmoType::ScaleAxis:
-            {
-                DrawDebugBox(InWorld, Elm.Location, BoxExtent, Elm.Rotation, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZLow, ThicknessZLow);
-                DrawDebugBox(InWorld, Elm.Location, BoxExtent, Elm.Rotation, IsClosestToMouse ? SelectionColor : AxisColorsZHigh[(uint8)Elm.Axis], false, 0.0f, ZHigh, ThicknessZHigh);
-                DrawDebugSolidBox(InWorld, Elm.Location, BoxExtent, Elm.Rotation, IsClosestToMouse ? SelectionColor : AxisColorsZLow[(uint8)Elm.Axis], false, 0.0f, ZHigh);
-                break;
-            }
-        }
-    }
-
-
-    if (ImGui::IsMouseDown(ImGuiMouseButton_Left))
-    {
-        IsDragging = ClosestGizmoElementType != ECogEngine_GizmoElementType::MAX;
-        StartTransform = InTransform;
-    }
-    else if (ImGui::IsMouseReleased(ImGuiMouseButton_Left))
-    {
-        IsDragging = false;
-    }
-
-    if (IsDragging)
-    {
-        if (ImGui::IsMouseDragging(ImGuiMouseButton_Left, 4.0f))
-        {
-            ImVec2 Delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Left);
-            FVector WorldOrigin, WorldDirection;
-            UGameplayStatics::DeprojectScreenToWorld(PlayerController, MousePos, WorldOrigin, WorldDirection);
-        }
-    }
-}

Plugins/Cog/Source/CogEngine/Private/CogEngineWindow_CollisionViewer.cpp

@@ -292,7 +292,7 @@ void FCogEngineWindow_CollisionViewer::RenderContent()
                 if (AlreadyDrawnActors.Contains(Actor) == false)
                 {
                     FColor TextColor = Color.WithAlpha(255);
-                    DrawDebugString(World, Actor->GetActorLocation(), GetNameSafe(Actor->GetClass()), nullptr, FColor::White, 0.0f, FCogDebugSettings::TextShadow, FCogDebugSettings::TextSize);
+                    DrawDebugString(World, Actor->GetActorLocation(), GetNameSafe(Actor->GetClass()), nullptr, FColor::White, 0.0f, FCogDebugSettings::Data.TextShadow, FCogDebugSettings::Data.TextSize);
                     AlreadyDrawnActors.Add(Actor);
                 }
             }

Plugins/Cog/Source/CogEngine/Private/CogEngineWindow_DebugSettings.cpp

@@ -21,22 +21,8 @@ void FCogEngineWindow_DebugSettings::Initialize()
 
     Config = GetConfig<UCogEngineConfig_DebugSettings>();
 
-    FCogDebugSettings::Persistent = Config->Persistent;
+    FCogDebugSettings::Data = Config->Data;
-    FCogDebugSettings::TextShadow = Config->TextShadow;
+    FCogDebugSettings::SetIsFilteringBySelection(GetWorld(), Config->Data.bIsFilteringBySelection);
-    FCogDebugSettings::Fade2D = Config->Fade2D;
-    FCogDebugSettings::Duration = Config->Duration;
-    FCogDebugSettings::DepthPriority = Config->DepthPriority;
-    FCogDebugSettings::Segments = Config->Segments;
-    FCogDebugSettings::Thickness = Config->Thickness;
-    FCogDebugSettings::ServerThickness = Config->ServerThickness;
-    FCogDebugSettings::ServerColorMultiplier = Config->ServerColorMultiplier;
-    FCogDebugSettings::ArrowSize = Config->ArrowSize;
-    FCogDebugSettings::AxesScale = Config->AxesScale;
-    FCogDebugSettings::GradientColorIntensity = Config->GradientColorIntensity;
-    FCogDebugSettings::GradientColorSpeed = Config->GradientColorSpeed;
-    FCogDebugSettings::TextSize = Config->TextSize;
-
-    FCogDebugSettings::SetIsFilteringBySelection(GetWorld(), Config->bIsFilteringBySelection);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -52,20 +38,7 @@ void FCogEngineWindow_DebugSettings::PreSaveConfig()
 {
     Super::PreSaveConfig();
 
-    Config->Persistent               = FCogDebugSettings::Persistent;
+    Config->Data = FCogDebugSettings::Data;
-    Config->TextShadow               = FCogDebugSettings::TextShadow;
-    Config->Fade2D                   = FCogDebugSettings::Fade2D;
-    Config->Duration                 = FCogDebugSettings::Duration;
-    Config->DepthPriority            = FCogDebugSettings::DepthPriority;
-    Config->Segments                 = FCogDebugSettings::Segments;
-    Config->Thickness                = FCogDebugSettings::Thickness;
-    Config->ServerThickness          = FCogDebugSettings::ServerThickness;
-    Config->ServerColorMultiplier    = FCogDebugSettings::ServerColorMultiplier;
-    Config->ArrowSize                = FCogDebugSettings::ArrowSize;
-    Config->AxesScale                = FCogDebugSettings::AxesScale;
-    Config->GradientColorIntensity   = FCogDebugSettings::GradientColorIntensity;
-    Config->GradientColorSpeed       = FCogDebugSettings::GradientColorSpeed;
-    Config->TextSize                 = FCogDebugSettings::TextSize;
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -75,117 +48,195 @@ void FCogEngineWindow_DebugSettings::RenderContent()
 
     if (ImGui::BeginMenuBar())
     {
-        if (ImGui::MenuItem("Reset"))
+        if (ImGui::BeginMenu("Options"))
         {
-            FCogDebugSettings::Reset();
+            if (ImGui::MenuItem("Reset"))
+            {
+                FCogDebugSettings::Reset();
+            }
+
+        	ImGui::Checkbox("Show Advanced Settings", &Config->bShowAdvancedSettings);
+
+            ImGui::EndMenu();
         }
 
         ImGui::EndMenuBar();
     }
 
-    Config->bIsFilteringBySelection = FCogDebugSettings::GetIsFilteringBySelection();
+    Config->Data.bIsFilteringBySelection = FCogDebugSettings::GetIsFilteringBySelection();
-    if (ImGui::Checkbox("Filter by selection", &Config->bIsFilteringBySelection))
+    if (ImGui::Checkbox("Filter by selection", &Config->Data.bIsFilteringBySelection))
     {
-        FCogDebugSettings::SetIsFilteringBySelection(GetWorld(), Config->bIsFilteringBySelection);
+        FCogDebugSettings::SetIsFilteringBySelection(GetWorld(), Config->Data.bIsFilteringBySelection);
     }
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("If checked, only show the debug of the currently selected actor. Otherwise show the debug of all actors.");
     }
 
-    ImGui::Checkbox("Persistent", &FCogDebugSettings::Persistent);
+    FCogDebugData& Data = FCogDebugSettings::Data;
+
+    ImGui::Checkbox("Persistent", &Data.Persistent);
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("Make debug draw always persist");
     }
 
-    ImGui::Checkbox("Text Shadow", &FCogDebugSettings::TextShadow);
+    ImGui::Checkbox("Text Shadow", &Data.TextShadow);
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("Show a shadow below debug text.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::Checkbox("Fade 2D", &FCogDebugSettings::Fade2D);
+    ImGui::Checkbox("Fade 2D", &Data.Fade2D);
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("Does the 2D debug is fading out.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Duration", &FCogDebugSettings::Duration, 0.01f, 0.0f, 100.0f, "%.1f");
+    ImGui::DragFloat("Duration", &Data.Duration, 0.01f, 0.0f, 100.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The duration of debug elements.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Thickness", &FCogDebugSettings::Thickness, 0.05f, 0.0f, 5.0f, "%.1f");
+    ImGui::DragFloat("Thickness", &Data.Thickness, 0.05f, 0.0f, 5.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The thickness of debug lines.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Server Thickness", &FCogDebugSettings::ServerThickness, 0.05f, 0.0f, 5.0f, "%.1f");
+    ImGui::DragFloat("Server Thickness", &Data.ServerThickness, 0.05f, 0.0f, 5.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The thickness the server debug lines.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Server Color Mult", &FCogDebugSettings::ServerColorMultiplier, 0.01f, 0.0f, 1.0f, "%.1f");
+    ImGui::DragFloat("Server Color Mult", &Data.ServerColorMultiplier, 0.01f, 0.0f, 1.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The color multiplier applied to the server debug lines.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragInt("Depth Priority", &FCogDebugSettings::DepthPriority, 0.1f, 0, 100);
+    ImGui::DragInt("Depth Priority", &Data.DepthPriority, 0.1f, 0, 100);
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The depth priority of debug elements.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragInt("Segments", &FCogDebugSettings::Segments, 0.1f, 4, 20.0f);
+    ImGui::DragInt("Segments", &Data.Segments, 0.1f, 4, 20.0f);
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The number of segments used for circular shapes.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Axes Scale", &FCogDebugSettings::AxesScale, 0.1f, 0, 10.0f, "%.1f");
+    ImGui::DragFloat("Axes Scale", &Data.AxesScale, 0.1f, 0, 10.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The scaling debug axis.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Arrow Size", &FCogDebugSettings::ArrowSize, 1.0f, 0.0f, 200.0f, "%.0f");
+    ImGui::DragFloat("Arrow Size", &Data.ArrowSize, 1.0f, 0.0f, 200.0f, "%.0f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The size of debug arrows.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Gradient Intensity", &FCogDebugSettings::GradientColorIntensity, 0.01f, 0.0f, 1.0f, "%.2f");
+    ImGui::DragFloat("Gradient Intensity", &Data.GradientColorIntensity, 0.01f, 0.0f, 1.0f, "%.2f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("How much the debug elements color should be changed by a gradient color over time.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Gradient Speed", &FCogDebugSettings::GradientColorSpeed, 0.1f, 0.0f, 10.0f, "%.1f");
+    ImGui::DragFloat("Gradient Speed", &Data.GradientColorSpeed, 0.1f, 0.0f, 10.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The speed of the gradient color change.");
     }
 
     FCogWindowWidgets::SetNextItemToShortWidth();
-    ImGui::DragFloat("Text Size", &FCogDebugSettings::TextSize, 0.1f, 0.1f, 5.0f, "%.1f");
+    ImGui::DragFloat("Text Size", &Data.TextSize, 0.1f, 0.1f, 5.0f, "%.1f");
     if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
     {
         ImGui::SetTooltip("The size of the debug texts.");
     }
+
+    if (Config->bShowAdvancedSettings)
+    {
+        ImGui::SeparatorText("Gizmo");
+    }
+
+    FCogWindowWidgets::SetNextItemToShortWidth();
+    ImGui::DragFloat("Gizmo Scale", &Data.GizmoScale, 0.1f, 0.1f, 10.0f, "%.1f");
+    if (ImGui::IsItemHovered(ImGuiHoveredFlags_Stationary))
+    {
+        ImGui::SetTooltip("The scale of the gizmo.");
+    }
+
+    if (Config->bShowAdvancedSettings)
+    {
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Axis Length", &Data.GizmoAxisLength, 0.1f, 0.1f, 500.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragInt("Gizmo Z Low", &Data.GizmoZLow, 0.5f, 0, 1000);
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragInt("Gizmo Z High", &Data.GizmoZHigh, 0.5f, 0, 1000);
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Thickness Z Low", &Data.GizmoThicknessZLow, 0.1f, 0.0f, 10.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Thickness Z High", &Data.GizmoThicknessZHigh, 0.1f, 0.0f, 10.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Mouse Max Distance", &Data.GizmoMouseMaxDistance, 0.1f, 0.0f, 50.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Plane Offset", &Data.GizmoPlaneOffset, 0.1f, 0.0f, 500.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Plane Extent", &Data.GizmoPlaneExtent, 0.1f, 0.0f, 100.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Scale Box Extent", &Data.GizmoScaleBoxExtent, 0.1f, 0.0f, 100.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Scale Speed", &Data.GizmoScaleSpeed, 0.1f, 0.0f, 100.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Scale Min", &Data.GizmoScaleMin, 0.001f, 0.001f, 1.0f, "%.3f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragFloat("Gizmo Rotation Radius", &Data.GizmoRotationRadius, 0.1f, 0.1f, 500.0f, "%.1f");
+
+        FCogWindowWidgets::SetNextItemToShortWidth();
+        ImGui::DragInt("Gizmo Rotation Segments", &Data.GizmoRotationSegments, 1.0f, 0, 64);
+
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZLow X", Data.GizmoAxisColorsZLowX, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZLow Y", Data.GizmoAxisColorsZLowY, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZLow Z", Data.GizmoAxisColorsZLowZ, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZLow W", Data.GizmoAxisColorsZLowW, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+
+    	FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZHigh X", Data.GizmoAxisColorsZHighX, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZHigh Y", Data.GizmoAxisColorsZHighY, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZHigh Z", Data.GizmoAxisColorsZHighZ, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors ZHigh W", Data.GizmoAxisColorsZHighW, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors Selection X", Data.GizmoAxisColorsSelectionX, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors Selection Y", Data.GizmoAxisColorsSelectionY, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors Selection Z", Data.GizmoAxisColorsSelectionZ, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+        FCogWindowWidgets::ColorEdit4("Gizmo Axis Colors Selection W", Data.GizmoAxisColorsSelectionW, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaPreviewHalf);
+    }
 }

Plugins/Cog/Source/CogEngine/Private/CogEngineWindow_Skeleton.cpp

@@ -321,7 +321,7 @@ void FCogEngineWindow_Skeleton::DrawSkeleton()
 
             if (ShowNames || BoneInfo.ShowName || IsHovered)
             {
-                ::DrawDebugString(World, BoneLocation, BoneInfo.Name.ToString(), nullptr, IsHovered ? FColor::Red : FColor::White, 0.0f, true, FCogDebugSettings::TextSize);
+                ::DrawDebugString(World, BoneLocation, BoneInfo.Name.ToString(), nullptr, IsHovered ? FColor::Red : FColor::White, 0.0f, true, FCogDebugSettings::Data.TextSize);
             }
 
             if (ShowAxes || BoneInfo.ShowAxes)
@@ -330,7 +330,7 @@ void FCogEngineWindow_Skeleton::DrawSkeleton()
                     World,
                     BoneLocation,
                     BoneRotation,
-                    10.0f * FCogDebugSettings::AxesScale,
+                    10.0f * FCogDebugSettings::Data.AxesScale,
                     false,
                     0.0f,
                     1,
@@ -345,7 +345,7 @@ void FCogEngineWindow_Skeleton::DrawSkeleton()
                         World,
                         BoneLocation,
                         BoneLocation + ParentBodyInstance->GetUnrealWorldVelocity() * World->GetDeltaSeconds(),
-                        FCogDebugSettings::ArrowSize,
+                        FCogDebugSettings::Data.ArrowSize,
                         FCogDebugSettings::ModulateDebugColor(World, FColor::Cyan),
                         FCogDebugSettings::GetDebugPersistent(true),
                         FCogDebugSettings::GetDebugDuration(true),

Plugins/Cog/Source/CogEngine/Public/CogEngineWindow_CollisionTester.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "CogDebugGizmo.h"
 #include "CogWindow.h"
 #include "CogWindowConfig.h"
 #include "Engine/HitResult.h"
@@ -56,57 +57,6 @@ enum class ECogEngine_CollisionQueryShape : uint8
     Capsule,
 };
 
-//--------------------------------------------------------------------------------------------------------------------------
-UENUM()
-enum class ECogEngine_GizmoType : uint8
-{
-    MoveAxis,
-    MovePlane,
-    Rotate,
-    ScaleAxis,
-    ScaleUniform,
-    MAX,
-};
-
-//--------------------------------------------------------------------------------------------------------------------------
-UENUM()
-enum class ECogEngine_GizmoAxis : uint8
-{
-    X,
-    Y,
-    Z,
-    MAX,
-};
-
-//--------------------------------------------------------------------------------------------------------------------------
-UENUM()
-enum class ECogEngine_GizmoElementType : uint8
-{
-    MoveX,
-    MoveY,
-    MoveZ,
-    MoveXY,
-    MoveXZ,
-    MoveYZ,
-    RotateX,
-    RotateY,
-    RotateZ,
-    ScaleXYZ,
-    ScaleX,
-    ScaleY,
-    ScaleZ,
-    MAX,
-};
-
-//--------------------------------------------------------------------------------------------------------------------------
-struct FCogEngine_GizmoElement
-{
-    ECogEngine_GizmoType Type;
-    ECogEngine_GizmoAxis Axis;
-    FQuat Rotation;
-    FVector Location;
-};
-
 //--------------------------------------------------------------------------------------------------------------------------
 class COGENGINE_API FCogEngineWindow_CollisionTester : public FCogWindow
 {
@@ -132,7 +82,6 @@ protected:
 
     void DrawShape(const FCollisionShape& Shape, const FVector& Location, const FQuat& Rotation, const FVector& Scale, const FColor& Color, bool DrawSolid) const;
 
-    void DrawTransformGizmos(const UWorld* InWorld, FTransform& InTransform);
 
     struct FChannel
     {
@@ -152,6 +101,9 @@ protected:
 
     bool IsDragging = false;
 
+    FCogDebug_Gizmo GizmoStart;
+    FCogDebug_Gizmo GizmoEnd;
+
     FTransform StartTransform;
 
 };
@@ -176,6 +128,9 @@ public:
     UPROPERTY(Config)
     FRotator3f Rotation;
 
+    UPROPERTY(Config)
+    FRotator3f Scale;
+
     UPROPERTY(Config)
     ECogEngine_CollisionQueryType Type;
 
@@ -204,16 +159,7 @@ public:
     int32 ProfileIndex;
 
     UPROPERTY(Config)
-    float SphereRadius;
+    FVector3f ShapeExtent;
-
-    UPROPERTY(Config)
-    FVector3f BoxExtent;
-
-    UPROPERTY(Config)
-    float CapsuleRadius;
-
-    UPROPERTY(Config)
-    float CapsuleHalfHeight;
 
     UPROPERTY(Config)
     int QueryTypeOld;
@@ -272,10 +218,7 @@ public:
         Shape = ECogEngine_CollisionQueryShape::Sphere;
         MultiHits = false;
         TraceComplex = false;
-        SphereRadius = 50.0f;
+        ShapeExtent = FVector3f(50.0f, 50.0f, 50.0f);
-        BoxExtent = FVector3f(50.0f, 50.0f, 50.0f);
-        CapsuleRadius = 50.0f;
-        CapsuleHalfHeight = 50.0f;
 
         ObjectTypesToQuery = 0;
         ProfileIndex = 0;

Plugins/Cog/Source/CogEngine/Public/CogEngineWindow_DebugSettings.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "CogDebugSettings.h"
 #include "CogWindow.h"
 #include "CogWindowConfig.h"
 #include "CogEngineWindow_DebugSettings.generated.h"
@@ -27,7 +28,6 @@ protected:
 private:
 
     TWeakObjectPtr<UCogEngineConfig_DebugSettings> Config = nullptr;
-
 };
 
 //--------------------------------------------------------------------------------------------------------------------------
@@ -39,68 +39,15 @@ class UCogEngineConfig_DebugSettings : public UCogWindowConfig
 public:
 
     UPROPERTY(Config)
-    bool bIsFilteringBySelection = true;
+    FCogDebugData Data;
 
     UPROPERTY(Config)
-    bool Persistent = false;
+    bool bShowAdvancedSettings = false;
-
-    UPROPERTY(Config)
-    bool TextShadow = true;
-
-    UPROPERTY(Config)
-    bool Fade2D = true;
-
-    UPROPERTY(Config)
-    float Duration = 3.0f;
-
-    UPROPERTY(Config)
-    int DepthPriority = 0;
-
-    UPROPERTY(Config)
-    int Segments = 12;
-
-    UPROPERTY(Config)
-    float Thickness = 0.0f;
-
-    UPROPERTY(Config)
-    float ServerThickness = 2.0f;
-
-    UPROPERTY(Config)
-    float ServerColorMultiplier = 0.8f;
-
-    UPROPERTY(Config)
-    float ArrowSize = 10.0f;
-
-    UPROPERTY(Config)
-    float AxesScale = 1.0f;
-
-    UPROPERTY(Config)
-    float GradientColorIntensity = 0.0f;
-
-    UPROPERTY(Config)
-    float GradientColorSpeed = 2.0f;
-
-    UPROPERTY(Config)
-    float TextSize = 1.0f;
 
     virtual void Reset() override
     {
         Super::Reset();
-
+        Data = FCogDebugData();
-        bIsFilteringBySelection = true;
+        bShowAdvancedSettings = false;
-        Persistent = false;
-        TextShadow = true;
-        Fade2D = true;
-        Duration = 3.0f;
-        DepthPriority = 0;
-        Segments = 12;
-        Thickness = 0.0f;
-        ServerThickness = 2.0f;
-        ServerColorMultiplier = 0.8f;
-        ArrowSize = 10.0f;
-        AxesScale = 1.0f;
-        GradientColorIntensity = 0.0f;
-        GradientColorSpeed = 2.0f;
-        TextSize = 1.0f;
     }
 };

Plugins/Cog/Source/CogImgui/Private/CogImguiWidget.cpp

@@ -124,17 +124,17 @@ FReply SCogImguiWidget::OnKeyChar(const FGeometry& MyGeometry, const FCharacterE
 //--------------------------------------------------------------------------------------------------------------------------
 FReply SCogImguiWidget::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent)
 {
-    return HandleKeyEvent(MyGeometry, KeyEvent);
+    return HandleKeyEvent(MyGeometry, KeyEvent, true);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
 FReply SCogImguiWidget::OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent)
 {
-    return HandleKeyEvent(MyGeometry, KeyEvent);
+    return HandleKeyEvent(MyGeometry, KeyEvent, false);
 }
 
 //--------------------------------------------------------------------------------------------------------------------------
-FReply SCogImguiWidget::HandleKeyEvent(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent)
+FReply SCogImguiWidget::HandleKeyEvent(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent, bool Down)
 {
     if (Context->GetEnableInput() == false)
     {
@@ -154,8 +154,9 @@ FReply SCogImguiWidget::HandleKeyEvent(const FGeometry& MyGeometry, const FKeyEv
         {
             return FReply::Unhandled();
         }
+
         ImGuiIO& IO = ImGui::GetIO();
-        IO.AddKeyEvent(FCogImguiInputHelper::ToImKey(KeyEvent.GetKey()), false);
+        IO.AddKeyEvent(FCogImguiInputHelper::ToImKey(KeyEvent.GetKey()), Down);
         IO.AddKeyEvent(ImGuiMod_Ctrl, KeyEvent.IsControlDown());
         IO.AddKeyEvent(ImGuiMod_Shift, KeyEvent.IsShiftDown());
         IO.AddKeyEvent(ImGuiMod_Alt, KeyEvent.IsAltDown());

Plugins/Cog/Source/CogImgui/Public/CogImguiWidget.h

@@ -53,7 +53,7 @@ public:
 
 protected:
 
-    FReply HandleKeyEvent(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent);
+    FReply HandleKeyEvent(const FGeometry& MyGeometry, const FKeyEvent& KeyEvent, bool Down);
 
     void RefreshVisibility();
 

Plugins/Cog/Source/CogWindow/Private/CogWindowWidgets.cpp

@@ -612,3 +612,24 @@ bool FCogWindowWidgets::MultiChoiceButtonsFloat(TArray<float>& Values, float& Va
 
     return IsPressed;
 }
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool FCogWindowWidgets::DragFVector(const char* Label, FVector& Vector, float Speed, float Min, float Max, const char* Format, ImGuiSliderFlags Flags)
+{
+    return ImGui::DragScalarN(Label, ImGuiDataType_Double, &Vector.X, 3, Speed, &Min, &Max, Format, Flags);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool FCogWindowWidgets::DragFVector2D(const char* Label, FVector2D& Vector, float Speed, float Min, float Max, const char* Format, ImGuiSliderFlags Flags)
+{
+    return ImGui::DragScalarN(Label, ImGuiDataType_Double, &Vector.X, 2, Speed, &Min, &Max, Format, Flags);
+}
+
+//--------------------------------------------------------------------------------------------------------------------------
+bool FCogWindowWidgets::ColorEdit4(const char* Label, FColor& Color, ImGuiColorEditFlags Flags)
+{
+    FLinearColor Linear(Color);
+	const bool Result = ImGui::ColorEdit4(Label, &Linear.R, Flags);
+    Color = Linear.ToFColor(true);
+    return Result;
+}

Plugins/Cog/Source/CogWindow/Public/CogWindowWidgets.h

@@ -20,6 +20,12 @@ public:
 
     static void EndTableTooltip();
 
+    static bool DragFVector(const char* Label, FVector& Vector, float Speed = 1.0f, float Min = 0.0f, float Max = 0.0f, const char* Format = "%.3f", ImGuiSliderFlags Flags = 0);
+
+    static bool DragFVector2D(const char* Label, FVector2D& Vector, float Speed = 1.0f, float Min = 0.0f, float Max = 0.0f, const char* Format = "%.3f", ImGuiSliderFlags Flags = 0);
+
+    static bool ColorEdit4(const char* Label, FColor& Color, ImGuiColorEditFlags Flags = 0);
+
     static void ProgressBarCentered(float Fraction, const ImVec2& Size, const char* Overlay);
 
     static bool ToggleMenuButton(bool* Value, const char* Text, const ImVec4& TrueColor);