# DrawAAPolyLine

> Draw anti-aliased line specified with point array and width.

## Definition

* **Type:** Method
* **Namespace:** [UnityEditor](/engine/6000.6/script-reference/unityeditor.md)
* **Assembly:** UnityEditor.CoreModule

## DrawAAPolyLine(Color\[], Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(Color[] colors, Vector3[] points)
```

### Parameters

**** (\[Color\[]]\(/engine/6000.6/script-reference/unityengine/color)): The colors to apply to each point. Must match the length of the points array or actualNumberOfPoints, whichever is lower and greater than zero.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(float, Color\[], Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(float width, Color[] colors, Vector3[] points)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The width of the line.**** (\[Color\[]]\(/engine/6000.6/script-reference/unityengine/color)): The colors to apply to each point. Must match the length of the points array or actualNumberOfPoints, whichever is lower and greater than zero.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(params Vector3[] points)
```

### Parameters

**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(float, Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(float width, params Vector3[] points)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The width of the line.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(Texture2D, Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(Texture2D lineTex, params Vector3[] points)
```

### Parameters

**** (\[Texture2D]\(/engine/6000.6/script-reference/unityengine/texture2d)): The AA texture used for rendering.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(float, int, Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(float width, int actualNumberOfPoints, params Vector3[] points)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The width of the line.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The total number of vertices to draw of the points array. Use this to keep a reusable buffer of point values without the need to resize frequently.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```

## DrawAAPolyLine(Texture2D, float, Vector3\[])

Draw anti-aliased line specified with point array and width.

```csharp
public static void DrawAAPolyLine(Texture2D lineTex, float width, params Vector3[] points)
```

### Parameters

**** (\[Texture2D]\(/engine/6000.6/script-reference/unityengine/texture2d)): The AA texture used for rendering.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): The width of the line.**** (\[Vector3\[]]\(/engine/6000.6/script-reference/unityengine/vector3)): List of points to build the line from.

### Remarks

**Note:** Use [HandleUtility.GetHandleSize](/engine/6000.6/script-reference/unityeditor/handleutility/gethandlesize.md) where you might want to have constant screen-sized handles.

**Note:** To get an anti-aliased effect use a texture that is 1x2 pixels with one transparent white pixel and one opaque white pixel.

### Examples

```csharp
using UnityEditor;
using UnityEngine;

public class ArrowDrawer : MonoBehaviour
{
    public void DrawArrow(Color color, float arrowThickness, float lineThickness, float shorten, Vector3 start, Vector3 end)
    {
        var length = (end - start).magnitude;
        if (length < 0.001f)
            return;

        var forward = (end - start) / length;
        var right = Vector3.Cross(Vector3.up, forward).normalized;

        var width = arrowThickness * 0.5f;
        var height = arrowThickness * 0.7f;

        start += forward * shorten;
        end -= forward * shorten;

        var arrowHead = new Vector3[3]
        {
            end,
            end - forward * height + right * width,
            end - forward * height - right * width
        };

        var arrowLine = new Vector3[2]
        {
            start,
            end - forward * height
        };

        Handles.color = color;
        Handles.DrawAAPolyLine(lineThickness, 2, arrowLine);
        Handles.DrawAAConvexPolygon(arrowHead);
    }

    void OnDrawGizmos()
    {
        DrawArrow(Color.white, 1f, 3f, 0f, transform.position, transform.position + transform.TransformDirection(Vector3.forward) * 4f);
    }
}
```