private RuntimeHandleAxis Hit() { float hit1Distance; float hit2Distance; Ray ray = SceneCamera.ScreenPointToRay(InputController._MousePosition); float scale = RuntimeHandles.GetScreenScale(Target.position, SceneCamera) * RuntimeHandles.HandleScale; if (Intersect(ray, Target.position, outerRadius * scale, out hit1Distance, out hit2Distance)) { Vector3 dpHitPoint; GetPointOnDragPlane(GetDragPlane(), InputController._MousePosition, out dpHitPoint); RuntimeHandleAxis axis = HitAxis(); if (axis != RuntimeHandleAxis.None) { return(axis); } bool isInside = (dpHitPoint - Target.position).magnitude <= innerRadius * scale; if (isInside) { return(RuntimeHandleAxis.Free); } else { return(RuntimeHandleAxis.Screen); } } return(RuntimeHandleAxis.None); }
private RuntimeHandleAxis HitAxis() { float screenScale = RuntimeHandles.GetScreenScale(Target.position, SceneCamera) * RuntimeHandles.HandleScale; Vector3 scale = new Vector3(screenScale, screenScale, screenScale); Matrix4x4 xTranform = Matrix4x4.TRS(Vector3.zero, Target.rotation * StartingRotationInv * Quaternion.AngleAxis(-90, Vector3.up), Vector3.one); Matrix4x4 yTranform = Matrix4x4.TRS(Vector3.zero, Target.rotation * StartingRotationInv * Quaternion.AngleAxis(-90, Vector3.right), Vector3.one); Matrix4x4 zTranform = Matrix4x4.TRS(Vector3.zero, Target.rotation * StartingRotationInv, Vector3.one); Matrix4x4 objToWorld = Matrix4x4.TRS(Target.position, Quaternion.identity, scale); float xDistance; float yDistance; float zDistance; bool hitX = HitAxis(xTranform, objToWorld, out xDistance); bool hitY = HitAxis(yTranform, objToWorld, out yDistance); bool hitZ = HitAxis(zTranform, objToWorld, out zDistance); if (hitX && xDistance < yDistance && xDistance < zDistance) { return(RuntimeHandleAxis.X); } else if (hitY && yDistance < xDistance && yDistance < zDistance) { return(RuntimeHandleAxis.Y); } else if (hitZ && zDistance < xDistance && zDistance < yDistance) { return(RuntimeHandleAxis.Z); } return(RuntimeHandleAxis.None); }
private void InitColliders() { m_gizmoPosition = GetGizmoPosition(); float sScale = RuntimeHandles.GetScreenScale(m_gizmoPosition, m_camera) * Size.y / 96; m_collidersGO.transform.rotation = Quaternion.identity; m_collidersGO.transform.position = GetGizmoPosition(); const float size = 0.15f; m_colliderProj.size = new Vector3(size, size, size) * sScale; m_colliderUp.size = new Vector3(size, size * 2, size) * sScale; m_colliderUp.center = new Vector3(0.0f, size + size / 2, 0.0f) * sScale; m_colliderDown.size = new Vector3(size, size * 2, size) * sScale; m_colliderDown.center = new Vector3(0.0f, -(size + size / 2), 0.0f) * sScale; m_colliderForward.size = new Vector3(size, size, size * 2) * sScale; m_colliderForward.center = new Vector3(0.0f, 0.0f, size + size / 2) * sScale; m_colliderBackward.size = new Vector3(size, size, size * 2) * sScale; m_colliderBackward.center = new Vector3(0.0f, 0.0f, -(size + size / 2)) * sScale; m_colliderRight.size = new Vector3(size * 2, size, size) * sScale; m_colliderRight.center = new Vector3(size + size / 2, 0.0f, 0.0f) * sScale; m_colliderLeft.size = new Vector3(size * 2, size, size) * sScale; m_colliderLeft.center = new Vector3(-(size + size / 2), 0.0f, 0.0f) * sScale; }
protected override bool OnBeginDrag() { m_screenScale = RuntimeHandles.GetScreenScale(transform.position, Camera); m_matrix = Matrix4x4.TRS(transform.position, Rotation, Vector3.one); m_inverse = m_matrix.inverse; Matrix4x4 matrix = Matrix4x4.TRS(transform.position, Rotation, new Vector3(m_screenScale, m_screenScale, m_screenScale)); if (HitCenter()) { SelectedAxis = RuntimeHandleAxis.Free; DragPlane = GetDragPlane(); } else { float distToYAxis; float distToZAxis; float distToXAxis; bool hit = HitAxis(Vector3.up, matrix, out distToYAxis); hit |= HitAxis(Vector3.forward, matrix, out distToZAxis); hit |= HitAxis(Vector3.right, matrix, out distToXAxis); if (hit) { if (distToYAxis <= distToZAxis && distToYAxis <= distToXAxis) { SelectedAxis = RuntimeHandleAxis.Y; } else if (distToXAxis <= distToYAxis && distToXAxis <= distToZAxis) { SelectedAxis = RuntimeHandleAxis.X; } else { SelectedAxis = RuntimeHandleAxis.Z; } } else { SelectedAxis = RuntimeHandleAxis.None; return(false); } } m_refScales = new Vector3[Targets.Length]; for (int i = 0; i < m_refScales.Length; ++i) { Quaternion rotation = RuntimeTools.PivotRotation == RuntimePivotRotation.Global ? Targets[i].rotation : Quaternion.identity; m_refScales[i] = rotation * Target.localScale; } DragPlane = GetDragPlane(); bool result = GetPointOnDragPlane(Input.mousePosition, out m_prevPoint); return(result); }
private void SyncModelTransform() { Vector3 position = HandlePosition; Model.transform.position = position; Model.transform.rotation = Rotation; float screenScale = RuntimeHandles.GetScreenScale(position, SceneCamera); Model.transform.localScale = RuntimeHandles.InvertZAxis ? new Vector3(1, 1, -1) * screenScale : Vector3.one * screenScale; }
private RuntimeHandleAxis Hit() { float scale = RuntimeHandles.GetScreenScale(HandlePosition, SceneCamera); m_matrix = Matrix4x4.TRS(HandlePosition, Rotation, Vector3.one);// transform.localScale); m_inverse = m_matrix.inverse; Matrix4x4 matrix = Matrix4x4.TRS(HandlePosition, Rotation, new Vector3(scale, scale, scale)); float s = 0.3f * scale; if (HitQuad(Vector3.up * RuntimeHandles.HandleScale, m_matrix, s)) { return(RuntimeHandleAxis.XZ); } if (HitQuad(Vector3.right * RuntimeHandles.HandleScale, m_matrix, s)) { return(RuntimeHandleAxis.YZ); } if (HitQuad(Vector3.forward * RuntimeHandles.HandleScale, m_matrix, s)) { return(RuntimeHandleAxis.XY); } float distToYAxis; float distToZAxis; float distToXAxis; bool hit = HitAxis(Vector3.up * RuntimeHandles.HandleScale, matrix, out distToYAxis); hit |= HitAxis(Vector3.forward * RuntimeHandles.HandleScale, matrix, out distToZAxis); hit |= HitAxis(Vector3.right * RuntimeHandles.HandleScale, matrix, out distToXAxis); if (hit) { if (distToYAxis <= distToZAxis && distToYAxis <= distToXAxis) { return(RuntimeHandleAxis.Y); } else if (distToXAxis <= distToYAxis && distToXAxis <= distToZAxis) { return(RuntimeHandleAxis.X); } else { return(RuntimeHandleAxis.Z); } } return(RuntimeHandleAxis.None); }
private RuntimeHandleAxis Hit() { float hit1Distance; float hit2Distance; Ray ray = Camera.ScreenPointToRay(Input.mousePosition); float scale = RuntimeHandles.GetScreenScale(Target.position, Camera); if (Intersect(ray, Target.position, outerRadius * scale, out hit1Distance, out hit2Distance)) { Vector3 dpHitPoint; GetPointOnDragPlane(GetDragPlane(), Input.mousePosition, out dpHitPoint); bool isInside = (dpHitPoint - Target.position).magnitude <= innerRadius * scale; if (isInside) { Intersect(ray, Target.position, innerRadius * scale, out hit1Distance, out hit2Distance); Vector3 hitPoint = m_targetInverse.MultiplyPoint(ray.GetPoint(hit1Distance)); Vector3 radiusVector = hitPoint.normalized; float dotX = Mathf.Abs(Vector3.Dot(radiusVector, Vector3.right)); float dotY = Mathf.Abs(Vector3.Dot(radiusVector, Vector3.up)); float dotZ = Mathf.Abs(Vector3.Dot(radiusVector, Vector3.forward)); if (dotX < hitDot) { return(RuntimeHandleAxis.X); } else if (dotY < hitDot) { return(RuntimeHandleAxis.Y); } else if (dotZ < hitDot) { return(RuntimeHandleAxis.Z); } else { return(RuntimeHandleAxis.Free); } } else { return(RuntimeHandleAxis.None); //return RuntimeHandleAxis.Screen; } } return(RuntimeHandleAxis.None); }
private RuntimeHandleAxis Hit() { m_screenScale = RuntimeHandles.GetScreenScale(transform.position, SceneCamera) * RuntimeHandles.HandleScale; m_matrix = Matrix4x4.TRS(transform.position, Rotation, RuntimeHandles.InvertZAxis ? new Vector3(1, 1, -1) : Vector3.one); m_inverse = m_matrix.inverse; Matrix4x4 matrix = Matrix4x4.TRS(transform.position, Rotation, new Vector3(m_screenScale, m_screenScale, m_screenScale)); if (HitCenter()) { return(RuntimeHandleAxis.Free); } float distToYAxis; float distToZAxis; float distToXAxis; bool hit = HitAxis(Vector3.up, matrix, out distToYAxis); hit |= HitAxis(RuntimeHandles.Forward, matrix, out distToZAxis); hit |= HitAxis(Vector3.right, matrix, out distToXAxis); if (hit) { if (distToYAxis <= distToZAxis && distToYAxis <= distToXAxis) { return(RuntimeHandleAxis.Y); } else if (distToXAxis <= distToYAxis && distToXAxis <= distToZAxis) { return(RuntimeHandleAxis.X); } else { return(RuntimeHandleAxis.Z); } } return(RuntimeHandleAxis.None); }
protected override bool OnBeginDrag() { m_cursorPosition = transform.position; m_currentPosition = m_cursorPosition; float scale = RuntimeHandles.GetScreenScale(transform.position, Camera); m_matrix = Matrix4x4.TRS(transform.position, Rotation, Vector3.one);// transform.localScale); m_inverse = m_matrix.inverse; Matrix4x4 matrix = Matrix4x4.TRS(transform.position, Rotation, new Vector3(scale, scale, scale)); float s = 0.3f * scale; if (HitQuad(Vector3.up, m_matrix, s)) { SelectedAxis = RuntimeHandleAxis.XZ; return(GetPointOnDragPlane(Input.mousePosition, out m_prevPoint)); } if (HitQuad(Vector3.right, m_matrix, s)) { SelectedAxis = RuntimeHandleAxis.YZ; return(GetPointOnDragPlane(Input.mousePosition, out m_prevPoint)); } if (HitQuad(Vector3.forward, m_matrix, s)) { SelectedAxis = RuntimeHandleAxis.XY; return(GetPointOnDragPlane(Input.mousePosition, out m_prevPoint)); } float distToYAxis; float distToZAxis; float distToXAxis; bool hit = HitAxis(Vector3.up, matrix, out distToYAxis); hit |= HitAxis(Vector3.forward, matrix, out distToZAxis); hit |= HitAxis(Vector3.right, matrix, out distToXAxis); if (hit) { if (distToYAxis <= distToZAxis && distToYAxis <= distToXAxis) { SelectedAxis = RuntimeHandleAxis.Y; } else if (distToXAxis <= distToYAxis && distToXAxis <= distToZAxis) { SelectedAxis = RuntimeHandleAxis.X; } else { SelectedAxis = RuntimeHandleAxis.Z; } DragPlane = GetDragPlane(); return(GetPointOnDragPlane(Input.mousePosition, out m_prevPoint)); } SelectedAxis = RuntimeHandleAxis.None; return(false); }
private void Update() { if (Input.GetMouseButtonDown(0)) { if (RuntimeTools.Current != RuntimeTool.Move && RuntimeTools.Current != RuntimeTool.None) { return; } if (Camera == null) { Debug.LogError("Camera is null"); return; } float scale = RuntimeHandles.GetScreenScale(transform.position, Camera); Matrix4x4 matrix = Matrix4x4.TRS(transform.position, transform.rotation, new Vector3(scale, scale, scale)); float distToYAxis; float distToZAxis; float distToXAxis; bool hit = HitAxis(Vector3.up, matrix, out distToYAxis); hit |= HitAxis(Vector3.forward, matrix, out distToZAxis); hit |= HitAxis(Vector3.right, matrix, out distToXAxis); if (hit) { if (distToYAxis <= distToZAxis && distToYAxis <= distToXAxis) { m_selectedAxis = RuntimeHandleAxis.Y; } else if (distToXAxis <= distToYAxis && distToXAxis <= distToZAxis) { m_selectedAxis = RuntimeHandleAxis.X; } else { m_selectedAxis = RuntimeHandleAxis.Z; } m_dragPlane = GetDragPlane(); m_isDragging = GetPointOnDragPlane(Input.mousePosition, out m_prevPoint); } else { m_selectedAxis = RuntimeHandleAxis.None; } } else if (Input.GetMouseButtonUp(0)) { m_isDragging = false; } else { if (m_isDragging) { Vector3 point; if (GetPointOnDragPlane(Input.mousePosition, out point)) { Vector3 offset = transform.InverseTransformVector(point - m_prevPoint); float mag = offset.magnitude; if (m_selectedAxis == RuntimeHandleAxis.X) { offset.y = offset.z = 0.0f; } else if (m_selectedAxis == RuntimeHandleAxis.Y) { offset.x = offset.z = 0.0f; } else { offset.x = offset.y = 0.0f; } offset = transform.TransformVector(offset).normalized *mag; transform.position += offset; m_prevPoint = point; } } } if (Target != null && Target.position != transform.position) { if (m_isDragging) { Target.position = transform.position; } else { transform.position = Target.position; } } }