public override void OnToolGUI(EditorWindow window) { var view = window as SceneView; if (!view || !Selection.activeTransform || Tools.s_Hidden) { return; } if (!StageUtility.IsGameObjectRenderedByCamera(Selection.activeTransform.gameObject, Camera.current)) { return; } bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); using (new EditorGUI.DisabledScope(isStatic)) { Vector3 handlePosition = Tools.handlePosition; ToolGUI(view, handlePosition, isStatic); Handles.ShowStaticLabelIfNeeded(handlePosition); } }
protected virtual void OnToolGUI(SceneView view) { if ((Selection.activeTransform != null) && !Tools.s_Hidden) { bool disabled = (!Tools.s_Hidden && EditorApplication.isPlaying) && GameObjectUtility.ContainsStatic(Selection.gameObjects); EditorGUI.BeginDisabledGroup(disabled); Vector3 handlePosition = Tools.handlePosition; this.ToolGUI(view, handlePosition, disabled); Handles.ShowStaticLabelIfNeeded(handlePosition); EditorGUI.EndDisabledGroup(); } }
protected virtual void OnToolGUI(SceneView view) { if (Selection.activeTransform && !Tools.s_Hidden) { bool flag = !Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects); using (new EditorGUI.DisabledScope(flag)) { Vector3 handlePosition = Tools.handlePosition; this.ToolGUI(view, handlePosition, flag); Handles.ShowStaticLabelIfNeeded(handlePosition); } } }
protected virtual void OnToolGUI(SceneView view) { if (!Selection.activeTransform || Tools.s_Hidden) { return; } bool flag = !Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects); EditorGUI.BeginDisabledGroup(flag); Vector3 handlePosition = Tools.handlePosition; this.ToolGUI(view, handlePosition, flag); Handles.ShowStaticLabelIfNeeded(handlePosition); EditorGUI.EndDisabledGroup(); }
protected virtual void OnToolGUI(SceneView view) { if (!Selection.activeTransform || Tools.s_Hidden) { return; } bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); using (new EditorGUI.DisabledScope(isStatic)) { Vector3 handlePosition = Tools.handlePosition; ToolGUI(view, handlePosition, isStatic); Handles.ShowStaticLabelIfNeeded(handlePosition); } }
internal static Quaternion DoRotationHandle(RotationHandleIds ids, Quaternion rotation, Vector3 position, RotationHandleParam param) { var evt = Event.current; var camForward = Handles.inverseMatrix.MultiplyVector(Camera.current != null ? Camera.current.transform.forward : Vector3.forward); var size = HandleUtility.GetHandleSize(position); var temp = color; var isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); var isHot = ids.Has(GUIUtility.hotControl); // Draw freerotation first to give it the lowest priority if (!isStatic && param.ShouldShow(RotationHandleParam.Handle.XYZ) && (isHot && ids.xyz == GUIUtility.hotControl || !isHot)) { color = centerColor; rotation = UnityEditorInternal.FreeRotate.Do(ids.xyz, rotation, position, size * param.xyzSize, param.displayXYZCircle); } var radiusOfAxesHandles = -1f; for (var i = 0; i < 3; ++i) { if (!param.ShouldShow(i)) { continue; } var axisColor = GetColorByAxis(i); color = isStatic ? Color.Lerp(axisColor, staticColor, staticBlend) : axisColor; color = ToActiveColorSpace(color); var axisDir = GetAxisVector(i); var radius = size * param.axisSize[i]; radiusOfAxesHandles = Mathf.Max(radius, radiusOfAxesHandles); rotation = UnityEditorInternal.Disc.Do(ids[i], rotation, position, rotation * axisDir, radius, true, SnapSettings.rotation, param.enableRayDrag, true, k_RotationPieColor); } if (radiusOfAxesHandles > 0 && evt.type == EventType.Repaint) { Handles.color = new Color(0, 0, 0, 0.2f); Handles.DrawWireDisc(position, camForward, radiusOfAxesHandles); } if (isHot && evt.type == EventType.Repaint) { color = ToActiveColorSpace(s_DisabledHandleColor); Handles.DrawWireDisc(position, camForward, size * param.axisSize[0]); } if (!isStatic && param.ShouldShow(RotationHandleParam.Handle.CameraAxis) && (isHot && ids.cameraAxis == GUIUtility.hotControl || !isHot)) { color = ToActiveColorSpace(centerColor); rotation = UnityEditorInternal.Disc.Do(ids.cameraAxis, rotation, position, camForward, size * param.cameraAxisSize, false, 0, param.enableRayDrag, true, k_RotationPieColor); } color = temp; return(rotation); }
static Vector3 DoPlanarHandle( int id, int planePrimaryAxis, Vector3 position, Vector3 offset, Quaternion rotation, float handleSize, float cameraLerp, Vector3 viewVectorDrawSpace, PositionHandleParam.Orientation orientation) { var positionOffset = offset; var axis1index = planePrimaryAxis; var axis2index = (axis1index + 1) % 3; var axisNormalIndex = (axis1index + 2) % 3; Color prevColor = Handles.color; bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); color = isStatic ? staticColor : GetColorByAxis(axisNormalIndex); color = Color.Lerp(color, Color.clear, cameraLerp); var updateOpacityFillColor = false; if (GUIUtility.hotControl == id) { color = selectedColor; } else if (HandleUtility.nearestControl == id) { color = preselectionColor; } else { updateOpacityFillColor = true; } color = ToActiveColorSpace(color); // NOTE: The planar transform handles always face toward the camera so they won't // obscure each other (unlike the X, Y, and Z axis handles which always face in the // positive axis directions). Whenever the octant that the camera is in (relative to // to the transform tool) changes, we need to move the planar transform handle // positions to the correct octant. // Comments below assume axis1 is X and axis2 is Z to make it easier to visualize things. // Shift the planar transform handle in the positive direction by half its // handleSize so that it doesn't overlap in the center of the transform gizmo, // and also move the handle origin into the octant that the camera is in. // Don't update the actant while dragging to avoid too much distraction. if (!currentlyDragging) { switch (orientation) { case PositionHandleParam.Orientation.Camera: // Offset the X position of the handle in negative direction if camera is in the -X octants; otherwise positive. // Test against -0.01 instead of 0 to give a little bias to the positive quadrants. This looks better in axis views. s_PlanarHandlesOctant[axis1index] = (viewVectorDrawSpace[axis1index] > 0.01f ? -1 : 1); // Likewise with the other axis. s_PlanarHandlesOctant[axis2index] = (viewVectorDrawSpace[axis2index] > 0.01f ? -1 : 1); break; case PositionHandleParam.Orientation.Signed: s_PlanarHandlesOctant[axis1index] = 1; s_PlanarHandlesOctant[axis2index] = 1; break; } } Vector3 handleOffset = s_PlanarHandlesOctant; // Zero out the offset along the normal axis. handleOffset[axisNormalIndex] = 0; positionOffset = rotation * Vector3.Scale(positionOffset, handleOffset); // Rotate and scale the offset handleOffset = rotation * (handleOffset * handleSize * 0.5f); // Calculate 3 axes Vector3 axis1 = Vector3.zero; Vector3 axis2 = Vector3.zero; Vector3 axisNormal = Vector3.zero; axis1[axis1index] = 1; axis2[axis2index] = 1; axisNormal[axisNormalIndex] = 1; axis1 = rotation * axis1; axis2 = rotation * axis2; axisNormal = rotation * axisNormal; // Draw the "filler" color for the handle verts[0] = position + positionOffset + handleOffset + (axis1 + axis2) * handleSize * 0.5f; verts[1] = position + positionOffset + handleOffset + (-axis1 + axis2) * handleSize * 0.5f; verts[2] = position + positionOffset + handleOffset + (-axis1 - axis2) * handleSize * 0.5f; verts[3] = position + positionOffset + handleOffset + (axis1 - axis2) * handleSize * 0.5f; Color faceColor = updateOpacityFillColor ? new Color(color.r, color.g, color.b, 0.1f) : color; faceColor = ToActiveColorSpace(faceColor); Handles.DrawSolidRectangleWithOutline(verts, faceColor, Color.clear); // And then render the handle itself (this is the colored outline) position = Slider2D(id, position, handleOffset + positionOffset, axisNormal, axis1, axis2, handleSize * 0.5f, RectangleHandleCap, GridSnapping.active ? Vector2.zero : new Vector2(SnapSettings.move[axis1index], SnapSettings.move[axis2index]), false); Handles.color = prevColor; return(position); }
static Vector3 DoPositionHandle_Internal(PositionHandleIds ids, Vector3 position, Quaternion rotation, PositionHandleParam param) { Color temp = color; bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); // Calculate the camera view vector in Handle draw space // this handle the case where the matrix is skewed var handlePosition = matrix.MultiplyPoint3x4(position); var drawToWorldMatrix = matrix * Matrix4x4.TRS(position, rotation, Vector3.one); var invDrawToWorldMatrix = drawToWorldMatrix.inverse; var viewVectorDrawSpace = GetCameraViewFrom(handlePosition, invDrawToWorldMatrix); var size = HandleUtility.GetHandleSize(position); // Calculate per axis camera lerp for (var i = 0; i < 3; ++i) { s_DoPositionHandle_Internal_CameraViewLerp[i] = ids[i] == GUIUtility.hotControl ? 0 : GetCameraViewLerpForWorldAxis(viewVectorDrawSpace, GetAxisVector(i)); } // Calculate per plane camera lerp (xy, yz, xz) for (var i = 0; i < 3; ++i) { s_DoPositionHandle_Internal_CameraViewLerp[3 + i] = Mathf.Max(s_DoPositionHandle_Internal_CameraViewLerp[i], s_DoPositionHandle_Internal_CameraViewLerp[(i + 1) % 3]); } var isHot = ids.Has(GUIUtility.hotControl); var axisOffset = param.axisOffset; var planeOffset = param.planeOffset; if (isHot) { axisOffset = Vector3.zero; planeOffset = Vector3.zero; } // Draw plane handles (xy, yz, xz) var planeSize = isHot ? param.planeSize + param.planeOffset : param.planeSize; for (var i = 0; i < 3; ++i) { if (!param.ShouldShow(3 + i) || isHot && ids[3 + i] != GUIUtility.hotControl) { continue; } var cameraLerp = isHot ? 0 : s_DoPositionHandle_Internal_CameraViewLerp[3 + i]; if (cameraLerp <= kCameraViewThreshold) { var offset = planeOffset * size; offset[s_DoPositionHandle_Internal_PrevIndex[i]] = 0; var planarSize = Mathf.Max(planeSize[i], planeSize[s_DoPositionHandle_Internal_NextIndex[i]]); position = DoPlanarHandle(ids[3 + i], i, position, offset, rotation, size * planarSize, cameraLerp, viewVectorDrawSpace, param.planeOrientation); } } // Draw axis sliders // Draw last to have priority over the planes for (var i = 0; i < 3; ++i) { if (!param.ShouldShow(i)) { continue; } if (!currentlyDragging) { switch (param.axesOrientation) { case PositionHandleParam.Orientation.Camera: s_DoPositionHandle_AxisHandlesOctant[i] = viewVectorDrawSpace[i] > 0.01f ? -1 : 1; break; case PositionHandleParam.Orientation.Signed: s_DoPositionHandle_AxisHandlesOctant[i] = 1; break; } } var isThisAxisHot = isHot && ids[i] == GUIUtility.hotControl; var axisColor = GetColorByAxis(i); color = isStatic ? Color.Lerp(axisColor, staticColor, staticBlend) : axisColor; GUI.SetNextControlName(s_DoPositionHandle_Internal_AxisNames[i]); // if we are hot here, the hot handle must be opaque var cameraLerp = isThisAxisHot ? 0 : s_DoPositionHandle_Internal_CameraViewLerp[i]; if (cameraLerp <= kCameraViewThreshold) { color = Color.Lerp(color, Color.clear, cameraLerp); var axisVector = GetAxisVector(i); var dir = rotation * axisVector; var offset = dir * axisOffset[i] * size; dir *= s_DoPositionHandle_AxisHandlesOctant[i]; offset *= s_DoPositionHandle_AxisHandlesOctant[i]; if (isHot && !isThisAxisHot) { color = s_DisabledHandleColor; } // A plane with this axis is hot if (isHot && (ids[s_DoPositionHandle_Internal_PrevPlaneIndex[i]] == GUIUtility.hotControl || ids[i + 3] == GUIUtility.hotControl)) { color = selectedColor; } color = ToActiveColorSpace(color); s_DoPositionHandle_ArrowCapConeOffset = isHot ? rotation * Vector3.Scale(Vector3.Scale(axisVector, param.axisOffset), s_DoPositionHandle_AxisHandlesOctant) : Vector3.zero; position = Slider(ids[i], position, offset, dir, size * param.axisSize[i], DoPositionHandle_ArrowCap, GridSnapping.active ? 0f : SnapSettings.move[i]); } } VertexSnapping.HandleMouseMove(ids.xyz); if (param.ShouldShow(PositionHandleParam.Handle.XYZ) && (isHot && ids.xyz == GUIUtility.hotControl || !isHot)) { color = ToActiveColorSpace(centerColor); GUI.SetNextControlName("FreeMoveAxis"); position = FreeMoveHandle(ids.xyz, position, rotation, size * kFreeMoveHandleSizeFactor, GridSnapping.active ? Vector3.zero : SnapSettings.move, RectangleHandleCap); } color = temp; if (GridSnapping.active) { position = GridSnapping.Snap(position); } return(position); }
internal static Vector3 DoScaleHandle(ScaleHandleIds ids, Vector3 scale, Vector3 position, Quaternion rotation, float handleSize, ScaleHandleParam param) { // Calculate the camera view vector in Handle draw space // this handle the case where the matrix is skewed var handlePosition = matrix.MultiplyPoint3x4(position); var drawToWorldMatrix = matrix * Matrix4x4.TRS(position, rotation, Vector3.one); var invDrawToWorldMatrix = drawToWorldMatrix.inverse; var viewVectorDrawSpace = GetCameraViewFrom(handlePosition, invDrawToWorldMatrix); var isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); var isHot = ids.Has(GUIUtility.hotControl); var axisOffset = param.axisOffset; var axisLineScale = param.axisLineScale; // When an axis is hot, draw the line from the center to the handle // So ignore the offset if (isHot) { axisLineScale += axisOffset; axisOffset = Vector3.zero; } var isCenterIsHot = ids.xyz == GUIUtility.hotControl; for (var i = 0; i < 3; ++i) { if (!param.ShouldShow(i)) { continue; } if (!currentlyDragging) { switch (param.orientation) { case ScaleHandleParam.Orientation.Signed: s_DoScaleHandle_AxisHandlesOctant[i] = 1; break; case ScaleHandleParam.Orientation.Camera: s_DoScaleHandle_AxisHandlesOctant[i] = viewVectorDrawSpace[i] > 0.01f ? -1 : 1; break; } } var id = ids[i]; var isThisAxisHot = isHot && id == GUIUtility.hotControl; var axisDir = GetAxisVector(i); var axisColor = GetColorByAxis(i); var offset = axisOffset[i]; var cameraLerp = id == GUIUtility.hotControl ? 0 : GetCameraViewLerpForWorldAxis(viewVectorDrawSpace, axisDir); // If we are here and is hot, then this axis is hot and must be opaque cameraLerp = isHot ? 0 : cameraLerp; color = isStatic ? Color.Lerp(axisColor, staticColor, staticBlend) : axisColor; axisDir *= s_DoScaleHandle_AxisHandlesOctant[i]; if (cameraLerp <= kCameraViewThreshold) { color = Color.Lerp(color, Color.clear, cameraLerp); if (isHot && !isThisAxisHot) { color = s_DisabledHandleColor; } if (isCenterIsHot) { color = selectedColor; } color = ToActiveColorSpace(color); scale[i] = UnityEditorInternal.SliderScale.DoAxis( id, scale[i], position, rotation * axisDir, rotation, handleSize * param.axisSize[i], SnapSettings.scale, offset, axisLineScale[i]); } } if (param.ShouldShow(ScaleHandleParam.Handle.XYZ) && (isHot && ids.xyz == GUIUtility.hotControl || !isHot)) { color = ToActiveColorSpace(centerColor); EditorGUI.BeginChangeCheck(); var s = ScaleValueHandle(ids.xyz, scale.x, position, rotation, handleSize * param.xyzSize, CubeHandleCap, SnapSettings.scale); if (EditorGUI.EndChangeCheck() && !Mathf.Approximately(scale.x, 0)) { var dif = s / scale.x; scale.x = s; scale.y *= dif; scale.z *= dif; } } return(scale); }
protected virtual bool ShouldToolGUIBeDisabled(out GUIContent disabledLabel) { disabledLabel = Handles.s_StaticLabel; return(!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); }