C#: Add Projection documentation

- Add documentation to Projection type
- Reorder Projection members to be consistent with other C# types

1 files changed, 368 insertions, 162 deletions

diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
index 371729ebec..8b1b73fcc3 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
@@ -3,6 +3,14 @@ using System.Runtime.InteropServices;
 
 namespace Godot
 {
+    /// <summary>
+    /// A 4x4 matrix used for 3D projective transformations. It can represent transformations such as
+    /// translation, rotation, scaling, shearing, and perspective division. It consists of four
+    /// <see cref="Vector4"/> columns.
+    /// For purely linear transformations (translation, rotation, and scale), it is recommended to use
+    /// <see cref="Transform3D"/>, as it is more performant and has a lower memory footprint.
+    /// Used internally as <see cref="Camera3D"/>'s projection matrix.
+    /// </summary>
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
     public struct Projection : IEquatable<Projection>
@@ -59,48 +67,107 @@ namespace Godot
         public Vector4 w;
 
         /// <summary>
-        /// Constructs a projection from 4 vectors (matrix columns).
+        /// Access whole columns in the form of <see cref="Vector4"/>.
         /// </summary>
-        /// <param name="x">The X column, or column index 0.</param>
-        /// <param name="y">The Y column, or column index 1.</param>
-        /// <param name="z">The Z column, or column index 2.</param>
-        /// <param name="w">The W column, or column index 3.</param>
-        public Projection(Vector4 x, Vector4 y, Vector4 z, Vector4 w)
+        /// <param name="column">Which column vector.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="column"/> is not 0, 1, 2 or 3.
+        /// </exception>
+        public Vector4 this[int column]
         {
-            this.x = x;
-            this.y = y;
-            this.z = z;
-            this.w = w;
+            readonly get
+            {
+                switch (column)
+                {
+                    case 0:
+                        return x;
+                    case 1:
+                        return y;
+                    case 2:
+                        return z;
+                    case 3:
+                        return w;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(column));
+                }
+            }
+            set
+            {
+                switch (column)
+                {
+                    case 0:
+                        x = value;
+                        return;
+                    case 1:
+                        y = value;
+                        return;
+                    case 2:
+                        z = value;
+                        return;
+                    case 3:
+                        w = value;
+                        return;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(column));
+                }
+            }
         }
 
         /// <summary>
-        /// Constructs a new <see cref="Projection"/> from a <see cref="Transform3D"/>.
+        /// Access single values.
         /// </summary>
-        /// <param name="transform">The <see cref="Transform3D"/>.</param>
-        public Projection(Transform3D transform)
+        /// <param name="column">Which column vector.</param>
+        /// <param name="row">Which row of the column.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="column"/> or <paramref name="row"/> are not 0, 1, 2 or 3.
+        /// </exception>
+        public real_t this[int column, int row]
         {
-            x = new Vector4(transform.basis.Row0.x, transform.basis.Row1.x, transform.basis.Row2.x, 0);
-            y = new Vector4(transform.basis.Row0.y, transform.basis.Row1.y, transform.basis.Row2.y, 0);
-            z = new Vector4(transform.basis.Row0.z, transform.basis.Row1.z, transform.basis.Row2.z, 0);
-            w = new Vector4(transform.origin.x, transform.origin.y, transform.origin.z, 1);
+            readonly get
+            {
+                switch (column)
+                {
+                    case 0:
+                        return x[row];
+                    case 1:
+                        return y[row];
+                    case 2:
+                        return z[row];
+                    case 3:
+                        return w[row];
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(column));
+                }
+            }
+            set
+            {
+                switch (column)
+                {
+                    case 0:
+                        x[row] = value;
+                        return;
+                    case 1:
+                        y[row] = value;
+                        return;
+                    case 2:
+                        z[row] = value;
+                        return;
+                    case 3:
+                        w[row] = value;
+                        return;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(column));
+                }
+            }
         }
 
         /// <summary>
