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 OnPostRender()
{
if (AutoCamOffset)
{
RuntimeHandles.DrawGrid(GridOffset, Camera.current.transform.position.y);
}
else
{
RuntimeHandles.DrawGrid(GridOffset, CamOffset);
}
}
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);
}
public void Draw(int cullingMask)
{
if (RuntimeTools.ShowSelectionGizmos)
{
RTLayer layer = RTLayer.SceneView;
if ((cullingMask & (int)layer) == 0)
{
return;
}
Bounds bounds = m_exposeToEditor.Bounds;
Transform trform = m_exposeToEditor.BoundsObject.transform;
RuntimeHandles.DrawBounds(ref bounds, trform.position, trform.rotation, trform.lossyScale);
if (RuntimeTools.DrawSelectionGizmoRay)
{
RuntimeHandles.DrawBoundRay(ref bounds, trform.TransformPoint(bounds.center), Quaternion.identity, trform.lossyScale);
}
}
}
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 void DrawOverride()
{
RuntimeHandles.DoPositionHandle(HandlePosition, Rotation, SelectedAxis, IsInSnappingMode, LockObject);
}
protected override void DrawOverride()
{
RuntimeHandles.DoScaleHandle(m_roundedScale, Target.position, Rotation, SelectedAxis, LockObject);
}
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);
}
protected override void DrawOverride()
{
RuntimeHandles.DoPositionHandle(transform.position, Rotation, SelectedAxis);
}
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;
}
}
}
public void Draw()
{
RuntimeHandles.DoPositionHandle(transform.position, transform.rotation, m_selectedAxis);
}
protected override void DrawOverride()
{
RuntimeHandles.DoRotationHandle(Target.rotation * StartingRotationInv, Target.position, SelectedAxis, LockObject);
}
protected override void DrawOverride()
{
RuntimeHandles.DoPositionHandle(transform.position, Rotation, axisCenterSize, axisLength, SelectedAxis);
}
protected override void DrawOverride()
{
RuntimeHandles.DoRotationHandle(Target.rotation, Target.position, SelectedAxis);
}
protected override void DrawOverride()
{
RuntimeHandles.DoScaleHandle(m_roundedScale, transform.position, Rotation, SelectedAxis);
}
private void OnPostRender()
{
RuntimeHandles.DoSceneGizmo(GetGizmoPosition(), Quaternion.identity, m_selectedAxis, Size.y / 96, m_xAlpha, m_yAlpha, m_zAlpha);
}
private void OnPreRender()
{
m_camera.farClipPlane = RuntimeHandles.GetGridFarPlane();
}
private void OnPostRender()
{
RuntimeHandles.DrawGrid();
}
