# Ortho(float, float, float, float, float, float)

> Create an orthogonal projection matrix.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine](/engine/6000.0/script-reference/unityengine.md)
* **Assembly:** UnityEngine.CoreModule

```csharp
public static Matrix4x4 Ortho(float left, float right, float bottom, float top, float zNear, float zFar)
```

### Parameters

**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Left-side x-coordinate.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Right-side x-coordinate.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Bottom y-coordinate.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Top y-coordinate.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Near depth clipping plane value.**** (\[float]\(https\://learn.microsoft.com/dotnet/api/system.single)): Far depth clipping plane value.

### Returns

| Type                                                                  | Description            |
| --------------------------------------------------------------------- | ---------------------- |
| [Matrix4x4](/engine/6000.0/script-reference/unityengine/matrix4x4.md) | The projection matrix. |

### Remarks

The returned matrix, when used as a Camera's projection matrix, creates a projection of the area between left, right, top and bottom, with zNear and zFar as the near and far depth clipping planes into a cube going from (left, bottom, near) = (-1, -1, -1) to (right, top, far) = (1, 1, 1).

The returned matrix embeds a z-flip operation whose purpose is to cancel the z-flip performed by the camera view matrix. If the view matrix is an identity or some custom matrix that doesn't perform a z-flip, consider multiplying the third column of the projection matrix (i.e. m02, m12, m22 and m32) by -1.

Projection matrices in Unity follow [OpenGL](https://en.wikipedia.org/wiki/OpenGL) convention, i.e. clip space near plane is at `z=-1`, and far plane is at `z=1`.

Note that depending on the graphics API used, projection matrices in shaders can follow different convention, for example the D3D-style clip space has near plane at zero and far plane at one; and "reversed Z" projection has near plane at one and far plane at zero. To calculate projection matrix value suitable for passing to shader variables, use [GL.GetGPUProjectionMatrix](/engine/6000.0/script-reference/unityengine/gl/getgpuprojectionmatrix.md).

```csharp
using UnityEngine;

public class ExampleScript : MonoBehaviour
{
    void Start()
    {
        // create orthographic matrix
        var matrix = Matrix4x4.Ortho(-4, 4, -2, 2, 1, 100);
        // will print:
        // 0.25000 0.00000  0.00000  0.00000
        // 0.00000 0.50000  0.00000  0.00000
        // 0.00000 0.00000 -0.02020 -1.02020
        // 0.00000 0.00000  0.00000  1.00000
        Debug.Log("projection matrix\n" + matrix);

        // get shader-compatible projection matrix value
        var shaderMatrix = GL.GetGPUProjectionMatrix(matrix, false);
        // on a Direct3D-like graphics API, will print:
        // 0.25000 0.00000  0.00000  0.00000
        // 0.00000 0.50000  0.00000  0.00000
        // 0.00000 0.00000 0.01010 1.01010
        // 0.00000 0.00000 0.00000 1.00000
        Debug.Log("shader projection matrix\n" + shaderMatrix);
    }
}
```

Additional Resources: [Matrix4x4.Perspective](/engine/6000.0/script-reference/unityengine/matrix4x4/perspective.md), [Camera.projectionMatrix](/engine/6000.0/script-reference/unityengine/camera/projectionmatrix.md), [GL.LoadPixelMatrix](/engine/6000.0/script-reference/unityengine/gl/loadpixelmatrix.md), [GL.LoadProjectionMatrix](/engine/6000.0/script-reference/unityengine/gl/loadprojectionmatrix.md), [GL.GetGPUProjectionMatrix](/engine/6000.0/script-reference/unityengine/gl/getgpuprojectionmatrix.md).