-        /// Constructs a new <see cref="Transform3D"/> from the <see cref="Projection"/>.
+        /// Creates a new <see cref="Projection"/> that projects positions from a depth range of
+        /// <c>-1</c> to <c>1</c> to one that ranges from <c>0</c> to <c>1</c>, and flips the projected
+        /// positions vertically, according to <paramref name="flipY"/>.
         /// </summary>
-        /// <param name="proj">The <see cref="Projection"/>.</param>
-        public static explicit operator Transform3D(Projection proj)
-        {
-            return new Transform3D(
-                new Basis(
-                    new Vector3(proj.x.x, proj.x.y, proj.x.z),
-                    new Vector3(proj.y.x, proj.y.y, proj.y.z),
-                    new Vector3(proj.z.x, proj.z.y, proj.z.z)
-                ),
-                new Vector3(proj.w.x, proj.w.y, proj.w.z)
-            );
-        }
-
+        /// <param name="flipY">If the projection should be flipped vertically.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateDepthCorrection(bool flipY)
         {
             return new Projection(
@@ -111,6 +178,12 @@ namespace Godot
             );
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that scales a given projection to fit around
+        /// a given <see cref="AABB"/> in projection space.
+        /// </summary>
+        /// <param name="aabb">The AABB to fit the projection around.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateFitAabb(AABB aabb)
         {
             Vector3 min = aabb.Position;
@@ -124,6 +197,25 @@ namespace Godot
             );
         }
 
