private void OnDrawGizmos()
{
#if UNITY_EDITOR
GizmosUtils.SetT(transform);
GizmosUtils.DrawArrow(Vector3.zero, GForce, GForce.magnitude, Color.magenta);
#endif
}
private void OnDrawGizmos()
{
Gizmos.color = Color.blue.WithAlpha(0.3f);
GizmosUtils.DrawSquareGrid(transform.position, GetSpawnSquareSize(), _maxMobsPerWave);
GizmosUtils.DrawText(CustomEditorPrefs.GizmoGuiSkin, "spawnpoint:\n" + ((_prefab != null) ? _prefab.name : "prefab=null"),
transform.position, Color.cyan,
(int)(CustomEditorPrefs.GizmoGuiSkin.GetStyle("Label").fontSize *0.8));
}
private void OnDrawGizmos()
{
var node = m_root;
if (node == null)
{
return;
}
var coners = node.Rect.Coners;
Gizmos.color = Color.red;
GizmosUtils.Draw2DLine(coners[0], coners[1]);
GizmosUtils.Draw2DLine(coners[1], coners[2]);
GizmosUtils.Draw2DLine(coners[2], coners[3]);
GizmosUtils.Draw2DLine(coners[3], coners[0]);
List <QuadTreeNode> openList = new List <QuadTreeNode>
{
node
};
List <QuadTreeNode> leafNodes = new List <QuadTreeNode>();
while (openList.Count > 0)
{
var curnode = openList[0];
openList.RemoveAt(0);
var children = curnode.Children;
if (children != null)
{
openList.AddRange(children);
}
else
{
leafNodes.Add(curnode);
}
}
Gizmos.color = Color.blue;
for (int i = 0; i < leafNodes.Count; i++)
{
var curNode = leafNodes[i];
if (curNode == m_root)
{
continue;
}
coners = curNode.Rect.Coners;
GizmosUtils.Draw2DLine(coners[0], coners[1]);
GizmosUtils.Draw2DLine(coners[1], coners[2]);
GizmosUtils.Draw2DLine(coners[2], coners[3]);
GizmosUtils.Draw2DLine(coners[3], coners[0]);
}
}
private void OnDrawGizmos()
{
bool isRectInersctWithCircle = m_circle.IntersectWith(m_rect);
bool isFanIntersectWithCircle = m_fan.IntersectWith(m_circle);
bool isFanIntersectWithRect = m_fan.IntersectWith(m_rect);
Color rectColor;
if (isRectInersctWithCircle)
{
rectColor = m_intersectCol;
}
else
{
rectColor = m_colors[0];
}
GizmosUtils.DrawRectSolid(m_rect, rectColor);
GizmosUtils.DrawRect(m_rect.Extand(m_circle.m_radius, m_circle.m_radius), rectColor);
Color circleColor;
if (isRectInersctWithCircle || isFanIntersectWithCircle)
{
circleColor = m_intersectCol;
}
else
{
circleColor = m_colors[1];
}
GizmosUtils.DrawCircle(m_circle, circleColor);
Color fanColor;
if (isFanIntersectWithCircle || isFanIntersectWithRect)
{
fanColor = m_intersectCol;
}
else
{
fanColor = m_colors[2];
}
GizmosUtils.DrawFan(m_fan, fanColor);
if (m_circle.ContainPoint(m_point) || m_rect.ContainPoint(m_point) || m_fan.ContainPoint(m_point))
{
Gizmos.color = m_intersectCol;
}
else
{
Gizmos.color = m_colors[3];
}
GizmosUtils.DrawPoint(m_point);
}
public void OnDrawGizmos()
{
Gizmos.color = Color.yellow;
Vector3 currentPos = transform.position;
foreach (var waypoint in Adjacents)
{
Vector3 otherPos = waypoint.transform.position;
GizmosUtils.DrawArrow2D(currentPos, otherPos);
}
}
private void OnDrawGizmos()
{
#if UNITY_EDITOR
GizmosUtils.SetT(transform);
GizmosUtils.DrawArrow(Vector3.zero, Thrust, Thrust.magnitude / GizmosThrustDivider, Color.white);
GizmosUtils.SetTR(transform);
GizmosUtils.DrawArrow(Vector3.zero, Vector3.right, PropellerLength, Color.white);
GizmosUtils.DrawArrow(Vector3.zero, Vector3.left, PropellerLength, Color.white);
GizmosUtils.DrawArrow(Vector3.zero, Vector3.up, PropellerLength, Color.white);
GizmosUtils.DrawArrow(Vector3.zero, Vector3.down, PropellerLength, Color.white);
#endif
}
private void OnDrawGizmos()
{
if (collider == null)
{
return;
}
Color color = !enabled ? Color.red
: State == States.Inactive ? Color.black
: Color.green;
GizmosUtils.DrawCollider(this.transform, collider, color);
}
protected virtual void OnDrawGizmosSelected()
{
if (Application.isPlaying && m_Debug && m_IsActive)
{
Gizmos.color = m_DebugSettings.CenterColor;
Gizmos.DrawRay(m_ObjectDetector.position, m_ObjectDetector.forward * m_CheckCoverLength);
Gizmos.color = m_HighCover ? m_DebugSettings.CenterColor : m_DebugSettings.ChangeStateColor;
Gizmos.DrawRay(m_HighCoverDetector.position, m_HighCoverDetector.forward * m_CheckCoverLength);
Gizmos.color = Color.cyan;
Gizmos.DrawSphere(rotationCheckPosition, 0.1f);
Gizmos.DrawRay(rotationCheckPosition, m_ObjectDetector.forward);
Gizmos.color = Color.red;
Gizmos.DrawRay(m_ObjectDetector.position, moveDirection);
if (m_LeftCoverPopup && m_RightCoverPopup)
{
Gizmos.color = m_CanPopLeft ? m_DebugSettings.ChangeStateColor : m_DebugSettings.LeftColor;
Gizmos.DrawRay(m_LeftCoverPopup.position, m_LeftCoverPopup.forward * m_CheckCoverLength);
//Gizmos.DrawCube(m_LeftCoverPopup.position, d_GizmoCubeSize);
Gizmos.DrawSphere(m_LeftCoverPopup.position, m_DebugSettings.GizmoSize);
GizmosUtils.DrawString("Left Cover", m_LeftCoverPopup.position + Vector3.up * 0.5f, Color.black);
if (m_CanPopLeft)
{
Gizmos.color = m_DebugSettings.LeftColor;
Gizmos.DrawWireSphere(m_StopPosition, 0.25f);
}
Gizmos.color = m_CanPopRight ? m_DebugSettings.ChangeStateColor : m_DebugSettings.RightColor;
Gizmos.DrawRay(m_RightCoverPopup.position, m_RightCoverPopup.forward * m_CheckCoverLength);
//Gizmos.DrawCube(m_RightCoverPopup.position, d_GizmoCubeSize);
Gizmos.DrawSphere(m_RightCoverPopup.position, m_DebugSettings.GizmoSize);
GizmosUtils.DrawString("Right Cover", m_RightCoverPopup.position + Vector3.up * 0.5f, Color.black);
if (m_CanPopRight)
{
Gizmos.color = m_DebugSettings.RightColor;
Gizmos.DrawWireSphere(m_StopPosition, 0.25f);
}
}
}
}
//protected Vector3 CalculateVelocity( Vector3 target, Vector3 origin, float time )
//{
// // Define the distance x and y first.
// Vector3 distance = target - origin;
// Vector3 distanceXZ = distance;
// distanceXZ.y = 0;
// // Create a float that repsents our distance
// float verticalDistance = distance.y; // vertical distance
// float horizontalDistance = distanceXZ.magnitude; // horizontal distance
// // Calculate the initial velocity. This is distance / time.
// float velocityXZ = horizontalDistance / time;
// float velocityY = (verticalDistance / time) + 0.5f * Mathf.Abs(Physics.gravity.y) * time;
// Vector3 result = distanceXZ.normalized;
// result *= velocityXZ;
// result.y = velocityY;
// return result;
//}
protected virtual void OnDrawGizmos()
{
if (Application.isPlaying && m_IsActive && m_Debug)
{
//Gizmos.color = Color.green;
//Gizmos.DrawRay(m_Transform.position + (Vector3.up * m_CheckHeight), m_Transform.forward * m_MoveToVaultDistance);
Gizmos.color = Color.magenta;
Gizmos.DrawWireSphere(startPosition, 0.15f);
Gizmos.color = Color.cyan;
GizmosUtils.DrawMarker(endEdgeOffset, 0.15f, Color.cyan);
Gizmos.color = Color.yellow;
Gizmos.DrawWireSphere(endPosition, 0.15f);
}
}
protected virtual void DrawGizmos()
{
if (m_DrawDebugLine)
{
Gizmos.color = Color.green;
Gizmos.DrawRay(transform.position + Vector3.up * 1.5f, LookDirection);
GizmosUtils.DrawText(GUI.skin, "LookDirection", transform.position + Vector3.up * 1.5f + LookDirection, Color.green);
Gizmos.color = Color.blue;
Gizmos.DrawRay(RaycastOrigin, m_MoveDirection);
Gizmos.color = Color.green;
GizmosUtils.DrawArrow(RaycastOrigin, m_Rigidbody.velocity);
GizmosUtils.DrawText(GUI.skin, "Velocity", RaycastOrigin + transform.forward, Color.green);
}
GizmosUtils.DrawText(GUI.skin, Movement.ToString(), transform.position + Vector3.up * 1.8f, Color.black);
}
private void OnDrawGizmos()
{
GizmosUtils.DrawText(GUI.skin, " " + id, transform.position + Vector3.down * 1.5f, Color.yellow, 16, 0);
if (destinationScene.ScenePath == this.gameObject.scene.path)
{
PortalComponent destinationPortalRef = PortalComponentCache.GetPortal(destinationId);
if (destinationPortalRef != null)
{
GizmosUtils.DrawArrow(transform.position, destinationPortalRef.transform.position, Color.yellow, 2.0f);
}
}
else if (destinationScene.ScenePath != string.Empty)
{
Gizmos.color = Color.yellow;
Gizmos.DrawWireSphere(transform.position, 0.7f);
Gizmos.DrawWireSphere(transform.position, 0.5f);
}
}
void OnDrawGizmos()
{
if (result == null)
{
return;
}
Gizmos.color = Color.yellow;
for (int i = 0; i < result.clusters.Length; i++)
{
if (showClustered)
{
Color color = Color.HSVToRGB(1f * i / result.clusters.Length, 1f, 1f);
Gizmos.color = color;
}
for (int j = 0; j < result.clusters[i].Length; j++)
{
GizmosUtils.DrawText(GUI.skin, i.ToString(), new Vector3(data[result.clusters[i][j]].x, 0, data[result.clusters[i][j]].y), Gizmos.color, 10);
}
}
}
private void OnDrawGizmos()
{
if (Application.isPlaying)
{
if (m_DebugDrawLookRay)
{
if (m_LookAtPoint != Vector3.zero)
{
Gizmos.color = Color.cyan;
Gizmos.DrawLine(m_Transform.position + Vector3.up * 1.35f, m_LookAtPoint);
Gizmos.DrawSphere(m_LookAtPoint, 0.1f);
}
if (m_controller.Aiming)
{
Gizmos.color = Color.magenta;
Gizmos.DrawRay(m_AimPivot.position, (m_AimPivot.forward * 50));
GizmosUtils.DrawString("Aim Direction", m_AimPivot.position, Color.magenta);
}
}
}
}
void OnDrawGizmos()
{
if (result == null)
{
return;
}
Gizmos.color = Color.yellow;
for (int i = 0; i < result.clusters.Length; i++)
{
if (showClustered)
{
Color color = Color.HSVToRGB(1f * i / result.clusters.Length, 1f, 1f);
//color.a = 0.5f;
Gizmos.color = color;
}
for (int j = 0; j < result.clusters[i].Length; j++)
{
//Gizmos.DrawSphere(data[result.clusters[i][j]], 0.1f);
GizmosUtils.DrawText(GUI.skin, i.ToString(), data[result.clusters[i][j]], Gizmos.color, 10);
}
}
}
protected virtual void OnDrawGizmos()
{
if (Application.isPlaying && m_isActive && m_Debug)
{
//Gizmos.color = Color.green;
//Gizmos.DrawRay(m_transform.position + (Vector3.up * m_CheckHeight), m_transform.forward * m_MoveToVaultDistance);
Gizmos.color = Color.magenta;
Gizmos.DrawWireSphere(startPosition, 0.08f);
Gizmos.color = Color.cyan;
GizmosUtils.DrawMarker(startReach, 0.12f, Color.cyan);
Gizmos.color = Color.cyan;
GizmosUtils.DrawMarker(endReach, 0.12f, Color.cyan);
Gizmos.color = Color.yellow;
Gizmos.DrawWireSphere(endPosition, m_collider.radius * 0.5f);
//motionPath.DrawMotionPath();
}
}
public static bool IntersectWith(Fan _fan, Rectangle _rect)
{
//条件一：矩形四个角落的判断
var coners = _rect.Coners;
for (int i = 0; i < 4; i++)
{
if (_fan.ContainPoint(coners[i]))
{
return(true);
}
}
//条件二：扇形的两个边点落在矩形内
if (_rect.ContainPoint(_fan.Left))
{
return(true);
}
if (_rect.ContainPoint(_fan.Right))
{
return(true);
}
//条件三：彼此中心点
if (_rect.ContainPoint(_fan.m_center))
{
return(true);
}
if (_fan.ContainPoint(_rect.m_center))
{
return(true);
}
//条件四，矩形的边和弧相交
var begin = _fan.m_center;
var end = _rect.m_center;
var v = end - begin;
//圆的方程（x - xc）^2 + ( y - yc ) ^ 2 = r^2
//线段的方程
// x = v.x * t + begin.x
// y = v.y * t + begin.y
//求扇形圆心和矩形的中心线段
//把线段方程代入可以得到一个二次方程
//把它化为形如 a * x^2 + 2 * b * x + c = 0
//如果 x 有解，说明相交，无解
//b^2 - a *c >= 0，有解
var dx = _fan.m_center.x - begin.x;
var dy = _fan.m_center.y - begin.y;
var sqr_r = _fan.Length * _fan.Length;
var a = v.x * v.x + v.y * v.y;
var b = -(dx * v.x + dy * v.y);
var c = dx * dx + dy * dy - sqr_r;
var d = b * b - a * c;
Color old = Gizmos.color;
Gizmos.color = Color.white;
Gizmos.DrawLine(begin.ToXZ(), end.ToXZ());
Gizmos.color = old;
if (d >= 0) // 有解
{
var t = (-b + Mathf.Sqrt(d)) / a;
var x = v.x * t + begin.x;
var y = v.y * t + begin.y;
var point = new Vector2(x, y);
GizmosUtils.DrawPoint(point);
//扇形只会包含其中一个解
var left = _fan.Left;
var right = _fan.Right;
if (_rect.ContainPoint(point) && point.Between(_fan.m_center, left, right))
{
return(true);
}
//另一个方向
t = (-b + Mathf.Sqrt(d)) / a;
x = v.x * t + begin.x;
y = v.y * t + begin.y;
point = new Vector2(x, y);
GizmosUtils.DrawPoint(point);
if (_rect.ContainPoint(point) && point.Between(_fan.m_center, left, right))
{
return(true);
}
}
else
{
//无解，说明要么扇形包含矩形中心，要么矩形包含扇形圆心，否则就不相交
}
return(false);
}
public void DrawGizmos(bool selected)
{
if (debugSettings == null)
{
return;
}
Color color = debugSettings.defaultColor;
switch (spawnType)
{
case SpawnType.SpawnOnly:
color = debugSettings.spawnColor;
break;
case SpawnType.RespawnOnly:
color = debugSettings.respawnColor;
break;
default:
color = debugSettings.defaultColor;
break;
}
if (!selected)
{
//color.a = color.a * 0.25f;
color = debugSettings.defaultColor;
}
if (Event.current.type == EventType.Repaint)
{
Gizmos.color = color;
if (selected)
{
Gizmos.DrawSphere(transform.position, debugSettings.gizmoSize);
}
Gizmos.DrawWireSphere(transform.position, radius);
if (selected)
{
Color diskColor = color;
diskColor.a = color.a * 0.2f;
UnityEditor.Handles.color = diskColor;
UnityEditor.Handles.DrawSolidDisc(transform.position, transform.up, radius);
}
UnityEditor.Handles.color = color;
UnityEditor.Handles.ArrowHandleCap(
0,
transform.position + transform.up * radius,
Quaternion.LookRotation(transform.forward),
radius,
EventType.Repaint);
var displayText = gameObject.name + "\n" + transform.position.ToString();
GizmosUtils.DrawString(displayText, transform.position + Vector3.up, debugSettings.textColor);
}
}
public void OnDrawGizmos()
{
GizmosUtils.SetT(transform);
GizmosUtils.DrawArrow(Vector3.zero, CounterSlipForce, CounterSlipForce.magnitude / GizmosThrustDivider);
}
private void OnDrawGizmos()
{
#if UNITY_EDITOR
if (controlMode == VisualizationColor.Static)
{
Gizmos.color = new Color(0.529f, 0.808f, 0.922f, 0.6f);
}
else
{
Gizmos.color = new Color(0.906f, 0.576f, 0.443f, 0.6f);
}
// Width and depth of surface
float width = transform.lossyScale.x, depth = transform.lossyScale.z;
// Project wind on UP/FORWARD plane of wing
Vector3 WindProjection = Vector3.ProjectOnPlane(-Wind, transform.right);
void renderSurface()
{
GizmosUtils.DrawPlane(Vector3.zero, new Vector2(width, depth), Color.black);
}
void renderArrows()
{
GizmosUtils.DrawArrow(Vector3.zero, DragForce, DragForce.magnitude / GizmosDragDivisor, Color.red);
GizmosUtils.DrawArrow(Vector3.zero, LiftForce, LiftForce.magnitude / GizmosLiftDivisor, Color.blue);
if (showWorldWind)
{
GizmosUtils.DrawArrow(Vector3.zero, manager.environment.CalculateWind(transform.position), manager.environment.CalculateWind(transform.position).magnitude, Color.cyan);
}
if (showFront)
{
GizmosUtils.DrawArrow(Vector3.zero, transform.forward, 1, Color.yellow);
}
if (showWind)
{
GizmosUtils.DrawArrow(-Wind, Wind, Wind.magnitude, Color.green);
}
if (showWindSpeedFront)
{
GizmosUtils.DrawLine(transform.forward, WindProjection.normalized, Color.grey);
GizmosUtils.DrawArrow(WindProjection, -WindProjection, WindProjection.magnitude, Color.magenta);
}
}
// Render plane with rotation, arrows global space
GizmosUtils.SetTR(transform);
renderSurface();
GizmosUtils.SetT(transform);
renderArrows();
// Render plane static with rotating forces
if (showLocalSpaceCopy)
{
Gizmos.matrix = Matrix4x4.TRS(transform.position + Vector3.right * 4, Quaternion.identity, Vector3.one);
renderSurface();
Gizmos.matrix = Matrix4x4.TRS(transform.position + Vector3.right * 4, Quaternion.Inverse(transform.rotation), Vector3.one);
renderArrows();
}
#endif
}
private void OnDrawGizmos()
{
GizmosUtils.SetT(transform);
Gizmos.DrawSphere(Vector3.zero, 2.0f);
GizmosUtils.DrawArrow(Vector3.zero, transform.forward, 5.0f);
}
private void OnDrawGizmos()
{
Gizmos.color = Color.red.WithAlpha(0.3f);
GizmosUtils.DrawRect(GetBounds(), 20, 15);
}
private void OnDrawGizmos()
{
GizmosUtils.DrawText(GUI.skin, transform.name, transform.position, textColor, fontSize, yOffset);
}
private void OnDrawGizmos()
{
GizmosUtils.DrawText(CustomEditorPrefs.GizmoGuiSkin, name, transform.position);
}
private void OnDrawGizmos()
{
GizmosUtils.DrawFan(m_fan, m_color);
}
void OnDrawGizmosSelected()
{
Gizmos.color = Color.green;
GizmosUtils.DrawRect(SceneBounds.ToRect());
}
private void OnDrawGizmos()
{
Gizmos.color = Color.blue.WithAlpha(0.3f);
GizmosUtils.DrawSquareGrid(transform.position, GetSpawnSquareSize(), _maxMobsPerWave);
}