void OnSceneUI(SceneView sceneView)
{
if (mHitData != null)
{
HitCheckBase hitCheck = mHitData.hitCheckData;
Vector3 pos = debugDummy.transform.TransformPoint(mHitData.startPosition) + hitCheck.posOffset;
Vector3 normal = debugDummy.transform.up;
if (mHitData.moveSpeed > 0)
{
Vector3 startDir = debugDummy.transform.TransformDirection(mHitData.startDirection.normalized);
Handles.ArrowCap(0, pos, Quaternion.LookRotation(startDir.normalized), 2f);
}
if (hitCheck.shapeType == EHitCheckShape.Fan)
{
Vector3 startVec = Quaternion.AngleAxis(-hitCheck.angle * 0.5f, normal) * debugDummy.transform.forward;
GizmosExtension.DrawFanShapeWithHeight(pos, normal, startVec, hitCheck.angle, hitCheck.radius, hitCheck.height);
}
else if (hitCheck.shapeType == EHitCheckShape.Capsule || hitCheck.shapeType == EHitCheckShape.Cylinder)
{
GizmosExtension.DrawCylinder(pos, normal, debugDummy.transform.forward, hitCheck.radius, hitCheck.height);
}
else if (hitCheck.shapeType == EHitCheckShape.LaserBeam)
{
}
}
}
/// <summary>
/// - Gizmoss a cylinder.
/// </summary>
/// <param name='start'>
/// - The position of one end of the cylinder.
/// </param>
/// <param name='end'>
/// - The position of the other end of the cylinder.
/// </param>
/// <param name='color'>
/// - The color of the cylinder.
/// </param>
/// <param name='radius'>
/// - The radius of the cylinder.
/// </param>
/// <param name='duration'>
/// - How long to draw the cylinder.
/// </param>
/// <param name='depthTest'>
/// - Whether or not the cylinder should be faded when behind other objects.
/// </param>
public static void GizmosCylinder(Vector3 start, Vector3 end, float radius = 1)
{
Vector3 up = (end - start).normalized * radius;
Vector3 forward = Vector3.Slerp(up, -up, 0.5f);
Vector3 right = Vector3.Cross(up, forward).normalized *radius;
//Radial circles
GizmosExtension.GizmosCircle(start, up, radius);
GizmosExtension.GizmosCircle(end, -up, radius);
GizmosExtension.GizmosCircle((start + end) * 0.5f, up, radius);
//Side lines
Gizmos.DrawLine(start + right, end + right);
Gizmos.DrawLine(start - right, end - right);
Gizmos.DrawLine(start + forward, end + forward);
Gizmos.DrawLine(start - forward, end - forward);
//Start endcap
Gizmos.DrawLine(start - right, start + right);
Gizmos.DrawLine(start - forward, start + forward);
//End endcap
Gizmos.DrawLine(end - right, end + right);
Gizmos.DrawLine(end - forward, end + forward);
}
void OnDrawGizmos()
{
for (int i = 0; i < transform.childCount; i++)
{
GizmosExtension.DrawLine(transform.GetChild(i).position, transform.GetChild((i + 1) % transform.childCount).position, Color.cyan);
}
}
public override void Draw()
{
Gizmos.color = Color.green;
#if UNITY_EDITOR
GizmosExtension.DrawIsoMesh(capsuleMesh, IsoTransform.Position + Center, Vector3.one);
#endif
}
void OnDrawGizmosSelected()
{
if (m_portals != null)
{
foreach (Vector3 portal in m_portals)
{
Vector3 worldPos = transform.TransformPoint(portal);
Gizmos.DrawIcon(worldPos, "icon_portal");
}
}
if (m_waypoints != null)
{
for (int i = 0; i < m_waypoints.Length; ++i)
{
Vector3 waypoint = m_waypoints[i];
Vector3 nextWaypoint = m_waypoints[(i + 1) % m_waypoints.Length];
Vector3 worldPos = transform.TransformPoint(waypoint);
Gizmos.DrawIcon(worldPos, "icon_waypoint");
GizmosExtension.DrawConnectedLine(worldPos, transform.TransformPoint(nextWaypoint));
}
}
}
private void OnDrawGizmos()
{
if (Slices != null && (viewParameters.drawSlices || viewParameters.drawSliceAABB))
{
foreach (Slice slice in Slices)
{
foreach (FourierCurve curve in slice.curves)
{
if (viewParameters.drawSlices)
{
GizmosExtension.DrawCurve(curve, slice.LocalX, slice.LocalY, slice.RefPoint, GizmosExtension.lightGreen);
}
if (viewParameters.drawSliceAABB)
{
GizmosExtension.DrawRectangle(curve.AABB, slice.LocalX, slice.LocalY, slice.RefPoint, GizmosExtension.lightRed);
}
}
}
}
if (viewParameters.drawBoundingSphere && BoundingSphere.CenterW != null)
{
Gizmos.color = GizmosExtension.lightBlue;
Gizmos.DrawWireSphere(BoundingSphere.CenterW, BoundingSphere.Radius);
//Gizmos.DrawSphere(BoundingSphere.Center, BoundingSphere.Radius);
}
}
void DrawAt(Vector3 position)
{
var scale = this.scale;
if (useTransformScale)
{
scale = transform.lossyScale.x;
}
if (showSphere)
{
Gizmos.DrawSphere(position, scale);
}
if (showWireSphere)
{
Gizmos.DrawWireSphere(position, scale);
}
//if (showWireCube) Gizmos.DrawWireCube(position, Vector3.one * scale);
if (showWireCube)
{
GizmosExtension.DrawTransformWireCube(transform);
}
Gizmos.matrix = Matrix4x4.LookAt(transform.position, transform.position + transform.forward, transform.up);
if (showForwardDirection)
{
Gizmos.DrawFrustum(Vector3.zero, 30, 0, scale, 1);
}
Gizmos.matrix = Matrix4x4.identity;
}
/// <summary>
/// - Gizmoss a cone.
/// </summary>
/// <param name='position'>
/// - The position for the tip of the cone.
/// </param>
/// <param name='direction'>
/// - The direction for the cone gets wider in.
/// </param>
/// <param name='angle'>
/// - The angle of the cone.
/// </param>
/// <param name='color'>
/// - The color of the cone.
/// </param>
/// <param name='duration'>
/// - How long to draw the cone.
/// </param>
/// <param name='depthTest'>
/// - Whether or not the cone should be faded when behind other objects.
/// </param>
public static void GizmosCone(Vector3 position, Vector3 direction, float angle = 45)
{
float length = direction.magnitude;
Vector3 _forward = direction;
Vector3 _up = Vector3.Slerp(_forward, -_forward, 0.5f);
Vector3 _right = Vector3.Cross(_forward, _up).normalized *length;
direction = direction.normalized;
Vector3 slerpedVector = Vector3.Slerp(_forward, _up, angle / 90.0f);
float dist;
var farPlane = new Plane(-direction, position + _forward);
var distRay = new Ray(position, slerpedVector);
farPlane.Raycast(distRay, out dist);
Gizmos.DrawRay(position, slerpedVector.normalized * dist);
Gizmos.DrawRay(position, Vector3.Slerp(_forward, -_up, angle / 90.0f).normalized *dist);
Gizmos.DrawRay(position, Vector3.Slerp(_forward, _right, angle / 90.0f).normalized *dist);
Gizmos.DrawRay(position, Vector3.Slerp(_forward, -_right, angle / 90.0f).normalized *dist);
GizmosExtension.GizmosCircle(position + _forward, direction, (_forward - (slerpedVector.normalized * dist)).magnitude);
GizmosExtension.GizmosCircle(position + (_forward * 0.5f), direction, ((_forward * 0.5f) - (slerpedVector.normalized * (dist * 0.5f))).magnitude);
}
void DrawGizmos()
{
if (ShowHitDebug == false)
{
return;
}
if (mHitData != null && mOwner != null && mOwner.transform != null)
{
HitCheckBase hitCheck = mHitData.hitCheckData;
Vector3 normal = mOwner.transform.up;
if (hitCheck.shapeType == EHitCheckShape.Fan)
{
Vector3 startVec = Quaternion.AngleAxis(-hitCheck.angle * 0.5f, normal) * mOwner.transform.forward;
GizmosExtension.DrawFanShapeWithHeight(pos, normal, startVec, hitCheck.angle, hitCheck.radius, hitCheck.height);
}
else if (hitCheck.shapeType == EHitCheckShape.Cylinder || hitCheck.shapeType == EHitCheckShape.Capsule)
{
GizmosExtension.DrawCylinder(pos, normal, forwardDir, hitCheck.radius, hitCheck.height);
}
else if (hitCheck.shapeType == EHitCheckShape.LaserBeam)
{
GizmosExtension.DrawLaserBeam(pos, moveDirection, hitCheck.radius, hitCheck.height);
}
}
}
private void OnDrawGizmos()
{
var isoTransform = GetComponent <IsoTransform>();
var mesh = CreateMesh();
GetComponent <MeshFilter>().mesh = mesh;
GizmosExtension.DrawIsoMesh(mesh, isoTransform.Position, isoTransform.Size);
// Gizmos.DrawWireMesh(mesh,isoTransform.Position);
}
void DrawParable(Vector2 velocity)
{
Vector2 start = (Vector2)transform.position;
Vector2 end = GizmosExtension.DrawParabel(start, velocity, Physics2D.gravity.y);
//Player start
Gizmos.DrawWireCube(start, Vector3.one);
//Player end
Gizmos.DrawWireCube(end, Vector3.one);
}
public void Draw()
{
var isoCollider = GetComponent<IsoCollider>();
if (isoCollider != null && isoCollider.isActiveAndEnabled)
isoCollider.Draw();
else {
Gizmos.color = Color.white;
GizmosExtension.DrawIsoWireCube(Position, Size);
}
}
public override void Draw()
{
base.Draw();
Gizmos.color = Color.green;
Size = Size == Vector3.zero ? IsoTransform.Size : Size;
if (IsoTransform != null)
{
GizmosExtension.DrawIsoWireCube(IsoTransform.Position + Center, Size);
}
}
private void OnDrawGizmos()
{
if (Samples.Count > 0)
{
var positionAvg = MathUtility.Average(Samples.Select(t => t.Item1));
var rotationAvg = MathUtility.Average(Samples.Select(t => t.Item2));
Gizmos.DrawCube(positionAvg, Vector3.one * 0.01f);
GizmosExtension.DrawRotation(positionAvg, rotationAvg, 0.1f);
}
}
void OnDrawGizmos()
{
// GizmosExtension.DrawCircle(transform.position, ViewRadius, Color.white, 32);
// GizmosExtension.DrawLine(transform.position, transform.position + DirectionFromAngle(ViewAngle / 2.0f) * ViewRadius, Color.white);
// GizmosExtension.DrawLine(transform.position, transform.position + DirectionFromAngle(-ViewAngle / 2.0f) * ViewRadius, Color.white);
if (_targetFound)
{
GizmosExtension.DrawLine(transform.position, _targetFound.position, Color.red);
}
}
private void OnDrawGizmosSelected()
{
Gizmos.color = Color.Lerp(Create.debugColor, Color.black, 0.3f);
Vector2 start = (Vector2)transform.position + Create.debugOffset * 4;
Vector2 velocity = Controller2D.GetJumpSpeed(jumpHeight) * Vector2.up + Create.debugOffset * 2f;
Vector2 end = GizmosExtension.DrawParabel(start, velocity, Physics2D.gravity.y);
//Block start
Gizmos.DrawWireCube(start, Vector3.one);
//Block end
Gizmos.DrawWireCube(end, Vector3.one);
}
private void OnDrawGizmos()
{
if (Application.isPlaying)
{
Gizmos.color = Color.blue;
Gizmos.DrawWireCube(Point1.transform.position, Vector3.one * 0.01f);
GizmosExtension.DrawRotation(Point1.transform.position, Point1.transform.rotation, 0.1f);
Gizmos.color = Color.green;
Gizmos.DrawWireCube(Point2.transform.position, Vector3.one * 0.01f);
GizmosExtension.DrawRotation(Point2.transform.position, Point2.transform.rotation, 0.1f);
}
}
private void OnDrawGizmos()
{
if (waypoints == null || waypoints.Count <= 1)
{
return;
}
Gizmos.color = Color.green;
for (int i = 1; i < waypoints.Count; i++)
{
GizmosExtension.DrawArrow(waypoints[i - 1].position, waypoints[i].position);
}
}
public override void Draw()
{
if (MCollider == null || MCollider.sharedMesh == null)
{
Debug.Log(name + ", IsoMeshCollider is missing a Mesh to show bounds. \n Add a mesh or delete the IsoMeshCollider component");
return;
}
if (IsoTransform == null)
{
IsoTransform = GetComponent <IsoTransform>();
}
Gizmos.color = Color.green;
GizmosExtension.DrawIsoMesh(Mesh, IsoTransform.Position, Scale);
}
private void OnDrawGizmosSelected()
{
Gizmos.color = Color.Lerp(Manipulate.debugColor, Color.black, 0.3f);
Vector2 start = (Vector2)transform.position + Manipulate.debugOffset * 3;
Vector2 velocity = (Manipulate.debugOffset + Vector2.up).normalized * speed;
Vector2 end = GizmosExtension.DrawParabel(start, velocity, Physics2D.gravity.y);
//Block start
Gizmos.DrawWireCube(start, Vector3.one);
//Trail
Gizmos.DrawLine(start, end);
//Block end
Gizmos.DrawWireCube(end, Vector3.one);
}
void DrawAspect(Camera cam, float h, float v, Color color, bool push = false)
{
Gizmos.color = color;
float ratiowidth = (cam.pixelHeight / v * h);
float x = (cam.pixelWidth / 2f) - (ratiowidth / 2f);
Vector3 point1 = cam.ScreenToWorldPoint(new Vector3(x, 0, 0));
Vector3 point2 = cam.ScreenToWorldPoint(new Vector3(x, cam.pixelHeight, 0));
Vector3 point3 = cam.ScreenToWorldPoint(new Vector3(x + ratiowidth, cam.pixelHeight, 0));
Vector3 point4 = cam.ScreenToWorldPoint(new Vector3(x + ratiowidth, 0, 0));
GizmosExtension.DrawPoly(point1, point2, point3, point4);
#if UNITY_EDITOR
GUIStyle style = new GUIStyle();
style.normal.textColor = color;
UnityEditor.Handles.Label(point4, (push?"\n":"") + h + ":" + v, style);
#endif
}
private void OnDrawGizmos()
{
Gizmos.color = Color.Lerp(Manipulate.debugColor, Color.black, 0.3f);
Vector2 start = (Vector2)transform.position + Manipulate.debugOffset * 2f;
Vector2 velocity = Controller2D.GetJumpSpeed(jumpHeight) * Vector2.up + Manipulate.debugOffset * 2f;
Vector2 end = GizmosExtension.DrawParabel(start, velocity, Physics2D.gravity.y);
//Block
Vector2 startBlock = start - velocity.normalized * 2;
Gizmos.DrawLine(startBlock, startBlock - velocity);
Gizmos.DrawWireCube(startBlock, Vector3.one);
//Player
Gizmos.color = PlayerController.debugColor;
//Player start
Gizmos.DrawWireCube(start, Vector3.one);
//Player end
Gizmos.DrawWireCube(end, Vector3.one);
}
// Used via button and editor to see current gridgraph set up
void OnDrawGizmos()
{
if (!ShowGraph)
{
return;
}
Gizmos.color = Color.red;
foreach (var gridPos in _gridGraph.Keys)
{
var node = _gridGraph[gridPos];
Gizmos.color = node.Passable ? Color.red : Color.black;
var center = new Vector3(node.Position.x, node.Position.y, node.Position.z);
var size = new Vector3(1, node.Height, 1);
GizmosExtension.DrawIsoWireCube(center, size);
foreach (var nextNode in node.NextNodes)
{
GizmosExtension.DrawIsoArrow(node.Position, nextNode.Position);
}
}
}
void OnDrawGizmos()
{
if (!ShowGraph)
{
return;
}
Gizmos.color = Color.red;
foreach (var gridPos in _gridGraph.Keys)
{
foreach (var gap in _gridGraph[gridPos])
{
Gizmos.color = gap.Passable ? Color.red : Color.black;
var center = new Vector3(gridPos.x, (gap.MaxY + gap.MinY) / 2, gridPos.y);
var size = new Vector3(1, gap.MaxY - gap.MinY, 1);
GizmosExtension.DrawIsoWireCube(center, size);
foreach (var nextNode in gap.NextNodes)
{
GizmosExtension.DrawIsoArrow(gap.Position, nextNode.Position);
}
}
}
}
void OnDrawGizmos()
{
CircleCollider2D circleCollider2D = GetComponent <CircleCollider2D> ();
GizmosExtension.DrawCircle(transform.position, circleCollider2D.radius, Color.blue, 32);
}
void OnDrawGizmos()
{
GizmosExtension.DrawCircle(Target.position, Vector3.Distance(Target.position, transform.position), Color.gray);
}
public void DrawGizmo()
{
GizmosExtension.DrawCircle(position, Vector3.up, radius);
}
void OnDrawGizmos()
{
Vector3 pos = transform.position + offset;
GizmosExtension.DrawFanShapeWithHeight(pos, transform.up, transform.right, angle, radius, height);
}
void OnDrawGizmos()
{
GizmosExtension.DrawCircle(transform.position, Radius, Color.white);
}
public override void Draw()
{
Gizmos.color = Color.green;
GizmosExtension.DrawIsoWireSphere(IsoTransform.Position + Center, Radius, 10.0f);
}
