first commit

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Geometry.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8179f9b7bb3904f5ba86140bea0a128b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Geometry/MinMaxAABB.cs

@@ -0,0 +1,322 @@
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics.Geometry
+{
+    /// <summary>
+    /// Axis aligned bounding box (AABB) stored in min and max form.
+    /// </summary>
+    /// <remarks>
+    /// Axis aligned bounding boxes (AABB) are boxes where each side is parallel with one of the Cartesian coordinate axes
+    /// X, Y, and Z. AABBs are useful for approximating the region an object (or collection of objects) occupies and quickly
+    /// testing whether or not that object (or collection of objects) is relevant. Because they are axis aligned, they
+    /// are very cheap to construct and perform overlap tests with them.
+    /// </remarks>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public struct MinMaxAABB : IEquatable<MinMaxAABB>
+    {
+        /// <summary>
+        /// The minimum point contained by the AABB.
+        /// </summary>
+        /// <remarks>
+        /// If any component of <see cref="Min"/> is greater than <see cref="Max"/> then this AABB is invalid.
+        /// </remarks>
+        /// <seealso cref="IsValid"/>
+        public float3 Min;
+
+        /// <summary>
+        /// The maximum point contained by the AABB.
+        /// </summary>
+        /// <remarks>
+        /// If any component of <see cref="Max"/> is less than <see cref="Min"/> then this AABB is invalid.
+        /// </remarks>
+        /// <seealso cref="IsValid"/>
+        public float3 Max;
+
+        /// <summary>
+        /// Constructs the AABB with the given minimum and maximum.
+        /// </summary>
+        /// <remarks>
+        /// If you have a center and extents, you can call <see cref="CreateFromCenterAndExtents"/> or <see cref="CreateFromCenterAndHalfExtents"/>
+        /// to create the AABB.
+        /// </remarks>
+        /// <param name="min">Minimum point inside AABB.</param>
+        /// <param name="max">Maximum point inside AABB.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public MinMaxAABB(float3 min, float3 max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        /// <summary>
+        /// Creates the AABB from a center and extents.
+        /// </summary>
+        /// <remarks>
+        /// This function takes full extents. It is the distance between <see cref="Min"/> and <see cref="Max"/>.
+        /// If you have half extents, you can call <see cref="CreateFromCenterAndHalfExtents"/>.
+        /// </remarks>
+        /// <param name="center">Center of AABB.</param>
+        /// <param name="extents">Full extents of AABB.</param>
+        /// <returns>AABB created from inputs.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MinMaxAABB CreateFromCenterAndExtents(float3 center, float3 extents)
+        {
+            return CreateFromCenterAndHalfExtents(center, extents * 0.5f);
+        }
+
+        /// <summary>
+        /// Creates the AABB from a center and half extents.
+        /// </summary>
+        /// <remarks>
+        /// This function takes half extents. It is half the distance between <see cref="Min"/> and <see cref="Max"/>.
+        /// If you have full extents, you can call <see cref="CreateFromCenterAndExtents"/>.
+        /// </remarks>
+        /// <param name="center">Center of AABB.</param>
+        /// <param name="halfExtents">Half extents of AABB.</param>
+        /// <returns>AABB created from inputs.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MinMaxAABB CreateFromCenterAndHalfExtents(float3 center, float3 halfExtents)
+        {
+            return new MinMaxAABB(center - halfExtents, center + halfExtents);
+        }
+
+        /// <summary>
+        /// Computes the extents of the AABB.
+        /// </summary>
+        /// <remarks>
+        /// Extents is the componentwise distance between min and max.
+        /// </remarks>
+        public float3 Extents => Max - Min;
+
+        /// <summary>
+        /// Computes the half extents of the AABB.
+        /// </summary>
+        /// <remarks>
+        /// HalfExtents is half of the componentwise distance between min and max. Subtracting HalfExtents from Center
+        /// gives Min and adding HalfExtents to Center gives Max.
+        /// </remarks>
+        public float3 HalfExtents => (Max - Min) * 0.5f;
+
+        /// <summary>
+        /// Computes the center of the AABB.
+        /// </summary>
+        public float3 Center => (Max + Min) * 0.5f;
+
+        /// <summary>
+        /// Check if the AABB is valid.
+        /// </summary>
+        /// <remarks>
+        /// An AABB is considered valid if <see cref="Min"/> is componentwise less than or equal to <see cref="Max"/>.
+        /// </remarks>
+        /// <returns>True if <see cref="Min"/> is componentwise less than or equal to <see cref="Max"/>.</returns>
+        public bool IsValid => math.all(Min <= Max);
+
+        /// <summary>
+        /// Computes the surface area for this axis aligned bounding box.
+        /// </summary>
+        public float SurfaceArea
+        {
+            get
+            {
+                float3 diff = Max - Min;
+                return 2 * math.dot(diff, diff.yzx);
+            }
+        }
+
+        /// <summary>
+        /// Tests if the input point is contained by the AABB.
+        /// </summary>
+        /// <param name="point">Point to test.</param>
+        /// <returns>True if AABB contains the input point.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(float3 point) => math.all(point >= Min & point <= Max);
+
+        /// <summary>
+        /// Tests if the input AABB is contained entirely by this AABB.
+        /// </summary>
+        /// <param name="aabb">AABB to test.</param>
+        /// <returns>True if input AABB is contained entirely by this AABB.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Contains(MinMaxAABB aabb) => math.all((Min <= aabb.Min) & (Max >= aabb.Max));
+
+        /// <summary>
+        /// Tests if the input AABB overlaps this AABB.
+        /// </summary>
+        /// <param name="aabb">AABB to test.</param>
+        /// <returns>True if input AABB overlaps with this AABB.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Overlaps(MinMaxAABB aabb)
+        {
+            return math.all(Max >= aabb.Min & Min <= aabb.Max);
+        }
+
+        /// <summary>
+        /// Expands the AABB by the given signed distance.
+        /// </summary>
+        /// <remarks>
+        /// Positive distance expands the AABB while negative distance shrinks the AABB.
+        /// </remarks>
+        /// <param name="signedDistance">Signed distance to expand the AABB with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Expand(float signedDistance)
+        {
+            Min -= signedDistance;
+            Max += signedDistance;
+        }
+
+        /// <summary>
+        /// Encapsulates the given AABB.
+        /// </summary>
+        /// <remarks>
+        /// Modifies this AABB so that it contains the given AABB. If the given AABB is already contained by this AABB,
+        /// then this AABB doesn't change.
+        /// </remarks>
+        /// <seealso cref="Contains(Unity.Mathematics.Geometry.MinMaxAABB)"/>
+        /// <param name="aabb">AABB to encapsulate.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Encapsulate(MinMaxAABB aabb)
+        {
+            Min = math.min(Min, aabb.Min);
+            Max = math.max(Max, aabb.Max);
+        }
+
+        /// <summary>
+        /// Encapsulate the given point.
+        /// </summary>
+        /// <remarks>
+        /// Modifies this AABB so that it contains the given point. If the given point is already contained by this AABB,
+        /// then this AABB doesn't change.
+        /// </remarks>
+        /// <seealso cref="Contains(Unity.Mathematics.float3)"/>
+        /// <param name="point">Point to encapsulate.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Encapsulate(float3 point)
+        {
+            Min = math.min(Min, point);
+            Max = math.max(Max, point);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(MinMaxAABB other)
+        {
+            return Min.Equals(other.Min) && Max.Equals(other.Max);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("MinMaxAABB({0}, {1})", Min, Max);
+        }
+    }
+
+    public static partial class Math
+    {
+        /// <summary>
+        /// Transforms the AABB with the given transform.
+        /// </summary>
+        /// <remarks>
+        /// The resulting AABB encapsulates the transformed AABB which may not be axis aligned after the transformation.
+        /// </remarks>
+        /// <param name="transform">Transform to apply to AABB.</param>
+        /// <param name="aabb">AABB to be transformed.</param>
+        /// <returns>Transformed AABB.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MinMaxAABB Transform(RigidTransform transform, MinMaxAABB aabb)
+        {
+            float3 halfExtentsInA = aabb.HalfExtents;
+
+            // Rotate each axis individually and find their new positions in the rotated space.
+            float3 x = math.rotate(transform.rot, new float3(halfExtentsInA.x, 0, 0));
+            float3 y = math.rotate(transform.rot, new float3(0, halfExtentsInA.y, 0));
+            float3 z = math.rotate(transform.rot, new float3(0, 0, halfExtentsInA.z));
+
+            // Find the new max corner by summing the rotated axes.  Absolute value of each axis
+            // since we are trying to find the max corner.
+            float3 halfExtentsInB = math.abs(x) + math.abs(y) + math.abs(z);
+            float3 centerInB = math.transform(transform, aabb.Center);
+
+            return new MinMaxAABB(centerInB - halfExtentsInB, centerInB + halfExtentsInB);
+        }
+
+        /// <summary>
+        /// Transforms the AABB with the given transform.
+        /// </summary>
+        /// <remarks>
+        /// The resulting AABB encapsulates the transformed AABB which may not be axis aligned after the transformation.
+        /// </remarks>
+        /// <param name="transform">Transform to apply to AABB.</param>
+        /// <param name="aabb">AABB to be transformed.</param>
+        /// <returns>Transformed AABB.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MinMaxAABB Transform(float4x4 transform, MinMaxAABB aabb)
+        {
+            var transformed = Transform(new float3x3(transform), aabb);
+            transformed.Min += transform.c3.xyz;
+            transformed.Max += transform.c3.xyz;
+            return transformed;
+        }
+
+        /// <summary>
+        /// Transforms the AABB with the given transform.
+        /// </summary>
+        /// <remarks>
+        /// The resulting AABB encapsulates the transformed AABB which may not be axis aligned after the transformation.
+        /// </remarks>
+        /// <param name="transform">Transform to apply to AABB.</param>
+        /// <param name="aabb">AABB to be transformed.</param>
+        /// <returns>Transformed AABB.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static MinMaxAABB Transform(float3x3 transform, MinMaxAABB aabb)
+        {
+            // From Christer Ericson's Real-Time Collision Detection on page 86 and 87.
+            // We want the transformed minimum and maximums of the AABB. Multiplying a 3x3 matrix on the left of a
+            // column vector looks like so:
+            //
+            // [ c0.x c1.x c2.x ] [ x ]   [ c0.x * x + c1.x * y + c2.x * z ]
+            // [ c0.y c1.y c2.y ] [ y ] = [ c0.y * x + c1.y * y + c2.y * z ]
+            // [ c0.z c1.z c2.z ] [ z ]   [ c0.z * x + c1.z * y + c2.z * z ]
+            //
+            // The column vectors we will use are the input AABB's min and max. Simply multiplying those two vectors
+            // with the transformation matrix won't guarantee we get the new min and max since those are only two
+            // points out of eight in the AABB and one of the other six may set the new min or max.
+            //
+            // To ensure we get the correct min and max, we must transform all eight points. But it's not necessary
+            // to actually perform eight matrix multiplies to get our final result. Instead, we can build the min and
+            // max incrementally by computing each term in the above matrix multiply separately then summing the min
+            // (or max). For instance, to find the new minimum contributed by the original min and max x component, we
+            // compute this:
+            //
+            // newMin.x = min(c0.x * Min.x, c0.x * Max.x);
+            // newMin.y = min(c0.y * Min.x, c0.y * Max.x);
+            // newMin.z = min(c0.z * Min.x, c0.z * Max.x);
+            //
+            // Then we add minimum contributed by the original min and max y components:
+            //
+            // newMin.x += min(c1.x * Min.y, c1.x * Max.y);
+            // newMin.y += min(c1.y * Min.y, c1.y * Max.y);
+            // newMin.z += min(c1.z * Min.y, c1.z * Max.y);
+            //
+            // And so on. Translation can be handled by simply initializing the new min and max with the translation
+            // amount since it does not affect the min and max bounds in local space.
+            var t1 = transform.c0.xyz * aabb.Min.xxx;
+            var t2 = transform.c0.xyz * aabb.Max.xxx;
+            var minMask = t1 < t2;
+            var transformed = new MinMaxAABB(select(t2, t1, minMask), select(t2, t1, !minMask));
+            t1 = transform.c1.xyz * aabb.Min.yyy;
+            t2 = transform.c1.xyz * aabb.Max.yyy;
+            minMask = t1 < t2;
+            transformed.Min += select(t2, t1, minMask);
+            transformed.Max += select(t2, t1, !minMask);
+            t1 = transform.c2.xyz * aabb.Min.zzz;
+            t2 = transform.c2.xyz * aabb.Max.zzz;
+            minMask = t1 < t2;
+            transformed.Min += select(t2, t1, minMask);
+            transformed.Max += select(t2, t1, !minMask);
+            return transformed;
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Geometry/MinMaxAABB.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e0eb9224bcb474ac091e7d7f2780d61d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Geometry/Plane.cs

@@ -0,0 +1,234 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+namespace Unity.Mathematics.Geometry
+{
+    /// <summary>
+    /// A plane represented by a normal vector and a distance along the normal from the origin.
+    /// </summary>
+    /// <remarks>
+    /// A plane splits the 3D space in half.  The normal vector points to the positive half and the other half is
+    /// considered negative.
+    /// </remarks>
+    [DebuggerDisplay("{Normal}, {Distance}")]
+    [Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public struct Plane
+    {
+        /// <summary>
+        /// A plane in the form Ax + By + Cz + Dw = 0.
+        /// </summary>
+        /// <remarks>
+        /// Stores the plane coefficients A, B, C, D where (A, B, C) is a unit normal vector and D is the distance
+        /// from the origin.  A plane stored with a unit normal vector is called a normalized plane.
+        /// </remarks>
+        public float4 NormalAndDistance;
+
+        /// <summary>
+        /// Constructs a Plane from arbitrary coefficients A, B, C, D of the plane equation Ax + By + Cz + Dw = 0.
+        /// </summary>
+        /// <remarks>
+        /// The constructed plane will be the normalized form of the plane specified by the given coefficients.
+        /// </remarks>
+        /// <param name="coefficientA">Coefficient A from plane equation.</param>
+        /// <param name="coefficientB">Coefficient B from plane equation.</param>
+        /// <param name="coefficientC">Coefficient C from plane equation.</param>
+        /// <param name="coefficientD">Coefficient D from plane equation.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Plane(float coefficientA, float coefficientB, float coefficientC, float coefficientD)
+        {
+            NormalAndDistance = Normalize(new float4(coefficientA, coefficientB, coefficientC, coefficientD));
+        }
+
+        /// <summary>
+        /// Constructs a plane with a normal vector and distance from the origin.
+        /// </summary>
+        /// <remarks>
+        /// The constructed plane will be the normalized form of the plane specified by the inputs.
+        /// </remarks>
+        /// <param name="normal">A non-zero vector that is perpendicular to the plane.  It may be any length.</param>
+        /// <param name="distance">Distance from the origin along the normal.  A negative value moves the plane in the
+        /// same direction as the normal while a positive value moves it in the opposite direction.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Plane(float3 normal, float distance)
+        {
+            NormalAndDistance = Normalize(new float4(normal, distance));
+        }
+
+        /// <summary>
+        /// Constructs a plane with a normal vector and a point that lies in the plane.
+        /// </summary>
+        /// <remarks>
+        /// The constructed plane will be the normalized form of the plane specified by the inputs.
+        /// </remarks>
+        /// <param name="normal">A non-zero vector that is perpendicular to the plane.  It may be any length.</param>
+        /// <param name="pointInPlane">A point that lies in the plane.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Plane(float3 normal, float3 pointInPlane)
+        : this(normal, -math.dot(normal, pointInPlane))
+        {
+        }
+
+        /// <summary>
+        /// Constructs a plane with two vectors and a point that all lie in the plane.
+        /// </summary>
+        /// <remarks>
+        /// The constructed plane will be the normalized form of the plane specified by the inputs.
+        /// </remarks>
+        /// <param name="vector1InPlane">A non-zero vector that lies in the plane.  It may be any length.</param>
+        /// <param name="vector2InPlane">A non-zero vector that lies in the plane.  It may be any length and must not be a scalar multiple of <paramref name="vector1InPlane"/>.</param>
+        /// <param name="pointInPlane">A point that lies in the plane.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Plane(float3 vector1InPlane, float3 vector2InPlane, float3 pointInPlane)
+        : this(math.cross(vector1InPlane, vector2InPlane), pointInPlane)
+        {
+        }
+
+        /// <summary>
+        /// Creates a normalized Plane directly without normalization cost.
+        /// </summary>
+        /// <remarks>
+        /// If you have a unit length normal vector, you can create a Plane faster than using one of its constructors
+        /// by calling this function.
+        /// </remarks>
+        /// <param name="unitNormal">A non-zero vector that is perpendicular to the plane.  It must be unit length.</param>
+        /// <param name="distance">Distance from the origin along the normal.  A negative value moves the plane in the
+        /// same direction as the normal while a positive value moves it in the opposite direction.</param>
+        /// <returns>Normalized Plane constructed from given inputs.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Plane CreateFromUnitNormalAndDistance(float3 unitNormal, float distance)
+        {
+            return new Plane { NormalAndDistance = new float4(unitNormal, distance) };
+        }
+
+        /// <summary>
+        /// Creates a normalized Plane without normalization cost.
+        /// </summary>
+        /// <remarks>
+        /// If you have a unit length normal vector, you can create a Plane faster than using one of its constructors
+        /// by calling this function.
+        /// </remarks>
+        /// <param name="unitNormal">A non-zero vector that is perpendicular to the plane.  It must be unit length.</param>
+        /// <param name="pointInPlane">A point that lies in the plane.</param>
+        /// <returns>Normalized Plane constructed from given inputs.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Plane CreateFromUnitNormalAndPointInPlane(float3 unitNormal, float3 pointInPlane)
+        {
+            return new Plane { NormalAndDistance = new float4(unitNormal, -math.dot(unitNormal, pointInPlane)) };
+        }
+
+        /// <summary>
+        /// Get/set the normal vector of the plane.
+        /// </summary>
+        /// <remarks>
+        /// It is assumed that the normal is unit length.  If you set a new plane such that Ax + By + Cz + Dw = 0 but
+        /// (A, B, C) is not unit length, then you must normalize the plane by calling <see cref="Normalize(Plane)"/>.
+        /// </remarks>
+        public float3 Normal
+        {
+            get => NormalAndDistance.xyz;
+            set => NormalAndDistance.xyz = value;
+        }
+
+        /// <summary>
+        /// Get/set the distance of the plane from the origin.  May be a negative value.
+        /// </summary>
+        /// <remarks>
+        /// It is assumed that the normal is unit length.  If you set a new plane such that Ax + By + Cz + Dw = 0 but
+        /// (A, B, C) is not unit length, then you must normalize the plane by calling <see cref="Normalize(Plane)"/>.
+        /// </remarks>
+        public float Distance
+        {
+            get => NormalAndDistance.w;
+            set => NormalAndDistance.w = value;
+        }
+
+        /// <summary>
+        /// Normalizes the given Plane.
+        /// </summary>
+        /// <param name="plane">Plane to normalize.</param>
+        /// <returns>Normalized Plane.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Plane Normalize(Plane plane)
+        {
+            return new Plane { NormalAndDistance = Normalize(plane.NormalAndDistance) };
+        }
+
+        /// <summary>
+        /// Normalizes the plane represented by the given plane coefficients.
+        /// </summary>
+        /// <remarks>
+        /// The plane coefficients are A, B, C, D and stored in that order in the <see cref="float4"/>.
+        /// </remarks>
+        /// <param name="planeCoefficients">Plane coefficients A, B, C, D stored in x, y, z, w (respectively).</param>
+        /// <returns>Normalized plane coefficients.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4 Normalize(float4 planeCoefficients)
+        {
+            float recipLength = math.rsqrt(math.lengthsq(planeCoefficients.xyz));
+            return new Plane { NormalAndDistance = planeCoefficients * recipLength };
+        }
+
+        /// <summary>
+        /// Get the signed distance from the point to the plane.
+        /// </summary>
+        /// <remarks>
+        /// Plane must be normalized prior to calling this function.  Distance is positive if point is on side of the
+        /// plane the normal points to, negative if on the opposite side and zero if the point lies in the plane.
+        /// Avoid comparing equality with 0.0f when testing if a point lies exactly in the plane and use an approximate
+        /// comparison instead.
+        /// </remarks>
+        /// <param name="point">Point to find the signed distance with.</param>
+        /// <returns>Signed distance of the point from the plane.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float SignedDistanceToPoint(float3 point)
+        {
+            CheckPlaneIsNormalized();
+            return math.dot(NormalAndDistance, new float4(point, 1.0f));
+        }
+
+        /// <summary>
+        /// Projects the given point onto the plane.
+        /// </summary>
+        /// <remarks>
+        /// Plane must be normalized prior to calling this function.  The result is the position closest to the point
+        /// that still lies in the plane.
+        /// </remarks>
+        /// <param name="point">Point to project onto the plane.</param>
+        /// <returns>Projected point that's inside the plane.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float3 Projection(float3 point)
+        {
+            CheckPlaneIsNormalized();
+            return point - Normal * SignedDistanceToPoint(point);
+        }
+
+        /// <summary>
+        /// Flips the plane so the normal points in the opposite direction.
+        /// </summary>
+        public Plane Flipped => new Plane { NormalAndDistance = -NormalAndDistance };
+
+        /// <summary>
+        /// Implicitly converts a <see cref="Plane"/> to <see cref="float4"/>.
+        /// </summary>
+        /// <param name="plane">Plane to convert.</param>
+        /// <returns>A <see cref="float4"/> representing the plane.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float4(Plane plane) => plane.NormalAndDistance;
+
+        [Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
+        void CheckPlaneIsNormalized()
+        {
+            float ll = math.lengthsq(Normal.xyz);
+            const float lowerBound = 0.999f * 0.999f;
+            const float upperBound = 1.001f * 1.001f;
+
+            if (ll < lowerBound || ll > upperBound)
+            {
+                throw new System.ArgumentException("Plane must be normalized. Call Plane.Normalize() to normalize plane.");
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Geometry/Plane.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b715caa4800cd41edbf02f1d3a42accf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Unity.IL2CPP.CompilerServices
+{
+    /// <summary>
+    /// This is used to indicate to IL2CPP that the static constructors should be executed eagerly at startup
+    /// rather than lazily at runtime.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
+    internal class Il2CppEagerStaticClassConstructionAttribute : Attribute
+    {
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3c7ef86a2cddb4254810c84d4f6e6618
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: abc6c021d7cd541b3956a3969c8c3ccb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/LICENSE

@@ -0,0 +1,20 @@
+Copyright (C) 2011 by Ashima Arts (Simplex noise)
+Copyright (C) 2011-2016 by Stefan Gustavson (Classic noise and others)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/LICENSE.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e8895079ca68e498482a3075d7e34508
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/README

@@ -0,0 +1,16 @@
+These files contain noise functions that are compatible with all
+current versions of GLSL (1.20 and up), and all you need to use them
+is provided in the source file. There is no external data, and no
+setup procedure. Just cut and paste and call the function.
+
+GLSL has a very rudimentary linker, so some helper functions are
+included in several of the files with the same name. If you want to
+use more than one of these functions in the same shader, you may run
+into problems with redefinition of the functions mod289() and permute().
+If that happens, just delete any superfluous definitions.
+
+-----
+
+Source: https://github.com/ashima/webgl-noise
+Changes:
+ - 10 April 2018, Unity Technologies, Ported to HPC# 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/README.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 16687ba1ea1804a9fb7cb7c2410eab23
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2D.cs

@@ -0,0 +1,61 @@
+// Cellular noise ("Worley noise") in 2D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// 2D Cellular noise ("Worley noise") with standard 3x3 search window for good feature point values.
+        /// </summary>
+        /// <param name="P">A point in 2D space.</param>
+        /// <returns>Feature points. F1 is in the x component, F2 in the y component.</returns>
+        public static float2 cellular(float2 P)
+        {
+            const float K = 0.142857142857f; // 1/7
+            const float Ko = 0.428571428571f; // 3/7
+            const float jitter = 1.0f; // Less gives more regular pattern
+
+            float2 Pi = mod289(floor(P));
+            float2 Pf = frac(P);
+            float3 oi = float3(-1.0f, 0.0f, 1.0f);
+            float3 of = float3(-0.5f, 0.5f, 1.5f);
+            float3 px = permute(Pi.x + oi);
+            float3 p = permute(px.x + Pi.y + oi); // p11, p12, p13
+            float3 ox = frac(p * K) - Ko;
+            float3 oy = mod7(floor(p * K)) * K - Ko;
+            float3 dx = Pf.x + 0.5f + jitter * ox;
+            float3 dy = Pf.y - of + jitter * oy;
+            float3 d1 = dx * dx + dy * dy; // d11, d12 and d13, squared
+            p = permute(px.y + Pi.y + oi); // p21, p22, p23
+            ox = frac(p * K) - Ko;
+            oy = mod7(floor(p * K)) * K - Ko;
+            dx = Pf.x - 0.5f + jitter * ox;
+            dy = Pf.y - of + jitter * oy;
+            float3 d2 = dx * dx + dy * dy; // d21, d22 and d23, squared
+            p = permute(px.z + Pi.y + oi); // p31, p32, p33
+            ox = frac(p * K) - Ko;
+            oy = mod7(floor(p * K)) * K - Ko;
+            dx = Pf.x - 1.5f + jitter * ox;
+            dy = Pf.y - of + jitter * oy;
+            float3 d3 = dx * dx + dy * dy; // d31, d32 and d33, squared
+            // Sort out the two smallest distances (F1, F2)
+            float3 d1a = min(d1, d2);
+            d2 = max(d1, d2); // Swap to keep candidates for F2
+            d2 = min(d2, d3); // neither F1 nor F2 are now in d3
+            d1 = min(d1a, d2); // F1 is now in d1
+            d2 = max(d1a, d2); // Swap to keep candidates for F2
+            d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; // Swap if smaller
+            d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; // F1 is in d1.x
+            d1.yz = min(d1.yz, d2.yz); // F2 is now not in d2.yz
+            d1.y = min(d1.y, d1.z); // nor in  d1.z
+            d1.y = min(d1.y, d2.x); // F2 is in d1.y, we're done.
+            return sqrt(d1.xy);
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7bc458fcf5f30484da36c2a11ca0c50a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2x2.cs

@@ -0,0 +1,48 @@
+// Cellular noise ("Worley noise") in 2D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// 2D Cellular noise ("Worley noise") with a 2x2 search window.
+        /// </summary>
+        /// <remarks>
+        /// Faster than using 3x3, at the expense of some strong pattern artifacts. F2 is often wrong and has sharp discontinuities. If you need a smooth F2, use the slower 3x3 version. F1 is sometimes wrong, too, but OK for most purposes.
+        /// </remarks>
+        /// <param name="P">A point in 2D space.</param>
+        /// <returns>Feature points. F1 is in the x component, F2 in the y component.</returns>
+        public static float2 cellular2x2(float2 P)
+        {
+            const float K = 0.142857142857f; // 1/7
+            const float K2 = 0.0714285714285f; // K/2
+            const float jitter = 0.8f; // jitter 1.0 makes F1 wrong more often
+
+            float2 Pi = mod289(floor(P));
+            float2 Pf = frac(P);
+            float4 Pfx = Pf.x + float4(-0.5f, -1.5f, -0.5f, -1.5f);
+            float4 Pfy = Pf.y + float4(-0.5f, -0.5f, -1.5f, -1.5f);
+            float4 p = permute(Pi.x + float4(0.0f, 1.0f, 0.0f, 1.0f));
+            p = permute(p + Pi.y + float4(0.0f, 0.0f, 1.0f, 1.0f));
+            float4 ox = mod7(p) * K + K2;
+            float4 oy = mod7(floor(p * K)) * K + K2;
+            float4 dx = Pfx + jitter * ox;
+            float4 dy = Pfy + jitter * oy;
+            float4 d = dx * dx + dy * dy; // d11, d12, d21 and d22, squared
+            // Sort out the two smallest distances
+            // Do it right and find both F1 and F2
+            d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap if smaller
+            d.xz = (d.x < d.z) ? d.xz : d.zx;
+            d.xw = (d.x < d.w) ? d.xw : d.wx;
+            d.y = min(d.y, d.z);
+            d.y = min(d.y, d.w);
+            return sqrt(d.xy);
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2x2.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fb26f7539fea841ac9538c01e2c20bc4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2x2x2.cs

@@ -0,0 +1,68 @@
+// Cellular noise ("Worley noise") in 3D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// 3D Cellular noise ("Worley noise") with a 2x2x2 search window.
+        /// </summary>
+        /// <remarks>
+        /// Faster than using 3x3x3, at the expense of some pattern artifacts. F2 is often wrong and has sharp discontinuities. If you need a smooth F2, use the slower 3x3x3 version.
+        /// </remarks>
+        /// <param name="P">A point in 3D space.</param>
+        /// <returns>Feature points. F1 is in the x component, F2 in the y component.</returns>
+        public static float2 cellular2x2x2(float3 P)
+        {
+            const float K = 0.142857142857f; // 1/7
+            const float Ko = 0.428571428571f; // 1/2-K/2
+            const float K2 = 0.020408163265306f; // 1/(7*7)
+            const float Kz = 0.166666666667f; // 1/6
+            const float Kzo = 0.416666666667f; // 1/2-1/6*2
+            const float jitter = 0.8f; // smaller jitter gives less errors in F2
+
+            float3 Pi = mod289(floor(P));
+            float3 Pf = frac(P);
+            float4 Pfx = Pf.x + float4(0.0f, -1.0f, 0.0f, -1.0f);
+            float4 Pfy = Pf.y + float4(0.0f, 0.0f, -1.0f, -1.0f);
+            float4 p = permute(Pi.x + float4(0.0f, 1.0f, 0.0f, 1.0f));
+            p = permute(p + Pi.y + float4(0.0f, 0.0f, 1.0f, 1.0f));
+            float4 p1 = permute(p + Pi.z); // z+0
+            float4 p2 = permute(p + Pi.z + float4(1.0f,1.0f,1.0f,1.0f)); // z+1
+            float4 ox1 = frac(p1 * K) - Ko;
+            float4 oy1 = mod7(floor(p1 * K)) * K - Ko;
+            float4 oz1 = floor(p1 * K2) * Kz - Kzo; // p1 < 289 guaranteed
+            float4 ox2 = frac(p2 * K) - Ko;
+            float4 oy2 = mod7(floor(p2 * K)) * K - Ko;
+            float4 oz2 = floor(p2 * K2) * Kz - Kzo;
+            float4 dx1 = Pfx + jitter * ox1;
+            float4 dy1 = Pfy + jitter * oy1;
+            float4 dz1 = Pf.z + jitter * oz1;
+            float4 dx2 = Pfx + jitter * ox2;
+            float4 dy2 = Pfy + jitter * oy2;
+            float4 dz2 = Pf.z - 1.0f + jitter * oz2;
+            float4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
+            float4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1
+
+            // Sort out the two smallest distances (F1, F2)
+
+            // Do it right and sort out both F1 and F2
+            float4 d = min(d1,d2); // F1 is now in d
+            d2 = max(d1,d2); // Make sure we keep all candidates for F2
+            d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap smallest to d.x
+            d.xz = (d.x < d.z) ? d.xz : d.zx;
+            d.xw = (d.x < d.w) ? d.xw : d.wx; // F1 is now in d.x
+            d.yzw = min(d.yzw, d2.yzw); // F2 now not in d2.yzw
+            d.y = min(d.y, d.z); // nor in d.z
+            d.y = min(d.y, d.w); // nor in d.w
+            d.y = min(d.y, d2.x); // F2 is now in d.y
+            return sqrt(d.xy); // F1 and F2
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular2x2x2.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d0dbb238670f4580aa39c5272c2911c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular3D.cs

@@ -0,0 +1,171 @@
+// Cellular noise ("Worley noise") in 3D in GLSL.
+// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
+// This code is released under the conditions of the MIT license.
+// See LICENSE file for details.
+// https://github.com/stegu/webgl-noise
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// 3D Cellular noise ("Worley noise") with 3x3x3 search region for good F2 everywhere, but a lot slower than the 2x2x2 version.
+        /// </summary>
+        /// <param name="P">A point in 2D space.</param>
+        /// <returns>Feature points. F1 is in the x component, F2 in the y component.</returns>
+        // The code below is a bit scary even to its author,
+        // but it has at least half decent performance on a
+        // math.modern GPU. In any case, it beats any software
+        // implementation of Worley noise hands down.
+
+        public static float2 cellular(float3 P)
+        {
+            const float K = 0.142857142857f; // 1/7
+            const float Ko = 0.428571428571f; // 1/2-K/2
+            const float K2 = 0.020408163265306f; // 1/(7*7)
+            const float Kz = 0.166666666667f; // 1/6
+            const float Kzo = 0.416666666667f; // 1/2-1/6*2
+            const float jitter = 1.0f; // smaller jitter gives more regular pattern
+
+            float3 Pi = mod289(floor(P));
+            float3 Pf = frac(P) - 0.5f;
+
+            float3 Pfx = Pf.x + float3(1.0f, 0.0f, -1.0f);
+            float3 Pfy = Pf.y + float3(1.0f, 0.0f, -1.0f);
+            float3 Pfz = Pf.z + float3(1.0f, 0.0f, -1.0f);
+
+            float3 p = permute(Pi.x + float3(-1.0f, 0.0f, 1.0f));
+            float3 p1 = permute(p + Pi.y - 1.0f);
+            float3 p2 = permute(p + Pi.y);
+            float3 p3 = permute(p + Pi.y + 1.0f);
+
+            float3 p11 = permute(p1 + Pi.z - 1.0f);
+            float3 p12 = permute(p1 + Pi.z);
+            float3 p13 = permute(p1 + Pi.z + 1.0f);
+
+            float3 p21 = permute(p2 + Pi.z - 1.0f);
+            float3 p22 = permute(p2 + Pi.z);
+            float3 p23 = permute(p2 + Pi.z + 1.0f);
+
+            float3 p31 = permute(p3 + Pi.z - 1.0f);
+            float3 p32 = permute(p3 + Pi.z);
+            float3 p33 = permute(p3 + Pi.z + 1.0f);
+
+            float3 ox11 = frac(p11 * K) - Ko;
+            float3 oy11 = mod7(floor(p11 * K)) * K - Ko;
+            float3 oz11 = floor(p11 * K2) * Kz - Kzo; // p11 < 289 guaranteed
+
+            float3 ox12 = frac(p12 * K) - Ko;
+            float3 oy12 = mod7(floor(p12 * K)) * K - Ko;
+            float3 oz12 = floor(p12 * K2) * Kz - Kzo;
+
+            float3 ox13 = frac(p13 * K) - Ko;
+            float3 oy13 = mod7(floor(p13 * K)) * K - Ko;
+            float3 oz13 = floor(p13 * K2) * Kz - Kzo;
+
+            float3 ox21 = frac(p21 * K) - Ko;
+            float3 oy21 = mod7(floor(p21 * K)) * K - Ko;
+            float3 oz21 = floor(p21 * K2) * Kz - Kzo;
+
+            float3 ox22 = frac(p22 * K) - Ko;
+            float3 oy22 = mod7(floor(p22 * K)) * K - Ko;
+            float3 oz22 = floor(p22 * K2) * Kz - Kzo;
+
+            float3 ox23 = frac(p23 * K) - Ko;
+            float3 oy23 = mod7(floor(p23 * K)) * K - Ko;
+            float3 oz23 = floor(p23 * K2) * Kz - Kzo;
+
+            float3 ox31 = frac(p31 * K) - Ko;
+            float3 oy31 = mod7(floor(p31 * K)) * K - Ko;
+            float3 oz31 = floor(p31 * K2) * Kz - Kzo;
+
+            float3 ox32 = frac(p32 * K) - Ko;
+            float3 oy32 = mod7(floor(p32 * K)) * K - Ko;
+            float3 oz32 = floor(p32 * K2) * Kz - Kzo;
+
+            float3 ox33 = frac(p33 * K) - Ko;
+            float3 oy33 = mod7(floor(p33 * K)) * K - Ko;
+            float3 oz33 = floor(p33 * K2) * Kz - Kzo;
+
+            float3 dx11 = Pfx + jitter * ox11;
+            float3 dy11 = Pfy.x + jitter * oy11;
+            float3 dz11 = Pfz.x + jitter * oz11;
+
+            float3 dx12 = Pfx + jitter * ox12;
+            float3 dy12 = Pfy.x + jitter * oy12;
+            float3 dz12 = Pfz.y + jitter * oz12;
+
+            float3 dx13 = Pfx + jitter * ox13;
+            float3 dy13 = Pfy.x + jitter * oy13;
+            float3 dz13 = Pfz.z + jitter * oz13;
+
+            float3 dx21 = Pfx + jitter * ox21;
+            float3 dy21 = Pfy.y + jitter * oy21;
+            float3 dz21 = Pfz.x + jitter * oz21;
+
+            float3 dx22 = Pfx + jitter * ox22;
+            float3 dy22 = Pfy.y + jitter * oy22;
+            float3 dz22 = Pfz.y + jitter * oz22;
+
+            float3 dx23 = Pfx + jitter * ox23;
+            float3 dy23 = Pfy.y + jitter * oy23;
+            float3 dz23 = Pfz.z + jitter * oz23;
+
+            float3 dx31 = Pfx + jitter * ox31;
+            float3 dy31 = Pfy.z + jitter * oy31;
+            float3 dz31 = Pfz.x + jitter * oz31;
+
+            float3 dx32 = Pfx + jitter * ox32;
+            float3 dy32 = Pfy.z + jitter * oy32;
+            float3 dz32 = Pfz.y + jitter * oz32;
+
+            float3 dx33 = Pfx + jitter * ox33;
+            float3 dy33 = Pfy.z + jitter * oy33;
+            float3 dz33 = Pfz.z + jitter * oz33;
+
+            float3 d11 = dx11 * dx11 + dy11 * dy11 + dz11 * dz11;
+            float3 d12 = dx12 * dx12 + dy12 * dy12 + dz12 * dz12;
+            float3 d13 = dx13 * dx13 + dy13 * dy13 + dz13 * dz13;
+            float3 d21 = dx21 * dx21 + dy21 * dy21 + dz21 * dz21;
+            float3 d22 = dx22 * dx22 + dy22 * dy22 + dz22 * dz22;
+            float3 d23 = dx23 * dx23 + dy23 * dy23 + dz23 * dz23;
+            float3 d31 = dx31 * dx31 + dy31 * dy31 + dz31 * dz31;
+            float3 d32 = dx32 * dx32 + dy32 * dy32 + dz32 * dz32;
+            float3 d33 = dx33 * dx33 + dy33 * dy33 + dz33 * dz33;
+
+            // Sort out the two smallest distances (F1, F2)
+            // Do it right and sort out both F1 and F2
+            float3 d1a = min(d11, d12);
+            d12 = max(d11, d12);
+            d11 = min(d1a, d13); // Smallest now not in d12 or d13
+            d13 = max(d1a, d13);
+            d12 = min(d12, d13); // 2nd smallest now not in d13
+            float3 d2a = min(d21, d22);
+            d22 = max(d21, d22);
+            d21 = min(d2a, d23); // Smallest now not in d22 or d23
+            d23 = max(d2a, d23);
+            d22 = min(d22, d23); // 2nd smallest now not in d23
+            float3 d3a = min(d31, d32);
+            d32 = max(d31, d32);
+            d31 = min(d3a, d33); // Smallest now not in d32 or d33
+            d33 = max(d3a, d33);
+            d32 = min(d32, d33); // 2nd smallest now not in d33
+            float3 da = min(d11, d21);
+            d21 = max(d11, d21);
+            d11 = min(da, d31); // Smallest now in d11
+            d31 = max(da, d31); // 2nd smallest now not in d31
+            d11.xy = (d11.x < d11.y) ? d11.xy : d11.yx;
+            d11.xz = (d11.x < d11.z) ? d11.xz : d11.zx; // d11.x now smallest
+            d12 = min(d12, d21); // 2nd smallest now not in d21
+            d12 = min(d12, d22); // nor in d22
+            d12 = min(d12, d31); // nor in d31
+            d12 = min(d12, d32); // nor in d32
+            d11.yz = min(d11.yz, d12.xy); // nor in d12.yz
+            d11.y = min(d11.y, d12.z); // Only two more to go
+            d11.y = min(d11.y, d11.z); // Done! (Phew!)
+            return sqrt(d11.xy); // F1, F2
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/cellular3D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6cea5378726344e72bf53fa723c6c3fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise2D.cs

@@ -0,0 +1,111 @@
+//
+// GLSL textureless classic 2D noise "cnoise",
+// with an RSL-style periodic variant "pnoise".
+// Author:  Stefan Gustavson (stefan.gustavson@liu.se)
+// Version: 2011-08-22
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// ideas for permutation and gradient selection.
+//
+// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
+// Distributed under the MIT license. See LICENSE file.
+// https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Classic Perlin noise
+        /// </summary>
+        /// <param name="P">Point on a 2D grid of gradient vectors.</param>
+        /// <returns>Noise value.</returns>
+        public static float cnoise(float2 P)
+        {
+            float4 Pi = floor(P.xyxy) + float4(0.0f, 0.0f, 1.0f, 1.0f);
+            float4 Pf = frac(P.xyxy) - float4(0.0f, 0.0f, 1.0f, 1.0f);
+            Pi = mod289(Pi); // To avoid truncation effects in permutation
+            float4 ix = Pi.xzxz;
+            float4 iy = Pi.yyww;
+            float4 fx = Pf.xzxz;
+            float4 fy = Pf.yyww;
+
+            float4 i = permute(permute(ix) + iy);
+
+            float4 gx = frac(i * (1.0f / 41.0f)) * 2.0f - 1.0f;
+            float4 gy = abs(gx) - 0.5f;
+            float4 tx = floor(gx + 0.5f);
+            gx = gx - tx;
+
+            float2 g00 = float2(gx.x, gy.x);
+            float2 g10 = float2(gx.y, gy.y);
+            float2 g01 = float2(gx.z, gy.z);
+            float2 g11 = float2(gx.w, gy.w);
+
+            float4 norm = taylorInvSqrt(float4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+            g00 *= norm.x;
+            g01 *= norm.y;
+            g10 *= norm.z;
+            g11 *= norm.w;
+
+            float n00 = dot(g00, float2(fx.x, fy.x));
+            float n10 = dot(g10, float2(fx.y, fy.y));
+            float n01 = dot(g01, float2(fx.z, fy.z));
+            float n11 = dot(g11, float2(fx.w, fy.w));
+
+            float2 fade_xy = fade(Pf.xy);
+            float2 n_x = lerp(float2(n00, n01), float2(n10, n11), fade_xy.x);
+            float n_xy = lerp(n_x.x, n_x.y, fade_xy.y);
+            return 2.3f * n_xy;
+        }
+
+        /// <summary>
+        /// Classic Perlin noise, periodic variant
+        /// </summary>
+        /// <param name="P">Point on a 2D grid of gradient vectors.</param>
+        /// <param name="rep">Period of repetition.</param>
+        /// <returns>Noise value.</returns>
+        public static float pnoise(float2 P, float2 rep)
+        {
+            float4 Pi = floor(P.xyxy) + float4(0.0f, 0.0f, 1.0f, 1.0f);
+            float4 Pf = frac(P.xyxy) - float4(0.0f, 0.0f, 1.0f, 1.0f);
+            Pi = fmod(Pi, rep.xyxy); // To create noise with explicit period
+            Pi = mod289(Pi); // To avoid truncation effects in permutation
+            float4 ix = Pi.xzxz;
+            float4 iy = Pi.yyww;
+            float4 fx = Pf.xzxz;
+            float4 fy = Pf.yyww;
+
+            float4 i = permute(permute(ix) + iy);
+
+            float4 gx = frac(i * (1.0f / 41.0f)) * 2.0f - 1.0f;
+            float4 gy = abs(gx) - 0.5f;
+            float4 tx = floor(gx + 0.5f);
+            gx = gx - tx;
+
+            float2 g00 = float2(gx.x, gy.x);
+            float2 g10 = float2(gx.y, gy.y);
+            float2 g01 = float2(gx.z, gy.z);
+            float2 g11 = float2(gx.w, gy.w);
+
+            float4 norm = taylorInvSqrt(float4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+            g00 *= norm.x;
+            g01 *= norm.y;
+            g10 *= norm.z;
+            g11 *= norm.w;
+
+            float n00 = dot(g00, float2(fx.x, fy.x));
+            float n10 = dot(g10, float2(fx.y, fy.y));
+            float n01 = dot(g01, float2(fx.z, fy.z));
+            float n11 = dot(g11, float2(fx.w, fy.w));
+
+            float2 fade_xy = fade(Pf.xy);
+            float2 n_x = lerp(float2(n00, n01), float2(n10, n11), fade_xy.x);
+            float n_xy = lerp(n_x.x, n_x.y, fade_xy.y);
+            return 2.3f * n_xy;
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cdfa008cc8af3440983f8c7beef680b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise3D.cs

@@ -0,0 +1,170 @@
+//
+// GLSL textureless classic 3D noise "cnoise",
+// with an RSL-style periodic variant "pnoise".
+// Author:  Stefan Gustavson (stefan.gustavson@liu.se)
+// Version: 2011-10-11
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// ideas for permutation and gradient selection.
+//
+// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
+// Distributed under the MIT license. See LICENSE file.
+// https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Classic Perlin noise
+        /// </summary>
+        /// <param name="P">Point on a 3D grid of gradient vectors.</param>
+        /// <returns>Noise value.</returns>
+        public static float cnoise(float3 P)
+        {
+            float3 Pi0 = floor(P); // Integer part for indexing
+            float3 Pi1 = Pi0 + float3(1.0f); // Integer part + 1
+            Pi0 = mod289(Pi0);
+            Pi1 = mod289(Pi1);
+            float3 Pf0 = frac(P); // Fractional part for interpolation
+            float3 Pf1 = Pf0 - float3(1.0f); // Fractional part - 1.0
+            float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+            float4 iy = float4(Pi0.yy, Pi1.yy);
+            float4 iz0 = Pi0.zzzz;
+            float4 iz1 = Pi1.zzzz;
+
+            float4 ixy = permute(permute(ix) + iy);
+            float4 ixy0 = permute(ixy + iz0);
+            float4 ixy1 = permute(ixy + iz1);
+
+            float4 gx0 = ixy0 * (1.0f / 7.0f);
+            float4 gy0 = frac(floor(gx0) * (1.0f / 7.0f)) - 0.5f;
+            gx0 = frac(gx0);
+            float4 gz0 = float4(0.5f) - abs(gx0) - abs(gy0);
+            float4 sz0 = step(gz0, float4(0.0f));
+            gx0 -= sz0 * (step(0.0f, gx0) - 0.5f);
+            gy0 -= sz0 * (step(0.0f, gy0) - 0.5f);
+
+            float4 gx1 = ixy1 * (1.0f / 7.0f);
+            float4 gy1 = frac(floor(gx1) * (1.0f / 7.0f)) - 0.5f;
+            gx1 = frac(gx1);
+            float4 gz1 = float4(0.5f) - abs(gx1) - abs(gy1);
+            float4 sz1 = step(gz1, float4(0.0f));
+            gx1 -= sz1 * (step(0.0f, gx1) - 0.5f);
+            gy1 -= sz1 * (step(0.0f, gy1) - 0.5f);
+
+            float3 g000 = float3(gx0.x, gy0.x, gz0.x);
+            float3 g100 = float3(gx0.y, gy0.y, gz0.y);
+            float3 g010 = float3(gx0.z, gy0.z, gz0.z);
+            float3 g110 = float3(gx0.w, gy0.w, gz0.w);
+            float3 g001 = float3(gx1.x, gy1.x, gz1.x);
+            float3 g101 = float3(gx1.y, gy1.y, gz1.y);
+            float3 g011 = float3(gx1.z, gy1.z, gz1.z);
+            float3 g111 = float3(gx1.w, gy1.w, gz1.w);
+
+            float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+            g000 *= norm0.x;
+            g010 *= norm0.y;
+            g100 *= norm0.z;
+            g110 *= norm0.w;
+            float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+            g001 *= norm1.x;
+            g011 *= norm1.y;
+            g101 *= norm1.z;
+            g111 *= norm1.w;
+
+            float n000 = dot(g000, Pf0);
+            float n100 = dot(g100, float3(Pf1.x, Pf0.yz));
+            float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
+            float n110 = dot(g110, float3(Pf1.xy, Pf0.z));
+            float n001 = dot(g001, float3(Pf0.xy, Pf1.z));
+            float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
+            float n011 = dot(g011, float3(Pf0.x, Pf1.yz));
+            float n111 = dot(g111, Pf1);
+
+            float3 fade_xyz = fade(Pf0);
+            float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
+            float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
+            float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
+            return 2.2f * n_xyz;
+        }
+
+        /// <summary>
+        /// Classic Perlin noise, periodic variant
+        /// </summary>
+        /// <param name="P">Point on a 3D grid of gradient vectors.</param>
+        /// <param name="rep">Period of repetition.</param>
+        /// <returns>Noise value.</returns>
+        public static float pnoise(float3 P, float3 rep)
+        {
+            float3 Pi0 = fmod(floor(P), rep); // Integer part, math.modulo period
+            float3 Pi1 = fmod(Pi0 + float3(1.0f), rep); // Integer part + 1, math.mod period
+            Pi0 = mod289(Pi0);
+            Pi1 = mod289(Pi1);
+            float3 Pf0 = frac(P); // Fractional part for interpolation
+            float3 Pf1 = Pf0 - float3(1.0f); // Fractional part - 1.0
+            float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+            float4 iy = float4(Pi0.yy, Pi1.yy);
+            float4 iz0 = Pi0.zzzz;
+            float4 iz1 = Pi1.zzzz;
+
+            float4 ixy = permute(permute(ix) + iy);
+            float4 ixy0 = permute(ixy + iz0);
+            float4 ixy1 = permute(ixy + iz1);
+
+            float4 gx0 = ixy0 * (1.0f / 7.0f);
+            float4 gy0 = frac(floor(gx0) * (1.0f / 7.0f)) - 0.5f;
+            gx0 = frac(gx0);
+            float4 gz0 = float4(0.5f) - abs(gx0) - abs(gy0);
+            float4 sz0 = step(gz0, float4(0.0f));
+            gx0 -= sz0 * (step(0.0f, gx0) - 0.5f);
+            gy0 -= sz0 * (step(0.0f, gy0) - 0.5f);
+
+            float4 gx1 = ixy1 * (1.0f / 7.0f);
+            float4 gy1 = frac(floor(gx1) * (1.0f / 7.0f)) - 0.5f;
+            gx1 = frac(gx1);
+            float4 gz1 = float4(0.5f) - abs(gx1) - abs(gy1);
+            float4 sz1 = step(gz1, float4(0.0f));
+            gx1 -= sz1 * (step(0.0f, gx1) - 0.5f);
+            gy1 -= sz1 * (step(0.0f, gy1) - 0.5f);
+
+            float3 g000 = float3(gx0.x, gy0.x, gz0.x);
+            float3 g100 = float3(gx0.y, gy0.y, gz0.y);
+            float3 g010 = float3(gx0.z, gy0.z, gz0.z);
+            float3 g110 = float3(gx0.w, gy0.w, gz0.w);
+            float3 g001 = float3(gx1.x, gy1.x, gz1.x);
+            float3 g101 = float3(gx1.y, gy1.y, gz1.y);
+            float3 g011 = float3(gx1.z, gy1.z, gz1.z);
+            float3 g111 = float3(gx1.w, gy1.w, gz1.w);
+
+            float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+            g000 *= norm0.x;
+            g010 *= norm0.y;
+            g100 *= norm0.z;
+            g110 *= norm0.w;
+            float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+            g001 *= norm1.x;
+            g011 *= norm1.y;
+            g101 *= norm1.z;
+            g111 *= norm1.w;
+
+            float n000 = dot(g000, Pf0);
+            float n100 = dot(g100, float3(Pf1.x, Pf0.yz));
+            float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
+            float n110 = dot(g110, float3(Pf1.xy, Pf0.z));
+            float n001 = dot(g001, float3(Pf0.xy, Pf1.z));
+            float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
+            float n011 = dot(g011, float3(Pf0.x, Pf1.yz));
+            float n111 = dot(g111, Pf1);
+
+            float3 fade_xyz = fade(Pf0);
+            float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
+            float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
+            float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
+            return 2.2f * n_xyz;
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise3D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ab5efd242473d4ce9b3d98450681549c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise4D.cs

@@ -0,0 +1,300 @@
+//
+// GLSL textureless classic 4D noise "cnoise",
+// with an RSL-style periodic variant "pnoise".
+// Author:  Stefan Gustavson (stefan.gustavson@liu.se)
+// Version: 2011-08-22
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// ideas for permutation and gradient selection.
+//
+// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
+// Distributed under the MIT license. See LICENSE file.
+// https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Classic Perlin noise
+        /// </summary>
+        /// <param name="P">Point on a 4D grid of gradient vectors.</param>
+        /// <returns>Noise value.</returns>
+        public static float cnoise(float4 P)
+        {
+            float4 Pi0 = floor(P); // Integer part for indexing
+            float4 Pi1 = Pi0 + 1.0f; // Integer part + 1
+            Pi0 = mod289(Pi0);
+            Pi1 = mod289(Pi1);
+            float4 Pf0 = frac(P); // Fractional part for interpolation
+            float4 Pf1 = Pf0 - 1.0f; // Fractional part - 1.0
+            float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+            float4 iy = float4(Pi0.yy, Pi1.yy);
+            float4 iz0 = float4(Pi0.zzzz);
+            float4 iz1 = float4(Pi1.zzzz);
+            float4 iw0 = float4(Pi0.wwww);
+            float4 iw1 = float4(Pi1.wwww);
+
+            float4 ixy = permute(permute(ix) + iy);
+            float4 ixy0 = permute(ixy + iz0);
+            float4 ixy1 = permute(ixy + iz1);
+            float4 ixy00 = permute(ixy0 + iw0);
+            float4 ixy01 = permute(ixy0 + iw1);
+            float4 ixy10 = permute(ixy1 + iw0);
+            float4 ixy11 = permute(ixy1 + iw1);
+
+            float4 gx00 = ixy00 * (1.0f / 7.0f);
+            float4 gy00 = floor(gx00) * (1.0f / 7.0f);
+            float4 gz00 = floor(gy00) * (1.0f / 6.0f);
+            gx00 = frac(gx00) - 0.5f;
+            gy00 = frac(gy00) - 0.5f;
+            gz00 = frac(gz00) - 0.5f;
+            float4 gw00 = float4(0.75f) - abs(gx00) - abs(gy00) - abs(gz00);
+            float4 sw00 = step(gw00, float4(0.0f));
+            gx00 -= sw00 * (step(0.0f, gx00) - 0.5f);
+            gy00 -= sw00 * (step(0.0f, gy00) - 0.5f);
+
+            float4 gx01 = ixy01 * (1.0f / 7.0f);
+            float4 gy01 = floor(gx01) * (1.0f / 7.0f);
+            float4 gz01 = floor(gy01) * (1.0f / 6.0f);
+            gx01 = frac(gx01) - 0.5f;
+            gy01 = frac(gy01) - 0.5f;
+            gz01 = frac(gz01) - 0.5f;
+            float4 gw01 = float4(0.75f) - abs(gx01) - abs(gy01) - abs(gz01);
+            float4 sw01 = step(gw01, float4(0.0f));
+            gx01 -= sw01 * (step(0.0f, gx01) - 0.5f);
+            gy01 -= sw01 * (step(0.0f, gy01) - 0.5f);
+
+            float4 gx10 = ixy10 * (1.0f / 7.0f);
+            float4 gy10 = floor(gx10) * (1.0f / 7.0f);
+            float4 gz10 = floor(gy10) * (1.0f / 6.0f);
+            gx10 = frac(gx10) - 0.5f;
+            gy10 = frac(gy10) - 0.5f;
+            gz10 = frac(gz10) - 0.5f;
+            float4 gw10 = float4(0.75f) - abs(gx10) - abs(gy10) - abs(gz10);
+            float4 sw10 = step(gw10, float4(0.0f));
+            gx10 -= sw10 * (step(0.0f, gx10) - 0.5f);
+            gy10 -= sw10 * (step(0.0f, gy10) - 0.5f);
+
+            float4 gx11 = ixy11 * (1.0f / 7.0f);
+            float4 gy11 = floor(gx11) * (1.0f / 7.0f);
+            float4 gz11 = floor(gy11) * (1.0f / 6.0f);
+            gx11 = frac(gx11) - 0.5f;
+            gy11 = frac(gy11) - 0.5f;
+            gz11 = frac(gz11) - 0.5f;
+            float4 gw11 = float4(0.75f) - abs(gx11) - abs(gy11) - abs(gz11);
+            float4 sw11 = step(gw11, float4(0.0f));
+            gx11 -= sw11 * (step(0.0f, gx11) - 0.5f);
+            gy11 -= sw11 * (step(0.0f, gy11) - 0.5f);
+
+            float4 g0000 = float4(gx00.x, gy00.x, gz00.x, gw00.x);
+            float4 g1000 = float4(gx00.y, gy00.y, gz00.y, gw00.y);
+            float4 g0100 = float4(gx00.z, gy00.z, gz00.z, gw00.z);
+            float4 g1100 = float4(gx00.w, gy00.w, gz00.w, gw00.w);
+            float4 g0010 = float4(gx10.x, gy10.x, gz10.x, gw10.x);
+            float4 g1010 = float4(gx10.y, gy10.y, gz10.y, gw10.y);
+            float4 g0110 = float4(gx10.z, gy10.z, gz10.z, gw10.z);
+            float4 g1110 = float4(gx10.w, gy10.w, gz10.w, gw10.w);
+            float4 g0001 = float4(gx01.x, gy01.x, gz01.x, gw01.x);
+            float4 g1001 = float4(gx01.y, gy01.y, gz01.y, gw01.y);
+            float4 g0101 = float4(gx01.z, gy01.z, gz01.z, gw01.z);
+            float4 g1101 = float4(gx01.w, gy01.w, gz01.w, gw01.w);
+            float4 g0011 = float4(gx11.x, gy11.x, gz11.x, gw11.x);
+            float4 g1011 = float4(gx11.y, gy11.y, gz11.y, gw11.y);
+            float4 g0111 = float4(gx11.z, gy11.z, gz11.z, gw11.z);
+            float4 g1111 = float4(gx11.w, gy11.w, gz11.w, gw11.w);
+
+            float4 norm00 = taylorInvSqrt(float4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+            g0000 *= norm00.x;
+            g0100 *= norm00.y;
+            g1000 *= norm00.z;
+            g1100 *= norm00.w;
+
+            float4 norm01 = taylorInvSqrt(float4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+            g0001 *= norm01.x;
+            g0101 *= norm01.y;
+            g1001 *= norm01.z;
+            g1101 *= norm01.w;
+
+            float4 norm10 = taylorInvSqrt(float4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+            g0010 *= norm10.x;
+            g0110 *= norm10.y;
+            g1010 *= norm10.z;
+            g1110 *= norm10.w;
+
+            float4 norm11 = taylorInvSqrt(float4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+            g0011 *= norm11.x;
+            g0111 *= norm11.y;
+            g1011 *= norm11.z;
+            g1111 *= norm11.w;
+
+            float n0000 = dot(g0000, Pf0);
+            float n1000 = dot(g1000, float4(Pf1.x, Pf0.yzw));
+            float n0100 = dot(g0100, float4(Pf0.x, Pf1.y, Pf0.zw));
+            float n1100 = dot(g1100, float4(Pf1.xy, Pf0.zw));
+            float n0010 = dot(g0010, float4(Pf0.xy, Pf1.z, Pf0.w));
+            float n1010 = dot(g1010, float4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+            float n0110 = dot(g0110, float4(Pf0.x, Pf1.yz, Pf0.w));
+            float n1110 = dot(g1110, float4(Pf1.xyz, Pf0.w));
+            float n0001 = dot(g0001, float4(Pf0.xyz, Pf1.w));
+            float n1001 = dot(g1001, float4(Pf1.x, Pf0.yz, Pf1.w));
+            float n0101 = dot(g0101, float4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+            float n1101 = dot(g1101, float4(Pf1.xy, Pf0.z, Pf1.w));
+            float n0011 = dot(g0011, float4(Pf0.xy, Pf1.zw));
+            float n1011 = dot(g1011, float4(Pf1.x, Pf0.y, Pf1.zw));
+            float n0111 = dot(g0111, float4(Pf0.x, Pf1.yzw));
+            float n1111 = dot(g1111, Pf1);
+
+            float4 fade_xyzw = fade(Pf0);
+            float4 n_0w = lerp(float4(n0000, n1000, n0100, n1100), float4(n0001, n1001, n0101, n1101), fade_xyzw.w);
+            float4 n_1w = lerp(float4(n0010, n1010, n0110, n1110), float4(n0011, n1011, n0111, n1111), fade_xyzw.w);
+            float4 n_zw = lerp(n_0w, n_1w, fade_xyzw.z);
+            float2 n_yzw = lerp(n_zw.xy, n_zw.zw, fade_xyzw.y);
+            float n_xyzw = lerp(n_yzw.x, n_yzw.y, fade_xyzw.x);
+            return 2.2f * n_xyzw;
+        }
+
+        /// <summary>
+        /// Classic Perlin noise, periodic variant
+        /// </summary>
+        /// <param name="P">Point on a 4D grid of gradient vectors.</param>
+        /// <param name="rep">Period of repetition.</param>
+        /// <returns>Noise value.</returns>
+        public static float pnoise(float4 P, float4 rep)
+        {
+            float4 Pi0 = fmod(floor(P), rep); // Integer part math.modulo rep
+            float4 Pi1 = fmod(Pi0 + 1.0f, rep); // Integer part + 1 math.mod rep
+            Pi0 = mod289(Pi0);
+            Pi1 = mod289(Pi1);
+            float4 Pf0 = frac(P); // Fractional part for interpolation
+            float4 Pf1 = Pf0 - 1.0f; // Fractional part - 1.0
+            float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+            float4 iy = float4(Pi0.yy, Pi1.yy);
+            float4 iz0 = float4(Pi0.zzzz);
+            float4 iz1 = float4(Pi1.zzzz);
+            float4 iw0 = float4(Pi0.wwww);
+            float4 iw1 = float4(Pi1.wwww);
+
+            float4 ixy = permute(permute(ix) + iy);
+            float4 ixy0 = permute(ixy + iz0);
+            float4 ixy1 = permute(ixy + iz1);
+            float4 ixy00 = permute(ixy0 + iw0);
+            float4 ixy01 = permute(ixy0 + iw1);
+            float4 ixy10 = permute(ixy1 + iw0);
+            float4 ixy11 = permute(ixy1 + iw1);
+
+            float4 gx00 = ixy00 * (1.0f / 7.0f);
+            float4 gy00 = floor(gx00) * (1.0f / 7.0f);
+            float4 gz00 = floor(gy00) * (1.0f / 6.0f);
+            gx00 = frac(gx00) - 0.5f;
+            gy00 = frac(gy00) - 0.5f;
+            gz00 = frac(gz00) - 0.5f;
+            float4 gw00 = float4(0.75f) - abs(gx00) - abs(gy00) - abs(gz00);
+            float4 sw00 = step(gw00, float4(0.0f));
+            gx00 -= sw00 * (step(0.0f, gx00) - 0.5f);
+            gy00 -= sw00 * (step(0.0f, gy00) - 0.5f);
+
+            float4 gx01 = ixy01 * (1.0f / 7.0f);
+            float4 gy01 = floor(gx01) * (1.0f / 7.0f);
+            float4 gz01 = floor(gy01) * (1.0f / 6.0f);
+            gx01 = frac(gx01) - 0.5f;
+            gy01 = frac(gy01) - 0.5f;
+            gz01 = frac(gz01) - 0.5f;
+            float4 gw01 = float4(0.75f) - abs(gx01) - abs(gy01) - abs(gz01);
+            float4 sw01 = step(gw01, float4(0.0f));
+            gx01 -= sw01 * (step(0.0f, gx01) - 0.5f);
+            gy01 -= sw01 * (step(0.0f, gy01) - 0.5f);
+
+            float4 gx10 = ixy10 * (1.0f / 7.0f);
+            float4 gy10 = floor(gx10) * (1.0f / 7.0f);
+            float4 gz10 = floor(gy10) * (1.0f / 6.0f);
+            gx10 = frac(gx10) - 0.5f;
+            gy10 = frac(gy10) - 0.5f;
+            gz10 = frac(gz10) - 0.5f;
+            float4 gw10 = float4(0.75f) - abs(gx10) - abs(gy10) - abs(gz10);
+            float4 sw10 = step(gw10, float4(0.0f));
+            gx10 -= sw10 * (step(0.0f, gx10) - 0.5f);
+            gy10 -= sw10 * (step(0.0f, gy10) - 0.5f);
+
+            float4 gx11 = ixy11 * (1.0f / 7.0f);
+            float4 gy11 = floor(gx11) * (1.0f / 7.0f);
+            float4 gz11 = floor(gy11) * (1.0f / 6.0f);
+            gx11 = frac(gx11) - 0.5f;
+            gy11 = frac(gy11) - 0.5f;
+            gz11 = frac(gz11) - 0.5f;
+            float4 gw11 = float4(0.75f) - abs(gx11) - abs(gy11) - abs(gz11);
+            float4 sw11 = step(gw11, float4(0.0f));
+            gx11 -= sw11 * (step(0.0f, gx11) - 0.5f);
+            gy11 -= sw11 * (step(0.0f, gy11) - 0.5f);
+
+            float4 g0000 = float4(gx00.x, gy00.x, gz00.x, gw00.x);
+            float4 g1000 = float4(gx00.y, gy00.y, gz00.y, gw00.y);
+            float4 g0100 = float4(gx00.z, gy00.z, gz00.z, gw00.z);
+            float4 g1100 = float4(gx00.w, gy00.w, gz00.w, gw00.w);
+            float4 g0010 = float4(gx10.x, gy10.x, gz10.x, gw10.x);
+            float4 g1010 = float4(gx10.y, gy10.y, gz10.y, gw10.y);
+            float4 g0110 = float4(gx10.z, gy10.z, gz10.z, gw10.z);
+            float4 g1110 = float4(gx10.w, gy10.w, gz10.w, gw10.w);
+            float4 g0001 = float4(gx01.x, gy01.x, gz01.x, gw01.x);
+            float4 g1001 = float4(gx01.y, gy01.y, gz01.y, gw01.y);
+            float4 g0101 = float4(gx01.z, gy01.z, gz01.z, gw01.z);
+            float4 g1101 = float4(gx01.w, gy01.w, gz01.w, gw01.w);
+            float4 g0011 = float4(gx11.x, gy11.x, gz11.x, gw11.x);
+            float4 g1011 = float4(gx11.y, gy11.y, gz11.y, gw11.y);
+            float4 g0111 = float4(gx11.z, gy11.z, gz11.z, gw11.z);
+            float4 g1111 = float4(gx11.w, gy11.w, gz11.w, gw11.w);
+
+            float4 norm00 = taylorInvSqrt(float4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+            g0000 *= norm00.x;
+            g0100 *= norm00.y;
+            g1000 *= norm00.z;
+            g1100 *= norm00.w;
+
+            float4 norm01 = taylorInvSqrt(float4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+            g0001 *= norm01.x;
+            g0101 *= norm01.y;
+            g1001 *= norm01.z;
+            g1101 *= norm01.w;
+
+            float4 norm10 = taylorInvSqrt(float4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+            g0010 *= norm10.x;
+            g0110 *= norm10.y;
+            g1010 *= norm10.z;
+            g1110 *= norm10.w;
+
+            float4 norm11 = taylorInvSqrt(float4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+            g0011 *= norm11.x;
+            g0111 *= norm11.y;
+            g1011 *= norm11.z;
+            g1111 *= norm11.w;
+
+            float n0000 = dot(g0000, Pf0);
+            float n1000 = dot(g1000, float4(Pf1.x, Pf0.yzw));
+            float n0100 = dot(g0100, float4(Pf0.x, Pf1.y, Pf0.zw));
+            float n1100 = dot(g1100, float4(Pf1.xy, Pf0.zw));
+            float n0010 = dot(g0010, float4(Pf0.xy, Pf1.z, Pf0.w));
+            float n1010 = dot(g1010, float4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+            float n0110 = dot(g0110, float4(Pf0.x, Pf1.yz, Pf0.w));
+            float n1110 = dot(g1110, float4(Pf1.xyz, Pf0.w));
+            float n0001 = dot(g0001, float4(Pf0.xyz, Pf1.w));
+            float n1001 = dot(g1001, float4(Pf1.x, Pf0.yz, Pf1.w));
+            float n0101 = dot(g0101, float4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+            float n1101 = dot(g1101, float4(Pf1.xy, Pf0.z, Pf1.w));
+            float n0011 = dot(g0011, float4(Pf0.xy, Pf1.zw));
+            float n1011 = dot(g1011, float4(Pf1.x, Pf0.y, Pf1.zw));
+            float n0111 = dot(g0111, float4(Pf0.x, Pf1.yzw));
+            float n1111 = dot(g1111, Pf1);
+
+            float4 fade_xyzw = fade(Pf0);
+            float4 n_0w = lerp(float4(n0000, n1000, n0100, n1100), float4(n0001, n1001, n0101, n1101), fade_xyzw.w);
+            float4 n_1w = lerp(float4(n0010, n1010, n0110, n1110), float4(n0011, n1011, n0111, n1111), fade_xyzw.w);
+            float4 n_zw = lerp(n_0w, n_1w, fade_xyzw.z);
+            float2 n_yzw = lerp(n_zw.xy, n_zw.zw, fade_xyzw.y);
+            float n_xyzw = lerp(n_yzw.x, n_yzw.y, fade_xyzw.x);
+            return 2.2f * n_xyzw;
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/classicnoise4D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 283464e0e530a4cdfbf4fae82efed3e3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/common.cs

@@ -0,0 +1,55 @@
+using Unity.IL2CPP.CompilerServices;
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    /// <summary>
+    /// A static class containing noise functions.
+    /// </summary>
+    [Il2CppEagerStaticClassConstruction]
+    public static partial class noise
+    {
+        // Modulo 289 without a division (only multiplications)
+        static float  mod289(float x)  { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
+        static float2 mod289(float2 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
+        static float3 mod289(float3 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
+        static float4 mod289(float4 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
+
+        // Modulo 7 without a division
+        static float3 mod7(float3 x) { return x - floor(x * (1.0f / 7.0f)) * 7.0f; }
+        static float4 mod7(float4 x) { return x - floor(x * (1.0f / 7.0f)) * 7.0f; }
+
+        // Permutation polynomial: (34x^2 + x) math.mod 289
+        static float  permute(float x)  { return mod289((34.0f * x + 1.0f) * x); }
+        static float3 permute(float3 x) { return mod289((34.0f * x + 1.0f) * x); }
+        static float4 permute(float4 x) { return mod289((34.0f * x + 1.0f) * x); }
+
+        static float  taylorInvSqrt(float r)  { return 1.79284291400159f - 0.85373472095314f * r; }
+        static float4 taylorInvSqrt(float4 r) { return 1.79284291400159f - 0.85373472095314f * r; }
+
+        static float2 fade(float2 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
+        static float3 fade(float3 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
+        static float4 fade(float4 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
+
+        static float4 grad4(float j, float4 ip)
+        {
+            float4 ones = float4(1.0f, 1.0f, 1.0f, -1.0f);
+            float3 pxyz = floor(frac(float3(j) * ip.xyz) * 7.0f) * ip.z - 1.0f;
+            float  pw   = 1.5f - dot(abs(pxyz), ones.xyz);
+            float4 p = float4(pxyz, pw);
+            float4 s = float4(p < 0.0f);
+            p.xyz = p.xyz + (s.xyz*2.0f - 1.0f) * s.www;
+            return p;
+        }
+
+        // Hashed 2-D gradients with an extra rotation.
+        // (The constant 0.0243902439 is 1/41)
+        static float2 rgrad2(float2 p, float rot)
+        {
+            // For more isotropic gradients, math.sin/math.cos can be used instead.
+            float u = permute(permute(p.x) + p.y) * 0.0243902439f + rot; // Rotate by shift
+            u = frac(u) * 6.28318530718f; // 2*pi
+            return float2(cos(u), sin(u));
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/common.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e99a8e417be944dfaad14c2d60f8450d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise2D.cs

@@ -0,0 +1,73 @@
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmath.mod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Simplex noise.
+        /// </summary>
+        /// <param name="v">Input coordinate.</param>
+        /// <returns>Noise value.</returns>
+        public static float snoise(float2 v)
+        {
+            float4 C = float4(0.211324865405187f,  // (3.0-math.sqrt(3.0))/6.0
+                                  0.366025403784439f,  // 0.5*(math.sqrt(3.0)-1.0)
+                                 -0.577350269189626f,  // -1.0 + 2.0 * C.x
+                                  0.024390243902439f); // 1.0 / 41.0
+            // First corner
+            float2 i = floor(v + dot(v, C.yy));
+            float2 x0 = v - i + dot(i, C.xx);
+
+            // Other corners
+            float2 i1;
+            //i1.x = math.step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+            //i1.y = 1.0 - i1.x;
+            i1 = (x0.x > x0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
+            // x0 = x0 - 0.0 + 0.0 * C.xx ;
+            // x1 = x0 - i1 + 1.0 * C.xx ;
+            // x2 = x0 - 1.0 + 2.0 * C.xx ;
+            float4 x12 = x0.xyxy + C.xxzz;
+            x12.xy -= i1;
+
+            // Permutations
+            i = mod289(i); // Avoid truncation effects in permutation
+            float3 p = permute(permute(i.y + float3(0.0f, i1.y, 1.0f)) + i.x + float3(0.0f, i1.x, 1.0f));
+
+            float3 m = max(0.5f - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0f);
+            m = m * m;
+            m = m * m;
+
+            // Gradients: 41 points uniformly over a line, mapped onto a diamond.
+            // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+            float3 x = 2.0f * frac(p * C.www) - 1.0f;
+            float3 h = abs(x) - 0.5f;
+            float3 ox = floor(x + 0.5f);
+            float3 a0 = x - ox;
+
+            // Normalise gradients implicitly by scaling m
+            // Approximation of: m *= inversemath.sqrt( a0*a0 + h*h );
+            m *= 1.79284291400159f - 0.85373472095314f * (a0 * a0 + h * h);
+
+            // Compute final noise value at P
+
+            float  gx = a0.x * x0.x + h.x * x0.y;
+            float2 gyz = a0.yz * x12.xz + h.yz * x12.yw;
+            float3 g = float3(gx,gyz);
+
+            return 130.0f * dot(m, g);
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a44cd1da263fb47c2a45958442e14af6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise3D.cs

@@ -0,0 +1,98 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmath.mod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Simplex noise.
+        /// </summary>
+        /// <param name="v">Input coordinate.</param>
+        /// <returns>Noise value.</returns>
+        public static float snoise(float3 v)
+        {
+            float2 C = float2(1.0f / 6.0f, 1.0f / 3.0f);
+            float4 D = float4(0.0f, 0.5f, 1.0f, 2.0f);
+
+            // First corner
+            float3 i = floor(v + dot(v, C.yyy));
+            float3 x0 = v - i + dot(i, C.xxx);
+
+            // Other corners
+            float3 g = step(x0.yzx, x0.xyz);
+            float3 l = 1.0f - g;
+            float3 i1 = min(g.xyz, l.zxy);
+            float3 i2 = max(g.xyz, l.zxy);
+
+            //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+            //   x1 = x0 - i1  + 1.0 * C.xxx;
+            //   x2 = x0 - i2  + 2.0 * C.xxx;
+            //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+            float3 x1 = x0 - i1 + C.xxx;
+            float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+            float3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
+
+            // Permutations
+            i = mod289(i);
+            float4 p = permute(permute(permute(
+                                         i.z + float4(0.0f, i1.z, i2.z, 1.0f))
+                                     + i.y + float4(0.0f, i1.y, i2.y, 1.0f))
+                             + i.x + float4(0.0f, i1.x, i2.x, 1.0f));
+
+            // Gradients: 7x7 points over a square, mapped onto an octahedron.
+            // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+            float n_ = 0.142857142857f; // 1.0/7.0
+            float3 ns = n_ * D.wyz - D.xzx;
+
+            float4 j = p - 49.0f * floor(p * ns.z * ns.z); //  math.mod(p,7*7)
+
+            float4 x_ = floor(j * ns.z);
+            float4 y_ = floor(j - 7.0f * x_); // math.mod(j,N)
+
+            float4 x = x_ * ns.x + ns.yyyy;
+            float4 y = y_ * ns.x + ns.yyyy;
+            float4 h = 1.0f - abs(x) - abs(y);
+
+            float4 b0 = float4(x.xy, y.xy);
+            float4 b1 = float4(x.zw, y.zw);
+
+            //float4 s0 = float4(math.lessThan(b0,0.0))*2.0 - 1.0;
+            //float4 s1 = float4(math.lessThan(b1,0.0))*2.0 - 1.0;
+            float4 s0 = floor(b0) * 2.0f + 1.0f;
+            float4 s1 = floor(b1) * 2.0f + 1.0f;
+            float4 sh = -step(h, float4(0.0f));
+
+            float4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+            float4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+            float3 p0 = float3(a0.xy, h.x);
+            float3 p1 = float3(a0.zw, h.y);
+            float3 p2 = float3(a1.xy, h.z);
+            float3 p3 = float3(a1.zw, h.w);
+
+            //Normalise gradients
+            float4 norm = taylorInvSqrt(float4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+            p0 *= norm.x;
+            p1 *= norm.y;
+            p2 *= norm.z;
+            p3 *= norm.w;
+
+            // Mix final noise value
+            float4 m = max(0.6f - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0f);
+            m = m * m;
+            return 42.0f * dot(m * m, float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise3D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 466846e8fd30645168912f2824cedb87
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise3Dgrad.cs

@@ -0,0 +1,108 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmath.mod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Simplex noise.
+        /// </summary>
+        /// <param name="v">Input coordinate.</param>
+        /// <param name="gradient">Output 3D noise gradient.</param>
+        /// <returns>Noise value.</returns>
+        public static float snoise(float3 v, out float3 gradient)
+        {
+            float2 C = float2(1.0f / 6.0f, 1.0f / 3.0f);
+            float4 D = float4(0.0f, 0.5f, 1.0f, 2.0f);
+
+            // First corner
+            float3 i = floor(v + dot(v, C.yyy));
+            float3 x0 = v - i + dot(i, C.xxx);
+
+            // Other corners
+            float3 g = step(x0.yzx, x0.xyz);
+            float3 l = 1.0f - g;
+            float3 i1 = min(g.xyz, l.zxy);
+            float3 i2 = max(g.xyz, l.zxy);
+
+            //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+            //   x1 = x0 - i1  + 1.0 * C.xxx;
+            //   x2 = x0 - i2  + 2.0 * C.xxx;
+            //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+            float3 x1 = x0 - i1 + C.xxx;
+            float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+            float3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
+
+            // Permutations
+            i = mod289(i);
+            float4 p = permute(permute(permute(
+                                           i.z + float4(0.0f, i1.z, i2.z, 1.0f))
+                                       + i.y + float4(0.0f, i1.y, i2.y, 1.0f))
+                               + i.x + float4(0.0f, i1.x, i2.x, 1.0f));
+
+            // Gradients: 7x7 points over a square, mapped onto an octahedron.
+            // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+            float n_ = 0.142857142857f; // 1.0/7.0
+            float3 ns = n_ * D.wyz - D.xzx;
+
+            float4 j = p - 49.0f * floor(p * ns.z * ns.z); //  math.mod(p,7*7)
+
+            float4 x_ = floor(j * ns.z);
+            float4 y_ = floor(j - 7.0f * x_); // math.mod(j,N)
+
+            float4 x = x_ * ns.x + ns.yyyy;
+            float4 y = y_ * ns.x + ns.yyyy;
+            float4 h = 1.0f - abs(x) - abs(y);
+
+            float4 b0 = float4(x.xy, y.xy);
+            float4 b1 = float4(x.zw, y.zw);
+
+            //float4 s0 = float4(math.lessThan(b0,0.0))*2.0 - 1.0;
+            //float4 s1 = float4(math.lessThan(b1,0.0))*2.0 - 1.0;
+            float4 s0 = floor(b0) * 2.0f + 1.0f;
+            float4 s1 = floor(b1) * 2.0f + 1.0f;
+            float4 sh = -step(h, float4(0.0f));
+
+            float4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+            float4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+
+            float3 p0 = float3(a0.xy, h.x);
+            float3 p1 = float3(a0.zw, h.y);
+            float3 p2 = float3(a1.xy, h.z);
+            float3 p3 = float3(a1.zw, h.w);
+
+            //Normalise gradients
+            float4 norm = taylorInvSqrt(float4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+            p0 *= norm.x;
+            p1 *= norm.y;
+            p2 *= norm.z;
+            p3 *= norm.w;
+
+            // Mix final noise value
+            float4 m = max(0.6f - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0f);
+            float4 m2 = m * m;
+            float4 m4 = m2 * m2;
+            float4 pdotx = float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3));
+
+            // Determath.mine noise gradient
+            float4 temp = m2 * m * pdotx;
+            gradient = -8.0f * (temp.x * x0 + temp.y * x1 + temp.z * x2 + temp.w * x3);
+            gradient += m4.x * p0 + m4.y * p1 + m4.z * p2 + m4.w * p3;
+            gradient *= 42.0f;
+
+            return 42.0f * dot(m4, pdotx);
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise3Dgrad.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6849bb8369e5b4b2eb95e435578ff960
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise4D.cs

@@ -0,0 +1,104 @@
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+//               noise functions.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : stegu
+//     Lastmath.mod : 20110822 (ijm)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//               https://github.com/ashima/webgl-noise
+//               https://github.com/stegu/webgl-noise
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// Simplex noise.
+        /// </summary>
+        /// <param name="v">Input coordinate.</param>
+        /// <returns>Noise value.</returns>
+        public static float snoise(float4 v)
+        {
+            // (math.sqrt(5) - 1)/4 = F4, used once below
+            const float F4 = 0.309016994374947451f;
+            float4 C = float4( 0.138196601125011f,  // (5 - math.sqrt(5))/20  G4
+                0.276393202250021f,  // 2 * G4
+                0.414589803375032f,  // 3 * G4
+                -0.447213595499958f); // -1 + 4 * G4
+
+            // First corner
+            float4 i  = floor(v + dot(v, float4(F4)) );
+            float4 x0 = v -   i + dot(i, C.xxxx);
+
+            // Other corners
+
+            // Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+            float4 i0 = float4(0.0f);
+            float3 isX = step( x0.yzw, x0.xxx );
+            float3 isYZ = step( x0.zww, x0.yyz );
+            //  i0.x = math.dot( isX, float3( 1.0 ) );
+            i0.x = isX.x + isX.y + isX.z;
+            i0.yzw = 1.0f - isX;
+            //  i0.y += math.dot( isYZ.xy, float2( 1.0 ) );
+            i0.y += isYZ.x + isYZ.y;
+            i0.zw += 1.0f - isYZ.xy;
+            i0.z += isYZ.z;
+            i0.w += 1.0f - isYZ.z;
+
+            // i0 now contains the unique values 0,1,2,3 in each channel
+            float4 i3 = clamp( i0, 0.0f, 1.0f );
+            float4 i2 = clamp( i0-1.0f, 0.0f, 1.0f );
+            float4 i1 = clamp( i0-2.0f, 0.0f, 1.0f );
+
+            //  x0 = x0 - 0.0 + 0.0 * C.xxxx
+            //  x1 = x0 - i1  + 1.0 * C.xxxx
+            //  x2 = x0 - i2  + 2.0 * C.xxxx
+            //  x3 = x0 - i3  + 3.0 * C.xxxx
+            //  x4 = x0 - 1.0 + 4.0 * C.xxxx
+            float4 x1 = x0 - i1 + C.xxxx;
+            float4 x2 = x0 - i2 + C.yyyy;
+            float4 x3 = x0 - i3 + C.zzzz;
+            float4 x4 = x0 + C.wwww;
+
+            // Permutations
+            i = mod289(i);
+            float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
+            float4 j1 = permute( permute( permute( permute (
+                                                       i.w + float4(i1.w, i2.w, i3.w, 1.0f ))
+                                                   + i.z + float4(i1.z, i2.z, i3.z, 1.0f ))
+                                          + i.y + float4(i1.y, i2.y, i3.y, 1.0f ))
+                                 + i.x + float4(i1.x, i2.x, i3.x, 1.0f ));
+
+            // Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+            // 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+            float4 ip = float4(1.0f/294.0f, 1.0f/49.0f, 1.0f/7.0f, 0.0f) ;
+
+            float4 p0 = grad4(j0,   ip);
+            float4 p1 = grad4(j1.x, ip);
+            float4 p2 = grad4(j1.y, ip);
+            float4 p3 = grad4(j1.z, ip);
+            float4 p4 = grad4(j1.w, ip);
+
+            // Normalise gradients
+            float4 norm = taylorInvSqrt(float4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+            p0 *= norm.x;
+            p1 *= norm.y;
+            p2 *= norm.z;
+            p3 *= norm.w;
+            p4 *= taylorInvSqrt(dot(p4,p4));
+
+            // Mix contributions from the five corners
+            float3 m0 = max(0.6f - float3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0f);
+            float2 m1 = max(0.6f - float2(dot(x3,x3), dot(x4,x4)            ), 0.0f);
+            m0 = m0 * m0;
+            m1 = m1 * m1;
+            return 49.0f * ( dot(m0*m0, float3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
+                            + dot(m1*m1, float2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
+
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/noise4D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0d0317cc486b452580ad028220b03bf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/psrdnoise2D.cs

@@ -0,0 +1,442 @@
+//
+// float3  psrdnoise(float2 pos, float2 per, float rot)
+// float3  psrdnoise(float2 pos, float2 per)
+// float psrnoise(float2 pos, float2 per, float rot)
+// float psrnoise(float2 pos, float2 per)
+// float3  srdnoise(float2 pos, float rot)
+// float3  srdnoise(float2 pos)
+// float srnoise(float2 pos, float rot)
+// float srnoise(float2 pos)
+//
+// Periodic (tiling) 2-D simplex noise (hexagonal lattice gradient noise)
+// with rotating gradients and analytic derivatives.
+// Variants also without the derivative (no "d" in the name), without
+// the tiling property (no "p" in the name) and without the rotating
+// gradients (no "r" in the name).
+//
+// This is (yet) another variation on simplex noise. It's similar to the
+// version presented by Ken Perlin, but the grid is axis-aligned and
+// slightly stretched in the y direction to permit rectangular tiling.
+//
+// The noise can be made to tile seamlessly to any integer period in x and
+// any even integer period in y. Odd periods may be specified for y, but
+// then the actual tiling period will be twice that number.
+//
+// The rotating gradients give the appearance of a swirling motion, and can
+// serve a similar purpose for animation as motion along z in 3-D noise.
+// The rotating gradients in conjunction with the analytic derivatives
+// can make "flow noise" effects as presented by Perlin and Neyret.
+//
+// float3 {p}s{r}dnoise(float2 pos {, float2 per} {, float rot})
+// "pos" is the input (x,y) coordinate
+// "per" is the x and y period, where per.x is a positive integer
+//    and per.y is a positive even integer
+// "rot" is the angle to rotate the gradients (any float value,
+//    where 0.0 is no rotation and 1.0 is one full turn)
+// The first component of the 3-element return vector is the noise value.
+// The second and third components are the x and y partial derivatives.
+//
+// float {p}s{r}noise(float2 pos {, float2 per} {, float rot})
+// "pos" is the input (x,y) coordinate
+// "per" is the x and y period, where per.x is a positive integer
+//    and per.y is a positive even integer
+// "rot" is the angle to rotate the gradients (any float value,
+//    where 0.0 is no rotation and 1.0 is one full turn)
+// The return value is the noise value.
+// Partial derivatives are not computed, making these functions faster.
+//
+// Author: Stefan Gustavson (stefan.gustavson@gmail.com)
+// Version 2016-05-10.
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// idea of umath.sing a permutation polynomial.
+//
+// Copyright (c) 2016 Stefan Gustavson. All rights reserved.
+// Distributed under the MIT license. See LICENSE file.
+// https://github.com/stegu/webgl-noise
+//
+
+//
+// TODO: One-pixel wide artefacts used to occur due to precision issues with
+// the gradient indexing. This is specific to this variant of noise, because
+// one axis of the simplex grid is perfectly aligned with the input x axis.
+// The errors were rare, and they are now very unlikely to ever be visible
+// after a quick fix was introduced: a small offset is added to the y coordinate.
+// A proper fix would involve umath.sing round() instead of math.floor() in selected
+// places, but the quick fix works fine.
+// (If you run into problems with this, please let me know.)
+//
+
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    public static partial class noise
+    {
+        /// <summary>
+        /// 2-D tiling simplex noise with rotating gradients and analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="per">The x and y period, where per.x is a positive integer and per.y is a positive even integer.</param>
+        /// <param name="rot">Angle to rotate the gradients.</param>
+        /// <returns>The first component of the 3-element return vector is the noise value, and the second and third components are the x and y partial derivatives.</returns>
+        public static float3 psrdnoise(float2 pos, float2 per, float rot)
+        {
+            // Hack: offset y slightly to hide some rare artifacts
+            pos.y += 0.01f;
+            // Skew to hexagonal grid
+            float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
+
+            float2 i0 = floor(uv);
+            float2 f0 = frac(uv);
+            // Traversal order
+            float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
+
+            // Unskewed grid points in (x,y) space
+            float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
+            float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
+            float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
+
+            // Vectors in unskewed (x,y) coordinates from
+            // each of the simplex corners to the evaluation point
+            float2 d0 = pos - p0;
+            float2 d1 = pos - p1;
+            float2 d2 = pos - p2;
+
+            // Wrap p0, p1 and p2 to the desired period before gradient hashing:
+            // wrap points in (x,y), map to (u,v)
+            float3 xw = fmod(float3(p0.x, p1.x, p2.x), per.x);
+            float3 yw = fmod(float3(p0.y, p1.y, p2.y), per.y);
+            float3 iuw = xw + 0.5f * yw;
+            float3 ivw = yw;
+
+            // Create gradients from indices
+            float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
+            float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
+            float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
+
+            // Gradients math.dot vectors to corresponding corners
+            // (The derivatives of this are simply the gradients)
+            float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
+
+            // Radial weights from corners
+            // 0.8 is the square of 2/math.sqrt(5), the distance from
+            // a grid point to the nearest simplex boundary
+            float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
+
+            // Partial derivatives for analytical gradient computation
+            float3 dtdx = -2.0f * float3(d0.x, d1.x, d2.x);
+            float3 dtdy = -2.0f * float3(d0.y, d1.y, d2.y);
+
+            // Set influence of each surflet to zero outside radius math.sqrt(0.8)
+            if (t.x < 0.0f)
+            {
+                dtdx.x = 0.0f;
+                dtdy.x = 0.0f;
+                t.x = 0.0f;
+            }
+            if (t.y < 0.0f)
+            {
+                dtdx.y = 0.0f;
+                dtdy.y = 0.0f;
+                t.y = 0.0f;
+            }
+            if (t.z < 0.0f)
+            {
+                dtdx.z = 0.0f;
+                dtdy.z = 0.0f;
+                t.z = 0.0f;
+            }
+
+            // Fourth power of t (and third power for derivative)
+            float3 t2 = t * t;
+            float3 t4 = t2 * t2;
+            float3 t3 = t2 * t;
+
+            // Final noise value is:
+            // sum of ((radial weights) times (gradient math.dot vector from corner))
+            float n = dot(t4, w);
+
+            // Final analytical derivative (gradient of a sum of scalar products)
+            float2 dt0 = float2(dtdx.x, dtdy.x) * 4.0f * t3.x;
+            float2 dn0 = t4.x * g0 + dt0 * w.x;
+            float2 dt1 = float2(dtdx.y, dtdy.y) * 4.0f * t3.y;
+            float2 dn1 = t4.y * g1 + dt1 * w.y;
+            float2 dt2 = float2(dtdx.z, dtdy.z) * 4.0f * t3.z;
+            float2 dn2 = t4.z * g2 + dt2 * w.z;
+
+            return 11.0f * float3(n, dn0 + dn1 + dn2);
+        }
+
+        /// <summary>
+        /// 2-D tiling simplex noise with fixed gradients and analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="per">The x and y period, where per.x is a positive integer and per.y is a positive even integer.</param>
+        /// <returns>The first component of the 3-element return vector is the noise value, and the second and third components are the x and y partial derivatives.</returns>
+        public static float3 psrdnoise(float2 pos, float2 per)
+        {
+            return psrdnoise(pos, per, 0.0f);
+        }
+
+        /// <summary>
+        /// 2-D tiling simplex noise with rotating gradients, but without the analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="per">The x and y period, where per.x is a positive integer and per.y is a positive even integer.</param>
+        /// <param name="rot">Angle to rotate the gradients.</param>
+        /// <returns>Noise value.</returns>
+        public static float psrnoise(float2 pos, float2 per, float rot)
+        {
+            // Offset y slightly to hide some rare artifacts
+            pos.y += 0.001f;
+            // Skew to hexagonal grid
+            float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
+
+            float2 i0 = floor(uv);
+            float2 f0 = frac(uv);
+            // Traversal order
+            float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
+
+            // Unskewed grid points in (x,y) space
+            float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
+            float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
+            float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
+
+            // Vectors in unskewed (x,y) coordinates from
+            // each of the simplex corners to the evaluation point
+            float2 d0 = pos - p0;
+            float2 d1 = pos - p1;
+            float2 d2 = pos - p2;
+
+            // Wrap p0, p1 and p2 to the desired period before gradient hashing:
+            // wrap points in (x,y), map to (u,v)
+            float3 xw = fmod(float3(p0.x, p1.x, p2.x), per.x);
+            float3 yw = fmod(float3(p0.y, p1.y, p2.y), per.y);
+            float3 iuw = xw + 0.5f * yw;
+            float3 ivw = yw;
+
+            // Create gradients from indices
+            float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
+            float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
+            float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
+
+            // Gradients math.dot vectors to corresponding corners
+            // (The derivatives of this are simply the gradients)
+            float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
+
+            // Radial weights from corners
+            // 0.8 is the square of 2/math.sqrt(5), the distance from
+            // a grid point to the nearest simplex boundary
+            float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
+
+            // Set influence of each surflet to zero outside radius math.sqrt(0.8)
+            t = max(t, 0.0f);
+
+            // Fourth power of t
+            float3 t2 = t * t;
+            float3 t4 = t2 * t2;
+
+            // Final noise value is:
+            // sum of ((radial weights) times (gradient math.dot vector from corner))
+            float n = dot(t4, w);
+
+            // Rescale to cover the range [-1,1] reasonably well
+            return 11.0f * n;
+        }
+
+        /// <summary>
+        /// 2-D tiling simplex noise with fixed gradients, without the analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="per">The x and y period, where per.x is a positive integer and per.y is a positive even integer.</param>
+        /// <returns>Noise value.</returns>
+        public static float psrnoise(float2 pos, float2 per)
+        {
+            return psrnoise(pos, per, 0.0f);
+        }
+
+        /// <summary>
+        /// 2-D non-tiling simplex noise with rotating gradients and analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="rot">Angle to rotate the gradients.</param>
+        /// <returns>The first component of the 3-element return vector is the noise value, and the second and third components are the x and y partial derivatives.</returns>
+        public static float3 srdnoise(float2 pos, float rot)
+        {
+            // Offset y slightly to hide some rare artifacts
+            pos.y += 0.001f;
+            // Skew to hexagonal grid
+            float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
+
+            float2 i0 = floor(uv);
+            float2 f0 = frac(uv);
+            // Traversal order
+            float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
+
+            // Unskewed grid points in (x,y) space
+            float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
+            float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
+            float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
+
+            // Vectors in unskewed (x,y) coordinates from
+            // each of the simplex corners to the evaluation point
+            float2 d0 = pos - p0;
+            float2 d1 = pos - p1;
+            float2 d2 = pos - p2;
+
+            float3 x = float3(p0.x, p1.x, p2.x);
+            float3 y = float3(p0.y, p1.y, p2.y);
+            float3 iuw = x + 0.5f * y;
+            float3 ivw = y;
+
+            // Avoid precision issues in permutation
+            iuw = mod289(iuw);
+            ivw = mod289(ivw);
+
+            // Create gradients from indices
+            float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
+            float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
+            float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
+
+            // Gradients math.dot vectors to corresponding corners
+            // (The derivatives of this are simply the gradients)
+            float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
+
+            // Radial weights from corners
+            // 0.8 is the square of 2/math.sqrt(5), the distance from
+            // a grid point to the nearest simplex boundary
+            float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
+
+            // Partial derivatives for analytical gradient computation
+            float3 dtdx = -2.0f * float3(d0.x, d1.x, d2.x);
+            float3 dtdy = -2.0f * float3(d0.y, d1.y, d2.y);
+
+            // Set influence of each surflet to zero outside radius math.sqrt(0.8)
+            if (t.x < 0.0f)
+            {
+                dtdx.x = 0.0f;
+                dtdy.x = 0.0f;
+                t.x = 0.0f;
+            }
+            if (t.y < 0.0f)
+            {
+                dtdx.y = 0.0f;
+                dtdy.y = 0.0f;
+                t.y = 0.0f;
+            }
+            if (t.z < 0.0f)
+            {
+                dtdx.z = 0.0f;
+                dtdy.z = 0.0f;
+                t.z = 0.0f;
+            }
+
+            // Fourth power of t (and third power for derivative)
+            float3 t2 = t * t;
+            float3 t4 = t2 * t2;
+            float3 t3 = t2 * t;
+
+            // Final noise value is:
+            // sum of ((radial weights) times (gradient math.dot vector from corner))
+            float n = dot(t4, w);
+
+            // Final analytical derivative (gradient of a sum of scalar products)
+            float2 dt0 = float2(dtdx.x, dtdy.x) * 4.0f * t3.x;
+            float2 dn0 = t4.x * g0 + dt0 * w.x;
+            float2 dt1 = float2(dtdx.y, dtdy.y) * 4.0f * t3.y;
+            float2 dn1 = t4.y * g1 + dt1 * w.y;
+            float2 dt2 = float2(dtdx.z, dtdy.z) * 4.0f * t3.z;
+            float2 dn2 = t4.z * g2 + dt2 * w.z;
+
+            return 11.0f * float3(n, dn0 + dn1 + dn2);
+        }
+
+        /// <summary>
+        /// 2-D non-tiling simplex noise with fixed gradients and analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <returns>The first component of the 3-element return vector is the noise value, and the second and third components are the x and y partial derivatives.</returns>
+        public static float3 srdnoise(float2 pos)
+        {
+            return srdnoise(pos, 0.0f);
+        }
+
+        /// <summary>
+        /// 2-D non-tiling simplex noise with rotating gradients, without the analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <param name="rot">Angle to rotate the gradients.</param>
+        /// <returns>Noise value.</returns>
+        public static float srnoise(float2 pos, float rot)
+        {
+            // Offset y slightly to hide some rare artifacts
+            pos.y += 0.001f;
+            // Skew to hexagonal grid
+            float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
+
+            float2 i0 = floor(uv);
+            float2 f0 = frac(uv);
+            // Traversal order
+            float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
+
+            // Unskewed grid points in (x,y) space
+            float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
+            float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
+            float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
+
+            // Vectors in unskewed (x,y) coordinates from
+            // each of the simplex corners to the evaluation point
+            float2 d0 = pos - p0;
+            float2 d1 = pos - p1;
+            float2 d2 = pos - p2;
+
+            float3 x = float3(p0.x, p1.x, p2.x);
+            float3 y = float3(p0.y, p1.y, p2.y);
+            float3 iuw = x + 0.5f * y;
+            float3 ivw = y;
+
+            // Avoid precision issues in permutation
+            iuw = mod289(iuw);
+            ivw = mod289(ivw);
+
+            // Create gradients from indices
+            float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
+            float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
+            float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
+
+            // Gradients math.dot vectors to corresponding corners
+            // (The derivatives of this are simply the gradients)
+            float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
+
+            // Radial weights from corners
+            // 0.8 is the square of 2/math.sqrt(5), the distance from
+            // a grid point to the nearest simplex boundary
+            float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
+
+            // Set influence of each surflet to zero outside radius math.sqrt(0.8)
+            t = max(t, 0.0f);
+
+            // Fourth power of t
+            float3 t2 = t * t;
+            float3 t4 = t2 * t2;
+
+            // Final noise value is:
+            // sum of ((radial weights) times (gradient math.dot vector from corner))
+            float n = dot(t4, w);
+
+            // Rescale to cover the range [-1,1] reasonably well
+            return 11.0f * n;
+        }
+
+        /// <summary>
+        /// 2-D non-tiling simplex noise with fixed gradients, without the analytical derivative.
+        /// </summary>
+        /// <param name="pos">Input (x,y) coordinate.</param>
+        /// <returns>Noise value.</returns>
+        public static float srnoise(float2 pos)
+        {
+            return srnoise(pos, 0.0f);
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Noise/psrdnoise2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8bf609f94feab4ac5af33f75a100630c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Properties.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d3e017d9ad3f00a4c9e234b0236911b7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Properties/AssemblyInfo.cs

@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
+[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Properties/AssemblyInfo.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fb0d7ffc71c40bd49a849e6427f80cb5

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/PropertyAttributes.cs

@@ -0,0 +1,12 @@
+namespace Unity.Mathematics
+{
+    /// <summary>
+    /// Used by property drawers when vectors should be post normalized.
+    /// </summary>
+    public class PostNormalizeAttribute : UnityEngine.PropertyAttribute {}
+
+    /// <summary>
+    /// Used by property drawers when vectors should not be normalized.
+    /// </summary>
+    public class DoNotNormalizeAttribute : UnityEngine.PropertyAttribute {}
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/PropertyAttributes.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 61cbbdd02bb00406b94029228cb3b73b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Unity.Mathematics.asmdef

@@ -0,0 +1,4 @@
+{
+	"name": "Unity.Mathematics",
+	"allowUnsafeCode": true
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/Unity.Mathematics.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d8b63aba1907145bea998dd612889d6b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/affine_transform.cs

@@ -0,0 +1,322 @@
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    /// <summary>
+    /// An affine transformation type.
+    /// </summary>
+    [Il2CppEagerStaticClassConstruction]
+    [Serializable]
+    public struct AffineTransform : IEquatable<AffineTransform>, IFormattable
+    {
+        /// <summary>
+        /// The rotation and scale part of the affine transformation.
+        /// </summary>
+        public float3x3 rs;
+
+        /// <summary>
+        /// The translation part of the affine transformation.
+        /// </summary>
+        public float3 t;
+
+        /// <summary>An AffineTransform representing the identity transform.</summary>
+        public static readonly AffineTransform identity = new AffineTransform(float3.zero, float3x3.identity);
+
+        /// <summary>
+        /// An AffineTransform zero value.
+        /// </summary>
+        public static readonly AffineTransform zero;
+
+        /// <summary>Constructs an AffineTransform from a translation represented by a float3 vector and rotation represented by a unit quaternion.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 translation, quaternion rotation)
+        {
+            rs = float3x3(rotation);
+            t = translation;
+        }
+
+        /// <summary>Constructs an AffineTransform from a translation represented by a float3 vector, rotation represented by a unit quaternion and scale represented by a float3 vector.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
+        /// <param name="scale">The scale vector.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 translation, quaternion rotation, float3 scale)
+        {
+            rs = mulScale(math.float3x3(rotation), scale);
+            t = translation;
+        }
+
+        /// <summary>Constructs an AffineTransform from a translation represented by float3 vector and a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 translation, float3x3 rotationScale)
+        {
+            rs = rotationScale;
+            t = translation;
+        }
+
+        /// <summary>Constructs an AffineTransform from float3x3 matrix representating both rotation and scale.</summary>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3x3 rotationScale)
+        {
+            rs = rotationScale;
+            t = float3.zero;
+        }
+
+        /// <summary>Constructs an AffineTransform from a RigidTransform.</summary>
+        /// <param name="rigid">The RigidTransform.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(RigidTransform rigid)
+        {
+            rs = math.float3x3(rigid.rot);
+            t = rigid.pos;
+        }
+
+        /// <summary>Constructs an AffineTransform from a float3x4 matrix.</summary>
+        /// <param name="m">The float3x4 matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3x4 m)
+        {
+            rs = math.float3x3(m.c0, m.c1, m.c2);
+            t = m.c3;
+        }
+
+        /// <summary>Constructs an AffineTransform from a float4x4 matrix.</summary>
+        /// <param name="m">The float4x4 matrix.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float4x4 m)
+        {
+            rs = math.float3x3(m.c0.xyz, m.c1.xyz, m.c2.xyz);
+            t = m.c3.xyz;
+        }
+
+        /// <summary>Implicit float3x4 cast operator.</summary>
+        /// <param name="m">The AffineTransform.</param>
+        /// <returns>The converted AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float3x4(AffineTransform m) { return float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
+
+        /// <summary>Implicit float4x4 cast operator.</summary>
+        /// <param name="m">The AffineTransform.</param>
+        /// <returns>The converted AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float4x4(AffineTransform m) { return float4x4(float4(m.rs.c0, 0f), float4(m.rs.c1, 0f), float4(m.rs.c2, 0f), float4(m.t, 1f)); }
+
+        /// <summary>Returns true if the AffineTransform is equal to a given AffineTransform, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(AffineTransform rhs) { return rs.Equals(rhs.rs) && t.Equals(rhs.t); }
+
+        /// <summary>Returns true if the AffineTransform is equal to a given AffineTransform, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is AffineTransform converted && Equals(converted); }
+
+        /// <summary>Returns a hash code for the AffineTransform.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)hash(this); }
+
+        /// <summary>Returns a string representation of the AffineTransform.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("AffineTransform(({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f,  {6}f, {7}f, {8}f), ({9}f, {10}f, {11}f))",
+                rs.c0.x, rs.c1.x, rs.c2.x, rs.c0.y, rs.c1.y, rs.c2.y, rs.c0.z, rs.c1.z, rs.c2.z, t.x, t.y, t.z
+            );
+        }
+
+        /// <summary>Returns a string representation of the AffineTransform using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("AffineTransform(({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f,  {6}f, {7}f, {8}f), ({9}f, {10}f, {11}f))",
+                rs.c0.x.ToString(format, formatProvider), rs.c1.x.ToString(format, formatProvider), rs.c2.x.ToString(format, formatProvider),
+                rs.c0.y.ToString(format, formatProvider), rs.c1.y.ToString(format, formatProvider), rs.c2.y.ToString(format, formatProvider),
+                rs.c0.z.ToString(format, formatProvider), rs.c1.z.ToString(format, formatProvider), rs.c2.z.ToString(format, formatProvider),
+                t.x.ToString(format, formatProvider), t.y.ToString(format, formatProvider), t.z.ToString(format, formatProvider)
+            );
+        }
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns an AffineTransform constructed from a translation represented by a float3 vector and rotation represented by a unit quaternion.</summary>
+        /// <param name="translation">The AffineTransform translation.</param>
+        /// <param name="rotation">The AffineTransform rotation.</param>
+        /// <returns>The AffineTransform given the translation vector and rotation quaternion.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return new AffineTransform(translation, rotation); }
+
+        /// <summary>Returns an AffineTransform constructed from a translation represented by a float3 vector, rotation represented by a unit quaternion and scale represented by a float3 vector.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
+        /// <param name="scale">The scale vector.</param>
+        /// <returns>The AffineTransform given the translation vector, rotation quaternion and scale vector.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
+
+        /// <summary>Returns an AffineTransform constructed from a translation represented by float3 vector and a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        /// <returns>The AffineTransform given the translation vector and float3x3 matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rotationScale) { return new AffineTransform(translation, rotationScale); }
+
+        /// <summary>Returns an AffineTransform constructed from a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        /// <returns>The AffineTransform given a float3x3 matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3x3 rotationScale) { return new AffineTransform(rotationScale); }
+
+        /// <summary>Returns an AffineTransform constructed from a float4x4 matrix.</summary>
+        /// <param name="m">The float4x4 matrix.</param>
+        /// <returns>The AffineTransform given a float4x4 matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
+
+        /// <summary>Returns an AffineTransform constructed from a float3x4 matrix.</summary>
+        /// <param name="m">The float3x4 matrix.</param>
+        /// <returns>The AffineTransform given a float3x4 matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
+
+        /// <summary>Returns an AffineTransform constructed from a RigidTransform.</summary>
+        /// <param name="rigid">The RigidTransform.</param>
+        /// <returns>The AffineTransform given a RigidTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(RigidTransform rigid) { return new AffineTransform (rigid); }
+
+        /// <summary>Returns a float4x4 matrix constructed from an AffineTransform.</summary>
+        /// <param name="transform">The AffineTransform.</param>
+        /// <returns>The float4x4 matrix given an AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }
+
+        /// <summary>Returns a float3x4 matrix constructed from an AffineTransform.</summary>
+        /// <param name="transform">The AffineTransform.</param>
+        /// <returns>The float3x4 matrix given an AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x4 float3x4(AffineTransform transform) { return float3x4(transform.rs.c0, transform.rs.c1, transform.rs.c2, transform.t); }
+
+        /// <summary>Returns the result of transforming the AffineTransform b by the AffineTransform a.</summary>
+        /// <param name="a">The AffineTransform on the left.</param>
+        /// <param name="b">The AffineTransform on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(AffineTransform a, AffineTransform b)
+        {
+            return new AffineTransform(transform(a, b.t), mul(a.rs, b.rs));
+        }
+
+        /// <summary>Returns the result of transforming the AffineTransform b by a float3x3 matrix a.</summary>
+        /// <param name="a">The float3x3 matrix on the left.</param>
+        /// <param name="b">The AffineTransform on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(float3x3 a, AffineTransform b)
+        {
+            return new AffineTransform(mul(a, b.t), mul(a, b.rs));
+        }
+
+        /// <summary>Returns the result of transforming the float3x3 b by an AffineTransform a.</summary>
+        /// <param name="a">The AffineTransform on the left.</param>
+        /// <param name="b">The float3x3 matrix on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(AffineTransform a, float3x3 b)
+        {
+            return new AffineTransform(a.t, mul(b, a.rs));
+        }
+
+        /// <summary>Returns the result of transforming a float4 homogeneous coordinate by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="pos">The position to be transformed.</param>
+        /// <returns>The transformed position.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4 mul(AffineTransform a, float4 pos)
+        {
+            return float4(mul(a.rs, pos.xyz) + a.t * pos.w, pos.w);
+        }
+
+        /// <summary>Returns the result of rotating a float3 vector by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="dir">The direction vector to rotate.</param>
+        /// <returns>The rotated direction vector.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 rotate(AffineTransform a, float3 dir)
+        {
+            return mul(a.rs, dir);
+        }
+
+        /// <summary>Returns the result of transforming a float3 point by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="pos">The position to transform.</param>
+        /// <returns>The transformed position.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 transform(AffineTransform a, float3 pos)
+        {
+            return a.t + mul(a.rs, pos);
+        }
+
+        /// <summary>Returns the inverse of an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform to invert.</param>
+        /// <returns>The inverse AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform inverse(AffineTransform a)
+        {
+            AffineTransform inv;
+            inv.rs = pseudoinverse(a.rs);
+            inv.t = mul(inv.rs, -a.t);
+            return inv;
+        }
+
+        /// <summary>Decomposes the AffineTransform in translation, rotation and scale.</summary>
+        /// <param name="a">The AffineTransform</param>
+        /// <param name="translation">The decomposed translation vector of the AffineTransform.</param>
+        /// <param name="rotation">The decomposed rotation quaternion of the AffineTransform.</param>
+        /// <param name="scale">The decomposed scale of the AffineTransform.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void decompose(AffineTransform a, out float3 translation, out quaternion rotation, out float3 scale)
+        {
+            translation = a.t;
+            rotation = math.rotation(a.rs);
+            var sm = mul(float3x3(conjugate(rotation)), a.rs);
+            scale = float3(sm.c0.x, sm.c1.y, sm.c2.z);
+        }
+
+        /// <summary>Returns a uint hash code of an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform to hash.</param>
+        /// <returns>The hash code of the input AffineTransform.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(AffineTransform a)
+        {
+            return hash(a.rs) + 0xC5C5394Bu * hash(a.t);
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of an AffineTransform.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="a">The AffineTransform to hash.</param>
+        /// <returns>The uint4 wide hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(AffineTransform a)
+        {
+            return hashwide(a.rs).xyzz + 0xC5C5394Bu * hashwide(a.t).xyzz;
+        }
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/affine_transform.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25c2cff1b9e35e648980b04c895d7332
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2.gen.cs

@@ -0,0 +1,626 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2 component vector of bools.</summary>
+    [DebuggerTypeProxy(typeof(bool2.DebuggerProxy))]
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool2 : System.IEquatable<bool2>
+    {
+        /// <summary>x component of the vector.</summary>
+        [MarshalAs(UnmanagedType.U1)]
+        public bool x;
+        /// <summary>y component of the vector.</summary>
+        [MarshalAs(UnmanagedType.U1)]
+        public bool y;
+
+
+        /// <summary>Constructs a bool2 vector from two bool values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2(bool x, bool y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        /// <summary>Constructs a bool2 vector from a bool2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2(bool2 xy)
+        {
+            this.x = xy.x;
+            this.y = xy.y;
+        }
+
+        /// <summary>Constructs a bool2 vector from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2(bool v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool2 vector by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool2(bool v) { return new bool2(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool2 vectors.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool2 vector and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (bool2 lhs, bool rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2 vector.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (bool lhs, bool2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool2 vectors.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool2 vector and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (bool2 lhs, bool rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2 vector.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (bool lhs, bool2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool2 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator ! (bool2 val) { return new bool2 (!val.x, !val.y); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool2 vectors.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator & (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x & rhs.x, lhs.y & rhs.y); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool2 vector and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator & (bool2 lhs, bool rhs) { return new bool2 (lhs.x & rhs, lhs.y & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2 vector.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator & (bool lhs, bool2 rhs) { return new bool2 (lhs & rhs.x, lhs & rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool2 vectors.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator | (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x | rhs.x, lhs.y | rhs.y); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool2 vector and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator | (bool2 lhs, bool rhs) { return new bool2 (lhs.x | rhs, lhs.y | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2 vector.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator | (bool lhs, bool2 rhs) { return new bool2 (lhs | rhs.x, lhs | rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2 vectors.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator ^ (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x ^ rhs.x, lhs.y ^ rhs.y); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2 vector and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator ^ (bool2 lhs, bool rhs) { return new bool2 (lhs.x ^ rhs, lhs.y ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2 vector.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator ^ (bool lhs, bool2 rhs) { return new bool2 (lhs ^ rhs.x, lhs ^ rhs.y); }
+
+
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 xyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(x, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool4 yyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool4(y, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 xxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 xxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 xyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 xyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 yxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 yxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 yyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool3 yyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool3(y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool2 xx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool2(x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool2 xy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool2(x, y); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { x = value.x; y = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool2 yx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool2(y, x); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { y = value.x; x = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public bool2 yy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new bool2(y, y); }
+        }
+
+
+
+        /// <summary>Returns the bool element at a specified index.</summary>
+        unsafe public bool this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (bool2* array = &this) { return ((bool*)array)[index]; }
+            }
+            set
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (bool* array = &x) { array[index] = value; }
+            }
+        }
+
+        /// <summary>Returns true if the bool2 is equal to a given bool2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool2 rhs) { return x == rhs.x && y == rhs.y; }
+
+        /// <summary>Returns true if the bool2 is equal to a given bool2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool2({0}, {1})", x, y);
+        }
+
+        internal sealed class DebuggerProxy
+        {
+            public bool x;
+            public bool y;
+            public DebuggerProxy(bool2 v)
+            {
+                x = v.x;
+                y = v.y;
+            }
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool2 vector constructed from two bool values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        /// <returns>bool2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 bool2(bool x, bool y) { return new bool2(x, y); }
+
+        /// <summary>Returns a bool2 vector constructed from a bool2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        /// <returns>bool2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 bool2(bool2 xy) { return new bool2(xy); }
+
+        /// <summary>Returns a bool2 vector constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 bool2(bool v) { return new bool2(v); }
+
+        /// <summary>Returns a uint hash code of a bool2 vector.</summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool2 v)
+        {
+            return csum(select(uint2(0x90A285BBu, 0x5D19E1D5u), uint2(0xFAAF07DDu, 0x625C45BDu), v));
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a bool2 vector.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(bool2 v)
+        {
+            return (select(uint2(0xC9F27FCBu, 0x6D2523B1u), uint2(0x6E2BF6A9u, 0xCC74B3B7u), v));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool value.</summary>
+        /// <param name="left">bool2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">bool2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting bool.</param>
+        /// <returns>bool result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool shuffle(bool2 left, bool2 right, ShuffleComponent x)
+        {
+            return select_shuffle_component(left, right, x);
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool2 vector.</summary>
+        /// <param name="left">bool2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">bool2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting bool2 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting bool2 y component.</param>
+        /// <returns>bool2 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y)
+        {
+            return bool2(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool3 vector.</summary>
+        /// <param name="left">bool2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">bool2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting bool3 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting bool3 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting bool3 z component.</param>
+        /// <returns>bool3 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
+        {
+            return bool3(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool4 vector.</summary>
+        /// <param name="left">bool2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">bool2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting bool4 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting bool4 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting bool4 z component.</param>
+        /// <param name="w">The ShuffleComponent to use when setting the resulting bool4 w component.</param>
+        /// <returns>bool4 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4 shuffle(bool2 left, bool2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
+        {
+            return bool4(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z),
+                select_shuffle_component(left, right, w));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static bool select_shuffle_component(bool2 a, bool2 b, ShuffleComponent component)
+        {
+            switch(component)
+            {
+                case ShuffleComponent.LeftX:
+                    return a.x;
+                case ShuffleComponent.LeftY:
+                    return a.y;
+                case ShuffleComponent.RightX:
+                    return b.x;
+                case ShuffleComponent.RightY:
+                    return b.y;
+                default:
+                    throw new System.ArgumentException("Invalid shuffle component: " + component);
+            }
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0790199222baf67419fdf802d76f93f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x2.gen.cs

@@ -0,0 +1,292 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x2 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool2x2 : System.IEquatable<bool2x2>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool2 c1;
+
+
+        /// <summary>Constructs a bool2x2 matrix from two bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x2(bool2 c0, bool2 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a bool2x2 matrix from 4 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x2(bool m00, bool m01,
+                       bool m10, bool m11)
+        {
+            this.c0 = new bool2(m00, m10);
+            this.c1 = new bool2(m01, m11);
+        }
+
+        /// <summary>Constructs a bool2x2 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x2(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool2x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool2x2(bool v) { return new bool2x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool2x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool2x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool2x2 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator ! (bool2x2 val) { return new bool2x2 (!val.c0, !val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator & (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool2x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator & (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator & (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs & rhs.c0, lhs & rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator | (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool2x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator | (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator | (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs | rhs.c0, lhs | rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator ^ (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator ^ (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator ^ (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
+
+
+
+        /// <summary>Returns the bool2 element at a specified index.</summary>
+        unsafe public ref bool2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (bool2x2* array = &this) { return ref ((bool2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool2x2 is equal to a given bool2x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the bool2x2 is equal to a given bool2x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool2x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool2x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool2x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool2x2({0}, {1},  {2}, {3})", c0.x, c1.x, c0.y, c1.y);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool2x2 matrix constructed from two bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>bool2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 bool2x2(bool2 c0, bool2 c1) { return new bool2x2(c0, c1); }
+
+        /// <summary>Returns a bool2x2 matrix constructed from from 4 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <returns>bool2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 bool2x2(bool m00, bool m01,
+                                      bool m10, bool m11)
+        {
+            return new bool2x2(m00, m01,
+                               m10, m11);
+        }
+
+        /// <summary>Returns a bool2x2 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 bool2x2(bool v) { return new bool2x2(v); }
+
+        /// <summary>Return the bool2x2 transpose of a bool2x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 transpose(bool2x2 v)
+        {
+            return bool2x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y);
+        }
+
+        /// <summary>Returns a uint hash code of a bool2x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool2x2 v)
+        {
+            return csum(select(uint2(0x7AF32C49u, 0xAE131389u), uint2(0x5D1B165Bu, 0x87096CD7u), v.c0) +
+                        select(uint2(0x4C7F6DD1u, 0x4822A3E9u), uint2(0xAAC3C25Du, 0xD21D0945u), v.c1));
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a bool2x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(bool2x2 v)
+        {
+            return (select(uint2(0x88FCAB2Du, 0x614DA60Du), uint2(0x5BA2C50Bu, 0x8C455ACBu), v.c0) +
+                    select(uint2(0xCD266C89u, 0xF1852A33u), uint2(0x77E35E77u, 0x863E3729u), v.c1));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 466955346f18d45f1811f3683f9cf707
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x3.gen.cs

@@ -0,0 +1,306 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x3 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool2x3 : System.IEquatable<bool2x3>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool2 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool2 c2;
+
+
+        /// <summary>Constructs a bool2x3 matrix from three bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x3(bool2 c0, bool2 c1, bool2 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a bool2x3 matrix from 6 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x3(bool m00, bool m01, bool m02,
+                       bool m10, bool m11, bool m12)
+        {
+            this.c0 = new bool2(m00, m10);
+            this.c1 = new bool2(m01, m11);
+            this.c2 = new bool2(m02, m12);
+        }
+
+        /// <summary>Constructs a bool2x3 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x3(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool2x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool2x3(bool v) { return new bool2x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool2x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool2x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool2x3 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator ! (bool2x3 val) { return new bool2x3 (!val.c0, !val.c1, !val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator & (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool2x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator & (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator & (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator | (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool2x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator | (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator | (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator ^ (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator ^ (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator ^ (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
+
+
+
+        /// <summary>Returns the bool2 element at a specified index.</summary>
+        unsafe public ref bool2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (bool2x3* array = &this) { return ref ((bool2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool2x3 is equal to a given bool2x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the bool2x3 is equal to a given bool2x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool2x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool2x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool2x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool2x3({0}, {1}, {2},  {3}, {4}, {5})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool2x3 matrix constructed from three bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>bool2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 bool2x3(bool2 c0, bool2 c1, bool2 c2) { return new bool2x3(c0, c1, c2); }
+
+        /// <summary>Returns a bool2x3 matrix constructed from from 6 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <returns>bool2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 bool2x3(bool m00, bool m01, bool m02,
+                                      bool m10, bool m11, bool m12)
+        {
+            return new bool2x3(m00, m01, m02,
+                               m10, m11, m12);
+        }
+
+        /// <summary>Returns a bool2x3 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 bool2x3(bool v) { return new bool2x3(v); }
+
+        /// <summary>Return the bool3x2 transpose of a bool2x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 transpose(bool2x3 v)
+        {
+            return bool3x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y,
+                v.c2.x, v.c2.y);
+        }
+
+        /// <summary>Returns a uint hash code of a bool2x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool2x3 v)
+        {
+            return csum(select(uint2(0x7BE39F3Bu, 0xFAB9913Fu), uint2(0xB4501269u, 0xE04B89FDu), v.c0) +
+                        select(uint2(0xDB3DE101u, 0x7B6D1B4Bu), uint2(0x58399E77u, 0x5EAC29C9u), v.c1) +
+                        select(uint2(0xFC6014F9u, 0x6BF6693Fu), uint2(0x9D1B1D9Bu, 0xF842F5C1u), v.c2));
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a bool2x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(bool2x3 v)
+        {
+            return (select(uint2(0xA47EC335u, 0xA477DF57u), uint2(0xC4B1493Fu, 0xBA0966D3u), v.c0) +
+                    select(uint2(0xAFBEE253u, 0x5B419C01u), uint2(0x515D90F5u, 0xEC9F68F3u), v.c1) +
+                    select(uint2(0xF9EA92D5u, 0xC2FAFCB9u), uint2(0x616E9CA1u, 0xC5C5394Bu), v.c2));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2da7f6798be134406a5cc96b770b5e70
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x4.gen.cs

@@ -0,0 +1,320 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x4 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool2x4 : System.IEquatable<bool2x4>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool2 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool2 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public bool2 c3;
+
+
+        /// <summary>Constructs a bool2x4 matrix from four bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a bool2x4 matrix from 8 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x4(bool m00, bool m01, bool m02, bool m03,
+                       bool m10, bool m11, bool m12, bool m13)
+        {
+            this.c0 = new bool2(m00, m10);
+            this.c1 = new bool2(m01, m11);
+            this.c2 = new bool2(m02, m12);
+            this.c3 = new bool2(m03, m13);
+        }
+
+        /// <summary>Constructs a bool2x4 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool2x4(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool2x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool2x4(bool v) { return new bool2x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool2x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool2x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool2x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool2x4 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator ! (bool2x4 val) { return new bool2x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator & (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool2x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator & (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator & (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator | (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool2x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator | (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator | (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator ^ (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool2x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator ^ (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool2x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool2x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator ^ (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
+
+
+
+        /// <summary>Returns the bool2 element at a specified index.</summary>
+        unsafe public ref bool2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (bool2x4* array = &this) { return ref ((bool2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool2x4 is equal to a given bool2x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the bool2x4 is equal to a given bool2x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool2x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool2x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool2x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool2x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool2x4 matrix constructed from four bool2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>bool2x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3) { return new bool2x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a bool2x4 matrix constructed from from 8 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <returns>bool2x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 bool2x4(bool m00, bool m01, bool m02, bool m03,
+                                      bool m10, bool m11, bool m12, bool m13)
+        {
+            return new bool2x4(m00, m01, m02, m03,
+                               m10, m11, m12, m13);
+        }
+
+        /// <summary>Returns a bool2x4 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 bool2x4(bool v) { return new bool2x4(v); }
+
+        /// <summary>Return the bool4x2 transpose of a bool2x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 transpose(bool2x4 v)
+        {
+            return bool4x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y,
+                v.c2.x, v.c2.y,
+                v.c3.x, v.c3.y);
+        }
+
+        /// <summary>Returns a uint hash code of a bool2x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool2x4 v)
+        {
+            return csum(select(uint2(0x45A22087u, 0xFC104C3Bu), uint2(0x5FFF6B19u, 0x5E6CBF3Bu), v.c0) +
+                        select(uint2(0xB546F2A5u, 0xBBCF63E7u), uint2(0xC53F4755u, 0x6985C229u), v.c1) +
+                        select(uint2(0xE133B0B3u, 0xC3E0A3B9u), uint2(0xFE31134Fu, 0x712A34D7u), v.c2) +
+                        select(uint2(0x9D77A59Bu, 0x4942CA39u), uint2(0xB40EC62Du, 0x565ED63Fu), v.c3));
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a bool2x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(bool2x4 v)
+        {
+            return (select(uint2(0x93C30C2Bu, 0xDCAF0351u), uint2(0x6E050B01u, 0x750FDBF5u), v.c0) +
+                    select(uint2(0x7F3DD499u, 0x52EAAEBBu), uint2(0x4599C793u, 0x83B5E729u), v.c1) +
+                    select(uint2(0xC267163Fu, 0x67BC9149u), uint2(0xAD7C5EC1u, 0x822A7D6Du), v.c2) +
+                    select(uint2(0xB492BF15u, 0xD37220E3u), uint2(0x7AA2C2BDu, 0xE16BC89Du), v.c3));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool2x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f3638df1ef4a049fb957126fc52d1a20
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 75aefc1758f9fbc41af3579fdd45aa62
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x2.gen.cs

@@ -0,0 +1,299 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x2 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool3x2 : System.IEquatable<bool3x2>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool3 c1;
+
+
+        /// <summary>Constructs a bool3x2 matrix from two bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x2(bool3 c0, bool3 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a bool3x2 matrix from 6 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x2(bool m00, bool m01,
+                       bool m10, bool m11,
+                       bool m20, bool m21)
+        {
+            this.c0 = new bool3(m00, m10, m20);
+            this.c1 = new bool3(m01, m11, m21);
+        }
+
+        /// <summary>Constructs a bool3x2 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x2(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool3x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool3x2(bool v) { return new bool3x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool3x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool3x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool3x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool3x2 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator ! (bool3x2 val) { return new bool3x2 (!val.c0, !val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator & (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool3x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator & (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator & (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs & rhs.c0, lhs & rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator | (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool3x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator | (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator | (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs | rhs.c0, lhs | rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator ^ (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator ^ (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator ^ (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
+
+
+
+        /// <summary>Returns the bool3 element at a specified index.</summary>
+        unsafe public ref bool3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (bool3x2* array = &this) { return ref ((bool3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool3x2 is equal to a given bool3x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the bool3x2 is equal to a given bool3x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool3x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool3x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool3x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool3x2({0}, {1},  {2}, {3},  {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool3x2 matrix constructed from two bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>bool3x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 bool3x2(bool3 c0, bool3 c1) { return new bool3x2(c0, c1); }
+
+        /// <summary>Returns a bool3x2 matrix constructed from from 6 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <returns>bool3x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 bool3x2(bool m00, bool m01,
+                                      bool m10, bool m11,
+                                      bool m20, bool m21)
+        {
+            return new bool3x2(m00, m01,
+                               m10, m11,
+                               m20, m21);
+        }
+
+        /// <summary>Returns a bool3x2 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 bool3x2(bool v) { return new bool3x2(v); }
+
+        /// <summary>Return the bool2x3 transpose of a bool3x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 transpose(bool3x2 v)
+        {
+            return bool2x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z);
+        }
+
+        /// <summary>Returns a uint hash code of a bool3x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool3x2 v)
+        {
+            return csum(select(uint3(0x9C9F0823u, 0x5A9CA13Bu, 0xAFCDD5EFu), uint3(0xA88D187Du, 0xCF6EBA1Du, 0x9D88E5A1u), v.c0) +
+                        select(uint3(0xEADF0775u, 0x747A9D7Bu, 0x4111F799u), uint3(0xB5F05AF1u, 0xFD80290Bu, 0x8B65ADB7u), v.c1));
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a bool3x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(bool3x2 v)
+        {
+            return (select(uint3(0xDFF4F563u, 0x7069770Du, 0xD1224537u), uint3(0xE99ED6F3u, 0x48125549u, 0xEEE2123Bu), v.c0) +
+                    select(uint3(0xE3AD9FE5u, 0xCE1CF8BFu, 0x7BE39F3Bu), uint3(0xFAB9913Fu, 0xB4501269u, 0xE04B89FDu), v.c1));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 21b83123b388e4dcb80da9576a60ebd2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x3.gen.cs

@@ -0,0 +1,315 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x3 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool3x3 : System.IEquatable<bool3x3>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool3 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool3 c2;
+
+
+        /// <summary>Constructs a bool3x3 matrix from three bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x3(bool3 c0, bool3 c1, bool3 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a bool3x3 matrix from 9 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x3(bool m00, bool m01, bool m02,
+                       bool m10, bool m11, bool m12,
+                       bool m20, bool m21, bool m22)
+        {
+            this.c0 = new bool3(m00, m10, m20);
+            this.c1 = new bool3(m01, m11, m21);
+            this.c2 = new bool3(m02, m12, m22);
+        }
+
+        /// <summary>Constructs a bool3x3 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x3(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool3x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool3x3(bool v) { return new bool3x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool3x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool3x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool3x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool3x3 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator ! (bool3x3 val) { return new bool3x3 (!val.c0, !val.c1, !val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator & (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool3x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator & (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator & (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator | (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool3x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator | (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator | (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator ^ (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator ^ (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator ^ (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
+
+
+
+        /// <summary>Returns the bool3 element at a specified index.</summary>
+        unsafe public ref bool3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (bool3x3* array = &this) { return ref ((bool3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool3x3 is equal to a given bool3x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the bool3x3 is equal to a given bool3x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool3x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool3x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool3x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool3x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool3x3 matrix constructed from three bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>bool3x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 bool3x3(bool3 c0, bool3 c1, bool3 c2) { return new bool3x3(c0, c1, c2); }
+
+        /// <summary>Returns a bool3x3 matrix constructed from from 9 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <returns>bool3x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 bool3x3(bool m00, bool m01, bool m02,
+                                      bool m10, bool m11, bool m12,
+                                      bool m20, bool m21, bool m22)
+        {
+            return new bool3x3(m00, m01, m02,
+                               m10, m11, m12,
+                               m20, m21, m22);
+        }
+
+        /// <summary>Returns a bool3x3 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 bool3x3(bool v) { return new bool3x3(v); }
+
+        /// <summary>Return the bool3x3 transpose of a bool3x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 transpose(bool3x3 v)
+        {
+            return bool3x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z,
+                v.c2.x, v.c2.y, v.c2.z);
+        }
+
+        /// <summary>Returns a uint hash code of a bool3x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool3x3 v)
+        {
+            return csum(select(uint3(0xE7579997u, 0xEF7D56C7u, 0x66F38F0Bu), uint3(0x624256A3u, 0x5292ADE1u, 0xD2E590E5u), v.c0) +
+                        select(uint3(0xF25BE857u, 0x9BC17CE7u, 0xC8B86851u), uint3(0x64095221u, 0xADF428FFu, 0xA3977109u), v.c1) +
+                        select(uint3(0x745ED837u, 0x9CDC88F5u, 0xFA62D721u), uint3(0x7E4DB1CFu, 0x68EEE0F5u, 0xBC3B0A59u), v.c2));
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a bool3x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(bool3x3 v)
+        {
+            return (select(uint3(0x816EFB5Du, 0xA24E82B7u, 0x45A22087u), uint3(0xFC104C3Bu, 0x5FFF6B19u, 0x5E6CBF3Bu), v.c0) +
+                    select(uint3(0xB546F2A5u, 0xBBCF63E7u, 0xC53F4755u), uint3(0x6985C229u, 0xE133B0B3u, 0xC3E0A3B9u), v.c1) +
+                    select(uint3(0xFE31134Fu, 0x712A34D7u, 0x9D77A59Bu), uint3(0x4942CA39u, 0xB40EC62Du, 0x565ED63Fu), v.c2));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a3b4b734e76c94d5099484b5b6c5b029
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x4.gen.cs

@@ -0,0 +1,331 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x4 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool3x4 : System.IEquatable<bool3x4>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool3 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool3 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public bool3 c3;
+
+
+        /// <summary>Constructs a bool3x4 matrix from four bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a bool3x4 matrix from 12 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x4(bool m00, bool m01, bool m02, bool m03,
+                       bool m10, bool m11, bool m12, bool m13,
+                       bool m20, bool m21, bool m22, bool m23)
+        {
+            this.c0 = new bool3(m00, m10, m20);
+            this.c1 = new bool3(m01, m11, m21);
+            this.c2 = new bool3(m02, m12, m22);
+            this.c3 = new bool3(m03, m13, m23);
+        }
+
+        /// <summary>Constructs a bool3x4 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool3x4(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool3x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool3x4(bool v) { return new bool3x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool3x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool3x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool3x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool3x4 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator ! (bool3x4 val) { return new bool3x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator & (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool3x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator & (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator & (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator | (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool3x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator | (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator | (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator ^ (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool3x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator ^ (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool3x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool3x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator ^ (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
+
+
+
+        /// <summary>Returns the bool3 element at a specified index.</summary>
+        unsafe public ref bool3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (bool3x4* array = &this) { return ref ((bool3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool3x4 is equal to a given bool3x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the bool3x4 is equal to a given bool3x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool3x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool3x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool3x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool3x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool3x4 matrix constructed from four bool3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>bool3x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3) { return new bool3x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a bool3x4 matrix constructed from from 12 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <returns>bool3x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 bool3x4(bool m00, bool m01, bool m02, bool m03,
+                                      bool m10, bool m11, bool m12, bool m13,
+                                      bool m20, bool m21, bool m22, bool m23)
+        {
+            return new bool3x4(m00, m01, m02, m03,
+                               m10, m11, m12, m13,
+                               m20, m21, m22, m23);
+        }
+
+        /// <summary>Returns a bool3x4 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 bool3x4(bool v) { return new bool3x4(v); }
+
+        /// <summary>Return the bool4x3 transpose of a bool3x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 transpose(bool3x4 v)
+        {
+            return bool4x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z,
+                v.c2.x, v.c2.y, v.c2.z,
+                v.c3.x, v.c3.y, v.c3.z);
+        }
+
+        /// <summary>Returns a uint hash code of a bool3x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool3x4 v)
+        {
+            return csum(select(uint3(0x83B58237u, 0x833E3E29u, 0xA9D919BFu), uint3(0xC3EC1D97u, 0xB8B208C7u, 0x5D3ED947u), v.c0) +
+                        select(uint3(0x4473BBB1u, 0xCBA11D5Fu, 0x685835CFu), uint3(0xC3D32AE1u, 0xB966942Fu, 0xFE9856B3u), v.c1) +
+                        select(uint3(0xFA3A3285u, 0xAD55999Du, 0xDCDD5341u), uint3(0x94DDD769u, 0xA1E92D39u, 0x4583C801u), v.c2) +
+                        select(uint3(0x9536A0F5u, 0xAF816615u, 0x9AF8D62Du), uint3(0xE3600729u, 0x5F17300Du, 0x670D6809u), v.c3));
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a bool3x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(bool3x4 v)
+        {
+            return (select(uint3(0x7AF32C49u, 0xAE131389u, 0x5D1B165Bu), uint3(0x87096CD7u, 0x4C7F6DD1u, 0x4822A3E9u), v.c0) +
+                    select(uint3(0xAAC3C25Du, 0xD21D0945u, 0x88FCAB2Du), uint3(0x614DA60Du, 0x5BA2C50Bu, 0x8C455ACBu), v.c1) +
+                    select(uint3(0xCD266C89u, 0xF1852A33u, 0x77E35E77u), uint3(0x863E3729u, 0xE191B035u, 0x68586FAFu), v.c2) +
+                    select(uint3(0xD4DFF6D3u, 0xCB634F4Du, 0x9B13B92Du), uint3(0x4ABF0813u, 0x86068063u, 0xD75513F9u), v.c3));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool3x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 82510cd108c8a4a7ebe40f0cec12d18c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 64216725f837f8345b407a998b4970b3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x2.gen.cs

@@ -0,0 +1,306 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x2 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool4x2 : System.IEquatable<bool4x2>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool4 c1;
+
+
+        /// <summary>Constructs a bool4x2 matrix from two bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x2(bool4 c0, bool4 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a bool4x2 matrix from 8 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x2(bool m00, bool m01,
+                       bool m10, bool m11,
+                       bool m20, bool m21,
+                       bool m30, bool m31)
+        {
+            this.c0 = new bool4(m00, m10, m20, m30);
+            this.c1 = new bool4(m01, m11, m21, m31);
+        }
+
+        /// <summary>Constructs a bool4x2 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x2(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool4x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool4x2(bool v) { return new bool4x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool4x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool4x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool4x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool4x2 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator ! (bool4x2 val) { return new bool4x2 (!val.c0, !val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator & (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool4x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator & (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator & (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs & rhs.c0, lhs & rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator | (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool4x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator | (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator | (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs | rhs.c0, lhs | rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator ^ (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x2 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator ^ (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x2 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x2 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator ^ (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
+
+
+
+        /// <summary>Returns the bool4 element at a specified index.</summary>
+        unsafe public ref bool4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (bool4x2* array = &this) { return ref ((bool4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool4x2 is equal to a given bool4x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the bool4x2 is equal to a given bool4x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool4x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool4x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool4x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool4x2({0}, {1},  {2}, {3},  {4}, {5},  {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool4x2 matrix constructed from two bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>bool4x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 bool4x2(bool4 c0, bool4 c1) { return new bool4x2(c0, c1); }
+
+        /// <summary>Returns a bool4x2 matrix constructed from from 8 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <returns>bool4x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 bool4x2(bool m00, bool m01,
+                                      bool m10, bool m11,
+                                      bool m20, bool m21,
+                                      bool m30, bool m31)
+        {
+            return new bool4x2(m00, m01,
+                               m10, m11,
+                               m20, m21,
+                               m30, m31);
+        }
+
+        /// <summary>Returns a bool4x2 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 bool4x2(bool v) { return new bool4x2(v); }
+
+        /// <summary>Return the bool2x4 transpose of a bool4x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 transpose(bool4x2 v)
+        {
+            return bool2x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w);
+        }
+
+        /// <summary>Returns a uint hash code of a bool4x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool4x2 v)
+        {
+            return csum(select(uint4(0xD19764C7u, 0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu), uint4(0x56A1530Du, 0x804B722Du, 0x738E50E5u, 0x4FC93C25u), v.c0) +
+                        select(uint4(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du, 0xA10D9E27u), uint4(0x568DAAA9u, 0x7530254Fu, 0x9F090439u, 0x5E9F85C9u), v.c1));
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a bool4x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(bool4x2 v)
+        {
+            return (select(uint4(0x8C4CA03Fu, 0xB8D969EDu, 0xAC5DB57Bu, 0xA91A02EDu), uint4(0xB3C49313u, 0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u), v.c0) +
+                    select(uint4(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu, 0xEBD0D005u), uint4(0x91475DF7u, 0x55E84827u, 0x90A285BBu, 0x5D19E1D5u), v.c1));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d34b6dd47888145b8870e017d6c84d4e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x3.gen.cs

@@ -0,0 +1,324 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x3 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool4x3 : System.IEquatable<bool4x3>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool4 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool4 c2;
+
+
+        /// <summary>Constructs a bool4x3 matrix from three bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x3(bool4 c0, bool4 c1, bool4 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a bool4x3 matrix from 12 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x3(bool m00, bool m01, bool m02,
+                       bool m10, bool m11, bool m12,
+                       bool m20, bool m21, bool m22,
+                       bool m30, bool m31, bool m32)
+        {
+            this.c0 = new bool4(m00, m10, m20, m30);
+            this.c1 = new bool4(m01, m11, m21, m31);
+            this.c2 = new bool4(m02, m12, m22, m32);
+        }
+
+        /// <summary>Constructs a bool4x3 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x3(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool4x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool4x3(bool v) { return new bool4x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool4x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool4x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool4x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool4x3 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator ! (bool4x3 val) { return new bool4x3 (!val.c0, !val.c1, !val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator & (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool4x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator & (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator & (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator | (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool4x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator | (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator | (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator ^ (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x3 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator ^ (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x3 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x3 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator ^ (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
+
+
+
+        /// <summary>Returns the bool4 element at a specified index.</summary>
+        unsafe public ref bool4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (bool4x3* array = &this) { return ref ((bool4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool4x3 is equal to a given bool4x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the bool4x3 is equal to a given bool4x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool4x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool4x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool4x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool4x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8},  {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool4x3 matrix constructed from three bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>bool4x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 bool4x3(bool4 c0, bool4 c1, bool4 c2) { return new bool4x3(c0, c1, c2); }
+
+        /// <summary>Returns a bool4x3 matrix constructed from from 12 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <returns>bool4x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 bool4x3(bool m00, bool m01, bool m02,
+                                      bool m10, bool m11, bool m12,
+                                      bool m20, bool m21, bool m22,
+                                      bool m30, bool m31, bool m32)
+        {
+            return new bool4x3(m00, m01, m02,
+                               m10, m11, m12,
+                               m20, m21, m22,
+                               m30, m31, m32);
+        }
+
+        /// <summary>Returns a bool4x3 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 bool4x3(bool v) { return new bool4x3(v); }
+
+        /// <summary>Return the bool3x4 transpose of a bool4x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 transpose(bool4x3 v)
+        {
+            return bool3x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w,
+                v.c2.x, v.c2.y, v.c2.z, v.c2.w);
+        }
+
+        /// <summary>Returns a uint hash code of a bool4x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool4x3 v)
+        {
+            return csum(select(uint4(0xEADF0775u, 0x747A9D7Bu, 0x4111F799u, 0xB5F05AF1u), uint4(0xFD80290Bu, 0x8B65ADB7u, 0xDFF4F563u, 0x7069770Du), v.c0) +
+                        select(uint4(0xD1224537u, 0xE99ED6F3u, 0x48125549u, 0xEEE2123Bu), uint4(0xE3AD9FE5u, 0xCE1CF8BFu, 0x7BE39F3Bu, 0xFAB9913Fu), v.c1) +
+                        select(uint4(0xB4501269u, 0xE04B89FDu, 0xDB3DE101u, 0x7B6D1B4Bu), uint4(0x58399E77u, 0x5EAC29C9u, 0xFC6014F9u, 0x6BF6693Fu), v.c2));
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a bool4x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(bool4x3 v)
+        {
+            return (select(uint4(0x9D1B1D9Bu, 0xF842F5C1u, 0xA47EC335u, 0xA477DF57u), uint4(0xC4B1493Fu, 0xBA0966D3u, 0xAFBEE253u, 0x5B419C01u), v.c0) +
+                    select(uint4(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u, 0xC2FAFCB9u), uint4(0x616E9CA1u, 0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u), v.c1) +
+                    select(uint4(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u, 0x91D13847u), uint4(0x52F7230Fu, 0xCF286E83u, 0xE121E6ADu, 0xC9CA1249u), v.c2));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e3e9b9173355b4d25aad23fb08782200
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x4.gen.cs

@@ -0,0 +1,342 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x4 matrix of bools.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct bool4x4 : System.IEquatable<bool4x4>
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public bool4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public bool4 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public bool4 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public bool4 c3;
+
+
+        /// <summary>Constructs a bool4x4 matrix from four bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a bool4x4 matrix from 16 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x4(bool m00, bool m01, bool m02, bool m03,
+                       bool m10, bool m11, bool m12, bool m13,
+                       bool m20, bool m21, bool m22, bool m23,
+                       bool m30, bool m31, bool m32, bool m33)
+        {
+            this.c0 = new bool4(m00, m10, m20, m30);
+            this.c1 = new bool4(m01, m11, m21, m31);
+            this.c2 = new bool4(m02, m12, m22, m32);
+            this.c3 = new bool4(m03, m13, m23, m33);
+        }
+
+        /// <summary>Constructs a bool4x4 matrix from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool4x4(bool v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+
+        /// <summary>Implicitly converts a single bool value to a bool4x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool4x4(bool v) { return new bool4x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two bool4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool4x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two bool4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool4x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not operation on a bool4x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise not.</param>
+        /// <returns>bool4x4 result of the componentwise not.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator ! (bool4x4 val) { return new bool4x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on two bool4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator & (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool4x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator & (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise and.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise and.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise and.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator & (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on two bool4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator | (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool4x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator | (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise or.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator | (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator ^ (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x4 matrix and a bool value.</summary>
+        /// <param name="lhs">Left hand side bool4x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator ^ (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
+
+        /// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side bool to use to compute componentwise bitwise exclusive or.</param>
+        /// <param name="rhs">Right hand side bool4x4 to use to compute componentwise bitwise exclusive or.</param>
+        /// <returns>bool4x4 result of the componentwise bitwise exclusive or.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator ^ (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
+
+
+
+        /// <summary>Returns the bool4 element at a specified index.</summary>
+        unsafe public ref bool4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (bool4x4* array = &this) { return ref ((bool4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the bool4x4 is equal to a given bool4x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(bool4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the bool4x4 is equal to a given bool4x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is bool4x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the bool4x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the bool4x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("bool4x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11},  {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w);
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a bool4x4 matrix constructed from four bool4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>bool4x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3) { return new bool4x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a bool4x4 matrix constructed from from 16 bool values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
+        /// <returns>bool4x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 bool4x4(bool m00, bool m01, bool m02, bool m03,
+                                      bool m10, bool m11, bool m12, bool m13,
+                                      bool m20, bool m21, bool m22, bool m23,
+                                      bool m30, bool m31, bool m32, bool m33)
+        {
+            return new bool4x4(m00, m01, m02, m03,
+                               m10, m11, m12, m13,
+                               m20, m21, m22, m23,
+                               m30, m31, m32, m33);
+        }
+
+        /// <summary>Returns a bool4x4 matrix constructed from a single bool value by assigning it to every component.</summary>
+        /// <param name="v">bool to convert to bool4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 bool4x4(bool v) { return new bool4x4(v); }
+
+        /// <summary>Return the bool4x4 transpose of a bool4x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 transpose(bool4x4 v)
+        {
+            return bool4x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w,
+                v.c2.x, v.c2.y, v.c2.z, v.c2.w,
+                v.c3.x, v.c3.y, v.c3.z, v.c3.w);
+        }
+
+        /// <summary>Returns a uint hash code of a bool4x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(bool4x4 v)
+        {
+            return csum(select(uint4(0xD19764C7u, 0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu), uint4(0x56A1530Du, 0x804B722Du, 0x738E50E5u, 0x4FC93C25u), v.c0) +
+                        select(uint4(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du, 0xA10D9E27u), uint4(0x568DAAA9u, 0x7530254Fu, 0x9F090439u, 0x5E9F85C9u), v.c1) +
+                        select(uint4(0x8C4CA03Fu, 0xB8D969EDu, 0xAC5DB57Bu, 0xA91A02EDu), uint4(0xB3C49313u, 0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u), v.c2) +
+                        select(uint4(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu, 0xEBD0D005u), uint4(0x91475DF7u, 0x55E84827u, 0x90A285BBu, 0x5D19E1D5u), v.c3));
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a bool4x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(bool4x4 v)
+        {
+            return (select(uint4(0xFAAF07DDu, 0x625C45BDu, 0xC9F27FCBu, 0x6D2523B1u), uint4(0x6E2BF6A9u, 0xCC74B3B7u, 0x83B58237u, 0x833E3E29u), v.c0) +
+                    select(uint4(0xA9D919BFu, 0xC3EC1D97u, 0xB8B208C7u, 0x5D3ED947u), uint4(0x4473BBB1u, 0xCBA11D5Fu, 0x685835CFu, 0xC3D32AE1u), v.c1) +
+                    select(uint4(0xB966942Fu, 0xFE9856B3u, 0xFA3A3285u, 0xAD55999Du), uint4(0xDCDD5341u, 0x94DDD769u, 0xA1E92D39u, 0x4583C801u), v.c2) +
+                    select(uint4(0x9536A0F5u, 0xAF816615u, 0x9AF8D62Du, 0xE3600729u), uint4(0x5F17300Du, 0x670D6809u, 0x7AF32C49u, 0xAE131389u), v.c3));
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/bool4x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec21b45eb93de4c05962f95aee69aee6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2.gen.cs

@@ -0,0 +1,998 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2 component vector of doubles.</summary>
+    [DebuggerTypeProxy(typeof(double2.DebuggerProxy))]
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double2 : System.IEquatable<double2>, IFormattable
+    {
+        /// <summary>x component of the vector.</summary>
+        public double x;
+        /// <summary>y component of the vector.</summary>
+        public double y;
+
+        /// <summary>double2 zero value.</summary>
+        public static readonly double2 zero;
+
+        /// <summary>Constructs a double2 vector from two double values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(double x, double y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        /// <summary>Constructs a double2 vector from a double2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(double2 xy)
+        {
+            this.x = xy.x;
+            this.y = xy.y;
+        }
+
+        /// <summary>Constructs a double2 vector from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(double v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a double2 vector from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(bool v)
+        {
+            this.x = v ? 1.0 : 0.0;
+            this.y = v ? 1.0 : 0.0;
+        }
+
+        /// <summary>Constructs a double2 vector from a bool2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(bool2 v)
+        {
+            this.x = v.x ? 1.0 : 0.0;
+            this.y = v.y ? 1.0 : 0.0;
+        }
+
+        /// <summary>Constructs a double2 vector from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(int v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a double2 vector from a int2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(int2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a double2 vector from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(uint v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a double2 vector from a uint2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(uint2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a double2 vector from a single half value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">half to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(half v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a double2 vector from a half2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(half2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a double2 vector from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(float v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a double2 vector from a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">float2 to convert to double2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2(float2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double2 vector by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(double v) { return new double2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double2 vector by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2(bool v) { return new double2(v); }
+
+        /// <summary>Explicitly converts a bool2 vector to a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2(bool2 v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a single int value to a double2 vector by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(int v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a int2 vector to a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(int2 v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double2 vector by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(uint v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a uint2 vector to a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(uint2 v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a single half value to a double2 vector by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">half to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(half v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a half2 vector to a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(half2 v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a single float value to a double2 vector by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(float v) { return new double2(v); }
+
+        /// <summary>Implicitly converts a float2 vector to a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">float2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2(float2 v) { return new double2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise multiplication.</param>
+        /// <returns>double2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator * (double2 lhs, double2 rhs) { return new double2 (lhs.x * rhs.x, lhs.y * rhs.y); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator * (double2 lhs, double rhs) { return new double2 (lhs.x * rhs, lhs.y * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise multiplication.</param>
+        /// <returns>double2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator * (double lhs, double2 rhs) { return new double2 (lhs * rhs.x, lhs * rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise addition.</param>
+        /// <returns>double2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator + (double2 lhs, double2 rhs) { return new double2 (lhs.x + rhs.x, lhs.y + rhs.y); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator + (double2 lhs, double rhs) { return new double2 (lhs.x + rhs, lhs.y + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise addition.</param>
+        /// <returns>double2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator + (double lhs, double2 rhs) { return new double2 (lhs + rhs.x, lhs + rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise subtraction.</param>
+        /// <returns>double2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator - (double2 lhs, double2 rhs) { return new double2 (lhs.x - rhs.x, lhs.y - rhs.y); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator - (double2 lhs, double rhs) { return new double2 (lhs.x - rhs, lhs.y - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise subtraction.</param>
+        /// <returns>double2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator - (double lhs, double2 rhs) { return new double2 (lhs - rhs.x, lhs - rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise division.</param>
+        /// <returns>double2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator / (double2 lhs, double2 rhs) { return new double2 (lhs.x / rhs.x, lhs.y / rhs.y); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator / (double2 lhs, double rhs) { return new double2 (lhs.x / rhs, lhs.y / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise division.</param>
+        /// <returns>double2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator / (double lhs, double2 rhs) { return new double2 (lhs / rhs.x, lhs / rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise modulus.</param>
+        /// <returns>double2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator % (double2 lhs, double2 rhs) { return new double2 (lhs.x % rhs.x, lhs.y % rhs.y); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator % (double2 lhs, double rhs) { return new double2 (lhs.x % rhs, lhs.y % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise modulus.</param>
+        /// <returns>double2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator % (double lhs, double2 rhs) { return new double2 (lhs % rhs.x, lhs % rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator ++ (double2 val) { return new double2 (++val.x, ++val.y); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator -- (double2 val) { return new double2 (--val.x, --val.y); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (double2 lhs, double2 rhs) { return new bool2 (lhs.x < rhs.x, lhs.y < rhs.y); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (double2 lhs, double rhs) { return new bool2 (lhs.x < rhs, lhs.y < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (double lhs, double2 rhs) { return new bool2 (lhs < rhs.x, lhs < rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (double2 lhs, double2 rhs) { return new bool2 (lhs.x <= rhs.x, lhs.y <= rhs.y); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (double2 lhs, double rhs) { return new bool2 (lhs.x <= rhs, lhs.y <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (double lhs, double2 rhs) { return new bool2 (lhs <= rhs.x, lhs <= rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (double2 lhs, double2 rhs) { return new bool2 (lhs.x > rhs.x, lhs.y > rhs.y); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (double2 lhs, double rhs) { return new bool2 (lhs.x > rhs, lhs.y > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (double lhs, double2 rhs) { return new bool2 (lhs > rhs.x, lhs > rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (double2 lhs, double2 rhs) { return new bool2 (lhs.x >= rhs.x, lhs.y >= rhs.y); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (double2 lhs, double rhs) { return new bool2 (lhs.x >= rhs, lhs.y >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (double lhs, double2 rhs) { return new bool2 (lhs >= rhs.x, lhs >= rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator - (double2 val) { return new double2 (-val.x, -val.y); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 operator + (double2 val) { return new double2 (+val.x, +val.y); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (double2 lhs, double2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (double2 lhs, double rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (double lhs, double2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double2 vectors.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (double2 lhs, double2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double2 vector and a double value.</summary>
+        /// <param name="lhs">Left hand side double2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (double2 lhs, double rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double2 vector.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (double lhs, double2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
+
+
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 xyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(x, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double4 yyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double4(y, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 xxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 xxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 xyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 xyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 yxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 yxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 yyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double3 yyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double3(y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double2 xx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double2(x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double2 xy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double2(x, y); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { x = value.x; y = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double2 yx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double2(y, x); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { y = value.x; x = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public double2 yy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new double2(y, y); }
+        }
+
+
+
+        /// <summary>Returns the double element at a specified index.</summary>
+        unsafe public double this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (double2* array = &this) { return ((double*)array)[index]; }
+            }
+            set
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (double* array = &x) { array[index] = value; }
+            }
+        }
+
+        /// <summary>Returns true if the double2 is equal to a given double2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double2 rhs) { return x == rhs.x && y == rhs.y; }
+
+        /// <summary>Returns true if the double2 is equal to a given double2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double2({0}, {1})", x, y);
+        }
+
+        /// <summary>Returns a string representation of the double2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double2({0}, {1})", x.ToString(format, formatProvider), y.ToString(format, formatProvider));
+        }
+
+        internal sealed class DebuggerProxy
+        {
+            public double x;
+            public double y;
+            public DebuggerProxy(double2 v)
+            {
+                x = v.x;
+                y = v.y;
+            }
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double2 vector constructed from two double values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        /// <returns>double2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(double x, double y) { return new double2(x, y); }
+
+        /// <summary>Returns a double2 vector constructed from a double2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        /// <returns>double2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(double2 xy) { return new double2(xy); }
+
+        /// <summary>Returns a double2 vector constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(double v) { return new double2(v); }
+
+        /// <summary>Returns a double2 vector constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(bool v) { return new double2(v); }
+
+        /// <summary>Return a double2 vector constructed from a bool2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(bool2 v) { return new double2(v); }
+
+        /// <summary>Returns a double2 vector constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(int v) { return new double2(v); }
+
+        /// <summary>Return a double2 vector constructed from a int2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(int2 v) { return new double2(v); }
+
+        /// <summary>Returns a double2 vector constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(uint v) { return new double2(v); }
+
+        /// <summary>Return a double2 vector constructed from a uint2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(uint2 v) { return new double2(v); }
+
+        /// <summary>Returns a double2 vector constructed from a single half value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">half to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(half v) { return new double2(v); }
+
+        /// <summary>Return a double2 vector constructed from a half2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(half2 v) { return new double2(v); }
+
+        /// <summary>Returns a double2 vector constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(float v) { return new double2(v); }
+
+        /// <summary>Return a double2 vector constructed from a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">float2 to convert to double2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 double2(float2 v) { return new double2(v); }
+
+        /// <summary>Returns a uint hash code of a double2 vector.</summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double2 v)
+        {
+            return csum(fold_to_uint(v) * uint2(0x9536A0F5u, 0xAF816615u)) + 0x9AF8D62Du;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a double2 vector.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(double2 v)
+        {
+            return (fold_to_uint(v) * uint2(0xE3600729u, 0x5F17300Du)) + 0x670D6809u;
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double value.</summary>
+        /// <param name="left">double2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">double2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting double.</param>
+        /// <returns>double result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double shuffle(double2 left, double2 right, ShuffleComponent x)
+        {
+            return select_shuffle_component(left, right, x);
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double2 vector.</summary>
+        /// <param name="left">double2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">double2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting double2 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting double2 y component.</param>
+        /// <returns>double2 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y)
+        {
+            return double2(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double3 vector.</summary>
+        /// <param name="left">double2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">double2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting double3 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting double3 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting double3 z component.</param>
+        /// <returns>double3 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
+        {
+            return double3(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double4 vector.</summary>
+        /// <param name="left">double2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">double2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting double4 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting double4 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting double4 z component.</param>
+        /// <param name="w">The ShuffleComponent to use when setting the resulting double4 w component.</param>
+        /// <returns>double4 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4 shuffle(double2 left, double2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
+        {
+            return double4(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z),
+                select_shuffle_component(left, right, w));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static double select_shuffle_component(double2 a, double2 b, ShuffleComponent component)
+        {
+            switch(component)
+            {
+                case ShuffleComponent.LeftX:
+                    return a.x;
+                case ShuffleComponent.LeftY:
+                    return a.y;
+                case ShuffleComponent.RightX:
+                    return b.x;
+                case ShuffleComponent.RightY:
+                    return b.y;
+                default:
+                    throw new System.ArgumentException("Invalid shuffle component: " + component);
+            }
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8df28422e0a0640c1896e8de330e2640
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x2.gen.cs

@@ -0,0 +1,658 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x2 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double2x2 : System.IEquatable<double2x2>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double2 c1;
+
+        /// <summary>double2x2 identity transform.</summary>
+        public static readonly double2x2 identity = new double2x2(1.0, 0.0,   0.0, 1.0);
+
+        /// <summary>double2x2 zero value.</summary>
+        public static readonly double2x2 zero;
+
+        /// <summary>Constructs a double2x2 matrix from two double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(double2 c0, double2 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from 4 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(double m00, double m01,
+                         double m10, double m11)
+        {
+            this.c0 = new double2(m00, m10);
+            this.c1 = new double2(m01, m11);
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(bool v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v);
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a bool2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(bool2x2 v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a int2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(int2x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a uint2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(uint2x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double2x2 matrix from a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x2 to convert to double2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x2(float2x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double2x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(double v) { return new double2x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x2(bool v) { return new double2x2(v); }
+
+        /// <summary>Explicitly converts a bool2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x2(bool2x2 v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a single int value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(int v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a int2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(int2x2 v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(uint v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a uint2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(uint2x2 v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a single float value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(float v) { return new double2x2(v); }
+
+        /// <summary>Implicitly converts a float2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x2(float2x2 v) { return new double2x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator * (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator * (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator * (double lhs, double2x2 rhs) { return new double2x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise addition.</param>
+        /// <returns>double2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator + (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator + (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise addition.</param>
+        /// <returns>double2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator + (double lhs, double2x2 rhs) { return new double2x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator - (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator - (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator - (double lhs, double2x2 rhs) { return new double2x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise division.</param>
+        /// <returns>double2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator / (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator / (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise division.</param>
+        /// <returns>double2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator / (double lhs, double2x2 rhs) { return new double2x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise modulus.</param>
+        /// <returns>double2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator % (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator % (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise modulus.</param>
+        /// <returns>double2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator % (double lhs, double2x2 rhs) { return new double2x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double2x2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator ++ (double2x2 val) { return new double2x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double2x2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator -- (double2x2 val) { return new double2x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (double lhs, double2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (double lhs, double2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (double lhs, double2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (double lhs, double2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double2x2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator - (double2x2 val) { return new double2x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double2x2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 operator + (double2x2 val) { return new double2x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (double lhs, double2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double2x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (double lhs, double2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+
+        /// <summary>Returns the double2 element at a specified index.</summary>
+        unsafe public ref double2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (double2x2* array = &this) { return ref ((double2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double2x2 is equal to a given double2x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the double2x2 is equal to a given double2x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double2x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double2x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double2x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double2x2({0}, {1},  {2}, {3})", c0.x, c1.x, c0.y, c1.y);
+        }
+
+        /// <summary>Returns a string representation of the double2x2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double2x2({0}, {1},  {2}, {3})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double2x2 matrix constructed from two double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>double2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(double2 c0, double2 c1) { return new double2x2(c0, c1); }
+
+        /// <summary>Returns a double2x2 matrix constructed from from 4 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <returns>double2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(double m00, double m01,
+                                          double m10, double m11)
+        {
+            return new double2x2(m00, m01,
+                                 m10, m11);
+        }
+
+        /// <summary>Returns a double2x2 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(double v) { return new double2x2(v); }
+
+        /// <summary>Returns a double2x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(bool v) { return new double2x2(v); }
+
+        /// <summary>Return a double2x2 matrix constructed from a bool2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(bool2x2 v) { return new double2x2(v); }
+
+        /// <summary>Returns a double2x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(int v) { return new double2x2(v); }
+
+        /// <summary>Return a double2x2 matrix constructed from a int2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(int2x2 v) { return new double2x2(v); }
+
+        /// <summary>Returns a double2x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(uint v) { return new double2x2(v); }
+
+        /// <summary>Return a double2x2 matrix constructed from a uint2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(uint2x2 v) { return new double2x2(v); }
+
+        /// <summary>Returns a double2x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(float v) { return new double2x2(v); }
+
+        /// <summary>Return a double2x2 matrix constructed from a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x2 to convert to double2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 double2x2(float2x2 v) { return new double2x2(v); }
+
+        /// <summary>Return the double2x2 transpose of a double2x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 transpose(double2x2 v)
+        {
+            return double2x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y);
+        }
+
+        /// <summary>Returns the double2x2 full inverse of a double2x2 matrix.</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x2 inverse(double2x2 m)
+        {
+            double a = m.c0.x;
+            double b = m.c1.x;
+            double c = m.c0.y;
+            double d = m.c1.y;
+
+            double det = a * d - b * c;
+
+            return double2x2(d, -b, -c, a) * (1.0 / det);
+        }
+
+        /// <summary>Returns the determinant of a double2x2 matrix.</summary>
+        /// <param name="m">Matrix to use when computing determinant.</param>
+        /// <returns>The determinant of the matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double determinant(double2x2 m)
+        {
+            double a = m.c0.x;
+            double b = m.c1.x;
+            double c = m.c0.y;
+            double d = m.c1.y;
+
+            return a * d - b * c;
+        }
+
+        /// <summary>Returns a uint hash code of a double2x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double2x2 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint2(0xFD80290Bu, 0x8B65ADB7u) +
+                        fold_to_uint(v.c1) * uint2(0xDFF4F563u, 0x7069770Du)) + 0xD1224537u;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a double2x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(double2x2 v)
+        {
+            return (fold_to_uint(v.c0) * uint2(0xE99ED6F3u, 0x48125549u) +
+                    fold_to_uint(v.c1) * uint2(0xEEE2123Bu, 0xE3AD9FE5u)) + 0xCE1CF8BFu;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3faab235f9f6845bbbd1d94d1376d896
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x3.gen.cs

@@ -0,0 +1,647 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x3 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double2x3 : System.IEquatable<double2x3>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double2 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double2 c2;
+
+        /// <summary>double2x3 zero value.</summary>
+        public static readonly double2x3 zero;
+
+        /// <summary>Constructs a double2x3 matrix from three double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(double2 c0, double2 c1, double2 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from 6 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(double m00, double m01, double m02,
+                         double m10, double m11, double m12)
+        {
+            this.c0 = new double2(m00, m10);
+            this.c1 = new double2(m01, m11);
+            this.c2 = new double2(m02, m12);
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(bool v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c2 = math.select(new double2(0.0), new double2(1.0), v);
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a bool2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(bool2x3 v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
+            this.c2 = math.select(new double2(0.0), new double2(1.0), v.c2);
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a int2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(int2x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a uint2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(uint2x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double2x3 matrix from a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x3 to convert to double2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x3(float2x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double2x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(double v) { return new double2x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x3(bool v) { return new double2x3(v); }
+
+        /// <summary>Explicitly converts a bool2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x3(bool2x3 v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a single int value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(int v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a int2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(int2x3 v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(uint v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a uint2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(uint2x3 v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a single float value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(float v) { return new double2x3(v); }
+
+        /// <summary>Implicitly converts a float2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x3(float2x3 v) { return new double2x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator * (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator * (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator * (double lhs, double2x3 rhs) { return new double2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise addition.</param>
+        /// <returns>double2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator + (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator + (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise addition.</param>
+        /// <returns>double2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator + (double lhs, double2x3 rhs) { return new double2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator - (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator - (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator - (double lhs, double2x3 rhs) { return new double2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise division.</param>
+        /// <returns>double2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator / (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator / (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise division.</param>
+        /// <returns>double2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator / (double lhs, double2x3 rhs) { return new double2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise modulus.</param>
+        /// <returns>double2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator % (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator % (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise modulus.</param>
+        /// <returns>double2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator % (double lhs, double2x3 rhs) { return new double2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double2x3 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator ++ (double2x3 val) { return new double2x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double2x3 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator -- (double2x3 val) { return new double2x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (double lhs, double2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (double lhs, double2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (double lhs, double2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (double lhs, double2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double2x3 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator - (double2x3 val) { return new double2x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double2x3 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 operator + (double2x3 val) { return new double2x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (double lhs, double2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double2x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (double lhs, double2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+
+        /// <summary>Returns the double2 element at a specified index.</summary>
+        unsafe public ref double2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (double2x3* array = &this) { return ref ((double2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double2x3 is equal to a given double2x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the double2x3 is equal to a given double2x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double2x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double2x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double2x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double2x3({0}, {1}, {2},  {3}, {4}, {5})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
+        }
+
+        /// <summary>Returns a string representation of the double2x3 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double2x3({0}, {1}, {2},  {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double2x3 matrix constructed from three double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>double2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(double2 c0, double2 c1, double2 c2) { return new double2x3(c0, c1, c2); }
+
+        /// <summary>Returns a double2x3 matrix constructed from from 6 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <returns>double2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(double m00, double m01, double m02,
+                                          double m10, double m11, double m12)
+        {
+            return new double2x3(m00, m01, m02,
+                                 m10, m11, m12);
+        }
+
+        /// <summary>Returns a double2x3 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(double v) { return new double2x3(v); }
+
+        /// <summary>Returns a double2x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(bool v) { return new double2x3(v); }
+
+        /// <summary>Return a double2x3 matrix constructed from a bool2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(bool2x3 v) { return new double2x3(v); }
+
+        /// <summary>Returns a double2x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(int v) { return new double2x3(v); }
+
+        /// <summary>Return a double2x3 matrix constructed from a int2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(int2x3 v) { return new double2x3(v); }
+
+        /// <summary>Returns a double2x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(uint v) { return new double2x3(v); }
+
+        /// <summary>Return a double2x3 matrix constructed from a uint2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(uint2x3 v) { return new double2x3(v); }
+
+        /// <summary>Returns a double2x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(float v) { return new double2x3(v); }
+
+        /// <summary>Return a double2x3 matrix constructed from a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x3 to convert to double2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 double2x3(float2x3 v) { return new double2x3(v); }
+
+        /// <summary>Return the double3x2 transpose of a double2x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 transpose(double2x3 v)
+        {
+            return double3x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y,
+                v.c2.x, v.c2.y);
+        }
+
+        /// <summary>Returns a uint hash code of a double2x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double2x3 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint2(0xF25BE857u, 0x9BC17CE7u) +
+                        fold_to_uint(v.c1) * uint2(0xC8B86851u, 0x64095221u) +
+                        fold_to_uint(v.c2) * uint2(0xADF428FFu, 0xA3977109u)) + 0x745ED837u;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a double2x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(double2x3 v)
+        {
+            return (fold_to_uint(v.c0) * uint2(0x9CDC88F5u, 0xFA62D721u) +
+                    fold_to_uint(v.c1) * uint2(0x7E4DB1CFu, 0x68EEE0F5u) +
+                    fold_to_uint(v.c2) * uint2(0xBC3B0A59u, 0x816EFB5Du)) + 0xA24E82B7u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c05b76c6656d48b1a5a25086c9277c7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x4.gen.cs

@@ -0,0 +1,669 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x4 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double2x4 : System.IEquatable<double2x4>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double2 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double2 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public double2 c3;
+
+        /// <summary>double2x4 zero value.</summary>
+        public static readonly double2x4 zero;
+
+        /// <summary>Constructs a double2x4 matrix from four double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(double2 c0, double2 c1, double2 c2, double2 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from 8 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(double m00, double m01, double m02, double m03,
+                         double m10, double m11, double m12, double m13)
+        {
+            this.c0 = new double2(m00, m10);
+            this.c1 = new double2(m01, m11);
+            this.c2 = new double2(m02, m12);
+            this.c3 = new double2(m03, m13);
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(bool v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c2 = math.select(new double2(0.0), new double2(1.0), v);
+            this.c3 = math.select(new double2(0.0), new double2(1.0), v);
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a bool2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x4 to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(bool2x4 v)
+        {
+            this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
+            this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
+            this.c2 = math.select(new double2(0.0), new double2(1.0), v.c2);
+            this.c3 = math.select(new double2(0.0), new double2(1.0), v.c3);
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a int2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x4 to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(int2x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a uint2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x4 to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(uint2x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double2x4 matrix from a float2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x4 to convert to double2x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double2x4(float2x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double2x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(double v) { return new double2x4(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x4(bool v) { return new double2x4(v); }
+
+        /// <summary>Explicitly converts a bool2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double2x4(bool2x4 v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a single int value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(int v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a int2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(int2x4 v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(uint v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a uint2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(uint2x4 v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a single float value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(float v) { return new double2x4(v); }
+
+        /// <summary>Implicitly converts a float2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double2x4(float2x4 v) { return new double2x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator * (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double2x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator * (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double2x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator * (double lhs, double2x4 rhs) { return new double2x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise addition.</param>
+        /// <returns>double2x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator + (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double2x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator + (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise addition.</param>
+        /// <returns>double2x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator + (double lhs, double2x4 rhs) { return new double2x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator - (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double2x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator - (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double2x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator - (double lhs, double2x4 rhs) { return new double2x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise division.</param>
+        /// <returns>double2x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator / (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double2x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator / (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise division.</param>
+        /// <returns>double2x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator / (double lhs, double2x4 rhs) { return new double2x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise modulus.</param>
+        /// <returns>double2x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator % (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double2x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator % (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise modulus.</param>
+        /// <returns>double2x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator % (double lhs, double2x4 rhs) { return new double2x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double2x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double2x4 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator ++ (double2x4 val) { return new double2x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double2x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double2x4 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator -- (double2x4 val) { return new double2x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise less than.</param>
+        /// <returns>bool2x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator < (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool2x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator < (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise less than.</param>
+        /// <returns>bool2x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator < (double lhs, double2x4 rhs) { return new bool2x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator <= (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator <= (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator <= (double lhs, double2x4 rhs) { return new bool2x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator > (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool2x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator > (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator > (double lhs, double2x4 rhs) { return new bool2x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator >= (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator >= (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator >= (double lhs, double2x4 rhs) { return new bool2x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double2x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double2x4 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator - (double2x4 val) { return new double2x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double2x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double2x4 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 operator + (double2x4 val) { return new double2x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise equality.</param>
+        /// <returns>bool2x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator == (double lhs, double2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double2x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double2x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double2x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double2x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x4 operator != (double lhs, double2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+
+        /// <summary>Returns the double2 element at a specified index.</summary>
+        unsafe public ref double2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (double2x4* array = &this) { return ref ((double2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double2x4 is equal to a given double2x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the double2x4 is equal to a given double2x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double2x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double2x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double2x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double2x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y);
+        }
+
+        /// <summary>Returns a string representation of the double2x4 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double2x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double2x4 matrix constructed from four double2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>double2x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(double2 c0, double2 c1, double2 c2, double2 c3) { return new double2x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a double2x4 matrix constructed from from 8 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <returns>double2x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(double m00, double m01, double m02, double m03,
+                                          double m10, double m11, double m12, double m13)
+        {
+            return new double2x4(m00, m01, m02, m03,
+                                 m10, m11, m12, m13);
+        }
+
+        /// <summary>Returns a double2x4 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(double v) { return new double2x4(v); }
+
+        /// <summary>Returns a double2x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(bool v) { return new double2x4(v); }
+
+        /// <summary>Return a double2x4 matrix constructed from a bool2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(bool2x4 v) { return new double2x4(v); }
+
+        /// <summary>Returns a double2x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(int v) { return new double2x4(v); }
+
+        /// <summary>Return a double2x4 matrix constructed from a int2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(int2x4 v) { return new double2x4(v); }
+
+        /// <summary>Returns a double2x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(uint v) { return new double2x4(v); }
+
+        /// <summary>Return a double2x4 matrix constructed from a uint2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(uint2x4 v) { return new double2x4(v); }
+
+        /// <summary>Returns a double2x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(float v) { return new double2x4(v); }
+
+        /// <summary>Return a double2x4 matrix constructed from a float2x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float2x4 to convert to double2x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 double2x4(float2x4 v) { return new double2x4(v); }
+
+        /// <summary>Return the double4x2 transpose of a double2x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 transpose(double2x4 v)
+        {
+            return double4x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y,
+                v.c2.x, v.c2.y,
+                v.c3.x, v.c3.y);
+        }
+
+        /// <summary>Returns a uint hash code of a double2x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double2x4 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint2(0x91475DF7u, 0x55E84827u) +
+                        fold_to_uint(v.c1) * uint2(0x90A285BBu, 0x5D19E1D5u) +
+                        fold_to_uint(v.c2) * uint2(0xFAAF07DDu, 0x625C45BDu) +
+                        fold_to_uint(v.c3) * uint2(0xC9F27FCBu, 0x6D2523B1u)) + 0x6E2BF6A9u;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a double2x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(double2x4 v)
+        {
+            return (fold_to_uint(v.c0) * uint2(0xCC74B3B7u, 0x83B58237u) +
+                    fold_to_uint(v.c1) * uint2(0x833E3E29u, 0xA9D919BFu) +
+                    fold_to_uint(v.c2) * uint2(0xC3EC1D97u, 0xB8B208C7u) +
+                    fold_to_uint(v.c3) * uint2(0x5D3ED947u, 0x4473BBB1u)) + 0xCBA11D5Fu;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double2x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e21dd148ae3e4bf98a4042d4756c4db
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8532598f495324d779593b36c90c7f7c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x2.gen.cs

@@ -0,0 +1,632 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x2 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double3x2 : System.IEquatable<double3x2>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double3 c1;
+
+        /// <summary>double3x2 zero value.</summary>
+        public static readonly double3x2 zero;
+
+        /// <summary>Constructs a double3x2 matrix from two double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(double3 c0, double3 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from 6 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(double m00, double m01,
+                         double m10, double m11,
+                         double m20, double m21)
+        {
+            this.c0 = new double3(m00, m10, m20);
+            this.c1 = new double3(m01, m11, m21);
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(bool v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v);
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a bool3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x2 to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(bool3x2 v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a int3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x2 to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(int3x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a uint3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x2 to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(uint3x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double3x2 matrix from a float3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x2 to convert to double3x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x2(float3x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double3x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(double v) { return new double3x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x2(bool v) { return new double3x2(v); }
+
+        /// <summary>Explicitly converts a bool3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x2(bool3x2 v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a single int value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(int v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a int3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(int3x2 v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(uint v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a uint3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(uint3x2 v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a single float value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(float v) { return new double3x2(v); }
+
+        /// <summary>Implicitly converts a float3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x2(float3x2 v) { return new double3x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator * (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double3x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator * (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator * (double lhs, double3x2 rhs) { return new double3x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise addition.</param>
+        /// <returns>double3x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator + (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double3x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator + (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise addition.</param>
+        /// <returns>double3x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator + (double lhs, double3x2 rhs) { return new double3x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator - (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double3x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator - (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator - (double lhs, double3x2 rhs) { return new double3x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise division.</param>
+        /// <returns>double3x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator / (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double3x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator / (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise division.</param>
+        /// <returns>double3x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator / (double lhs, double3x2 rhs) { return new double3x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise modulus.</param>
+        /// <returns>double3x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator % (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double3x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator % (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise modulus.</param>
+        /// <returns>double3x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator % (double lhs, double3x2 rhs) { return new double3x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double3x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double3x2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator ++ (double3x2 val) { return new double3x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double3x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double3x2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator -- (double3x2 val) { return new double3x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise less than.</param>
+        /// <returns>bool3x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool3x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise less than.</param>
+        /// <returns>bool3x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator < (double lhs, double3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator <= (double lhs, double3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool3x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator > (double lhs, double3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator >= (double lhs, double3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double3x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double3x2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator - (double3x2 val) { return new double3x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double3x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double3x2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 operator + (double3x2 val) { return new double3x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise equality.</param>
+        /// <returns>bool3x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator == (double lhs, double3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double3x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double3x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x2 operator != (double lhs, double3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+
+        /// <summary>Returns the double3 element at a specified index.</summary>
+        unsafe public ref double3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (double3x2* array = &this) { return ref ((double3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double3x2 is equal to a given double3x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the double3x2 is equal to a given double3x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double3x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double3x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double3x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double3x2({0}, {1},  {2}, {3},  {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z);
+        }
+
+        /// <summary>Returns a string representation of the double3x2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double3x2({0}, {1},  {2}, {3},  {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double3x2 matrix constructed from two double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>double3x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(double3 c0, double3 c1) { return new double3x2(c0, c1); }
+
+        /// <summary>Returns a double3x2 matrix constructed from from 6 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <returns>double3x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(double m00, double m01,
+                                          double m10, double m11,
+                                          double m20, double m21)
+        {
+            return new double3x2(m00, m01,
+                                 m10, m11,
+                                 m20, m21);
+        }
+
+        /// <summary>Returns a double3x2 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(double v) { return new double3x2(v); }
+
+        /// <summary>Returns a double3x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(bool v) { return new double3x2(v); }
+
+        /// <summary>Return a double3x2 matrix constructed from a bool3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(bool3x2 v) { return new double3x2(v); }
+
+        /// <summary>Returns a double3x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(int v) { return new double3x2(v); }
+
+        /// <summary>Return a double3x2 matrix constructed from a int3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(int3x2 v) { return new double3x2(v); }
+
+        /// <summary>Returns a double3x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(uint v) { return new double3x2(v); }
+
+        /// <summary>Return a double3x2 matrix constructed from a uint3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(uint3x2 v) { return new double3x2(v); }
+
+        /// <summary>Returns a double3x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(float v) { return new double3x2(v); }
+
+        /// <summary>Return a double3x2 matrix constructed from a float3x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x2 to convert to double3x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x2 double3x2(float3x2 v) { return new double3x2(v); }
+
+        /// <summary>Return the double2x3 transpose of a double3x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x3 transpose(double3x2 v)
+        {
+            return double2x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z);
+        }
+
+        /// <summary>Returns a uint hash code of a double3x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double3x2 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint3(0xEE390C97u, 0x9C8A2F05u, 0x4DDC6509u) +
+                        fold_to_uint(v.c1) * uint3(0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u)) + 0xE857DCE1u;
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a double3x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(double3x2 v)
+        {
+            return (fold_to_uint(v.c0) * uint3(0xF62213C5u, 0x9CDAA959u, 0xAA269ABFu) +
+                    fold_to_uint(v.c1) * uint3(0xD54BA36Fu, 0xFD0847B9u, 0x8189A683u)) + 0xB139D651u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dbb081701c605492aa7bca8b0dcd80d7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x3.gen.cs

@@ -0,0 +1,697 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x3 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double3x3 : System.IEquatable<double3x3>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double3 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double3 c2;
+
+        /// <summary>double3x3 identity transform.</summary>
+        public static readonly double3x3 identity = new double3x3(1.0, 0.0, 0.0,   0.0, 1.0, 0.0,   0.0, 0.0, 1.0);
+
+        /// <summary>double3x3 zero value.</summary>
+        public static readonly double3x3 zero;
+
+        /// <summary>Constructs a double3x3 matrix from three double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(double3 c0, double3 c1, double3 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from 9 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(double m00, double m01, double m02,
+                         double m10, double m11, double m12,
+                         double m20, double m21, double m22)
+        {
+            this.c0 = new double3(m00, m10, m20);
+            this.c1 = new double3(m01, m11, m21);
+            this.c2 = new double3(m02, m12, m22);
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(bool v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c2 = math.select(new double3(0.0), new double3(1.0), v);
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a bool3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x3 to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(bool3x3 v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
+            this.c2 = math.select(new double3(0.0), new double3(1.0), v.c2);
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a int3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x3 to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(int3x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a uint3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x3 to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(uint3x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double3x3 matrix from a float3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x3 to convert to double3x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x3(float3x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double3x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(double v) { return new double3x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x3(bool v) { return new double3x3(v); }
+
+        /// <summary>Explicitly converts a bool3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x3(bool3x3 v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a single int value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(int v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a int3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(int3x3 v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(uint v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a uint3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(uint3x3 v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a single float value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(float v) { return new double3x3(v); }
+
+        /// <summary>Implicitly converts a float3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x3(float3x3 v) { return new double3x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator * (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double3x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator * (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator * (double lhs, double3x3 rhs) { return new double3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise addition.</param>
+        /// <returns>double3x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator + (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double3x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator + (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise addition.</param>
+        /// <returns>double3x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator + (double lhs, double3x3 rhs) { return new double3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator - (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double3x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator - (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator - (double lhs, double3x3 rhs) { return new double3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise division.</param>
+        /// <returns>double3x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator / (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double3x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator / (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise division.</param>
+        /// <returns>double3x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator / (double lhs, double3x3 rhs) { return new double3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise modulus.</param>
+        /// <returns>double3x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator % (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double3x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator % (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise modulus.</param>
+        /// <returns>double3x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator % (double lhs, double3x3 rhs) { return new double3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double3x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double3x3 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator ++ (double3x3 val) { return new double3x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double3x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double3x3 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator -- (double3x3 val) { return new double3x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise less than.</param>
+        /// <returns>bool3x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator < (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool3x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator < (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise less than.</param>
+        /// <returns>bool3x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator < (double lhs, double3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator <= (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator <= (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator <= (double lhs, double3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator > (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool3x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator > (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator > (double lhs, double3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator >= (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator >= (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator >= (double lhs, double3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double3x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double3x3 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator - (double3x3 val) { return new double3x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double3x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double3x3 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 operator + (double3x3 val) { return new double3x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise equality.</param>
+        /// <returns>bool3x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator == (double lhs, double3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double3x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double3x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x3 operator != (double lhs, double3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+
+        /// <summary>Returns the double3 element at a specified index.</summary>
+        unsafe public ref double3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (double3x3* array = &this) { return ref ((double3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double3x3 is equal to a given double3x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the double3x3 is equal to a given double3x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double3x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double3x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double3x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double3x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z);
+        }
+
+        /// <summary>Returns a string representation of the double3x3 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double3x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double3x3 matrix constructed from three double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>double3x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(double3 c0, double3 c1, double3 c2) { return new double3x3(c0, c1, c2); }
+
+        /// <summary>Returns a double3x3 matrix constructed from from 9 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <returns>double3x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(double m00, double m01, double m02,
+                                          double m10, double m11, double m12,
+                                          double m20, double m21, double m22)
+        {
+            return new double3x3(m00, m01, m02,
+                                 m10, m11, m12,
+                                 m20, m21, m22);
+        }
+
+        /// <summary>Returns a double3x3 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(double v) { return new double3x3(v); }
+
+        /// <summary>Returns a double3x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(bool v) { return new double3x3(v); }
+
+        /// <summary>Return a double3x3 matrix constructed from a bool3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(bool3x3 v) { return new double3x3(v); }
+
+        /// <summary>Returns a double3x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(int v) { return new double3x3(v); }
+
+        /// <summary>Return a double3x3 matrix constructed from a int3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(int3x3 v) { return new double3x3(v); }
+
+        /// <summary>Returns a double3x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(uint v) { return new double3x3(v); }
+
+        /// <summary>Return a double3x3 matrix constructed from a uint3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(uint3x3 v) { return new double3x3(v); }
+
+        /// <summary>Returns a double3x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(float v) { return new double3x3(v); }
+
+        /// <summary>Return a double3x3 matrix constructed from a float3x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x3 to convert to double3x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 double3x3(float3x3 v) { return new double3x3(v); }
+
+        /// <summary>Return the double3x3 transpose of a double3x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x3 transpose(double3x3 v)
+        {
+            return double3x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z,
+                v.c2.x, v.c2.y, v.c2.z);
+        }
+
+        /// <summary>Returns the double3x3 full inverse of a double3x3 matrix.</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        public static double3x3 inverse(double3x3 m)
+        {
+            double3 c0 = m.c0;
+            double3 c1 = m.c1;
+            double3 c2 = m.c2;
+
+            double3 t0 = double3(c1.x, c2.x, c0.x);
+            double3 t1 = double3(c1.y, c2.y, c0.y);
+            double3 t2 = double3(c1.z, c2.z, c0.z);
+
+            double3 m0 = t1 * t2.yzx - t1.yzx * t2;
+            double3 m1 = t0.yzx * t2 - t0 * t2.yzx;
+            double3 m2 = t0 * t1.yzx - t0.yzx * t1;
+
+            double rcpDet = 1.0 / csum(t0.zxy * m0);
+            return double3x3(m0, m1, m2) * rcpDet;
+        }
+
+        /// <summary>Returns the determinant of a double3x3 matrix.</summary>
+        /// <param name="m">Matrix to use when computing determinant.</param>
+        /// <returns>The determinant of the matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double determinant(double3x3 m)
+        {
+            double3 c0 = m.c0;
+            double3 c1 = m.c1;
+            double3 c2 = m.c2;
+
+            double m00 = c1.y * c2.z - c1.z * c2.y;
+            double m01 = c0.y * c2.z - c0.z * c2.y;
+            double m02 = c0.y * c1.z - c0.z * c1.y;
+
+            return c0.x * m00 - c1.x * m01 + c2.x * m02;
+        }
+
+        /// <summary>Returns a uint hash code of a double3x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double3x3 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint3(0xAC5DB57Bu, 0xA91A02EDu, 0xB3C49313u) +
+                        fold_to_uint(v.c1) * uint3(0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u) +
+                        fold_to_uint(v.c2) * uint3(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu)) + 0xEBD0D005u;
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a double3x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(double3x3 v)
+        {
+            return (fold_to_uint(v.c0) * uint3(0x91475DF7u, 0x55E84827u, 0x90A285BBu) +
+                    fold_to_uint(v.c1) * uint3(0x5D19E1D5u, 0xFAAF07DDu, 0x625C45BDu) +
+                    fold_to_uint(v.c2) * uint3(0xC9F27FCBu, 0x6D2523B1u, 0x6E2BF6A9u)) + 0xCC74B3B7u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f1e8e688d7f354f92a78d4d78697150d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x4.gen.cs

@@ -0,0 +1,699 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 3x4 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double3x4 : System.IEquatable<double3x4>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double3 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double3 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double3 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public double3 c3;
+
+        /// <summary>double3x4 zero value.</summary>
+        public static readonly double3x4 zero;
+
+        /// <summary>Constructs a double3x4 matrix from four double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(double3 c0, double3 c1, double3 c2, double3 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from 12 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(double m00, double m01, double m02, double m03,
+                         double m10, double m11, double m12, double m13,
+                         double m20, double m21, double m22, double m23)
+        {
+            this.c0 = new double3(m00, m10, m20);
+            this.c1 = new double3(m01, m11, m21);
+            this.c2 = new double3(m02, m12, m22);
+            this.c3 = new double3(m03, m13, m23);
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(bool v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c2 = math.select(new double3(0.0), new double3(1.0), v);
+            this.c3 = math.select(new double3(0.0), new double3(1.0), v);
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a bool3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x4 to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(bool3x4 v)
+        {
+            this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
+            this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
+            this.c2 = math.select(new double3(0.0), new double3(1.0), v.c2);
+            this.c3 = math.select(new double3(0.0), new double3(1.0), v.c3);
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a int3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x4 to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(int3x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a uint3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x4 to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(uint3x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double3x4 matrix from a float3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x4 to convert to double3x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double3x4(float3x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double3x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(double v) { return new double3x4(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x4(bool v) { return new double3x4(v); }
+
+        /// <summary>Explicitly converts a bool3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double3x4(bool3x4 v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a single int value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(int v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a int3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(int3x4 v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(uint v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a uint3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(uint3x4 v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a single float value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(float v) { return new double3x4(v); }
+
+        /// <summary>Implicitly converts a float3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double3x4(float3x4 v) { return new double3x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator * (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double3x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator * (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double3x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator * (double lhs, double3x4 rhs) { return new double3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise addition.</param>
+        /// <returns>double3x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator + (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double3x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator + (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise addition.</param>
+        /// <returns>double3x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator + (double lhs, double3x4 rhs) { return new double3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator - (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double3x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator - (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double3x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator - (double lhs, double3x4 rhs) { return new double3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise division.</param>
+        /// <returns>double3x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator / (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double3x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator / (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise division.</param>
+        /// <returns>double3x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator / (double lhs, double3x4 rhs) { return new double3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise modulus.</param>
+        /// <returns>double3x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator % (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double3x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator % (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise modulus.</param>
+        /// <returns>double3x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator % (double lhs, double3x4 rhs) { return new double3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double3x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double3x4 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator ++ (double3x4 val) { return new double3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double3x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double3x4 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator -- (double3x4 val) { return new double3x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise less than.</param>
+        /// <returns>bool3x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator < (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool3x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator < (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise less than.</param>
+        /// <returns>bool3x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator < (double lhs, double3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator <= (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator <= (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool3x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator <= (double lhs, double3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator > (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool3x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator > (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool3x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator > (double lhs, double3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator >= (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator >= (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool3x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator >= (double lhs, double3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double3x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double3x4 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator - (double3x4 val) { return new double3x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double3x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double3x4 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 operator + (double3x4 val) { return new double3x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise equality.</param>
+        /// <returns>bool3x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator == (double lhs, double3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double3x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double3x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double3x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double3x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool3x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool3x4 operator != (double lhs, double3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+
+        /// <summary>Returns the double3 element at a specified index.</summary>
+        unsafe public ref double3 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (double3x4* array = &this) { return ref ((double3*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double3x4 is equal to a given double3x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the double3x4 is equal to a given double3x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double3x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double3x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double3x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double3x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z);
+        }
+
+        /// <summary>Returns a string representation of the double3x4 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double3x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double3x4 matrix constructed from four double3 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>double3x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(double3 c0, double3 c1, double3 c2, double3 c3) { return new double3x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a double3x4 matrix constructed from from 12 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <returns>double3x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(double m00, double m01, double m02, double m03,
+                                          double m10, double m11, double m12, double m13,
+                                          double m20, double m21, double m22, double m23)
+        {
+            return new double3x4(m00, m01, m02, m03,
+                                 m10, m11, m12, m13,
+                                 m20, m21, m22, m23);
+        }
+
+        /// <summary>Returns a double3x4 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(double v) { return new double3x4(v); }
+
+        /// <summary>Returns a double3x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(bool v) { return new double3x4(v); }
+
+        /// <summary>Return a double3x4 matrix constructed from a bool3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(bool3x4 v) { return new double3x4(v); }
+
+        /// <summary>Returns a double3x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(int v) { return new double3x4(v); }
+
+        /// <summary>Return a double3x4 matrix constructed from a int3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(int3x4 v) { return new double3x4(v); }
+
+        /// <summary>Returns a double3x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(uint v) { return new double3x4(v); }
+
+        /// <summary>Return a double3x4 matrix constructed from a uint3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(uint3x4 v) { return new double3x4(v); }
+
+        /// <summary>Returns a double3x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(float v) { return new double3x4(v); }
+
+        /// <summary>Return a double3x4 matrix constructed from a float3x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float3x4 to convert to double3x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 double3x4(float3x4 v) { return new double3x4(v); }
+
+        /// <summary>Return the double4x3 transpose of a double3x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 transpose(double3x4 v)
+        {
+            return double4x3(
+                v.c0.x, v.c0.y, v.c0.z,
+                v.c1.x, v.c1.y, v.c1.z,
+                v.c2.x, v.c2.y, v.c2.z,
+                v.c3.x, v.c3.y, v.c3.z);
+        }
+
+        /// <summary>Fast matrix inverse for rigid transforms (orthonormal basis and translation)</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        public static double3x4 fastinverse(double3x4 m)
+        {
+            double3 c0 = m.c0;
+            double3 c1 = m.c1;
+            double3 c2 = m.c2;
+            double3 pos = m.c3;
+
+            double3 r0 = double3(c0.x, c1.x, c2.x);
+            double3 r1 = double3(c0.y, c1.y, c2.y);
+            double3 r2 = double3(c0.z, c1.z, c2.z);
+
+            pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
+
+            return double3x4(r0, r1, r2, pos);
+        }
+
+        /// <summary>Returns a uint hash code of a double3x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double3x4 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint3(0xEE390C97u, 0x9C8A2F05u, 0x4DDC6509u) +
+                        fold_to_uint(v.c1) * uint3(0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u) +
+                        fold_to_uint(v.c2) * uint3(0xE857DCE1u, 0xF62213C5u, 0x9CDAA959u) +
+                        fold_to_uint(v.c3) * uint3(0xAA269ABFu, 0xD54BA36Fu, 0xFD0847B9u)) + 0x8189A683u;
+        }
+
+        /// <summary>
+        /// Returns a uint3 vector hash code of a double3x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint3 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint3 hashwide(double3x4 v)
+        {
+            return (fold_to_uint(v.c0) * uint3(0xB139D651u, 0xE7579997u, 0xEF7D56C7u) +
+                    fold_to_uint(v.c1) * uint3(0x66F38F0Bu, 0x624256A3u, 0x5292ADE1u) +
+                    fold_to_uint(v.c2) * uint3(0xD2E590E5u, 0xF25BE857u, 0x9BC17CE7u) +
+                    fold_to_uint(v.c3) * uint3(0xC8B86851u, 0x64095221u, 0xADF428FFu)) + 0xA3977109u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double3x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 419ac95b4026548c39e12d2aa34922d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d041bf430fc14f4787b6f89d3326147
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x2.gen.cs

@@ -0,0 +1,639 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x2 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double4x2 : System.IEquatable<double4x2>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double4 c1;
+
+        /// <summary>double4x2 zero value.</summary>
+        public static readonly double4x2 zero;
+
+        /// <summary>Constructs a double4x2 matrix from two double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(double4 c0, double4 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from 8 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(double m00, double m01,
+                         double m10, double m11,
+                         double m20, double m21,
+                         double m30, double m31)
+        {
+            this.c0 = new double4(m00, m10, m20, m30);
+            this.c1 = new double4(m01, m11, m21, m31);
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(bool v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v);
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a bool4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x2 to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(bool4x2 v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a int4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x2 to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(int4x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a uint4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x2 to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(uint4x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a double4x2 matrix from a float4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x2 to convert to double4x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x2(float4x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double4x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(double v) { return new double4x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x2(bool v) { return new double4x2(v); }
+
+        /// <summary>Explicitly converts a bool4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x2(bool4x2 v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a single int value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(int v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a int4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(int4x2 v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(uint v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a uint4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(uint4x2 v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a single float value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(float v) { return new double4x2(v); }
+
+        /// <summary>Implicitly converts a float4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x2(float4x2 v) { return new double4x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator * (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double4x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator * (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator * (double lhs, double4x2 rhs) { return new double4x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise addition.</param>
+        /// <returns>double4x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator + (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double4x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator + (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise addition.</param>
+        /// <returns>double4x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator + (double lhs, double4x2 rhs) { return new double4x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator - (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double4x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator - (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator - (double lhs, double4x2 rhs) { return new double4x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise division.</param>
+        /// <returns>double4x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator / (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double4x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator / (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise division.</param>
+        /// <returns>double4x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator / (double lhs, double4x2 rhs) { return new double4x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise modulus.</param>
+        /// <returns>double4x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator % (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double4x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator % (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise modulus.</param>
+        /// <returns>double4x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator % (double lhs, double4x2 rhs) { return new double4x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double4x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double4x2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator ++ (double4x2 val) { return new double4x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double4x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double4x2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator -- (double4x2 val) { return new double4x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise less than.</param>
+        /// <returns>bool4x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool4x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise less than.</param>
+        /// <returns>bool4x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator < (double lhs, double4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator <= (double lhs, double4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool4x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator > (double lhs, double4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator >= (double lhs, double4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double4x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double4x2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator - (double4x2 val) { return new double4x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double4x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double4x2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 operator + (double4x2 val) { return new double4x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise equality.</param>
+        /// <returns>bool4x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator == (double lhs, double4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double4x2 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double4x2 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x2 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x2 operator != (double lhs, double4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+
+        /// <summary>Returns the double4 element at a specified index.</summary>
+        unsafe public ref double4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (double4x2* array = &this) { return ref ((double4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double4x2 is equal to a given double4x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the double4x2 is equal to a given double4x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double4x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double4x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double4x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double4x2({0}, {1},  {2}, {3},  {4}, {5},  {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w);
+        }
+
+        /// <summary>Returns a string representation of the double4x2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double4x2({0}, {1},  {2}, {3},  {4}, {5},  {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double4x2 matrix constructed from two double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>double4x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(double4 c0, double4 c1) { return new double4x2(c0, c1); }
+
+        /// <summary>Returns a double4x2 matrix constructed from from 8 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <returns>double4x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(double m00, double m01,
+                                          double m10, double m11,
+                                          double m20, double m21,
+                                          double m30, double m31)
+        {
+            return new double4x2(m00, m01,
+                                 m10, m11,
+                                 m20, m21,
+                                 m30, m31);
+        }
+
+        /// <summary>Returns a double4x2 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(double v) { return new double4x2(v); }
+
+        /// <summary>Returns a double4x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(bool v) { return new double4x2(v); }
+
+        /// <summary>Return a double4x2 matrix constructed from a bool4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(bool4x2 v) { return new double4x2(v); }
+
+        /// <summary>Returns a double4x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(int v) { return new double4x2(v); }
+
+        /// <summary>Return a double4x2 matrix constructed from a int4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(int4x2 v) { return new double4x2(v); }
+
+        /// <summary>Returns a double4x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(uint v) { return new double4x2(v); }
+
+        /// <summary>Return a double4x2 matrix constructed from a uint4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(uint4x2 v) { return new double4x2(v); }
+
+        /// <summary>Returns a double4x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(float v) { return new double4x2(v); }
+
+        /// <summary>Return a double4x2 matrix constructed from a float4x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x2 to convert to double4x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x2 double4x2(float4x2 v) { return new double4x2(v); }
+
+        /// <summary>Return the double2x4 transpose of a double4x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double2x4 transpose(double4x2 v)
+        {
+            return double2x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w);
+        }
+
+        /// <summary>Returns a uint hash code of a double4x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double4x2 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint4(0x5AB3E8CDu, 0x676E8407u, 0xB36DE767u, 0x6FCA387Du) +
+                        fold_to_uint(v.c1) * uint4(0xAF0F3103u, 0xE4A056C7u, 0x841D8225u, 0xC9393C7Du)) + 0xD42EAFA3u;
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a double4x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(double4x2 v)
+        {
+            return (fold_to_uint(v.c0) * uint4(0xD9AFD06Du, 0x97A65421u, 0x7809205Fu, 0x9C9F0823u) +
+                    fold_to_uint(v.c1) * uint4(0x5A9CA13Bu, 0xAFCDD5EFu, 0xA88D187Du, 0xCF6EBA1Du)) + 0x9D88E5A1u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2780651a7c8e8413da73612cb720fbac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x3.gen.cs

@@ -0,0 +1,665 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x3 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double4x3 : System.IEquatable<double4x3>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double4 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double4 c2;
+
+        /// <summary>double4x3 zero value.</summary>
+        public static readonly double4x3 zero;
+
+        /// <summary>Constructs a double4x3 matrix from three double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(double4 c0, double4 c1, double4 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from 12 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(double m00, double m01, double m02,
+                         double m10, double m11, double m12,
+                         double m20, double m21, double m22,
+                         double m30, double m31, double m32)
+        {
+            this.c0 = new double4(m00, m10, m20, m30);
+            this.c1 = new double4(m01, m11, m21, m31);
+            this.c2 = new double4(m02, m12, m22, m32);
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(bool v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c2 = math.select(new double4(0.0), new double4(1.0), v);
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a bool4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x3 to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(bool4x3 v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
+            this.c2 = math.select(new double4(0.0), new double4(1.0), v.c2);
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a int4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x3 to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(int4x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a uint4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x3 to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(uint4x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a double4x3 matrix from a float4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x3 to convert to double4x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x3(float4x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double4x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(double v) { return new double4x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x3(bool v) { return new double4x3(v); }
+
+        /// <summary>Explicitly converts a bool4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x3(bool4x3 v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a single int value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(int v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a int4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(int4x3 v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(uint v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a uint4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(uint4x3 v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a single float value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(float v) { return new double4x3(v); }
+
+        /// <summary>Implicitly converts a float4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x3(float4x3 v) { return new double4x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator * (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double4x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator * (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator * (double lhs, double4x3 rhs) { return new double4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise addition.</param>
+        /// <returns>double4x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator + (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double4x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator + (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise addition.</param>
+        /// <returns>double4x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator + (double lhs, double4x3 rhs) { return new double4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator - (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double4x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator - (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator - (double lhs, double4x3 rhs) { return new double4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise division.</param>
+        /// <returns>double4x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator / (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double4x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator / (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise division.</param>
+        /// <returns>double4x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator / (double lhs, double4x3 rhs) { return new double4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise modulus.</param>
+        /// <returns>double4x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator % (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double4x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator % (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise modulus.</param>
+        /// <returns>double4x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator % (double lhs, double4x3 rhs) { return new double4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double4x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double4x3 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator ++ (double4x3 val) { return new double4x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double4x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double4x3 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator -- (double4x3 val) { return new double4x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise less than.</param>
+        /// <returns>bool4x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator < (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool4x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator < (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise less than.</param>
+        /// <returns>bool4x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator < (double lhs, double4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator <= (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator <= (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator <= (double lhs, double4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator > (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool4x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator > (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator > (double lhs, double4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator >= (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator >= (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator >= (double lhs, double4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double4x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double4x3 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator - (double4x3 val) { return new double4x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double4x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double4x3 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 operator + (double4x3 val) { return new double4x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise equality.</param>
+        /// <returns>bool4x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator == (double lhs, double4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double4x3 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double4x3 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x3 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x3 operator != (double lhs, double4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+
+        /// <summary>Returns the double4 element at a specified index.</summary>
+        unsafe public ref double4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (double4x3* array = &this) { return ref ((double4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double4x3 is equal to a given double4x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the double4x3 is equal to a given double4x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double4x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double4x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double4x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double4x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8},  {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w);
+        }
+
+        /// <summary>Returns a string representation of the double4x3 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double4x3({0}, {1}, {2},  {3}, {4}, {5},  {6}, {7}, {8},  {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double4x3 matrix constructed from three double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>double4x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(double4 c0, double4 c1, double4 c2) { return new double4x3(c0, c1, c2); }
+
+        /// <summary>Returns a double4x3 matrix constructed from from 12 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <returns>double4x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(double m00, double m01, double m02,
+                                          double m10, double m11, double m12,
+                                          double m20, double m21, double m22,
+                                          double m30, double m31, double m32)
+        {
+            return new double4x3(m00, m01, m02,
+                                 m10, m11, m12,
+                                 m20, m21, m22,
+                                 m30, m31, m32);
+        }
+
+        /// <summary>Returns a double4x3 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(double v) { return new double4x3(v); }
+
+        /// <summary>Returns a double4x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(bool v) { return new double4x3(v); }
+
+        /// <summary>Return a double4x3 matrix constructed from a bool4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(bool4x3 v) { return new double4x3(v); }
+
+        /// <summary>Returns a double4x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(int v) { return new double4x3(v); }
+
+        /// <summary>Return a double4x3 matrix constructed from a int4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(int4x3 v) { return new double4x3(v); }
+
+        /// <summary>Returns a double4x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(uint v) { return new double4x3(v); }
+
+        /// <summary>Return a double4x3 matrix constructed from a uint4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(uint4x3 v) { return new double4x3(v); }
+
+        /// <summary>Returns a double4x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(float v) { return new double4x3(v); }
+
+        /// <summary>Return a double4x3 matrix constructed from a float4x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x3 to convert to double4x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x3 double4x3(float4x3 v) { return new double4x3(v); }
+
+        /// <summary>Return the double3x4 transpose of a double4x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3x4 transpose(double4x3 v)
+        {
+            return double3x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w,
+                v.c2.x, v.c2.y, v.c2.z, v.c2.w);
+        }
+
+        /// <summary>Returns a uint hash code of a double4x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double4x3 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint4(0x7AA07CD3u, 0xAF642BA9u, 0xA8F2213Bu, 0x9F3FDC37u) +
+                        fold_to_uint(v.c1) * uint4(0xAC60D0C3u, 0x9263662Fu, 0xE69626FFu, 0xBD010EEBu) +
+                        fold_to_uint(v.c2) * uint4(0x9CEDE1D1u, 0x43BE0B51u, 0xAF836EE1u, 0xB130C137u)) + 0x54834775u;
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a double4x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(double4x3 v)
+        {
+            return (fold_to_uint(v.c0) * uint4(0x7C022221u, 0xA2D00EDFu, 0xA8977779u, 0x9F1C739Bu) +
+                    fold_to_uint(v.c1) * uint4(0x4B1BD187u, 0x9DF50593u, 0xF18EEB85u, 0x9E19BFC3u) +
+                    fold_to_uint(v.c2) * uint4(0x8196B06Fu, 0xD24EFA19u, 0x7D8048BBu, 0x713BD06Fu)) + 0x753AD6ADu;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x3.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 673ff09d67f254e00a538d7bbb41618e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x4.gen.cs

@@ -0,0 +1,824 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 4x4 matrix of doubles.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct double4x4 : System.IEquatable<double4x4>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public double4 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public double4 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public double4 c2;
+        /// <summary>Column 3 of the matrix.</summary>
+        public double4 c3;
+
+        /// <summary>double4x4 identity transform.</summary>
+        public static readonly double4x4 identity = new double4x4(1.0, 0.0, 0.0, 0.0,   0.0, 1.0, 0.0, 0.0,   0.0, 0.0, 1.0, 0.0,   0.0, 0.0, 0.0, 1.0);
+
+        /// <summary>double4x4 zero value.</summary>
+        public static readonly double4x4 zero;
+
+        /// <summary>Constructs a double4x4 matrix from four double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(double4 c0, double4 c1, double4 c2, double4 c3)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+            this.c3 = c3;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from 16 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(double m00, double m01, double m02, double m03,
+                         double m10, double m11, double m12, double m13,
+                         double m20, double m21, double m22, double m23,
+                         double m30, double m31, double m32, double m33)
+        {
+            this.c0 = new double4(m00, m10, m20, m30);
+            this.c1 = new double4(m01, m11, m21, m31);
+            this.c2 = new double4(m02, m12, m22, m32);
+            this.c3 = new double4(m03, m13, m23, m33);
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(double v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(bool v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c2 = math.select(new double4(0.0), new double4(1.0), v);
+            this.c3 = math.select(new double4(0.0), new double4(1.0), v);
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a bool4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x4 to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(bool4x4 v)
+        {
+            this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
+            this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
+            this.c2 = math.select(new double4(0.0), new double4(1.0), v.c2);
+            this.c3 = math.select(new double4(0.0), new double4(1.0), v.c3);
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a int4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x4 to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(int4x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a uint4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x4 to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(uint4x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+            this.c3 = v;
+        }
+
+        /// <summary>Constructs a double4x4 matrix from a float4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x4 to convert to double4x4</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public double4x4(float4x4 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+            this.c3 = v.c3;
+        }
+
+
+        /// <summary>Implicitly converts a single double value to a double4x4 matrix by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(double v) { return new double4x4(v); }
+
+        /// <summary>Explicitly converts a single bool value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x4(bool v) { return new double4x4(v); }
+
+        /// <summary>Explicitly converts a bool4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator double4x4(bool4x4 v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a single int value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(int v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a int4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(int4x4 v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a single uint value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(uint v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a uint4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(uint4x4 v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a single float value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(float v) { return new double4x4(v); }
+
+        /// <summary>Implicitly converts a float4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator double4x4(float4x4 v) { return new double4x4(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator * (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise multiplication.</param>
+        /// <returns>double4x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator * (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise multiplication.</param>
+        /// <returns>double4x4 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator * (double lhs, double4x4 rhs) { return new double4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise addition.</param>
+        /// <returns>double4x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator + (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise addition.</param>
+        /// <returns>double4x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator + (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise addition.</param>
+        /// <returns>double4x4 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator + (double lhs, double4x4 rhs) { return new double4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator - (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise subtraction.</param>
+        /// <returns>double4x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator - (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise subtraction.</param>
+        /// <returns>double4x4 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator - (double lhs, double4x4 rhs) { return new double4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise division.</param>
+        /// <returns>double4x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator / (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise division.</param>
+        /// <returns>double4x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator / (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise division.</param>
+        /// <returns>double4x4 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator / (double lhs, double4x4 rhs) { return new double4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise modulus.</param>
+        /// <returns>double4x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator % (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise modulus.</param>
+        /// <returns>double4x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator % (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise modulus.</param>
+        /// <returns>double4x4 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator % (double lhs, double4x4 rhs) { return new double4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a double4x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>double4x4 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator ++ (double4x4 val) { return new double4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a double4x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>double4x4 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator -- (double4x4 val) { return new double4x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise less than.</param>
+        /// <returns>bool4x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator < (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less than.</param>
+        /// <returns>bool4x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator < (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise less than.</param>
+        /// <returns>bool4x4 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator < (double lhs, double4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator <= (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator <= (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise less or equal.</param>
+        /// <returns>bool4x4 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator <= (double lhs, double4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator > (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater than.</param>
+        /// <returns>bool4x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator > (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise greater than.</param>
+        /// <returns>bool4x4 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator > (double lhs, double4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator >= (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator >= (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool4x4 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator >= (double lhs, double4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a double4x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>double4x4 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator - (double4x4 val) { return new double4x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a double4x4 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>double4x4 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 operator + (double4x4 val) { return new double4x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise equality.</param>
+        /// <returns>bool4x4 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator == (double lhs, double4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two double4x4 matrices.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double4x4 matrix and a double value.</summary>
+        /// <param name="lhs">Left hand side double4x4 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x4 matrix.</summary>
+        /// <param name="lhs">Left hand side double to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side double4x4 to use to compute componentwise not equal.</param>
+        /// <returns>bool4x4 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool4x4 operator != (double lhs, double4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
+
+
+
+        /// <summary>Returns the double4 element at a specified index.</summary>
+        unsafe public ref double4 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 4)
+                    throw new System.ArgumentException("index must be between[0...3]");
+#endif
+                fixed (double4x4* array = &this) { return ref ((double4*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the double4x4 is equal to a given double4x4, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(double4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
+
+        /// <summary>Returns true if the double4x4 is equal to a given double4x4, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is double4x4 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the double4x4.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the double4x4.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("double4x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11},  {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w);
+        }
+
+        /// <summary>Returns a string representation of the double4x4 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("double4x4({0}, {1}, {2}, {3},  {4}, {5}, {6}, {7},  {8}, {9}, {10}, {11},  {12}, {13}, {14}, {15})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a double4x4 matrix constructed from four double4 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <param name="c3">The matrix column c3 will be set to this value.</param>
+        /// <returns>double4x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(double4 c0, double4 c1, double4 c2, double4 c3) { return new double4x4(c0, c1, c2, c3); }
+
+        /// <summary>Returns a double4x4 matrix constructed from from 16 double values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m03">The matrix at row 0, column 3 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <param name="m13">The matrix at row 1, column 3 will be set to this value.</param>
+        /// <param name="m20">The matrix at row 2, column 0 will be set to this value.</param>
+        /// <param name="m21">The matrix at row 2, column 1 will be set to this value.</param>
+        /// <param name="m22">The matrix at row 2, column 2 will be set to this value.</param>
+        /// <param name="m23">The matrix at row 2, column 3 will be set to this value.</param>
+        /// <param name="m30">The matrix at row 3, column 0 will be set to this value.</param>
+        /// <param name="m31">The matrix at row 3, column 1 will be set to this value.</param>
+        /// <param name="m32">The matrix at row 3, column 2 will be set to this value.</param>
+        /// <param name="m33">The matrix at row 3, column 3 will be set to this value.</param>
+        /// <returns>double4x4 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(double m00, double m01, double m02, double m03,
+                                          double m10, double m11, double m12, double m13,
+                                          double m20, double m21, double m22, double m23,
+                                          double m30, double m31, double m32, double m33)
+        {
+            return new double4x4(m00, m01, m02, m03,
+                                 m10, m11, m12, m13,
+                                 m20, m21, m22, m23,
+                                 m30, m31, m32, m33);
+        }
+
+        /// <summary>Returns a double4x4 matrix constructed from a single double value by assigning it to every component.</summary>
+        /// <param name="v">double to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(double v) { return new double4x4(v); }
+
+        /// <summary>Returns a double4x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(bool v) { return new double4x4(v); }
+
+        /// <summary>Return a double4x4 matrix constructed from a bool4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(bool4x4 v) { return new double4x4(v); }
+
+        /// <summary>Returns a double4x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">int to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(int v) { return new double4x4(v); }
+
+        /// <summary>Return a double4x4 matrix constructed from a int4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">int4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(int4x4 v) { return new double4x4(v); }
+
+        /// <summary>Returns a double4x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(uint v) { return new double4x4(v); }
+
+        /// <summary>Return a double4x4 matrix constructed from a uint4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(uint4x4 v) { return new double4x4(v); }
+
+        /// <summary>Returns a double4x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
+        /// <param name="v">float to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(float v) { return new double4x4(v); }
+
+        /// <summary>Return a double4x4 matrix constructed from a float4x4 matrix by componentwise conversion.</summary>
+        /// <param name="v">float4x4 to convert to double4x4</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 double4x4(float4x4 v) { return new double4x4(v); }
+
+        /// <summary>Return the result of rotating a double3 vector by a double4x4 matrix</summary>
+        /// <param name ="a">Left hand side matrix argument that specifies the rotation.</param>
+        /// <param name ="b">Right hand side vector argument to be rotated.</param>
+        /// <returns>The rotated vector.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3 rotate(double4x4 a, double3 b)
+        {
+            return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z).xyz;
+        }
+
+        /// <summary>Return the result of transforming a double3 point by a double4x4 matrix</summary>
+        /// <param name ="a">Left hand side matrix argument that specifies the transformation.</param>
+        /// <param name ="b">Right hand side point argument to be transformed.</param>
+        /// <returns>The transformed point.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double3 transform(double4x4 a, double3 b)
+        {
+            return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3).xyz;
+        }
+
+        /// <summary>Return the double4x4 transpose of a double4x4 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static double4x4 transpose(double4x4 v)
+        {
+            return double4x4(
+                v.c0.x, v.c0.y, v.c0.z, v.c0.w,
+                v.c1.x, v.c1.y, v.c1.z, v.c1.w,
+                v.c2.x, v.c2.y, v.c2.z, v.c2.w,
+                v.c3.x, v.c3.y, v.c3.z, v.c3.w);
+        }
+
+        /// <summary>Returns the double4x4 full inverse of a double4x4 matrix.</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        public static double4x4 inverse(double4x4 m)
+        {
+            double4 c0 = m.c0;
+            double4 c1 = m.c1;
+            double4 c2 = m.c2;
+            double4 c3 = m.c3;
+
+            double4 r0y_r1y_r0x_r1x = movelh(c1, c0);
+            double4 r0z_r1z_r0w_r1w = movelh(c2, c3);
+            double4 r2y_r3y_r2x_r3x = movehl(c0, c1);
+            double4 r2z_r3z_r2w_r3w = movehl(c3, c2);
+
+            double4 r1y_r2y_r1x_r2x = shuffle(c1, c0, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
+            double4 r1z_r2z_r1w_r2w = shuffle(c2, c3, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
+            double4 r3y_r0y_r3x_r0x = shuffle(c1, c0, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
+            double4 r3z_r0z_r3w_r0w = shuffle(c2, c3, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
+
+            double4 r0_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
+            double4 r1_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
+            double4 r2_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
+            double4 r3_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
+            double4 r0_xyzw = shuffle(r0y_r1y_r0x_r1x, r0z_r1z_r0w_r1w, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
+
+            // Calculate remaining inner term pairs. inner terms have zw=-xy, so we only have to calculate xy and can pack two pairs per vector.
+            double4 inner12_23 = r1y_r2y_r1x_r2x * r2z_r3z_r2w_r3w - r1z_r2z_r1w_r2w * r2y_r3y_r2x_r3x;
+            double4 inner02_13 = r0y_r1y_r0x_r1x * r2z_r3z_r2w_r3w - r0z_r1z_r0w_r1w * r2y_r3y_r2x_r3x;
+            double4 inner30_01 = r3z_r0z_r3w_r0w * r0y_r1y_r0x_r1x - r3y_r0y_r3x_r0x * r0z_r1z_r0w_r1w;
+
+            // Expand inner terms back to 4 components. zw signs still need to be flipped
+            double4 inner12 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
+            double4 inner23 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
+
+            double4 inner02 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
+            double4 inner13 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
+
+            // Calculate minors
+            double4 minors0 = r3_wzyx * inner12 - r2_wzyx * inner13 + r1_wzyx * inner23;
+
+            double4 denom = r0_xyzw * minors0;
+
+            // Horizontal sum of denominator. Free sign flip of z and w compensates for missing flip in inner terms.
+            denom = denom + shuffle(denom, denom, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightZ);   // x+y        x+y            z+w            z+w
+            denom = denom - shuffle(denom, denom, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightX);   // x+y-z-w  x+y-z-w        z+w-x-y        z+w-x-y
+
+            double4 rcp_denom_ppnn = double4(1.0) / denom;
+            double4x4 res;
+            res.c0 = minors0 * rcp_denom_ppnn;
+
+            double4 inner30 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
+            double4 inner01 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
+
+            double4 minors1 = r2_wzyx * inner30 - r0_wzyx * inner23 - r3_wzyx * inner02;
+            res.c1 = minors1 * rcp_denom_ppnn;
+
+            double4 minors2 = r0_wzyx * inner13 - r1_wzyx * inner30 - r3_wzyx * inner01;
+            res.c2 = minors2 * rcp_denom_ppnn;
+
+            double4 minors3 = r1_wzyx * inner02 - r0_wzyx * inner12 + r2_wzyx * inner01;
+            res.c3 = minors3 * rcp_denom_ppnn;
+            return res;
+        }
+
+        /// <summary>Fast matrix inverse for rigid transforms (orthonormal basis and translation)</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        public static double4x4 fastinverse(double4x4 m)
+        {
+            double4 c0 = m.c0;
+            double4 c1 = m.c1;
+            double4 c2 = m.c2;
+            double4 pos = m.c3;
+
+            double4 zero = double4(0);
+
+            double4 t0 = unpacklo(c0, c2);
+            double4 t1 = unpacklo(c1, zero);
+            double4 t2 = unpackhi(c0, c2);
+            double4 t3 = unpackhi(c1, zero);
+
+            double4 r0 = unpacklo(t0, t1);
+            double4 r1 = unpackhi(t0, t1);
+            double4 r2 = unpacklo(t2, t3);
+
+            pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
+            pos.w = 1.0f;
+
+            return double4x4(r0, r1, r2, pos);
+        }
+
+        /// <summary>Returns the determinant of a double4x4 matrix.</summary>
+        /// <param name="m">Matrix to use when computing determinant.</param>
+        /// <returns>The determinant of the matrix.</returns>
+        public static double determinant(double4x4 m)
+        {
+            double4 c0 = m.c0;
+            double4 c1 = m.c1;
+            double4 c2 = m.c2;
+            double4 c3 = m.c3;
+
+            double m00 = c1.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c1.z * c3.w - c1.w * c3.z) + c3.y * (c1.z * c2.w - c1.w * c2.z);
+            double m01 = c0.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c2.w - c0.w * c2.z);
+            double m02 = c0.y * (c1.z * c3.w - c1.w * c3.z) - c1.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c1.w - c0.w * c1.z);
+            double m03 = c0.y * (c1.z * c2.w - c1.w * c2.z) - c1.y * (c0.z * c2.w - c0.w * c2.z) + c2.y * (c0.z * c1.w - c0.w * c1.z);
+
+            return c0.x * m00 - c1.x * m01 + c2.x * m02 - c3.x * m03;
+        }
+
+        /// <summary>Returns a uint hash code of a double4x4 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(double4x4 v)
+        {
+            return csum(fold_to_uint(v.c0) * uint4(0x4DDC6509u, 0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u) +
+                        fold_to_uint(v.c1) * uint4(0xE857DCE1u, 0xF62213C5u, 0x9CDAA959u, 0xAA269ABFu) +
+                        fold_to_uint(v.c2) * uint4(0xD54BA36Fu, 0xFD0847B9u, 0x8189A683u, 0xB139D651u) +
+                        fold_to_uint(v.c3) * uint4(0xE7579997u, 0xEF7D56C7u, 0x66F38F0Bu, 0x624256A3u)) + 0x5292ADE1u;
+        }
+
+        /// <summary>
+        /// Returns a uint4 vector hash code of a double4x4 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint4 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(double4x4 v)
+        {
+            return (fold_to_uint(v.c0) * uint4(0xD2E590E5u, 0xF25BE857u, 0x9BC17CE7u, 0xC8B86851u) +
+                    fold_to_uint(v.c1) * uint4(0x64095221u, 0xADF428FFu, 0xA3977109u, 0x745ED837u) +
+                    fold_to_uint(v.c2) * uint4(0x9CDC88F5u, 0xFA62D721u, 0x7E4DB1CFu, 0x68EEE0F5u) +
+                    fold_to_uint(v.c3) * uint4(0xBC3B0A59u, 0x816EFB5Du, 0xA24E82B7u, 0x45A22087u)) + 0xFC104C3Bu;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/double4x4.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e000b5ccaea0345d8b4686220f3307ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/float2.gen.cs

@@ -0,0 +1,998 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using System.Diagnostics;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2 component vector of floats.</summary>
+    [DebuggerTypeProxy(typeof(float2.DebuggerProxy))]
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct float2 : System.IEquatable<float2>, IFormattable
+    {
+        /// <summary>x component of the vector.</summary>
+        public float x;
+        /// <summary>y component of the vector.</summary>
+        public float y;
+
+        /// <summary>float2 zero value.</summary>
+        public static readonly float2 zero;
+
+        /// <summary>Constructs a float2 vector from two float values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(float x, float y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        /// <summary>Constructs a float2 vector from a float2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(float2 xy)
+        {
+            this.x = xy.x;
+            this.y = xy.y;
+        }
+
+        /// <summary>Constructs a float2 vector from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(float v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a float2 vector from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(bool v)
+        {
+            this.x = v ? 1.0f : 0.0f;
+            this.y = v ? 1.0f : 0.0f;
+        }
+
+        /// <summary>Constructs a float2 vector from a bool2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(bool2 v)
+        {
+            this.x = v.x ? 1.0f : 0.0f;
+            this.y = v.y ? 1.0f : 0.0f;
+        }
+
+        /// <summary>Constructs a float2 vector from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(int v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a float2 vector from a int2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(int2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a float2 vector from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(uint v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a float2 vector from a uint2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(uint2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a float2 vector from a single half value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">half to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(half v)
+        {
+            this.x = v;
+            this.y = v;
+        }
+
+        /// <summary>Constructs a float2 vector from a half2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(half2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
+        /// <summary>Constructs a float2 vector from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(double v)
+        {
+            this.x = (float)v;
+            this.y = (float)v;
+        }
+
+        /// <summary>Constructs a float2 vector from a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">double2 to convert to float2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2(double2 v)
+        {
+            this.x = (float)v.x;
+            this.y = (float)v.y;
+        }
+
+
+        /// <summary>Implicitly converts a single float value to a float2 vector by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(float v) { return new float2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a float2 vector by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2(bool v) { return new float2(v); }
+
+        /// <summary>Explicitly converts a bool2 vector to a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2(bool2 v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a single int value to a float2 vector by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(int v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a int2 vector to a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(int2 v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a float2 vector by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(uint v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a uint2 vector to a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(uint2 v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a single half value to a float2 vector by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">half to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(half v) { return new float2(v); }
+
+        /// <summary>Implicitly converts a half2 vector to a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2(half2 v) { return new float2(v); }
+
+        /// <summary>Explicitly converts a single double value to a float2 vector by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2(double v) { return new float2(v); }
+
+        /// <summary>Explicitly converts a double2 vector to a float2 vector by componentwise conversion.</summary>
+        /// <param name="v">double2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2(double2 v) { return new float2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise multiplication.</param>
+        /// <returns>float2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator * (float2 lhs, float2 rhs) { return new float2 (lhs.x * rhs.x, lhs.y * rhs.y); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise multiplication.</param>
+        /// <returns>float2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator * (float2 lhs, float rhs) { return new float2 (lhs.x * rhs, lhs.y * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise multiplication.</param>
+        /// <returns>float2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator * (float lhs, float2 rhs) { return new float2 (lhs * rhs.x, lhs * rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise addition.</param>
+        /// <returns>float2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator + (float2 lhs, float2 rhs) { return new float2 (lhs.x + rhs.x, lhs.y + rhs.y); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise addition.</param>
+        /// <returns>float2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator + (float2 lhs, float rhs) { return new float2 (lhs.x + rhs, lhs.y + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise addition.</param>
+        /// <returns>float2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator + (float lhs, float2 rhs) { return new float2 (lhs + rhs.x, lhs + rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise subtraction.</param>
+        /// <returns>float2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator - (float2 lhs, float2 rhs) { return new float2 (lhs.x - rhs.x, lhs.y - rhs.y); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise subtraction.</param>
+        /// <returns>float2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator - (float2 lhs, float rhs) { return new float2 (lhs.x - rhs, lhs.y - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise subtraction.</param>
+        /// <returns>float2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator - (float lhs, float2 rhs) { return new float2 (lhs - rhs.x, lhs - rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise division.</param>
+        /// <returns>float2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator / (float2 lhs, float2 rhs) { return new float2 (lhs.x / rhs.x, lhs.y / rhs.y); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise division.</param>
+        /// <returns>float2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator / (float2 lhs, float rhs) { return new float2 (lhs.x / rhs, lhs.y / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise division.</param>
+        /// <returns>float2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator / (float lhs, float2 rhs) { return new float2 (lhs / rhs.x, lhs / rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise modulus.</param>
+        /// <returns>float2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator % (float2 lhs, float2 rhs) { return new float2 (lhs.x % rhs.x, lhs.y % rhs.y); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise modulus.</param>
+        /// <returns>float2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator % (float2 lhs, float rhs) { return new float2 (lhs.x % rhs, lhs.y % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise modulus.</param>
+        /// <returns>float2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator % (float lhs, float2 rhs) { return new float2 (lhs % rhs.x, lhs % rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a float2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>float2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator ++ (float2 val) { return new float2 (++val.x, ++val.y); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a float2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>float2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator -- (float2 val) { return new float2 (--val.x, --val.y); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (float2 lhs, float2 rhs) { return new bool2 (lhs.x < rhs.x, lhs.y < rhs.y); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (float2 lhs, float rhs) { return new bool2 (lhs.x < rhs, lhs.y < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise less than.</param>
+        /// <returns>bool2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator < (float lhs, float2 rhs) { return new bool2 (lhs < rhs.x, lhs < rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (float2 lhs, float2 rhs) { return new bool2 (lhs.x <= rhs.x, lhs.y <= rhs.y); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (float2 lhs, float rhs) { return new bool2 (lhs.x <= rhs, lhs.y <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator <= (float lhs, float2 rhs) { return new bool2 (lhs <= rhs.x, lhs <= rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (float2 lhs, float2 rhs) { return new bool2 (lhs.x > rhs.x, lhs.y > rhs.y); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (float2 lhs, float rhs) { return new bool2 (lhs.x > rhs, lhs.y > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator > (float lhs, float2 rhs) { return new bool2 (lhs > rhs.x, lhs > rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (float2 lhs, float2 rhs) { return new bool2 (lhs.x >= rhs.x, lhs.y >= rhs.y); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (float2 lhs, float rhs) { return new bool2 (lhs.x >= rhs, lhs.y >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator >= (float lhs, float2 rhs) { return new bool2 (lhs >= rhs.x, lhs >= rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a float2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>float2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator - (float2 val) { return new float2 (-val.x, -val.y); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a float2 vector.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>float2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 operator + (float2 val) { return new float2 (+val.x, +val.y); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (float2 lhs, float2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (float2 lhs, float rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise equality.</param>
+        /// <returns>bool2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator == (float lhs, float2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two float2 vectors.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (float2 lhs, float2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float2 vector and a float value.</summary>
+        /// <param name="lhs">Left hand side float2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (float2 lhs, float rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float value and a float2 vector.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2 operator != (float lhs, float2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
+
+
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 xyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(x, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yxxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yxxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yxyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yxyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yyxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yyxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yyyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float4 yyyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float4(y, y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 xxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(x, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 xxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(x, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 xyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(x, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 xyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(x, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 yxx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(y, x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 yxy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(y, x, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 yyx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(y, y, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float3 yyy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float3(y, y, y); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float2 xx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float2(x, x); }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float2 xy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float2(x, y); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { x = value.x; y = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float2 yx
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float2(y, x); }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set { y = value.x; x = value.y; }
+        }
+
+
+        /// <summary>Swizzles the vector.</summary>
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public float2 yy
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return new float2(y, y); }
+        }
+
+
+
+        /// <summary>Returns the float element at a specified index.</summary>
+        unsafe public float this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (float2* array = &this) { return ((float*)array)[index]; }
+            }
+            set
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (float* array = &x) { array[index] = value; }
+            }
+        }
+
+        /// <summary>Returns true if the float2 is equal to a given float2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(float2 rhs) { return x == rhs.x && y == rhs.y; }
+
+        /// <summary>Returns true if the float2 is equal to a given float2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is float2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the float2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the float2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("float2({0}f, {1}f)", x, y);
+        }
+
+        /// <summary>Returns a string representation of the float2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("float2({0}f, {1}f)", x.ToString(format, formatProvider), y.ToString(format, formatProvider));
+        }
+
+        internal sealed class DebuggerProxy
+        {
+            public float x;
+            public float y;
+            public DebuggerProxy(float2 v)
+            {
+                x = v.x;
+                y = v.y;
+            }
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a float2 vector constructed from two float values.</summary>
+        /// <param name="x">The constructed vector's x component will be set to this value.</param>
+        /// <param name="y">The constructed vector's y component will be set to this value.</param>
+        /// <returns>float2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(float x, float y) { return new float2(x, y); }
+
+        /// <summary>Returns a float2 vector constructed from a float2 vector.</summary>
+        /// <param name="xy">The constructed vector's xy components will be set to this value.</param>
+        /// <returns>float2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(float2 xy) { return new float2(xy); }
+
+        /// <summary>Returns a float2 vector constructed from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(float v) { return new float2(v); }
+
+        /// <summary>Returns a float2 vector constructed from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(bool v) { return new float2(v); }
+
+        /// <summary>Return a float2 vector constructed from a bool2 vector by componentwise conversion.</summary>
+        /// <param name="v">bool2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(bool2 v) { return new float2(v); }
+
+        /// <summary>Returns a float2 vector constructed from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(int v) { return new float2(v); }
+
+        /// <summary>Return a float2 vector constructed from a int2 vector by componentwise conversion.</summary>
+        /// <param name="v">int2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(int2 v) { return new float2(v); }
+
+        /// <summary>Returns a float2 vector constructed from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(uint v) { return new float2(v); }
+
+        /// <summary>Return a float2 vector constructed from a uint2 vector by componentwise conversion.</summary>
+        /// <param name="v">uint2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(uint2 v) { return new float2(v); }
+
+        /// <summary>Returns a float2 vector constructed from a single half value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">half to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(half v) { return new float2(v); }
+
+        /// <summary>Return a float2 vector constructed from a half2 vector by componentwise conversion.</summary>
+        /// <param name="v">half2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(half2 v) { return new float2(v); }
+
+        /// <summary>Returns a float2 vector constructed from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(double v) { return new float2(v); }
+
+        /// <summary>Return a float2 vector constructed from a double2 vector by componentwise conversion.</summary>
+        /// <param name="v">double2 to convert to float2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 float2(double2 v) { return new float2(v); }
+
+        /// <summary>Returns a uint hash code of a float2 vector.</summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(float2 v)
+        {
+            return csum(asuint(v) * uint2(0xFA3A3285u, 0xAD55999Du)) + 0xDCDD5341u;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a float2 vector.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Vector value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(float2 v)
+        {
+            return (asuint(v) * uint2(0x94DDD769u, 0xA1E92D39u)) + 0x4583C801u;
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float value.</summary>
+        /// <param name="left">float2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">float2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting float.</param>
+        /// <returns>float result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float shuffle(float2 left, float2 right, ShuffleComponent x)
+        {
+            return select_shuffle_component(left, right, x);
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float2 vector.</summary>
+        /// <param name="left">float2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">float2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting float2 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting float2 y component.</param>
+        /// <returns>float2 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y)
+        {
+            return float2(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float3 vector.</summary>
+        /// <param name="left">float2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">float2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting float3 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting float3 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting float3 z component.</param>
+        /// <returns>float3 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
+        {
+            return float3(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z));
+        }
+
+        /// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float4 vector.</summary>
+        /// <param name="left">float2 to use as the left argument of the shuffle operation.</param>
+        /// <param name="right">float2 to use as the right argument of the shuffle operation.</param>
+        /// <param name="x">The ShuffleComponent to use when setting the resulting float4 x component.</param>
+        /// <param name="y">The ShuffleComponent to use when setting the resulting float4 y component.</param>
+        /// <param name="z">The ShuffleComponent to use when setting the resulting float4 z component.</param>
+        /// <param name="w">The ShuffleComponent to use when setting the resulting float4 w component.</param>
+        /// <returns>float4 result of the shuffle operation.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4 shuffle(float2 left, float2 right, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
+        {
+            return float4(
+                select_shuffle_component(left, right, x),
+                select_shuffle_component(left, right, y),
+                select_shuffle_component(left, right, z),
+                select_shuffle_component(left, right, w));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static float select_shuffle_component(float2 a, float2 b, ShuffleComponent component)
+        {
+            switch(component)
+            {
+                case ShuffleComponent.LeftX:
+                    return a.x;
+                case ShuffleComponent.LeftY:
+                    return a.y;
+                case ShuffleComponent.RightX:
+                    return b.x;
+                case ShuffleComponent.RightY:
+                    return b.y;
+                default:
+                    throw new System.ArgumentException("Invalid shuffle component: " + component);
+            }
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/float2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4319f4482dc5b5b44a7f99c8725ef211
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/float2x2.gen.cs

@@ -0,0 +1,658 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x2 matrix of floats.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct float2x2 : System.IEquatable<float2x2>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public float2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public float2 c1;
+
+        /// <summary>float2x2 identity transform.</summary>
+        public static readonly float2x2 identity = new float2x2(1.0f, 0.0f,   0.0f, 1.0f);
+
+        /// <summary>float2x2 zero value.</summary>
+        public static readonly float2x2 zero;
+
+        /// <summary>Constructs a float2x2 matrix from two float2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(float2 c0, float2 c1)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from 4 float values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(float m00, float m01,
+                        float m10, float m11)
+        {
+            this.c0 = new float2(m00, m10);
+            this.c1 = new float2(m01, m11);
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(bool v)
+        {
+            this.c0 = math.select(new float2(0.0f), new float2(1.0f), v);
+            this.c1 = math.select(new float2(0.0f), new float2(1.0f), v);
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a bool2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(bool2x2 v)
+        {
+            this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0);
+            this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1);
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a int2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(int2x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a uint2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(uint2x2 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(double v)
+        {
+            this.c0 = (float2)v;
+            this.c1 = (float2)v;
+        }
+
+        /// <summary>Constructs a float2x2 matrix from a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x2 to convert to float2x2</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x2(double2x2 v)
+        {
+            this.c0 = (float2)v.c0;
+            this.c1 = (float2)v.c1;
+        }
+
+
+        /// <summary>Implicitly converts a single float value to a float2x2 matrix by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x2(float v) { return new float2x2(v); }
+
+        /// <summary>Explicitly converts a single bool value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x2(bool v) { return new float2x2(v); }
+
+        /// <summary>Explicitly converts a bool2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x2(bool2x2 v) { return new float2x2(v); }
+
+        /// <summary>Implicitly converts a single int value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x2(int v) { return new float2x2(v); }
+
+        /// <summary>Implicitly converts a int2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x2(int2x2 v) { return new float2x2(v); }
+
+        /// <summary>Implicitly converts a single uint value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x2(uint v) { return new float2x2(v); }
+
+        /// <summary>Implicitly converts a uint2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x2(uint2x2 v) { return new float2x2(v); }
+
+        /// <summary>Explicitly converts a single double value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x2(double v) { return new float2x2(v); }
+
+        /// <summary>Explicitly converts a double2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x2(double2x2 v) { return new float2x2(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise multiplication.</param>
+        /// <returns>float2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator * (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise multiplication.</param>
+        /// <returns>float2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator * (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise multiplication.</param>
+        /// <returns>float2x2 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator * (float lhs, float2x2 rhs) { return new float2x2 (lhs * rhs.c0, lhs * rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise addition.</param>
+        /// <returns>float2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator + (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise addition.</param>
+        /// <returns>float2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator + (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise addition.</param>
+        /// <returns>float2x2 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator + (float lhs, float2x2 rhs) { return new float2x2 (lhs + rhs.c0, lhs + rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise subtraction.</param>
+        /// <returns>float2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator - (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise subtraction.</param>
+        /// <returns>float2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator - (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise subtraction.</param>
+        /// <returns>float2x2 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator - (float lhs, float2x2 rhs) { return new float2x2 (lhs - rhs.c0, lhs - rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise division.</param>
+        /// <returns>float2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator / (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise division.</param>
+        /// <returns>float2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator / (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise division.</param>
+        /// <returns>float2x2 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator / (float lhs, float2x2 rhs) { return new float2x2 (lhs / rhs.c0, lhs / rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise modulus.</param>
+        /// <returns>float2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator % (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise modulus.</param>
+        /// <returns>float2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator % (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise modulus.</param>
+        /// <returns>float2x2 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator % (float lhs, float2x2 rhs) { return new float2x2 (lhs % rhs.c0, lhs % rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a float2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>float2x2 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator ++ (float2x2 val) { return new float2x2 (++val.c0, ++val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a float2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>float2x2 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator -- (float2x2 val) { return new float2x2 (--val.c0, --val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise less than.</param>
+        /// <returns>bool2x2 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator < (float lhs, float2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x2 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator <= (float lhs, float2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x2 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator > (float lhs, float2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x2 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator >= (float lhs, float2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a float2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>float2x2 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator - (float2x2 val) { return new float2x2 (-val.c0, -val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a float2x2 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>float2x2 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 operator + (float2x2 val) { return new float2x2 (+val.c0, +val.c1); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise equality.</param>
+        /// <returns>bool2x2 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator == (float lhs, float2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two float2x2 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float2x2 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x2 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float value and a float2x2 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2x2 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x2 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x2 operator != (float lhs, float2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
+
+
+
+        /// <summary>Returns the float2 element at a specified index.</summary>
+        unsafe public ref float2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 2)
+                    throw new System.ArgumentException("index must be between[0...1]");
+#endif
+                fixed (float2x2* array = &this) { return ref ((float2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the float2x2 is equal to a given float2x2, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(float2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
+
+        /// <summary>Returns true if the float2x2 is equal to a given float2x2, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is float2x2 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the float2x2.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the float2x2.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("float2x2({0}f, {1}f,  {2}f, {3}f)", c0.x, c1.x, c0.y, c1.y);
+        }
+
+        /// <summary>Returns a string representation of the float2x2 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("float2x2({0}f, {1}f,  {2}f, {3}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a float2x2 matrix constructed from two float2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <returns>float2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(float2 c0, float2 c1) { return new float2x2(c0, c1); }
+
+        /// <summary>Returns a float2x2 matrix constructed from from 4 float values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <returns>float2x2 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(float m00, float m01,
+                                        float m10, float m11)
+        {
+            return new float2x2(m00, m01,
+                                m10, m11);
+        }
+
+        /// <summary>Returns a float2x2 matrix constructed from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(float v) { return new float2x2(v); }
+
+        /// <summary>Returns a float2x2 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(bool v) { return new float2x2(v); }
+
+        /// <summary>Return a float2x2 matrix constructed from a bool2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(bool2x2 v) { return new float2x2(v); }
+
+        /// <summary>Returns a float2x2 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(int v) { return new float2x2(v); }
+
+        /// <summary>Return a float2x2 matrix constructed from a int2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(int2x2 v) { return new float2x2(v); }
+
+        /// <summary>Returns a float2x2 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(uint v) { return new float2x2(v); }
+
+        /// <summary>Return a float2x2 matrix constructed from a uint2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(uint2x2 v) { return new float2x2(v); }
+
+        /// <summary>Returns a float2x2 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(double v) { return new float2x2(v); }
+
+        /// <summary>Return a float2x2 matrix constructed from a double2x2 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x2 to convert to float2x2</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 float2x2(double2x2 v) { return new float2x2(v); }
+
+        /// <summary>Return the float2x2 transpose of a float2x2 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 transpose(float2x2 v)
+        {
+            return float2x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y);
+        }
+
+        /// <summary>Returns the float2x2 full inverse of a float2x2 matrix.</summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The inverted matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x2 inverse(float2x2 m)
+        {
+            float a = m.c0.x;
+            float b = m.c1.x;
+            float c = m.c0.y;
+            float d = m.c1.y;
+
+            float det = a * d - b * c;
+
+            return float2x2(d, -b, -c, a) * (1.0f / det);
+        }
+
+        /// <summary>Returns the determinant of a float2x2 matrix.</summary>
+        /// <param name="m">Matrix to use when computing determinant.</param>
+        /// <returns>The determinant of the matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float determinant(float2x2 m)
+        {
+            float a = m.c0.x;
+            float b = m.c1.x;
+            float c = m.c0.y;
+            float d = m.c1.y;
+
+            return a * d - b * c;
+        }
+
+        /// <summary>Returns a uint hash code of a float2x2 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(float2x2 v)
+        {
+            return csum(asuint(v.c0) * uint2(0x9C9F0823u, 0x5A9CA13Bu) +
+                        asuint(v.c1) * uint2(0xAFCDD5EFu, 0xA88D187Du)) + 0xCF6EBA1Du;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a float2x2 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(float2x2 v)
+        {
+            return (asuint(v.c0) * uint2(0x9D88E5A1u, 0xEADF0775u) +
+                    asuint(v.c1) * uint2(0x747A9D7Bu, 0x4111F799u)) + 0xB5F05AF1u;
+        }
+
+    }
+}

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/float2x2.gen.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 93080f7a13fd743e3aaaac6fee9f12b6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.mathematics@8017b507cc74/Unity.Mathematics/float2x3.gen.cs

@@ -0,0 +1,647 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
+// </auto-generated>
+//------------------------------------------------------------------------------
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+#pragma warning disable 0660, 0661
+
+namespace Unity.Mathematics
+{
+    /// <summary>A 2x3 matrix of floats.</summary>
+    [System.Serializable]
+    [Il2CppEagerStaticClassConstruction]
+    public partial struct float2x3 : System.IEquatable<float2x3>, IFormattable
+    {
+        /// <summary>Column 0 of the matrix.</summary>
+        public float2 c0;
+        /// <summary>Column 1 of the matrix.</summary>
+        public float2 c1;
+        /// <summary>Column 2 of the matrix.</summary>
+        public float2 c2;
+
+        /// <summary>float2x3 zero value.</summary>
+        public static readonly float2x3 zero;
+
+        /// <summary>Constructs a float2x3 matrix from three float2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(float2 c0, float2 c1, float2 c2)
+        {
+            this.c0 = c0;
+            this.c1 = c1;
+            this.c2 = c2;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from 6 float values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(float m00, float m01, float m02,
+                        float m10, float m11, float m12)
+        {
+            this.c0 = new float2(m00, m10);
+            this.c1 = new float2(m01, m11);
+            this.c2 = new float2(m02, m12);
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(float v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(bool v)
+        {
+            this.c0 = math.select(new float2(0.0f), new float2(1.0f), v);
+            this.c1 = math.select(new float2(0.0f), new float2(1.0f), v);
+            this.c2 = math.select(new float2(0.0f), new float2(1.0f), v);
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a bool2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(bool2x3 v)
+        {
+            this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0);
+            this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1);
+            this.c2 = math.select(new float2(0.0f), new float2(1.0f), v.c2);
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(int v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a int2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(int2x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(uint v)
+        {
+            this.c0 = v;
+            this.c1 = v;
+            this.c2 = v;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a uint2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(uint2x3 v)
+        {
+            this.c0 = v.c0;
+            this.c1 = v.c1;
+            this.c2 = v.c2;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(double v)
+        {
+            this.c0 = (float2)v;
+            this.c1 = (float2)v;
+            this.c2 = (float2)v;
+        }
+
+        /// <summary>Constructs a float2x3 matrix from a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x3 to convert to float2x3</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public float2x3(double2x3 v)
+        {
+            this.c0 = (float2)v.c0;
+            this.c1 = (float2)v.c1;
+            this.c2 = (float2)v.c2;
+        }
+
+
+        /// <summary>Implicitly converts a single float value to a float2x3 matrix by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x3(float v) { return new float2x3(v); }
+
+        /// <summary>Explicitly converts a single bool value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x3(bool v) { return new float2x3(v); }
+
+        /// <summary>Explicitly converts a bool2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x3(bool2x3 v) { return new float2x3(v); }
+
+        /// <summary>Implicitly converts a single int value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x3(int v) { return new float2x3(v); }
+
+        /// <summary>Implicitly converts a int2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x3(int2x3 v) { return new float2x3(v); }
+
+        /// <summary>Implicitly converts a single uint value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x3(uint v) { return new float2x3(v); }
+
+        /// <summary>Implicitly converts a uint2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float2x3(uint2x3 v) { return new float2x3(v); }
+
+        /// <summary>Explicitly converts a single double value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x3(double v) { return new float2x3(v); }
+
+        /// <summary>Explicitly converts a double2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static explicit operator float2x3(double2x3 v) { return new float2x3(v); }
+
+
+        /// <summary>Returns the result of a componentwise multiplication operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise multiplication.</param>
+        /// <returns>float2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator * (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise multiplication.</param>
+        /// <returns>float2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator * (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
+
+        /// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise multiplication.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise multiplication.</param>
+        /// <returns>float2x3 result of the componentwise multiplication.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator * (float lhs, float2x3 rhs) { return new float2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise addition operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise addition.</param>
+        /// <returns>float2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator + (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise addition.</param>
+        /// <returns>float2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator + (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
+
+        /// <summary>Returns the result of a componentwise addition operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise addition.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise addition.</param>
+        /// <returns>float2x3 result of the componentwise addition.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator + (float lhs, float2x3 rhs) { return new float2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise subtraction operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise subtraction.</param>
+        /// <returns>float2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator - (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise subtraction.</param>
+        /// <returns>float2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator - (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
+
+        /// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise subtraction.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise subtraction.</param>
+        /// <returns>float2x3 result of the componentwise subtraction.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator - (float lhs, float2x3 rhs) { return new float2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise division operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise division.</param>
+        /// <returns>float2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator / (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise division.</param>
+        /// <returns>float2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator / (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
+
+        /// <summary>Returns the result of a componentwise division operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise division.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise division.</param>
+        /// <returns>float2x3 result of the componentwise division.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator / (float lhs, float2x3 rhs) { return new float2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise modulus operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise modulus.</param>
+        /// <returns>float2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator % (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise modulus.</param>
+        /// <returns>float2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator % (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
+
+        /// <summary>Returns the result of a componentwise modulus operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise modulus.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise modulus.</param>
+        /// <returns>float2x3 result of the componentwise modulus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator % (float lhs, float2x3 rhs) { return new float2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise increment operation on a float2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise increment.</param>
+        /// <returns>float2x3 result of the componentwise increment.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator ++ (float2x3 val) { return new float2x3 (++val.c0, ++val.c1, ++val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise decrement operation on a float2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise decrement.</param>
+        /// <returns>float2x3 result of the componentwise decrement.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator -- (float2x3 val) { return new float2x3 (--val.c0, --val.c1, --val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less than operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
+
+        /// <summary>Returns the result of a componentwise less than operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less than.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise less than.</param>
+        /// <returns>bool2x3 result of the componentwise less than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator < (float lhs, float2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise less or equal operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
+
+        /// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise less or equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise less or equal.</param>
+        /// <returns>bool2x3 result of the componentwise less or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator <= (float lhs, float2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater than operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
+
+        /// <summary>Returns the result of a componentwise greater than operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater than.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise greater than.</param>
+        /// <returns>bool2x3 result of the componentwise greater than.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator > (float lhs, float2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
+
+        /// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise greater or equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise greater or equal.</param>
+        /// <returns>bool2x3 result of the componentwise greater or equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator >= (float lhs, float2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary minus operation on a float2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary minus.</param>
+        /// <returns>float2x3 result of the componentwise unary minus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator - (float2x3 val) { return new float2x3 (-val.c0, -val.c1, -val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise unary plus operation on a float2x3 matrix.</summary>
+        /// <param name="val">Value to use when computing the componentwise unary plus.</param>
+        /// <returns>float2x3 result of the componentwise unary plus.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 operator + (float2x3 val) { return new float2x3 (+val.c0, +val.c1, +val.c2); }
+
+
+        /// <summary>Returns the result of a componentwise equality operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
+
+        /// <summary>Returns the result of a componentwise equality operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise equality.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise equality.</param>
+        /// <returns>bool2x3 result of the componentwise equality.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator == (float lhs, float2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
+
+
+        /// <summary>Returns the result of a componentwise not equal operation on two float2x3 matrices.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float2x3 matrix and a float value.</summary>
+        /// <param name="lhs">Left hand side float2x3 to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
+
+        /// <summary>Returns the result of a componentwise not equal operation on a float value and a float2x3 matrix.</summary>
+        /// <param name="lhs">Left hand side float to use to compute componentwise not equal.</param>
+        /// <param name="rhs">Right hand side float2x3 to use to compute componentwise not equal.</param>
+        /// <returns>bool2x3 result of the componentwise not equal.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool2x3 operator != (float lhs, float2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
+
+
+
+        /// <summary>Returns the float2 element at a specified index.</summary>
+        unsafe public ref float2 this[int index]
+        {
+            get
+            {
+#if ENABLE_UNITY_COLLECTIONS_CHECKS
+                if ((uint)index >= 3)
+                    throw new System.ArgumentException("index must be between[0...2]");
+#endif
+                fixed (float2x3* array = &this) { return ref ((float2*)array)[index]; }
+            }
+        }
+
+        /// <summary>Returns true if the float2x3 is equal to a given float2x3, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(float2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
+
+        /// <summary>Returns true if the float2x3 is equal to a given float2x3, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
+        public override bool Equals(object o) { return o is float2x3 converted && Equals(converted); }
+
+
+        /// <summary>Returns a hash code for the float2x3.</summary>
+        /// <returns>The computed hash code.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+
+        /// <summary>Returns a string representation of the float2x3.</summary>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("float2x3({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
+        }
+
+        /// <summary>Returns a string representation of the float2x3 using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("float2x3({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider));
+        }
+
+    }
+
+    public static partial class math
+    {
+        /// <summary>Returns a float2x3 matrix constructed from three float2 vectors.</summary>
+        /// <param name="c0">The matrix column c0 will be set to this value.</param>
+        /// <param name="c1">The matrix column c1 will be set to this value.</param>
+        /// <param name="c2">The matrix column c2 will be set to this value.</param>
+        /// <returns>float2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(float2 c0, float2 c1, float2 c2) { return new float2x3(c0, c1, c2); }
+
+        /// <summary>Returns a float2x3 matrix constructed from from 6 float values given in row-major order.</summary>
+        /// <param name="m00">The matrix at row 0, column 0 will be set to this value.</param>
+        /// <param name="m01">The matrix at row 0, column 1 will be set to this value.</param>
+        /// <param name="m02">The matrix at row 0, column 2 will be set to this value.</param>
+        /// <param name="m10">The matrix at row 1, column 0 will be set to this value.</param>
+        /// <param name="m11">The matrix at row 1, column 1 will be set to this value.</param>
+        /// <param name="m12">The matrix at row 1, column 2 will be set to this value.</param>
+        /// <returns>float2x3 constructed from arguments.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(float m00, float m01, float m02,
+                                        float m10, float m11, float m12)
+        {
+            return new float2x3(m00, m01, m02,
+                                m10, m11, m12);
+        }
+
+        /// <summary>Returns a float2x3 matrix constructed from a single float value by assigning it to every component.</summary>
+        /// <param name="v">float to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(float v) { return new float2x3(v); }
+
+        /// <summary>Returns a float2x3 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">bool to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(bool v) { return new float2x3(v); }
+
+        /// <summary>Return a float2x3 matrix constructed from a bool2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">bool2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(bool2x3 v) { return new float2x3(v); }
+
+        /// <summary>Returns a float2x3 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">int to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(int v) { return new float2x3(v); }
+
+        /// <summary>Return a float2x3 matrix constructed from a int2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">int2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(int2x3 v) { return new float2x3(v); }
+
+        /// <summary>Returns a float2x3 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">uint to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(uint v) { return new float2x3(v); }
+
+        /// <summary>Return a float2x3 matrix constructed from a uint2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">uint2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(uint2x3 v) { return new float2x3(v); }
+
+        /// <summary>Returns a float2x3 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
+        /// <param name="v">double to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(double v) { return new float2x3(v); }
+
+        /// <summary>Return a float2x3 matrix constructed from a double2x3 matrix by componentwise conversion.</summary>
+        /// <param name="v">double2x3 to convert to float2x3</param>
+        /// <returns>Converted value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2x3 float2x3(double2x3 v) { return new float2x3(v); }
+
+        /// <summary>Return the float3x2 transpose of a float2x3 matrix.</summary>
+        /// <param name="v">Value to transpose.</param>
+        /// <returns>Transposed value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x2 transpose(float2x3 v)
+        {
+            return float3x2(
+                v.c0.x, v.c0.y,
+                v.c1.x, v.c1.y,
+                v.c2.x, v.c2.y);
+        }
+
+        /// <summary>Returns a uint hash code of a float2x3 matrix.</summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(float2x3 v)
+        {
+            return csum(asuint(v.c0) * uint2(0xE857DCE1u, 0xF62213C5u) +
+                        asuint(v.c1) * uint2(0x9CDAA959u, 0xAA269ABFu) +
+                        asuint(v.c2) * uint2(0xD54BA36Fu, 0xFD0847B9u)) + 0x8189A683u;
+        }
+
+        /// <summary>
+        /// Returns a uint2 vector hash code of a float2x3 matrix.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="v">Matrix value to hash.</param>
+        /// <returns>uint2 hash of the argument.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint2 hashwide(float2x3 v)
+        {
+            return (asuint(v.c0) * uint2(0xB139D651u, 0xE7579997u) +
+                    asuint(v.c1) * uint2(0xEF7D56C7u, 0x66F38F0Bu) +
+                    asuint(v.c2) * uint2(0x624256A3u, 0x5292ADE1u)) + 0xD2E590E5u;
+        }
+
+    }
+}