Projection

public Projection(Transform3D transform);

Constructs a Projection from four Vector4 values (matrix columns).

public Projection(Vector4 x, Vector4 y, Vector4 z, Vector4 w);

Constructs a Projection from four Vector4 values (matrix columns).

public Projection(float xx, float xy, float xz, float xw, float yx, float yy, float yz, float yw, float zx, float zy, float zz, float zw, float wx, float wy, float wz, float ww);

Constructs a Projection from four Vector4 values (matrix columns).

public static Projection Identity { get; }

A Projection with no transformation defined. When applied to other data structures, no transformation is performed.

public Vector4 this[int column] { get; set; }

Access whole columns in the form of Vector4.

public float this[int column, int row] { get; set; }

Access single values.

public static Projection Zero { get; }

A Projection with all values initialized to 0. When applied to other data structures, they will be zeroed.

public static Projection CreateDepthCorrection(bool flipY);

Creates a new Projection that projects positions from a depth range of -1 to 1 to one that ranges from 0 to 1, and flips the projected positions vertically, according to flip_y.

public static Projection CreateFitAabb(Aabb aabb);

Creates a new Projection that scales a given projection to fit around a given Aabb in projection space.

public static Projection CreateForHmd(int eye, float aspect, float intraocularDist, float displayWidth, float displayToLens, float oversample, float zNear, float zFar);

Creates a new Projection for projecting positions onto a head-mounted display with the given X:Y aspect ratio, distance between eyes, display width, distance to lens, oversampling factor, and depth clipping planes. eye creates the projection for the left eye when set to 1, or the right eye when set to 2.

public static Projection CreateFrustum(float left, float right, float bottom, float top, float depthNear, float depthFar);

Creates a new Projection that projects positions in a frustum with the given clipping planes.

public static Projection CreateFrustumAspect(float size, float aspect, Vector2 offset, float depthNear, float depthFar, bool flipFov);

Creates a new Projection that projects positions in a frustum with the given size, X:Y aspect ratio, offset, and clipping planes. flip_fov determines whether the projection's field of view is flipped over its diagonal.

public static Projection CreateLightAtlasRect(Rect2 rect);

Creates a new Projection that projects positions into the given Rect2.

public static Projection CreateOrthogonal(float left, float right, float bottom, float top, float zNear, float zFar);

Creates a new Projection that projects positions using an orthogonal projection with the given clipping planes.

public static Projection CreateOrthogonalAspect(float size, float aspect, float zNear, float zFar, bool flipFov);

Creates a new Projection that projects positions using an orthogonal projection with the given size, X:Y aspect ratio, and clipping planes. flip_fov determines whether the projection's field of view is flipped over its diagonal.

public static Projection CreatePerspective(float fovyDegrees, float aspect, float zNear, float zFar, bool flipFov);

Creates a new Projection that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping planes. flip_fov determines whether the projection's field of view is flipped over its diagonal.

public static Projection CreatePerspectiveHmd(float fovyDegrees, float aspect, float zNear, float zFar, bool flipFov, int eye, float intraocularDist, float convergenceDist);

Creates a new Projection that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping distances. The projection is adjusted for a head-mounted display with the given distance between eyes and distance to a point that can be focused on. eye creates the projection for the left eye when set to 1, or the right eye when set to 2. flip_fov determines whether the projection's field of view is flipped over its diagonal.

public float Determinant();

Returns a scalar value that is the signed factor by which areas are scaled by this matrix. If the sign is negative, the matrix flips the orientation of the area. The determinant can be used to calculate the invertibility of a matrix or solve linear systems of equations involving the matrix, among other applications.

public bool Equals(Projection other);

Returns true if the projections are exactly equal.

public override bool Equals(object? obj);

Returns true if the projection is exactly equal to the given object (obj).

public Projection FlippedY();

Returns a copy of this Projection with the signs of the values of the Y column flipped.

public float GetAspect();

Returns the X:Y aspect ratio of this Projection's viewport.

public Vector2 GetFarPlaneHalfExtents();

Returns the dimensions of the far clipping plane of the projection, divided by two.

public float GetFov();

Returns the horizontal field of view of the projection (in degrees).

public static float GetFovy(float fovx, float aspect);

Returns the vertical field of view of the projection (in degrees) associated with the given horizontal field of view (in degrees) and aspect ratio. Note: Unlike most methods of Projection, aspect is expected to be 1 divided by the X:Y aspect ratio.

public override int GetHashCode();

Serves as the hash function for Projection.

public float GetLodMultiplier();

Returns the factor by which the visible level of detail is scaled by this Projection.

public int GetPixelsPerMeter(int forPixelWidth);

Returns for_pixel_width divided by the viewport's width measured in meters on the near plane, after this Projection is applied.

public Plane GetProjectionPlane(Projection.Planes plane);

Returns the clipping plane of this Projection whose index is given by plane. plane should be equal to one of Projection.Planes.Near, Projection.Planes.Far, Projection.Planes.Left, Projection.Planes.Top, Projection.Planes.Right, or Projection.Planes.Bottom.

public Vector2 GetViewportHalfExtents();

Returns the dimensions of the viewport plane that this Projection projects positions onto, divided by two.

public float GetZFar();

Returns the distance for this Projection beyond which positions are clipped.

public float GetZNear();

Returns the distance for this Projection before which positions are clipped.

public Projection Inverse();

Returns a Projection that performs the inverse of this Projection's projective transformation.

public bool IsOrthogonal();

Returns true if this Projection performs an orthogonal projection.

public Projection JitterOffseted(Vector2 offset);

Returns a Projection with the X and Y values from the given Vector2 added to the first and second values of the final column respectively.

public Projection PerspectiveZNearAdjusted(float newZNear);

Returns a Projection with the near clipping distance adjusted to be new_znear. Note: The original Projection must be a perspective projection.

public override string ToString();

Converts this Projection to a string.

public string ToString(string? format);

Converts this Projection to a string with the given format.

public static bool operator ==(Projection left, Projection right);

Returns true if the projections are exactly equal.

public static explicit operator Transform3D(Projection proj);

Constructs a new Transform3D from the Projection.

public static bool operator !=(Projection left, Projection right);

Returns true if the projections are not exactly equal.

public static Projection operator *(Projection left, Projection right);

Composes these two projections by multiplying them together. This has the effect of applying the right and then the left projection.

public static Vector3 operator *(Projection proj, Vector3 vector);

Returns a Vector3 transformed (multiplied) by the projection.

public static Vector4 operator *(Projection proj, Vector4 vector);

Returns a Vector4 transformed (multiplied) by the projection.

public static Vector4 operator *(Vector4 vector, Projection proj);

Returns a Vector4 transformed (multiplied) by the transpose of the projection. For transforming by inverse of a projection projection.Inverse() * vector can be used instead. See Projection.Inverse.

public Vector4 W;

The projection matrix's W vector (column 3). Equivalent to array index 3.

public Vector4 X;

The projection matrix's X vector (column 0). Equivalent to array index 0.

public Vector4 Y;

The projection matrix's Y vector (column 1). Equivalent to array index 1.

public Vector4 Z;

The projection matrix's Z vector (column 2). Equivalent to array index 2.