+        /// <summary>
+        /// Creates a new <see cref="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.
+        /// <paramref name="eye"/> creates the projection for the left eye when set to 1,
+        /// or the right eye when set to 2.
+        /// </summary>
+        /// <param name="eye">
+        /// The eye to create the projection for.
+        /// The left eye when set to 1, the right eye when set to 2.
+        /// </param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <param name="intraocularDist">The distance between the eyes.</param>
+        /// <param name="displayWidth">The display width.</param>
+        /// <param name="displayToLens">The distance to the lens.</param>
+        /// <param name="oversample">The oversampling factor.</param>
+        /// <param name="zNear">The near clipping distance.</param>
+        /// <param name="zFar">The far clipping distance.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateForHmd(int eye, real_t aspect, real_t intraocularDist, real_t displayWidth, real_t displayToLens, real_t oversample, real_t zNear, real_t zFar)
         {
             real_t f1 = (intraocularDist * (real_t)0.5) / displayToLens;
@@ -148,6 +240,17 @@ namespace Godot
             }
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that projects positions in a frustum with
+        /// the given clipping planes.
+        /// </summary>
+        /// <param name="left">The left clipping distance.</param>
+        /// <param name="right">The right clipping distance.</param>
+        /// <param name="bottom">The bottom clipping distance.</param>
+        /// <param name="top">The top clipping distance.</param>
+        /// <param name="near">The near clipping distance.</param>
+        /// <param name="far">The far clipping distance.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateFrustum(real_t left, real_t right, real_t bottom, real_t top, real_t near, real_t far)
         {
             if (right <= left)
@@ -179,6 +282,18 @@ namespace Godot
             );
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that projects positions in a frustum with
+        /// the given size, X:Y aspect ratio, offset, and clipping planes.
+        /// <paramref name="flipFov"/> determines whether the projection's field of view is flipped over its diagonal.
+        /// </summary>
+        /// <param name="size">The frustum size.</param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <param name="offset">The offset to apply.</param>
+        /// <param name="near">The near clipping distance.</param>
+        /// <param name="far">The far clipping distance.</param>
+        /// <param name="flipFov">If the field of view is flipped over the projection's diagonal.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateFrustumAspect(real_t size, real_t aspect, Vector2 offset, real_t near, real_t far, bool flipFov)
         {
             if (!flipFov)
@@ -188,6 +303,11 @@ namespace Godot
             return CreateFrustum(-size / 2 + offset.x, +size / 2 + offset.x, -size / aspect / 2 + offset.y, +size / aspect / 2 + offset.y, near, far);
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that projects positions into the given <see cref="Rect2"/>.
+        /// </summary>
+        /// <param name="rect">The Rect2 to project positions into.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateLightAtlasRect(Rect2 rect)
         {
             return new Projection(
@@ -198,6 +318,17 @@ namespace Godot
             );
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that projects positions using an orthogonal projection with
+        /// the given clipping planes.
+        /// </summary>
+        /// <param name="left">The left clipping distance.</param>
+        /// <param name="right">The right clipping distance.</param>
+        /// <param name="bottom">The bottom clipping distance.</param>
+        /// <param name="top">The top clipping distance.</param>
+        /// <param name="zNear">The near clipping distance.</param>
+        /// <param name="zFar">The far clipping distance.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateOrthogonal(real_t left, real_t right, real_t bottom, real_t top, real_t zNear, real_t zFar)
         {
             Projection proj = Projection.Identity;
@@ -211,6 +342,17 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Creates a new <see cref="Projection"/> that projects positions using an orthogonal projection with
+        /// the given size, X:Y aspect ratio, and clipping planes.
+        /// <paramref name="flipFov"/> determines whether the projection's field of view is flipped over its diagonal.
+        /// </summary>
+        /// <param name="size">The frustum size.</param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <param name="zNear">The near clipping distance.</param>
+        /// <param name="zFar">The far clipping distance.</param>
+        /// <param name="flipFov">If the field of view is flipped over the projection's diagonal.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreateOrthogonalAspect(real_t size, real_t aspect, real_t zNear, real_t zFar, bool flipFov)
         {
             if (!flipFov)
@@ -220,6 +362,17 @@ namespace Godot
             return CreateOrthogonal(-size / 2, +size / 2, -size / aspect / 2, +size / aspect / 2, zNear, zFar);
         }
 
+        /// <summary>
+        /// Creates a new <see cref="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.
+        /// <paramref name="flipFov"/> determines whether the projection's field of view is flipped over its diagonal.
+        /// </summary>
+        /// <param name="fovyDegrees">The vertical field of view (in degrees).</param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <param name="zNear">The near clipping distance.</param>
+        /// <param name="zFar">The far clipping distance.</param>
+        /// <param name="flipFov">If the field of view is flipped over the projection's diagonal.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreatePerspective(real_t fovyDegrees, real_t aspect, real_t zNear, real_t zFar, bool flipFov)
         {
             if (flipFov)
@@ -249,6 +402,27 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Creates a new <see cref="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.
+        /// <paramref name="eye"/> creates the projection for the left eye when set to 1,
+        /// or the right eye when set to 2.
+        /// <paramref name="flipFov"/> determines whether the projection's field of view is flipped over its diagonal.
+        /// </summary>
+        /// <param name="fovyDegrees">The vertical field of view (in degrees).</param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <param name="zNear">The near clipping distance.</param>
+        /// <param name="zFar">The far clipping distance.</param>
+        /// <param name="flipFov">If the field of view is flipped over the projection's diagonal.</param>
+        /// <param name="eye">
+        /// The eye to create the projection for.
+        /// The left eye when set to 1, the right eye when set to 2.
+        /// </param>
+        /// <param name="intraocularDist">The distance between the eyes.</param>
+        /// <param name="convergenceDist">The distance to a point of convergence that can be focused on.</param>
+        /// <returns>The created projection.</returns>
         public static Projection CreatePerspectiveHmd(real_t fovyDegrees, real_t aspect, real_t zNear, real_t zFar, bool flipFov, int eye, real_t intraocularDist, real_t convergenceDist)
         {
             if (flipFov)
@@ -286,6 +460,13 @@ namespace Godot
             return proj * cm;
         }
 
+        /// <summary>
+        /// 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.
+        /// </summary>
+        /// <returns>The determinant calculated from this projection.</returns>
         public readonly real_t Determinant()
         {
             return x.w * y.z * z.y * w.x - x.z * y.w * z.y * w.x -
@@ -302,12 +483,20 @@ namespace Godot
                    x.y * y.x * z.z * w.w + x.x * y.y * z.z * w.w;
         }
 
+        /// <summary>
+        /// Returns the X:Y aspect ratio of this <see cref="Projection"/>'s viewport.
+        /// </summary>
+        /// <returns>The aspect ratio from this projection's viewport.</returns>
         public readonly real_t GetAspect()
         {
             Vector2 vpHe = GetViewportHalfExtents();
             return vpHe.x / vpHe.y;
         }
 
+        /// <summary>
+        /// Returns the horizontal field of view of the projection (in degrees).
+        /// </summary>
+        /// <returns>The horizontal field of view of this projection.</returns>
         public readonly real_t GetFov()
         {
             Plane rightPlane = new Plane(x.w - x.x, y.w - y.x, z.w - z.x, -w.w + w.x).Normalized();
@@ -322,11 +511,22 @@ namespace Godot
             }
         }
 
+        /// <summary>
+        /// Returns the vertical field of view of the projection (in degrees) associated with
+        /// the given horizontal field of view (in degrees) and aspect ratio.
+        /// </summary>
+        /// <param name="fovx">The horizontal field of view (in degrees).</param>
+        /// <param name="aspect">The aspect ratio.</param>
+        /// <returns>The vertical field of view of this projection.</returns>
         public static real_t GetFovy(real_t fovx, real_t aspect)
         {
             return Mathf.RadToDeg(Mathf.Atan(aspect * Mathf.Tan(Mathf.DegToRad(fovx) * (real_t)0.5)) * (real_t)2.0);
         }
 
+        /// <summary>
+        /// Returns the factor by which the visible level of detail is scaled by this <see cref="Projection"/>.
+        /// </summary>
+        /// <returns>The level of detail factor for this projection.</returns>
         public readonly real_t GetLodMultiplier()
         {
             if (IsOrthogonal())
@@ -341,6 +541,12 @@ namespace Godot
             }
         }
 
+        /// <summary>
+        /// Returns the number of pixels with the given pixel width displayed per meter, after
+        /// this <see cref="Projection"/> is applied.
+        /// </summary>
+        /// <param name="forPixelWidth">The width for each pixel (in meters).</param>
+        /// <returns>The number of pixels per meter.</returns>
         public readonly int GetPixelsPerMeter(int forPixelWidth)
         {
             Vector3 result = this * new Vector3(1, 0, -1);
@@ -348,6 +554,15 @@ namespace Godot
             return (int)((result.x * (real_t)0.5 + (real_t)0.5) * forPixelWidth);
         }
 
+        /// <summary>
+        /// Returns the clipping plane of this <see cref="Projection"/> whose index is given
+        /// by <paramref name="plane"/>.
+        /// <paramref name="plane"/> should be equal to one of <see cref="Planes.Near"/>,
+        /// <see cref="Planes.Far"/>, <see cref="Planes.Left"/>, <see cref="Planes.Top"/>,
+        /// <see cref="Planes.Right"/>, or <see cref="Planes.Bottom"/>.
+        /// </summary>
+        /// <param name="plane">The kind of clipping plane to get from the projection.</param>
+        /// <returns>The clipping plane of this projection.</returns>
         public readonly Plane GetProjectionPlane(Planes plane)
         {
             Plane newPlane = plane switch
@@ -364,28 +579,49 @@ namespace Godot
             return newPlane.Normalized();
         }
 
+        /// <summary>
+        /// Returns the dimensions of the far clipping plane of the projection, divided by two.
+        /// </summary>
+        /// <returns>The half extents for this projection's far plane.</returns>
         public readonly Vector2 GetFarPlaneHalfExtents()
         {
             var res = GetProjectionPlane(Planes.Far).Intersect3(GetProjectionPlane(Planes.Right), GetProjectionPlane(Planes.Top));
             return new Vector2(res.Value.x, res.Value.y);
         }
 
+        /// <summary>
+        /// Returns the dimensions of the viewport plane that this <see cref="Projection"/>
+        /// projects positions onto, divided by two.
+        /// </summary>
+        /// <returns>The half extents for this projection's viewport plane.</returns>
         public readonly Vector2 GetViewportHalfExtents()
         {
             var res = GetProjectionPlane(Planes.Near).Intersect3(GetProjectionPlane(Planes.Right), GetProjectionPlane(Planes.Top));
             return new Vector2(res.Value.x, res.Value.y);
         }
 
+        /// <summary>
+        /// Returns the distance for this <see cref="Projection"/> beyond which positions are clipped.
+        /// </summary>
+        /// <returns>The distance beyond which positions are clipped.</returns>
         public readonly real_t GetZFar()
         {
             return GetProjectionPlane(Planes.Far).D;
         }
 
+        /// <summary>
+        /// Returns the distance for this <see cref="Projection"/> before which positions are clipped.
+        /// </summary>
+        /// <returns>The distance before which positions are clipped.</returns>
         public readonly real_t GetZNear()
         {
             return -GetProjectionPlane(Planes.Near).D;
         }
 
+        /// <summary>
+        /// Returns a copy of this <see cref="Projection"/> with the signs of the values of the Y column flipped.
+        /// </summary>
+        /// <returns>The flipped projection.</returns>
         public readonly Projection FlippedY()
         {
             Projection proj = this;
@@ -393,6 +629,13 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Returns a <see cref="Projection"/> with the near clipping distance adjusted to be
+        /// <paramref name="newZNear"/>.
+        /// Note: The original <see cref="Projection"/> must be a perspective projection.
+        /// </summary>
+        /// <param name="newZNear">The near clipping distance to adjust the projection to.</param>
+        /// <returns>The adjusted projection.</returns>
         public readonly Projection PerspectiveZNearAdjusted(real_t newZNear)
         {
             Projection proj = this;
@@ -404,6 +647,12 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Returns a <see cref="Projection"/> with the X and Y values from the given <see cref="Vector2"/>
+        /// added to the first and second values of the final column respectively.
+        /// </summary>
+        /// <param name="offset">The offset to apply to the projection.</param>
+        /// <returns>The offseted projection.</returns>
         public readonly Projection JitterOffseted(Vector2 offset)
         {
             Projection proj = this;
@@ -412,6 +661,11 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Returns a <see cref="Projection"/> that performs the inverse of this <see cref="Projection"/>'s
+        /// projective transformation.
+        /// </summary>
+        /// <returns>The inverted projection.</returns>
         public readonly Projection Inverse()
         {
             Projection proj = this;
@@ -535,11 +789,70 @@ namespace Godot
             return proj;
         }
 
+        /// <summary>
+        /// Returns <see langword="true"/> if this <see cref="Projection"/> performs an orthogonal projection.
+        /// </summary>
+        /// <returns>If the projection performs an orthogonal projection.</returns>
         public readonly bool IsOrthogonal()
         {
             return w.w == (real_t)1.0;
         }
 
+        // Constants
+        private static readonly Projection _zero = new Projection(
+            new Vector4(0, 0, 0, 0),
+            new Vector4(0, 0, 0, 0),
+            new Vector4(0, 0, 0, 0),
+            new Vector4(0, 0, 0, 0)
+        );
+        private static readonly Projection _identity = new Projection(
+            new Vector4(1, 0, 0, 0),
+            new Vector4(0, 1, 0, 0),
+            new Vector4(0, 0, 1, 0),
+            new Vector4(0, 0, 0, 1)
+        );
+
+        /// <summary>
+        /// Zero projection, a projection with all components set to <c>0</c>.
+        /// </summary>
+        /// <value>Equivalent to <c>new Projection(Vector4.Zero, Vector4.Zero, Vector4.Zero, Vector4.Zero)</c>.</value>
+        public static Projection Zero { get { return _zero; } }
+
+        /// <summary>
+        /// The identity projection, with no distortion applied.
+        /// This is used as a replacement for <c>Projection()</c> in GDScript.
+        /// Do not use <c>new Projection()</c> with no arguments in C#, because it sets all values to zero.
+        /// </summary>
+        /// <value>Equivalent to <c>new Projection(new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1))</c>.</value>
+        public static Projection Identity { get { return _identity; } }
+
+        /// <summary>
+        /// Constructs a projection from 4 vectors (matrix columns).
+        /// </summary>
+        /// <param name="x">The X column, or column index 0.</param>
+        /// <param name="y">The Y column, or column index 1.</param>
+        /// <param name="z">The Z column, or column index 2.</param>
+        /// <param name="w">The W column, or column index 3.</param>
+        public Projection(Vector4 x, Vector4 y, Vector4 z, Vector4 w)
+        {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.w = w;
+        }
+
+        /// <summary>
+        /// Constructs a new <see cref="Projection"/> from a <see cref="Transform3D"/>.
+        /// </summary>
+        /// <param name="transform">The <see cref="Transform3D"/>.</param>
+        public Projection(Transform3D transform)
+        {
+            x = new Vector4(transform.basis.Row0.x, transform.basis.Row1.x, transform.basis.Row2.x, 0);
+            y = new Vector4(transform.basis.Row0.y, transform.basis.Row1.y, transform.basis.Row2.y, 0);
+            z = new Vector4(transform.basis.Row0.z, transform.basis.Row1.z, transform.basis.Row2.z, 0);
+            w = new Vector4(transform.origin.x, transform.origin.y, transform.origin.z, 1);
+        }
+
         /// <summary>
         /// Composes these two projections by multiplying them
         /// together. This has the effect of applying the right
@@ -646,127 +959,41 @@ namespace Godot
         }
 
         /// <summary>
-        /// Access whole columns in the form of <see cref="Vector4"/>.
+        /// Constructs a new <see cref="Transform3D"/> from the <see cref="Projection"/>.
         /// </summary>
-        /// <param name="column">Which column vector.</param>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// <paramref name="column"/> is not 0, 1, 2 or 3.
-        /// </exception>
-        public Vector4 this[int column]
+        /// <param name="proj">The <see cref="Projection"/>.</param>
+        public static explicit operator Transform3D(Projection proj)
         {
-            readonly get
-            {
-                switch (column)
-                {
-                    case 0:
-                        return x;
-                    case 1:
-                        return y;
-                    case 2:
-                        return z;
-                    case 3:
-                        return w;
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(column));
-                }
-            }
-            set
-            {
-                switch (column)
-                {
-                    case 0:
-                        x = value;
-                        return;
-                    case 1:
-                        y = value;
-                        return;
-                    case 2:
-                        z = value;
-                        return;
-                    case 3:
-                        w = value;
-                        return;
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(column));
-                }
-            }
+            return new Transform3D(
+                new Basis(
+                    new Vector3(proj.x.x, proj.x.y, proj.x.z),
+                    new Vector3(proj.y.x, proj.y.y, proj.y.z),
+                    new Vector3(proj.z.x, proj.z.y, proj.z.z)
+                ),
+                new Vector3(proj.w.x, proj.w.y, proj.w.z)
+            );
         }
 
         /// <summary>
-        /// Access single values.
+        /// Returns <see langword="true"/> if the projection is exactly equal
+        /// to the given object (<see paramref="obj"/>).
         /// </summary>
-        /// <param name="column">Which column vector.</param>
-        /// <param name="row">Which row of the column.</param>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// <paramref name="column"/> or <paramref name="row"/> are not 0, 1, 2 or 3.
-        /// </exception>
-        public real_t this[int column, int row]
+        /// <param name="obj">The object to compare with.</param>
+        /// <returns>Whether or not the vector and the object are equal.</returns>
+        public override readonly bool Equals(object obj)
         {
-            readonly get
-            {
-                switch (column)
-                {
-                    case 0:
-                        return x[row];
-                    case 1:
-                        return y[row];
-                    case 2:
-                        return z[row];
-                    case 3:
-                        return w[row];
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(column));
-                }
-            }
-            set
-            {
-                switch (column)
-                {
-                    case 0:
-                        x[row] = value;
-                        return;
-                    case 1:
-                        y[row] = value;
-                        return;
-                    case 2:
-                        z[row] = value;
-                        return;
-                    case 3:
-                        w[row] = value;
-                        return;
-                    default:
-                        throw new ArgumentOutOfRangeException(nameof(column));
-                }
-            }
+            return obj is Projection other && Equals(other);
         }
 
-        // Constants
-        private static readonly Projection _zero = new Projection(
-            new Vector4(0, 0, 0, 0),
-            new Vector4(0, 0, 0, 0),
-            new Vector4(0, 0, 0, 0),
-            new Vector4(0, 0, 0, 0)
-        );
-        private static readonly Projection _identity = new Projection(
-            new Vector4(1, 0, 0, 0),
-            new Vector4(0, 1, 0, 0),
-            new Vector4(0, 0, 1, 0),
-            new Vector4(0, 0, 0, 1)
-        );
-
-        /// <summary>
-        /// Zero projection, a projection with all components set to <c>0</c>.
-        /// </summary>
-        /// <value>Equivalent to <c>new Projection(Vector4.Zero, Vector4.Zero, Vector4.Zero, Vector4.Zero)</c>.</value>
-        public static Projection Zero { get { return _zero; } }
-
         /// <summary>
-        /// The identity projection, with no distortion applied.
-        /// This is used as a replacement for <c>Projection()</c> in GDScript.
-        /// Do not use <c>new Projection()</c> with no arguments in C#, because it sets all values to zero.
+        /// Returns <see langword="true"/> if the projections are exactly equal.
         /// </summary>
-        /// <value>Equivalent to <c>new Projection(new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1))</c>.</value>
-        public static Projection Identity { get { return _identity; } }
+        /// <param name="other">The other projection.</param>
+        /// <returns>Whether or not the projections are exactly equal.</returns>
+        public readonly bool Equals(Projection other)
+        {
+            return x == other.x && y == other.y && z == other.z && w == other.w;
+        }
 
         /// <summary>
         /// Serves as the hash function for <see cref="Projection"/>.
@@ -797,26 +1024,5 @@ namespace Godot
                 $"{z.x.ToString(format)}, {z.y.ToString(format)}, {z.z.ToString(format)}, {z.w.ToString(format)}\n" +
                 $"{w.x.ToString(format)}, {w.y.ToString(format)}, {w.z.ToString(format)}, {w.w.ToString(format)}\n";
         }
-
-        /// <summary>
-        /// Returns <see langword="true"/> if the projection is exactly equal
-        /// to the given object (<see paramref="obj"/>).
-        /// </summary>
-        /// <param name="obj">The object to compare with.</param>
-        /// <returns>Whether or not the vector and the object are equal.</returns>
-        public override readonly bool Equals(object obj)
-        {
-            return obj is Projection other && Equals(other);
-        }
-
-        /// <summary>
-        /// Returns <see langword="true"/> if the projections are exactly equal.
-        /// </summary>
-        /// <param name="other">The other projection.</param>
-        /// <returns>Whether or not the projections are exactly equal.</returns>
-        public readonly bool Equals(Projection other)
-        {
-            return x == other.x && y == other.y && z == other.z && w == other.w;
-        }
     }
 }