unity drawing

using System.Reflection;

using UnityEngine;

// Line drawing routine originally courtesy of Linusmartensson:

// http://forum.unity3d.com/threads/71979-Drawing-lines-in-the-editor

//

// Rewritten to improve performance by Yossarian King / August 2013.

//

// This version produces virtually identical results to the original (tested by drawing

// one over the other and observing errors of one pixel or less), but for large numbers

// of lines this version is more than four times faster than the original, and comes

// within about 70% of the raw performance of Graphics.DrawTexture.

//

// Peak performance on my laptop is around 200,000 lines per second. The laptop is

// Windows 7 64-bit, Intel Core2 Duo CPU 2.53GHz, 4G RAM, NVIDIA GeForce GT 220M.

// Line width and anti-aliasing had negligible impact on performance.

//

// For a graph of benchmark results in a standalone Windows build, see this image:

// https://app.box.com/s/hyuhi565dtolqdm97e00

//

// For a Google spreadsheet with full benchmark results, see:

// https://docs.google.com/spreadsheet/ccc?key=0AvJlJlbRO26VdHhzeHNRMVF2UHZHMXFCTVFZN011V1E&usp=sharing

public static class Drawing

{

private static Texture2D aaLineTex = null;

private static Texture2D lineTex = null;

private static Material blitMaterial = null;

private static Material blendMaterial = null;

private static Rect lineRect = new Rect(0, 0, 1, 1);

// Draw a line in screen space, suitable for use from OnGUI calls from either

// MonoBehaviour or EditorWindow. Note that this should only be called during repaint

// events, when (Event.current.type == EventType.Repaint).

//

// Works by computing a matrix that transforms a unit square -- Rect(0,0,1,1) -- into

// a scaled, rotated, and offset rectangle that corresponds to the line and its width.

// A DrawTexture call used to draw a line texture into the transformed rectangle.

//

// More specifically:

//      scale x by line length, y by line width

//      rotate around z by the angle of the line

//      offset by the position of the upper left corner of the target rectangle

//

// By working out the matrices and applying some trigonometry, the matrix calculation comes

// out pretty simple. See https://app.box.com/s/xi08ow8o8ujymazg100j for a picture of my

// notebook with the calculations.

public static void DrawLine(Vector2 pointA, Vector2 pointB, Color color, float width, bool antiAlias)

{

// Normally the static initializer does this, but to handle texture reinitialization

// after editor play mode stops we need this check in the Editor.

#if UNITY_EDITOR

if (!lineTex)

{

Initialize();

}

#endif

// Note that theta = atan2(dy, dx) is the angle we want to rotate by, but instead

// of calculating the angle we just use the sine (dy/len) and cosine (dx/len).

float dx = pointB.x - pointA.x;

float dy = pointB.y - pointA.y;

float len = Mathf.Sqrt(dx * dx + dy * dy);

// Early out on tiny lines to avoid divide by zero.

// Plus what's the point of drawing a line 1/1000th of a pixel long??

if (len < 0.001f)

{

return;

}

// Pick texture and material (and tweak width) based on anti-alias setting.

Texture2D tex;

Material mat;

if (antiAlias)

{

// Multiplying by three is fine for anti-aliasing width-1 lines, but make a wide "fringe"

// for thicker lines, which may or may not be desirable.

width = width * 3.0f;

tex = aaLineTex;

mat = blendMaterial;

}

else

{

tex = lineTex;

mat = blitMaterial;

}

float wdx = width * dy / len;

float wdy = width * dx / len;

Matrix4x4 matrix = Matrix4x4.identity;

matrix.m00 = dx;

matrix.m01 = -wdx;

matrix.m03 = pointA.x + 0.5f * wdx;

matrix.m10 = dy;

matrix.m11 = wdy;

matrix.m13 = pointA.y - 0.5f * wdy;

// Use GL matrix and Graphics.DrawTexture rather than GUI.matrix and GUI.DrawTexture,

// for better performance. (Setting GUI.matrix is slow, and GUI.DrawTexture is just a

// wrapper on Graphics.DrawTexture.)

GL.PushMatrix();

GL.MultMatrix(matrix);

//Graphics.DrawTexture(lineRect, tex, lineRect, 0, 0, 0, 0, color, mat);

//Replaced by:

GUI.color = color;//this and...

GUI.DrawTexture( lineRect, tex );//this

GL.PopMatrix();

}

//

public static void DrawCircle(float x, float y, float z, float r, float accuracy)

{

GL.PushMatrix();

//绘制2D图像

GL.LoadOrtho();

float stride = r * accuracy;

float size = 1 / accuracy;

float x1 = x, x2 = x, y1 = 0, y2 = 0;

float x3 = x, x4 = x, y3 = 0, y4 = 0;

double squareDe;

squareDe = r * r - Mathf.Pow(x - x1, 2);

squareDe = squareDe > 0 ? squareDe : 0;

y1 = (float)(y + Mathf.Sqrt((float)squareDe));

squareDe = r * r - Mathf.Pow(x - x1, 2);

squareDe = squareDe > 0 ? squareDe : 0;

y2 = (float)(y - Mathf.Sqrt((float)squareDe));

for (int i = 0; i < size; i++)

{

x3 = x1 + stride;

x4 = x2 - stride;

squareDe = r * r - Mathf.Pow(x - x3, 2);

squareDe = squareDe > 0 ? squareDe : 0;

y3 = (float)(y + Mathf.Sqrt((float)squareDe));

squareDe = r * r - Mathf.Pow(x - x4, 2);

squareDe = squareDe > 0 ? squareDe : 0;

y4 = (float)(y - Mathf.Sqrt((float)squareDe));

//绘制线段

GL.Begin(GL.LINES);

GL.Color(Color.blue);

GL.Vertex(new Vector3(x1 / Screen.width, y1 / Screen.height, z));

GL.Vertex(new Vector3(x3 / Screen.width, y3 / Screen.height, z));

GL.End();

GL.Begin(GL.LINES);

GL.Color(Color.blue);

GL.Vertex(new Vector3(x2 / Screen.width, y1 / Screen.height, z));

GL.Vertex(new Vector3(x4 / Screen.width, y3 / Screen.height, z));

GL.End();

GL.Begin(GL.LINES);

GL.Color(Color.blue);

GL.Vertex(new Vector3(x1 / Screen.width, y2 / Screen.height, z));

GL.Vertex(new Vector3(x3 / Screen.width, y4 / Screen.height, z));

GL.End();

GL.Begin(GL.LINES);

GL.Color(Color.blue);

GL.Vertex(new Vector3(x2 / Screen.width, y2 / Screen.height, z));

GL.Vertex(new Vector3(x4 / Screen.width, y4 / Screen.height, z));

GL.End();

x1 = x3;

x2 = x4;

y1 = y3;

y2 = y4;

}

GL.PopMatrix();

}

public static void DrawCircle(Vector2 center, int radius, Color color, float width, int segmentsPerQuarter) {

DrawCircle(center, radius, color, width, false, segmentsPerQuarter);

}

public static void DrawCircle(Vector2 center, int radius, Color color, float width, bool antiAlias, int segmentsPerQuarter) {

float rh = (float)radius / 2;

Vector2 p1 = new Vector2(center.x, center.y - radius);

Vector2 p1_tan_a = new Vector2(center.x - rh, center.y - radius);

Vector2 p1_tan_b = new Vector2(center.x + rh, center.y - radius);

Vector2 p2 = new Vector2(center.x + radius, center.y);

Vector2 p2_tan_a = new Vector2(center.x + radius, center.y - rh);

Vector2 p2_tan_b = new Vector2(center.x + radius, center.y + rh);

Vector2 p3 = new Vector2(center.x, center.y + radius);

Vector2 p3_tan_a = new Vector2(center.x - rh, center.y + radius);

Vector2 p3_tan_b = new Vector2(center.x + rh, center.y + radius);

Vector2 p4 = new Vector2(center.x - radius, center.y);

Vector2 p4_tan_a = new Vector2(center.x - radius, center.y - rh);

Vector2 p4_tan_b = new Vector2(center.x - radius, center.y + rh);

DrawBezierLine(p1, p1_tan_b, p2, p2_tan_a, color, width, antiAlias, segmentsPerQuarter);

DrawBezierLine(p2, p2_tan_b, p3, p3_tan_b, color, width, antiAlias, segmentsPerQuarter);

DrawBezierLine(p3, p3_tan_a, p4, p4_tan_b, color, width, antiAlias, segmentsPerQuarter);

DrawBezierLine(p4, p4_tan_a, p1, p1_tan_a, color, width, antiAlias, segmentsPerQuarter);

}

// Other than method name, DrawBezierLine is unchanged from Linusmartensson's original implementation.

public static void DrawBezierLine(Vector2 start, Vector2 startTangent, Vector2 end, Vector2 endTangent, Color color, float width, bool antiAlias, int segments)

{

Vector2 lastV = CubeBezier(start, startTangent, end, endTangent, 0);

for (int i = 1; i < segments + 1; ++i)

{

Vector2 v = CubeBezier(start, startTangent, end, endTangent, i/(float)segments);

Drawing.DrawLine(lastV, v, color, width, antiAlias);

lastV = v;

}

}

private static Vector2 CubeBezier(Vector2 s, Vector2 st, Vector2 e, Vector2 et, float t)

{

float rt = 1 - t;

return rt * rt * rt * s + 3 * rt * rt * t * st + 3 * rt * t * t * et + t * t * t * e;

}

// This static initializer works for runtime, but apparently isn't called when

// Editor play mode stops, so DrawLine will re-initialize if needed.

static Drawing()

{

Initialize();

}

private static void Initialize()

{

if (lineTex == null)

{

lineTex = new Texture2D(1, 1, TextureFormat.ARGB32, false);

lineTex.SetPixel(0, 1, Color.white);

lineTex.Apply();

}

if (aaLineTex == null)

{

// TODO: better anti-aliasing of wide lines with a larger texture? or use Graphics.DrawTexture with border settings

aaLineTex = new Texture2D(1, 3, TextureFormat.ARGB32, false);

aaLineTex.SetPixel(0, 0, new Color(1, 1, 1, 0));

aaLineTex.SetPixel(0, 1, Color.white);

aaLineTex.SetPixel(0, 2, new Color(1, 1, 1, 0));

aaLineTex.Apply();

}

// GUI.blitMaterial and GUI.blendMaterial are used internally by GUI.DrawTexture,

// depending on the alphaBlend parameter. Use reflection to "borrow" these references.

blitMaterial = (Material)typeof(GUI).GetMethod("get_blitMaterial", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, null);

blendMaterial = (Material)typeof(GUI).GetMethod("get_blendMaterial", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, null);

}

}