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); }