tooll3--t3
wehub-resource-sync
1349 行
52 KiB
C#
1349 行
52 KiB
C#
#nullable enable
|
|
using System.Diagnostics;
|
|
using ImGuiNET;
|
|
using T3.Core.Operator;
|
|
using T3.Core.Operator.Interfaces;
|
|
using T3.Core.Operator.Slots;
|
|
using T3.Core.Resource;
|
|
using T3.Core.Utils;
|
|
using T3.Core.Utils.Geometry;
|
|
using T3.Editor.Gui.Styling;
|
|
using T3.Editor.Gui.UiHelpers;
|
|
using T3.Editor.Gui.Windows;
|
|
using T3.Editor.UiModel;
|
|
using T3.Editor.UiModel.Commands;
|
|
using T3.Editor.UiModel.Commands.Graph;
|
|
using Color = T3.Core.DataTypes.Vector.Color;
|
|
using GraphicsMath = T3.Core.Utils.Geometry.GraphicsMath;
|
|
using Plane = System.Numerics.Plane;
|
|
using Quaternion = System.Numerics.Quaternion;
|
|
using Vector2 = System.Numerics.Vector2;
|
|
using Vector4 = System.Numerics.Vector4;
|
|
using Ray = T3.Core.Utils.Geometry.Ray;
|
|
|
|
// ReSharper disable RedundantNameQualifier
|
|
|
|
namespace T3.Editor.Gui.Interaction.TransformGizmos;
|
|
|
|
/**
|
|
* Handles the interaction with 3d-gizmos for operators selected in the graph.
|
|
*/
|
|
[HelpUiID("Gizmo")]
|
|
internal static class TransformGizmoHandling
|
|
{
|
|
#region Setup and callback
|
|
|
|
public static bool IsDragging => _draggedGizmoPart != GizmoParts.None;
|
|
|
|
public static void RegisterSelectedTransformable(SymbolUi.Child node, ITransformable transformable)
|
|
{
|
|
if (_selectedTransformables.Contains(transformable))
|
|
return;
|
|
|
|
transformable.TransformCallback = TransformCallback;
|
|
_selectedTransformables.Add(transformable);
|
|
}
|
|
|
|
public static void ClearDeselectedTransformableNode(ITransformable transformable)
|
|
{
|
|
if (_selectedTransformables.Contains(transformable))
|
|
{
|
|
Log.Warning("trying to deselect an unregistered transformable?");
|
|
return;
|
|
}
|
|
|
|
transformable.TransformCallback = null;
|
|
_selectedTransformables.Remove(transformable);
|
|
}
|
|
|
|
public static void ClearSelectedTransformables()
|
|
{
|
|
foreach (var selectedTransformable in _selectedTransformables)
|
|
{
|
|
selectedTransformable.TransformCallback = null;
|
|
}
|
|
|
|
_selectedTransformables.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// We need the foreground draw list at the moment when the output texture is drawn to the to output view...
|
|
/// </summary>
|
|
public static void SetDrawList(ImDrawListPtr drawList)
|
|
{
|
|
_drawList = drawList;
|
|
_isDrawListValid = true;
|
|
|
|
if (_dragNotStopped)
|
|
{
|
|
if (!ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
Log.Warning("Gizmo Drag not correctly stopped?");
|
|
_draggedGizmoPart = GizmoParts.None;
|
|
}
|
|
|
|
_dragNotStopped = false;
|
|
}
|
|
else if (_draggedGizmoPart != GizmoParts.None && !ImGui.IsMouseDown(ImGuiMouseButton.Left))
|
|
{
|
|
_dragNotStopped = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
/// <summary>
|
|
/// In certain situations the release is not correctly handled during the update.
|
|
/// In SetDrawList
|
|
/// </summary>
|
|
private static bool _dragNotStopped;
|
|
|
|
public static void RestoreDrawList()
|
|
{
|
|
_isDrawListValid = false;
|
|
}
|
|
|
|
private static Vector3 _selectedCenter;
|
|
|
|
public static Vector3 GetLatestSelectionCenter()
|
|
{
|
|
if (_selectedTransformables.Count == 0)
|
|
return Vector3.Zero;
|
|
|
|
return _selectedCenter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called from <see cref="ITransformable"/> operators during update call
|
|
/// </summary>
|
|
public static void TransformCallback(Instance instance, EvaluationContext context)
|
|
{
|
|
if (!_isDrawListValid)
|
|
{
|
|
Log.Warning("can't draw gizmo without initialized draw list");
|
|
return;
|
|
}
|
|
|
|
if (instance is not ITransformable tmp)
|
|
return;
|
|
|
|
_instance = instance;
|
|
|
|
_transformable = tmp;
|
|
|
|
if (!_selectedTransformables.Contains(_transformable))
|
|
{
|
|
Log.Warning("transform-callback from non-selected node?" + _transformable);
|
|
return;
|
|
}
|
|
|
|
if (context.ShowGizmos == GizmoVisibility.Off)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_objectToWorld = context.ObjectToWorld;
|
|
_objectToClipSpace = context.ObjectToWorld * context.WorldToCamera * context.CameraToClipSpace;
|
|
|
|
PrepareCalculations(context);
|
|
|
|
if (_canvas == null)
|
|
return;
|
|
|
|
var gizmoScale = CalcGizmoScale(context, _localToObject, _viewport.Width, _viewport.Height, 45f, UserSettings.Config.GizmoSize);
|
|
_centerPadding = 0.2f * gizmoScale / _canvas.Scale.X;
|
|
_gizmoLength = 2f * gizmoScale / _canvas.Scale.Y;
|
|
_planeGizmoSize = 0.5f * gizmoScale / _canvas.Scale.X;
|
|
//var lineThickness = 2;
|
|
|
|
// Handle different gizmo modes
|
|
switch (context.TransformGizmoMode)
|
|
{
|
|
case TransformGizmoModes.Move:
|
|
if (_transformable.TranslationInput != null)
|
|
{
|
|
HandlePositionGizmos();
|
|
}
|
|
|
|
break;
|
|
|
|
case TransformGizmoModes.Scale:
|
|
if (_transformable.ScaleInput != null)
|
|
{
|
|
HandleScaleGizmos();
|
|
}
|
|
|
|
break;
|
|
|
|
case TransformGizmoModes.Rotate:
|
|
if (_transformable.RotationInput != null)
|
|
{
|
|
HandleRotationGizmos(context);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Extract position gizmo handling into separate method
|
|
private static bool HandlePositionGizmos()
|
|
{
|
|
var isHoveringSomething = HandleDragOnAxis(Vector3.UnitX, Color.Red, GizmoParts.PositionXAxis);
|
|
isHoveringSomething |= HandleDragOnAxis(Vector3.UnitY, Color.Green, GizmoParts.PositionYAxis);
|
|
isHoveringSomething |= HandleDragOnAxis(Vector3.UnitZ, Color.Blue, GizmoParts.PositionZAxis);
|
|
isHoveringSomething |= HandleDragOnPlane(Vector3.UnitX, Vector3.UnitY, Color.Blue, GizmoParts.PositionOnXyPlane);
|
|
isHoveringSomething |= HandleDragOnPlane(Vector3.UnitX, Vector3.UnitZ, Color.Green, GizmoParts.PositionOnXzPlane);
|
|
isHoveringSomething |= HandleDragOnPlane(Vector3.UnitY, Vector3.UnitZ, Color.Red, GizmoParts.PositionOnYzPlane);
|
|
isHoveringSomething |= HandleDragInScreenSpace();
|
|
|
|
return isHoveringSomething;
|
|
}
|
|
|
|
|
|
private static void PrepareCalculations(EvaluationContext context)
|
|
{
|
|
Debug.Assert(_transformable != null);
|
|
|
|
// Terminology of the matrices:
|
|
// objectToClipSpace means in this context the transform without application of the ITransformable values. These are
|
|
// named 'local'. So localToObject is the matrix of applying the ITransformable values and localToClipSpace to transform
|
|
// points from the local system (including trans/rot of ITransformable) to the projected space. Scale is ignored for
|
|
// local here as the local values are only used for drawing, and therefore we don't want to draw anything scaled by this values.
|
|
_mousePosInScreen = ImGui.GetIO().MousePos;
|
|
|
|
|
|
var translation = TryGetVectorFromInput(_transformable.TranslationInput);
|
|
var center = Vector3.TransformNormal(translation, _objectToWorld);
|
|
_selectedCenter = center;
|
|
|
|
_localToObject = GraphicsMath.CreateTransformationMatrix(
|
|
scalingCenter: Vector3.Zero,
|
|
scalingRotation: Quaternion.Identity,
|
|
scaling: Vector3.One,
|
|
rotationCenter: Vector3.Zero,
|
|
rotation: Quaternion.Identity, // no rotation here
|
|
translation: translation);
|
|
|
|
_localToClipSpace = _localToObject * _objectToClipSpace;
|
|
|
|
// Camera looks along negative Z in view space
|
|
// Camera looks along negative Z in world space
|
|
var viewDirWorld = -Vector3.UnitZ;
|
|
|
|
// Bring to object space
|
|
_viewDirLocal = Vector3.TransformNormal(viewDirWorld, _initialObjectToLocal);
|
|
_originInClipSpace = GraphicsMath.TransformCoordinate(translation, _objectToClipSpace);
|
|
|
|
// Compute gizmo center in world space
|
|
_initialOriginWorld = Vector3.Transform(_initialOrigin, _objectToWorld);
|
|
|
|
// Don't draw gizmo behind camera (view plane)
|
|
_renderGizmo = Math.Abs(_originInClipSpace.Z) <= 1 && Math.Abs(_originInClipSpace.X) <= 2 && Math.Abs(_originInClipSpace.Y) <= 2;
|
|
|
|
var viewports = ResourceManager.Device.ImmediateContext.Rasterizer.GetViewports<SharpDX.Mathematics.Interop.RawViewportF>();
|
|
_viewport = viewports[0];
|
|
var originInViewport = new Vector2(_viewport.Width * (_originInClipSpace.X * 0.5f + 0.5f),
|
|
_viewport.Height * (1.0f - (_originInClipSpace.Y * 0.5f + 0.5f)));
|
|
|
|
_canvas = ImageOutputCanvas.Current;
|
|
if (_canvas == null)
|
|
return;
|
|
|
|
var originInCanvas = _canvas.TransformDirection(originInViewport);
|
|
_topLeftOnScreen = _canvas.TransformPosition(System.Numerics.Vector2.Zero);
|
|
_originInScreen = _topLeftOnScreen + originInCanvas;
|
|
|
|
Matrix4x4.Invert(_localToObject, out _initialObjectToLocal);
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region scale ----------------------------------------------------------------
|
|
// New method to handle scale gizmos
|
|
private static bool HandleScaleGizmos()
|
|
{
|
|
var isHoveringSomething = HandleAndDrawScaleDragOnAxis(Vector3.UnitX, Color.Red, GizmoParts.ScaleXAxis);
|
|
isHoveringSomething |= HandleAndDrawScaleDragOnAxis(Vector3.UnitY, Color.Green, GizmoParts.ScaleYAxis);
|
|
isHoveringSomething |= HandleAndDrawScaleDragOnAxis(Vector3.UnitZ, Color.Blue, GizmoParts.ScaleZAxis);
|
|
isHoveringSomething |= HandleUniformScale();
|
|
|
|
return isHoveringSomething;
|
|
}
|
|
|
|
private static bool HandleAndDrawScaleDragOnAxis(Vector3 gizmoAxis, Color color, GizmoParts mode)
|
|
{
|
|
var axisStartInScreen = LocalPosToScreenPos(gizmoAxis * _centerPadding);
|
|
var deltaScaleForAxis = (_draggedGizmoPart == GizmoParts.ScaleUniform || mode == _draggedGizmoPart)
|
|
? _deltaScaleFactor
|
|
: 1;
|
|
var axisEndInScreen = LocalPosToScreenPos(gizmoAxis * _gizmoLength * deltaScaleForAxis);
|
|
|
|
// Draw scale handle as a cube at the end of the axis
|
|
var handleSize = 12f;
|
|
var handleRect = new Vector2(handleSize, handleSize);
|
|
var handleCenter = axisEndInScreen;
|
|
var handleMin = handleCenter - handleRect * 0.5f;
|
|
var handleMax = handleCenter + handleRect * 0.5f;
|
|
|
|
var isHovering = false;
|
|
if (!IsDragging)
|
|
{
|
|
// Check if mouse is over the handle
|
|
isHovering = (_mousePosInScreen.X >= handleMin.X && _mousePosInScreen.X <= handleMax.X &&
|
|
_mousePosInScreen.Y >= handleMin.Y && _mousePosInScreen.Y <= handleMax.Y);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartScaleDragging(mode);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == mode
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
UpdateScaleDragging(gizmoAxis);
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompleteScaleDragging();
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
// Draw axis line
|
|
_drawList.AddLine(axisStartInScreen, axisEndInScreen, color, 2 * (isHovering ? 3 : 1));
|
|
|
|
// Draw scale handle (cube)
|
|
var handleColor = color;
|
|
handleColor.Rgba.W = isHovering ? 1.0f : 0.8f;
|
|
_drawList.AddRectFilled(handleMin, handleMax, handleColor);
|
|
_drawList.AddRect(handleMin, handleMax, Color.White, 0, ImDrawFlags.None, 1);
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
// New method to handle uniform scaling
|
|
private static bool HandleUniformScale()
|
|
{
|
|
const float handleSize = 12f;
|
|
var handleRect = new Vector2(handleSize, handleSize);
|
|
var handleCenter = _originInScreen;
|
|
var handleMin = handleCenter - handleRect * 0.5f;
|
|
var handleMax = handleCenter + handleRect * 0.5f;
|
|
|
|
var isHovering = false;
|
|
|
|
if (!IsDragging)
|
|
{
|
|
isHovering = (_mousePosInScreen.X >= handleMin.X && _mousePosInScreen.X <= handleMax.X &&
|
|
_mousePosInScreen.Y >= handleMin.Y && _mousePosInScreen.Y <= handleMax.Y);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartScaleDragging(GizmoParts.ScaleUniform);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == GizmoParts.ScaleUniform
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
UpdateUniformScaleDragging();
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompleteScaleDragging();
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
var color = UiColors.StatusAnimated;
|
|
color.Rgba.W = isHovering ? 1.0f : 0.6f;
|
|
_drawList.AddRectFilled(handleMin, handleMax, color);
|
|
_drawList.AddRect(handleMin, handleMax, Color.White, 0, ImDrawFlags.None, 2);
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
// New method to start scale dragging
|
|
private static void StartScaleDragging(GizmoParts mode)
|
|
{
|
|
Debug.Assert(_instance?.Parent != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
_draggedGizmoPart = mode;
|
|
_inputCommandInFlight = new ChangeInputValueCommand(_instance.Parent.Symbol,
|
|
_instance.SymbolChildId,
|
|
_transformable.ScaleInput.Input,
|
|
_transformable.ScaleInput.Input.Value);
|
|
|
|
_draggedTransformable = _transformable;
|
|
_dragInteractionWindowId = ImGui.GetID("");
|
|
_initialOffsetToOrigin = _mousePosInScreen - _originInScreen;
|
|
_initialScale = TryGetVectorFromInput(_transformable.ScaleInput, 1f);
|
|
|
|
var rayInObject = GetPickRayInObject(_mousePosInScreen);
|
|
var rayInLocal = rayInObject;
|
|
rayInLocal.Direction = Vector3.TransformNormal(rayInObject.Direction, _initialObjectToLocal);
|
|
rayInLocal.Origin = Vector3.Transform(rayInObject.Origin, _initialObjectToLocal);
|
|
|
|
_plane = GetPlaneForDragMode(mode, rayInObject.Direction, _initialOrigin);
|
|
if (!_plane.Intersects(rayInLocal, out _initialIntersectionPoint))
|
|
{
|
|
_plane.D = -_plane.D;
|
|
if (!_plane.Intersects(rayInLocal, out _initialIntersectionPoint))
|
|
{
|
|
_plane.Normal = Vector3.Zero;
|
|
Log.Debug($"Couldn't intersect pick ray with gizmo axis plane.");
|
|
}
|
|
}
|
|
}
|
|
|
|
// New method to update scale dragging
|
|
private static void UpdateScaleDragging(Vector3 axis)
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
var rayInObject = GetPickRayInObject(_mousePosInScreen);
|
|
var rayInLocal = rayInObject;
|
|
rayInLocal.Direction = Vector3.TransformNormal(rayInObject.Direction, _initialObjectToLocal);
|
|
rayInLocal.Origin = Vector3.Transform(rayInObject.Origin, _initialObjectToLocal);
|
|
|
|
if (_plane.Normal != Vector3.Zero && _plane.Intersects(rayInLocal, out Vector3 intersectionPoint))
|
|
{
|
|
var deltaInLocal = intersectionPoint - _initialIntersectionPoint;
|
|
var scaleDelta = Vector3.Dot(deltaInLocal, axis);
|
|
|
|
var newScale = _initialScale + axis * scaleDelta;
|
|
_deltaScaleFactor = 1 + scaleDelta;
|
|
|
|
// Prevent negative or zero scaling
|
|
//newScale.X = Math.Max(0.001f, newScale.X);
|
|
//newScale.Y = Math.Max(0.001f, newScale.Y);
|
|
//newScale.Z = Math.Max(0.001f, newScale.Z);
|
|
|
|
TrySetVector3ToInput(_transformable.ScaleInput, newScale);
|
|
_inputCommandInFlight.AssignNewValue(_transformable.ScaleInput.Input.Value);
|
|
}
|
|
}
|
|
|
|
/** Uniform */
|
|
private static float _deltaScaleFactor = 1;
|
|
|
|
// New method to update uniform scale dragging
|
|
private static void UpdateUniformScaleDragging()
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
var mouseDelta = _mousePosInScreen - (_originInScreen + _initialOffsetToOrigin);
|
|
var scaleDelta = 1 + mouseDelta.X * 0.01f; // Use X movement for uniform scaling
|
|
_deltaScaleFactor = scaleDelta;
|
|
|
|
//var newScale = _initialScale + Vector3.One * scaleDelta;
|
|
|
|
var newScale = _initialScale * scaleDelta;
|
|
|
|
TrySetVector3ToInput(_transformable.ScaleInput, newScale);
|
|
_inputCommandInFlight.AssignNewValue(_transformable.ScaleInput.Input.Value);
|
|
}
|
|
|
|
// New method to complete scale dragging
|
|
private static void CompleteScaleDragging()
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
UndoRedoStack.Add(_inputCommandInFlight);
|
|
_inputCommandInFlight = null;
|
|
|
|
_draggedGizmoPart = GizmoParts.None;
|
|
_draggedTransformable = null;
|
|
_dragInteractionWindowId = 0;
|
|
_deltaScaleFactor = 1;
|
|
_dragNotStopped = false;
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region translate ----------------------------------------------------
|
|
|
|
// Returns true if hovered or active
|
|
private static bool HandleDragOnAxis(Vector3 gizmoAxis, Color color, GizmoParts mode)
|
|
{
|
|
var axisStartInScreen = LocalPosToScreenPos(gizmoAxis * _centerPadding);
|
|
var axisEndInScreen = LocalPosToScreenPos(gizmoAxis * _gizmoLength);
|
|
|
|
var isHovering = false;
|
|
if (!IsDragging)
|
|
{
|
|
isHovering = IsPointOnLine(_mousePosInScreen, axisStartInScreen, axisEndInScreen);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartPositionDragging(mode, true);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == mode
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
|
|
var rayInObject = GetPickRayInObject(_mousePosInScreen);
|
|
var rayInLocal = rayInObject;
|
|
rayInLocal.Direction = Vector3.TransformNormal((rayInObject.Direction), _initialObjectToLocal);
|
|
rayInLocal.Origin = Vector3.Transform((rayInObject.Origin), _initialObjectToLocal);
|
|
|
|
Vector3 newOrigin = _initialOrigin; // (GetNewOffsetInObject() - _initialOrigin) * (gizmoAxis1 + gizmoAxis2) + _initialOrigin;
|
|
if (_plane.Normal != Vector3.Zero
|
|
&& _plane.Intersects(rayInLocal, out Vector3 intersectionPoint))
|
|
{
|
|
Vector3 offsetInLocal = (intersectionPoint - _initialIntersectionPoint) * gizmoAxis;
|
|
var offsetInObject = Vector4.Transform(new Vector4(offsetInLocal, 1), _localToObject);
|
|
newOrigin = new Vector3(offsetInObject.X, offsetInObject.Y, offsetInObject.Z) / offsetInObject.W;
|
|
}
|
|
|
|
UpdatePositionDragging(newOrigin);
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompletePositionDragging();
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
_drawList.AddLine(axisStartInScreen, axisEndInScreen, color, 2 * (isHovering ? 3 : 1));
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
// Returns true if hovered or active
|
|
private static bool HandleDragOnPlane(Vector3 gizmoAxis1, Vector3 gizmoAxis2, Color color, GizmoParts mode)
|
|
{
|
|
var origin = (gizmoAxis1 + gizmoAxis2) * _centerPadding;
|
|
Vector2[] pointsOnScreen =
|
|
{
|
|
LocalPosToScreenPos(origin),
|
|
LocalPosToScreenPos(origin + gizmoAxis1 * _planeGizmoSize),
|
|
LocalPosToScreenPos(origin + (gizmoAxis1 + gizmoAxis2) * _planeGizmoSize),
|
|
LocalPosToScreenPos(origin + gizmoAxis2 * _planeGizmoSize),
|
|
};
|
|
var isHovering = false;
|
|
|
|
if (!IsDragging)
|
|
{
|
|
isHovering = IsPointInQuad(_mousePosInScreen, pointsOnScreen);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartPositionDragging(mode, true);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == mode
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
|
|
var rayInObject = GetPickRayInObject(_mousePosInScreen);
|
|
var rayInLocal = rayInObject;
|
|
rayInLocal.Direction = (Vector3.TransformNormal((rayInObject.Direction), _initialObjectToLocal));
|
|
rayInLocal.Origin = (Vector3.Transform((rayInObject.Origin), _initialObjectToLocal));
|
|
|
|
Vector3 newOrigin = _initialOrigin; // (GetNewOffsetInObject() - _initialOrigin) * (gizmoAxis1 + gizmoAxis2) + _initialOrigin;
|
|
if (_plane.Normal != Vector3.Zero
|
|
&& _plane.Intersects(rayInLocal, out Vector3 intersectionPoint))
|
|
{
|
|
Vector3 offsetInLocal = (intersectionPoint - _initialIntersectionPoint) * (gizmoAxis1 + gizmoAxis2);
|
|
var offsetInObject = GraphicsMath.TransformCoordinate(offsetInLocal, _localToObject);
|
|
newOrigin = offsetInObject;
|
|
}
|
|
|
|
UpdatePositionDragging(newOrigin);
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompletePositionDragging();
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
var color2 = color;
|
|
color2.Rgba.W = isHovering ? 0.4f : 0.2f;
|
|
_drawList.AddConvexPolyFilled(ref pointsOnScreen[0], 4, color2);
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
private static bool HandleDragInScreenSpace()
|
|
{
|
|
const float gizmoSize = 4;
|
|
var screenSquaredMin = _originInScreen - new Vector2(gizmoSize, gizmoSize);
|
|
var screenSquaredMax = _originInScreen + new Vector2(gizmoSize, gizmoSize);
|
|
|
|
var isHovering = false;
|
|
|
|
if (_draggedGizmoPart == GizmoParts.None)
|
|
{
|
|
isHovering = (_mousePosInScreen.X > screenSquaredMin.X && _mousePosInScreen.X < screenSquaredMax.X &&
|
|
_mousePosInScreen.Y > screenSquaredMin.Y && _mousePosInScreen.Y < screenSquaredMax.Y);
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartPositionDragging(GizmoParts.PositionInScreenPlane, true);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == GizmoParts.PositionInScreenPlane
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompletePositionDragging();
|
|
}
|
|
else
|
|
{
|
|
UpdatePositionDragging(GetNewOffsetInObject());
|
|
// not internal plane udpate needed here since it's not used at all
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
var color2 = UiColors.StatusAnimated;
|
|
color2.Rgba.W = isHovering ? 0.8f : 0.3f;
|
|
_drawList.AddRectFilled(screenSquaredMin, screenSquaredMax, color2);
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
private static void StartPositionDragging(GizmoParts mode, bool createUndo)
|
|
{
|
|
Debug.Assert(_instance?.Parent != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
_draggedGizmoPart = mode;
|
|
if (createUndo)
|
|
{
|
|
_inputCommandInFlight = new ChangeInputValueCommand(_instance.Parent.Symbol,
|
|
_instance.SymbolChildId,
|
|
_transformable.TranslationInput.Input,
|
|
_transformable.TranslationInput.Input.Value);
|
|
}
|
|
|
|
_draggedTransformable = _transformable;
|
|
_dragInteractionWindowId = ImGui.GetID("");
|
|
_initialOffsetToOrigin = _mousePosInScreen - _originInScreen;
|
|
_initialOrigin = _localToObject.Translation;
|
|
|
|
var rayInObject = GetPickRayInObject(_mousePosInScreen);
|
|
var rayInLocal = rayInObject;
|
|
rayInLocal.Direction = Vector3.TransformNormal((rayInObject.Direction), _initialObjectToLocal);
|
|
rayInLocal.Origin = Vector3.Transform((rayInObject.Origin), _initialObjectToLocal);
|
|
|
|
_plane = GetPlaneForDragMode(mode, (rayInObject.Direction), _initialOrigin);
|
|
if (mode == GizmoParts.PositionInScreenPlane)
|
|
{
|
|
_plane.Normal = Vector3.Zero;
|
|
}
|
|
else if (!_plane.Intersects(rayInLocal, out _initialIntersectionPoint))
|
|
{
|
|
_plane.D = -_plane.D;
|
|
if (!_plane.Intersects(rayInLocal, out _initialIntersectionPoint))
|
|
{
|
|
_plane.Normal = Vector3.Zero;
|
|
Log.Debug($"Couldn't intersect pick ray with gizmo axis plane.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void UpdatePositionDragging(in Vector3 newOrigin)
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
TrySetVector3ToInput(_transformable.TranslationInput, newOrigin);
|
|
InputValue value = _transformable.TranslationInput.Input.Value;
|
|
|
|
_inputCommandInFlight.AssignNewValue(value);
|
|
}
|
|
|
|
private static void CompletePositionDragging()
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
UndoRedoStack.Add(_inputCommandInFlight);
|
|
_inputCommandInFlight = null;
|
|
|
|
_draggedGizmoPart = GizmoParts.None;
|
|
_draggedTransformable = null;
|
|
_dragInteractionWindowId = 0;
|
|
_dragNotStopped = false;
|
|
}
|
|
|
|
private static Vector3 GetNewOffsetInObject()
|
|
{
|
|
Debug.Assert(_canvas != null);
|
|
|
|
Vector2 newOriginInScreen = _mousePosInScreen - _initialOffsetToOrigin;
|
|
// transform back to object space
|
|
Matrix4x4.Invert(_objectToClipSpace, out var clipSpaceToObject);
|
|
var newOriginInCanvas = newOriginInScreen - _topLeftOnScreen;
|
|
var newOriginInViewport = _canvas.InverseTransformDirection(newOriginInCanvas);
|
|
var newOriginInClipSpace = new Vector4(2.0f * newOriginInViewport.X / _viewport.Width - 1.0f,
|
|
-(2.0f * newOriginInViewport.Y / _viewport.Height - 1.0f),
|
|
_originInClipSpace.Z, 1);
|
|
var newOriginInObject = Vector4.Transform(newOriginInClipSpace, clipSpaceToObject);
|
|
Vector3 newTranslation = new Vector3(newOriginInObject.X, newOriginInObject.Y, newOriginInObject.Z) / newOriginInObject.W;
|
|
return new Vector3(newTranslation.X, newTranslation.Y, newTranslation.Z);
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
#region rotate ----------------------------------------------------------
|
|
private static bool HandleRotationGizmos(EvaluationContext context)
|
|
{
|
|
if (_transformable?.RotationInput == null)
|
|
return false;
|
|
|
|
var rotation = TryGetVectorFromInput(_transformable.RotationInput);
|
|
var yaw = rotation.Y.ToRadians();
|
|
var pitch = rotation.X.ToRadians();
|
|
|
|
// Create individual quaternions
|
|
var yawQ = Quaternion.CreateFromAxisAngle(Vector3.UnitY, yaw);
|
|
var pitchQ = Quaternion.CreateFromAxisAngle(Vector3.UnitX, pitch);
|
|
|
|
// Gimbal axes
|
|
var axisYaw = Vector3.UnitY;
|
|
var axisPitch = Vector3.Transform(Vector3.UnitX, yawQ);
|
|
var yawPitchQ = Quaternion.Concatenate(pitchQ, yawQ);
|
|
var axisRoll = Vector3.Transform(Vector3.UnitZ, yawPitchQ);
|
|
|
|
var isHovering = HandleRotationOnAxis(context, axisYaw, Color.Green, GizmoParts.RotationYAxis);
|
|
isHovering |= HandleRotationOnAxis(context,axisPitch, Color.Red, GizmoParts.RotationXAxis);
|
|
isHovering |= HandleRotationOnAxis(context,axisRoll, Color.Blue, GizmoParts.RotationZAxis);
|
|
isHovering |= HandleScreenRotation();
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
private static bool HandleRotationOnAxis(EvaluationContext context, Vector3 axis, Color color, GizmoParts mode)
|
|
{
|
|
const int circleSegments = 32;
|
|
var gizmoRadius = _gizmoLength * 0.6f;
|
|
|
|
var circlePoints = new Vector2[circleSegments];
|
|
|
|
// Create two perpendicular vectors to form the circle plane
|
|
Vector3 tangent1, tangent2;
|
|
if (MathF.Abs(Vector3.Dot(axis, Vector3.UnitZ)) > 0.999f)
|
|
{
|
|
tangent1 = Vector3.UnitX;
|
|
tangent2 = Vector3.UnitY;
|
|
}
|
|
else
|
|
{
|
|
tangent1 = Vector3.Normalize(Vector3.Cross(axis, Vector3.UnitZ));
|
|
tangent2 = Vector3.Normalize(Vector3.Cross(axis, tangent1));
|
|
}
|
|
|
|
// Calculate circle points in 3D space then project to screen
|
|
for (int i = 0; i < circleSegments; i++)
|
|
{
|
|
float angle = (float)i / circleSegments * MathF.PI * 2;
|
|
Vector3 point3D = tangent1 * MathF.Cos(angle) * gizmoRadius +
|
|
tangent2 * MathF.Sin(angle) * gizmoRadius;
|
|
|
|
circlePoints[i] = LocalPosToScreenPos(point3D);
|
|
}
|
|
|
|
var isHovering = false;
|
|
|
|
if (!IsDragging)
|
|
{
|
|
isHovering = IsPointNearPolygon(_mousePosInScreen, circlePoints);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartRotationDragging(mode, axis);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == mode
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
UpdateRotationDragging(_draggedRotationAxis);
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompleteRotationDragging();
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
Vector3[] points3D = new Vector3[circleSegments];
|
|
Vector2[] points2D = new Vector2[circleSegments];
|
|
// Recompute view vector every frame
|
|
|
|
Matrix4x4.Invert(context.WorldToCamera, out var cameraToWorld);
|
|
Vector3 cameraWorldPos = Vector3.Transform(Vector3.Zero, cameraToWorld);
|
|
Vector3 dirWorld = Vector3.Normalize(_initialOriginWorld - cameraWorldPos);
|
|
_viewDirLocal = Vector3.TransformNormal(dirWorld, _initialObjectToLocal);
|
|
|
|
for (int i = 0; i < circleSegments; i++)
|
|
{
|
|
float angle = i / (float)circleSegments * MathF.PI * 2;
|
|
float cos = MathF.Cos(angle);
|
|
float sin = MathF.Sin(angle);
|
|
|
|
Vector3 p3D = tangent1 * cos * gizmoRadius + tangent2 * sin * gizmoRadius;
|
|
points3D[i] = p3D;
|
|
points2D[i] = LocalPosToScreenPos(p3D);
|
|
}
|
|
|
|
for (int i = 0; i < circleSegments; i++)
|
|
{
|
|
int next = (i + 1) % circleSegments;
|
|
|
|
Vector3 midPoint3D = (points3D[i] + points3D[next]) * 0.5f;
|
|
float facing = Vector3.Dot(midPoint3D, _viewDirLocal);
|
|
|
|
float alpha = facing >= 0 ? 0.3f : 1.0f;
|
|
|
|
var segColor = color;
|
|
segColor.Rgba.W = alpha;
|
|
|
|
_drawList.AddLine(points2D[i], points2D[next], segColor, isHovering ? 3 : 2);
|
|
}
|
|
|
|
if (_draggedGizmoPart == mode &&
|
|
_draggedTransformable == _transformable &&
|
|
_dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
Vector3 initialWorldPos = _initialRotationVector * gizmoRadius * 1.05f;
|
|
Vector3 currentWorldPos = _currentRotationVector * gizmoRadius * 1.05f;
|
|
|
|
Vector2 initialScreenPos = LocalPosToScreenPos(initialWorldPos);
|
|
Vector2 currentScreenPos = LocalPosToScreenPos(currentWorldPos);
|
|
|
|
float markerRadius = 5.0f;
|
|
|
|
|
|
_drawList.AddCircleFilled(initialScreenPos, markerRadius*0.6f, color);
|
|
_drawList.AddCircleFilled(currentScreenPos, markerRadius, color);
|
|
}
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
private static Vector3 _initialOriginWorld;
|
|
|
|
// Add this method to handle screen space rotation
|
|
private static bool HandleScreenRotation()
|
|
{
|
|
const float outerRadius = 2.0f;
|
|
const float innerRadius = 1.8f;
|
|
|
|
var outerCirclePoints = new Vector2[32];
|
|
var innerCirclePoints = new Vector2[32];
|
|
|
|
// Calculate circle points in screen space
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
float angle = (float)i / 32 * MathF.PI * 2;
|
|
outerCirclePoints[i] = _originInScreen + new Vector2(
|
|
MathF.Cos(angle) * outerRadius,
|
|
MathF.Sin(angle) * outerRadius);
|
|
|
|
innerCirclePoints[i] = _originInScreen + new Vector2(
|
|
MathF.Cos(angle) * innerRadius,
|
|
MathF.Sin(angle) * innerRadius);
|
|
}
|
|
|
|
var isHovering = false;
|
|
|
|
if (!IsDragging)
|
|
{
|
|
// Check if mouse is in the ring between inner and outer circles
|
|
isHovering = IsPointInRing(_mousePosInScreen, _originInScreen, innerRadius, outerRadius);
|
|
|
|
if (isHovering && ImGui.IsMouseClicked(ImGuiMouseButton.Left))
|
|
{
|
|
StartRotationDragging(GizmoParts.RotationScreen, Vector3.Zero);
|
|
}
|
|
}
|
|
else if (_draggedGizmoPart == GizmoParts.RotationScreen
|
|
&& _draggedTransformable == _transformable
|
|
&& _dragInteractionWindowId == ImGui.GetID(""))
|
|
{
|
|
isHovering = true;
|
|
UpdateScreenRotationDragging();
|
|
|
|
if (ImGui.IsMouseReleased(ImGuiMouseButton.Left))
|
|
{
|
|
CompleteRotationDragging();
|
|
}
|
|
}
|
|
|
|
if (_renderGizmo)
|
|
{
|
|
// Draw screen rotation ring
|
|
var color = UiColors.StatusAnimated;
|
|
color.Rgba.W = isHovering ? 0.8f : 0.6f;
|
|
|
|
for (int i = 0; i < 32; i++)
|
|
{
|
|
int next = (i + 1) % 32;
|
|
_drawList.AddQuad(
|
|
outerCirclePoints[i],
|
|
outerCirclePoints[next],
|
|
innerCirclePoints[next],
|
|
innerCirclePoints[i],
|
|
color);
|
|
}
|
|
}
|
|
|
|
return isHovering;
|
|
}
|
|
|
|
private static void StartRotationDragging(GizmoParts mode, Vector3 axis)
|
|
{
|
|
Debug.Assert(_instance?.Parent != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
_draggedGizmoPart = mode;
|
|
_inputCommandInFlight = new ChangeInputValueCommand(
|
|
_instance.Parent.Symbol,
|
|
_instance.SymbolChildId,
|
|
_transformable.RotationInput.Input,
|
|
_transformable.RotationInput.Input.Value);
|
|
|
|
_draggedTransformable = _transformable;
|
|
_dragInteractionWindowId = ImGui.GetID("");
|
|
_initialOrigin = _localToObject.Translation;
|
|
_initialRotation = TryGetVectorFromInput(_transformable.RotationInput);
|
|
_initialMousePos = _mousePosInScreen;
|
|
_draggedRotationAxis = axis;
|
|
|
|
// Get initial mouse pick ray in object space
|
|
var ray = GetPickRayInObject(_mousePosInScreen);
|
|
|
|
// Intersect with rotation plane
|
|
var plane = new Plane(axis, -Vector3.Dot(axis, _initialOrigin));
|
|
if (!PlaneIntersectRay(plane, ray, out var intersection))
|
|
{
|
|
Log.Warning("Couldn't intersect pick ray with rotation plane.");
|
|
_initialRotationVector = Vector3.UnitX; // fallback
|
|
return;
|
|
}
|
|
|
|
// Vector from gizmo origin to intersection, normalized
|
|
_initialRotationVector = Vector3.Normalize(intersection - _initialOrigin);
|
|
}
|
|
|
|
private static void UpdateRotationDragging(Vector3 axis)
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
var ray = GetPickRayInObject(_mousePosInScreen);
|
|
var plane = new Plane(axis, -Vector3.Dot(axis, _initialOrigin));
|
|
|
|
if (!PlaneIntersectRay(plane, ray, out var intersection))
|
|
return;
|
|
|
|
var currentVector = Vector3.Normalize(intersection - _initialOrigin);
|
|
_currentRotationVector = currentVector;
|
|
|
|
// Compute signed angle between initial and current vectors
|
|
float angleRad = MathF.Atan2(
|
|
Vector3.Dot(axis, Vector3.Cross(_initialRotationVector, currentVector)),
|
|
Vector3.Dot(_initialRotationVector, currentVector)
|
|
);
|
|
float angleDeg = angleRad * (180f / MathF.PI);
|
|
Vector3 newRotation = _initialRotation;
|
|
|
|
var snap = ImGui.GetIO().KeyCtrl;
|
|
|
|
switch (_draggedGizmoPart)
|
|
{
|
|
case GizmoParts.RotationXAxis:
|
|
newRotation.X += angleDeg;
|
|
if (snap)
|
|
newRotation.X = MathF.Round(newRotation.X/15)*15;
|
|
break;
|
|
case GizmoParts.RotationYAxis:
|
|
newRotation.Y += angleDeg;
|
|
if(snap)
|
|
newRotation.Y = MathF.Round(newRotation.Y/15)*15;
|
|
break;
|
|
case GizmoParts.RotationZAxis:
|
|
newRotation.Z += angleDeg;
|
|
if(snap)
|
|
newRotation.Z = MathF.Round(newRotation.Z/15)*15;
|
|
break;
|
|
default:
|
|
Log.Debug("No valid gizmo part for rotation.");
|
|
break;
|
|
}
|
|
|
|
TrySetVector3ToInput(_transformable.RotationInput, newRotation);
|
|
_inputCommandInFlight.AssignNewValue(_transformable.RotationInput.Input.Value);
|
|
}
|
|
|
|
private static bool PlaneIntersectRay(Plane plane, Ray ray, out Vector3 intersection)
|
|
{
|
|
float denom = Vector3.Dot(plane.Normal, ray.Direction);
|
|
if (MathF.Abs(denom) < 1e-6f)
|
|
{
|
|
intersection = Vector3.Zero;
|
|
return false;
|
|
}
|
|
|
|
float t = -(Vector3.Dot(plane.Normal, ray.Origin) + plane.D) / denom;
|
|
intersection = ray.Origin + ray.Direction * t;
|
|
return t >= 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
private static void UpdateScreenRotationDragging()
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
Debug.Assert(_transformable != null);
|
|
|
|
// For screen rotation, use circular motion around the gizmo center
|
|
Vector2 initialDir = Vector2.Normalize(_initialMousePos - _originInScreen);
|
|
Vector2 currentDir = Vector2.Normalize(_mousePosInScreen - _originInScreen);
|
|
|
|
// Calculate the angle between the two directions
|
|
float dot = Vector2.Dot(initialDir, currentDir);
|
|
float det = initialDir.X * currentDir.Y - initialDir.Y * currentDir.X;
|
|
float angleDelta = MathF.Atan2(det, dot) * (180f / MathF.PI);
|
|
|
|
// Apply to all axes equally for screen rotation, or choose one axis
|
|
Vector3 newRotation = _initialRotation;
|
|
newRotation.Z += angleDelta; // Apply to Z-axis for screen rotation
|
|
|
|
TrySetVector3ToInput(_transformable.RotationInput, newRotation);
|
|
_inputCommandInFlight.AssignNewValue(_transformable.RotationInput.Input.Value);
|
|
}
|
|
|
|
private static void CompleteRotationDragging()
|
|
{
|
|
Debug.Assert(_inputCommandInFlight != null);
|
|
UndoRedoStack.Add(_inputCommandInFlight);
|
|
_inputCommandInFlight = null;
|
|
|
|
_draggedGizmoPart = GizmoParts.None;
|
|
_draggedTransformable = null;
|
|
_dragInteractionWindowId = 0;
|
|
_dragNotStopped = false;
|
|
}
|
|
|
|
// Add this helper method to check if point is near a polygon
|
|
private static bool IsPointNearPolygon(Vector2 point, Vector2[] polygon, float threshold = 5f)
|
|
{
|
|
for (int i = 0; i < polygon.Length; i++)
|
|
{
|
|
int next = (i + 1) % polygon.Length;
|
|
if (IsPointOnLine(point, polygon[i], polygon[next], threshold))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Add this helper method to check if point is in a ring
|
|
private static bool IsPointInRing(Vector2 point, Vector2 center, float innerRadius, float outerRadius)
|
|
{
|
|
float distanceSquared = Vector2.DistanceSquared(point, center);
|
|
return distanceSquared >= innerRadius * innerRadius &&
|
|
distanceSquared <= outerRadius * outerRadius;
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region setting helpers -----------------------------------------
|
|
|
|
private static Vector3 TryGetVectorFromInput(IInputSlot input, float defaultValue = 0f)
|
|
{
|
|
return input switch
|
|
{
|
|
InputSlot<System.Numerics.Vector3> vec3Input => vec3Input.Value,
|
|
InputSlot<System.Numerics.Vector2> vec2Input => new Vector3(vec2Input.Value.X, vec2Input.Value.Y, defaultValue),
|
|
_ => new Vector3(defaultValue, defaultValue, defaultValue)
|
|
};
|
|
}
|
|
|
|
private static void TrySetVector3ToInput(IInputSlot input, Vector3 vector3)
|
|
{
|
|
switch (input)
|
|
{
|
|
case InputSlot<System.Numerics.Vector3> vec3Input:
|
|
vec3Input.SetTypedInputValue(vector3);
|
|
break;
|
|
case InputSlot<System.Numerics.Vector2> vec2Input:
|
|
vec2Input.SetTypedInputValue(new Vector2(vector3.X, vector3.Y));
|
|
break;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region math
|
|
private static Ray GetPickRayInObject(Vector2 posInScreen)
|
|
{
|
|
Debug.Assert(_canvas != null);
|
|
|
|
Matrix4x4.Invert(_objectToClipSpace, out var clipSpaceToObject);
|
|
var newOriginInCanvas = posInScreen - _topLeftOnScreen;
|
|
var newOriginInViewport = _canvas.InverseTransformDirection(newOriginInCanvas);
|
|
|
|
float xInClipSpace = 2.0f * newOriginInViewport.X / _viewport.Width - 1.0f;
|
|
float yInClipSpace = -(2.0f * newOriginInViewport.Y / _viewport.Height - 1.0f);
|
|
|
|
var rayStartInClipSpace = new Vector3(xInClipSpace, yInClipSpace, 0);
|
|
var rayStartInObject = GraphicsMath.TransformCoordinate(rayStartInClipSpace, clipSpaceToObject);
|
|
|
|
var rayEndInClipSpace = new Vector3(xInClipSpace, yInClipSpace, 1);
|
|
var rayEndInObject = GraphicsMath.TransformCoordinate(rayEndInClipSpace, clipSpaceToObject);
|
|
|
|
var rayDir = (rayEndInObject - rayStartInObject);
|
|
//rayDir = Vector3.Normalize(rayDir);
|
|
|
|
return new Ray(rayStartInObject, rayDir);
|
|
}
|
|
|
|
// Calculates the scale for a gizmo based on the distance to the cam
|
|
private static float CalcGizmoScale(EvaluationContext context, in Matrix4x4 localToObject, float width, float height, float fovInDegree,
|
|
float gizmoSize)
|
|
{
|
|
var localToCamera = localToObject * context.ObjectToWorld * context.WorldToCamera;
|
|
var distance = localToCamera.Translation.Length(); // distance of local origin to cam
|
|
var denom = Math.Sqrt(width * width + height * height) * Math.Tan(fovInDegree.ToRadians());
|
|
return (float)Math.Max(0.0001, (distance / denom) * gizmoSize);
|
|
}
|
|
|
|
private static Vector2 LocalPosToScreenPos(Vector3 posInLocal)
|
|
{
|
|
Debug.Assert(_canvas != null);
|
|
|
|
var homogenousPosInLocal = new Vector4(posInLocal.X, posInLocal.Y, posInLocal.Z, 1);
|
|
Vector4 originInClipSpace = Vector4.Transform(homogenousPosInLocal, _localToClipSpace);
|
|
Vector3 posInNdc = new Vector3(originInClipSpace.X, originInClipSpace.Y, originInClipSpace.Z) / originInClipSpace.W;
|
|
var viewports = ResourceManager.Device.ImmediateContext.Rasterizer.GetViewports<SharpDX.Mathematics.Interop.RawViewportF>();
|
|
var viewport = viewports[0];
|
|
var originInViewport = new Vector2(viewport.Width * (posInNdc.X * 0.5f + 0.5f),
|
|
viewport.Height * (1.0f - (posInNdc.Y * 0.5f + 0.5f)));
|
|
|
|
var posInCanvas = _canvas.TransformDirection(originInViewport);
|
|
return _topLeftOnScreen + posInCanvas;
|
|
}
|
|
|
|
// Update the GetPlaneForDragMode method to handle scale modes
|
|
private static Plane GetPlaneForDragMode(GizmoParts mode, Vector3 normDir, Vector3 origin)
|
|
{
|
|
Vector3 firstAxis, secondAxis;
|
|
|
|
switch (mode)
|
|
{
|
|
case GizmoParts.PositionXAxis:
|
|
case GizmoParts.ScaleXAxis:
|
|
{
|
|
firstAxis = Vector3.UnitX;
|
|
secondAxis = Math.Abs(Vector3.Dot(normDir, Vector3.UnitY)) <
|
|
Math.Abs(Vector3.Dot(normDir, Vector3.UnitZ))
|
|
? Vector3.UnitY
|
|
: Vector3.UnitZ;
|
|
break;
|
|
}
|
|
case GizmoParts.PositionYAxis:
|
|
case GizmoParts.ScaleYAxis:
|
|
{
|
|
firstAxis = Vector3.UnitY;
|
|
secondAxis = Math.Abs(Vector3.Dot(normDir, Vector3.UnitX)) <
|
|
Math.Abs(Vector3.Dot(normDir, Vector3.UnitZ))
|
|
? Vector3.UnitX
|
|
: Vector3.UnitZ;
|
|
break;
|
|
}
|
|
case GizmoParts.PositionZAxis:
|
|
case GizmoParts.ScaleZAxis:
|
|
{
|
|
firstAxis = Vector3.UnitZ;
|
|
secondAxis = Math.Abs(Vector3.Dot(normDir, Vector3.UnitX)) <
|
|
Math.Abs(Vector3.Dot(normDir, Vector3.UnitY))
|
|
? Vector3.UnitX
|
|
: Vector3.UnitY;
|
|
break;
|
|
}
|
|
case GizmoParts.PositionOnXyPlane:
|
|
case GizmoParts.ScaleOnXyPlane:
|
|
firstAxis = Vector3.UnitX;
|
|
secondAxis = Vector3.UnitY;
|
|
break;
|
|
case GizmoParts.PositionOnXzPlane:
|
|
case GizmoParts.ScaleOnXzPlane:
|
|
firstAxis = Vector3.UnitX;
|
|
secondAxis = Vector3.UnitZ;
|
|
break;
|
|
case GizmoParts.PositionOnYzPlane:
|
|
case GizmoParts.ScaleOnYzPlane:
|
|
firstAxis = Vector3.UnitY;
|
|
secondAxis = Vector3.UnitZ;
|
|
break;
|
|
case GizmoParts.ScaleUniform:
|
|
// For uniform scaling, use a plane perpendicular to the view direction
|
|
firstAxis = Vector3.UnitX;
|
|
secondAxis = Vector3.UnitY;
|
|
break;
|
|
default:
|
|
Log.Error($"{nameof(GetPlaneForDragMode)}(...) called with wrong GizmoDraggingMode.");
|
|
firstAxis = Vector3.UnitX;
|
|
secondAxis = Vector3.UnitY;
|
|
break;
|
|
}
|
|
|
|
var point2 = origin + firstAxis;
|
|
var point3 = origin + secondAxis;
|
|
return Plane.CreateFromVertices(origin, point2, point3);
|
|
}
|
|
|
|
private static bool IsPointOnLine(Vector2 point, Vector2 lineStart, Vector2 lineEnd, float threshold = 3)
|
|
{
|
|
var rect = new ImRect(lineStart, lineEnd).MakePositive();
|
|
rect.Expand(threshold);
|
|
if (!rect.Contains(point))
|
|
return false;
|
|
|
|
var positionOnLine = GetClosestPointOnLine(point, lineStart, lineEnd);
|
|
return Vector2.Distance(point, positionOnLine) <= threshold;
|
|
}
|
|
|
|
private static Vector2 GetClosestPointOnLine(Vector2 point, Vector2 lineStart, Vector2 lineEnd)
|
|
{
|
|
var v = (lineEnd - lineStart);
|
|
var vLen = v.Length();
|
|
|
|
var d = Vector2.Dot(v, point - lineStart) / vLen;
|
|
return lineStart + v * d / vLen;
|
|
}
|
|
|
|
private static bool IsPointInTriangle(Vector2 p, Vector2 p0, Vector2 p1, Vector2 p2)
|
|
{
|
|
var a = 0.5f * (-p1.Y * p2.X + p0.Y * (-p1.X + p2.X) + p0.X * (p1.Y - p2.Y) + p1.X * p2.Y);
|
|
var sign = a < 0 ? -1 : 1;
|
|
var s = (p0.Y * p2.X - p0.X * p2.Y + (p2.Y - p0.Y) * p.X + (p0.X - p2.X) * p.Y) * sign;
|
|
var t = (p0.X * p1.Y - p0.Y * p1.X + (p0.Y - p1.Y) * p.X + (p1.X - p0.X) * p.Y) * sign;
|
|
|
|
return s > 0 && t > 0 && (s + t) < 2 * a * sign;
|
|
}
|
|
|
|
private static bool IsPointInQuad(Vector2 p, Vector2[] corners)
|
|
{
|
|
return IsPointInTriangle(p, corners[0], corners[1], corners[2])
|
|
|| IsPointInTriangle(p, corners[0], corners[2], corners[3]);
|
|
}
|
|
#endregion
|
|
|
|
#region too many members
|
|
|
|
|
|
public enum GizmoParts
|
|
{
|
|
None,
|
|
PositionInScreenPlane,
|
|
PositionXAxis,
|
|
PositionYAxis,
|
|
PositionZAxis,
|
|
PositionOnXyPlane,
|
|
PositionOnXzPlane,
|
|
PositionOnYzPlane,
|
|
|
|
// Scale gizmo parts
|
|
ScaleXAxis,
|
|
ScaleYAxis,
|
|
ScaleZAxis,
|
|
ScaleUniform,
|
|
ScaleOnXyPlane,
|
|
ScaleOnXzPlane,
|
|
ScaleOnYzPlane,
|
|
|
|
// Rotation gizmo parts
|
|
RotationXAxis,
|
|
RotationYAxis,
|
|
RotationZAxis,
|
|
RotationScreen,
|
|
}
|
|
|
|
#endregion
|
|
|
|
private static Instance? _instance;
|
|
private static ITransformable? _transformable;
|
|
|
|
private static GizmoParts _draggedGizmoPart = GizmoParts.None;
|
|
private static ITransformable? _draggedTransformable;
|
|
private static ChangeInputValueCommand? _inputCommandInFlight;
|
|
|
|
private static float _centerPadding;
|
|
private static float _gizmoLength;
|
|
private static float _planeGizmoSize;
|
|
|
|
private static ImDrawListPtr _drawList = null;
|
|
private static bool _isDrawListValid;
|
|
|
|
private static uint _dragInteractionWindowId;
|
|
|
|
private static readonly HashSet<ITransformable> _selectedTransformables = [];
|
|
|
|
private static SharpDX.Mathematics.Interop.RawViewportF _viewport;
|
|
private static Vector2 _mousePosInScreen;
|
|
private static ImageOutputCanvas? _canvas;
|
|
private static Vector2 _topLeftOnScreen;
|
|
|
|
private static Vector2 _originInScreen;
|
|
private static Vector3 _originInClipSpace;
|
|
private static bool _renderGizmo;
|
|
|
|
// Keep values when interaction started
|
|
private static Vector3 _initialOrigin;
|
|
private static Vector2 _initialOffsetToOrigin;
|
|
private static Matrix4x4 _initialObjectToLocal;
|
|
private static Vector3 _initialIntersectionPoint;
|
|
|
|
private static Plane _plane;
|
|
|
|
private static Matrix4x4 _objectToClipSpace;
|
|
private static Matrix4x4 _objectToWorld;
|
|
private static Matrix4x4 _localToObject;
|
|
private static Matrix4x4 _localToClipSpace;
|
|
|
|
private static Vector3 _viewDirLocal;
|
|
|
|
// Scale gizmo state
|
|
private static Vector3 _initialScale;
|
|
|
|
private static Vector3 _currentRotationVector;
|
|
private static Vector3 _initialRotation;
|
|
private static Vector3 _initialRotationVector;
|
|
private static Vector3 _draggedRotationAxis;
|
|
private static Vector2 _initialMousePos;
|
|
} |