public virtual void DrawSphere(float radius, Matrix4x4 matrix)
{
Matrix4x4 lookMatrix = Matrix4x4.identity;
#if UNITY_EDITOR
UnityEditor.SceneView sceneView = UnityEditor.SceneView.currentDrawingSceneView;
if (sceneView != null)
{
Camera cam = sceneView.camera;
var cameraTrans = cam.transform;
var rotation = Quaternion.LookRotation(cameraTrans.position - matrix.MultiplyPoint(Vector3.zero));
lookMatrix = Matrix4x4.TRS(matrix.MultiplyPoint(Vector3.zero), rotation, matrix.lossyScale);
DrawCircle(radius, lookMatrix);
}
#endif
//绘制边界
bool oldFillColor = fillPolygon;
fillPolygon = false;
PushColor(outlineColor);
DrawCircle(radius, matrix);
DrawCircle(radius, matrix * Matrix4x4.Rotate(Quaternion.Euler(0, 90, 0)));
DrawCircle(radius, matrix * Matrix4x4.Rotate(Quaternion.Euler(90, 0, 0)));
PopColor();
fillPolygon = oldFillColor;
}
public static T SafeGetComponent <T>(GameObject go) where T : Component
{
T component = go.GetComponent <T>();
if (component == null)
{
string err = string.Format("Unable to GetComponent of type \"{0}\" on GameObject \"{1}\"", typeof(T), go.name);
Debug.LogError(err);
#if UNITY_EDITOR
if (UnityEditor.SceneView.sceneViews.Count > 0)
{
UnityEditor.SceneView sv = UnityEditor.SceneView.sceneViews[0] as UnityEditor.SceneView;
if (sv != null)
{
UnityEditor.EditorApplication.isPaused = true;
UnityEditor.Selection.activeGameObject = go;
sv.FrameSelected();
}
}
#endif
throw new UnityException(err);
}
return(component);
}
private void OnSceneGUI(UnityEditor.SceneView sceneview)
{
m_mousePosition = Event.current.mousePosition;
switch (Event.current.type)
{
case EventType.MouseDown:
m_MouseClickPosition = m_mousePosition;
break;
case EventType.KeyDown:
switch (Event.current.keyCode)
{
case KeyCode.PageUp:
++m_DebugStep;
sceneview.Repaint();
break;
case KeyCode.PageDown:
m_DebugStep = Mathf.Max(0, m_DebugStep - 1);
sceneview.Repaint();
break;
case KeyCode.End:
// Usefull we you don't want to change the scene viewport but still update the mouse click position
m_MouseClickPosition = m_mousePosition;
sceneview.Repaint();
break;
}
break;
}
}
/// <summary>
/// 用于在Scene窗口Renderer
/// </summary>
protected void OnSceneGUI(UnityEditor.SceneView sceneView)
{
if (MyRendererIn == RendererIn.Scene)
{
DoUpdate(sceneView.camera);
}
}
/// <summary>
/// <para>Seguimiento de la vista al objetivo</para>
/// </summary>
private void Follow()// Seguimiento de la vista al objetivo
{
// Selecciona la sceneview actual
sceneViews = UnityEditor.SceneView.sceneViews;
// Si no se cumplen las condiciones optimas, return
if (svSeguidor == null || !on || sceneViews.Count == 0) return;
// Recorremos todas
foreach (SceneViewSeguidor svs in svSeguidor)
{
// Si no esta activado continuamos
if (svs.activado == false) continue;
// Fijamos la sceneview
UnityEditor.SceneView sceneView = (UnityEditor.SceneView)sceneViews[svs.sceneViewIndex];
if (sceneView != null)
{
if ((Application.isPlaying && soloEnPlayMode) || !soloEnPlayMode)
{
// Seguimos
sceneView.orthographic = svs.ortographic;
sceneView.LookAtDirect(svs.objetivo.position + svs.posicionOffset, (svs.activarFixedRotacion) ? Quaternion.Euler(svs.fixedRotacion) : svs.objetivo.rotation, svs.distancia);
}
}
}
}
private void DuringSceneGui(UnityEditor.SceneView sceneView)
{
Event currentGUIEvent = Event.current;
Vector3 mousePos = currentGUIEvent.mousePosition;
float pixelsPerPoint = UnityEditor.EditorGUIUtility.pixelsPerPoint;
mousePos.y = sceneView.camera.pixelHeight - mousePos.y * pixelsPerPoint;
mousePos.x *= pixelsPerPoint;
Ray ray = sceneView.camera.ScreenPointToRay(mousePos);
if (Physics.Raycast(ray, out RaycastHit hit))
{
clickHelper.UpdateTargeting(hit.point);
}
switch (currentGUIEvent.type)
{
case EventType.MouseMove:
UnityEditor.HandleUtility.Repaint();
break;
case EventType.MouseDown:
if (currentGUIEvent.button == 0) // Wait for Left mouse button down
{
clickHelper.EndTargeting();
UnityEditor.SceneView.duringSceneGui -= DuringSceneGui;
currentGUIEvent
.Use(); // This consumes the event, so that other controls/buttons won't be able to use it
}
break;
}
}
public static void MarkInScene(Vector3 worldPos, float pixel, float rad)
{
#if UNITY_EDITOR
UnityEditor.SceneView scene = UnityEditor.SceneView.currentDrawingSceneView;
if (!scene || !scene.camera)
{
return;
}
Matrix4x4 defM = Gizmos.matrix;
Gizmos.matrix = scene.camera.cameraToWorldMatrix;
Vector3 p = scene.camera.worldToCameraMatrix.MultiplyPoint(worldPos);
Vector3 sp = scene.camera.WorldToScreenPoint(worldPos);
Vector3 sp2 = scene.camera.WorldToScreenPoint(Gizmos.matrix.MultiplyPoint(p + Vector3.right));
float pixScale = 1f / Vector3.Distance(sp, sp2);
Vector3 p1;
Vector2 off = new Vector2(Mathf.Sin(rad), Mathf.Cos(rad));
off *= pixel * pixScale;
p1.x = p.x + off.x;
p1.y = p.y + off.y;
p1.z = p.z;
Vector3 p2 = p1;
p2.x = p.x * 2f - p1.x;
p2.y = p.y * 2f - p1.y;
Gizmos.DrawLine(p1, p2);
p1.x = p.x + off.y;
p1.y = p.y - off.x;
p2.x = p.x * 2f - p1.x;
p2.y = p.y * 2f - p1.y;
Gizmos.DrawLine(p1, p2);
Gizmos.matrix = defM;
#endif
}
private void OnSceneGUIDelegate(UnityEditor.SceneView sceneView)
{
//Debug.Log(Time.renderedFrameCount);
if (!_existenceHook())
{
UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUIDelegate;
Dispose();
return;
}
if (_lastFrame >= Time.renderedFrameCount)
{
return;
}
_lastFrame = Time.renderedFrameCount;
var position = _position();
var rotation = _rotation();
var dSize = _dataSize();
dSize = new Vector3(Mathf.Max(dSize.x, float.Epsilon), Mathf.Max(dSize.y, float.Epsilon), Mathf.Max(dSize.z, float.Epsilon));
var displaySize = _displaySize();
var displaySizeScale = new Vector3(displaySize.x / dSize.x, displaySize.y / dSize.y, displaySize.z / dSize.z);
var scale = _scale();
scale = new Vector3(scale.x * displaySizeScale.x, scale.y * displaySizeScale.y, scale.z * displaySizeScale.z);
var mat = Matrix4x4.TRS(position, rotation, scale);
Graphics.DrawMesh(_mesh, mat, _material, 0);
}
private static bool ShouldDrawGizmos(ProbeVolume probeVolume)
{
if (ShaderConfig.s_ProbeVolumesEvaluationMode == ProbeVolumesEvaluationModes.Disabled)
{
return(false);
}
UnityEditor.SceneView sceneView = UnityEditor.SceneView.currentDrawingSceneView;
if (sceneView == null)
{
sceneView = UnityEditor.SceneView.lastActiveSceneView;
}
if (sceneView != null && !sceneView.drawGizmos)
{
return(false);
}
if (!probeVolume.enabled)
{
return(false);
}
return(probeVolume.parameters.drawProbes);
}
public static Vector2 GetMousePosition()
{
if (IsEditor())
{
#if UNITY_EDITOR
UnityEditor.SceneView sceneview = UnityEditor.SceneView.lastActiveSceneView;
if (sceneview == null || sceneview.camera == null || Event.current == null)
{
return(Vector2.zero);
}
Vector2 mousePos = Event.current.mousePosition;
mousePos = new Vector2(mousePos.x / sceneview.camera.pixelWidth, mousePos.y / sceneview.camera.pixelHeight);
#if UNITY_5_4_OR_NEWER
mousePos *= UnityEditor.EditorGUIUtility.pixelsPerPoint;
#endif
mousePos.y = 1 - mousePos.y;
return(mousePos);
#else
return(Input.mousePosition);
#endif
}
else
{
return(Input.mousePosition);
}
}
/// <summary>
/// Update the scene view matrix for shader.
/// </summary>
static void UpdateSceneViewMatrixForShader()
{
UnityEditor.SceneView sceneView = UnityEditor.SceneView.lastActiveSceneView;
if (!sceneView || !sceneView.camera)
{
return;
}
Camera cam = sceneView.camera;
Matrix4x4 w2c = cam.worldToCameraMatrix;
Matrix4x4 prj = cam.projectionMatrix;
foreach (var sm in s_ActiveSoftMaskables)
{
if (sm)
{
Material mat = sm._maskMaterial;
if (mat)
{
mat.SetMatrix("_SceneView", w2c);
mat.SetMatrix("_SceneProj", prj);
}
}
}
}
//[UnityEditor.DrawGizmo(UnityEditor.GizmoType.NonSelected | UnityEditor.GizmoType.Active)]
static public void Draw(UnityEditor.SceneView sceneView) //(Transform objectTransform, UnityEditor.GizmoType gizmoType)
{
foreach (var kvp in allGizmos)
{
GizmoGroup group = kvp.Value;
if (!group.enabled)
{
continue;
}
if (group.colorOverride)
{
UnityEditor.Handles.color = group.color;
}
for (int i = 0; i < group.gizmos.Count; i++)
{
if (!group.colorOverride)
{
UnityEditor.Handles.color = group.gizmos[i].Color;
}
group.gizmos[i].Draw();
}
}
//allGizmos.Clear();
//will show gizmos only the frame they were assigned
}
public bool IsEditorSceneViewFocused()
{
#if UNITY_EDITOR
ArrayList sceneViews = UnityEditor.SceneView.sceneViews;
if (sceneViews == null)
{
return(false);
}
string focusedWindowTitle = GetFocusedEditorWindowTitle();
for (int i = 0; i < sceneViews.Count; i++)
{
UnityEditor.SceneView sceneView = sceneViews[i] as UnityEditor.SceneView;
if (sceneView == null)
{
continue;
}
#if UNITY_2017_PLUS
if (sceneView.titleContent.text == focusedWindowTitle)
{
return(true);
}
#else
if (sceneView.title == focusedWindowTitle)
{
return(true);
}
#endif
}
return(false);
#else
return(false);
#endif
}
private void OnSceneGUI(UnityEditor.SceneView sceneView)
{
if (parent is PositionDrawer)
{
DrawInfiniteAxisLine();
}
}
void Follow()
{
sceneViews = UnityEditor.SceneView.sceneViews;
if (sceneViewFollowers == null || !on || sceneViews.Count == 0)
{
return;
}
foreach (SceneViewFollower svf in sceneViewFollowers)
{
if (!svf.enable)
{
continue;
}
UnityEditor.SceneView sceneView = (UnityEditor.SceneView)sceneViews[svf.sceneViewIndex];
if (sceneView != null)
{
if ((Application.isPlaying && onlyInPlayMode) || !onlyInPlayMode)
{
sceneView.orthographic = svf.orthographic;
sceneView.LookAtDirect(svf.targetTransform.position + svf.positionOffset, (svf.enableFixedRotation) ? Quaternion.Euler(svf.fixedRotation) : svf.targetTransform.rotation, svf.size);
}
}
}
}
public static void DoViewTool(UnityEditor.SceneView view)
{
if (__DoViewTool_0_1 == null)
{
__DoViewTool_0_1 = (Action <UnityEditor.SceneView>)Delegate.CreateDelegate(typeof(Action <UnityEditor.SceneView>), null, UnityTypes.UnityEditor_SceneViewMotion.GetMethod("DoViewTool", R.StaticMembers, null, new Type[] { typeof(UnityEditor.SceneView) }, null));
}
__DoViewTool_0_1(view);
}
public override void BeforeSceneDraw(UnityEditor.SceneView current)
{
base.BeforeSceneDraw(current);
if (Event.current.type == EventType.MouseUp)
{
GetRotation();
}
}
/// <summary>
/// Called on scene view
/// </summary>
private void OnSceneView(UnityEditor.SceneView sView)
{
if (Application.isPlaying)
{
return;
}
threadUpdate();
}
public void OnRepaint(UnityEditor.SceneView sceneView, Event e)
{
// Selected brush green outline
if (!isBrushConvex)
{
SabreCSGResources.GetSelectedBrushMaterial().SetPass(0);
DrawPolygons(Color.red, polygons);
}
}
public static float FactorFromSceneViewPixel(Transform trans, Vector3 localPos = new Vector3())
{
#if UNITY_EDITOR
UnityEditor.SceneView scene = UnityEditor.SceneView.currentDrawingSceneView;
if (scene)
return FactorFromPixel(scene.camera, trans, localPos);
else
return 0f;
#else
return 0f;
#endif
}
private static bool IsValidCamera(Camera cam)
{
#if UNITY_EDITOR
UnityEditor.SceneView sView = UnityEditor.SceneView.currentDrawingSceneView;
if (sView && sView.camera == cam)
{
return(true);
}
#endif
return(cam.enabled);
}
public static Camera GetSceneViewCamera()
{
#if UNITY_EDITOR
UnityEditor.SceneView scene = UnityEditor.SceneView.currentDrawingSceneView;
if (scene)
return scene.camera;
else
return null;
#else
return null;
#endif
}
public static void Focus()
{
#if UNITY_EDITOR
UnityEditor.SceneView sv = UnityEditor.SceneView.sceneViews[0] as UnityEditor.SceneView;
sv.in2DMode = true;
sv.orthographic = true;
UnityEditor.EditorGUIUtility.PingObject(CScapeToolsetManager.tiles[activeTile]);
var currentlActive = UnityEditor.Selection.activeGameObject;
UnityEditor.Selection.activeGameObject = tiles[activeTile].gameObject;
UnityEditor.SceneView.lastActiveSceneView.FrameSelected();
UnityEditor.Selection.activeGameObject = currentlActive;
#endif
}
/// <summary>
/// Removes the command buffer used for rendering.
/// </summary>
public void ClearCommandBuffer()
{
if (renderingCaller != null && renderingCaller.mainCamera != null)
{
renderingCaller.mainCamera.RemoveCommandBuffer(_cameraEvent, commandBuffer);
}
#if UNITY_EDITOR
UnityEditor.SceneView sceneView = UnityEditor.SceneView.lastActiveSceneView;
if (sceneView != null && sceneView.camera != null)
{
sceneView.camera.RemoveCommandBuffer(_cameraEvent, commandBuffer);
}
#endif //UNITY_EDITOR
}
public static float FactorToSceneViewPixel(Transform trans, Vector3 localPos = new Vector3())
{
#if UNITY_EDITOR
UnityEditor.SceneView scene = UnityEditor.SceneView.currentDrawingSceneView;
if (scene)
{
return(FactorToPixel(scene.camera, trans, localPos));
}
else
{
return(0f);
}
#else
return(0f);
#endif
}
private void AddCommandBuffer(UnityEngine.Rendering.CameraEvent cameraEvent)
{
this.usedCameraEvent = cameraEvent;
this.cameraEventHandler.CameraComponent.AddCommandBuffer(this.usedCameraEvent, this.commandBuffer);
#if UNITY_EDITOR
if (this.drawInScene)
{
int sceneViewCount = UnityEditor.SceneView.sceneViews.Count;
for (int i = 0; i < sceneViewCount; ++i)
{
UnityEditor.SceneView sceneView = UnityEditor.SceneView.sceneViews[i] as UnityEditor.SceneView;
sceneView.camera.AddCommandBuffer(this.usedCameraEvent, this.commandBuffer);
}
}
#endif
}
void ongui(UnityEditor.SceneView sv)
{
if (!DrawHandles)
{
return;
}
var target = this;
UnityEditor.Handles.color = target.color;
UnityEditor.Handles.zTest = UnityEngine.Rendering.CompareFunction.Disabled;
UnityEditor.Handles.SphereHandleCap(0, target.transform.position, target.transform.rotation, target.HandlesSizes, EventType.Repaint);
UnityEditor.Handles.ArrowHandleCap(0, target.transform.position, target.transform.rotation, target.HandlesSizes * 2.5f, EventType.Repaint);
UnityEditor.Handles.ArrowHandleCap(0, target.transform.position + target.HandlesSizes * target.transform.right, target.transform.rotation, target.HandlesSizes * 1.5f, EventType.Repaint);
UnityEditor.Handles.ArrowHandleCap(0, target.transform.position + target.HandlesSizes * (Quaternion.AngleAxis(120, target.transform.forward) * target.transform.right), target.transform.rotation, target.HandlesSizes * 1.5f, EventType.Repaint);
UnityEditor.Handles.ArrowHandleCap(0, target.transform.position + target.HandlesSizes * (Quaternion.AngleAxis(240, target.transform.forward) * target.transform.right), target.transform.rotation, target.HandlesSizes * 1.5f, EventType.Repaint);
}
/// <summary>
/// Initializes the command buffer used for rendering.
/// </summary>
/// <param name="cameraEvent"></param> The camera event on which the command buffer is to be executed.
public void InitializeCommandBuffer(CameraEvent cameraEvent)
{
commandBuffer = new CommandBuffer();
commandBuffer.name = gameObject.name + " - Execute rendering";
_cameraEvent = cameraEvent;
if (renderingCaller != null && renderingCaller.mainCamera != null)
{
renderingCaller.mainCamera.AddCommandBuffer(_cameraEvent, commandBuffer);
}
#if UNITY_EDITOR
UnityEditor.SceneView sceneView = UnityEditor.SceneView.lastActiveSceneView;
if (sceneView != null && sceneView.camera != null)
{
sceneView.camera.AddCommandBuffer(_cameraEvent, commandBuffer);
}
#endif //UNITY_EDITOR
}
//----------------------------------------------------------------------------------------------------------------------
//Make the specified camera (or Camera.main) follow the first SceneView camera
void Follow()
{
ArrayList sceneViews = UnityEditor.SceneView.sceneViews;
if (sceneViews.Count == 0)
{
return;
}
Camera gameCamera = (null != m_gameViewCamera) ? m_gameViewCamera : Camera.main;
if (null == gameCamera)
{
return;
}
Transform gameCameraT = gameCamera.transform;
if (sceneViews.Count <= 0)
{
return;
}
UnityEditor.SceneView sceneView = (UnityEditor.SceneView)sceneViews[0];
if (null == sceneView)
{
return;
}
Camera curSceneCam = sceneView.camera;
if (null == curSceneCam)
{
return;
}
Transform curSceneCamT = curSceneCam.transform;
gameCamera.orthographic = sceneView.orthographic;
gameCameraT.position = curSceneCamT.position;
gameCameraT.rotation = curSceneCamT.rotation;
}
private static bool ShouldDrawGizmos(ProbeVolume probeVolume)
{
UnityEditor.SceneView sceneView = UnityEditor.SceneView.currentDrawingSceneView;
if (sceneView == null)
{
sceneView = UnityEditor.SceneView.lastActiveSceneView;
}
if (sceneView != null && !sceneView.drawGizmos)
{
return(false);
}
if (!probeVolume.enabled)
{
return(false);
}
return(probeVolume.parameters.drawProbes);
}
