mirror of
https://github.com/BotChain-Robots/ui.git
synced 2026-07-08 15:07:22 +02:00
Leo Qu
854
Assets/IK/PositionControlGizmo.cs
Normal file
854
Assets/IK/PositionControlGizmo.cs
Normal file
@@ -0,0 +1,854 @@
|
||||
using UnityEngine;
|
||||
using UnityEngine.EventSystems;
|
||||
using UnityEngine.UI;
|
||||
using TMPro;
|
||||
public class PositionControlGizmo : MonoBehaviour
|
||||
{
|
||||
[Header("Gizmo Settings")]
|
||||
public float arrowLength = 1.0f;
|
||||
public float arrowHeadSize = 0.25f;
|
||||
public float lineWidth = 0.04f;
|
||||
public float clickableRadius = 0.5f;
|
||||
public float screenSpaceClickThreshold = 30f;
|
||||
|
||||
[Header("Colors")]
|
||||
public Color xAxisColor = Color.red;
|
||||
public Color yAxisColor = Color.green;
|
||||
public Color zAxisColor = Color.blue;
|
||||
public Color hoverColor = Color.yellow;
|
||||
public Color selectedColor = new Color(1f, 1f, 0f, 0.8f);
|
||||
|
||||
[Header("References")]
|
||||
public Camera mainCamera;
|
||||
public ModulePositionController positionController;
|
||||
|
||||
[Header("Placement")]
|
||||
[Tooltip("If enabled, the gizmo is drawn at the selected module's visual center (renderer/collider bounds center), rather than transform.position.")]
|
||||
public bool centerOnModuleBounds = true;
|
||||
[Tooltip("World-space offset added to gizmo origin.")]
|
||||
public Vector3 gizmoWorldOffset = Vector3.zero;
|
||||
|
||||
private ModuleBase targetModule;
|
||||
private int hoveredAxis = -1;
|
||||
private int previousHoveredAxis = -1;
|
||||
private int selectedAxis = -1;
|
||||
private Color[] previousColors = new Color[3];
|
||||
private bool isDragging = false;
|
||||
private bool gizmoWasClickedThisFrame = false;
|
||||
|
||||
private Vector3 axisDragStartGizmoOrigin;
|
||||
private Vector3 axisDragStartModulePosition;
|
||||
private Vector2 axisDragStartMousePosition;
|
||||
[Header("Axis Drag Settings")]
|
||||
public float axisDragSensitivity = 0.01f;
|
||||
|
||||
public bool WasGizmoClicked()
|
||||
{
|
||||
return gizmoWasClickedThisFrame;
|
||||
}
|
||||
|
||||
public void RefreshGizmoVisibility()
|
||||
{
|
||||
UpdateGizmoVisibility();
|
||||
}
|
||||
|
||||
private LineRenderer xAxisLine;
|
||||
private LineRenderer yAxisLine;
|
||||
private LineRenderer zAxisLine;
|
||||
private GameObject gizmoContainer;
|
||||
|
||||
private Transform xAxisHead;
|
||||
private Transform yAxisHead;
|
||||
private Transform zAxisHead;
|
||||
private static Mesh _coneMesh;
|
||||
|
||||
void Start()
|
||||
{
|
||||
if (mainCamera == null)
|
||||
{
|
||||
mainCamera = Camera.main;
|
||||
if (mainCamera == null)
|
||||
{
|
||||
mainCamera = FindObjectOfType<Camera>();
|
||||
}
|
||||
}
|
||||
|
||||
if (positionController == null)
|
||||
{
|
||||
positionController = GetComponentInParent<ModulePositionController>();
|
||||
if (positionController == null)
|
||||
{
|
||||
positionController = FindObjectOfType<ModulePositionController>();
|
||||
}
|
||||
if (positionController != null && positionController.gizmo == null)
|
||||
{
|
||||
positionController.gizmo = this;
|
||||
}
|
||||
}
|
||||
|
||||
previousColors[0] = xAxisColor;
|
||||
previousColors[1] = yAxisColor;
|
||||
previousColors[2] = zAxisColor;
|
||||
|
||||
FindGizmoLines();
|
||||
}
|
||||
|
||||
void FindGizmoLines()
|
||||
{
|
||||
if (gizmoContainer != null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Transform existingContainer = this.transform.Find("PositionControlGizmo");
|
||||
if (existingContainer != null)
|
||||
{
|
||||
gizmoContainer = existingContainer.gameObject;
|
||||
}
|
||||
else
|
||||
{
|
||||
gizmoContainer = new GameObject("PositionControlGizmo");
|
||||
gizmoContainer.transform.SetParent(this.transform);
|
||||
gizmoContainer.transform.localPosition = Vector3.zero;
|
||||
gizmoContainer.transform.localRotation = Quaternion.identity;
|
||||
gizmoContainer.transform.localScale = Vector3.one;
|
||||
}
|
||||
|
||||
Transform xAxisTransform = gizmoContainer.transform.Find("XAxis");
|
||||
if (xAxisTransform == null)
|
||||
{
|
||||
GameObject xAxisObj = new GameObject("XAxis");
|
||||
xAxisObj.transform.SetParent(gizmoContainer.transform);
|
||||
xAxisObj.transform.localPosition = Vector3.zero;
|
||||
xAxisObj.transform.localRotation = Quaternion.identity;
|
||||
xAxisObj.transform.localScale = Vector3.one;
|
||||
xAxisLine = xAxisObj.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(xAxisLine, xAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
xAxisLine = xAxisTransform.GetComponent<LineRenderer>();
|
||||
if (xAxisLine == null)
|
||||
{
|
||||
xAxisLine = xAxisTransform.gameObject.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(xAxisLine, xAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
SetupLineRenderer(xAxisLine, xAxisColor);
|
||||
}
|
||||
}
|
||||
|
||||
Transform yAxisTransform = gizmoContainer.transform.Find("YAxis");
|
||||
if (yAxisTransform == null)
|
||||
{
|
||||
GameObject yAxisObj = new GameObject("YAxis");
|
||||
yAxisObj.transform.SetParent(gizmoContainer.transform);
|
||||
yAxisObj.transform.localPosition = Vector3.zero;
|
||||
yAxisObj.transform.localRotation = Quaternion.identity;
|
||||
yAxisObj.transform.localScale = Vector3.one;
|
||||
yAxisLine = yAxisObj.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(yAxisLine, yAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
yAxisLine = yAxisTransform.GetComponent<LineRenderer>();
|
||||
if (yAxisLine == null)
|
||||
{
|
||||
yAxisLine = yAxisTransform.gameObject.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(yAxisLine, yAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
SetupLineRenderer(yAxisLine, yAxisColor);
|
||||
}
|
||||
}
|
||||
|
||||
Transform zAxisTransform = gizmoContainer.transform.Find("ZAxis");
|
||||
if (zAxisTransform == null)
|
||||
{
|
||||
GameObject zAxisObj = new GameObject("ZAxis");
|
||||
zAxisObj.transform.SetParent(gizmoContainer.transform);
|
||||
zAxisObj.transform.localPosition = Vector3.zero;
|
||||
zAxisObj.transform.localRotation = Quaternion.identity;
|
||||
zAxisObj.transform.localScale = Vector3.one;
|
||||
zAxisLine = zAxisObj.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(zAxisLine, zAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
zAxisLine = zAxisTransform.GetComponent<LineRenderer>();
|
||||
if (zAxisLine == null)
|
||||
{
|
||||
zAxisLine = zAxisTransform.gameObject.AddComponent<LineRenderer>();
|
||||
SetupLineRenderer(zAxisLine, zAxisColor);
|
||||
}
|
||||
else
|
||||
{
|
||||
SetupLineRenderer(zAxisLine, zAxisColor);
|
||||
}
|
||||
}
|
||||
|
||||
xAxisHead = EnsureArrowHead(xAxisLine != null ? xAxisLine.transform : null, "Head");
|
||||
yAxisHead = EnsureArrowHead(yAxisLine != null ? yAxisLine.transform : null, "Head");
|
||||
zAxisHead = EnsureArrowHead(zAxisLine != null ? zAxisLine.transform : null, "Head");
|
||||
|
||||
gizmoContainer.SetActive(false);
|
||||
}
|
||||
|
||||
private Transform EnsureArrowHead(Transform axisTransform, string name)
|
||||
{
|
||||
if (axisTransform == null) return null;
|
||||
|
||||
Transform head = axisTransform.Find(name);
|
||||
if (head == null)
|
||||
{
|
||||
var go = new GameObject(name);
|
||||
go.transform.SetParent(axisTransform, false);
|
||||
head = go.transform;
|
||||
}
|
||||
|
||||
var mf = head.GetComponent<MeshFilter>();
|
||||
if (mf == null) mf = head.gameObject.AddComponent<MeshFilter>();
|
||||
|
||||
var mr = head.GetComponent<MeshRenderer>();
|
||||
if (mr == null) mr = head.gameObject.AddComponent<MeshRenderer>();
|
||||
|
||||
if (_coneMesh == null)
|
||||
{
|
||||
_coneMesh = CreateConeMesh(18);
|
||||
}
|
||||
mf.sharedMesh = _coneMesh;
|
||||
|
||||
if (axisTransform.TryGetComponent<LineRenderer>(out var lr) && lr.material != null)
|
||||
{
|
||||
mr.sharedMaterial = lr.material;
|
||||
}
|
||||
else
|
||||
{
|
||||
var mat = new Material(Shader.Find("Unlit/Color"));
|
||||
mat.color = Color.white;
|
||||
mr.sharedMaterial = mat;
|
||||
}
|
||||
|
||||
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
||||
mr.receiveShadows = false;
|
||||
|
||||
return head;
|
||||
}
|
||||
|
||||
private static Mesh CreateConeMesh(int segments)
|
||||
{
|
||||
segments = Mathf.Clamp(segments, 6, 64);
|
||||
|
||||
var mesh = new Mesh();
|
||||
mesh.name = "PositionControlGizmo_Cone";
|
||||
|
||||
int vertCount = segments + 2; // base ring + base center + tip
|
||||
Vector3[] v = new Vector3[vertCount];
|
||||
Vector3[] n = new Vector3[vertCount];
|
||||
Vector2[] uv = new Vector2[vertCount];
|
||||
|
||||
int baseCenter = segments;
|
||||
int tip = segments + 1;
|
||||
|
||||
float radius = 0.5f;
|
||||
for (int i = 0; i < segments; i++)
|
||||
{
|
||||
float a = (i / (float)segments) * Mathf.PI * 2f;
|
||||
float x = Mathf.Cos(a) * radius;
|
||||
float y = Mathf.Sin(a) * radius;
|
||||
v[i] = new Vector3(x, y, 0f);
|
||||
n[i] = (new Vector3(x, y, radius)).normalized; // approximate
|
||||
uv[i] = new Vector2(i / (float)segments, 0f);
|
||||
}
|
||||
|
||||
v[baseCenter] = new Vector3(0f, 0f, 0f);
|
||||
n[baseCenter] = Vector3.back;
|
||||
uv[baseCenter] = new Vector2(0.5f, 0f);
|
||||
|
||||
v[tip] = new Vector3(0f, 0f, 1f);
|
||||
n[tip] = Vector3.forward;
|
||||
uv[tip] = new Vector2(0.5f, 1f);
|
||||
|
||||
int[] tris = new int[segments * 6];
|
||||
int t = 0;
|
||||
for (int i = 0; i < segments; i++)
|
||||
{
|
||||
int next = (i + 1) % segments;
|
||||
|
||||
tris[t++] = i;
|
||||
tris[t++] = next;
|
||||
tris[t++] = tip;
|
||||
|
||||
tris[t++] = next;
|
||||
tris[t++] = i;
|
||||
tris[t++] = baseCenter;
|
||||
}
|
||||
|
||||
mesh.vertices = v;
|
||||
mesh.normals = n;
|
||||
mesh.uv = uv;
|
||||
mesh.triangles = tris;
|
||||
mesh.RecalculateBounds();
|
||||
return mesh;
|
||||
}
|
||||
|
||||
void OnEnable()
|
||||
{
|
||||
UpdateGizmoVisibility();
|
||||
}
|
||||
|
||||
void UpdateGizmoVisibility()
|
||||
{
|
||||
if (gizmoContainer != null)
|
||||
{
|
||||
if (positionController != null)
|
||||
{
|
||||
targetModule = positionController.selectedModule;
|
||||
}
|
||||
|
||||
bool shouldShow = targetModule != null && this.enabled;
|
||||
|
||||
if (shouldShow)
|
||||
{
|
||||
gizmoContainer.SetActive(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
gizmoContainer.SetActive(false);
|
||||
}
|
||||
|
||||
if (!shouldShow)
|
||||
{
|
||||
hoveredAxis = -1;
|
||||
selectedAxis = -1;
|
||||
isDragging = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
FindGizmoLines();
|
||||
}
|
||||
}
|
||||
|
||||
void SetupLineRenderer(LineRenderer lr, Color color)
|
||||
{
|
||||
Shader unlitShader = Shader.Find("Unlit/Color");
|
||||
Material gizmoMaterial;
|
||||
|
||||
if (unlitShader != null)
|
||||
{
|
||||
gizmoMaterial = new Material(unlitShader);
|
||||
gizmoMaterial.color = color;
|
||||
gizmoMaterial.SetInt("_ZTest", (int)UnityEngine.Rendering.CompareFunction.Always);
|
||||
gizmoMaterial.SetInt("_ZWrite", 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
gizmoMaterial = new Material(Shader.Find("Sprites/Default"));
|
||||
gizmoMaterial.color = color;
|
||||
}
|
||||
|
||||
lr.material = gizmoMaterial;
|
||||
lr.startColor = color;
|
||||
lr.endColor = color;
|
||||
lr.startWidth = lineWidth;
|
||||
lr.endWidth = lineWidth;
|
||||
lr.positionCount = 2;
|
||||
lr.useWorldSpace = true;
|
||||
lr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
||||
lr.receiveShadows = false;
|
||||
|
||||
lr.sortingOrder = 1000;
|
||||
}
|
||||
|
||||
void UpdateGizmoVisualization()
|
||||
{
|
||||
if (targetModule == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (gizmoContainer == null)
|
||||
{
|
||||
FindGizmoLines();
|
||||
if (gizmoContainer == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (xAxisLine == null || yAxisLine == null || zAxisLine == null)
|
||||
{
|
||||
FindGizmoLines();
|
||||
if (xAxisLine == null || yAxisLine == null || zAxisLine == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Vector3 gizmoOrigin = GetGizmoOrigin();
|
||||
|
||||
Color xColor = GetAxisColor(0);
|
||||
if (previousColors[0] != xColor)
|
||||
{
|
||||
previousColors[0] = xColor;
|
||||
}
|
||||
UpdateAxisLine(xAxisLine, gizmoOrigin, GetAxisDirection(0), arrowLength, xColor);
|
||||
UpdateAxisHead(xAxisHead, gizmoOrigin, GetAxisDirection(0), arrowLength, arrowHeadSize, xColor);
|
||||
|
||||
Color yColor = GetAxisColor(1);
|
||||
if (previousColors[1] != yColor)
|
||||
{
|
||||
previousColors[1] = yColor;
|
||||
}
|
||||
UpdateAxisLine(yAxisLine, gizmoOrigin, GetAxisDirection(1), arrowLength, yColor);
|
||||
UpdateAxisHead(yAxisHead, gizmoOrigin, GetAxisDirection(1), arrowLength, arrowHeadSize, yColor);
|
||||
|
||||
Color zColor = GetAxisColor(2);
|
||||
if (previousColors[2] != zColor)
|
||||
{
|
||||
previousColors[2] = zColor;
|
||||
}
|
||||
UpdateAxisLine(zAxisLine, gizmoOrigin, GetAxisDirection(2), arrowLength, zColor);
|
||||
UpdateAxisHead(zAxisHead, gizmoOrigin, GetAxisDirection(2), arrowLength, arrowHeadSize, zColor);
|
||||
}
|
||||
|
||||
void UpdateAxisHead(Transform head, Vector3 start, Vector3 direction, float length, float headSize, Color color)
|
||||
{
|
||||
if (head == null) return;
|
||||
|
||||
Vector3 dir = direction.normalized;
|
||||
Vector3 end = start + dir * length;
|
||||
|
||||
head.position = end;
|
||||
head.rotation = Quaternion.LookRotation(dir, Vector3.up);
|
||||
head.localScale = new Vector3(headSize, headSize, headSize);
|
||||
|
||||
// Update head material color (shared with line renderer in most cases)
|
||||
var mr = head.GetComponent<MeshRenderer>();
|
||||
if (mr != null && mr.sharedMaterial != null)
|
||||
{
|
||||
if (mr.sharedMaterial.HasProperty("_Color"))
|
||||
mr.sharedMaterial.SetColor("_Color", color);
|
||||
mr.sharedMaterial.color = color;
|
||||
}
|
||||
}
|
||||
|
||||
void UpdateAxisLine(LineRenderer lr, Vector3 start, Vector3 direction, float length, Color color)
|
||||
{
|
||||
if (lr == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// Ensure LineRenderer is enabled
|
||||
if (!lr.enabled)
|
||||
{
|
||||
lr.enabled = true;
|
||||
}
|
||||
|
||||
|
||||
Vector3 end = start + direction.normalized * length;
|
||||
lr.SetPosition(0, start);
|
||||
lr.SetPosition(1, end);
|
||||
lr.startColor = color;
|
||||
lr.endColor = color;
|
||||
|
||||
// Also update material color (important for Unlit/Color shader)
|
||||
if (lr.material != null)
|
||||
{
|
||||
lr.material.color = color;
|
||||
// Also set _Color property explicitly (some shaders use this)
|
||||
if (lr.material.HasProperty("_Color"))
|
||||
{
|
||||
lr.material.SetColor("_Color", color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Update()
|
||||
{
|
||||
if (positionController != null)
|
||||
{
|
||||
targetModule = positionController.selectedModule;
|
||||
}
|
||||
|
||||
UpdateGizmoVisibility();
|
||||
|
||||
if (targetModule != null)
|
||||
{
|
||||
HandleGizmoInteraction();
|
||||
|
||||
UpdateGizmoVisualization();
|
||||
}
|
||||
else
|
||||
{
|
||||
hoveredAxis = -1;
|
||||
selectedAxis = -1;
|
||||
isDragging = false;
|
||||
}
|
||||
}
|
||||
|
||||
void HandleGizmoInteraction()
|
||||
{
|
||||
if (targetModule == null || mainCamera == null)
|
||||
{
|
||||
hoveredAxis = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
|
||||
{
|
||||
hoveredAxis = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
Vector3 gizmoOrigin = GetGizmoOrigin();
|
||||
Vector2 mouseScreenPos = Input.mousePosition;
|
||||
|
||||
float closestDistance = float.MaxValue;
|
||||
int closestAxis = -1;
|
||||
|
||||
for (int axis = 0; axis < 3; axis++)
|
||||
{
|
||||
Vector3 axisDirection = GetAxisDirection(axis);
|
||||
Vector3 axisStart = gizmoOrigin;
|
||||
Vector3 axisEnd = gizmoOrigin + axisDirection * arrowLength;
|
||||
|
||||
Vector3 screenStart3D = mainCamera.WorldToScreenPoint(axisStart);
|
||||
Vector3 screenEnd3D = mainCamera.WorldToScreenPoint(axisEnd);
|
||||
|
||||
if (screenStart3D.z < 0 || screenEnd3D.z < 0)
|
||||
continue;
|
||||
|
||||
Vector2 screenStart = new Vector2(screenStart3D.x, screenStart3D.y);
|
||||
Vector2 screenEnd = new Vector2(screenEnd3D.x, screenEnd3D.y);
|
||||
|
||||
Vector2 closestPointOnLine = ClosestPointOnScreenLine(screenStart, screenEnd, mouseScreenPos);
|
||||
float screenDistance = Vector2.Distance(mouseScreenPos, closestPointOnLine);
|
||||
|
||||
float distanceToStart = Vector2.Distance(mouseScreenPos, screenStart);
|
||||
float minDistance = Mathf.Min(screenDistance, distanceToStart);
|
||||
|
||||
if (minDistance < screenSpaceClickThreshold && minDistance < closestDistance)
|
||||
{
|
||||
closestDistance = minDistance;
|
||||
closestAxis = axis;
|
||||
}
|
||||
}
|
||||
|
||||
int oldHoveredAxis = hoveredAxis;
|
||||
hoveredAxis = closestAxis;
|
||||
|
||||
if (hoveredAxis != oldHoveredAxis)
|
||||
{
|
||||
// no-op (hover state tracking only)
|
||||
}
|
||||
|
||||
gizmoWasClickedThisFrame = false;
|
||||
|
||||
HandleAxisBasedInteraction();
|
||||
}
|
||||
|
||||
void HandleAxisBasedInteraction()
|
||||
{
|
||||
if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
|
||||
{
|
||||
hoveredAxis = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
Vector3 gizmoOrigin = GetGizmoOrigin();
|
||||
Vector2 mouseScreenPos = Input.mousePosition;
|
||||
|
||||
if (Input.GetMouseButtonDown(0))
|
||||
{
|
||||
if (hoveredAxis >= 0)
|
||||
{
|
||||
selectedAxis = hoveredAxis;
|
||||
isDragging = true;
|
||||
axisDragStartGizmoOrigin = gizmoOrigin; // Store starting gizmo origin
|
||||
axisDragStartModulePosition = targetModule.transform.position; // Store module pivot position for IK targets
|
||||
axisDragStartMousePosition = mouseScreenPos; // Store starting mouse position
|
||||
gizmoWasClickedThisFrame = true; // Mark that gizmo was clicked
|
||||
|
||||
if (positionController != null)
|
||||
{
|
||||
positionController.OnGizmoClicked();
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (isDragging && selectedAxis >= 0 && Input.GetMouseButton(0))
|
||||
{
|
||||
ProcessUnityStyleAxisDrag();
|
||||
}
|
||||
else if (Input.GetMouseButtonUp(0))
|
||||
{
|
||||
if (isDragging)
|
||||
{
|
||||
isDragging = false;
|
||||
selectedAxis = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ProcessUnityStyleAxisDrag()
|
||||
{
|
||||
if (targetModule == null || mainCamera == null || positionController == null) return;
|
||||
|
||||
Vector2 currentMousePos = Input.mousePosition;
|
||||
Vector2 mouseDelta = currentMousePos - axisDragStartMousePosition;
|
||||
|
||||
float minMouseMovement = 2f; // Minimum pixels of movement required
|
||||
if (mouseDelta.magnitude < minMouseMovement)
|
||||
{
|
||||
return; // User just clicked without dragging - no movement
|
||||
}
|
||||
|
||||
Vector3 axisDirection = GetAxisDirection(selectedAxis);
|
||||
Vector3 gizmoOrigin = axisDragStartGizmoOrigin; // Use gizmo origin as reference for screen-space projection
|
||||
|
||||
Vector2 screenAxis = (Vector2)mainCamera.WorldToScreenPoint(gizmoOrigin + axisDirection) -
|
||||
(Vector2)mainCamera.WorldToScreenPoint(gizmoOrigin);
|
||||
screenAxis.Normalize();
|
||||
|
||||
float movementAlongAxis = Vector2.Dot(mouseDelta, screenAxis);
|
||||
|
||||
float worldMovement = movementAlongAxis * axisDragSensitivity;
|
||||
|
||||
if (positionController != null && positionController.ikController != null)
|
||||
{
|
||||
worldMovement *= positionController.ikController.dragSensitivity;
|
||||
}
|
||||
|
||||
// IMPORTANT: keep IK target based on module pivot (transform.position), not the visual gizmo origin.
|
||||
Vector3 currentPosition = targetModule.transform.position;
|
||||
Vector3 targetPosition = axisDragStartModulePosition + axisDirection * worldMovement;
|
||||
|
||||
float minMovementThreshold = 0.03f; // Minimum 3cm movement required
|
||||
float distanceToTarget = Vector3.Distance(targetPosition, currentPosition);
|
||||
|
||||
if (distanceToTarget < minMovementThreshold)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Vector3 intendedMovement = targetPosition - currentPosition;
|
||||
float intendedAxisMovement = Vector3.Dot(intendedMovement, axisDirection);
|
||||
float minAxisMovement = 0.02f; // Minimum 2cm movement along the selected axis
|
||||
|
||||
if (Mathf.Abs(intendedAxisMovement) < minAxisMovement)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (positionController.ikController != null)
|
||||
{
|
||||
bool success = positionController.ikController.SolveIK(targetPosition);
|
||||
|
||||
if (success)
|
||||
{
|
||||
Vector3 actualPosition = targetModule.transform.position;
|
||||
Vector3 actualMovement = actualPosition - axisDragStartModulePosition;
|
||||
float actualAxisMovement = Vector3.Dot(actualMovement, axisDirection);
|
||||
float actualMovementDistance = actualMovement.magnitude;
|
||||
|
||||
if (actualMovementDistance >= minMovementThreshold && Mathf.Abs(actualAxisMovement) >= minAxisMovement)
|
||||
{
|
||||
if (Mathf.Sign(actualAxisMovement) == Mathf.Sign(intendedAxisMovement))
|
||||
{
|
||||
axisDragStartModulePosition = actualPosition;
|
||||
axisDragStartGizmoOrigin = GetGizmoOrigin();
|
||||
axisDragStartMousePosition = currentMousePos;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Vector3 GetGizmoOrigin()
|
||||
{
|
||||
if (targetModule == null) return Vector3.zero;
|
||||
|
||||
Vector3 origin = targetModule.transform.position;
|
||||
if (!centerOnModuleBounds)
|
||||
return origin + gizmoWorldOffset;
|
||||
|
||||
bool hasBounds = false;
|
||||
Bounds b = default;
|
||||
|
||||
foreach (var r in GetRenderersOwnedByModule(targetModule))
|
||||
{
|
||||
if (r == null) continue;
|
||||
if (!hasBounds)
|
||||
{
|
||||
b = r.bounds;
|
||||
hasBounds = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
b.Encapsulate(r.bounds);
|
||||
}
|
||||
}
|
||||
|
||||
if (!hasBounds)
|
||||
{
|
||||
foreach (var c in GetCollidersOwnedByModule(targetModule))
|
||||
{
|
||||
if (c == null) continue;
|
||||
if (!hasBounds)
|
||||
{
|
||||
b = c.bounds;
|
||||
hasBounds = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
b.Encapsulate(c.bounds);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
origin = hasBounds ? b.center : origin;
|
||||
return origin + gizmoWorldOffset;
|
||||
}
|
||||
|
||||
static System.Collections.Generic.IEnumerable<Renderer> GetRenderersOwnedByModule(ModuleBase rootModule)
|
||||
{
|
||||
if (rootModule == null) yield break;
|
||||
Transform root = rootModule.transform;
|
||||
|
||||
var stack = new System.Collections.Generic.Stack<Transform>();
|
||||
stack.Push(root);
|
||||
|
||||
while (stack.Count > 0)
|
||||
{
|
||||
Transform t = stack.Pop();
|
||||
if (t == null) continue;
|
||||
|
||||
if (t != root)
|
||||
{
|
||||
ModuleBase other = t.GetComponent<ModuleBase>();
|
||||
if (other != null && other != rootModule)
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach (var r in t.GetComponents<Renderer>())
|
||||
if (r != null) yield return r;
|
||||
|
||||
for (int i = 0; i < t.childCount; i++)
|
||||
stack.Push(t.GetChild(i));
|
||||
}
|
||||
}
|
||||
|
||||
static System.Collections.Generic.IEnumerable<Collider> GetCollidersOwnedByModule(ModuleBase rootModule)
|
||||
{
|
||||
if (rootModule == null) yield break;
|
||||
Transform root = rootModule.transform;
|
||||
|
||||
var stack = new System.Collections.Generic.Stack<Transform>();
|
||||
stack.Push(root);
|
||||
|
||||
while (stack.Count > 0)
|
||||
{
|
||||
Transform t = stack.Pop();
|
||||
if (t == null) continue;
|
||||
|
||||
if (t != root)
|
||||
{
|
||||
ModuleBase other = t.GetComponent<ModuleBase>();
|
||||
if (other != null && other != rootModule)
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach (var c in t.GetComponents<Collider>())
|
||||
if (c != null) yield return c;
|
||||
|
||||
for (int i = 0; i < t.childCount; i++)
|
||||
stack.Push(t.GetChild(i));
|
||||
}
|
||||
}
|
||||
|
||||
Vector2 ClosestPointOnScreenLine(Vector2 lineStart, Vector2 lineEnd, Vector2 point)
|
||||
{
|
||||
Vector2 line = lineEnd - lineStart;
|
||||
float lineLength = line.magnitude;
|
||||
|
||||
if (lineLength < 0.001f)
|
||||
return lineStart;
|
||||
|
||||
line.Normalize();
|
||||
Vector2 pointToStart = point - lineStart;
|
||||
float projectionLength = Vector2.Dot(pointToStart, line);
|
||||
projectionLength = Mathf.Clamp(projectionLength, 0f, lineLength);
|
||||
|
||||
return lineStart + line * projectionLength;
|
||||
}
|
||||
|
||||
void AdjustPosition(int axis, int sign)
|
||||
{
|
||||
if (positionController != null)
|
||||
{
|
||||
positionController.AdjustPositionAxis(axis, sign);
|
||||
}
|
||||
}
|
||||
|
||||
Vector3 GetAxisDirection(int axis)
|
||||
{
|
||||
switch (axis)
|
||||
{
|
||||
case 0: return Vector3.right; // X axis (world space - always points right)
|
||||
case 1: return Vector3.up; // Y axis (world space - always points up)
|
||||
case 2: return Vector3.forward; // Z axis (world space - always points forward)
|
||||
default: return Vector3.zero;
|
||||
}
|
||||
}
|
||||
|
||||
Color GetAxisColor(int axis)
|
||||
{
|
||||
if (axis == selectedAxis) return selectedColor;
|
||||
if (axis == hoveredAxis) return hoverColor;
|
||||
|
||||
switch (axis)
|
||||
{
|
||||
case 0: return xAxisColor;
|
||||
case 1: return yAxisColor;
|
||||
case 2: return zAxisColor;
|
||||
default: return Color.white;
|
||||
}
|
||||
}
|
||||
|
||||
Vector3 ClosestPointOnLineSegment(Vector3 lineStart, Vector3 lineEnd, Vector3 point)
|
||||
{
|
||||
Vector3 line = lineEnd - lineStart;
|
||||
float lineLength = line.magnitude;
|
||||
line.Normalize();
|
||||
|
||||
Vector3 pointToStart = point - lineStart;
|
||||
float projectionLength = Vector3.Dot(pointToStart, line);
|
||||
projectionLength = Mathf.Clamp(projectionLength, 0f, lineLength);
|
||||
|
||||
return lineStart + line * projectionLength;
|
||||
}
|
||||
|
||||
Vector3 ClosestPointOnRay(Ray ray, Vector3 point)
|
||||
{
|
||||
Vector3 rayToPoint = point - ray.origin;
|
||||
float projectionLength = Vector3.Dot(rayToPoint, ray.direction);
|
||||
projectionLength = Mathf.Max(0f, projectionLength); // Don't go backwards
|
||||
|
||||
return ray.origin + ray.direction * projectionLength;
|
||||
}
|
||||
|
||||
void OnDestroy()
|
||||
{
|
||||
// Don't destroy gizmo container - it's part of the scene hierarchy, not created at runtime
|
||||
// Just clear the reference
|
||||
gizmoContainer = null;
|
||||
xAxisLine = null;
|
||||
yAxisLine = null;
|
||||
zAxisLine = null;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user