From d514efebba4ea24026bbf247a7c584936d0c1929 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:29:59 +0200 Subject: [PATCH 01/20] Make CultMath HLSL-shaped: writable components, bool-vector comparisons HLSL is now CultMath's semantic authority where it defines one. - float2/3/4, int2, double2/3, bool2 and quaternion are plain structs with public mutable fields instead of record structs. Indexers and swizzles (float2.yx; float3 xy xz yx yz zy xyz xzy yzx zyx; float4 xy xyz xyw yzx) have setters. - ==, !=, <, >, <=, >= are component-wise and return bool2/3/4. Equals and GetHashCode stay value-based so vectors remain dictionary keys. quaternion is not an HLSL type and keeps a bool ==. - Scalar/vector arithmetic and comparisons get explicit overloads on both sides instead of leaning on implicit splat. - New types: bool3, bool4, int3, int4, float2x2, float3x3 (row-major like HLSL, _mRC fields, Rotate / RotateX/Y/Z / Euler with math.RotationOrder). - New intrinsics: mul (matrix-vector both sides, matrix-matrix), any, all, select (HLSL argument order), log, vector pow/sqrt/sin/cos/acos/atan2, double min/max, int3/int4/bool3/bool4/float2x2/float3x3 constructor functions. - simplex_noise is renamed snoise and gains the Ashima 3D variant; the HLSL mirror follows as cultmath_snoise(float2/float3). - Random gains NextFloat3() and NextFloat3(float3 max) on the same draw order. Tests pin snoise(float3), float3x3.Euler and float2x2.Rotate to Unity.Mathematics reference values, and an HLSL-shaped source block compiles under using static CultMath.math. Co-Authored-By: Claude Opus 5 --- packages/cultmath/shaders/CultMath.hlsl | 61 +++- packages/cultmath/src/CultMath/Random.cs | 6 +- packages/cultmath/src/CultMath/bool2.cs | 45 ++- packages/cultmath/src/CultMath/bool3.cs | 55 +++ packages/cultmath/src/CultMath/bool3.cs.meta | 2 + packages/cultmath/src/CultMath/bool4.cs | 59 ++++ packages/cultmath/src/CultMath/bool4.cs.meta | 2 + packages/cultmath/src/CultMath/double2.cs | 45 ++- packages/cultmath/src/CultMath/double3.cs | 52 ++- packages/cultmath/src/CultMath/float2.cs | 78 +++- packages/cultmath/src/CultMath/float2x2.cs | 69 ++++ .../cultmath/src/CultMath/float2x2.cs.meta | 2 + packages/cultmath/src/CultMath/float3.cs | 140 +++++++- packages/cultmath/src/CultMath/float3x3.cs | 125 +++++++ .../cultmath/src/CultMath/float3x3.cs.meta | 2 + packages/cultmath/src/CultMath/float4.cs | 116 +++++- packages/cultmath/src/CultMath/int2.cs | 45 ++- packages/cultmath/src/CultMath/int3.cs | 64 ++++ packages/cultmath/src/CultMath/int3.cs.meta | 2 + packages/cultmath/src/CultMath/int4.cs | 68 ++++ packages/cultmath/src/CultMath/int4.cs.meta | 2 + packages/cultmath/src/CultMath/math.cs | 189 +++++++++- packages/cultmath/src/CultMath/quaternion.cs | 29 +- .../tests/CultMath.Tests/HlslMirrorTests.cs | 3 +- .../CultMath.Tests/HlslSemanticsTests.cs | 332 ++++++++++++++++++ .../CultMath.Tests/HlslSemanticsTests.cs.meta | 2 + .../HlslSourceCompatibilityTests.cs | 85 +++++ .../HlslSourceCompatibilityTests.cs.meta | 2 + .../tests/CultMath.Tests/MathTests.cs | 4 +- 29 files changed, 1610 insertions(+), 76 deletions(-) create mode 100644 packages/cultmath/src/CultMath/bool3.cs create mode 100644 packages/cultmath/src/CultMath/bool3.cs.meta create mode 100644 packages/cultmath/src/CultMath/bool4.cs create mode 100644 packages/cultmath/src/CultMath/bool4.cs.meta create mode 100644 packages/cultmath/src/CultMath/float2x2.cs create mode 100644 packages/cultmath/src/CultMath/float2x2.cs.meta create mode 100644 packages/cultmath/src/CultMath/float3x3.cs create mode 100644 packages/cultmath/src/CultMath/float3x3.cs.meta create mode 100644 packages/cultmath/src/CultMath/int3.cs create mode 100644 packages/cultmath/src/CultMath/int3.cs.meta create mode 100644 packages/cultmath/src/CultMath/int4.cs create mode 100644 packages/cultmath/src/CultMath/int4.cs.meta create mode 100644 packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs create mode 100644 packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs.meta create mode 100644 packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs create mode 100644 packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs.meta diff --git a/packages/cultmath/shaders/CultMath.hlsl b/packages/cultmath/shaders/CultMath.hlsl index 4c00fb69..f3c398d6 100644 --- a/packages/cultmath/shaders/CultMath.hlsl +++ b/packages/cultmath/shaders/CultMath.hlsl @@ -73,11 +73,64 @@ float cultmath_smootherstep(float value) return value * value * value * (value * (value * 6.0 - 15.0) + 10.0); } -float2 cultmath_simplex_mod289(float2 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } -float3 cultmath_simplex_mod289(float3 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } -float3 cultmath_simplex_permute(float3 value) { return cultmath_simplex_mod289(((value * 34.0) + 1.0) * value); } +float2 cultmath_snoise_mod289(float2 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float3 cultmath_snoise_mod289(float3 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float4 cultmath_snoise_mod289(float4 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float3 cultmath_snoise_permute(float3 value) { return cultmath_snoise_mod289(((value * 34.0) + 1.0) * value); } +float4 cultmath_snoise_permute(float4 value) { return cultmath_snoise_mod289(((value * 34.0) + 1.0) * value); } -float cultmath_simplex_noise(float2 value) +// Ashima Arts / Ian McEwan 3D simplex noise (MIT), same float32 evaluation +// order as the C# math.snoise(float3) mirror. +float cultmath_snoise(float3 value) +{ + const float2 c = float2(1.0 / 6.0, 1.0 / 3.0); + float3 i = floor(value + dot(value, c.yyy)); + float3 x0 = value - i + dot(i, c.xxx); + float3 g = step(x0.yzx, x0.xyz); + float3 l = 1.0 - g; + float3 i1 = min(g.xyz, l.zxy); + float3 i2 = max(g.xyz, l.zxy); + float3 x1 = x0 - i1 + c.xxx; + float3 x2 = x0 - i2 + c.yyy; + float3 x3 = x0 - 0.5; + + i = cultmath_snoise_mod289(i); + float4 p = cultmath_snoise_permute(cultmath_snoise_permute(cultmath_snoise_permute( + i.z + float4(0.0, i1.z, i2.z, 1.0)) + i.y + float4(0.0, i1.y, i2.y, 1.0)) + i.x + float4(0.0, i1.x, i2.x, 1.0)); + + const float n_ = 0.142857142857; + float3 ns = float3(2.0 * n_, 0.5 * n_ - 1.0, n_); + float4 j = p - 49.0 * floor(p * ns.z * ns.z); + float4 x_ = floor(j * ns.z); + float4 y_ = floor(j - 7.0 * x_); + float4 x = x_ * ns.x + ns.yyyy; + float4 y = y_ * ns.x + ns.yyyy; + float4 h = 1.0 - abs(x) - abs(y); + + float4 b0 = float4(x.xy, y.xy); + float4 b1 = float4(x.zw, y.zw); + float4 s0 = floor(b0) * 2.0 + 1.0; + float4 s1 = floor(b1) * 2.0 + 1.0; + float4 sh = -step(h, 0.0); + 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); + float4 norm = 1.79284291400159 - 0.85373472095314 * 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; + + float4 m = max(0.6 - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0); + m = m * m; + return 42.0 * dot(m * m, float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); +} + +float cultmath_snoise(float2 value) { const float4 c = float4( 0.211324865405187, diff --git a/packages/cultmath/src/CultMath/Random.cs b/packages/cultmath/src/CultMath/Random.cs index 9931a87f..6892e20c 100644 --- a/packages/cultmath/src/CultMath/Random.cs +++ b/packages/cultmath/src/CultMath/Random.cs @@ -58,5 +58,9 @@ public struct Random return new float2(math.cos(angle), math.sin(angle)); } - public float3 NextFloat3(float3 min, float3 max) => min + new float3(NextFloat(), NextFloat(), NextFloat()) * (max - min); + public float3 NextFloat3() => new(NextFloat(), NextFloat(), NextFloat()); + + public float3 NextFloat3(float3 max) => NextFloat3() * max; + + public float3 NextFloat3(float3 min, float3 max) => min + NextFloat3() * (max - min); } diff --git a/packages/cultmath/src/CultMath/bool2.cs b/packages/cultmath/src/CultMath/bool2.cs index 95ab29eb..31fd10b0 100644 --- a/packages/cultmath/src/CultMath/bool2.cs +++ b/packages/cultmath/src/CultMath/bool2.cs @@ -2,17 +2,50 @@ using System; namespace CultMath; -public record struct bool2(bool x, bool y) +public struct bool2 : IEquatable { public static readonly bool2 @false = new(false, false); public static readonly bool2 @true = new(true, true); - public bool this[int index] => index switch + public bool x; + public bool y; + + public bool2(bool x, bool y) { - 0 => x, - 1 => y, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + this.x = x; + this.y = y; + } + + public bool this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator bool2(bool value) => new(value, value); + + public static bool2 operator !(bool2 value) => new(!value.x, !value.y); + public static bool2 operator &(bool2 left, bool2 right) => new(left.x & right.x, left.y & right.y); + public static bool2 operator |(bool2 left, bool2 right) => new(left.x | right.x, left.y | right.y); + public static bool2 operator ^(bool2 left, bool2 right) => new(left.x ^ right.x, left.y ^ right.y); + public static bool2 operator ==(bool2 left, bool2 right) => new(left.x == right.x, left.y == right.y); + public static bool2 operator !=(bool2 left, bool2 right) => new(left.x != right.x, left.y != right.y); + + public readonly bool Equals(bool2 other) => x == other.x && y == other.y; + public override readonly bool Equals(object? obj) => obj is bool2 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y); + public override readonly string ToString() => $"bool2({x}, {y})"; } diff --git a/packages/cultmath/src/CultMath/bool3.cs b/packages/cultmath/src/CultMath/bool3.cs new file mode 100644 index 00000000..15c834ed --- /dev/null +++ b/packages/cultmath/src/CultMath/bool3.cs @@ -0,0 +1,55 @@ +using System; + +namespace CultMath; + +public struct bool3 : IEquatable +{ + public static readonly bool3 @false = new(false, false, false); + public static readonly bool3 @true = new(true, true, true); + + public bool x; + public bool y; + public bool z; + + public bool3(bool x, bool y, bool z) + { + this.x = x; + this.y = y; + this.z = z; + } + + public bool this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } + + public static implicit operator bool3(bool value) => new(value, value, value); + + public static bool3 operator !(bool3 value) => new(!value.x, !value.y, !value.z); + public static bool3 operator &(bool3 left, bool3 right) => new(left.x & right.x, left.y & right.y, left.z & right.z); + public static bool3 operator |(bool3 left, bool3 right) => new(left.x | right.x, left.y | right.y, left.z | right.z); + public static bool3 operator ^(bool3 left, bool3 right) => new(left.x ^ right.x, left.y ^ right.y, left.z ^ right.z); + public static bool3 operator ==(bool3 left, bool3 right) => new(left.x == right.x, left.y == right.y, left.z == right.z); + public static bool3 operator !=(bool3 left, bool3 right) => new(left.x != right.x, left.y != right.y, left.z != right.z); + + public readonly bool Equals(bool3 other) => x == other.x && y == other.y && z == other.z; + public override readonly bool Equals(object? obj) => obj is bool3 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z); + public override readonly string ToString() => $"bool3({x}, {y}, {z})"; +} diff --git a/packages/cultmath/src/CultMath/bool3.cs.meta b/packages/cultmath/src/CultMath/bool3.cs.meta new file mode 100644 index 00000000..ada81b6d --- /dev/null +++ b/packages/cultmath/src/CultMath/bool3.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 323ec670fc374c8ba4d87b4bf4c91f34 diff --git a/packages/cultmath/src/CultMath/bool4.cs b/packages/cultmath/src/CultMath/bool4.cs new file mode 100644 index 00000000..09300432 --- /dev/null +++ b/packages/cultmath/src/CultMath/bool4.cs @@ -0,0 +1,59 @@ +using System; + +namespace CultMath; + +public struct bool4 : IEquatable +{ + public static readonly bool4 @false = new(false, false, false, false); + public static readonly bool4 @true = new(true, true, true, true); + + public bool x; + public bool y; + public bool z; + public bool w; + + public bool4(bool x, bool y, bool z, bool w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + public bool this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + 3 => w, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + case 3: w = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } + + public static implicit operator bool4(bool value) => new(value, value, value, value); + + public static bool4 operator !(bool4 value) => new(!value.x, !value.y, !value.z, !value.w); + public static bool4 operator &(bool4 left, bool4 right) => new(left.x & right.x, left.y & right.y, left.z & right.z, left.w & right.w); + public static bool4 operator |(bool4 left, bool4 right) => new(left.x | right.x, left.y | right.y, left.z | right.z, left.w | right.w); + public static bool4 operator ^(bool4 left, bool4 right) => new(left.x ^ right.x, left.y ^ right.y, left.z ^ right.z, left.w ^ right.w); + public static bool4 operator ==(bool4 left, bool4 right) => new(left.x == right.x, left.y == right.y, left.z == right.z, left.w == right.w); + public static bool4 operator !=(bool4 left, bool4 right) => new(left.x != right.x, left.y != right.y, left.z != right.z, left.w != right.w); + + public readonly bool Equals(bool4 other) => x == other.x && y == other.y && z == other.z && w == other.w; + public override readonly bool Equals(object? obj) => obj is bool4 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z, w); + public override readonly string ToString() => $"bool4({x}, {y}, {z}, {w})"; +} diff --git a/packages/cultmath/src/CultMath/bool4.cs.meta b/packages/cultmath/src/CultMath/bool4.cs.meta new file mode 100644 index 00000000..625bb46b --- /dev/null +++ b/packages/cultmath/src/CultMath/bool4.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: d38b9f70d88c459584441b85ecbfd92a diff --git a/packages/cultmath/src/CultMath/double2.cs b/packages/cultmath/src/CultMath/double2.cs index 000c3cb0..e61d84ea 100644 --- a/packages/cultmath/src/CultMath/double2.cs +++ b/packages/cultmath/src/CultMath/double2.cs @@ -2,17 +2,38 @@ using System; namespace CultMath; -public record struct double2(double x, double y) +public struct double2 : IEquatable { public static readonly double2 zero = new(0.0, 0.0); public static readonly double2 one = new(1.0, 1.0); - public double this[int index] => index switch + public double x; + public double y; + + public double2(double x, double y) { - 0 => x, - 1 => y, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + this.x = x; + this.y = y; + } + + public double this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator double2(double value) => new(value, value); @@ -22,4 +43,16 @@ public record struct double2(double x, double y) public static double2 operator -(double2 left, double2 right) => new(left.x - right.x, left.y - right.y); public static double2 operator *(double2 left, double2 right) => new(left.x * right.x, left.y * right.y); public static double2 operator /(double2 left, double2 right) => new(left.x / right.x, left.y / right.y); + + public static bool2 operator <(double2 left, double2 right) => new(left.x < right.x, left.y < right.y); + public static bool2 operator >(double2 left, double2 right) => new(left.x > right.x, left.y > right.y); + public static bool2 operator <=(double2 left, double2 right) => new(left.x <= right.x, left.y <= right.y); + public static bool2 operator >=(double2 left, double2 right) => new(left.x >= right.x, left.y >= right.y); + public static bool2 operator ==(double2 left, double2 right) => new(left.x == right.x, left.y == right.y); + public static bool2 operator !=(double2 left, double2 right) => new(left.x != right.x, left.y != right.y); + + public readonly bool Equals(double2 other) => x.Equals(other.x) && y.Equals(other.y); + public override readonly bool Equals(object? obj) => obj is double2 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y); + public override readonly string ToString() => FormattableString.Invariant($"double2({x:R}, {y:R})"); } diff --git a/packages/cultmath/src/CultMath/double3.cs b/packages/cultmath/src/CultMath/double3.cs index b1427505..98c79327 100644 --- a/packages/cultmath/src/CultMath/double3.cs +++ b/packages/cultmath/src/CultMath/double3.cs @@ -2,14 +2,25 @@ using System; namespace CultMath; -public record struct double3(double x, double y, double z) +public struct double3 : IEquatable { public static readonly double3 zero = new(0.0, 0.0, 0.0); public static readonly double3 one = new(1.0, 1.0, 1.0); + public double x; + public double y; + public double z; + + public double3(double x, double y, double z) + { + this.x = x; + this.y = y; + this.z = z; + } + public double2 xy { - get => new(x, y); + readonly get => new(x, y); set { x = value.x; @@ -17,13 +28,26 @@ public record struct double3(double x, double y, double z) } } - public double this[int index] => index switch + public double this[int index] { - 0 => x, - 1 => y, - 2 => z, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator double3(double value) => new(value, value, value); @@ -33,4 +57,16 @@ public record struct double3(double x, double y, double z) public static double3 operator -(double3 left, double3 right) => new(left.x - right.x, left.y - right.y, left.z - right.z); public static double3 operator *(double3 left, double3 right) => new(left.x * right.x, left.y * right.y, left.z * right.z); public static double3 operator /(double3 left, double3 right) => new(left.x / right.x, left.y / right.y, left.z / right.z); + + public static bool3 operator <(double3 left, double3 right) => new(left.x < right.x, left.y < right.y, left.z < right.z); + public static bool3 operator >(double3 left, double3 right) => new(left.x > right.x, left.y > right.y, left.z > right.z); + public static bool3 operator <=(double3 left, double3 right) => new(left.x <= right.x, left.y <= right.y, left.z <= right.z); + public static bool3 operator >=(double3 left, double3 right) => new(left.x >= right.x, left.y >= right.y, left.z >= right.z); + public static bool3 operator ==(double3 left, double3 right) => new(left.x == right.x, left.y == right.y, left.z == right.z); + public static bool3 operator !=(double3 left, double3 right) => new(left.x != right.x, left.y != right.y, left.z != right.z); + + public readonly bool Equals(double3 other) => x.Equals(other.x) && y.Equals(other.y) && z.Equals(other.z); + public override readonly bool Equals(object? obj) => obj is double3 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z); + public override readonly string ToString() => FormattableString.Invariant($"double3({x:R}, {y:R}, {z:R})"); } diff --git a/packages/cultmath/src/CultMath/float2.cs b/packages/cultmath/src/CultMath/float2.cs index 5298494b..f1fb5ccd 100644 --- a/packages/cultmath/src/CultMath/float2.cs +++ b/packages/cultmath/src/CultMath/float2.cs @@ -2,17 +2,48 @@ using System; namespace CultMath; -public record struct float2(float x, float y) +public struct float2 : IEquatable { public static readonly float2 zero = new(0.0f, 0.0f); public static readonly float2 one = new(1.0f, 1.0f); - public float this[int index] => index switch + public float x; + public float y; + + public float2(float x, float y) { - 0 => x, - 1 => y, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + this.x = x; + this.y = y; + } + + public float2 yx + { + readonly get => new(y, x); + set + { + y = value.x; + x = value.y; + } + } + + public float this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator float2(float value) => new(value, value); public static explicit operator System.Numerics.Vector2(float2 value) => new(value.x, value.y); @@ -20,9 +51,44 @@ public record struct float2(float x, float y) public static float2 operator +(float2 value) => value; public static float2 operator -(float2 value) => new(-value.x, -value.y); + public static float2 operator +(float2 left, float2 right) => new(left.x + right.x, left.y + right.y); + public static float2 operator +(float2 left, float right) => new(left.x + right, left.y + right); + public static float2 operator +(float left, float2 right) => new(left + right.x, left + right.y); public static float2 operator -(float2 left, float2 right) => new(left.x - right.x, left.y - right.y); + public static float2 operator -(float2 left, float right) => new(left.x - right, left.y - right); + public static float2 operator -(float left, float2 right) => new(left - right.x, left - right.y); public static float2 operator *(float2 left, float2 right) => new(left.x * right.x, left.y * right.y); + public static float2 operator *(float2 left, float right) => new(left.x * right, left.y * right); + public static float2 operator *(float left, float2 right) => new(left * right.x, left * right.y); public static float2 operator /(float2 left, float2 right) => new(left.x / right.x, left.y / right.y); + public static float2 operator /(float2 left, float right) => new(left.x / right, left.y / right); + public static float2 operator /(float left, float2 right) => new(left / right.x, left / right.y); public static float2 operator %(float2 left, float2 right) => new(left.x % right.x, left.y % right.y); + public static float2 operator %(float2 left, float right) => new(left.x % right, left.y % right); + public static float2 operator %(float left, float2 right) => new(left % right.x, left % right.y); + + public static bool2 operator <(float2 left, float2 right) => new(left.x < right.x, left.y < right.y); + public static bool2 operator <(float2 left, float right) => new(left.x < right, left.y < right); + public static bool2 operator <(float left, float2 right) => new(left < right.x, left < right.y); + public static bool2 operator >(float2 left, float2 right) => new(left.x > right.x, left.y > right.y); + public static bool2 operator >(float2 left, float right) => new(left.x > right, left.y > right); + public static bool2 operator >(float left, float2 right) => new(left > right.x, left > right.y); + public static bool2 operator <=(float2 left, float2 right) => new(left.x <= right.x, left.y <= right.y); + public static bool2 operator <=(float2 left, float right) => new(left.x <= right, left.y <= right); + public static bool2 operator <=(float left, float2 right) => new(left <= right.x, left <= right.y); + public static bool2 operator >=(float2 left, float2 right) => new(left.x >= right.x, left.y >= right.y); + public static bool2 operator >=(float2 left, float right) => new(left.x >= right, left.y >= right); + public static bool2 operator >=(float left, float2 right) => new(left >= right.x, left >= right.y); + public static bool2 operator ==(float2 left, float2 right) => new(left.x == right.x, left.y == right.y); + public static bool2 operator ==(float2 left, float right) => new(left.x == right, left.y == right); + public static bool2 operator ==(float left, float2 right) => new(left == right.x, left == right.y); + public static bool2 operator !=(float2 left, float2 right) => new(left.x != right.x, left.y != right.y); + public static bool2 operator !=(float2 left, float right) => new(left.x != right, left.y != right); + public static bool2 operator !=(float left, float2 right) => new(left != right.x, left != right.y); + + public readonly bool Equals(float2 other) => x.Equals(other.x) && y.Equals(other.y); + public override readonly bool Equals(object? obj) => obj is float2 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y); + public override readonly string ToString() => FormattableString.Invariant($"float2({x:R}, {y:R})"); } diff --git a/packages/cultmath/src/CultMath/float2x2.cs b/packages/cultmath/src/CultMath/float2x2.cs new file mode 100644 index 00000000..60f59fb2 --- /dev/null +++ b/packages/cultmath/src/CultMath/float2x2.cs @@ -0,0 +1,69 @@ +using System; + +namespace CultMath; + +/// +/// HLSL float2x2: row-major. Constructors take rows, m[i] is row i, and +/// _mRC names row R, column C exactly as HLSL does. Use +/// for products; there is no * matrix product because HLSL's * is component-wise. +/// +public struct float2x2 : IEquatable +{ + public static readonly float2x2 identity = new(1.0f, 0.0f, 0.0f, 1.0f); + public static readonly float2x2 zero = new(0.0f, 0.0f, 0.0f, 0.0f); + + public float _m00; + public float _m01; + public float _m10; + public float _m11; + + public float2x2(float m00, float m01, float m10, float m11) + { + _m00 = m00; + _m01 = m01; + _m10 = m10; + _m11 = m11; + } + + public float2x2(float2 row0, float2 row1) + : this(row0.x, row0.y, row1.x, row1.y) + { + } + + public float2 this[int row] + { + readonly get => row switch + { + 0 => new float2(_m00, _m01), + 1 => new float2(_m10, _m11), + _ => throw new ArgumentOutOfRangeException(nameof(row)), + }; + set + { + switch (row) + { + case 0: _m00 = value.x; _m01 = value.y; break; + case 1: _m10 = value.x; _m11 = value.y; break; + default: throw new ArgumentOutOfRangeException(nameof(row)); + } + } + } + + /// + /// Counter-clockwise rotation for column vectors: mul(Rotate(a), v) equals + /// math.rotate(v, a); mul(v, Rotate(a)) rotates the other way. + /// + public static float2x2 Rotate(float radians) + { + var s = MathF.Sin(radians); + var c = MathF.Cos(radians); + return new float2x2(c, -s, s, c); + } + + public readonly bool Equals(float2x2 other) => + _m00.Equals(other._m00) && _m01.Equals(other._m01) && _m10.Equals(other._m10) && _m11.Equals(other._m11); + + public override readonly bool Equals(object? obj) => obj is float2x2 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(_m00, _m01, _m10, _m11); + public override readonly string ToString() => FormattableString.Invariant($"float2x2({_m00:R}, {_m01:R}, {_m10:R}, {_m11:R})"); +} diff --git a/packages/cultmath/src/CultMath/float2x2.cs.meta b/packages/cultmath/src/CultMath/float2x2.cs.meta new file mode 100644 index 00000000..56840df7 --- /dev/null +++ b/packages/cultmath/src/CultMath/float2x2.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: c0dcec14c0b7432dbd8ba0bebb0a7c2f diff --git a/packages/cultmath/src/CultMath/float3.cs b/packages/cultmath/src/CultMath/float3.cs index 4a4efeba..b4dfa854 100644 --- a/packages/cultmath/src/CultMath/float3.cs +++ b/packages/cultmath/src/CultMath/float3.cs @@ -2,11 +2,22 @@ using System; namespace CultMath; -public record struct float3(float x, float y, float z) +public struct float3 : IEquatable { public static readonly float3 zero = new(0.0f, 0.0f, 0.0f); public static readonly float3 one = new(1.0f, 1.0f, 1.0f); + public float x; + public float y; + public float z; + + public float3(float x, float y, float z) + { + this.x = x; + this.y = y; + this.z = z; + } + public float3(float2 xy, float z) : this(xy.x, xy.y, z) { @@ -14,7 +25,7 @@ public record struct float3(float x, float y, float z) public float2 xy { - get => new(x, y); + readonly get => new(x, y); set { x = value.x; @@ -24,7 +35,7 @@ public record struct float3(float x, float y, float z) public float2 xz { - get => new(x, z); + readonly get => new(x, z); set { x = value.x; @@ -32,9 +43,19 @@ public record struct float3(float x, float y, float z) } } + public float2 yx + { + readonly get => new(y, x); + set + { + y = value.x; + x = value.y; + } + } + public float2 yz { - get => new(y, z); + readonly get => new(y, z); set { y = value.x; @@ -44,7 +65,7 @@ public record struct float3(float x, float y, float z) public float2 zy { - get => new(z, y); + readonly get => new(z, y); set { z = value.x; @@ -52,28 +73,115 @@ public record struct float3(float x, float y, float z) } } - public float3 yzx => new(y, z, x); - public float3 zyx => new(z, y, x); - - public float this[int index] => index switch + public float3 xyz { - 0 => x, - 1 => y, - 2 => z, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + readonly get => new(x, y, z); + set + { + x = value.x; + y = value.y; + z = value.z; + } + } + + public float3 xzy + { + readonly get => new(x, z, y); + set + { + x = value.x; + z = value.y; + y = value.z; + } + } + + public float3 yzx + { + readonly get => new(y, z, x); + set + { + y = value.x; + z = value.y; + x = value.z; + } + } + + public float3 zyx + { + readonly get => new(z, y, x); + set + { + z = value.x; + y = value.y; + x = value.z; + } + } + + public float this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator float3(float value) => new(value, value, value); public static explicit operator System.Numerics.Vector3(float3 value) => new(value.x, value.y, value.z); public static explicit operator float3(System.Numerics.Vector3 value) => new(value.X, value.Y, value.Z); - public override readonly string ToString() => $"float3({x:R}, {y:R}, {z:R})"; - public static float3 operator +(float3 value) => value; public static float3 operator -(float3 value) => new(-value.x, -value.y, -value.z); + public static float3 operator +(float3 left, float3 right) => new(left.x + right.x, left.y + right.y, left.z + right.z); + public static float3 operator +(float3 left, float right) => new(left.x + right, left.y + right, left.z + right); + public static float3 operator +(float left, float3 right) => new(left + right.x, left + right.y, left + right.z); public static float3 operator -(float3 left, float3 right) => new(left.x - right.x, left.y - right.y, left.z - right.z); + public static float3 operator -(float3 left, float right) => new(left.x - right, left.y - right, left.z - right); + public static float3 operator -(float left, float3 right) => new(left - right.x, left - right.y, left - right.z); public static float3 operator *(float3 left, float3 right) => new(left.x * right.x, left.y * right.y, left.z * right.z); + public static float3 operator *(float3 left, float right) => new(left.x * right, left.y * right, left.z * right); + public static float3 operator *(float left, float3 right) => new(left * right.x, left * right.y, left * right.z); public static float3 operator /(float3 left, float3 right) => new(left.x / right.x, left.y / right.y, left.z / right.z); + public static float3 operator /(float3 left, float right) => new(left.x / right, left.y / right, left.z / right); + public static float3 operator /(float left, float3 right) => new(left / right.x, left / right.y, left / right.z); public static float3 operator %(float3 left, float3 right) => new(left.x % right.x, left.y % right.y, left.z % right.z); + public static float3 operator %(float3 left, float right) => new(left.x % right, left.y % right, left.z % right); + public static float3 operator %(float left, float3 right) => new(left % right.x, left % right.y, left % right.z); + + public static bool3 operator <(float3 left, float3 right) => new(left.x < right.x, left.y < right.y, left.z < right.z); + public static bool3 operator <(float3 left, float right) => new(left.x < right, left.y < right, left.z < right); + public static bool3 operator <(float left, float3 right) => new(left < right.x, left < right.y, left < right.z); + public static bool3 operator >(float3 left, float3 right) => new(left.x > right.x, left.y > right.y, left.z > right.z); + public static bool3 operator >(float3 left, float right) => new(left.x > right, left.y > right, left.z > right); + public static bool3 operator >(float left, float3 right) => new(left > right.x, left > right.y, left > right.z); + public static bool3 operator <=(float3 left, float3 right) => new(left.x <= right.x, left.y <= right.y, left.z <= right.z); + public static bool3 operator <=(float3 left, float right) => new(left.x <= right, left.y <= right, left.z <= right); + public static bool3 operator <=(float left, float3 right) => new(left <= right.x, left <= right.y, left <= right.z); + public static bool3 operator >=(float3 left, float3 right) => new(left.x >= right.x, left.y >= right.y, left.z >= right.z); + public static bool3 operator >=(float3 left, float right) => new(left.x >= right, left.y >= right, left.z >= right); + public static bool3 operator >=(float left, float3 right) => new(left >= right.x, left >= right.y, left >= right.z); + public static bool3 operator ==(float3 left, float3 right) => new(left.x == right.x, left.y == right.y, left.z == right.z); + public static bool3 operator ==(float3 left, float right) => new(left.x == right, left.y == right, left.z == right); + public static bool3 operator ==(float left, float3 right) => new(left == right.x, left == right.y, left == right.z); + public static bool3 operator !=(float3 left, float3 right) => new(left.x != right.x, left.y != right.y, left.z != right.z); + public static bool3 operator !=(float3 left, float right) => new(left.x != right, left.y != right, left.z != right); + public static bool3 operator !=(float left, float3 right) => new(left != right.x, left != right.y, left != right.z); + + public readonly bool Equals(float3 other) => x.Equals(other.x) && y.Equals(other.y) && z.Equals(other.z); + public override readonly bool Equals(object? obj) => obj is float3 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z); + public override readonly string ToString() => FormattableString.Invariant($"float3({x:R}, {y:R}, {z:R})"); } diff --git a/packages/cultmath/src/CultMath/float3x3.cs b/packages/cultmath/src/CultMath/float3x3.cs new file mode 100644 index 00000000..41e39936 --- /dev/null +++ b/packages/cultmath/src/CultMath/float3x3.cs @@ -0,0 +1,125 @@ +using System; + +namespace CultMath; + +/// +/// HLSL float3x3: row-major. Constructors take rows, m[i] is row i, and +/// _mRC names row R, column C exactly as HLSL does. Use +/// for products; there is no * matrix product because HLSL's * is component-wise. +/// +public struct float3x3 : IEquatable +{ + public static readonly float3x3 identity = new(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f); + public static readonly float3x3 zero = new(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); + + public float _m00; + public float _m01; + public float _m02; + public float _m10; + public float _m11; + public float _m12; + public float _m20; + public float _m21; + public float _m22; + + public float3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) + { + _m00 = m00; + _m01 = m01; + _m02 = m02; + _m10 = m10; + _m11 = m11; + _m12 = m12; + _m20 = m20; + _m21 = m21; + _m22 = m22; + } + + public float3x3(float3 row0, float3 row1, float3 row2) + : this(row0.x, row0.y, row0.z, row1.x, row1.y, row1.z, row2.x, row2.y, row2.z) + { + } + + public float3 this[int row] + { + readonly get => row switch + { + 0 => new float3(_m00, _m01, _m02), + 1 => new float3(_m10, _m11, _m12), + 2 => new float3(_m20, _m21, _m22), + _ => throw new ArgumentOutOfRangeException(nameof(row)), + }; + set + { + switch (row) + { + case 0: _m00 = value.x; _m01 = value.y; _m02 = value.z; break; + case 1: _m10 = value.x; _m11 = value.y; _m12 = value.z; break; + case 2: _m20 = value.x; _m21 = value.y; _m22 = value.z; break; + default: throw new ArgumentOutOfRangeException(nameof(row)); + } + } + } + + /// Rotation about +X for column vectors (mul(m, v)). + public static float3x3 RotateX(float radians) + { + var s = MathF.Sin(radians); + var c = MathF.Cos(radians); + return new float3x3(1.0f, 0.0f, 0.0f, 0.0f, c, -s, 0.0f, s, c); + } + + /// Rotation about +Y for column vectors (mul(m, v)). + public static float3x3 RotateY(float radians) + { + var s = MathF.Sin(radians); + var c = MathF.Cos(radians); + return new float3x3(c, 0.0f, s, 0.0f, 1.0f, 0.0f, -s, 0.0f, c); + } + + /// Rotation about +Z for column vectors (mul(m, v)). + public static float3x3 RotateZ(float radians) + { + var s = MathF.Sin(radians); + var c = MathF.Cos(radians); + return new float3x3(c, -s, 0.0f, s, c, 0.0f, 0.0f, 0.0f, 1.0f); + } + + /// + /// Extrinsic Euler rotation in radians. The order names the axis applied first: + /// rotates about Y, then X, then Z, so the + /// matrix is mul(RotateZ, mul(RotateX, RotateY)) for column vectors. + /// + public static float3x3 Euler(float3 xyz, math.RotationOrder order = math.RotationOrder.Default) + { + var x = RotateX(xyz.x); + var y = RotateY(xyz.y); + var z = RotateZ(xyz.z); + return order switch + { + math.RotationOrder.XYZ => math.mul(z, math.mul(y, x)), + math.RotationOrder.XZY => math.mul(y, math.mul(z, x)), + math.RotationOrder.YXZ => math.mul(z, math.mul(x, y)), + math.RotationOrder.YZX => math.mul(x, math.mul(z, y)), + math.RotationOrder.ZXY => math.mul(y, math.mul(x, z)), + math.RotationOrder.ZYX => math.mul(x, math.mul(y, z)), + _ => throw new ArgumentOutOfRangeException(nameof(order)), + }; + } + + public static float3x3 Euler(float x, float y, float z, math.RotationOrder order = math.RotationOrder.Default) => + Euler(new float3(x, y, z), order); + + public readonly bool Equals(float3x3 other) => + _m00.Equals(other._m00) && _m01.Equals(other._m01) && _m02.Equals(other._m02) && + _m10.Equals(other._m10) && _m11.Equals(other._m11) && _m12.Equals(other._m12) && + _m20.Equals(other._m20) && _m21.Equals(other._m21) && _m22.Equals(other._m22); + + public override readonly bool Equals(object? obj) => obj is float3x3 other && Equals(other); + + public override readonly int GetHashCode() => + HashCode.Combine(HashCode.Combine(_m00, _m01, _m02), HashCode.Combine(_m10, _m11, _m12), HashCode.Combine(_m20, _m21, _m22)); + + public override readonly string ToString() => + FormattableString.Invariant($"float3x3({_m00:R}, {_m01:R}, {_m02:R}, {_m10:R}, {_m11:R}, {_m12:R}, {_m20:R}, {_m21:R}, {_m22:R})"); +} diff --git a/packages/cultmath/src/CultMath/float3x3.cs.meta b/packages/cultmath/src/CultMath/float3x3.cs.meta new file mode 100644 index 00000000..99b25ed3 --- /dev/null +++ b/packages/cultmath/src/CultMath/float3x3.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 9ca36a9bfff144a9b51478a6d7b19c8e diff --git a/packages/cultmath/src/CultMath/float4.cs b/packages/cultmath/src/CultMath/float4.cs index b6eed097..d73175d8 100644 --- a/packages/cultmath/src/CultMath/float4.cs +++ b/packages/cultmath/src/CultMath/float4.cs @@ -2,11 +2,24 @@ using System; namespace CultMath; -public record struct float4(float x, float y, float z, float w) +public struct float4 : IEquatable { public static readonly float4 zero = new(0.0f, 0.0f, 0.0f, 0.0f); public static readonly float4 one = new(1.0f, 1.0f, 1.0f, 1.0f); + public float x; + public float y; + public float z; + public float w; + + public float4(float x, float y, float z, float w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + public float4(float2 xy, float z, float w) : this(xy.x, xy.y, z, w) { @@ -24,25 +37,69 @@ public record struct float4(float x, float y, float z, float w) public float2 xy { - get => new(x, y); + readonly get => new(x, y); set { x = value.x; y = value.y; } } - public float3 xyw => new(x, y, w); - public float3 yzx => new(y, z, x); - public float3 xyz => new(x, y, z); - public float this[int index] => index switch + public float3 xyz { - 0 => x, - 1 => y, - 2 => z, - 3 => w, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + readonly get => new(x, y, z); + set + { + x = value.x; + y = value.y; + z = value.z; + } + } + + public float3 xyw + { + readonly get => new(x, y, w); + set + { + x = value.x; + y = value.y; + w = value.z; + } + } + + public float3 yzx + { + readonly get => new(y, z, x); + set + { + y = value.x; + z = value.y; + x = value.z; + } + } + + public float this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + 3 => w, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + case 3: w = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator float4(float value) => new(value, value, value, value); public static explicit operator System.Numerics.Vector4(float4 value) => new(value.x, value.y, value.z, value.w); @@ -50,9 +107,44 @@ public record struct float4(float x, float y, float z, float w) public static float4 operator +(float4 value) => value; public static float4 operator -(float4 value) => new(-value.x, -value.y, -value.z, -value.w); + public static float4 operator +(float4 left, float4 right) => new(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); + public static float4 operator +(float4 left, float right) => new(left.x + right, left.y + right, left.z + right, left.w + right); + public static float4 operator +(float left, float4 right) => new(left + right.x, left + right.y, left + right.z, left + right.w); public static float4 operator -(float4 left, float4 right) => new(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); + public static float4 operator -(float4 left, float right) => new(left.x - right, left.y - right, left.z - right, left.w - right); + public static float4 operator -(float left, float4 right) => new(left - right.x, left - right.y, left - right.z, left - right.w); public static float4 operator *(float4 left, float4 right) => new(left.x * right.x, left.y * right.y, left.z * right.z, left.w * right.w); + public static float4 operator *(float4 left, float right) => new(left.x * right, left.y * right, left.z * right, left.w * right); + public static float4 operator *(float left, float4 right) => new(left * right.x, left * right.y, left * right.z, left * right.w); public static float4 operator /(float4 left, float4 right) => new(left.x / right.x, left.y / right.y, left.z / right.z, left.w / right.w); + public static float4 operator /(float4 left, float right) => new(left.x / right, left.y / right, left.z / right, left.w / right); + public static float4 operator /(float left, float4 right) => new(left / right.x, left / right.y, left / right.z, left / right.w); public static float4 operator %(float4 left, float4 right) => new(left.x % right.x, left.y % right.y, left.z % right.z, left.w % right.w); + public static float4 operator %(float4 left, float right) => new(left.x % right, left.y % right, left.z % right, left.w % right); + public static float4 operator %(float left, float4 right) => new(left % right.x, left % right.y, left % right.z, left % right.w); + + public static bool4 operator <(float4 left, float4 right) => new(left.x < right.x, left.y < right.y, left.z < right.z, left.w < right.w); + public static bool4 operator <(float4 left, float right) => new(left.x < right, left.y < right, left.z < right, left.w < right); + public static bool4 operator <(float left, float4 right) => new(left < right.x, left < right.y, left < right.z, left < right.w); + public static bool4 operator >(float4 left, float4 right) => new(left.x > right.x, left.y > right.y, left.z > right.z, left.w > right.w); + public static bool4 operator >(float4 left, float right) => new(left.x > right, left.y > right, left.z > right, left.w > right); + public static bool4 operator >(float left, float4 right) => new(left > right.x, left > right.y, left > right.z, left > right.w); + public static bool4 operator <=(float4 left, float4 right) => new(left.x <= right.x, left.y <= right.y, left.z <= right.z, left.w <= right.w); + public static bool4 operator <=(float4 left, float right) => new(left.x <= right, left.y <= right, left.z <= right, left.w <= right); + public static bool4 operator <=(float left, float4 right) => new(left <= right.x, left <= right.y, left <= right.z, left <= right.w); + public static bool4 operator >=(float4 left, float4 right) => new(left.x >= right.x, left.y >= right.y, left.z >= right.z, left.w >= right.w); + public static bool4 operator >=(float4 left, float right) => new(left.x >= right, left.y >= right, left.z >= right, left.w >= right); + public static bool4 operator >=(float left, float4 right) => new(left >= right.x, left >= right.y, left >= right.z, left >= right.w); + public static bool4 operator ==(float4 left, float4 right) => new(left.x == right.x, left.y == right.y, left.z == right.z, left.w == right.w); + public static bool4 operator ==(float4 left, float right) => new(left.x == right, left.y == right, left.z == right, left.w == right); + public static bool4 operator ==(float left, float4 right) => new(left == right.x, left == right.y, left == right.z, left == right.w); + public static bool4 operator !=(float4 left, float4 right) => new(left.x != right.x, left.y != right.y, left.z != right.z, left.w != right.w); + public static bool4 operator !=(float4 left, float right) => new(left.x != right, left.y != right, left.z != right, left.w != right); + public static bool4 operator !=(float left, float4 right) => new(left != right.x, left != right.y, left != right.z, left != right.w); + + public readonly bool Equals(float4 other) => x.Equals(other.x) && y.Equals(other.y) && z.Equals(other.z) && w.Equals(other.w); + public override readonly bool Equals(object? obj) => obj is float4 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z, w); + public override readonly string ToString() => FormattableString.Invariant($"float4({x:R}, {y:R}, {z:R}, {w:R})"); } diff --git a/packages/cultmath/src/CultMath/int2.cs b/packages/cultmath/src/CultMath/int2.cs index 7c2f350b..06b4c4f6 100644 --- a/packages/cultmath/src/CultMath/int2.cs +++ b/packages/cultmath/src/CultMath/int2.cs @@ -2,17 +2,38 @@ using System; namespace CultMath; -public record struct int2(int x, int y) +public struct int2 : IEquatable { public static readonly int2 zero = new(0, 0); public static readonly int2 one = new(1, 1); - public int this[int index] => index switch + public int x; + public int y; + + public int2(int x, int y) { - 0 => x, - 1 => y, - _ => throw new ArgumentOutOfRangeException(nameof(index)), - }; + this.x = x; + this.y = y; + } + + public int this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } public static implicit operator int2(int value) => new(value, value); public static implicit operator float2(int2 value) => new(value.x, value.y); @@ -26,4 +47,16 @@ public record struct int2(int x, int y) public static int2 operator *(int2 left, int2 right) => new(left.x * right.x, left.y * right.y); public static int2 operator /(int2 left, int2 right) => new(left.x / right.x, left.y / right.y); public static int2 operator %(int2 left, int2 right) => new(left.x % right.x, left.y % right.y); + + public static bool2 operator <(int2 left, int2 right) => new(left.x < right.x, left.y < right.y); + public static bool2 operator >(int2 left, int2 right) => new(left.x > right.x, left.y > right.y); + public static bool2 operator <=(int2 left, int2 right) => new(left.x <= right.x, left.y <= right.y); + public static bool2 operator >=(int2 left, int2 right) => new(left.x >= right.x, left.y >= right.y); + public static bool2 operator ==(int2 left, int2 right) => new(left.x == right.x, left.y == right.y); + public static bool2 operator !=(int2 left, int2 right) => new(left.x != right.x, left.y != right.y); + + public readonly bool Equals(int2 other) => x == other.x && y == other.y; + public override readonly bool Equals(object? obj) => obj is int2 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y); + public override readonly string ToString() => FormattableString.Invariant($"int2({x}, {y})"); } diff --git a/packages/cultmath/src/CultMath/int3.cs b/packages/cultmath/src/CultMath/int3.cs new file mode 100644 index 00000000..60cbff29 --- /dev/null +++ b/packages/cultmath/src/CultMath/int3.cs @@ -0,0 +1,64 @@ +using System; + +namespace CultMath; + +public struct int3 : IEquatable +{ + public static readonly int3 zero = new(0, 0, 0); + public static readonly int3 one = new(1, 1, 1); + + public int x; + public int y; + public int z; + + public int3(int x, int y, int z) + { + this.x = x; + this.y = y; + this.z = z; + } + + public int this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } + + public static implicit operator int3(int value) => new(value, value, value); + public static implicit operator float3(int3 value) => new(value.x, value.y, value.z); + + public static int3 operator +(int3 value) => value; + public static int3 operator -(int3 value) => new(-value.x, -value.y, -value.z); + public static int3 operator +(int3 left, int3 right) => new(left.x + right.x, left.y + right.y, left.z + right.z); + public static int3 operator -(int3 left, int3 right) => new(left.x - right.x, left.y - right.y, left.z - right.z); + public static int3 operator *(int3 left, int3 right) => new(left.x * right.x, left.y * right.y, left.z * right.z); + public static int3 operator /(int3 left, int3 right) => new(left.x / right.x, left.y / right.y, left.z / right.z); + public static int3 operator %(int3 left, int3 right) => new(left.x % right.x, left.y % right.y, left.z % right.z); + + public static bool3 operator <(int3 left, int3 right) => new(left.x < right.x, left.y < right.y, left.z < right.z); + public static bool3 operator >(int3 left, int3 right) => new(left.x > right.x, left.y > right.y, left.z > right.z); + public static bool3 operator <=(int3 left, int3 right) => new(left.x <= right.x, left.y <= right.y, left.z <= right.z); + public static bool3 operator >=(int3 left, int3 right) => new(left.x >= right.x, left.y >= right.y, left.z >= right.z); + public static bool3 operator ==(int3 left, int3 right) => new(left.x == right.x, left.y == right.y, left.z == right.z); + public static bool3 operator !=(int3 left, int3 right) => new(left.x != right.x, left.y != right.y, left.z != right.z); + + public readonly bool Equals(int3 other) => x == other.x && y == other.y && z == other.z; + public override readonly bool Equals(object? obj) => obj is int3 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z); + public override readonly string ToString() => FormattableString.Invariant($"int3({x}, {y}, {z})"); +} diff --git a/packages/cultmath/src/CultMath/int3.cs.meta b/packages/cultmath/src/CultMath/int3.cs.meta new file mode 100644 index 00000000..d0400303 --- /dev/null +++ b/packages/cultmath/src/CultMath/int3.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 42ee98aace354db19b3ae87bdcbc1df9 diff --git a/packages/cultmath/src/CultMath/int4.cs b/packages/cultmath/src/CultMath/int4.cs new file mode 100644 index 00000000..4c301203 --- /dev/null +++ b/packages/cultmath/src/CultMath/int4.cs @@ -0,0 +1,68 @@ +using System; + +namespace CultMath; + +public struct int4 : IEquatable +{ + public static readonly int4 zero = new(0, 0, 0, 0); + public static readonly int4 one = new(1, 1, 1, 1); + + public int x; + public int y; + public int z; + public int w; + + public int4(int x, int y, int z, int w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + + public int this[int index] + { + readonly get => index switch + { + 0 => x, + 1 => y, + 2 => z, + 3 => w, + _ => throw new ArgumentOutOfRangeException(nameof(index)), + }; + set + { + switch (index) + { + case 0: x = value; break; + case 1: y = value; break; + case 2: z = value; break; + case 3: w = value; break; + default: throw new ArgumentOutOfRangeException(nameof(index)); + } + } + } + + public static implicit operator int4(int value) => new(value, value, value, value); + public static implicit operator float4(int4 value) => new(value.x, value.y, value.z, value.w); + + public static int4 operator +(int4 value) => value; + public static int4 operator -(int4 value) => new(-value.x, -value.y, -value.z, -value.w); + public static int4 operator +(int4 left, int4 right) => new(left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w); + public static int4 operator -(int4 left, int4 right) => new(left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w); + public static int4 operator *(int4 left, int4 right) => new(left.x * right.x, left.y * right.y, left.z * right.z, left.w * right.w); + public static int4 operator /(int4 left, int4 right) => new(left.x / right.x, left.y / right.y, left.z / right.z, left.w / right.w); + public static int4 operator %(int4 left, int4 right) => new(left.x % right.x, left.y % right.y, left.z % right.z, left.w % right.w); + + public static bool4 operator <(int4 left, int4 right) => new(left.x < right.x, left.y < right.y, left.z < right.z, left.w < right.w); + public static bool4 operator >(int4 left, int4 right) => new(left.x > right.x, left.y > right.y, left.z > right.z, left.w > right.w); + public static bool4 operator <=(int4 left, int4 right) => new(left.x <= right.x, left.y <= right.y, left.z <= right.z, left.w <= right.w); + public static bool4 operator >=(int4 left, int4 right) => new(left.x >= right.x, left.y >= right.y, left.z >= right.z, left.w >= right.w); + public static bool4 operator ==(int4 left, int4 right) => new(left.x == right.x, left.y == right.y, left.z == right.z, left.w == right.w); + public static bool4 operator !=(int4 left, int4 right) => new(left.x != right.x, left.y != right.y, left.z != right.z, left.w != right.w); + + public readonly bool Equals(int4 other) => x == other.x && y == other.y && z == other.z && w == other.w; + public override readonly bool Equals(object? obj) => obj is int4 other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z, w); + public override readonly string ToString() => FormattableString.Invariant($"int4({x}, {y}, {z}, {w})"); +} diff --git a/packages/cultmath/src/CultMath/int4.cs.meta b/packages/cultmath/src/CultMath/int4.cs.meta new file mode 100644 index 00000000..48d0eaba --- /dev/null +++ b/packages/cultmath/src/CultMath/int4.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 1a313709f76a430eb83901bb2d05c74e diff --git a/packages/cultmath/src/CultMath/math.cs b/packages/cultmath/src/CultMath/math.cs index d0a56e76..3bed477b 100644 --- a/packages/cultmath/src/CultMath/math.cs +++ b/packages/cultmath/src/CultMath/math.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace CultMath; @@ -8,6 +8,22 @@ public static class math public const float TAU = MathF.PI * 2.0f; public const float HALF_PI = MathF.PI * 0.5f; + /// + /// Extrinsic Euler order for : + /// the first letter is the axis applied first. Nested here so using static CultMath.math; + /// brings it into scope with the rest of the shader vocabulary. + /// + public enum RotationOrder : byte + { + XYZ, + XZY, + YXZ, + YZX, + ZXY, + ZYX, + Default = ZXY, + } + public static float2 float2(float x, float y) => new(x, y); public static float2 float2(float value) => new(value, value); public static bool2 bool2(bool x, bool y) => new(x, y); @@ -22,6 +38,23 @@ public static class math public static float4 float4(float3 xyz, float w) => new(xyz, w); public static float4 float4(float x, float3 yzw) => new(x, yzw); public static float4 float4(float value) => new(value, value, value, value); + public static bool3 bool3(bool x, bool y, bool z) => new(x, y, z); + public static bool3 bool3(bool value) => new(value, value, value); + public static bool4 bool4(bool x, bool y, bool z, bool w) => new(x, y, z, w); + public static bool4 bool4(bool value) => new(value, value, value, value); + public static int3 int3(int x, int y, int z) => new(x, y, z); + public static int3 int3(int value) => new(value, value, value); + public static int4 int4(int x, int y, int z, int w) => new(x, y, z, w); + public static int4 int4(int value) => new(value, value, value, value); + + // Matrix constructor functions take rows, as HLSL does. Under `using static CultMath.math;` + // these method groups hide the type names in member access, so static members need a + // qualified type: `CultMath.float3x3.Euler(...)`, `CultMath.float2x2.Rotate(...)`. + public static float2x2 float2x2(float m00, float m01, float m10, float m11) => new(m00, m01, m10, m11); + public static float2x2 float2x2(float2 row0, float2 row1) => new(row0, row1); + public static float3x3 float3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) => + new(m00, m01, m02, m10, m11, m12, m20, m21, m22); + public static float3x3 float3x3(float3 row0, float3 row1, float3 row2) => new(row0, row1, row2); public static float radians(float degrees) => degrees * (PI / 180.0f); public static float degrees(float radians) => radians * (180.0f / PI); public static float sin(float value) => MathF.Sin(value); @@ -324,9 +357,149 @@ public static class math public static float hash(float2 value) => hash(dot(value, new float2(127.1f, 311.7f))); public static float hash(float3 value) => hash(dot(value, new float3(127.1f, 311.7f, 74.7f))); + public static float log(float value) => MathF.Log(value); + public static float2 log(float2 value) => new(log(value.x), log(value.y)); + public static float3 log(float3 value) => new(log(value.x), log(value.y), log(value.z)); + public static float4 log(float4 value) => new(log(value.x), log(value.y), log(value.z), log(value.w)); + + public static float2 pow(float2 value, float2 power) => new(pow(value.x, power.x), pow(value.y, power.y)); + public static float3 pow(float3 value, float3 power) => new(pow(value.x, power.x), pow(value.y, power.y), pow(value.z, power.z)); + public static float4 pow(float4 value, float4 power) => new(pow(value.x, power.x), pow(value.y, power.y), pow(value.z, power.z), pow(value.w, power.w)); + + public static float2 sqrt(float2 value) => new(sqrt(value.x), sqrt(value.y)); + public static float3 sqrt(float3 value) => new(sqrt(value.x), sqrt(value.y), sqrt(value.z)); + public static float4 sqrt(float4 value) => new(sqrt(value.x), sqrt(value.y), sqrt(value.z), sqrt(value.w)); + + public static float2 sin(float2 value) => new(sin(value.x), sin(value.y)); + public static float3 sin(float3 value) => new(sin(value.x), sin(value.y), sin(value.z)); + public static float4 sin(float4 value) => new(sin(value.x), sin(value.y), sin(value.z), sin(value.w)); + + public static float2 cos(float2 value) => new(cos(value.x), cos(value.y)); + public static float3 cos(float3 value) => new(cos(value.x), cos(value.y), cos(value.z)); + public static float4 cos(float4 value) => new(cos(value.x), cos(value.y), cos(value.z), cos(value.w)); + + public static float2 acos(float2 value) => new(acos(value.x), acos(value.y)); + public static float3 acos(float3 value) => new(acos(value.x), acos(value.y), acos(value.z)); + public static float4 acos(float4 value) => new(acos(value.x), acos(value.y), acos(value.z), acos(value.w)); + + public static float2 atan2(float2 y, float2 x) => new(atan2(y.x, x.x), atan2(y.y, x.y)); + public static float3 atan2(float3 y, float3 x) => new(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)); + public static float4 atan2(float4 y, float4 x) => new(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)); + + public static double min(double left, double right) => Math.Min(left, right); + public static double max(double left, double right) => Math.Max(left, right); + + public static bool any(bool2 value) => value.x || value.y; + public static bool any(bool3 value) => value.x || value.y || value.z; + public static bool any(bool4 value) => value.x || value.y || value.z || value.w; + public static bool all(bool2 value) => value.x && value.y; + public static bool all(bool3 value) => value.x && value.y && value.z; + public static bool all(bool4 value) => value.x && value.y && value.z && value.w; + + // HLSL 2021 argument order: select(condition, whenTrue, whenFalse). + // Unity.Mathematics' select(falseValue, trueValue, condition) is the reverse. + public static float select(bool condition, float whenTrue, float whenFalse) => condition ? whenTrue : whenFalse; + public static float2 select(bool2 condition, float2 whenTrue, float2 whenFalse) => + new(condition.x ? whenTrue.x : whenFalse.x, condition.y ? whenTrue.y : whenFalse.y); + public static float3 select(bool3 condition, float3 whenTrue, float3 whenFalse) => + new(condition.x ? whenTrue.x : whenFalse.x, condition.y ? whenTrue.y : whenFalse.y, condition.z ? whenTrue.z : whenFalse.z); + public static float4 select(bool4 condition, float4 whenTrue, float4 whenFalse) => + new(condition.x ? whenTrue.x : whenFalse.x, condition.y ? whenTrue.y : whenFalse.y, condition.z ? whenTrue.z : whenFalse.z, condition.w ? whenTrue.w : whenFalse.w); + + // HLSL mul: mul(m, v) treats v as a column vector, mul(v, m) as a row vector. + public static float mul(float left, float right) => left * right; + + public static float2 mul(float2x2 m, float2 v) => + new(m._m00 * v.x + m._m01 * v.y, m._m10 * v.x + m._m11 * v.y); + + public static float2 mul(float2 v, float2x2 m) => + new(v.x * m._m00 + v.y * m._m10, v.x * m._m01 + v.y * m._m11); + + public static float2x2 mul(float2x2 a, float2x2 b) => + new( + a._m00 * b._m00 + a._m01 * b._m10, a._m00 * b._m01 + a._m01 * b._m11, + a._m10 * b._m00 + a._m11 * b._m10, a._m10 * b._m01 + a._m11 * b._m11); + + public static float3 mul(float3x3 m, float3 v) => + new( + m._m00 * v.x + m._m01 * v.y + m._m02 * v.z, + m._m10 * v.x + m._m11 * v.y + m._m12 * v.z, + m._m20 * v.x + m._m21 * v.y + m._m22 * v.z); + + public static float3 mul(float3 v, float3x3 m) => + new( + v.x * m._m00 + v.y * m._m10 + v.z * m._m20, + v.x * m._m01 + v.y * m._m11 + v.z * m._m21, + v.x * m._m02 + v.y * m._m12 + v.z * m._m22); + + public static float3x3 mul(float3x3 a, float3x3 b) => + new( + a._m00 * b._m00 + a._m01 * b._m10 + a._m02 * b._m20, + a._m00 * b._m01 + a._m01 * b._m11 + a._m02 * b._m21, + a._m00 * b._m02 + a._m01 * b._m12 + a._m02 * b._m22, + a._m10 * b._m00 + a._m11 * b._m10 + a._m12 * b._m20, + a._m10 * b._m01 + a._m11 * b._m11 + a._m12 * b._m21, + a._m10 * b._m02 + a._m11 * b._m12 + a._m12 * b._m22, + a._m20 * b._m00 + a._m21 * b._m10 + a._m22 * b._m20, + a._m20 * b._m01 + a._m21 * b._m11 + a._m22 * b._m21, + a._m20 * b._m02 + a._m21 * b._m12 + a._m22 * b._m22); + + // Ashima Arts / Ian McEwan 3D simplex noise (MIT), mirrored by cultmath_snoise(float3) + // in shaders/CultMath.hlsl with the same float32 evaluation order. + public static float snoise(float3 value) + { + const float cx = 1.0f / 6.0f; + const float cy = 1.0f / 3.0f; + var i = floor(value + dot(value, new float3(cy, cy, cy))); + var x0 = value - i + dot(i, new float3(cx, cx, cx)); + var g = step(new float3(x0.y, x0.z, x0.x), x0); + var l = 1.0f - g; + var lzxy = new float3(l.z, l.x, l.y); + var i1 = min(g, lzxy); + var i2 = max(g, lzxy); + var x1 = x0 - i1 + cx; + var x2 = x0 - i2 + cy; + var x3 = x0 - 0.5f; + + i = snoise_mod289(i); + var p = snoise_permute(snoise_permute(snoise_permute( + i.z + new float4(0.0f, i1.z, i2.z, 1.0f)) + i.y + new float4(0.0f, i1.y, i2.y, 1.0f)) + i.x + new float4(0.0f, i1.x, i2.x, 1.0f)); + + const float n = 0.142857142857f; + var ns = new float3(2.0f * n, 0.5f * n - 1.0f, n); + var j = p - 49.0f * floor(p * ns.z * ns.z); + var xs = floor(j * ns.z); + var ys = floor(j - 7.0f * xs); + var x = xs * ns.x + ns.y; + var y = ys * ns.x + ns.y; + var h = 1.0f - abs(x) - abs(y); + + var b0 = new float4(x.x, x.y, y.x, y.y); + var b1 = new float4(x.z, x.w, y.z, y.w); + var s0 = floor(b0) * 2.0f + 1.0f; + var s1 = floor(b1) * 2.0f + 1.0f; + var sh = -step(h, 0.0f); + var a0 = new float4(b0.x, b0.z, b0.y, b0.w) + new float4(s0.x, s0.z, s0.y, s0.w) * new float4(sh.x, sh.x, sh.y, sh.y); + var a1 = new float4(b1.x, b1.z, b1.y, b1.w) + new float4(s1.x, s1.z, s1.y, s1.w) * new float4(sh.z, sh.z, sh.w, sh.w); + + var p0 = new float3(a0.x, a0.y, h.x); + var p1 = new float3(a0.z, a0.w, h.y); + var p2 = new float3(a1.x, a1.y, h.z); + var p3 = new float3(a1.z, a1.w, h.w); + var norm = 1.79284291400159f - 0.85373472095314f * new 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; + + var m = max(0.6f - new float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0f); + m = m * m; + return 42.0f * dot(m * m, new float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); + } + // Ashima Arts / Ian McEwan 2D simplex noise, kept component-explicit so // the C# and HLSL mirrors preserve the same float32 evaluation order. - public static float simplex_noise(float2 value) + public static float snoise(float2 value) { var c = new float4( 0.211324865405187f, @@ -342,8 +515,8 @@ public static class math x0.x + c.z, x0.y + c.z); - i = simplex_mod289(i); - var p = simplex_permute(simplex_permute(i.y + new float3(0.0f, i1.y, 1.0f)) + i.x + new float3(0.0f, i1.x, 1.0f)); + i = snoise_mod289(i); + var p = snoise_permute(snoise_permute(i.y + new float3(0.0f, i1.y, 1.0f)) + i.x + new float3(0.0f, i1.x, 1.0f)); var m = max(0.5f - new float3( dot(x0, x0), x12.x * x12.x + x12.y * x12.y, @@ -364,9 +537,11 @@ public static class math return 130.0f * dot(m, g); } - private static float2 simplex_mod289(float2 value) => value - floor(value * (1.0f / 289.0f)) * 289.0f; - private static float3 simplex_mod289(float3 value) => value - floor(value * (1.0f / 289.0f)) * 289.0f; - private static float3 simplex_permute(float3 value) => simplex_mod289(((value * 34.0f) + 1.0f) * value); + private static float2 snoise_mod289(float2 value) => value - floor(value * (1.0f / 289.0f)) * 289.0f; + private static float3 snoise_mod289(float3 value) => value - floor(value * (1.0f / 289.0f)) * 289.0f; + private static float4 snoise_mod289(float4 value) => value - floor(value * (1.0f / 289.0f)) * 289.0f; + private static float3 snoise_permute(float3 value) => snoise_mod289(((value * 34.0f) + 1.0f) * value); + private static float4 snoise_permute(float4 value) => snoise_mod289(((value * 34.0f) + 1.0f) * value); public static float value_noise(float2 position) { diff --git a/packages/cultmath/src/CultMath/quaternion.cs b/packages/cultmath/src/CultMath/quaternion.cs index fe8dda8e..e8c4a48c 100644 --- a/packages/cultmath/src/CultMath/quaternion.cs +++ b/packages/cultmath/src/CultMath/quaternion.cs @@ -1,9 +1,28 @@ +using System; + namespace CultMath; -public record struct quaternion(float x, float y, float z, float w) +/// +/// Not an HLSL type: shaders carry rotations as float4. Equality therefore stays +/// scalar (== returns bool) instead of following the component-wise vector rule. +/// +public struct quaternion : IEquatable { public static readonly quaternion identity = new(0.0f, 0.0f, 0.0f, 1.0f); + public float x; + public float y; + public float z; + public float w; + + public quaternion(float x, float y, float z, float w) + { + this.x = x; + this.y = y; + this.z = z; + this.w = w; + } + public static quaternion LookRotation(float3 forward, float3 up) { forward = math.normalize(forward); @@ -65,4 +84,12 @@ public record struct quaternion(float x, float y, float z, float w) public static implicit operator quaternion(float4 value) => new(value.x, value.y, value.z, value.w); public static implicit operator float4(quaternion value) => new(value.x, value.y, value.z, value.w); + + public static bool operator ==(quaternion left, quaternion right) => left.Equals(right); + public static bool operator !=(quaternion left, quaternion right) => !left.Equals(right); + + public readonly bool Equals(quaternion other) => x.Equals(other.x) && y.Equals(other.y) && z.Equals(other.z) && w.Equals(other.w); + public override readonly bool Equals(object? obj) => obj is quaternion other && Equals(other); + public override readonly int GetHashCode() => HashCode.Combine(x, y, z, w); + public override readonly string ToString() => FormattableString.Invariant($"quaternion({x:R}, {y:R}, {z:R}, {w:R})"); } diff --git a/packages/cultmath/tests/CultMath.Tests/HlslMirrorTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslMirrorTests.cs index 0034a283..445ad255 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslMirrorTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslMirrorTests.cs @@ -42,7 +42,8 @@ public sealed class HlslMirrorTests "cultmath_cubic_bezier", "cultmath_hash", "cultmath_value_noise", - "cultmath_simplex_noise", + "cultmath_snoise(float2", + "cultmath_snoise(float3", "cultmath_value_noise_bicubic", "cultmath_value_noise_texture", "cultmath_value_noise_texture_bicubic", diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs new file mode 100644 index 00000000..bdb41cbf --- /dev/null +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs @@ -0,0 +1,332 @@ +using System.Text.Json; +using Xunit; + +namespace CultMath.Tests; + +public sealed class HlslSemanticsTests +{ + [Fact] + public void ComponentsAndIndexersAreWritable() + { + var value = new float4(1.0f, 2.0f, 3.0f, 4.0f); + value.w = 9.0f; + value[0] = -1.0f; + + Assert.Equal(new float4(-1.0f, 2.0f, 3.0f, 9.0f), value); + + var cell = new int3(1, 2, 3); + cell[2] = 7; + Assert.Equal(new int3(1, 2, 7), cell); + + ref var component = ref value.y; + component = 20.0f; + Assert.Equal(20.0f, value.y); + } + + [Fact] + public void Float2SwizzlesReadAndWrite() + { + var value = new float2(1.0f, 2.0f); + Assert.Equal(new float2(2.0f, 1.0f), value.yx); + + value.yx = new float2(5.0f, 6.0f); + Assert.Equal(new float2(6.0f, 5.0f), value); + } + + [Fact] + public void Float3SwizzlesReadAndWrite() + { + var source = new float3(1.0f, 2.0f, 3.0f); + Assert.Equal(new float2(1.0f, 2.0f), source.xy); + Assert.Equal(new float2(1.0f, 3.0f), source.xz); + Assert.Equal(new float2(2.0f, 1.0f), source.yx); + Assert.Equal(new float2(2.0f, 3.0f), source.yz); + Assert.Equal(new float2(3.0f, 2.0f), source.zy); + Assert.Equal(new float3(1.0f, 2.0f, 3.0f), source.xyz); + Assert.Equal(new float3(1.0f, 3.0f, 2.0f), source.xzy); + Assert.Equal(new float3(2.0f, 3.0f, 1.0f), source.yzx); + Assert.Equal(new float3(3.0f, 2.0f, 1.0f), source.zyx); + + Assert.Equal(new float3(8.0f, 9.0f, 3.0f), Write(source, (ref float3 v) => v.xy = new float2(8.0f, 9.0f))); + Assert.Equal(new float3(8.0f, 2.0f, 9.0f), Write(source, (ref float3 v) => v.xz = new float2(8.0f, 9.0f))); + Assert.Equal(new float3(9.0f, 8.0f, 3.0f), Write(source, (ref float3 v) => v.yx = new float2(8.0f, 9.0f))); + Assert.Equal(new float3(1.0f, 8.0f, 9.0f), Write(source, (ref float3 v) => v.yz = new float2(8.0f, 9.0f))); + Assert.Equal(new float3(1.0f, 9.0f, 8.0f), Write(source, (ref float3 v) => v.zy = new float2(8.0f, 9.0f))); + Assert.Equal(new float3(7.0f, 8.0f, 9.0f), Write(source, (ref float3 v) => v.xyz = new float3(7.0f, 8.0f, 9.0f))); + Assert.Equal(new float3(7.0f, 9.0f, 8.0f), Write(source, (ref float3 v) => v.xzy = new float3(7.0f, 8.0f, 9.0f))); + Assert.Equal(new float3(9.0f, 7.0f, 8.0f), Write(source, (ref float3 v) => v.yzx = new float3(7.0f, 8.0f, 9.0f))); + Assert.Equal(new float3(9.0f, 8.0f, 7.0f), Write(source, (ref float3 v) => v.zyx = new float3(7.0f, 8.0f, 9.0f))); + } + + [Fact] + public void Float4SwizzlesReadAndWrite() + { + var source = new float4(1.0f, 2.0f, 3.0f, 4.0f); + Assert.Equal(new float2(1.0f, 2.0f), source.xy); + Assert.Equal(new float3(1.0f, 2.0f, 3.0f), source.xyz); + Assert.Equal(new float3(1.0f, 2.0f, 4.0f), source.xyw); + Assert.Equal(new float3(2.0f, 3.0f, 1.0f), source.yzx); + + var a = source; + a.xy = new float2(8.0f, 9.0f); + Assert.Equal(new float4(8.0f, 9.0f, 3.0f, 4.0f), a); + + var b = source; + b.xyz = new float3(7.0f, 8.0f, 9.0f); + Assert.Equal(new float4(7.0f, 8.0f, 9.0f, 4.0f), b); + + var c = source; + c.xyw = new float3(7.0f, 8.0f, 9.0f); + Assert.Equal(new float4(7.0f, 8.0f, 3.0f, 9.0f), c); + + var d = source; + d.yzx = new float3(7.0f, 8.0f, 9.0f); + Assert.Equal(new float4(9.0f, 7.0f, 8.0f, 4.0f), d); + } + + [Fact] + public void ComparisonOperatorsReturnComponentWiseBoolVectors() + { + var a = new float3(1.0f, 2.0f, 3.0f); + var b = new float3(3.0f, 2.0f, 1.0f); + + Assert.Equal(new bool3(true, false, false), a < b); + Assert.Equal(new bool3(false, false, true), a > b); + Assert.Equal(new bool3(true, true, false), a <= b); + Assert.Equal(new bool3(false, true, true), a >= b); + Assert.Equal(new bool3(false, true, false), a == b); + Assert.Equal(new bool3(true, false, true), a != b); + + Assert.Equal(new bool3(true, false, false), a < 2.0f); + Assert.Equal(new bool3(false, false, true), 2.0f < a); + Assert.Equal(new bool2(true, false), new float2(0.0f, 1.0f) == 0.0f); + Assert.Equal(new bool4(false, true, true, true), new float4(0.0f, 1.0f, 2.0f, 3.0f) >= 1.0f); + Assert.Equal(new bool2(false, true), new int2(1, 2) > new int2(1, 1)); + Assert.Equal(new bool3(true, false, true), new int3(1, 2, 3) != new int3(0, 2, 4)); + Assert.Equal(new bool4(true, true, false, false), new int4(1, 2, 3, 4) <= new int4(1, 2, 2, 2)); + Assert.Equal(new bool2(true, false), new double2(0.5, 1.0) < new double2(1.0, 1.0)); + Assert.Equal(new bool3(false, false, true), new double3(1.0, 1.0, 2.0) > new double3(1.0, 1.0, 1.0)); + } + + [Fact] + public void ScalarOperatorsApplyPerComponentOnBothSides() + { + var value = new float3(1.0f, 2.0f, 4.0f); + + Assert.Equal(new float3(3.0f, 2.0f, 0.0f), 4.0f - value); + Assert.Equal(new float3(0.0f, 1.0f, 3.0f), value - 1.0f); + Assert.Equal(new float3(2.0f, 3.0f, 5.0f), 1.0f + value); + Assert.Equal(new float3(4.0f, 2.0f, 1.0f), 4.0f / value); + Assert.Equal(new float3(0.5f, 1.0f, 2.0f), value / 2.0f); + Assert.Equal(new float3(2.0f, 4.0f, 8.0f), 2.0f * value); + Assert.Equal(new float3(1.0f, 0.0f, 0.0f), value % 2.0f); + Assert.Equal(new float2(1.5f, 2.5f), new float2(1.0f, 2.0f) + 0.5f); + Assert.Equal(new float4(0.0f, 1.0f, 2.0f, 3.0f), new float4(1.0f, 2.0f, 3.0f, 4.0f) - 1.0f); + } + + [Fact] + public void EqualsAndHashCodeStayValueBasedForDictionaryKeys() + { + var map = new Dictionary { [new float3(1.0f, 2.0f, 3.0f)] = "hit" }; + Assert.Equal("hit", map[new float3(1.0f, 2.0f, 3.0f)]); + Assert.False(map.ContainsKey(new float3(1.0f, 2.0f, 3.5f))); + + var cells = new HashSet { new int2(3, 4) }; + Assert.Contains(new int2(3, 4), cells); + Assert.Contains(new int3(1, 2, 3), new HashSet { new int3(1, 2, 3) }); + + var nan = new float2(float.NaN, 0.0f); + var sameNan = nan; + Assert.True(nan.Equals(sameNan)); + Assert.False((nan == sameNan).x); + + Assert.True(new quaternion(0.0f, 0.0f, 0.0f, 1.0f) == quaternion.identity); + Assert.Equal(float2x2.identity, math.float2x2(1.0f, 0.0f, 0.0f, 1.0f)); + Assert.Equal("float3(1, 2.5, -3)", new float3(1.0f, 2.5f, -3.0f).ToString()); + } + + [Fact] + public void AnyAllAndSelectFollowHlsl() + { + Assert.True(math.any(new bool2(false, true))); + Assert.False(math.any(bool3.@false)); + Assert.True(math.all(bool4.@true)); + Assert.False(math.all(new bool3(true, false, true))); + + var mask = new bool3(true, false, true); + Assert.Equal(new float3(1.0f, 20.0f, 3.0f), math.select(mask, new float3(1.0f, 2.0f, 3.0f), new float3(10.0f, 20.0f, 30.0f))); + Assert.Equal(7.0f, math.select(true, 7.0f, 8.0f)); + Assert.Equal(new float2(0.0f, 5.0f), math.select(new bool2(false, true), math.float2(5.0f), math.float2(0.0f))); + Assert.Equal(new float4(1.0f, 0.0f, 1.0f, 0.0f), math.select(new bool4(true, false, true, false), 1.0f, 0.0f)); + + Assert.Equal(new bool2(false, true), !new bool2(true, false)); + Assert.Equal(new bool3(true, false, false), new bool3(true, true, false) & new bool3(true, false, true)); + Assert.Equal(new bool3(true, true, true), new bool3(true, true, false) | new bool3(true, false, true)); + } + + [Fact] + public void AddedIntrinsicsAreComponentWise() + { + Assert.Equal(MathF.Log(3.0f), math.log(3.0f)); + Assert.Equal(new float3(0.0f, MathF.Log(2.0f), MathF.Log(4.0f)), math.log(new float3(1.0f, 2.0f, 4.0f))); + Assert.Equal(new float2(8.0f, 9.0f), math.pow(new float2(2.0f, 3.0f), new float2(3.0f, 2.0f))); + Assert.Equal(new float4(1.0f, 2.0f, 3.0f, 4.0f), math.sqrt(new float4(1.0f, 4.0f, 9.0f, 16.0f))); + var sines = math.sin(new float3(0.0f, math.HALF_PI, math.PI)); + Assert.Equal(0.0f, sines.x, precision: 5); + Assert.Equal(1.0f, sines.y, precision: 5); + Assert.Equal(0.0f, sines.z, precision: 5); + var cosines = math.cos(new float2(0.0f, math.PI)); + Assert.Equal(1.0f, cosines.x, precision: 5); + Assert.Equal(-1.0f, cosines.y, precision: 5); + var arccosines = math.acos(new float3(1.0f, 0.0f, -1.0f)); + Assert.Equal(0.0f, arccosines.x, precision: 5); + Assert.Equal(math.HALF_PI, arccosines.y, precision: 5); + Assert.Equal(math.PI, arccosines.z, precision: 5); + Assert.Equal(math.atan2(1.0f, -1.0f), math.atan2(new float2(1.0f, 0.0f), new float2(-1.0f, 1.0f)).x); + Assert.Equal(0.0f, math.atan2(new float4(1.0f, 0.0f, 1.0f, 0.0f), new float4(1.0f, 1.0f, 1.0f, 1.0f)).y); + Assert.Equal(2.5, math.min(2.5, 3.5)); + Assert.Equal(3.5, math.max(2.5, 3.5)); + } + + [Fact] + public void IntVectorsPromoteToFloatVectors() + { + float3 promoted3 = new int3(1, 2, 3); + float4 promoted4 = new int4(1, 2, 3, 4); + + Assert.Equal(new float3(1.0f, 2.0f, 3.0f), promoted3); + Assert.Equal(new float4(1.0f, 2.0f, 3.0f, 4.0f), promoted4); + Assert.Equal(new int3(2, 4, 6), new int3(1, 2, 3) * 2); + Assert.Equal(new int4(1, 0, 1, 0), new int4(3, 4, 5, 6) % 2); + Assert.Equal(new int3(1, 2, 3), math.int3(1, 2, 3)); + Assert.Equal(new int4(5, 5, 5, 5), math.int4(5)); + } + + [Fact] + public void MatrixMulFollowsHlslRowMajorConvention() + { + var m = math.float2x2(1.0f, 2.0f, 3.0f, 4.0f); + var v = new float2(5.0f, 6.0f); + + Assert.Equal(new float2(1.0f, 2.0f), m[0]); + Assert.Equal(new float2(17.0f, 39.0f), math.mul(m, v)); + Assert.Equal(new float2(23.0f, 34.0f), math.mul(v, m)); + Assert.Equal(math.float2x2(7.0f, 10.0f, 15.0f, 22.0f), math.mul(m, m)); + + var m3 = math.float3x3(new float3(1.0f, 2.0f, 3.0f), new float3(4.0f, 5.0f, 6.0f), new float3(7.0f, 8.0f, 9.0f)); + var v3 = new float3(1.0f, 0.0f, -1.0f); + Assert.Equal(new float3(-2.0f, -2.0f, -2.0f), math.mul(m3, v3)); + Assert.Equal(new float3(-6.0f, -6.0f, -6.0f), math.mul(v3, m3)); + Assert.Equal(math.float3x3(30.0f, 36.0f, 42.0f, 66.0f, 81.0f, 96.0f, 102.0f, 126.0f, 150.0f), math.mul(m3, m3)); + Assert.Equal(m3, math.mul(m3, float3x3.identity)); + + m3[1] = new float3(0.0f, 1.0f, 0.0f); + Assert.Equal(1.0f, m3._m11); + Assert.Equal(12.0f, math.mul(3.0f, 4.0f)); + } + + [Fact] + public void Float2x2RotateMatchesRotateAndUnityMathematics() + { + var rotation = float2x2.Rotate(0.5f); + var column = math.mul(rotation, new float2(1.0f, 0.0f)); + var row = math.mul(new float2(1.0f, 0.0f), rotation); + var reference = math.rotate(new float2(1.0f, 0.0f), 0.5f); + + Assert.Equal(reference.x, column.x, precision: 6); + Assert.Equal(reference.y, column.y, precision: 6); + + // Unity.Mathematics 1.x reference values: mul(float2(1, 0), float2x2.Rotate(0.5f)). + Assert.Equal(0.87758255f, row.x, precision: 6); + Assert.Equal(-0.47942555f, row.y, precision: 6); + } + + [Fact] + public void Float3x3EulerMatchesUnityMathematicsReference() + { + // Unity.Mathematics 1.x reference values captured from float3x3.Euler. + AssertRows( + float3x3.Euler(new float3(0.4f, -0.7f, 1.3f), math.RotationOrder.YXZ), + 0.44632244f, -0.8874959f, 0.114662126f, + 0.6698625f, 0.24638279f, -0.700414f, + 0.59336376f, 0.38941833f, 0.70446634f); + AssertRows( + float3x3.Euler(new float3(0.4f, -0.7f, 1.3f)), + -0.037133574f, -0.8040775f, -0.59336376f, + 0.8874959f, 0.24638279f, -0.38941833f, + 0.45931715f, -0.5410684f, 0.70446634f); + + // Aetheria ActionGameManager view direction: mul(float3(0, 0, 1), Euler(float3(yawPitch.yx, 0), YXZ)). + var yawPitch = new float2(0.3f, -1.1f); + var view = math.mul(new float3(0.0f, 0.0f, 1.0f), float3x3.Euler(new float3(yawPitch.yx, 0.0f), math.RotationOrder.YXZ)); + Assert.Equal(-0.13404681f, view.x, precision: 5); + Assert.Equal(-0.8912074f, view.y, precision: 5); + Assert.Equal(0.4333369f, view.z, precision: 5); + + var composed = math.mul(float3x3.RotateZ(0.2f), math.mul(float3x3.RotateY(0.3f), float3x3.RotateX(0.1f))); + AssertRows(float3x3.Euler(0.1f, 0.3f, 0.2f, math.RotationOrder.XYZ), + composed._m00, composed._m01, composed._m02, + composed._m10, composed._m11, composed._m12, + composed._m20, composed._m21, composed._m22); + } + + [Theory] + [InlineData(0.0f, 0.0f, 0.0f, -0.41219875f)] + [InlineData(0.25f, -0.5f, 1.75f, 0.5250269f)] + [InlineData(12.25f, -4.5f, 3.125f, 0.008141451f)] + [InlineData(-7.3f, 2.9f, 101.4f, 0.578015f)] + public void Snoise3MatchesUnityMathematicsReference(float x, float y, float z, float expected) + { + Assert.Equal(expected, math.snoise(new float3(x, y, z)), precision: 5); + } + + [Fact] + public void RandomFloat3OverloadsShareOneDrawOrder() + { + var a = new Random(99); + var b = new Random(99); + var c = new Random(99); + + var unit = a.NextFloat3(); + Assert.Equal(new float3(b.NextFloat(), b.NextFloat(), b.NextFloat()), unit); + Assert.Equal(unit * new float3(2.0f, 4.0f, 8.0f), c.NextFloat3(new float3(2.0f, 4.0f, 8.0f))); + + var d = new Random(99); + Assert.Equal(math.float3(-1.0f) + unit * 2.0f, d.NextFloat3(math.float3(-1.0f), math.float3(1.0f))); + } + + [Fact] + public void CoreAssemblyStaysEngineFree() + { + var references = typeof(math).Assembly.GetReferencedAssemblies(); + Assert.DoesNotContain(references, reference => reference.Name!.StartsWith("UnityEngine", StringComparison.Ordinal)); + + var root = new DirectoryInfo(AppContext.BaseDirectory); + while (root is not null && !File.Exists(Path.Combine(root.FullName, "packages", "cultmath", "src", "CultMath", "CultMath.asmdef"))) + { + root = root.Parent; + } + + Assert.NotNull(root); + var asmdefPath = Path.Combine(root!.FullName, "packages", "cultmath", "src", "CultMath", "CultMath.asmdef"); + using var asmdef = JsonDocument.Parse(File.ReadAllText(asmdefPath)); + Assert.True(asmdef.RootElement.GetProperty("noEngineReferences").GetBoolean()); + } + + private static float3 Write(float3 value, WriteAction action) + { + action(ref value); + return value; + } + + private delegate void WriteAction(ref float3 value); + + private static void AssertRows(float3x3 m, params float[] expected) + { + var actual = new[] { m._m00, m._m01, m._m02, m._m10, m._m11, m._m12, m._m20, m._m21, m._m22 }; + for (var index = 0; index < expected.Length; index++) + { + Assert.Equal(expected[index], actual[index], precision: 5); + } + } +} diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs.meta b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs.meta new file mode 100644 index 00000000..8158a66d --- /dev/null +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 7164d00a023e43578a31897347d8f106 diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs new file mode 100644 index 00000000..575952c3 --- /dev/null +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -0,0 +1,85 @@ +using Xunit; +using static CultMath.math; + +namespace CultMath.Tests; + +/// +/// HLSL written against CultMath compiles as C# under using static CultMath.math;. +/// The only spelling C# forces is float literal suffixes (0.5f): an unsuffixed +/// literal is a double in C#. +/// +public sealed class HlslSourceCompatibilityTests +{ + // ---- HLSL-shaped source: keep this block free of C#-only constructs. ---- + static float3 shade(float3 position, float3 normal, float2 wind, float time) + { + float3 p = position; + p.xz = p.xz + wind * time; + p.y = saturate(p.y); + + float3x3 basis = float3x3(float3(1, 0, 0), float3(0, 1, 0), float3(0, 0, 1)); + float3 n = normalize(mul(basis, normal)); + float ndotl = saturate(dot(n, normalize(float3(0.3f, 1, 0.2f)))); + float3 color = lerp(float3(0.1f, 0.1f, 0.2f), float3(1, 0.9f, 0.7f), ndotl); + + if (any(p < 0.0f)) + color *= 0.5f; + if (all(abs(n) <= 1.0f)) + color.yzx = color.yzx * float3(1, 1, 1); + + color = select(p > 10.0f, float3(0), color); + float2 uv = frac(p.xz * 0.25f); + color.xy = lerp(color.xy, uv, 0.1f); + return color; + } + + static float2 steer(float2 direction, float torque) + { + float2x2 turn = float2x2(cos(torque), -sin(torque), sin(torque), cos(torque)); + float2 turned = mul(direction, turn); + return normalize(turned) * pow(length(turned), 1.0f); + } + + static float fbm(float3 p, int octaves) + { + float sum = 0.0f; + float amp = 0.5f; + float freq = 1.0f; + for (int i = 0; i < octaves; i++) + { + sum += abs(snoise(p * freq)) * amp; + freq *= 2.0f; + amp *= 0.5f; + } + return sum; + } + // ---- end HLSL-shaped source ---- + + [Fact] + public void ShaderStyleMathCompilesAndEvaluates() + { + var color = shade(new float3(1.0f, 0.5f, 2.0f), new float3(0.0f, 1.0f, 0.0f), new float2(1.0f, 0.0f), 0.0f); + + Assert.True(color.x > 0.1f && color.x <= 1.0f); + Assert.True(float.IsFinite(color.y) && float.IsFinite(color.z)); + + var far = shade(new float3(20.0f, 20.0f, 20.0f), new float3(0.0f, 1.0f, 0.0f), float2(0.0f), 0.0f); + Assert.Equal(0.0f, far.z); + } + + [Fact] + public void AetheriaStyleRotationAndNoiseCompile() + { + var steered = steer(new float2(1.0f, 0.0f), 0.5f); + var viaRotate = mul(new float2(1.0f, 0.0f), CultMath.float2x2.Rotate(0.5f)); + + Assert.Equal(viaRotate.x, steered.x, precision: 5); + Assert.Equal(viaRotate.y, steered.y, precision: 5); + + var view = mul(float3(0, 0, 1), CultMath.float3x3.Euler(float3(float2(0.3f, -1.1f).yx, 0), RotationOrder.YXZ)); + Assert.Equal(1.0f, length(view), precision: 5); + + var noise = fbm(float3(1.5f, -2.25f, 0.75f), 4); + Assert.InRange(noise, 0.0f, 1.0f); + } +} diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs.meta b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs.meta new file mode 100644 index 00000000..0d673e1e --- /dev/null +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 942fbcb9c28a4e559e5baf435dc24cf1 diff --git a/packages/cultmath/tests/CultMath.Tests/MathTests.cs b/packages/cultmath/tests/CultMath.Tests/MathTests.cs index 652ba23a..956bea08 100644 --- a/packages/cultmath/tests/CultMath.Tests/MathTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/MathTests.cs @@ -33,7 +33,7 @@ public sealed class MathTests } [Fact] - public void VectorsExposeCommonReadOnlySwizzles() + public void VectorsExposeCommonSwizzles() { Assert.Equal(new float3(2.0f, 3.0f, 1.0f), new float3(1.0f, 2.0f, 3.0f).yzx); Assert.Equal(new float3(3.0f, 2.0f, 1.0f), new float3(1.0f, 2.0f, 3.0f).zyx); @@ -277,7 +277,7 @@ public sealed class MathTests [InlineData(536.5106f, 536.5106f, -0.6901103f)] public void SimplexNoiseMatchesUnityMathematics(float x, float y, float expected) { - Assert.Equal(expected, math.simplex_noise(new float2(x, y)), precision: 6); + Assert.Equal(expected, math.snoise(new float2(x, y)), precision: 6); } [Fact] From 23cc86c4e9cabfa3b64e9c83b88d07f48b256ea1 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:30:00 +0200 Subject: [PATCH 02/20] Ship CultMath 0.2.0 to Unity with a UnityEngine conversion bridge - Bump GameCult.Math and org.gamecult.cultmath to 0.2.0; the CultCache Unity tools package now depends on cultmath 0.2.0. - Rebuild the tracked netstandard2.1 CultMath.dll/pdb with the builder's deterministic command; build-unity-package.ps1 verifies it byte-for-byte. - Add Runtime/UnityBridge (CultMath.UnityBridge asmdef) with ToCultMath / ToUnity / ToColor extension methods for Vector2/3/4, Vector2Int/3Int, Quaternion and Color. C# only admits conversion operators on the source or target type, and the core DLL stays engine-free. - The builder admits exactly that one bridge assembly: it must reference UnityEngine and CultMath.dll, and no core source may be compiled in the package. - Sync the Unity copy of CultMath.hlsl and the third-party notice. Co-Authored-By: Claude Opus 5 --- packages/cultmath/THIRD-PARTY-NOTICES.md | 6 +- .../cultmath/scripts/build-unity-package.ps1 | 41 ++++++++---- .../cultmath/src/CultMath/CultMath.csproj | 4 +- .../unity/org.gamecult.cultmath/README.md | 12 +++- .../Runtime/Plugins/CultMath.dll | Bin 47104 -> 66048 bytes .../Runtime/Plugins/CultMath.pdb | Bin 23936 -> 33440 bytes .../Runtime/UnityBridge.meta | 8 +++ .../UnityBridge/CultMath.UnityBridge.asmdef | 16 +++++ .../CultMath.UnityBridge.asmdef.meta | 7 ++ .../Runtime/UnityBridge/UnityConversions.cs | 28 ++++++++ .../UnityBridge/UnityConversions.cs.meta | 11 ++++ .../Shaders/CultMath.hlsl | 61 ++++++++++++++++-- .../THIRD-PARTY-NOTICES.md | 6 +- .../unity/org.gamecult.cultmath/package.json | 4 +- .../Assets/Caching/package.json | 4 +- 15 files changed, 179 insertions(+), 29 deletions(-) create mode 100644 packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge.meta create mode 100644 packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/CultMath.UnityBridge.asmdef create mode 100644 packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/CultMath.UnityBridge.asmdef.meta create mode 100644 packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/UnityConversions.cs create mode 100644 packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/UnityConversions.cs.meta diff --git a/packages/cultmath/THIRD-PARTY-NOTICES.md b/packages/cultmath/THIRD-PARTY-NOTICES.md index c283df2b..06ebb6c3 100644 --- a/packages/cultmath/THIRD-PARTY-NOTICES.md +++ b/packages/cultmath/THIRD-PARTY-NOTICES.md @@ -1,9 +1,9 @@ # Third-Party Notices -## 2D Simplex Noise +## 2D and 3D Simplex Noise -`math.simplex_noise` and `cultmath_simplex_noise` port the textureless 2D -simplex-noise function by Ian McEwan and Ashima Arts, as distributed by Stefan +`math.snoise` and `cultmath_snoise` port the textureless 2D and 3D +simplex-noise functions by Ian McEwan and Ashima Arts, as distributed by Stefan Gustavson's `webgl-noise` project and Unity Mathematics. - Copyright 2011 Ashima Arts. diff --git a/packages/cultmath/scripts/build-unity-package.ps1 b/packages/cultmath/scripts/build-unity-package.ps1 index f5fcacc0..7bc3da7c 100644 --- a/packages/cultmath/scripts/build-unity-package.ps1 +++ b/packages/cultmath/scripts/build-unity-package.ps1 @@ -52,6 +52,10 @@ $requiredTemplateFiles = @( "Runtime\Plugins\CultMath.dll.meta", "Runtime\Plugins\CultMath.pdb", "Runtime\Plugins\CultMath.pdb.meta", + "Runtime\UnityBridge\CultMath.UnityBridge.asmdef", + "Runtime\UnityBridge\CultMath.UnityBridge.asmdef.meta", + "Runtime\UnityBridge\UnityConversions.cs", + "Runtime\UnityBridge\UnityConversions.cs.meta", "Shaders\CultMath.hlsl", "Shaders\CultMath.hlsl.meta" ) @@ -62,7 +66,7 @@ foreach ($relativePath in $requiredTemplateFiles) { } $unityAssetFiles = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -File | Where-Object { - $_.Extension -in @(".asmdef", ".dll", ".pdb", ".hlsl") + $_.Extension -in @(".asmdef", ".cs", ".dll", ".pdb", ".hlsl") }) $missingAssetMetas = @($unityAssetFiles | Where-Object { -not (Test-Path -LiteralPath ($_.FullName + ".meta")) }) $missingDirectoryMetas = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -Directory | Where-Object { @@ -78,9 +82,18 @@ $pluginMeta = Get-Content -LiteralPath ($trackedAssembly + ".meta") -Raw if ($pluginMeta -notmatch '(?m)^\s*isExplicitlyReferenced:\s*0\s*$') { throw "CultMath.dll must be auto-referenced; explicit-only plugins do not reach dependent Unity asmdefs" } -$facadeDefinitions = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -File -Filter "*.asmdef") -if ($facadeDefinitions.Count -ne 0) { - throw "CultMath's precompiled DLL is the Unity assembly authority; empty asmdef facades are forbidden" +# The precompiled DLL is the only authority for CultMath's numeric types. The one +# compiled assembly allowed beside it is the UnityEngine conversion bridge, which +# references that DLL and must not re-declare core sources. +$bridgeRoot = Join-Path $templateRoot "Runtime\UnityBridge" +$bridgeDefinition = Join-Path $bridgeRoot "CultMath.UnityBridge.asmdef" +$definitions = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -File -Filter "*.asmdef") +if ($definitions.Count -ne 1 -or $definitions[0].FullName -ne $bridgeDefinition) { + throw "CultMath's Unity package may define only the Runtime\UnityBridge assembly; found: $($definitions.FullName -join ', ')" +} +$bridge = Get-Content -LiteralPath $bridgeDefinition -Raw | ConvertFrom-Json +if ($bridge.noEngineReferences -or -not $bridge.overrideReferences -or @($bridge.precompiledReferences) -notcontains "CultMath.dll") { + throw "CultMath.UnityBridge must reference UnityEngine and the precompiled CultMath.dll" } $expectedFileVersion = "$($manifest.version).0" $trackedFileVersion = [Diagnostics.FileVersionInfo]::GetVersionInfo($trackedAssembly).FileVersion @@ -97,23 +110,29 @@ foreach ($pair in @(@($freshAssembly, $trackedAssembly), @($freshSymbols, $track } } +$coreSourceNames = @(Get-ChildItem -LiteralPath (Join-Path $repoRoot "src\CultMath") -File -Filter "*.cs" | ForEach-Object Name) $trackedSourceFiles = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -File -Filter "*.cs") -if ($trackedSourceFiles.Count -ne 0) { - throw "CultMath Unity package must not compile repository C# sources: $($trackedSourceFiles.FullName -join ', ')" +$strayOrCoreSources = @($trackedSourceFiles | Where-Object { + $_.DirectoryName -ne $bridgeRoot -or $coreSourceNames -contains $_.Name +}) +if ($trackedSourceFiles.Count -eq 0 -or $strayOrCoreSources.Count -ne 0) { + throw "CultMath Unity package may compile only bridge sources under Runtime\UnityBridge, never core sources: $($strayOrCoreSources.FullName -join ', ')" } New-Item -ItemType Directory -Force -Path $outputRoot | Out-Null Copy-Item -Path (Join-Path $templateRoot "*") -Destination $outputRoot -Recurse -Force $stagedAssemblies = @(Get-ChildItem -LiteralPath (Join-Path $outputRoot "Runtime\Plugins") -Filter "*.dll") +$stagedBridgeRoot = Join-Path $outputRoot "Runtime\UnityBridge" $stagedSources = @(Get-ChildItem -LiteralPath $outputRoot -Recurse -File -Filter "*.cs") -$stagedFacades = @(Get-ChildItem -LiteralPath $outputRoot -Recurse -File -Filter "*.asmdef") -if ($stagedAssemblies.Count -ne 1 -or $stagedAssemblies[0].Name -ne "CultMath.dll" -or $stagedSources.Count -ne 0 -or $stagedFacades.Count -ne 0) { - throw "CultMath package must contain one owned auto-referenced DLL, no C# source files, and no asmdef facade" +$stagedDefinitions = @(Get-ChildItem -LiteralPath $outputRoot -Recurse -File -Filter "*.asmdef") +$stagedStraySources = @($stagedSources | Where-Object { $_.DirectoryName -ne $stagedBridgeRoot }) +if ($stagedAssemblies.Count -ne 1 -or $stagedAssemblies[0].Name -ne "CultMath.dll" -or $stagedStraySources.Count -ne 0 -or $stagedDefinitions.Count -ne 1) { + throw "CultMath package must contain one owned auto-referenced DLL and only the UnityBridge assembly as source" } Write-Host "CultMath Unity package: $outputRoot" Write-Host "Package: $($manifest.name)@$($manifest.version)" Write-Host "Managed assemblies: $($stagedAssemblies.Count)" -Write-Host "C# source files: $($stagedSources.Count)" -Write-Host "Asmdef facades: $($stagedFacades.Count)" +Write-Host "Bridge C# source files: $($stagedSources.Count)" +Write-Host "Asmdef definitions: $($stagedDefinitions.Count)" diff --git a/packages/cultmath/src/CultMath/CultMath.csproj b/packages/cultmath/src/CultMath/CultMath.csproj index 0ca99063..a8f61d97 100644 --- a/packages/cultmath/src/CultMath/CultMath.csproj +++ b/packages/cultmath/src/CultMath/CultMath.csproj @@ -1,4 +1,4 @@ - + net8.0;netstandard2.1 @@ -8,7 +8,7 @@ CultMath CultMath GameCult.Math - 0.1.2 + 0.2.0 Clean-room C# math shaped for HLSL-style renderer code. GameCult README.md diff --git a/packages/cultmath/unity/org.gamecult.cultmath/README.md b/packages/cultmath/unity/org.gamecult.cultmath/README.md index 7d9c34bf..20e1840c 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/README.md +++ b/packages/cultmath/unity/org.gamecult.cultmath/README.md @@ -1,8 +1,16 @@ # CultMath for Unity This is CultMath's Unity 2021.3-compatible Git-UPM surface. It contains the -precompiled `CultMath.dll`, portable symbols, and the numeric -`Shaders/CultMath.hlsl` mirror. +precompiled `CultMath.dll`, portable symbols, the numeric +`Shaders/CultMath.hlsl` mirror, and the `CultMath.UnityBridge` assembly. + +`CultMath.UnityBridge` is the only C# source Unity compiles here. It holds the +UnityEngine conversions the engine-free core cannot declare: `ToCultMath()` on +`Vector2/3/4`, `Vector2Int/3Int`, `Quaternion`, and `Color`; `ToUnity()` on +`float2/3/4`, `int2/3`, and `quaternion`; `ToColor()` on `float4`. C# only +admits conversion operators on the source or target type, so these are +extension methods rather than implicit casts. Import `CultMath.UnityBridge` to +use them. Unity does not compile CultMath's repository source tree. That source uses the current C# language and remains owned by the normal .NET project. The package diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 379dad44e209aea24d0cd34f7cb28a1a490d2ae8..8428d20690adaebbde2e500625a8f679c80308c2 100644 GIT binary patch literal 66048 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%0ARed(@)^bI8{rXMTJ- dbZkFVyKr9j)2Dv3{s)Bt=O+CB%>NA$_@DOK!M6Ya diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index 223b4de88b508404e9dd23578205c7692bc9427e..29e4b8f36d31510cf419bde4383440839fda51d1 100644 GIT binary patch literal 33440 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 D-I6+t literal 23936 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 + /// Explicit conversions between UnityEngine and CultMath value types. + /// C# only admits user-defined conversion operators declared on the source or target + /// type, and CultMath's core types stay engine-free, so the bridge is extension methods. + /// + public static class UnityConversions + { + public static float2 ToCultMath(this Vector2 value) => new float2(value.x, value.y); + public static float3 ToCultMath(this Vector3 value) => new float3(value.x, value.y, value.z); + public static float4 ToCultMath(this Vector4 value) => new float4(value.x, value.y, value.z, value.w); + public static float4 ToCultMath(this Color value) => new float4(value.r, value.g, value.b, value.a); + public static quaternion ToCultMath(this Quaternion value) => new quaternion(value.x, value.y, value.z, value.w); + public static int2 ToCultMath(this Vector2Int value) => new int2(value.x, value.y); + public static int3 ToCultMath(this Vector3Int value) => new int3(value.x, value.y, value.z); + + public static Vector2 ToUnity(this float2 value) => new Vector2(value.x, value.y); + public static Vector3 ToUnity(this float3 value) => new Vector3(value.x, value.y, value.z); + public static Vector4 ToUnity(this float4 value) => new Vector4(value.x, value.y, value.z, value.w); + public static Quaternion ToUnity(this quaternion value) => new Quaternion(value.x, value.y, value.z, value.w); + public static Vector2Int ToUnity(this int2 value) => new Vector2Int(value.x, value.y); + public static Vector3Int ToUnity(this int3 value) => new Vector3Int(value.x, value.y, value.z); + public static Color ToColor(this float4 value) => new Color(value.x, value.y, value.z, value.w); + } +} diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/UnityConversions.cs.meta b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/UnityConversions.cs.meta new file mode 100644 index 00000000..ccbd3f10 --- /dev/null +++ b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/UnityBridge/UnityConversions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8fc742177b3f4715b204afe0e69a400c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl index 4c00fb69..f3c398d6 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl +++ b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl @@ -73,11 +73,64 @@ float cultmath_smootherstep(float value) return value * value * value * (value * (value * 6.0 - 15.0) + 10.0); } -float2 cultmath_simplex_mod289(float2 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } -float3 cultmath_simplex_mod289(float3 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } -float3 cultmath_simplex_permute(float3 value) { return cultmath_simplex_mod289(((value * 34.0) + 1.0) * value); } +float2 cultmath_snoise_mod289(float2 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float3 cultmath_snoise_mod289(float3 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float4 cultmath_snoise_mod289(float4 value) { return value - floor(value * (1.0 / 289.0)) * 289.0; } +float3 cultmath_snoise_permute(float3 value) { return cultmath_snoise_mod289(((value * 34.0) + 1.0) * value); } +float4 cultmath_snoise_permute(float4 value) { return cultmath_snoise_mod289(((value * 34.0) + 1.0) * value); } -float cultmath_simplex_noise(float2 value) +// Ashima Arts / Ian McEwan 3D simplex noise (MIT), same float32 evaluation +// order as the C# math.snoise(float3) mirror. +float cultmath_snoise(float3 value) +{ + const float2 c = float2(1.0 / 6.0, 1.0 / 3.0); + float3 i = floor(value + dot(value, c.yyy)); + float3 x0 = value - i + dot(i, c.xxx); + float3 g = step(x0.yzx, x0.xyz); + float3 l = 1.0 - g; + float3 i1 = min(g.xyz, l.zxy); + float3 i2 = max(g.xyz, l.zxy); + float3 x1 = x0 - i1 + c.xxx; + float3 x2 = x0 - i2 + c.yyy; + float3 x3 = x0 - 0.5; + + i = cultmath_snoise_mod289(i); + float4 p = cultmath_snoise_permute(cultmath_snoise_permute(cultmath_snoise_permute( + i.z + float4(0.0, i1.z, i2.z, 1.0)) + i.y + float4(0.0, i1.y, i2.y, 1.0)) + i.x + float4(0.0, i1.x, i2.x, 1.0)); + + const float n_ = 0.142857142857; + float3 ns = float3(2.0 * n_, 0.5 * n_ - 1.0, n_); + float4 j = p - 49.0 * floor(p * ns.z * ns.z); + float4 x_ = floor(j * ns.z); + float4 y_ = floor(j - 7.0 * x_); + float4 x = x_ * ns.x + ns.yyyy; + float4 y = y_ * ns.x + ns.yyyy; + float4 h = 1.0 - abs(x) - abs(y); + + float4 b0 = float4(x.xy, y.xy); + float4 b1 = float4(x.zw, y.zw); + float4 s0 = floor(b0) * 2.0 + 1.0; + float4 s1 = floor(b1) * 2.0 + 1.0; + float4 sh = -step(h, 0.0); + 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); + float4 norm = 1.79284291400159 - 0.85373472095314 * 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; + + float4 m = max(0.6 - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0); + m = m * m; + return 42.0 * dot(m * m, float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))); +} + +float cultmath_snoise(float2 value) { const float4 c = float4( 0.211324865405187, diff --git a/packages/cultmath/unity/org.gamecult.cultmath/THIRD-PARTY-NOTICES.md b/packages/cultmath/unity/org.gamecult.cultmath/THIRD-PARTY-NOTICES.md index c283df2b..06ebb6c3 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/THIRD-PARTY-NOTICES.md +++ b/packages/cultmath/unity/org.gamecult.cultmath/THIRD-PARTY-NOTICES.md @@ -1,9 +1,9 @@ # Third-Party Notices -## 2D Simplex Noise +## 2D and 3D Simplex Noise -`math.simplex_noise` and `cultmath_simplex_noise` port the textureless 2D -simplex-noise function by Ian McEwan and Ashima Arts, as distributed by Stefan +`math.snoise` and `cultmath_snoise` port the textureless 2D and 3D +simplex-noise functions by Ian McEwan and Ashima Arts, as distributed by Stefan Gustavson's `webgl-noise` project and Unity Mathematics. - Copyright 2011 Ashima Arts. diff --git a/packages/cultmath/unity/org.gamecult.cultmath/package.json b/packages/cultmath/unity/org.gamecult.cultmath/package.json index 80ceddad..302eb481 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/package.json +++ b/packages/cultmath/unity/org.gamecult.cultmath/package.json @@ -1,7 +1,7 @@ -{ +{ "name": "org.gamecult.cultmath", "displayName": "CultMath", - "version": "0.1.2", + "version": "0.2.0", "unity": "2021.3", "description": "Precompiled CultMath numeric primitives and matching HLSL semantics for GameCult Unity runtimes.", "license": "MPL-2.0", diff --git a/src/GameCult.Unity/Assets/Caching/package.json b/src/GameCult.Unity/Assets/Caching/package.json index cde27289..560600a9 100644 --- a/src/GameCult.Unity/Assets/Caching/package.json +++ b/src/GameCult.Unity/Assets/Caching/package.json @@ -1,4 +1,4 @@ -{ +{ "name": "org.gamecult.caching.unity", "displayName": "GameCult CultCache Unity Tools", "version": "1.1.0", @@ -11,7 +11,7 @@ ], "dependencies": { "org.gamecult.cultlib": "1.0.57", - "org.gamecult.cultmath": "0.1.2" + "org.gamecult.cultmath": "0.2.0" }, "license": "MIT", "category": "Scripting" From d9e469554dc72bc805a535942b0f1ad5a307538b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:30:00 +0200 Subject: [PATCH 03/20] State HLSL source compatibility as CultMath's design target The design doc now names HLSL as the parity target: HLSL-shaped math compiles as C# under using static CultMath.math, components and swizzles are writable, comparisons are component-wise, matrices are row-major through mul, and select uses HLSL's argument order. "Prefer small immutable value types" becomes plain mutable value types. CultMath keeps its own decisions where HLSL is silent (safe normalize, float hash, its own Random), and the core assembly stays engine-free. Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 52 +++++++++++++++++++++++++++----- 1 file changed, 45 insertions(+), 7 deletions(-) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index 8250ba78..da28079f 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -3,22 +3,60 @@ CultMath exists to make renderer math readable in every place it needs to live: Rust hot kernels, C# host code, and HLSL shader code. +## Parity Target: HLSL + +HLSL is the semantic authority for every type and intrinsic HLSL defines. The +goal is source compatibility: HLSL-shaped math compiles as C# under +`using static CultMath.math;`. C# forces float literal suffixes (`0.5f`); the +rest of the spelling should survive the move. + +That makes these HLSL rules, not options: + +- Components and swizzles are writable. `v.xz = f2;` and `v[1] = s;` work. + Swizzle setters exist only for non-repeating masks, because HLSL rejects + `v.xx = ...`. +- Comparison operators (`<`, `>`, `<=`, `>=`, `==`, `!=`) are component-wise and + return `bool2`/`bool3`/`bool4`. Reduce them with `any` and `all`. + `Equals`/`GetHashCode` stay value-based so vectors still work as dictionary + keys. +- `select(condition, whenTrue, whenFalse)` uses HLSL's argument order. +- Matrices are row-major: constructors take rows, `m[i]` is row i, `_mRC` is + row R column C, and products go through `mul` (`mul(m, v)` treats `v` as a + column, `mul(v, m)` as a row). `*` on matrices would be component-wise in HLSL, + so CultMath does not define it. +- Scalar/vector arithmetic and comparisons have explicit overloads on both + sides rather than leaning on implicit scalar splat. + +Where HLSL is silent, CultMath keeps its own decisions and does not defer to +Unity.Mathematics: `normalize` is safe (divides by `max(length, 1e-20)`), +`hash` returns float, and `Random` is CultMath's own xorshift32. Engine-shaped +helpers that HLSL lacks (`float2x2.Rotate`, `float3x3.Euler`, `quaternion`, +`snoise`) enter only when a consumer needs them, with their semantics stated in +code. + +Known C# friction: under `using static CultMath.math;` the constructor +functions (`float3(...)`, `float3x3(...)`) hide the type names in member access, +so static members need a qualified type (`CultMath.float3x3.Euler(...)`). + ## Rules -- Keep type names HLSL-shaped: `float2`, `float3`, `float4`, and `math`. +- Keep type names HLSL-shaped: `float2`, `float3`, `float4`, `float3x3`, and `math`. - Keep Rust as the owner of native hot-path kernels and parity fixtures. - Keep C#, shader, and scripting surfaces as runtime wrappers, not competing math authorities. - Keep `shaders/CultMath.hlsl` as the canonical shader mirror for shared - intrinsics. Project-local shader helpers should move here once more than one - organ needs them or once CPU/GPU parity matters. + CultMath functions HLSL does not already provide (HLSL intrinsics such as + `mul`, `any`, and `log` need no mirror). Project-local shader helpers should + move here once more than one organ needs them or once CPU/GPU parity matters. - Implement public shader semantics directly; do not copy Unity.Mathematics. -- Prefer small immutable value types. +- Prefer plain mutable value types with public component fields, as HLSL does. - Prefer component-wise overloads over clever generic machinery until the API earns that complexity. -- Keep the surface boring and exact. Noise primitives are allowed when they are - source-grounded, shader-shaped, and shared by more than one project. Matrices, - quaternions, and packing helpers still need an owner before they enter. +- Keep the surface boring and exact. Fill what a consumer uses, guided by HLSL + semantics; noise primitives, matrices, quaternions, and packing helpers need an + owner before they enter. +- Keep the core assembly engine-free. Unity conversions live in the Unity + package's `CultMath.UnityBridge` assembly. ## Non-Goals From 2ad8dbc9b3056e1ae31ad6ed3c6370410e1087a1 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:30:49 +0200 Subject: [PATCH 04/20] Rebuild the CultMath 0.2.0 DLL from normalized sources The previous prebuilt DLL/PDB came from LF working-copy files. The PDB embeds source checksums, so a text=auto checkout (CRLF on Windows) built different bytes and build-unity-package.ps1 would reject the tracked artifact. Rebuilt from a clean checkout of the committed sources and re-verified. Co-Authored-By: Claude Opus 5 --- .../Runtime/Plugins/CultMath.dll | Bin 66048 -> 66048 bytes .../Runtime/Plugins/CultMath.pdb | Bin 33440 -> 33440 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 8428d20690adaebbde2e500625a8f679c80308c2..89a981c86647129de1d2639726f04be8e4504265 100644 GIT binary patch delta 237 zcmZo@VQFY#nb5)VY>q+a#-4=d0+w4Il!tc4I&9>1y7M&1<d znxrI~8zm)M7?>uS8k<_07$q5`878KfCK?-QNp5 delta 237 zcmZo@VQFY#nb5(KbL-;&jXep^1tL-t<`<~U@R^^uS83{mo{O9RJU`5*VUd(-Xl{~Z zVU(O~nQED0k!X-)nv!g6ZeU<(nrxYDX>4j_nwDgkGWq$prz`@wpI=PA@I64_%l2n? z5{e&q?z-}%sxG`MZnD9TPz9J^6;u$YI^%VC=J{B6@!h=q+d?)k{qdW{--02DA(g?9 z!JNSa$g*HCVn_x;OQ4t~Lkf_e$Y1~zHwChj8H|Cd41mxQ$OowbVPhcM2#C{wstg%Y KHoyNX$N~Uy=~fT` diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index 29e4b8f36d31510cf419bde4383440839fda51d1..0241859fbd8e9b8e1cf3d304837582a0817be95a 100644 GIT binary patch delta 3938 zcmZwJ2{f14AII_gvoDc^iPEShW#2_*Un=ctCXA`5s395@MShk z1uBZujs?dZk3@`xZu)|POB^ItEhLdA46^SUuPE_JBPT-uB zav9fg8xPTemv|3}nUYXKSLi_BOqmHQ3nS7JZU{geq*#ol$iq5p#&+z%0UX6?TtFkF z&6Im+!!x|WC&-yA3sq=B7X}yrbJ$@hJm7=z@WT{@U^Ze9j}$CH4pyVUTt$@PH0sS& zq~ZyUriF^=2V+>l0WKD*yhc?qlAMIeh{QakBO8S%#sM5f9j>7RFQIIyDl}jSGk72f znOK2*OR1{ZOjC-zID`|ZMFW~~A5YMU_mHtt6)Mn#9{R!<)))+T_`nwd2*%Hd!UCiq z6DyD}rEEqi_TmsupcV~iw(24tLC?C2FoY*Eu?{;>jdu_>U4#<4LI=HV)cAnZgfVFk zcZ|XJ2*GTmLYhh0h;69GU1-{>30)Xq0L)>Bq40nY#={R&5Q5o=K|E5h1UXoZ0u*5< z_MsZ5anV*yDz4Jp!bALl*Z2f^J2jyOZRn#v%wPv6cww}iI$wjj@F&-iQRI9iAsyLR ziS^imQk3H$YH-F*sxB_lTtN%&qaDxjC;o!GeOLa7T}3z2o3tS9;RH{NgfILt6`_d0 zTqGbBnOKfBC`2)KqEc$F!9Hn-W2C%^hG-?9;04~|GZY4C2sLP-C;Gw&mKX$QcwrPK zAOJy_IY?8)ARZ}Lf*h50hE>>rtti7@RN)xT;u5amHXh+A-rz4N z4CW0%2fbkkbJ)Wf-k5-?Qp#*BKngOk0{PgCQtZVcoIoua(2VE_y{>CP0`*b3wcZ~3 z`sfdH*uxp#=;gxx$G9*c79k6HSdX(V-NheJa_uhCk&TsDk1Z%gIS!)6RZE;f1Dfy< z@@`t93-s|FOkfR1xMCP4cu@inxf(^dFY54h=sDJj_3wm#3Q4^qRUU_!&F={WHem7BswmJGP0guPEQiy zYbf(~h8xNKokQIf$N`+Is+9%^1!1c^Kq!jUs;xp!R4Hwd$ce)hjf1z#PF$O=(?|Ja zNcgg`K9s_h@MDe}*bG1IPW zpVIe|k-EYM$EQPf={DSG%$0LV{~_1sO`2l1zx5i^!)2k3ZyV!F`sww4^lL_2aK=^T zk1gX=rbo^V4xjP$_{r-GVxx=V`lMI~KK>!}=&g50*ZBr6ewFW4mf>Z#+pNxaVRP<1 z7j5bCiw*sP1LqW5sedPNSaZ+#{5Xx$OZ9SB7RyB!l(_zRN;M=rGAPD6&ibphr6?He zuJ;MsaQEV)mUX*5_n$s=vvv6IE7!LT>guc;dez5fM~3p>w|zaK6eoio#}XanW4%jd zqsuc@XZP3Xh;Wqtl<`|zyTYoxm%1C~sr@sUP2B(87iHiQSocOV+3!xr3)6!are*UQ&)g9K zH_}#&ZuDpmGF>`5*>r8a!|`QTuD9iC$G6NlAU#%8mg>4?Y|YpUSz2csQ?pyQI4m9+ zetPW4s8a*CPU(6)@uu{9!=%pqyWM2N<#S?_3~slStd4l-pSEkOxbOBpH?3UGZr;W{ zYI0|c>PGn(Y*YC*E7Wz{y?Q@Y$K=;;$FzRTpIG_AUb1HYqtyO^XQT&TZkiCCa7Cfj z$1m2c&51atsqp@ragF6hCQZo+A5=^<7sW>fm1K8DRJ1#04XY{Ic*C~l zre(#Vh}zrNbDWa(ic-b}dFZLsJ&&lGJSH_}Rnoax!S^@)RUg+9Hm$wDp`*pHeng(< zxws4Qlj3%zf86{@^;y;A%O9`y9W8wvu%Y0=6Vnk^8;X8?H=;nxV*ECTkz*R0{GD&V zk&VAqdh6#`OUvE2pRswG<@es=grxI&Y>xNw>PO)TmiMbZ{5G#s#&G5E?w48*+WPLB zzcoSsbArk*E@l@Eqfds_G<}-?UK+G7u~Dz=UiY4xE`%KlF%657sSQ>dFMT>h(oLc; zFZZJNh=J1`XV}_1+S%DopEk%kc$$NyU67rPoujRFuw{r<&~&>X8_PjsN#%Im-M8 D!B0T0 delta 3946 zcmZwJ2~^GLAII_M)=hibWh%l{(yB!zxsnhKStc@vv?xnyRF(=?DQS`@YA_;HlPyF@ z#**DIMNzUvOm|FVvW{i`Z!`aM{{H98J?HiPe9!rv-|u;z-*bQGJX_P1wx%nsS#0>? z@Z;OlsPUY!Z6i@u~Ih9DRVu@vc8g*gPc-?GVI4uoWe!ap{c)?c!ciGTEY^($iznMLN(stFQ~d`2^|>0+(nxY zNL$#DZt%fZn1~sOMk?f)lr1PhHSR&rRa=;#C#+x(S9oD4{1J#rn1&gMMm&;`f|bZY zJ~m?qcH53Di)K*tKAQkAqYkY)?yROiJ0lq*l^o1h^ zz#GFb8sia+>4=@4^SD%8-fwcVF`P|M4;g#ByXI51VjKW*~lt>JS650@+xHP1uGq?89OFG{jJx zMI9Q^3aO8w(1aQKpdb3f12PQ9ct1)oru!I)D8wTTS;)l(Y(**d;t;A)gG;Ex1D{Wa z8CPK}6h6kH1FsP@)L7&~)z?@=U;)&I84F#QAPE^2j#^V4MyShHDs`3lNsMGxN=m~% zot`9OoR!kwImbr&cX|!&LRxdKs#dcWU4)CewNMrLnh%9k98udYk&3E{>jTS_CmuO) zVO{ym*R6X`ufFA9RR7$#ZRLn__xuA7y(6YinzaEzE4U^n0^q04J40*6_nn$yBP+sj|LyLU@xB51whra3cB65FR zi@v(&u^)TaN&*5aS5GsUS@z*@o>Z0*^yA|d_d7Zo7d>)WnBL1^$mNxedlQ$0RPP>p ze%bPnj=C!v5wY{bqGx7&mYn>ejPLszI$bI7 zQ{=VCjO43wJ9N}dOMS032KA}j)h4~trJT&tNW#{_nmx3)#0OD?LgzY>vH2e(yIk zE;}PUuF0+DvfrTZrGr%ud1n1HnCs^=EVCG+dt-)cpfuoUPuardUE_MI)HZL4=`r}X z_L$Cutvx#4sLq<3;Ot=kza2}xYjHZem!g|e+&IgKohohb@2;=4@2;KaZRs>jKWptB zgDejni_}Qz34ChY|{(LUWhgsx4 z(o-CB2r^Kcx@4zvv8>%=zu%&&leRB29Uq@7ziH=Kk>N91S-x$}Y*~3?dB{j}{bOT` z)(=;H-OxifYogM<`9VQP3(_8^)N{rcd)ECj`?izrxo0WWHT#YqJUGW|lS9*2Lwn8l zpVF9~`_*+{Md+8=F)4N%>W-YsslVBlXXMp>pjmeRT7%Ely3%{rk;6w_SNNQNK5pY_ z%S!zc%fv84=kgWPWl!b(Onp>+JC^BHDg~Nbj8t<_6n~RAt;o?PRl4S5M5wt>w)xEH zJ}EB;I^`J$PHgFBYEo;uXy4V8-rx4pXbc;j_g#OslD0)6!+*WVa^HANN z`U9pK?sR-raM9jq^})vbj!6pZRcmKIs_ML_aQ2A=Nf#WePIMGH8gBmK_{1#vh8v@&Y*dMyJ@>&WW% zWSx?RV-0Pl;o0M}qizS!dl8bR+* Date: Mon, 14 Sep 2026 13:57:02 +0200 Subject: [PATCH 05/20] Generate every HLSL swizzle and mixed constructor; fix intrinsic types tools/generate-swizzles.ps1 writes the checked-in src/CultMath/Swizzles.g.cs as partial structs plus a partial math: for float2/3/4, int2/3/4 and bool2/3/4 every swizzle of length 2-4 including repeats, in xyzw and rgba naming, with setters only on non-repeating masks, plus single-component r/g/b/a. double2/3 get lengths 2-3 (there is no double4). Every HLSL mixed constructor (float4(float2, float2), float4(float, float2, float), copy forms, ...) exists as a struct constructor and, for float/int/bool, a math function. The hand-written swizzles and mixed constructors it supersedes are deleted. Matrices store private rows and return ref float2/float3 from the row indexer ([UnscopedRef], polyfilled for netstandard2.1), so m[1][2] = s compiles as in HLSL; _mRC are get/set properties over the rows. Equality and hashing stay value-based. Intrinsics follow HLSL: sign returns int/intN and yields 0 for NaN; step is x >= y ? 1 : 0 so NaN yields 0; any/all accept float and int vectors; min/max/abs on int vectors return int vectors, and abs(int) returns int. Strips the UTF-8 BOMs this branch added to math.cs, CultMath.csproj and HlslSemanticsTests.cs. Co-Authored-By: Claude Opus 5 --- .../cultmath/src/CultMath/CultMath.csproj | 2 +- packages/cultmath/src/CultMath/Swizzles.g.cs | 3137 +++++++++++++++++ .../cultmath/src/CultMath/Swizzles.g.cs.meta | 2 + .../src/CultMath/UnscopedRefAttribute.cs | 10 + .../src/CultMath/UnscopedRefAttribute.cs.meta | 2 + packages/cultmath/src/CultMath/bool2.cs | 2 +- packages/cultmath/src/CultMath/bool3.cs | 2 +- packages/cultmath/src/CultMath/bool4.cs | 2 +- packages/cultmath/src/CultMath/double2.cs | 2 +- packages/cultmath/src/CultMath/double3.cs | 12 +- packages/cultmath/src/CultMath/float2.cs | 12 +- packages/cultmath/src/CultMath/float2x2.cs | 51 +- packages/cultmath/src/CultMath/float3.cs | 101 +- packages/cultmath/src/CultMath/float3x3.cs | 76 +- packages/cultmath/src/CultMath/float4.cs | 60 +- packages/cultmath/src/CultMath/int2.cs | 2 +- packages/cultmath/src/CultMath/int3.cs | 2 +- packages/cultmath/src/CultMath/int4.cs | 2 +- packages/cultmath/src/CultMath/math.cs | 49 +- .../CultMath.Tests/HlslSemanticsTests.cs | 89 +- .../tests/CultMath.Tests/MathTests.cs | 8 +- packages/cultmath/tools/generate-swizzles.ps1 | 132 + .../cultmath/tools/generate-swizzles.ps1.meta | 7 + 23 files changed, 3489 insertions(+), 275 deletions(-) create mode 100644 packages/cultmath/src/CultMath/Swizzles.g.cs create mode 100644 packages/cultmath/src/CultMath/Swizzles.g.cs.meta create mode 100644 packages/cultmath/src/CultMath/UnscopedRefAttribute.cs create mode 100644 packages/cultmath/src/CultMath/UnscopedRefAttribute.cs.meta create mode 100644 packages/cultmath/tools/generate-swizzles.ps1 create mode 100644 packages/cultmath/tools/generate-swizzles.ps1.meta diff --git a/packages/cultmath/src/CultMath/CultMath.csproj b/packages/cultmath/src/CultMath/CultMath.csproj index a8f61d97..5dfe069c 100644 --- a/packages/cultmath/src/CultMath/CultMath.csproj +++ b/packages/cultmath/src/CultMath/CultMath.csproj @@ -1,4 +1,4 @@ - + net8.0;netstandard2.1 diff --git a/packages/cultmath/src/CultMath/Swizzles.g.cs b/packages/cultmath/src/CultMath/Swizzles.g.cs new file mode 100644 index 00000000..ce84bbc4 --- /dev/null +++ b/packages/cultmath/src/CultMath/Swizzles.g.cs @@ -0,0 +1,3137 @@ +// +// Generated by tools/generate-swizzles.ps1. Do not edit by hand. +// + +namespace CultMath; + +public partial struct float2 +{ + public float2(float2 xy) : this(xy.x, xy.y) { } + public float r { readonly get => x; set => x = value; } + public float g { readonly get => y; set => y = value; } + public readonly float2 xx => new(x, x); + public float2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 yy => new(y, y); + public readonly float3 xxx => new(x, x, x); + public readonly float3 xxy => new(x, x, y); + public readonly float3 xyx => new(x, y, x); + public readonly float3 xyy => new(x, y, y); + public readonly float3 yxx => new(y, x, x); + public readonly float3 yxy => new(y, x, y); + public readonly float3 yyx => new(y, y, x); + public readonly float3 yyy => new(y, y, y); + public readonly float4 xxxx => new(x, x, x, x); + public readonly float4 xxxy => new(x, x, x, y); + public readonly float4 xxyx => new(x, x, y, x); + public readonly float4 xxyy => new(x, x, y, y); + public readonly float4 xyxx => new(x, y, x, x); + public readonly float4 xyxy => new(x, y, x, y); + public readonly float4 xyyx => new(x, y, y, x); + public readonly float4 xyyy => new(x, y, y, y); + public readonly float4 yxxx => new(y, x, x, x); + public readonly float4 yxxy => new(y, x, x, y); + public readonly float4 yxyx => new(y, x, y, x); + public readonly float4 yxyy => new(y, x, y, y); + public readonly float4 yyxx => new(y, y, x, x); + public readonly float4 yyxy => new(y, y, x, y); + public readonly float4 yyyx => new(y, y, y, x); + public readonly float4 yyyy => new(y, y, y, y); + public readonly float2 rr => new(x, x); + public float2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 gg => new(y, y); + public readonly float3 rrr => new(x, x, x); + public readonly float3 rrg => new(x, x, y); + public readonly float3 rgr => new(x, y, x); + public readonly float3 rgg => new(x, y, y); + public readonly float3 grr => new(y, x, x); + public readonly float3 grg => new(y, x, y); + public readonly float3 ggr => new(y, y, x); + public readonly float3 ggg => new(y, y, y); + public readonly float4 rrrr => new(x, x, x, x); + public readonly float4 rrrg => new(x, x, x, y); + public readonly float4 rrgr => new(x, x, y, x); + public readonly float4 rrgg => new(x, x, y, y); + public readonly float4 rgrr => new(x, y, x, x); + public readonly float4 rgrg => new(x, y, x, y); + public readonly float4 rggr => new(x, y, y, x); + public readonly float4 rggg => new(x, y, y, y); + public readonly float4 grrr => new(y, x, x, x); + public readonly float4 grrg => new(y, x, x, y); + public readonly float4 grgr => new(y, x, y, x); + public readonly float4 grgg => new(y, x, y, y); + public readonly float4 ggrr => new(y, y, x, x); + public readonly float4 ggrg => new(y, y, x, y); + public readonly float4 gggr => new(y, y, y, x); + public readonly float4 gggg => new(y, y, y, y); +} + +public partial struct float3 +{ + public float3(float x, float2 yz) : this(x, yz.x, yz.y) { } + public float3(float2 xy, float z) : this(xy.x, xy.y, z) { } + public float3(float3 xyz) : this(xyz.x, xyz.y, xyz.z) { } + public float r { readonly get => x; set => x = value; } + public float g { readonly get => y; set => y = value; } + public float b { readonly get => z; set => z = value; } + public readonly float2 xx => new(x, x); + public float2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public float2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 yy => new(y, y); + public float2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public float2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public float2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly float2 zz => new(z, z); + public readonly float3 xxx => new(x, x, x); + public readonly float3 xxy => new(x, x, y); + public readonly float3 xxz => new(x, x, z); + public readonly float3 xyx => new(x, y, x); + public readonly float3 xyy => new(x, y, y); + public float3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly float3 xzx => new(x, z, x); + public float3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly float3 xzz => new(x, z, z); + public readonly float3 yxx => new(y, x, x); + public readonly float3 yxy => new(y, x, y); + public float3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly float3 yyx => new(y, y, x); + public readonly float3 yyy => new(y, y, y); + public readonly float3 yyz => new(y, y, z); + public float3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly float3 yzy => new(y, z, y); + public readonly float3 yzz => new(y, z, z); + public readonly float3 zxx => new(z, x, x); + public float3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly float3 zxz => new(z, x, z); + public float3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly float3 zyy => new(z, y, y); + public readonly float3 zyz => new(z, y, z); + public readonly float3 zzx => new(z, z, x); + public readonly float3 zzy => new(z, z, y); + public readonly float3 zzz => new(z, z, z); + public readonly float4 xxxx => new(x, x, x, x); + public readonly float4 xxxy => new(x, x, x, y); + public readonly float4 xxxz => new(x, x, x, z); + public readonly float4 xxyx => new(x, x, y, x); + public readonly float4 xxyy => new(x, x, y, y); + public readonly float4 xxyz => new(x, x, y, z); + public readonly float4 xxzx => new(x, x, z, x); + public readonly float4 xxzy => new(x, x, z, y); + public readonly float4 xxzz => new(x, x, z, z); + public readonly float4 xyxx => new(x, y, x, x); + public readonly float4 xyxy => new(x, y, x, y); + public readonly float4 xyxz => new(x, y, x, z); + public readonly float4 xyyx => new(x, y, y, x); + public readonly float4 xyyy => new(x, y, y, y); + public readonly float4 xyyz => new(x, y, y, z); + public readonly float4 xyzx => new(x, y, z, x); + public readonly float4 xyzy => new(x, y, z, y); + public readonly float4 xyzz => new(x, y, z, z); + public readonly float4 xzxx => new(x, z, x, x); + public readonly float4 xzxy => new(x, z, x, y); + public readonly float4 xzxz => new(x, z, x, z); + public readonly float4 xzyx => new(x, z, y, x); + public readonly float4 xzyy => new(x, z, y, y); + public readonly float4 xzyz => new(x, z, y, z); + public readonly float4 xzzx => new(x, z, z, x); + public readonly float4 xzzy => new(x, z, z, y); + public readonly float4 xzzz => new(x, z, z, z); + public readonly float4 yxxx => new(y, x, x, x); + public readonly float4 yxxy => new(y, x, x, y); + public readonly float4 yxxz => new(y, x, x, z); + public readonly float4 yxyx => new(y, x, y, x); + public readonly float4 yxyy => new(y, x, y, y); + public readonly float4 yxyz => new(y, x, y, z); + public readonly float4 yxzx => new(y, x, z, x); + public readonly float4 yxzy => new(y, x, z, y); + public readonly float4 yxzz => new(y, x, z, z); + public readonly float4 yyxx => new(y, y, x, x); + public readonly float4 yyxy => new(y, y, x, y); + public readonly float4 yyxz => new(y, y, x, z); + public readonly float4 yyyx => new(y, y, y, x); + public readonly float4 yyyy => new(y, y, y, y); + public readonly float4 yyyz => new(y, y, y, z); + public readonly float4 yyzx => new(y, y, z, x); + public readonly float4 yyzy => new(y, y, z, y); + public readonly float4 yyzz => new(y, y, z, z); + public readonly float4 yzxx => new(y, z, x, x); + public readonly float4 yzxy => new(y, z, x, y); + public readonly float4 yzxz => new(y, z, x, z); + public readonly float4 yzyx => new(y, z, y, x); + public readonly float4 yzyy => new(y, z, y, y); + public readonly float4 yzyz => new(y, z, y, z); + public readonly float4 yzzx => new(y, z, z, x); + public readonly float4 yzzy => new(y, z, z, y); + public readonly float4 yzzz => new(y, z, z, z); + public readonly float4 zxxx => new(z, x, x, x); + public readonly float4 zxxy => new(z, x, x, y); + public readonly float4 zxxz => new(z, x, x, z); + public readonly float4 zxyx => new(z, x, y, x); + public readonly float4 zxyy => new(z, x, y, y); + public readonly float4 zxyz => new(z, x, y, z); + public readonly float4 zxzx => new(z, x, z, x); + public readonly float4 zxzy => new(z, x, z, y); + public readonly float4 zxzz => new(z, x, z, z); + public readonly float4 zyxx => new(z, y, x, x); + public readonly float4 zyxy => new(z, y, x, y); + public readonly float4 zyxz => new(z, y, x, z); + public readonly float4 zyyx => new(z, y, y, x); + public readonly float4 zyyy => new(z, y, y, y); + public readonly float4 zyyz => new(z, y, y, z); + public readonly float4 zyzx => new(z, y, z, x); + public readonly float4 zyzy => new(z, y, z, y); + public readonly float4 zyzz => new(z, y, z, z); + public readonly float4 zzxx => new(z, z, x, x); + public readonly float4 zzxy => new(z, z, x, y); + public readonly float4 zzxz => new(z, z, x, z); + public readonly float4 zzyx => new(z, z, y, x); + public readonly float4 zzyy => new(z, z, y, y); + public readonly float4 zzyz => new(z, z, y, z); + public readonly float4 zzzx => new(z, z, z, x); + public readonly float4 zzzy => new(z, z, z, y); + public readonly float4 zzzz => new(z, z, z, z); + public readonly float2 rr => new(x, x); + public float2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public float2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 gg => new(y, y); + public float2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public float2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public float2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly float2 bb => new(z, z); + public readonly float3 rrr => new(x, x, x); + public readonly float3 rrg => new(x, x, y); + public readonly float3 rrb => new(x, x, z); + public readonly float3 rgr => new(x, y, x); + public readonly float3 rgg => new(x, y, y); + public float3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly float3 rbr => new(x, z, x); + public float3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly float3 rbb => new(x, z, z); + public readonly float3 grr => new(y, x, x); + public readonly float3 grg => new(y, x, y); + public float3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly float3 ggr => new(y, y, x); + public readonly float3 ggg => new(y, y, y); + public readonly float3 ggb => new(y, y, z); + public float3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly float3 gbg => new(y, z, y); + public readonly float3 gbb => new(y, z, z); + public readonly float3 brr => new(z, x, x); + public float3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly float3 brb => new(z, x, z); + public float3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly float3 bgg => new(z, y, y); + public readonly float3 bgb => new(z, y, z); + public readonly float3 bbr => new(z, z, x); + public readonly float3 bbg => new(z, z, y); + public readonly float3 bbb => new(z, z, z); + public readonly float4 rrrr => new(x, x, x, x); + public readonly float4 rrrg => new(x, x, x, y); + public readonly float4 rrrb => new(x, x, x, z); + public readonly float4 rrgr => new(x, x, y, x); + public readonly float4 rrgg => new(x, x, y, y); + public readonly float4 rrgb => new(x, x, y, z); + public readonly float4 rrbr => new(x, x, z, x); + public readonly float4 rrbg => new(x, x, z, y); + public readonly float4 rrbb => new(x, x, z, z); + public readonly float4 rgrr => new(x, y, x, x); + public readonly float4 rgrg => new(x, y, x, y); + public readonly float4 rgrb => new(x, y, x, z); + public readonly float4 rggr => new(x, y, y, x); + public readonly float4 rggg => new(x, y, y, y); + public readonly float4 rggb => new(x, y, y, z); + public readonly float4 rgbr => new(x, y, z, x); + public readonly float4 rgbg => new(x, y, z, y); + public readonly float4 rgbb => new(x, y, z, z); + public readonly float4 rbrr => new(x, z, x, x); + public readonly float4 rbrg => new(x, z, x, y); + public readonly float4 rbrb => new(x, z, x, z); + public readonly float4 rbgr => new(x, z, y, x); + public readonly float4 rbgg => new(x, z, y, y); + public readonly float4 rbgb => new(x, z, y, z); + public readonly float4 rbbr => new(x, z, z, x); + public readonly float4 rbbg => new(x, z, z, y); + public readonly float4 rbbb => new(x, z, z, z); + public readonly float4 grrr => new(y, x, x, x); + public readonly float4 grrg => new(y, x, x, y); + public readonly float4 grrb => new(y, x, x, z); + public readonly float4 grgr => new(y, x, y, x); + public readonly float4 grgg => new(y, x, y, y); + public readonly float4 grgb => new(y, x, y, z); + public readonly float4 grbr => new(y, x, z, x); + public readonly float4 grbg => new(y, x, z, y); + public readonly float4 grbb => new(y, x, z, z); + public readonly float4 ggrr => new(y, y, x, x); + public readonly float4 ggrg => new(y, y, x, y); + public readonly float4 ggrb => new(y, y, x, z); + public readonly float4 gggr => new(y, y, y, x); + public readonly float4 gggg => new(y, y, y, y); + public readonly float4 gggb => new(y, y, y, z); + public readonly float4 ggbr => new(y, y, z, x); + public readonly float4 ggbg => new(y, y, z, y); + public readonly float4 ggbb => new(y, y, z, z); + public readonly float4 gbrr => new(y, z, x, x); + public readonly float4 gbrg => new(y, z, x, y); + public readonly float4 gbrb => new(y, z, x, z); + public readonly float4 gbgr => new(y, z, y, x); + public readonly float4 gbgg => new(y, z, y, y); + public readonly float4 gbgb => new(y, z, y, z); + public readonly float4 gbbr => new(y, z, z, x); + public readonly float4 gbbg => new(y, z, z, y); + public readonly float4 gbbb => new(y, z, z, z); + public readonly float4 brrr => new(z, x, x, x); + public readonly float4 brrg => new(z, x, x, y); + public readonly float4 brrb => new(z, x, x, z); + public readonly float4 brgr => new(z, x, y, x); + public readonly float4 brgg => new(z, x, y, y); + public readonly float4 brgb => new(z, x, y, z); + public readonly float4 brbr => new(z, x, z, x); + public readonly float4 brbg => new(z, x, z, y); + public readonly float4 brbb => new(z, x, z, z); + public readonly float4 bgrr => new(z, y, x, x); + public readonly float4 bgrg => new(z, y, x, y); + public readonly float4 bgrb => new(z, y, x, z); + public readonly float4 bggr => new(z, y, y, x); + public readonly float4 bggg => new(z, y, y, y); + public readonly float4 bggb => new(z, y, y, z); + public readonly float4 bgbr => new(z, y, z, x); + public readonly float4 bgbg => new(z, y, z, y); + public readonly float4 bgbb => new(z, y, z, z); + public readonly float4 bbrr => new(z, z, x, x); + public readonly float4 bbrg => new(z, z, x, y); + public readonly float4 bbrb => new(z, z, x, z); + public readonly float4 bbgr => new(z, z, y, x); + public readonly float4 bbgg => new(z, z, y, y); + public readonly float4 bbgb => new(z, z, y, z); + public readonly float4 bbbr => new(z, z, z, x); + public readonly float4 bbbg => new(z, z, z, y); + public readonly float4 bbbb => new(z, z, z, z); +} + +public partial struct float4 +{ + public float4(float x, float y, float2 zw) : this(x, y, zw.x, zw.y) { } + public float4(float x, float2 yz, float w) : this(x, yz.x, yz.y, w) { } + public float4(float x, float3 yzw) : this(x, yzw.x, yzw.y, yzw.z) { } + public float4(float2 xy, float z, float w) : this(xy.x, xy.y, z, w) { } + public float4(float2 xy, float2 zw) : this(xy.x, xy.y, zw.x, zw.y) { } + public float4(float3 xyz, float w) : this(xyz.x, xyz.y, xyz.z, w) { } + public float4(float4 xyzw) : this(xyzw.x, xyzw.y, xyzw.z, xyzw.w) { } + public float r { readonly get => x; set => x = value; } + public float g { readonly get => y; set => y = value; } + public float b { readonly get => z; set => z = value; } + public float a { readonly get => w; set => w = value; } + public readonly float2 xx => new(x, x); + public float2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public float2 xw { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public float2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 yy => new(y, y); + public float2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public float2 yw { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public float2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public float2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly float2 zz => new(z, z); + public float2 zw { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public float2 wx { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public float2 wy { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public float2 wz { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly float2 ww => new(w, w); + public readonly float3 xxx => new(x, x, x); + public readonly float3 xxy => new(x, x, y); + public readonly float3 xxz => new(x, x, z); + public readonly float3 xxw => new(x, x, w); + public readonly float3 xyx => new(x, y, x); + public readonly float3 xyy => new(x, y, y); + public float3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public float3 xyw { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly float3 xzx => new(x, z, x); + public float3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly float3 xzz => new(x, z, z); + public float3 xzw { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly float3 xwx => new(x, w, x); + public float3 xwy { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public float3 xwz { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly float3 xww => new(x, w, w); + public readonly float3 yxx => new(y, x, x); + public readonly float3 yxy => new(y, x, y); + public float3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public float3 yxw { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly float3 yyx => new(y, y, x); + public readonly float3 yyy => new(y, y, y); + public readonly float3 yyz => new(y, y, z); + public readonly float3 yyw => new(y, y, w); + public float3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly float3 yzy => new(y, z, y); + public readonly float3 yzz => new(y, z, z); + public float3 yzw { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public float3 ywx { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly float3 ywy => new(y, w, y); + public float3 ywz { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly float3 yww => new(y, w, w); + public readonly float3 zxx => new(z, x, x); + public float3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly float3 zxz => new(z, x, z); + public float3 zxw { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public float3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly float3 zyy => new(z, y, y); + public readonly float3 zyz => new(z, y, z); + public float3 zyw { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly float3 zzx => new(z, z, x); + public readonly float3 zzy => new(z, z, y); + public readonly float3 zzz => new(z, z, z); + public readonly float3 zzw => new(z, z, w); + public float3 zwx { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public float3 zwy { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly float3 zwz => new(z, w, z); + public readonly float3 zww => new(z, w, w); + public readonly float3 wxx => new(w, x, x); + public float3 wxy { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public float3 wxz { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly float3 wxw => new(w, x, w); + public float3 wyx { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly float3 wyy => new(w, y, y); + public float3 wyz { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly float3 wyw => new(w, y, w); + public float3 wzx { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public float3 wzy { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly float3 wzz => new(w, z, z); + public readonly float3 wzw => new(w, z, w); + public readonly float3 wwx => new(w, w, x); + public readonly float3 wwy => new(w, w, y); + public readonly float3 wwz => new(w, w, z); + public readonly float3 www => new(w, w, w); + public readonly float4 xxxx => new(x, x, x, x); + public readonly float4 xxxy => new(x, x, x, y); + public readonly float4 xxxz => new(x, x, x, z); + public readonly float4 xxxw => new(x, x, x, w); + public readonly float4 xxyx => new(x, x, y, x); + public readonly float4 xxyy => new(x, x, y, y); + public readonly float4 xxyz => new(x, x, y, z); + public readonly float4 xxyw => new(x, x, y, w); + public readonly float4 xxzx => new(x, x, z, x); + public readonly float4 xxzy => new(x, x, z, y); + public readonly float4 xxzz => new(x, x, z, z); + public readonly float4 xxzw => new(x, x, z, w); + public readonly float4 xxwx => new(x, x, w, x); + public readonly float4 xxwy => new(x, x, w, y); + public readonly float4 xxwz => new(x, x, w, z); + public readonly float4 xxww => new(x, x, w, w); + public readonly float4 xyxx => new(x, y, x, x); + public readonly float4 xyxy => new(x, y, x, y); + public readonly float4 xyxz => new(x, y, x, z); + public readonly float4 xyxw => new(x, y, x, w); + public readonly float4 xyyx => new(x, y, y, x); + public readonly float4 xyyy => new(x, y, y, y); + public readonly float4 xyyz => new(x, y, y, z); + public readonly float4 xyyw => new(x, y, y, w); + public readonly float4 xyzx => new(x, y, z, x); + public readonly float4 xyzy => new(x, y, z, y); + public readonly float4 xyzz => new(x, y, z, z); + public float4 xyzw { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly float4 xywx => new(x, y, w, x); + public readonly float4 xywy => new(x, y, w, y); + public float4 xywz { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly float4 xyww => new(x, y, w, w); + public readonly float4 xzxx => new(x, z, x, x); + public readonly float4 xzxy => new(x, z, x, y); + public readonly float4 xzxz => new(x, z, x, z); + public readonly float4 xzxw => new(x, z, x, w); + public readonly float4 xzyx => new(x, z, y, x); + public readonly float4 xzyy => new(x, z, y, y); + public readonly float4 xzyz => new(x, z, y, z); + public float4 xzyw { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly float4 xzzx => new(x, z, z, x); + public readonly float4 xzzy => new(x, z, z, y); + public readonly float4 xzzz => new(x, z, z, z); + public readonly float4 xzzw => new(x, z, z, w); + public readonly float4 xzwx => new(x, z, w, x); + public float4 xzwy { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly float4 xzwz => new(x, z, w, z); + public readonly float4 xzww => new(x, z, w, w); + public readonly float4 xwxx => new(x, w, x, x); + public readonly float4 xwxy => new(x, w, x, y); + public readonly float4 xwxz => new(x, w, x, z); + public readonly float4 xwxw => new(x, w, x, w); + public readonly float4 xwyx => new(x, w, y, x); + public readonly float4 xwyy => new(x, w, y, y); + public float4 xwyz { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly float4 xwyw => new(x, w, y, w); + public readonly float4 xwzx => new(x, w, z, x); + public float4 xwzy { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly float4 xwzz => new(x, w, z, z); + public readonly float4 xwzw => new(x, w, z, w); + public readonly float4 xwwx => new(x, w, w, x); + public readonly float4 xwwy => new(x, w, w, y); + public readonly float4 xwwz => new(x, w, w, z); + public readonly float4 xwww => new(x, w, w, w); + public readonly float4 yxxx => new(y, x, x, x); + public readonly float4 yxxy => new(y, x, x, y); + public readonly float4 yxxz => new(y, x, x, z); + public readonly float4 yxxw => new(y, x, x, w); + public readonly float4 yxyx => new(y, x, y, x); + public readonly float4 yxyy => new(y, x, y, y); + public readonly float4 yxyz => new(y, x, y, z); + public readonly float4 yxyw => new(y, x, y, w); + public readonly float4 yxzx => new(y, x, z, x); + public readonly float4 yxzy => new(y, x, z, y); + public readonly float4 yxzz => new(y, x, z, z); + public float4 yxzw { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly float4 yxwx => new(y, x, w, x); + public readonly float4 yxwy => new(y, x, w, y); + public float4 yxwz { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly float4 yxww => new(y, x, w, w); + public readonly float4 yyxx => new(y, y, x, x); + public readonly float4 yyxy => new(y, y, x, y); + public readonly float4 yyxz => new(y, y, x, z); + public readonly float4 yyxw => new(y, y, x, w); + public readonly float4 yyyx => new(y, y, y, x); + public readonly float4 yyyy => new(y, y, y, y); + public readonly float4 yyyz => new(y, y, y, z); + public readonly float4 yyyw => new(y, y, y, w); + public readonly float4 yyzx => new(y, y, z, x); + public readonly float4 yyzy => new(y, y, z, y); + public readonly float4 yyzz => new(y, y, z, z); + public readonly float4 yyzw => new(y, y, z, w); + public readonly float4 yywx => new(y, y, w, x); + public readonly float4 yywy => new(y, y, w, y); + public readonly float4 yywz => new(y, y, w, z); + public readonly float4 yyww => new(y, y, w, w); + public readonly float4 yzxx => new(y, z, x, x); + public readonly float4 yzxy => new(y, z, x, y); + public readonly float4 yzxz => new(y, z, x, z); + public float4 yzxw { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly float4 yzyx => new(y, z, y, x); + public readonly float4 yzyy => new(y, z, y, y); + public readonly float4 yzyz => new(y, z, y, z); + public readonly float4 yzyw => new(y, z, y, w); + public readonly float4 yzzx => new(y, z, z, x); + public readonly float4 yzzy => new(y, z, z, y); + public readonly float4 yzzz => new(y, z, z, z); + public readonly float4 yzzw => new(y, z, z, w); + public float4 yzwx { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly float4 yzwy => new(y, z, w, y); + public readonly float4 yzwz => new(y, z, w, z); + public readonly float4 yzww => new(y, z, w, w); + public readonly float4 ywxx => new(y, w, x, x); + public readonly float4 ywxy => new(y, w, x, y); + public float4 ywxz { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly float4 ywxw => new(y, w, x, w); + public readonly float4 ywyx => new(y, w, y, x); + public readonly float4 ywyy => new(y, w, y, y); + public readonly float4 ywyz => new(y, w, y, z); + public readonly float4 ywyw => new(y, w, y, w); + public float4 ywzx { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly float4 ywzy => new(y, w, z, y); + public readonly float4 ywzz => new(y, w, z, z); + public readonly float4 ywzw => new(y, w, z, w); + public readonly float4 ywwx => new(y, w, w, x); + public readonly float4 ywwy => new(y, w, w, y); + public readonly float4 ywwz => new(y, w, w, z); + public readonly float4 ywww => new(y, w, w, w); + public readonly float4 zxxx => new(z, x, x, x); + public readonly float4 zxxy => new(z, x, x, y); + public readonly float4 zxxz => new(z, x, x, z); + public readonly float4 zxxw => new(z, x, x, w); + public readonly float4 zxyx => new(z, x, y, x); + public readonly float4 zxyy => new(z, x, y, y); + public readonly float4 zxyz => new(z, x, y, z); + public float4 zxyw { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly float4 zxzx => new(z, x, z, x); + public readonly float4 zxzy => new(z, x, z, y); + public readonly float4 zxzz => new(z, x, z, z); + public readonly float4 zxzw => new(z, x, z, w); + public readonly float4 zxwx => new(z, x, w, x); + public float4 zxwy { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly float4 zxwz => new(z, x, w, z); + public readonly float4 zxww => new(z, x, w, w); + public readonly float4 zyxx => new(z, y, x, x); + public readonly float4 zyxy => new(z, y, x, y); + public readonly float4 zyxz => new(z, y, x, z); + public float4 zyxw { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly float4 zyyx => new(z, y, y, x); + public readonly float4 zyyy => new(z, y, y, y); + public readonly float4 zyyz => new(z, y, y, z); + public readonly float4 zyyw => new(z, y, y, w); + public readonly float4 zyzx => new(z, y, z, x); + public readonly float4 zyzy => new(z, y, z, y); + public readonly float4 zyzz => new(z, y, z, z); + public readonly float4 zyzw => new(z, y, z, w); + public float4 zywx { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly float4 zywy => new(z, y, w, y); + public readonly float4 zywz => new(z, y, w, z); + public readonly float4 zyww => new(z, y, w, w); + public readonly float4 zzxx => new(z, z, x, x); + public readonly float4 zzxy => new(z, z, x, y); + public readonly float4 zzxz => new(z, z, x, z); + public readonly float4 zzxw => new(z, z, x, w); + public readonly float4 zzyx => new(z, z, y, x); + public readonly float4 zzyy => new(z, z, y, y); + public readonly float4 zzyz => new(z, z, y, z); + public readonly float4 zzyw => new(z, z, y, w); + public readonly float4 zzzx => new(z, z, z, x); + public readonly float4 zzzy => new(z, z, z, y); + public readonly float4 zzzz => new(z, z, z, z); + public readonly float4 zzzw => new(z, z, z, w); + public readonly float4 zzwx => new(z, z, w, x); + public readonly float4 zzwy => new(z, z, w, y); + public readonly float4 zzwz => new(z, z, w, z); + public readonly float4 zzww => new(z, z, w, w); + public readonly float4 zwxx => new(z, w, x, x); + public float4 zwxy { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly float4 zwxz => new(z, w, x, z); + public readonly float4 zwxw => new(z, w, x, w); + public float4 zwyx { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly float4 zwyy => new(z, w, y, y); + public readonly float4 zwyz => new(z, w, y, z); + public readonly float4 zwyw => new(z, w, y, w); + public readonly float4 zwzx => new(z, w, z, x); + public readonly float4 zwzy => new(z, w, z, y); + public readonly float4 zwzz => new(z, w, z, z); + public readonly float4 zwzw => new(z, w, z, w); + public readonly float4 zwwx => new(z, w, w, x); + public readonly float4 zwwy => new(z, w, w, y); + public readonly float4 zwwz => new(z, w, w, z); + public readonly float4 zwww => new(z, w, w, w); + public readonly float4 wxxx => new(w, x, x, x); + public readonly float4 wxxy => new(w, x, x, y); + public readonly float4 wxxz => new(w, x, x, z); + public readonly float4 wxxw => new(w, x, x, w); + public readonly float4 wxyx => new(w, x, y, x); + public readonly float4 wxyy => new(w, x, y, y); + public float4 wxyz { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly float4 wxyw => new(w, x, y, w); + public readonly float4 wxzx => new(w, x, z, x); + public float4 wxzy { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly float4 wxzz => new(w, x, z, z); + public readonly float4 wxzw => new(w, x, z, w); + public readonly float4 wxwx => new(w, x, w, x); + public readonly float4 wxwy => new(w, x, w, y); + public readonly float4 wxwz => new(w, x, w, z); + public readonly float4 wxww => new(w, x, w, w); + public readonly float4 wyxx => new(w, y, x, x); + public readonly float4 wyxy => new(w, y, x, y); + public float4 wyxz { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly float4 wyxw => new(w, y, x, w); + public readonly float4 wyyx => new(w, y, y, x); + public readonly float4 wyyy => new(w, y, y, y); + public readonly float4 wyyz => new(w, y, y, z); + public readonly float4 wyyw => new(w, y, y, w); + public float4 wyzx { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly float4 wyzy => new(w, y, z, y); + public readonly float4 wyzz => new(w, y, z, z); + public readonly float4 wyzw => new(w, y, z, w); + public readonly float4 wywx => new(w, y, w, x); + public readonly float4 wywy => new(w, y, w, y); + public readonly float4 wywz => new(w, y, w, z); + public readonly float4 wyww => new(w, y, w, w); + public readonly float4 wzxx => new(w, z, x, x); + public float4 wzxy { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly float4 wzxz => new(w, z, x, z); + public readonly float4 wzxw => new(w, z, x, w); + public float4 wzyx { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly float4 wzyy => new(w, z, y, y); + public readonly float4 wzyz => new(w, z, y, z); + public readonly float4 wzyw => new(w, z, y, w); + public readonly float4 wzzx => new(w, z, z, x); + public readonly float4 wzzy => new(w, z, z, y); + public readonly float4 wzzz => new(w, z, z, z); + public readonly float4 wzzw => new(w, z, z, w); + public readonly float4 wzwx => new(w, z, w, x); + public readonly float4 wzwy => new(w, z, w, y); + public readonly float4 wzwz => new(w, z, w, z); + public readonly float4 wzww => new(w, z, w, w); + public readonly float4 wwxx => new(w, w, x, x); + public readonly float4 wwxy => new(w, w, x, y); + public readonly float4 wwxz => new(w, w, x, z); + public readonly float4 wwxw => new(w, w, x, w); + public readonly float4 wwyx => new(w, w, y, x); + public readonly float4 wwyy => new(w, w, y, y); + public readonly float4 wwyz => new(w, w, y, z); + public readonly float4 wwyw => new(w, w, y, w); + public readonly float4 wwzx => new(w, w, z, x); + public readonly float4 wwzy => new(w, w, z, y); + public readonly float4 wwzz => new(w, w, z, z); + public readonly float4 wwzw => new(w, w, z, w); + public readonly float4 wwwx => new(w, w, w, x); + public readonly float4 wwwy => new(w, w, w, y); + public readonly float4 wwwz => new(w, w, w, z); + public readonly float4 wwww => new(w, w, w, w); + public readonly float2 rr => new(x, x); + public float2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public float2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public float2 ra { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public float2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly float2 gg => new(y, y); + public float2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public float2 ga { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public float2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public float2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly float2 bb => new(z, z); + public float2 ba { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public float2 ar { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public float2 ag { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public float2 ab { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly float2 aa => new(w, w); + public readonly float3 rrr => new(x, x, x); + public readonly float3 rrg => new(x, x, y); + public readonly float3 rrb => new(x, x, z); + public readonly float3 rra => new(x, x, w); + public readonly float3 rgr => new(x, y, x); + public readonly float3 rgg => new(x, y, y); + public float3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public float3 rga { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly float3 rbr => new(x, z, x); + public float3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly float3 rbb => new(x, z, z); + public float3 rba { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly float3 rar => new(x, w, x); + public float3 rag { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public float3 rab { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly float3 raa => new(x, w, w); + public readonly float3 grr => new(y, x, x); + public readonly float3 grg => new(y, x, y); + public float3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public float3 gra { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly float3 ggr => new(y, y, x); + public readonly float3 ggg => new(y, y, y); + public readonly float3 ggb => new(y, y, z); + public readonly float3 gga => new(y, y, w); + public float3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly float3 gbg => new(y, z, y); + public readonly float3 gbb => new(y, z, z); + public float3 gba { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public float3 gar { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly float3 gag => new(y, w, y); + public float3 gab { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly float3 gaa => new(y, w, w); + public readonly float3 brr => new(z, x, x); + public float3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly float3 brb => new(z, x, z); + public float3 bra { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public float3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly float3 bgg => new(z, y, y); + public readonly float3 bgb => new(z, y, z); + public float3 bga { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly float3 bbr => new(z, z, x); + public readonly float3 bbg => new(z, z, y); + public readonly float3 bbb => new(z, z, z); + public readonly float3 bba => new(z, z, w); + public float3 bar { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public float3 bag { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly float3 bab => new(z, w, z); + public readonly float3 baa => new(z, w, w); + public readonly float3 arr => new(w, x, x); + public float3 arg { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public float3 arb { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly float3 ara => new(w, x, w); + public float3 agr { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly float3 agg => new(w, y, y); + public float3 agb { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly float3 aga => new(w, y, w); + public float3 abr { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public float3 abg { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly float3 abb => new(w, z, z); + public readonly float3 aba => new(w, z, w); + public readonly float3 aar => new(w, w, x); + public readonly float3 aag => new(w, w, y); + public readonly float3 aab => new(w, w, z); + public readonly float3 aaa => new(w, w, w); + public readonly float4 rrrr => new(x, x, x, x); + public readonly float4 rrrg => new(x, x, x, y); + public readonly float4 rrrb => new(x, x, x, z); + public readonly float4 rrra => new(x, x, x, w); + public readonly float4 rrgr => new(x, x, y, x); + public readonly float4 rrgg => new(x, x, y, y); + public readonly float4 rrgb => new(x, x, y, z); + public readonly float4 rrga => new(x, x, y, w); + public readonly float4 rrbr => new(x, x, z, x); + public readonly float4 rrbg => new(x, x, z, y); + public readonly float4 rrbb => new(x, x, z, z); + public readonly float4 rrba => new(x, x, z, w); + public readonly float4 rrar => new(x, x, w, x); + public readonly float4 rrag => new(x, x, w, y); + public readonly float4 rrab => new(x, x, w, z); + public readonly float4 rraa => new(x, x, w, w); + public readonly float4 rgrr => new(x, y, x, x); + public readonly float4 rgrg => new(x, y, x, y); + public readonly float4 rgrb => new(x, y, x, z); + public readonly float4 rgra => new(x, y, x, w); + public readonly float4 rggr => new(x, y, y, x); + public readonly float4 rggg => new(x, y, y, y); + public readonly float4 rggb => new(x, y, y, z); + public readonly float4 rgga => new(x, y, y, w); + public readonly float4 rgbr => new(x, y, z, x); + public readonly float4 rgbg => new(x, y, z, y); + public readonly float4 rgbb => new(x, y, z, z); + public float4 rgba { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly float4 rgar => new(x, y, w, x); + public readonly float4 rgag => new(x, y, w, y); + public float4 rgab { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly float4 rgaa => new(x, y, w, w); + public readonly float4 rbrr => new(x, z, x, x); + public readonly float4 rbrg => new(x, z, x, y); + public readonly float4 rbrb => new(x, z, x, z); + public readonly float4 rbra => new(x, z, x, w); + public readonly float4 rbgr => new(x, z, y, x); + public readonly float4 rbgg => new(x, z, y, y); + public readonly float4 rbgb => new(x, z, y, z); + public float4 rbga { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly float4 rbbr => new(x, z, z, x); + public readonly float4 rbbg => new(x, z, z, y); + public readonly float4 rbbb => new(x, z, z, z); + public readonly float4 rbba => new(x, z, z, w); + public readonly float4 rbar => new(x, z, w, x); + public float4 rbag { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly float4 rbab => new(x, z, w, z); + public readonly float4 rbaa => new(x, z, w, w); + public readonly float4 rarr => new(x, w, x, x); + public readonly float4 rarg => new(x, w, x, y); + public readonly float4 rarb => new(x, w, x, z); + public readonly float4 rara => new(x, w, x, w); + public readonly float4 ragr => new(x, w, y, x); + public readonly float4 ragg => new(x, w, y, y); + public float4 ragb { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly float4 raga => new(x, w, y, w); + public readonly float4 rabr => new(x, w, z, x); + public float4 rabg { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly float4 rabb => new(x, w, z, z); + public readonly float4 raba => new(x, w, z, w); + public readonly float4 raar => new(x, w, w, x); + public readonly float4 raag => new(x, w, w, y); + public readonly float4 raab => new(x, w, w, z); + public readonly float4 raaa => new(x, w, w, w); + public readonly float4 grrr => new(y, x, x, x); + public readonly float4 grrg => new(y, x, x, y); + public readonly float4 grrb => new(y, x, x, z); + public readonly float4 grra => new(y, x, x, w); + public readonly float4 grgr => new(y, x, y, x); + public readonly float4 grgg => new(y, x, y, y); + public readonly float4 grgb => new(y, x, y, z); + public readonly float4 grga => new(y, x, y, w); + public readonly float4 grbr => new(y, x, z, x); + public readonly float4 grbg => new(y, x, z, y); + public readonly float4 grbb => new(y, x, z, z); + public float4 grba { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly float4 grar => new(y, x, w, x); + public readonly float4 grag => new(y, x, w, y); + public float4 grab { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly float4 graa => new(y, x, w, w); + public readonly float4 ggrr => new(y, y, x, x); + public readonly float4 ggrg => new(y, y, x, y); + public readonly float4 ggrb => new(y, y, x, z); + public readonly float4 ggra => new(y, y, x, w); + public readonly float4 gggr => new(y, y, y, x); + public readonly float4 gggg => new(y, y, y, y); + public readonly float4 gggb => new(y, y, y, z); + public readonly float4 ggga => new(y, y, y, w); + public readonly float4 ggbr => new(y, y, z, x); + public readonly float4 ggbg => new(y, y, z, y); + public readonly float4 ggbb => new(y, y, z, z); + public readonly float4 ggba => new(y, y, z, w); + public readonly float4 ggar => new(y, y, w, x); + public readonly float4 ggag => new(y, y, w, y); + public readonly float4 ggab => new(y, y, w, z); + public readonly float4 ggaa => new(y, y, w, w); + public readonly float4 gbrr => new(y, z, x, x); + public readonly float4 gbrg => new(y, z, x, y); + public readonly float4 gbrb => new(y, z, x, z); + public float4 gbra { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly float4 gbgr => new(y, z, y, x); + public readonly float4 gbgg => new(y, z, y, y); + public readonly float4 gbgb => new(y, z, y, z); + public readonly float4 gbga => new(y, z, y, w); + public readonly float4 gbbr => new(y, z, z, x); + public readonly float4 gbbg => new(y, z, z, y); + public readonly float4 gbbb => new(y, z, z, z); + public readonly float4 gbba => new(y, z, z, w); + public float4 gbar { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly float4 gbag => new(y, z, w, y); + public readonly float4 gbab => new(y, z, w, z); + public readonly float4 gbaa => new(y, z, w, w); + public readonly float4 garr => new(y, w, x, x); + public readonly float4 garg => new(y, w, x, y); + public float4 garb { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly float4 gara => new(y, w, x, w); + public readonly float4 gagr => new(y, w, y, x); + public readonly float4 gagg => new(y, w, y, y); + public readonly float4 gagb => new(y, w, y, z); + public readonly float4 gaga => new(y, w, y, w); + public float4 gabr { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly float4 gabg => new(y, w, z, y); + public readonly float4 gabb => new(y, w, z, z); + public readonly float4 gaba => new(y, w, z, w); + public readonly float4 gaar => new(y, w, w, x); + public readonly float4 gaag => new(y, w, w, y); + public readonly float4 gaab => new(y, w, w, z); + public readonly float4 gaaa => new(y, w, w, w); + public readonly float4 brrr => new(z, x, x, x); + public readonly float4 brrg => new(z, x, x, y); + public readonly float4 brrb => new(z, x, x, z); + public readonly float4 brra => new(z, x, x, w); + public readonly float4 brgr => new(z, x, y, x); + public readonly float4 brgg => new(z, x, y, y); + public readonly float4 brgb => new(z, x, y, z); + public float4 brga { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly float4 brbr => new(z, x, z, x); + public readonly float4 brbg => new(z, x, z, y); + public readonly float4 brbb => new(z, x, z, z); + public readonly float4 brba => new(z, x, z, w); + public readonly float4 brar => new(z, x, w, x); + public float4 brag { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly float4 brab => new(z, x, w, z); + public readonly float4 braa => new(z, x, w, w); + public readonly float4 bgrr => new(z, y, x, x); + public readonly float4 bgrg => new(z, y, x, y); + public readonly float4 bgrb => new(z, y, x, z); + public float4 bgra { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly float4 bggr => new(z, y, y, x); + public readonly float4 bggg => new(z, y, y, y); + public readonly float4 bggb => new(z, y, y, z); + public readonly float4 bgga => new(z, y, y, w); + public readonly float4 bgbr => new(z, y, z, x); + public readonly float4 bgbg => new(z, y, z, y); + public readonly float4 bgbb => new(z, y, z, z); + public readonly float4 bgba => new(z, y, z, w); + public float4 bgar { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly float4 bgag => new(z, y, w, y); + public readonly float4 bgab => new(z, y, w, z); + public readonly float4 bgaa => new(z, y, w, w); + public readonly float4 bbrr => new(z, z, x, x); + public readonly float4 bbrg => new(z, z, x, y); + public readonly float4 bbrb => new(z, z, x, z); + public readonly float4 bbra => new(z, z, x, w); + public readonly float4 bbgr => new(z, z, y, x); + public readonly float4 bbgg => new(z, z, y, y); + public readonly float4 bbgb => new(z, z, y, z); + public readonly float4 bbga => new(z, z, y, w); + public readonly float4 bbbr => new(z, z, z, x); + public readonly float4 bbbg => new(z, z, z, y); + public readonly float4 bbbb => new(z, z, z, z); + public readonly float4 bbba => new(z, z, z, w); + public readonly float4 bbar => new(z, z, w, x); + public readonly float4 bbag => new(z, z, w, y); + public readonly float4 bbab => new(z, z, w, z); + public readonly float4 bbaa => new(z, z, w, w); + public readonly float4 barr => new(z, w, x, x); + public float4 barg { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly float4 barb => new(z, w, x, z); + public readonly float4 bara => new(z, w, x, w); + public float4 bagr { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly float4 bagg => new(z, w, y, y); + public readonly float4 bagb => new(z, w, y, z); + public readonly float4 baga => new(z, w, y, w); + public readonly float4 babr => new(z, w, z, x); + public readonly float4 babg => new(z, w, z, y); + public readonly float4 babb => new(z, w, z, z); + public readonly float4 baba => new(z, w, z, w); + public readonly float4 baar => new(z, w, w, x); + public readonly float4 baag => new(z, w, w, y); + public readonly float4 baab => new(z, w, w, z); + public readonly float4 baaa => new(z, w, w, w); + public readonly float4 arrr => new(w, x, x, x); + public readonly float4 arrg => new(w, x, x, y); + public readonly float4 arrb => new(w, x, x, z); + public readonly float4 arra => new(w, x, x, w); + public readonly float4 argr => new(w, x, y, x); + public readonly float4 argg => new(w, x, y, y); + public float4 argb { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly float4 arga => new(w, x, y, w); + public readonly float4 arbr => new(w, x, z, x); + public float4 arbg { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly float4 arbb => new(w, x, z, z); + public readonly float4 arba => new(w, x, z, w); + public readonly float4 arar => new(w, x, w, x); + public readonly float4 arag => new(w, x, w, y); + public readonly float4 arab => new(w, x, w, z); + public readonly float4 araa => new(w, x, w, w); + public readonly float4 agrr => new(w, y, x, x); + public readonly float4 agrg => new(w, y, x, y); + public float4 agrb { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly float4 agra => new(w, y, x, w); + public readonly float4 aggr => new(w, y, y, x); + public readonly float4 aggg => new(w, y, y, y); + public readonly float4 aggb => new(w, y, y, z); + public readonly float4 agga => new(w, y, y, w); + public float4 agbr { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly float4 agbg => new(w, y, z, y); + public readonly float4 agbb => new(w, y, z, z); + public readonly float4 agba => new(w, y, z, w); + public readonly float4 agar => new(w, y, w, x); + public readonly float4 agag => new(w, y, w, y); + public readonly float4 agab => new(w, y, w, z); + public readonly float4 agaa => new(w, y, w, w); + public readonly float4 abrr => new(w, z, x, x); + public float4 abrg { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly float4 abrb => new(w, z, x, z); + public readonly float4 abra => new(w, z, x, w); + public float4 abgr { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly float4 abgg => new(w, z, y, y); + public readonly float4 abgb => new(w, z, y, z); + public readonly float4 abga => new(w, z, y, w); + public readonly float4 abbr => new(w, z, z, x); + public readonly float4 abbg => new(w, z, z, y); + public readonly float4 abbb => new(w, z, z, z); + public readonly float4 abba => new(w, z, z, w); + public readonly float4 abar => new(w, z, w, x); + public readonly float4 abag => new(w, z, w, y); + public readonly float4 abab => new(w, z, w, z); + public readonly float4 abaa => new(w, z, w, w); + public readonly float4 aarr => new(w, w, x, x); + public readonly float4 aarg => new(w, w, x, y); + public readonly float4 aarb => new(w, w, x, z); + public readonly float4 aara => new(w, w, x, w); + public readonly float4 aagr => new(w, w, y, x); + public readonly float4 aagg => new(w, w, y, y); + public readonly float4 aagb => new(w, w, y, z); + public readonly float4 aaga => new(w, w, y, w); + public readonly float4 aabr => new(w, w, z, x); + public readonly float4 aabg => new(w, w, z, y); + public readonly float4 aabb => new(w, w, z, z); + public readonly float4 aaba => new(w, w, z, w); + public readonly float4 aaar => new(w, w, w, x); + public readonly float4 aaag => new(w, w, w, y); + public readonly float4 aaab => new(w, w, w, z); + public readonly float4 aaaa => new(w, w, w, w); +} + +public partial struct int2 +{ + public int2(int2 xy) : this(xy.x, xy.y) { } + public int r { readonly get => x; set => x = value; } + public int g { readonly get => y; set => y = value; } + public readonly int2 xx => new(x, x); + public int2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 yy => new(y, y); + public readonly int3 xxx => new(x, x, x); + public readonly int3 xxy => new(x, x, y); + public readonly int3 xyx => new(x, y, x); + public readonly int3 xyy => new(x, y, y); + public readonly int3 yxx => new(y, x, x); + public readonly int3 yxy => new(y, x, y); + public readonly int3 yyx => new(y, y, x); + public readonly int3 yyy => new(y, y, y); + public readonly int4 xxxx => new(x, x, x, x); + public readonly int4 xxxy => new(x, x, x, y); + public readonly int4 xxyx => new(x, x, y, x); + public readonly int4 xxyy => new(x, x, y, y); + public readonly int4 xyxx => new(x, y, x, x); + public readonly int4 xyxy => new(x, y, x, y); + public readonly int4 xyyx => new(x, y, y, x); + public readonly int4 xyyy => new(x, y, y, y); + public readonly int4 yxxx => new(y, x, x, x); + public readonly int4 yxxy => new(y, x, x, y); + public readonly int4 yxyx => new(y, x, y, x); + public readonly int4 yxyy => new(y, x, y, y); + public readonly int4 yyxx => new(y, y, x, x); + public readonly int4 yyxy => new(y, y, x, y); + public readonly int4 yyyx => new(y, y, y, x); + public readonly int4 yyyy => new(y, y, y, y); + public readonly int2 rr => new(x, x); + public int2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 gg => new(y, y); + public readonly int3 rrr => new(x, x, x); + public readonly int3 rrg => new(x, x, y); + public readonly int3 rgr => new(x, y, x); + public readonly int3 rgg => new(x, y, y); + public readonly int3 grr => new(y, x, x); + public readonly int3 grg => new(y, x, y); + public readonly int3 ggr => new(y, y, x); + public readonly int3 ggg => new(y, y, y); + public readonly int4 rrrr => new(x, x, x, x); + public readonly int4 rrrg => new(x, x, x, y); + public readonly int4 rrgr => new(x, x, y, x); + public readonly int4 rrgg => new(x, x, y, y); + public readonly int4 rgrr => new(x, y, x, x); + public readonly int4 rgrg => new(x, y, x, y); + public readonly int4 rggr => new(x, y, y, x); + public readonly int4 rggg => new(x, y, y, y); + public readonly int4 grrr => new(y, x, x, x); + public readonly int4 grrg => new(y, x, x, y); + public readonly int4 grgr => new(y, x, y, x); + public readonly int4 grgg => new(y, x, y, y); + public readonly int4 ggrr => new(y, y, x, x); + public readonly int4 ggrg => new(y, y, x, y); + public readonly int4 gggr => new(y, y, y, x); + public readonly int4 gggg => new(y, y, y, y); +} + +public partial struct int3 +{ + public int3(int x, int2 yz) : this(x, yz.x, yz.y) { } + public int3(int2 xy, int z) : this(xy.x, xy.y, z) { } + public int3(int3 xyz) : this(xyz.x, xyz.y, xyz.z) { } + public int r { readonly get => x; set => x = value; } + public int g { readonly get => y; set => y = value; } + public int b { readonly get => z; set => z = value; } + public readonly int2 xx => new(x, x); + public int2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public int2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 yy => new(y, y); + public int2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public int2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public int2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly int2 zz => new(z, z); + public readonly int3 xxx => new(x, x, x); + public readonly int3 xxy => new(x, x, y); + public readonly int3 xxz => new(x, x, z); + public readonly int3 xyx => new(x, y, x); + public readonly int3 xyy => new(x, y, y); + public int3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly int3 xzx => new(x, z, x); + public int3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly int3 xzz => new(x, z, z); + public readonly int3 yxx => new(y, x, x); + public readonly int3 yxy => new(y, x, y); + public int3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly int3 yyx => new(y, y, x); + public readonly int3 yyy => new(y, y, y); + public readonly int3 yyz => new(y, y, z); + public int3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly int3 yzy => new(y, z, y); + public readonly int3 yzz => new(y, z, z); + public readonly int3 zxx => new(z, x, x); + public int3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly int3 zxz => new(z, x, z); + public int3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly int3 zyy => new(z, y, y); + public readonly int3 zyz => new(z, y, z); + public readonly int3 zzx => new(z, z, x); + public readonly int3 zzy => new(z, z, y); + public readonly int3 zzz => new(z, z, z); + public readonly int4 xxxx => new(x, x, x, x); + public readonly int4 xxxy => new(x, x, x, y); + public readonly int4 xxxz => new(x, x, x, z); + public readonly int4 xxyx => new(x, x, y, x); + public readonly int4 xxyy => new(x, x, y, y); + public readonly int4 xxyz => new(x, x, y, z); + public readonly int4 xxzx => new(x, x, z, x); + public readonly int4 xxzy => new(x, x, z, y); + public readonly int4 xxzz => new(x, x, z, z); + public readonly int4 xyxx => new(x, y, x, x); + public readonly int4 xyxy => new(x, y, x, y); + public readonly int4 xyxz => new(x, y, x, z); + public readonly int4 xyyx => new(x, y, y, x); + public readonly int4 xyyy => new(x, y, y, y); + public readonly int4 xyyz => new(x, y, y, z); + public readonly int4 xyzx => new(x, y, z, x); + public readonly int4 xyzy => new(x, y, z, y); + public readonly int4 xyzz => new(x, y, z, z); + public readonly int4 xzxx => new(x, z, x, x); + public readonly int4 xzxy => new(x, z, x, y); + public readonly int4 xzxz => new(x, z, x, z); + public readonly int4 xzyx => new(x, z, y, x); + public readonly int4 xzyy => new(x, z, y, y); + public readonly int4 xzyz => new(x, z, y, z); + public readonly int4 xzzx => new(x, z, z, x); + public readonly int4 xzzy => new(x, z, z, y); + public readonly int4 xzzz => new(x, z, z, z); + public readonly int4 yxxx => new(y, x, x, x); + public readonly int4 yxxy => new(y, x, x, y); + public readonly int4 yxxz => new(y, x, x, z); + public readonly int4 yxyx => new(y, x, y, x); + public readonly int4 yxyy => new(y, x, y, y); + public readonly int4 yxyz => new(y, x, y, z); + public readonly int4 yxzx => new(y, x, z, x); + public readonly int4 yxzy => new(y, x, z, y); + public readonly int4 yxzz => new(y, x, z, z); + public readonly int4 yyxx => new(y, y, x, x); + public readonly int4 yyxy => new(y, y, x, y); + public readonly int4 yyxz => new(y, y, x, z); + public readonly int4 yyyx => new(y, y, y, x); + public readonly int4 yyyy => new(y, y, y, y); + public readonly int4 yyyz => new(y, y, y, z); + public readonly int4 yyzx => new(y, y, z, x); + public readonly int4 yyzy => new(y, y, z, y); + public readonly int4 yyzz => new(y, y, z, z); + public readonly int4 yzxx => new(y, z, x, x); + public readonly int4 yzxy => new(y, z, x, y); + public readonly int4 yzxz => new(y, z, x, z); + public readonly int4 yzyx => new(y, z, y, x); + public readonly int4 yzyy => new(y, z, y, y); + public readonly int4 yzyz => new(y, z, y, z); + public readonly int4 yzzx => new(y, z, z, x); + public readonly int4 yzzy => new(y, z, z, y); + public readonly int4 yzzz => new(y, z, z, z); + public readonly int4 zxxx => new(z, x, x, x); + public readonly int4 zxxy => new(z, x, x, y); + public readonly int4 zxxz => new(z, x, x, z); + public readonly int4 zxyx => new(z, x, y, x); + public readonly int4 zxyy => new(z, x, y, y); + public readonly int4 zxyz => new(z, x, y, z); + public readonly int4 zxzx => new(z, x, z, x); + public readonly int4 zxzy => new(z, x, z, y); + public readonly int4 zxzz => new(z, x, z, z); + public readonly int4 zyxx => new(z, y, x, x); + public readonly int4 zyxy => new(z, y, x, y); + public readonly int4 zyxz => new(z, y, x, z); + public readonly int4 zyyx => new(z, y, y, x); + public readonly int4 zyyy => new(z, y, y, y); + public readonly int4 zyyz => new(z, y, y, z); + public readonly int4 zyzx => new(z, y, z, x); + public readonly int4 zyzy => new(z, y, z, y); + public readonly int4 zyzz => new(z, y, z, z); + public readonly int4 zzxx => new(z, z, x, x); + public readonly int4 zzxy => new(z, z, x, y); + public readonly int4 zzxz => new(z, z, x, z); + public readonly int4 zzyx => new(z, z, y, x); + public readonly int4 zzyy => new(z, z, y, y); + public readonly int4 zzyz => new(z, z, y, z); + public readonly int4 zzzx => new(z, z, z, x); + public readonly int4 zzzy => new(z, z, z, y); + public readonly int4 zzzz => new(z, z, z, z); + public readonly int2 rr => new(x, x); + public int2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public int2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 gg => new(y, y); + public int2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public int2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public int2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly int2 bb => new(z, z); + public readonly int3 rrr => new(x, x, x); + public readonly int3 rrg => new(x, x, y); + public readonly int3 rrb => new(x, x, z); + public readonly int3 rgr => new(x, y, x); + public readonly int3 rgg => new(x, y, y); + public int3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly int3 rbr => new(x, z, x); + public int3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly int3 rbb => new(x, z, z); + public readonly int3 grr => new(y, x, x); + public readonly int3 grg => new(y, x, y); + public int3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly int3 ggr => new(y, y, x); + public readonly int3 ggg => new(y, y, y); + public readonly int3 ggb => new(y, y, z); + public int3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly int3 gbg => new(y, z, y); + public readonly int3 gbb => new(y, z, z); + public readonly int3 brr => new(z, x, x); + public int3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly int3 brb => new(z, x, z); + public int3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly int3 bgg => new(z, y, y); + public readonly int3 bgb => new(z, y, z); + public readonly int3 bbr => new(z, z, x); + public readonly int3 bbg => new(z, z, y); + public readonly int3 bbb => new(z, z, z); + public readonly int4 rrrr => new(x, x, x, x); + public readonly int4 rrrg => new(x, x, x, y); + public readonly int4 rrrb => new(x, x, x, z); + public readonly int4 rrgr => new(x, x, y, x); + public readonly int4 rrgg => new(x, x, y, y); + public readonly int4 rrgb => new(x, x, y, z); + public readonly int4 rrbr => new(x, x, z, x); + public readonly int4 rrbg => new(x, x, z, y); + public readonly int4 rrbb => new(x, x, z, z); + public readonly int4 rgrr => new(x, y, x, x); + public readonly int4 rgrg => new(x, y, x, y); + public readonly int4 rgrb => new(x, y, x, z); + public readonly int4 rggr => new(x, y, y, x); + public readonly int4 rggg => new(x, y, y, y); + public readonly int4 rggb => new(x, y, y, z); + public readonly int4 rgbr => new(x, y, z, x); + public readonly int4 rgbg => new(x, y, z, y); + public readonly int4 rgbb => new(x, y, z, z); + public readonly int4 rbrr => new(x, z, x, x); + public readonly int4 rbrg => new(x, z, x, y); + public readonly int4 rbrb => new(x, z, x, z); + public readonly int4 rbgr => new(x, z, y, x); + public readonly int4 rbgg => new(x, z, y, y); + public readonly int4 rbgb => new(x, z, y, z); + public readonly int4 rbbr => new(x, z, z, x); + public readonly int4 rbbg => new(x, z, z, y); + public readonly int4 rbbb => new(x, z, z, z); + public readonly int4 grrr => new(y, x, x, x); + public readonly int4 grrg => new(y, x, x, y); + public readonly int4 grrb => new(y, x, x, z); + public readonly int4 grgr => new(y, x, y, x); + public readonly int4 grgg => new(y, x, y, y); + public readonly int4 grgb => new(y, x, y, z); + public readonly int4 grbr => new(y, x, z, x); + public readonly int4 grbg => new(y, x, z, y); + public readonly int4 grbb => new(y, x, z, z); + public readonly int4 ggrr => new(y, y, x, x); + public readonly int4 ggrg => new(y, y, x, y); + public readonly int4 ggrb => new(y, y, x, z); + public readonly int4 gggr => new(y, y, y, x); + public readonly int4 gggg => new(y, y, y, y); + public readonly int4 gggb => new(y, y, y, z); + public readonly int4 ggbr => new(y, y, z, x); + public readonly int4 ggbg => new(y, y, z, y); + public readonly int4 ggbb => new(y, y, z, z); + public readonly int4 gbrr => new(y, z, x, x); + public readonly int4 gbrg => new(y, z, x, y); + public readonly int4 gbrb => new(y, z, x, z); + public readonly int4 gbgr => new(y, z, y, x); + public readonly int4 gbgg => new(y, z, y, y); + public readonly int4 gbgb => new(y, z, y, z); + public readonly int4 gbbr => new(y, z, z, x); + public readonly int4 gbbg => new(y, z, z, y); + public readonly int4 gbbb => new(y, z, z, z); + public readonly int4 brrr => new(z, x, x, x); + public readonly int4 brrg => new(z, x, x, y); + public readonly int4 brrb => new(z, x, x, z); + public readonly int4 brgr => new(z, x, y, x); + public readonly int4 brgg => new(z, x, y, y); + public readonly int4 brgb => new(z, x, y, z); + public readonly int4 brbr => new(z, x, z, x); + public readonly int4 brbg => new(z, x, z, y); + public readonly int4 brbb => new(z, x, z, z); + public readonly int4 bgrr => new(z, y, x, x); + public readonly int4 bgrg => new(z, y, x, y); + public readonly int4 bgrb => new(z, y, x, z); + public readonly int4 bggr => new(z, y, y, x); + public readonly int4 bggg => new(z, y, y, y); + public readonly int4 bggb => new(z, y, y, z); + public readonly int4 bgbr => new(z, y, z, x); + public readonly int4 bgbg => new(z, y, z, y); + public readonly int4 bgbb => new(z, y, z, z); + public readonly int4 bbrr => new(z, z, x, x); + public readonly int4 bbrg => new(z, z, x, y); + public readonly int4 bbrb => new(z, z, x, z); + public readonly int4 bbgr => new(z, z, y, x); + public readonly int4 bbgg => new(z, z, y, y); + public readonly int4 bbgb => new(z, z, y, z); + public readonly int4 bbbr => new(z, z, z, x); + public readonly int4 bbbg => new(z, z, z, y); + public readonly int4 bbbb => new(z, z, z, z); +} + +public partial struct int4 +{ + public int4(int x, int y, int2 zw) : this(x, y, zw.x, zw.y) { } + public int4(int x, int2 yz, int w) : this(x, yz.x, yz.y, w) { } + public int4(int x, int3 yzw) : this(x, yzw.x, yzw.y, yzw.z) { } + public int4(int2 xy, int z, int w) : this(xy.x, xy.y, z, w) { } + public int4(int2 xy, int2 zw) : this(xy.x, xy.y, zw.x, zw.y) { } + public int4(int3 xyz, int w) : this(xyz.x, xyz.y, xyz.z, w) { } + public int4(int4 xyzw) : this(xyzw.x, xyzw.y, xyzw.z, xyzw.w) { } + public int r { readonly get => x; set => x = value; } + public int g { readonly get => y; set => y = value; } + public int b { readonly get => z; set => z = value; } + public int a { readonly get => w; set => w = value; } + public readonly int2 xx => new(x, x); + public int2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public int2 xw { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public int2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 yy => new(y, y); + public int2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public int2 yw { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public int2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public int2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly int2 zz => new(z, z); + public int2 zw { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public int2 wx { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public int2 wy { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public int2 wz { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly int2 ww => new(w, w); + public readonly int3 xxx => new(x, x, x); + public readonly int3 xxy => new(x, x, y); + public readonly int3 xxz => new(x, x, z); + public readonly int3 xxw => new(x, x, w); + public readonly int3 xyx => new(x, y, x); + public readonly int3 xyy => new(x, y, y); + public int3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public int3 xyw { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly int3 xzx => new(x, z, x); + public int3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly int3 xzz => new(x, z, z); + public int3 xzw { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly int3 xwx => new(x, w, x); + public int3 xwy { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public int3 xwz { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly int3 xww => new(x, w, w); + public readonly int3 yxx => new(y, x, x); + public readonly int3 yxy => new(y, x, y); + public int3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public int3 yxw { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly int3 yyx => new(y, y, x); + public readonly int3 yyy => new(y, y, y); + public readonly int3 yyz => new(y, y, z); + public readonly int3 yyw => new(y, y, w); + public int3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly int3 yzy => new(y, z, y); + public readonly int3 yzz => new(y, z, z); + public int3 yzw { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public int3 ywx { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly int3 ywy => new(y, w, y); + public int3 ywz { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly int3 yww => new(y, w, w); + public readonly int3 zxx => new(z, x, x); + public int3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly int3 zxz => new(z, x, z); + public int3 zxw { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public int3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly int3 zyy => new(z, y, y); + public readonly int3 zyz => new(z, y, z); + public int3 zyw { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly int3 zzx => new(z, z, x); + public readonly int3 zzy => new(z, z, y); + public readonly int3 zzz => new(z, z, z); + public readonly int3 zzw => new(z, z, w); + public int3 zwx { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public int3 zwy { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly int3 zwz => new(z, w, z); + public readonly int3 zww => new(z, w, w); + public readonly int3 wxx => new(w, x, x); + public int3 wxy { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public int3 wxz { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly int3 wxw => new(w, x, w); + public int3 wyx { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly int3 wyy => new(w, y, y); + public int3 wyz { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly int3 wyw => new(w, y, w); + public int3 wzx { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public int3 wzy { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly int3 wzz => new(w, z, z); + public readonly int3 wzw => new(w, z, w); + public readonly int3 wwx => new(w, w, x); + public readonly int3 wwy => new(w, w, y); + public readonly int3 wwz => new(w, w, z); + public readonly int3 www => new(w, w, w); + public readonly int4 xxxx => new(x, x, x, x); + public readonly int4 xxxy => new(x, x, x, y); + public readonly int4 xxxz => new(x, x, x, z); + public readonly int4 xxxw => new(x, x, x, w); + public readonly int4 xxyx => new(x, x, y, x); + public readonly int4 xxyy => new(x, x, y, y); + public readonly int4 xxyz => new(x, x, y, z); + public readonly int4 xxyw => new(x, x, y, w); + public readonly int4 xxzx => new(x, x, z, x); + public readonly int4 xxzy => new(x, x, z, y); + public readonly int4 xxzz => new(x, x, z, z); + public readonly int4 xxzw => new(x, x, z, w); + public readonly int4 xxwx => new(x, x, w, x); + public readonly int4 xxwy => new(x, x, w, y); + public readonly int4 xxwz => new(x, x, w, z); + public readonly int4 xxww => new(x, x, w, w); + public readonly int4 xyxx => new(x, y, x, x); + public readonly int4 xyxy => new(x, y, x, y); + public readonly int4 xyxz => new(x, y, x, z); + public readonly int4 xyxw => new(x, y, x, w); + public readonly int4 xyyx => new(x, y, y, x); + public readonly int4 xyyy => new(x, y, y, y); + public readonly int4 xyyz => new(x, y, y, z); + public readonly int4 xyyw => new(x, y, y, w); + public readonly int4 xyzx => new(x, y, z, x); + public readonly int4 xyzy => new(x, y, z, y); + public readonly int4 xyzz => new(x, y, z, z); + public int4 xyzw { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly int4 xywx => new(x, y, w, x); + public readonly int4 xywy => new(x, y, w, y); + public int4 xywz { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly int4 xyww => new(x, y, w, w); + public readonly int4 xzxx => new(x, z, x, x); + public readonly int4 xzxy => new(x, z, x, y); + public readonly int4 xzxz => new(x, z, x, z); + public readonly int4 xzxw => new(x, z, x, w); + public readonly int4 xzyx => new(x, z, y, x); + public readonly int4 xzyy => new(x, z, y, y); + public readonly int4 xzyz => new(x, z, y, z); + public int4 xzyw { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly int4 xzzx => new(x, z, z, x); + public readonly int4 xzzy => new(x, z, z, y); + public readonly int4 xzzz => new(x, z, z, z); + public readonly int4 xzzw => new(x, z, z, w); + public readonly int4 xzwx => new(x, z, w, x); + public int4 xzwy { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly int4 xzwz => new(x, z, w, z); + public readonly int4 xzww => new(x, z, w, w); + public readonly int4 xwxx => new(x, w, x, x); + public readonly int4 xwxy => new(x, w, x, y); + public readonly int4 xwxz => new(x, w, x, z); + public readonly int4 xwxw => new(x, w, x, w); + public readonly int4 xwyx => new(x, w, y, x); + public readonly int4 xwyy => new(x, w, y, y); + public int4 xwyz { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly int4 xwyw => new(x, w, y, w); + public readonly int4 xwzx => new(x, w, z, x); + public int4 xwzy { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly int4 xwzz => new(x, w, z, z); + public readonly int4 xwzw => new(x, w, z, w); + public readonly int4 xwwx => new(x, w, w, x); + public readonly int4 xwwy => new(x, w, w, y); + public readonly int4 xwwz => new(x, w, w, z); + public readonly int4 xwww => new(x, w, w, w); + public readonly int4 yxxx => new(y, x, x, x); + public readonly int4 yxxy => new(y, x, x, y); + public readonly int4 yxxz => new(y, x, x, z); + public readonly int4 yxxw => new(y, x, x, w); + public readonly int4 yxyx => new(y, x, y, x); + public readonly int4 yxyy => new(y, x, y, y); + public readonly int4 yxyz => new(y, x, y, z); + public readonly int4 yxyw => new(y, x, y, w); + public readonly int4 yxzx => new(y, x, z, x); + public readonly int4 yxzy => new(y, x, z, y); + public readonly int4 yxzz => new(y, x, z, z); + public int4 yxzw { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly int4 yxwx => new(y, x, w, x); + public readonly int4 yxwy => new(y, x, w, y); + public int4 yxwz { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly int4 yxww => new(y, x, w, w); + public readonly int4 yyxx => new(y, y, x, x); + public readonly int4 yyxy => new(y, y, x, y); + public readonly int4 yyxz => new(y, y, x, z); + public readonly int4 yyxw => new(y, y, x, w); + public readonly int4 yyyx => new(y, y, y, x); + public readonly int4 yyyy => new(y, y, y, y); + public readonly int4 yyyz => new(y, y, y, z); + public readonly int4 yyyw => new(y, y, y, w); + public readonly int4 yyzx => new(y, y, z, x); + public readonly int4 yyzy => new(y, y, z, y); + public readonly int4 yyzz => new(y, y, z, z); + public readonly int4 yyzw => new(y, y, z, w); + public readonly int4 yywx => new(y, y, w, x); + public readonly int4 yywy => new(y, y, w, y); + public readonly int4 yywz => new(y, y, w, z); + public readonly int4 yyww => new(y, y, w, w); + public readonly int4 yzxx => new(y, z, x, x); + public readonly int4 yzxy => new(y, z, x, y); + public readonly int4 yzxz => new(y, z, x, z); + public int4 yzxw { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly int4 yzyx => new(y, z, y, x); + public readonly int4 yzyy => new(y, z, y, y); + public readonly int4 yzyz => new(y, z, y, z); + public readonly int4 yzyw => new(y, z, y, w); + public readonly int4 yzzx => new(y, z, z, x); + public readonly int4 yzzy => new(y, z, z, y); + public readonly int4 yzzz => new(y, z, z, z); + public readonly int4 yzzw => new(y, z, z, w); + public int4 yzwx { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly int4 yzwy => new(y, z, w, y); + public readonly int4 yzwz => new(y, z, w, z); + public readonly int4 yzww => new(y, z, w, w); + public readonly int4 ywxx => new(y, w, x, x); + public readonly int4 ywxy => new(y, w, x, y); + public int4 ywxz { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly int4 ywxw => new(y, w, x, w); + public readonly int4 ywyx => new(y, w, y, x); + public readonly int4 ywyy => new(y, w, y, y); + public readonly int4 ywyz => new(y, w, y, z); + public readonly int4 ywyw => new(y, w, y, w); + public int4 ywzx { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly int4 ywzy => new(y, w, z, y); + public readonly int4 ywzz => new(y, w, z, z); + public readonly int4 ywzw => new(y, w, z, w); + public readonly int4 ywwx => new(y, w, w, x); + public readonly int4 ywwy => new(y, w, w, y); + public readonly int4 ywwz => new(y, w, w, z); + public readonly int4 ywww => new(y, w, w, w); + public readonly int4 zxxx => new(z, x, x, x); + public readonly int4 zxxy => new(z, x, x, y); + public readonly int4 zxxz => new(z, x, x, z); + public readonly int4 zxxw => new(z, x, x, w); + public readonly int4 zxyx => new(z, x, y, x); + public readonly int4 zxyy => new(z, x, y, y); + public readonly int4 zxyz => new(z, x, y, z); + public int4 zxyw { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly int4 zxzx => new(z, x, z, x); + public readonly int4 zxzy => new(z, x, z, y); + public readonly int4 zxzz => new(z, x, z, z); + public readonly int4 zxzw => new(z, x, z, w); + public readonly int4 zxwx => new(z, x, w, x); + public int4 zxwy { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly int4 zxwz => new(z, x, w, z); + public readonly int4 zxww => new(z, x, w, w); + public readonly int4 zyxx => new(z, y, x, x); + public readonly int4 zyxy => new(z, y, x, y); + public readonly int4 zyxz => new(z, y, x, z); + public int4 zyxw { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly int4 zyyx => new(z, y, y, x); + public readonly int4 zyyy => new(z, y, y, y); + public readonly int4 zyyz => new(z, y, y, z); + public readonly int4 zyyw => new(z, y, y, w); + public readonly int4 zyzx => new(z, y, z, x); + public readonly int4 zyzy => new(z, y, z, y); + public readonly int4 zyzz => new(z, y, z, z); + public readonly int4 zyzw => new(z, y, z, w); + public int4 zywx { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly int4 zywy => new(z, y, w, y); + public readonly int4 zywz => new(z, y, w, z); + public readonly int4 zyww => new(z, y, w, w); + public readonly int4 zzxx => new(z, z, x, x); + public readonly int4 zzxy => new(z, z, x, y); + public readonly int4 zzxz => new(z, z, x, z); + public readonly int4 zzxw => new(z, z, x, w); + public readonly int4 zzyx => new(z, z, y, x); + public readonly int4 zzyy => new(z, z, y, y); + public readonly int4 zzyz => new(z, z, y, z); + public readonly int4 zzyw => new(z, z, y, w); + public readonly int4 zzzx => new(z, z, z, x); + public readonly int4 zzzy => new(z, z, z, y); + public readonly int4 zzzz => new(z, z, z, z); + public readonly int4 zzzw => new(z, z, z, w); + public readonly int4 zzwx => new(z, z, w, x); + public readonly int4 zzwy => new(z, z, w, y); + public readonly int4 zzwz => new(z, z, w, z); + public readonly int4 zzww => new(z, z, w, w); + public readonly int4 zwxx => new(z, w, x, x); + public int4 zwxy { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly int4 zwxz => new(z, w, x, z); + public readonly int4 zwxw => new(z, w, x, w); + public int4 zwyx { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly int4 zwyy => new(z, w, y, y); + public readonly int4 zwyz => new(z, w, y, z); + public readonly int4 zwyw => new(z, w, y, w); + public readonly int4 zwzx => new(z, w, z, x); + public readonly int4 zwzy => new(z, w, z, y); + public readonly int4 zwzz => new(z, w, z, z); + public readonly int4 zwzw => new(z, w, z, w); + public readonly int4 zwwx => new(z, w, w, x); + public readonly int4 zwwy => new(z, w, w, y); + public readonly int4 zwwz => new(z, w, w, z); + public readonly int4 zwww => new(z, w, w, w); + public readonly int4 wxxx => new(w, x, x, x); + public readonly int4 wxxy => new(w, x, x, y); + public readonly int4 wxxz => new(w, x, x, z); + public readonly int4 wxxw => new(w, x, x, w); + public readonly int4 wxyx => new(w, x, y, x); + public readonly int4 wxyy => new(w, x, y, y); + public int4 wxyz { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly int4 wxyw => new(w, x, y, w); + public readonly int4 wxzx => new(w, x, z, x); + public int4 wxzy { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly int4 wxzz => new(w, x, z, z); + public readonly int4 wxzw => new(w, x, z, w); + public readonly int4 wxwx => new(w, x, w, x); + public readonly int4 wxwy => new(w, x, w, y); + public readonly int4 wxwz => new(w, x, w, z); + public readonly int4 wxww => new(w, x, w, w); + public readonly int4 wyxx => new(w, y, x, x); + public readonly int4 wyxy => new(w, y, x, y); + public int4 wyxz { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly int4 wyxw => new(w, y, x, w); + public readonly int4 wyyx => new(w, y, y, x); + public readonly int4 wyyy => new(w, y, y, y); + public readonly int4 wyyz => new(w, y, y, z); + public readonly int4 wyyw => new(w, y, y, w); + public int4 wyzx { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly int4 wyzy => new(w, y, z, y); + public readonly int4 wyzz => new(w, y, z, z); + public readonly int4 wyzw => new(w, y, z, w); + public readonly int4 wywx => new(w, y, w, x); + public readonly int4 wywy => new(w, y, w, y); + public readonly int4 wywz => new(w, y, w, z); + public readonly int4 wyww => new(w, y, w, w); + public readonly int4 wzxx => new(w, z, x, x); + public int4 wzxy { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly int4 wzxz => new(w, z, x, z); + public readonly int4 wzxw => new(w, z, x, w); + public int4 wzyx { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly int4 wzyy => new(w, z, y, y); + public readonly int4 wzyz => new(w, z, y, z); + public readonly int4 wzyw => new(w, z, y, w); + public readonly int4 wzzx => new(w, z, z, x); + public readonly int4 wzzy => new(w, z, z, y); + public readonly int4 wzzz => new(w, z, z, z); + public readonly int4 wzzw => new(w, z, z, w); + public readonly int4 wzwx => new(w, z, w, x); + public readonly int4 wzwy => new(w, z, w, y); + public readonly int4 wzwz => new(w, z, w, z); + public readonly int4 wzww => new(w, z, w, w); + public readonly int4 wwxx => new(w, w, x, x); + public readonly int4 wwxy => new(w, w, x, y); + public readonly int4 wwxz => new(w, w, x, z); + public readonly int4 wwxw => new(w, w, x, w); + public readonly int4 wwyx => new(w, w, y, x); + public readonly int4 wwyy => new(w, w, y, y); + public readonly int4 wwyz => new(w, w, y, z); + public readonly int4 wwyw => new(w, w, y, w); + public readonly int4 wwzx => new(w, w, z, x); + public readonly int4 wwzy => new(w, w, z, y); + public readonly int4 wwzz => new(w, w, z, z); + public readonly int4 wwzw => new(w, w, z, w); + public readonly int4 wwwx => new(w, w, w, x); + public readonly int4 wwwy => new(w, w, w, y); + public readonly int4 wwwz => new(w, w, w, z); + public readonly int4 wwww => new(w, w, w, w); + public readonly int2 rr => new(x, x); + public int2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public int2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public int2 ra { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public int2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly int2 gg => new(y, y); + public int2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public int2 ga { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public int2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public int2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly int2 bb => new(z, z); + public int2 ba { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public int2 ar { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public int2 ag { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public int2 ab { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly int2 aa => new(w, w); + public readonly int3 rrr => new(x, x, x); + public readonly int3 rrg => new(x, x, y); + public readonly int3 rrb => new(x, x, z); + public readonly int3 rra => new(x, x, w); + public readonly int3 rgr => new(x, y, x); + public readonly int3 rgg => new(x, y, y); + public int3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public int3 rga { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly int3 rbr => new(x, z, x); + public int3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly int3 rbb => new(x, z, z); + public int3 rba { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly int3 rar => new(x, w, x); + public int3 rag { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public int3 rab { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly int3 raa => new(x, w, w); + public readonly int3 grr => new(y, x, x); + public readonly int3 grg => new(y, x, y); + public int3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public int3 gra { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly int3 ggr => new(y, y, x); + public readonly int3 ggg => new(y, y, y); + public readonly int3 ggb => new(y, y, z); + public readonly int3 gga => new(y, y, w); + public int3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly int3 gbg => new(y, z, y); + public readonly int3 gbb => new(y, z, z); + public int3 gba { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public int3 gar { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly int3 gag => new(y, w, y); + public int3 gab { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly int3 gaa => new(y, w, w); + public readonly int3 brr => new(z, x, x); + public int3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly int3 brb => new(z, x, z); + public int3 bra { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public int3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly int3 bgg => new(z, y, y); + public readonly int3 bgb => new(z, y, z); + public int3 bga { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly int3 bbr => new(z, z, x); + public readonly int3 bbg => new(z, z, y); + public readonly int3 bbb => new(z, z, z); + public readonly int3 bba => new(z, z, w); + public int3 bar { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public int3 bag { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly int3 bab => new(z, w, z); + public readonly int3 baa => new(z, w, w); + public readonly int3 arr => new(w, x, x); + public int3 arg { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public int3 arb { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly int3 ara => new(w, x, w); + public int3 agr { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly int3 agg => new(w, y, y); + public int3 agb { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly int3 aga => new(w, y, w); + public int3 abr { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public int3 abg { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly int3 abb => new(w, z, z); + public readonly int3 aba => new(w, z, w); + public readonly int3 aar => new(w, w, x); + public readonly int3 aag => new(w, w, y); + public readonly int3 aab => new(w, w, z); + public readonly int3 aaa => new(w, w, w); + public readonly int4 rrrr => new(x, x, x, x); + public readonly int4 rrrg => new(x, x, x, y); + public readonly int4 rrrb => new(x, x, x, z); + public readonly int4 rrra => new(x, x, x, w); + public readonly int4 rrgr => new(x, x, y, x); + public readonly int4 rrgg => new(x, x, y, y); + public readonly int4 rrgb => new(x, x, y, z); + public readonly int4 rrga => new(x, x, y, w); + public readonly int4 rrbr => new(x, x, z, x); + public readonly int4 rrbg => new(x, x, z, y); + public readonly int4 rrbb => new(x, x, z, z); + public readonly int4 rrba => new(x, x, z, w); + public readonly int4 rrar => new(x, x, w, x); + public readonly int4 rrag => new(x, x, w, y); + public readonly int4 rrab => new(x, x, w, z); + public readonly int4 rraa => new(x, x, w, w); + public readonly int4 rgrr => new(x, y, x, x); + public readonly int4 rgrg => new(x, y, x, y); + public readonly int4 rgrb => new(x, y, x, z); + public readonly int4 rgra => new(x, y, x, w); + public readonly int4 rggr => new(x, y, y, x); + public readonly int4 rggg => new(x, y, y, y); + public readonly int4 rggb => new(x, y, y, z); + public readonly int4 rgga => new(x, y, y, w); + public readonly int4 rgbr => new(x, y, z, x); + public readonly int4 rgbg => new(x, y, z, y); + public readonly int4 rgbb => new(x, y, z, z); + public int4 rgba { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly int4 rgar => new(x, y, w, x); + public readonly int4 rgag => new(x, y, w, y); + public int4 rgab { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly int4 rgaa => new(x, y, w, w); + public readonly int4 rbrr => new(x, z, x, x); + public readonly int4 rbrg => new(x, z, x, y); + public readonly int4 rbrb => new(x, z, x, z); + public readonly int4 rbra => new(x, z, x, w); + public readonly int4 rbgr => new(x, z, y, x); + public readonly int4 rbgg => new(x, z, y, y); + public readonly int4 rbgb => new(x, z, y, z); + public int4 rbga { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly int4 rbbr => new(x, z, z, x); + public readonly int4 rbbg => new(x, z, z, y); + public readonly int4 rbbb => new(x, z, z, z); + public readonly int4 rbba => new(x, z, z, w); + public readonly int4 rbar => new(x, z, w, x); + public int4 rbag { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly int4 rbab => new(x, z, w, z); + public readonly int4 rbaa => new(x, z, w, w); + public readonly int4 rarr => new(x, w, x, x); + public readonly int4 rarg => new(x, w, x, y); + public readonly int4 rarb => new(x, w, x, z); + public readonly int4 rara => new(x, w, x, w); + public readonly int4 ragr => new(x, w, y, x); + public readonly int4 ragg => new(x, w, y, y); + public int4 ragb { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly int4 raga => new(x, w, y, w); + public readonly int4 rabr => new(x, w, z, x); + public int4 rabg { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly int4 rabb => new(x, w, z, z); + public readonly int4 raba => new(x, w, z, w); + public readonly int4 raar => new(x, w, w, x); + public readonly int4 raag => new(x, w, w, y); + public readonly int4 raab => new(x, w, w, z); + public readonly int4 raaa => new(x, w, w, w); + public readonly int4 grrr => new(y, x, x, x); + public readonly int4 grrg => new(y, x, x, y); + public readonly int4 grrb => new(y, x, x, z); + public readonly int4 grra => new(y, x, x, w); + public readonly int4 grgr => new(y, x, y, x); + public readonly int4 grgg => new(y, x, y, y); + public readonly int4 grgb => new(y, x, y, z); + public readonly int4 grga => new(y, x, y, w); + public readonly int4 grbr => new(y, x, z, x); + public readonly int4 grbg => new(y, x, z, y); + public readonly int4 grbb => new(y, x, z, z); + public int4 grba { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly int4 grar => new(y, x, w, x); + public readonly int4 grag => new(y, x, w, y); + public int4 grab { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly int4 graa => new(y, x, w, w); + public readonly int4 ggrr => new(y, y, x, x); + public readonly int4 ggrg => new(y, y, x, y); + public readonly int4 ggrb => new(y, y, x, z); + public readonly int4 ggra => new(y, y, x, w); + public readonly int4 gggr => new(y, y, y, x); + public readonly int4 gggg => new(y, y, y, y); + public readonly int4 gggb => new(y, y, y, z); + public readonly int4 ggga => new(y, y, y, w); + public readonly int4 ggbr => new(y, y, z, x); + public readonly int4 ggbg => new(y, y, z, y); + public readonly int4 ggbb => new(y, y, z, z); + public readonly int4 ggba => new(y, y, z, w); + public readonly int4 ggar => new(y, y, w, x); + public readonly int4 ggag => new(y, y, w, y); + public readonly int4 ggab => new(y, y, w, z); + public readonly int4 ggaa => new(y, y, w, w); + public readonly int4 gbrr => new(y, z, x, x); + public readonly int4 gbrg => new(y, z, x, y); + public readonly int4 gbrb => new(y, z, x, z); + public int4 gbra { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly int4 gbgr => new(y, z, y, x); + public readonly int4 gbgg => new(y, z, y, y); + public readonly int4 gbgb => new(y, z, y, z); + public readonly int4 gbga => new(y, z, y, w); + public readonly int4 gbbr => new(y, z, z, x); + public readonly int4 gbbg => new(y, z, z, y); + public readonly int4 gbbb => new(y, z, z, z); + public readonly int4 gbba => new(y, z, z, w); + public int4 gbar { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly int4 gbag => new(y, z, w, y); + public readonly int4 gbab => new(y, z, w, z); + public readonly int4 gbaa => new(y, z, w, w); + public readonly int4 garr => new(y, w, x, x); + public readonly int4 garg => new(y, w, x, y); + public int4 garb { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly int4 gara => new(y, w, x, w); + public readonly int4 gagr => new(y, w, y, x); + public readonly int4 gagg => new(y, w, y, y); + public readonly int4 gagb => new(y, w, y, z); + public readonly int4 gaga => new(y, w, y, w); + public int4 gabr { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly int4 gabg => new(y, w, z, y); + public readonly int4 gabb => new(y, w, z, z); + public readonly int4 gaba => new(y, w, z, w); + public readonly int4 gaar => new(y, w, w, x); + public readonly int4 gaag => new(y, w, w, y); + public readonly int4 gaab => new(y, w, w, z); + public readonly int4 gaaa => new(y, w, w, w); + public readonly int4 brrr => new(z, x, x, x); + public readonly int4 brrg => new(z, x, x, y); + public readonly int4 brrb => new(z, x, x, z); + public readonly int4 brra => new(z, x, x, w); + public readonly int4 brgr => new(z, x, y, x); + public readonly int4 brgg => new(z, x, y, y); + public readonly int4 brgb => new(z, x, y, z); + public int4 brga { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly int4 brbr => new(z, x, z, x); + public readonly int4 brbg => new(z, x, z, y); + public readonly int4 brbb => new(z, x, z, z); + public readonly int4 brba => new(z, x, z, w); + public readonly int4 brar => new(z, x, w, x); + public int4 brag { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly int4 brab => new(z, x, w, z); + public readonly int4 braa => new(z, x, w, w); + public readonly int4 bgrr => new(z, y, x, x); + public readonly int4 bgrg => new(z, y, x, y); + public readonly int4 bgrb => new(z, y, x, z); + public int4 bgra { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly int4 bggr => new(z, y, y, x); + public readonly int4 bggg => new(z, y, y, y); + public readonly int4 bggb => new(z, y, y, z); + public readonly int4 bgga => new(z, y, y, w); + public readonly int4 bgbr => new(z, y, z, x); + public readonly int4 bgbg => new(z, y, z, y); + public readonly int4 bgbb => new(z, y, z, z); + public readonly int4 bgba => new(z, y, z, w); + public int4 bgar { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly int4 bgag => new(z, y, w, y); + public readonly int4 bgab => new(z, y, w, z); + public readonly int4 bgaa => new(z, y, w, w); + public readonly int4 bbrr => new(z, z, x, x); + public readonly int4 bbrg => new(z, z, x, y); + public readonly int4 bbrb => new(z, z, x, z); + public readonly int4 bbra => new(z, z, x, w); + public readonly int4 bbgr => new(z, z, y, x); + public readonly int4 bbgg => new(z, z, y, y); + public readonly int4 bbgb => new(z, z, y, z); + public readonly int4 bbga => new(z, z, y, w); + public readonly int4 bbbr => new(z, z, z, x); + public readonly int4 bbbg => new(z, z, z, y); + public readonly int4 bbbb => new(z, z, z, z); + public readonly int4 bbba => new(z, z, z, w); + public readonly int4 bbar => new(z, z, w, x); + public readonly int4 bbag => new(z, z, w, y); + public readonly int4 bbab => new(z, z, w, z); + public readonly int4 bbaa => new(z, z, w, w); + public readonly int4 barr => new(z, w, x, x); + public int4 barg { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly int4 barb => new(z, w, x, z); + public readonly int4 bara => new(z, w, x, w); + public int4 bagr { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly int4 bagg => new(z, w, y, y); + public readonly int4 bagb => new(z, w, y, z); + public readonly int4 baga => new(z, w, y, w); + public readonly int4 babr => new(z, w, z, x); + public readonly int4 babg => new(z, w, z, y); + public readonly int4 babb => new(z, w, z, z); + public readonly int4 baba => new(z, w, z, w); + public readonly int4 baar => new(z, w, w, x); + public readonly int4 baag => new(z, w, w, y); + public readonly int4 baab => new(z, w, w, z); + public readonly int4 baaa => new(z, w, w, w); + public readonly int4 arrr => new(w, x, x, x); + public readonly int4 arrg => new(w, x, x, y); + public readonly int4 arrb => new(w, x, x, z); + public readonly int4 arra => new(w, x, x, w); + public readonly int4 argr => new(w, x, y, x); + public readonly int4 argg => new(w, x, y, y); + public int4 argb { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly int4 arga => new(w, x, y, w); + public readonly int4 arbr => new(w, x, z, x); + public int4 arbg { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly int4 arbb => new(w, x, z, z); + public readonly int4 arba => new(w, x, z, w); + public readonly int4 arar => new(w, x, w, x); + public readonly int4 arag => new(w, x, w, y); + public readonly int4 arab => new(w, x, w, z); + public readonly int4 araa => new(w, x, w, w); + public readonly int4 agrr => new(w, y, x, x); + public readonly int4 agrg => new(w, y, x, y); + public int4 agrb { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly int4 agra => new(w, y, x, w); + public readonly int4 aggr => new(w, y, y, x); + public readonly int4 aggg => new(w, y, y, y); + public readonly int4 aggb => new(w, y, y, z); + public readonly int4 agga => new(w, y, y, w); + public int4 agbr { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly int4 agbg => new(w, y, z, y); + public readonly int4 agbb => new(w, y, z, z); + public readonly int4 agba => new(w, y, z, w); + public readonly int4 agar => new(w, y, w, x); + public readonly int4 agag => new(w, y, w, y); + public readonly int4 agab => new(w, y, w, z); + public readonly int4 agaa => new(w, y, w, w); + public readonly int4 abrr => new(w, z, x, x); + public int4 abrg { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly int4 abrb => new(w, z, x, z); + public readonly int4 abra => new(w, z, x, w); + public int4 abgr { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly int4 abgg => new(w, z, y, y); + public readonly int4 abgb => new(w, z, y, z); + public readonly int4 abga => new(w, z, y, w); + public readonly int4 abbr => new(w, z, z, x); + public readonly int4 abbg => new(w, z, z, y); + public readonly int4 abbb => new(w, z, z, z); + public readonly int4 abba => new(w, z, z, w); + public readonly int4 abar => new(w, z, w, x); + public readonly int4 abag => new(w, z, w, y); + public readonly int4 abab => new(w, z, w, z); + public readonly int4 abaa => new(w, z, w, w); + public readonly int4 aarr => new(w, w, x, x); + public readonly int4 aarg => new(w, w, x, y); + public readonly int4 aarb => new(w, w, x, z); + public readonly int4 aara => new(w, w, x, w); + public readonly int4 aagr => new(w, w, y, x); + public readonly int4 aagg => new(w, w, y, y); + public readonly int4 aagb => new(w, w, y, z); + public readonly int4 aaga => new(w, w, y, w); + public readonly int4 aabr => new(w, w, z, x); + public readonly int4 aabg => new(w, w, z, y); + public readonly int4 aabb => new(w, w, z, z); + public readonly int4 aaba => new(w, w, z, w); + public readonly int4 aaar => new(w, w, w, x); + public readonly int4 aaag => new(w, w, w, y); + public readonly int4 aaab => new(w, w, w, z); + public readonly int4 aaaa => new(w, w, w, w); +} + +public partial struct bool2 +{ + public bool2(bool2 xy) : this(xy.x, xy.y) { } + public bool r { readonly get => x; set => x = value; } + public bool g { readonly get => y; set => y = value; } + public readonly bool2 xx => new(x, x); + public bool2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 yy => new(y, y); + public readonly bool3 xxx => new(x, x, x); + public readonly bool3 xxy => new(x, x, y); + public readonly bool3 xyx => new(x, y, x); + public readonly bool3 xyy => new(x, y, y); + public readonly bool3 yxx => new(y, x, x); + public readonly bool3 yxy => new(y, x, y); + public readonly bool3 yyx => new(y, y, x); + public readonly bool3 yyy => new(y, y, y); + public readonly bool4 xxxx => new(x, x, x, x); + public readonly bool4 xxxy => new(x, x, x, y); + public readonly bool4 xxyx => new(x, x, y, x); + public readonly bool4 xxyy => new(x, x, y, y); + public readonly bool4 xyxx => new(x, y, x, x); + public readonly bool4 xyxy => new(x, y, x, y); + public readonly bool4 xyyx => new(x, y, y, x); + public readonly bool4 xyyy => new(x, y, y, y); + public readonly bool4 yxxx => new(y, x, x, x); + public readonly bool4 yxxy => new(y, x, x, y); + public readonly bool4 yxyx => new(y, x, y, x); + public readonly bool4 yxyy => new(y, x, y, y); + public readonly bool4 yyxx => new(y, y, x, x); + public readonly bool4 yyxy => new(y, y, x, y); + public readonly bool4 yyyx => new(y, y, y, x); + public readonly bool4 yyyy => new(y, y, y, y); + public readonly bool2 rr => new(x, x); + public bool2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 gg => new(y, y); + public readonly bool3 rrr => new(x, x, x); + public readonly bool3 rrg => new(x, x, y); + public readonly bool3 rgr => new(x, y, x); + public readonly bool3 rgg => new(x, y, y); + public readonly bool3 grr => new(y, x, x); + public readonly bool3 grg => new(y, x, y); + public readonly bool3 ggr => new(y, y, x); + public readonly bool3 ggg => new(y, y, y); + public readonly bool4 rrrr => new(x, x, x, x); + public readonly bool4 rrrg => new(x, x, x, y); + public readonly bool4 rrgr => new(x, x, y, x); + public readonly bool4 rrgg => new(x, x, y, y); + public readonly bool4 rgrr => new(x, y, x, x); + public readonly bool4 rgrg => new(x, y, x, y); + public readonly bool4 rggr => new(x, y, y, x); + public readonly bool4 rggg => new(x, y, y, y); + public readonly bool4 grrr => new(y, x, x, x); + public readonly bool4 grrg => new(y, x, x, y); + public readonly bool4 grgr => new(y, x, y, x); + public readonly bool4 grgg => new(y, x, y, y); + public readonly bool4 ggrr => new(y, y, x, x); + public readonly bool4 ggrg => new(y, y, x, y); + public readonly bool4 gggr => new(y, y, y, x); + public readonly bool4 gggg => new(y, y, y, y); +} + +public partial struct bool3 +{ + public bool3(bool x, bool2 yz) : this(x, yz.x, yz.y) { } + public bool3(bool2 xy, bool z) : this(xy.x, xy.y, z) { } + public bool3(bool3 xyz) : this(xyz.x, xyz.y, xyz.z) { } + public bool r { readonly get => x; set => x = value; } + public bool g { readonly get => y; set => y = value; } + public bool b { readonly get => z; set => z = value; } + public readonly bool2 xx => new(x, x); + public bool2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public bool2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 yy => new(y, y); + public bool2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public bool2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public bool2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly bool2 zz => new(z, z); + public readonly bool3 xxx => new(x, x, x); + public readonly bool3 xxy => new(x, x, y); + public readonly bool3 xxz => new(x, x, z); + public readonly bool3 xyx => new(x, y, x); + public readonly bool3 xyy => new(x, y, y); + public bool3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly bool3 xzx => new(x, z, x); + public bool3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly bool3 xzz => new(x, z, z); + public readonly bool3 yxx => new(y, x, x); + public readonly bool3 yxy => new(y, x, y); + public bool3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly bool3 yyx => new(y, y, x); + public readonly bool3 yyy => new(y, y, y); + public readonly bool3 yyz => new(y, y, z); + public bool3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly bool3 yzy => new(y, z, y); + public readonly bool3 yzz => new(y, z, z); + public readonly bool3 zxx => new(z, x, x); + public bool3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly bool3 zxz => new(z, x, z); + public bool3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly bool3 zyy => new(z, y, y); + public readonly bool3 zyz => new(z, y, z); + public readonly bool3 zzx => new(z, z, x); + public readonly bool3 zzy => new(z, z, y); + public readonly bool3 zzz => new(z, z, z); + public readonly bool4 xxxx => new(x, x, x, x); + public readonly bool4 xxxy => new(x, x, x, y); + public readonly bool4 xxxz => new(x, x, x, z); + public readonly bool4 xxyx => new(x, x, y, x); + public readonly bool4 xxyy => new(x, x, y, y); + public readonly bool4 xxyz => new(x, x, y, z); + public readonly bool4 xxzx => new(x, x, z, x); + public readonly bool4 xxzy => new(x, x, z, y); + public readonly bool4 xxzz => new(x, x, z, z); + public readonly bool4 xyxx => new(x, y, x, x); + public readonly bool4 xyxy => new(x, y, x, y); + public readonly bool4 xyxz => new(x, y, x, z); + public readonly bool4 xyyx => new(x, y, y, x); + public readonly bool4 xyyy => new(x, y, y, y); + public readonly bool4 xyyz => new(x, y, y, z); + public readonly bool4 xyzx => new(x, y, z, x); + public readonly bool4 xyzy => new(x, y, z, y); + public readonly bool4 xyzz => new(x, y, z, z); + public readonly bool4 xzxx => new(x, z, x, x); + public readonly bool4 xzxy => new(x, z, x, y); + public readonly bool4 xzxz => new(x, z, x, z); + public readonly bool4 xzyx => new(x, z, y, x); + public readonly bool4 xzyy => new(x, z, y, y); + public readonly bool4 xzyz => new(x, z, y, z); + public readonly bool4 xzzx => new(x, z, z, x); + public readonly bool4 xzzy => new(x, z, z, y); + public readonly bool4 xzzz => new(x, z, z, z); + public readonly bool4 yxxx => new(y, x, x, x); + public readonly bool4 yxxy => new(y, x, x, y); + public readonly bool4 yxxz => new(y, x, x, z); + public readonly bool4 yxyx => new(y, x, y, x); + public readonly bool4 yxyy => new(y, x, y, y); + public readonly bool4 yxyz => new(y, x, y, z); + public readonly bool4 yxzx => new(y, x, z, x); + public readonly bool4 yxzy => new(y, x, z, y); + public readonly bool4 yxzz => new(y, x, z, z); + public readonly bool4 yyxx => new(y, y, x, x); + public readonly bool4 yyxy => new(y, y, x, y); + public readonly bool4 yyxz => new(y, y, x, z); + public readonly bool4 yyyx => new(y, y, y, x); + public readonly bool4 yyyy => new(y, y, y, y); + public readonly bool4 yyyz => new(y, y, y, z); + public readonly bool4 yyzx => new(y, y, z, x); + public readonly bool4 yyzy => new(y, y, z, y); + public readonly bool4 yyzz => new(y, y, z, z); + public readonly bool4 yzxx => new(y, z, x, x); + public readonly bool4 yzxy => new(y, z, x, y); + public readonly bool4 yzxz => new(y, z, x, z); + public readonly bool4 yzyx => new(y, z, y, x); + public readonly bool4 yzyy => new(y, z, y, y); + public readonly bool4 yzyz => new(y, z, y, z); + public readonly bool4 yzzx => new(y, z, z, x); + public readonly bool4 yzzy => new(y, z, z, y); + public readonly bool4 yzzz => new(y, z, z, z); + public readonly bool4 zxxx => new(z, x, x, x); + public readonly bool4 zxxy => new(z, x, x, y); + public readonly bool4 zxxz => new(z, x, x, z); + public readonly bool4 zxyx => new(z, x, y, x); + public readonly bool4 zxyy => new(z, x, y, y); + public readonly bool4 zxyz => new(z, x, y, z); + public readonly bool4 zxzx => new(z, x, z, x); + public readonly bool4 zxzy => new(z, x, z, y); + public readonly bool4 zxzz => new(z, x, z, z); + public readonly bool4 zyxx => new(z, y, x, x); + public readonly bool4 zyxy => new(z, y, x, y); + public readonly bool4 zyxz => new(z, y, x, z); + public readonly bool4 zyyx => new(z, y, y, x); + public readonly bool4 zyyy => new(z, y, y, y); + public readonly bool4 zyyz => new(z, y, y, z); + public readonly bool4 zyzx => new(z, y, z, x); + public readonly bool4 zyzy => new(z, y, z, y); + public readonly bool4 zyzz => new(z, y, z, z); + public readonly bool4 zzxx => new(z, z, x, x); + public readonly bool4 zzxy => new(z, z, x, y); + public readonly bool4 zzxz => new(z, z, x, z); + public readonly bool4 zzyx => new(z, z, y, x); + public readonly bool4 zzyy => new(z, z, y, y); + public readonly bool4 zzyz => new(z, z, y, z); + public readonly bool4 zzzx => new(z, z, z, x); + public readonly bool4 zzzy => new(z, z, z, y); + public readonly bool4 zzzz => new(z, z, z, z); + public readonly bool2 rr => new(x, x); + public bool2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public bool2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 gg => new(y, y); + public bool2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public bool2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public bool2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly bool2 bb => new(z, z); + public readonly bool3 rrr => new(x, x, x); + public readonly bool3 rrg => new(x, x, y); + public readonly bool3 rrb => new(x, x, z); + public readonly bool3 rgr => new(x, y, x); + public readonly bool3 rgg => new(x, y, y); + public bool3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly bool3 rbr => new(x, z, x); + public bool3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly bool3 rbb => new(x, z, z); + public readonly bool3 grr => new(y, x, x); + public readonly bool3 grg => new(y, x, y); + public bool3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly bool3 ggr => new(y, y, x); + public readonly bool3 ggg => new(y, y, y); + public readonly bool3 ggb => new(y, y, z); + public bool3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly bool3 gbg => new(y, z, y); + public readonly bool3 gbb => new(y, z, z); + public readonly bool3 brr => new(z, x, x); + public bool3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly bool3 brb => new(z, x, z); + public bool3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly bool3 bgg => new(z, y, y); + public readonly bool3 bgb => new(z, y, z); + public readonly bool3 bbr => new(z, z, x); + public readonly bool3 bbg => new(z, z, y); + public readonly bool3 bbb => new(z, z, z); + public readonly bool4 rrrr => new(x, x, x, x); + public readonly bool4 rrrg => new(x, x, x, y); + public readonly bool4 rrrb => new(x, x, x, z); + public readonly bool4 rrgr => new(x, x, y, x); + public readonly bool4 rrgg => new(x, x, y, y); + public readonly bool4 rrgb => new(x, x, y, z); + public readonly bool4 rrbr => new(x, x, z, x); + public readonly bool4 rrbg => new(x, x, z, y); + public readonly bool4 rrbb => new(x, x, z, z); + public readonly bool4 rgrr => new(x, y, x, x); + public readonly bool4 rgrg => new(x, y, x, y); + public readonly bool4 rgrb => new(x, y, x, z); + public readonly bool4 rggr => new(x, y, y, x); + public readonly bool4 rggg => new(x, y, y, y); + public readonly bool4 rggb => new(x, y, y, z); + public readonly bool4 rgbr => new(x, y, z, x); + public readonly bool4 rgbg => new(x, y, z, y); + public readonly bool4 rgbb => new(x, y, z, z); + public readonly bool4 rbrr => new(x, z, x, x); + public readonly bool4 rbrg => new(x, z, x, y); + public readonly bool4 rbrb => new(x, z, x, z); + public readonly bool4 rbgr => new(x, z, y, x); + public readonly bool4 rbgg => new(x, z, y, y); + public readonly bool4 rbgb => new(x, z, y, z); + public readonly bool4 rbbr => new(x, z, z, x); + public readonly bool4 rbbg => new(x, z, z, y); + public readonly bool4 rbbb => new(x, z, z, z); + public readonly bool4 grrr => new(y, x, x, x); + public readonly bool4 grrg => new(y, x, x, y); + public readonly bool4 grrb => new(y, x, x, z); + public readonly bool4 grgr => new(y, x, y, x); + public readonly bool4 grgg => new(y, x, y, y); + public readonly bool4 grgb => new(y, x, y, z); + public readonly bool4 grbr => new(y, x, z, x); + public readonly bool4 grbg => new(y, x, z, y); + public readonly bool4 grbb => new(y, x, z, z); + public readonly bool4 ggrr => new(y, y, x, x); + public readonly bool4 ggrg => new(y, y, x, y); + public readonly bool4 ggrb => new(y, y, x, z); + public readonly bool4 gggr => new(y, y, y, x); + public readonly bool4 gggg => new(y, y, y, y); + public readonly bool4 gggb => new(y, y, y, z); + public readonly bool4 ggbr => new(y, y, z, x); + public readonly bool4 ggbg => new(y, y, z, y); + public readonly bool4 ggbb => new(y, y, z, z); + public readonly bool4 gbrr => new(y, z, x, x); + public readonly bool4 gbrg => new(y, z, x, y); + public readonly bool4 gbrb => new(y, z, x, z); + public readonly bool4 gbgr => new(y, z, y, x); + public readonly bool4 gbgg => new(y, z, y, y); + public readonly bool4 gbgb => new(y, z, y, z); + public readonly bool4 gbbr => new(y, z, z, x); + public readonly bool4 gbbg => new(y, z, z, y); + public readonly bool4 gbbb => new(y, z, z, z); + public readonly bool4 brrr => new(z, x, x, x); + public readonly bool4 brrg => new(z, x, x, y); + public readonly bool4 brrb => new(z, x, x, z); + public readonly bool4 brgr => new(z, x, y, x); + public readonly bool4 brgg => new(z, x, y, y); + public readonly bool4 brgb => new(z, x, y, z); + public readonly bool4 brbr => new(z, x, z, x); + public readonly bool4 brbg => new(z, x, z, y); + public readonly bool4 brbb => new(z, x, z, z); + public readonly bool4 bgrr => new(z, y, x, x); + public readonly bool4 bgrg => new(z, y, x, y); + public readonly bool4 bgrb => new(z, y, x, z); + public readonly bool4 bggr => new(z, y, y, x); + public readonly bool4 bggg => new(z, y, y, y); + public readonly bool4 bggb => new(z, y, y, z); + public readonly bool4 bgbr => new(z, y, z, x); + public readonly bool4 bgbg => new(z, y, z, y); + public readonly bool4 bgbb => new(z, y, z, z); + public readonly bool4 bbrr => new(z, z, x, x); + public readonly bool4 bbrg => new(z, z, x, y); + public readonly bool4 bbrb => new(z, z, x, z); + public readonly bool4 bbgr => new(z, z, y, x); + public readonly bool4 bbgg => new(z, z, y, y); + public readonly bool4 bbgb => new(z, z, y, z); + public readonly bool4 bbbr => new(z, z, z, x); + public readonly bool4 bbbg => new(z, z, z, y); + public readonly bool4 bbbb => new(z, z, z, z); +} + +public partial struct bool4 +{ + public bool4(bool x, bool y, bool2 zw) : this(x, y, zw.x, zw.y) { } + public bool4(bool x, bool2 yz, bool w) : this(x, yz.x, yz.y, w) { } + public bool4(bool x, bool3 yzw) : this(x, yzw.x, yzw.y, yzw.z) { } + public bool4(bool2 xy, bool z, bool w) : this(xy.x, xy.y, z, w) { } + public bool4(bool2 xy, bool2 zw) : this(xy.x, xy.y, zw.x, zw.y) { } + public bool4(bool3 xyz, bool w) : this(xyz.x, xyz.y, xyz.z, w) { } + public bool4(bool4 xyzw) : this(xyzw.x, xyzw.y, xyzw.z, xyzw.w) { } + public bool r { readonly get => x; set => x = value; } + public bool g { readonly get => y; set => y = value; } + public bool b { readonly get => z; set => z = value; } + public bool a { readonly get => w; set => w = value; } + public readonly bool2 xx => new(x, x); + public bool2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public bool2 xw { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public bool2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 yy => new(y, y); + public bool2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public bool2 yw { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public bool2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public bool2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly bool2 zz => new(z, z); + public bool2 zw { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public bool2 wx { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public bool2 wy { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public bool2 wz { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly bool2 ww => new(w, w); + public readonly bool3 xxx => new(x, x, x); + public readonly bool3 xxy => new(x, x, y); + public readonly bool3 xxz => new(x, x, z); + public readonly bool3 xxw => new(x, x, w); + public readonly bool3 xyx => new(x, y, x); + public readonly bool3 xyy => new(x, y, y); + public bool3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public bool3 xyw { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly bool3 xzx => new(x, z, x); + public bool3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly bool3 xzz => new(x, z, z); + public bool3 xzw { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly bool3 xwx => new(x, w, x); + public bool3 xwy { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public bool3 xwz { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly bool3 xww => new(x, w, w); + public readonly bool3 yxx => new(y, x, x); + public readonly bool3 yxy => new(y, x, y); + public bool3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public bool3 yxw { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly bool3 yyx => new(y, y, x); + public readonly bool3 yyy => new(y, y, y); + public readonly bool3 yyz => new(y, y, z); + public readonly bool3 yyw => new(y, y, w); + public bool3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly bool3 yzy => new(y, z, y); + public readonly bool3 yzz => new(y, z, z); + public bool3 yzw { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public bool3 ywx { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly bool3 ywy => new(y, w, y); + public bool3 ywz { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly bool3 yww => new(y, w, w); + public readonly bool3 zxx => new(z, x, x); + public bool3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly bool3 zxz => new(z, x, z); + public bool3 zxw { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public bool3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly bool3 zyy => new(z, y, y); + public readonly bool3 zyz => new(z, y, z); + public bool3 zyw { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly bool3 zzx => new(z, z, x); + public readonly bool3 zzy => new(z, z, y); + public readonly bool3 zzz => new(z, z, z); + public readonly bool3 zzw => new(z, z, w); + public bool3 zwx { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public bool3 zwy { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly bool3 zwz => new(z, w, z); + public readonly bool3 zww => new(z, w, w); + public readonly bool3 wxx => new(w, x, x); + public bool3 wxy { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public bool3 wxz { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly bool3 wxw => new(w, x, w); + public bool3 wyx { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly bool3 wyy => new(w, y, y); + public bool3 wyz { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly bool3 wyw => new(w, y, w); + public bool3 wzx { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public bool3 wzy { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly bool3 wzz => new(w, z, z); + public readonly bool3 wzw => new(w, z, w); + public readonly bool3 wwx => new(w, w, x); + public readonly bool3 wwy => new(w, w, y); + public readonly bool3 wwz => new(w, w, z); + public readonly bool3 www => new(w, w, w); + public readonly bool4 xxxx => new(x, x, x, x); + public readonly bool4 xxxy => new(x, x, x, y); + public readonly bool4 xxxz => new(x, x, x, z); + public readonly bool4 xxxw => new(x, x, x, w); + public readonly bool4 xxyx => new(x, x, y, x); + public readonly bool4 xxyy => new(x, x, y, y); + public readonly bool4 xxyz => new(x, x, y, z); + public readonly bool4 xxyw => new(x, x, y, w); + public readonly bool4 xxzx => new(x, x, z, x); + public readonly bool4 xxzy => new(x, x, z, y); + public readonly bool4 xxzz => new(x, x, z, z); + public readonly bool4 xxzw => new(x, x, z, w); + public readonly bool4 xxwx => new(x, x, w, x); + public readonly bool4 xxwy => new(x, x, w, y); + public readonly bool4 xxwz => new(x, x, w, z); + public readonly bool4 xxww => new(x, x, w, w); + public readonly bool4 xyxx => new(x, y, x, x); + public readonly bool4 xyxy => new(x, y, x, y); + public readonly bool4 xyxz => new(x, y, x, z); + public readonly bool4 xyxw => new(x, y, x, w); + public readonly bool4 xyyx => new(x, y, y, x); + public readonly bool4 xyyy => new(x, y, y, y); + public readonly bool4 xyyz => new(x, y, y, z); + public readonly bool4 xyyw => new(x, y, y, w); + public readonly bool4 xyzx => new(x, y, z, x); + public readonly bool4 xyzy => new(x, y, z, y); + public readonly bool4 xyzz => new(x, y, z, z); + public bool4 xyzw { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly bool4 xywx => new(x, y, w, x); + public readonly bool4 xywy => new(x, y, w, y); + public bool4 xywz { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly bool4 xyww => new(x, y, w, w); + public readonly bool4 xzxx => new(x, z, x, x); + public readonly bool4 xzxy => new(x, z, x, y); + public readonly bool4 xzxz => new(x, z, x, z); + public readonly bool4 xzxw => new(x, z, x, w); + public readonly bool4 xzyx => new(x, z, y, x); + public readonly bool4 xzyy => new(x, z, y, y); + public readonly bool4 xzyz => new(x, z, y, z); + public bool4 xzyw { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly bool4 xzzx => new(x, z, z, x); + public readonly bool4 xzzy => new(x, z, z, y); + public readonly bool4 xzzz => new(x, z, z, z); + public readonly bool4 xzzw => new(x, z, z, w); + public readonly bool4 xzwx => new(x, z, w, x); + public bool4 xzwy { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly bool4 xzwz => new(x, z, w, z); + public readonly bool4 xzww => new(x, z, w, w); + public readonly bool4 xwxx => new(x, w, x, x); + public readonly bool4 xwxy => new(x, w, x, y); + public readonly bool4 xwxz => new(x, w, x, z); + public readonly bool4 xwxw => new(x, w, x, w); + public readonly bool4 xwyx => new(x, w, y, x); + public readonly bool4 xwyy => new(x, w, y, y); + public bool4 xwyz { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly bool4 xwyw => new(x, w, y, w); + public readonly bool4 xwzx => new(x, w, z, x); + public bool4 xwzy { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly bool4 xwzz => new(x, w, z, z); + public readonly bool4 xwzw => new(x, w, z, w); + public readonly bool4 xwwx => new(x, w, w, x); + public readonly bool4 xwwy => new(x, w, w, y); + public readonly bool4 xwwz => new(x, w, w, z); + public readonly bool4 xwww => new(x, w, w, w); + public readonly bool4 yxxx => new(y, x, x, x); + public readonly bool4 yxxy => new(y, x, x, y); + public readonly bool4 yxxz => new(y, x, x, z); + public readonly bool4 yxxw => new(y, x, x, w); + public readonly bool4 yxyx => new(y, x, y, x); + public readonly bool4 yxyy => new(y, x, y, y); + public readonly bool4 yxyz => new(y, x, y, z); + public readonly bool4 yxyw => new(y, x, y, w); + public readonly bool4 yxzx => new(y, x, z, x); + public readonly bool4 yxzy => new(y, x, z, y); + public readonly bool4 yxzz => new(y, x, z, z); + public bool4 yxzw { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly bool4 yxwx => new(y, x, w, x); + public readonly bool4 yxwy => new(y, x, w, y); + public bool4 yxwz { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly bool4 yxww => new(y, x, w, w); + public readonly bool4 yyxx => new(y, y, x, x); + public readonly bool4 yyxy => new(y, y, x, y); + public readonly bool4 yyxz => new(y, y, x, z); + public readonly bool4 yyxw => new(y, y, x, w); + public readonly bool4 yyyx => new(y, y, y, x); + public readonly bool4 yyyy => new(y, y, y, y); + public readonly bool4 yyyz => new(y, y, y, z); + public readonly bool4 yyyw => new(y, y, y, w); + public readonly bool4 yyzx => new(y, y, z, x); + public readonly bool4 yyzy => new(y, y, z, y); + public readonly bool4 yyzz => new(y, y, z, z); + public readonly bool4 yyzw => new(y, y, z, w); + public readonly bool4 yywx => new(y, y, w, x); + public readonly bool4 yywy => new(y, y, w, y); + public readonly bool4 yywz => new(y, y, w, z); + public readonly bool4 yyww => new(y, y, w, w); + public readonly bool4 yzxx => new(y, z, x, x); + public readonly bool4 yzxy => new(y, z, x, y); + public readonly bool4 yzxz => new(y, z, x, z); + public bool4 yzxw { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly bool4 yzyx => new(y, z, y, x); + public readonly bool4 yzyy => new(y, z, y, y); + public readonly bool4 yzyz => new(y, z, y, z); + public readonly bool4 yzyw => new(y, z, y, w); + public readonly bool4 yzzx => new(y, z, z, x); + public readonly bool4 yzzy => new(y, z, z, y); + public readonly bool4 yzzz => new(y, z, z, z); + public readonly bool4 yzzw => new(y, z, z, w); + public bool4 yzwx { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly bool4 yzwy => new(y, z, w, y); + public readonly bool4 yzwz => new(y, z, w, z); + public readonly bool4 yzww => new(y, z, w, w); + public readonly bool4 ywxx => new(y, w, x, x); + public readonly bool4 ywxy => new(y, w, x, y); + public bool4 ywxz { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly bool4 ywxw => new(y, w, x, w); + public readonly bool4 ywyx => new(y, w, y, x); + public readonly bool4 ywyy => new(y, w, y, y); + public readonly bool4 ywyz => new(y, w, y, z); + public readonly bool4 ywyw => new(y, w, y, w); + public bool4 ywzx { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly bool4 ywzy => new(y, w, z, y); + public readonly bool4 ywzz => new(y, w, z, z); + public readonly bool4 ywzw => new(y, w, z, w); + public readonly bool4 ywwx => new(y, w, w, x); + public readonly bool4 ywwy => new(y, w, w, y); + public readonly bool4 ywwz => new(y, w, w, z); + public readonly bool4 ywww => new(y, w, w, w); + public readonly bool4 zxxx => new(z, x, x, x); + public readonly bool4 zxxy => new(z, x, x, y); + public readonly bool4 zxxz => new(z, x, x, z); + public readonly bool4 zxxw => new(z, x, x, w); + public readonly bool4 zxyx => new(z, x, y, x); + public readonly bool4 zxyy => new(z, x, y, y); + public readonly bool4 zxyz => new(z, x, y, z); + public bool4 zxyw { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly bool4 zxzx => new(z, x, z, x); + public readonly bool4 zxzy => new(z, x, z, y); + public readonly bool4 zxzz => new(z, x, z, z); + public readonly bool4 zxzw => new(z, x, z, w); + public readonly bool4 zxwx => new(z, x, w, x); + public bool4 zxwy { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly bool4 zxwz => new(z, x, w, z); + public readonly bool4 zxww => new(z, x, w, w); + public readonly bool4 zyxx => new(z, y, x, x); + public readonly bool4 zyxy => new(z, y, x, y); + public readonly bool4 zyxz => new(z, y, x, z); + public bool4 zyxw { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly bool4 zyyx => new(z, y, y, x); + public readonly bool4 zyyy => new(z, y, y, y); + public readonly bool4 zyyz => new(z, y, y, z); + public readonly bool4 zyyw => new(z, y, y, w); + public readonly bool4 zyzx => new(z, y, z, x); + public readonly bool4 zyzy => new(z, y, z, y); + public readonly bool4 zyzz => new(z, y, z, z); + public readonly bool4 zyzw => new(z, y, z, w); + public bool4 zywx { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly bool4 zywy => new(z, y, w, y); + public readonly bool4 zywz => new(z, y, w, z); + public readonly bool4 zyww => new(z, y, w, w); + public readonly bool4 zzxx => new(z, z, x, x); + public readonly bool4 zzxy => new(z, z, x, y); + public readonly bool4 zzxz => new(z, z, x, z); + public readonly bool4 zzxw => new(z, z, x, w); + public readonly bool4 zzyx => new(z, z, y, x); + public readonly bool4 zzyy => new(z, z, y, y); + public readonly bool4 zzyz => new(z, z, y, z); + public readonly bool4 zzyw => new(z, z, y, w); + public readonly bool4 zzzx => new(z, z, z, x); + public readonly bool4 zzzy => new(z, z, z, y); + public readonly bool4 zzzz => new(z, z, z, z); + public readonly bool4 zzzw => new(z, z, z, w); + public readonly bool4 zzwx => new(z, z, w, x); + public readonly bool4 zzwy => new(z, z, w, y); + public readonly bool4 zzwz => new(z, z, w, z); + public readonly bool4 zzww => new(z, z, w, w); + public readonly bool4 zwxx => new(z, w, x, x); + public bool4 zwxy { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly bool4 zwxz => new(z, w, x, z); + public readonly bool4 zwxw => new(z, w, x, w); + public bool4 zwyx { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly bool4 zwyy => new(z, w, y, y); + public readonly bool4 zwyz => new(z, w, y, z); + public readonly bool4 zwyw => new(z, w, y, w); + public readonly bool4 zwzx => new(z, w, z, x); + public readonly bool4 zwzy => new(z, w, z, y); + public readonly bool4 zwzz => new(z, w, z, z); + public readonly bool4 zwzw => new(z, w, z, w); + public readonly bool4 zwwx => new(z, w, w, x); + public readonly bool4 zwwy => new(z, w, w, y); + public readonly bool4 zwwz => new(z, w, w, z); + public readonly bool4 zwww => new(z, w, w, w); + public readonly bool4 wxxx => new(w, x, x, x); + public readonly bool4 wxxy => new(w, x, x, y); + public readonly bool4 wxxz => new(w, x, x, z); + public readonly bool4 wxxw => new(w, x, x, w); + public readonly bool4 wxyx => new(w, x, y, x); + public readonly bool4 wxyy => new(w, x, y, y); + public bool4 wxyz { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly bool4 wxyw => new(w, x, y, w); + public readonly bool4 wxzx => new(w, x, z, x); + public bool4 wxzy { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly bool4 wxzz => new(w, x, z, z); + public readonly bool4 wxzw => new(w, x, z, w); + public readonly bool4 wxwx => new(w, x, w, x); + public readonly bool4 wxwy => new(w, x, w, y); + public readonly bool4 wxwz => new(w, x, w, z); + public readonly bool4 wxww => new(w, x, w, w); + public readonly bool4 wyxx => new(w, y, x, x); + public readonly bool4 wyxy => new(w, y, x, y); + public bool4 wyxz { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly bool4 wyxw => new(w, y, x, w); + public readonly bool4 wyyx => new(w, y, y, x); + public readonly bool4 wyyy => new(w, y, y, y); + public readonly bool4 wyyz => new(w, y, y, z); + public readonly bool4 wyyw => new(w, y, y, w); + public bool4 wyzx { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly bool4 wyzy => new(w, y, z, y); + public readonly bool4 wyzz => new(w, y, z, z); + public readonly bool4 wyzw => new(w, y, z, w); + public readonly bool4 wywx => new(w, y, w, x); + public readonly bool4 wywy => new(w, y, w, y); + public readonly bool4 wywz => new(w, y, w, z); + public readonly bool4 wyww => new(w, y, w, w); + public readonly bool4 wzxx => new(w, z, x, x); + public bool4 wzxy { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly bool4 wzxz => new(w, z, x, z); + public readonly bool4 wzxw => new(w, z, x, w); + public bool4 wzyx { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly bool4 wzyy => new(w, z, y, y); + public readonly bool4 wzyz => new(w, z, y, z); + public readonly bool4 wzyw => new(w, z, y, w); + public readonly bool4 wzzx => new(w, z, z, x); + public readonly bool4 wzzy => new(w, z, z, y); + public readonly bool4 wzzz => new(w, z, z, z); + public readonly bool4 wzzw => new(w, z, z, w); + public readonly bool4 wzwx => new(w, z, w, x); + public readonly bool4 wzwy => new(w, z, w, y); + public readonly bool4 wzwz => new(w, z, w, z); + public readonly bool4 wzww => new(w, z, w, w); + public readonly bool4 wwxx => new(w, w, x, x); + public readonly bool4 wwxy => new(w, w, x, y); + public readonly bool4 wwxz => new(w, w, x, z); + public readonly bool4 wwxw => new(w, w, x, w); + public readonly bool4 wwyx => new(w, w, y, x); + public readonly bool4 wwyy => new(w, w, y, y); + public readonly bool4 wwyz => new(w, w, y, z); + public readonly bool4 wwyw => new(w, w, y, w); + public readonly bool4 wwzx => new(w, w, z, x); + public readonly bool4 wwzy => new(w, w, z, y); + public readonly bool4 wwzz => new(w, w, z, z); + public readonly bool4 wwzw => new(w, w, z, w); + public readonly bool4 wwwx => new(w, w, w, x); + public readonly bool4 wwwy => new(w, w, w, y); + public readonly bool4 wwwz => new(w, w, w, z); + public readonly bool4 wwww => new(w, w, w, w); + public readonly bool2 rr => new(x, x); + public bool2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public bool2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public bool2 ra { readonly get => new(x, w); set { x = value.x; w = value.y; } } + public bool2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly bool2 gg => new(y, y); + public bool2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public bool2 ga { readonly get => new(y, w); set { y = value.x; w = value.y; } } + public bool2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public bool2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly bool2 bb => new(z, z); + public bool2 ba { readonly get => new(z, w); set { z = value.x; w = value.y; } } + public bool2 ar { readonly get => new(w, x); set { w = value.x; x = value.y; } } + public bool2 ag { readonly get => new(w, y); set { w = value.x; y = value.y; } } + public bool2 ab { readonly get => new(w, z); set { w = value.x; z = value.y; } } + public readonly bool2 aa => new(w, w); + public readonly bool3 rrr => new(x, x, x); + public readonly bool3 rrg => new(x, x, y); + public readonly bool3 rrb => new(x, x, z); + public readonly bool3 rra => new(x, x, w); + public readonly bool3 rgr => new(x, y, x); + public readonly bool3 rgg => new(x, y, y); + public bool3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public bool3 rga { readonly get => new(x, y, w); set { x = value.x; y = value.y; w = value.z; } } + public readonly bool3 rbr => new(x, z, x); + public bool3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly bool3 rbb => new(x, z, z); + public bool3 rba { readonly get => new(x, z, w); set { x = value.x; z = value.y; w = value.z; } } + public readonly bool3 rar => new(x, w, x); + public bool3 rag { readonly get => new(x, w, y); set { x = value.x; w = value.y; y = value.z; } } + public bool3 rab { readonly get => new(x, w, z); set { x = value.x; w = value.y; z = value.z; } } + public readonly bool3 raa => new(x, w, w); + public readonly bool3 grr => new(y, x, x); + public readonly bool3 grg => new(y, x, y); + public bool3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public bool3 gra { readonly get => new(y, x, w); set { y = value.x; x = value.y; w = value.z; } } + public readonly bool3 ggr => new(y, y, x); + public readonly bool3 ggg => new(y, y, y); + public readonly bool3 ggb => new(y, y, z); + public readonly bool3 gga => new(y, y, w); + public bool3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly bool3 gbg => new(y, z, y); + public readonly bool3 gbb => new(y, z, z); + public bool3 gba { readonly get => new(y, z, w); set { y = value.x; z = value.y; w = value.z; } } + public bool3 gar { readonly get => new(y, w, x); set { y = value.x; w = value.y; x = value.z; } } + public readonly bool3 gag => new(y, w, y); + public bool3 gab { readonly get => new(y, w, z); set { y = value.x; w = value.y; z = value.z; } } + public readonly bool3 gaa => new(y, w, w); + public readonly bool3 brr => new(z, x, x); + public bool3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly bool3 brb => new(z, x, z); + public bool3 bra { readonly get => new(z, x, w); set { z = value.x; x = value.y; w = value.z; } } + public bool3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly bool3 bgg => new(z, y, y); + public readonly bool3 bgb => new(z, y, z); + public bool3 bga { readonly get => new(z, y, w); set { z = value.x; y = value.y; w = value.z; } } + public readonly bool3 bbr => new(z, z, x); + public readonly bool3 bbg => new(z, z, y); + public readonly bool3 bbb => new(z, z, z); + public readonly bool3 bba => new(z, z, w); + public bool3 bar { readonly get => new(z, w, x); set { z = value.x; w = value.y; x = value.z; } } + public bool3 bag { readonly get => new(z, w, y); set { z = value.x; w = value.y; y = value.z; } } + public readonly bool3 bab => new(z, w, z); + public readonly bool3 baa => new(z, w, w); + public readonly bool3 arr => new(w, x, x); + public bool3 arg { readonly get => new(w, x, y); set { w = value.x; x = value.y; y = value.z; } } + public bool3 arb { readonly get => new(w, x, z); set { w = value.x; x = value.y; z = value.z; } } + public readonly bool3 ara => new(w, x, w); + public bool3 agr { readonly get => new(w, y, x); set { w = value.x; y = value.y; x = value.z; } } + public readonly bool3 agg => new(w, y, y); + public bool3 agb { readonly get => new(w, y, z); set { w = value.x; y = value.y; z = value.z; } } + public readonly bool3 aga => new(w, y, w); + public bool3 abr { readonly get => new(w, z, x); set { w = value.x; z = value.y; x = value.z; } } + public bool3 abg { readonly get => new(w, z, y); set { w = value.x; z = value.y; y = value.z; } } + public readonly bool3 abb => new(w, z, z); + public readonly bool3 aba => new(w, z, w); + public readonly bool3 aar => new(w, w, x); + public readonly bool3 aag => new(w, w, y); + public readonly bool3 aab => new(w, w, z); + public readonly bool3 aaa => new(w, w, w); + public readonly bool4 rrrr => new(x, x, x, x); + public readonly bool4 rrrg => new(x, x, x, y); + public readonly bool4 rrrb => new(x, x, x, z); + public readonly bool4 rrra => new(x, x, x, w); + public readonly bool4 rrgr => new(x, x, y, x); + public readonly bool4 rrgg => new(x, x, y, y); + public readonly bool4 rrgb => new(x, x, y, z); + public readonly bool4 rrga => new(x, x, y, w); + public readonly bool4 rrbr => new(x, x, z, x); + public readonly bool4 rrbg => new(x, x, z, y); + public readonly bool4 rrbb => new(x, x, z, z); + public readonly bool4 rrba => new(x, x, z, w); + public readonly bool4 rrar => new(x, x, w, x); + public readonly bool4 rrag => new(x, x, w, y); + public readonly bool4 rrab => new(x, x, w, z); + public readonly bool4 rraa => new(x, x, w, w); + public readonly bool4 rgrr => new(x, y, x, x); + public readonly bool4 rgrg => new(x, y, x, y); + public readonly bool4 rgrb => new(x, y, x, z); + public readonly bool4 rgra => new(x, y, x, w); + public readonly bool4 rggr => new(x, y, y, x); + public readonly bool4 rggg => new(x, y, y, y); + public readonly bool4 rggb => new(x, y, y, z); + public readonly bool4 rgga => new(x, y, y, w); + public readonly bool4 rgbr => new(x, y, z, x); + public readonly bool4 rgbg => new(x, y, z, y); + public readonly bool4 rgbb => new(x, y, z, z); + public bool4 rgba { readonly get => new(x, y, z, w); set { x = value.x; y = value.y; z = value.z; w = value.w; } } + public readonly bool4 rgar => new(x, y, w, x); + public readonly bool4 rgag => new(x, y, w, y); + public bool4 rgab { readonly get => new(x, y, w, z); set { x = value.x; y = value.y; w = value.z; z = value.w; } } + public readonly bool4 rgaa => new(x, y, w, w); + public readonly bool4 rbrr => new(x, z, x, x); + public readonly bool4 rbrg => new(x, z, x, y); + public readonly bool4 rbrb => new(x, z, x, z); + public readonly bool4 rbra => new(x, z, x, w); + public readonly bool4 rbgr => new(x, z, y, x); + public readonly bool4 rbgg => new(x, z, y, y); + public readonly bool4 rbgb => new(x, z, y, z); + public bool4 rbga { readonly get => new(x, z, y, w); set { x = value.x; z = value.y; y = value.z; w = value.w; } } + public readonly bool4 rbbr => new(x, z, z, x); + public readonly bool4 rbbg => new(x, z, z, y); + public readonly bool4 rbbb => new(x, z, z, z); + public readonly bool4 rbba => new(x, z, z, w); + public readonly bool4 rbar => new(x, z, w, x); + public bool4 rbag { readonly get => new(x, z, w, y); set { x = value.x; z = value.y; w = value.z; y = value.w; } } + public readonly bool4 rbab => new(x, z, w, z); + public readonly bool4 rbaa => new(x, z, w, w); + public readonly bool4 rarr => new(x, w, x, x); + public readonly bool4 rarg => new(x, w, x, y); + public readonly bool4 rarb => new(x, w, x, z); + public readonly bool4 rara => new(x, w, x, w); + public readonly bool4 ragr => new(x, w, y, x); + public readonly bool4 ragg => new(x, w, y, y); + public bool4 ragb { readonly get => new(x, w, y, z); set { x = value.x; w = value.y; y = value.z; z = value.w; } } + public readonly bool4 raga => new(x, w, y, w); + public readonly bool4 rabr => new(x, w, z, x); + public bool4 rabg { readonly get => new(x, w, z, y); set { x = value.x; w = value.y; z = value.z; y = value.w; } } + public readonly bool4 rabb => new(x, w, z, z); + public readonly bool4 raba => new(x, w, z, w); + public readonly bool4 raar => new(x, w, w, x); + public readonly bool4 raag => new(x, w, w, y); + public readonly bool4 raab => new(x, w, w, z); + public readonly bool4 raaa => new(x, w, w, w); + public readonly bool4 grrr => new(y, x, x, x); + public readonly bool4 grrg => new(y, x, x, y); + public readonly bool4 grrb => new(y, x, x, z); + public readonly bool4 grra => new(y, x, x, w); + public readonly bool4 grgr => new(y, x, y, x); + public readonly bool4 grgg => new(y, x, y, y); + public readonly bool4 grgb => new(y, x, y, z); + public readonly bool4 grga => new(y, x, y, w); + public readonly bool4 grbr => new(y, x, z, x); + public readonly bool4 grbg => new(y, x, z, y); + public readonly bool4 grbb => new(y, x, z, z); + public bool4 grba { readonly get => new(y, x, z, w); set { y = value.x; x = value.y; z = value.z; w = value.w; } } + public readonly bool4 grar => new(y, x, w, x); + public readonly bool4 grag => new(y, x, w, y); + public bool4 grab { readonly get => new(y, x, w, z); set { y = value.x; x = value.y; w = value.z; z = value.w; } } + public readonly bool4 graa => new(y, x, w, w); + public readonly bool4 ggrr => new(y, y, x, x); + public readonly bool4 ggrg => new(y, y, x, y); + public readonly bool4 ggrb => new(y, y, x, z); + public readonly bool4 ggra => new(y, y, x, w); + public readonly bool4 gggr => new(y, y, y, x); + public readonly bool4 gggg => new(y, y, y, y); + public readonly bool4 gggb => new(y, y, y, z); + public readonly bool4 ggga => new(y, y, y, w); + public readonly bool4 ggbr => new(y, y, z, x); + public readonly bool4 ggbg => new(y, y, z, y); + public readonly bool4 ggbb => new(y, y, z, z); + public readonly bool4 ggba => new(y, y, z, w); + public readonly bool4 ggar => new(y, y, w, x); + public readonly bool4 ggag => new(y, y, w, y); + public readonly bool4 ggab => new(y, y, w, z); + public readonly bool4 ggaa => new(y, y, w, w); + public readonly bool4 gbrr => new(y, z, x, x); + public readonly bool4 gbrg => new(y, z, x, y); + public readonly bool4 gbrb => new(y, z, x, z); + public bool4 gbra { readonly get => new(y, z, x, w); set { y = value.x; z = value.y; x = value.z; w = value.w; } } + public readonly bool4 gbgr => new(y, z, y, x); + public readonly bool4 gbgg => new(y, z, y, y); + public readonly bool4 gbgb => new(y, z, y, z); + public readonly bool4 gbga => new(y, z, y, w); + public readonly bool4 gbbr => new(y, z, z, x); + public readonly bool4 gbbg => new(y, z, z, y); + public readonly bool4 gbbb => new(y, z, z, z); + public readonly bool4 gbba => new(y, z, z, w); + public bool4 gbar { readonly get => new(y, z, w, x); set { y = value.x; z = value.y; w = value.z; x = value.w; } } + public readonly bool4 gbag => new(y, z, w, y); + public readonly bool4 gbab => new(y, z, w, z); + public readonly bool4 gbaa => new(y, z, w, w); + public readonly bool4 garr => new(y, w, x, x); + public readonly bool4 garg => new(y, w, x, y); + public bool4 garb { readonly get => new(y, w, x, z); set { y = value.x; w = value.y; x = value.z; z = value.w; } } + public readonly bool4 gara => new(y, w, x, w); + public readonly bool4 gagr => new(y, w, y, x); + public readonly bool4 gagg => new(y, w, y, y); + public readonly bool4 gagb => new(y, w, y, z); + public readonly bool4 gaga => new(y, w, y, w); + public bool4 gabr { readonly get => new(y, w, z, x); set { y = value.x; w = value.y; z = value.z; x = value.w; } } + public readonly bool4 gabg => new(y, w, z, y); + public readonly bool4 gabb => new(y, w, z, z); + public readonly bool4 gaba => new(y, w, z, w); + public readonly bool4 gaar => new(y, w, w, x); + public readonly bool4 gaag => new(y, w, w, y); + public readonly bool4 gaab => new(y, w, w, z); + public readonly bool4 gaaa => new(y, w, w, w); + public readonly bool4 brrr => new(z, x, x, x); + public readonly bool4 brrg => new(z, x, x, y); + public readonly bool4 brrb => new(z, x, x, z); + public readonly bool4 brra => new(z, x, x, w); + public readonly bool4 brgr => new(z, x, y, x); + public readonly bool4 brgg => new(z, x, y, y); + public readonly bool4 brgb => new(z, x, y, z); + public bool4 brga { readonly get => new(z, x, y, w); set { z = value.x; x = value.y; y = value.z; w = value.w; } } + public readonly bool4 brbr => new(z, x, z, x); + public readonly bool4 brbg => new(z, x, z, y); + public readonly bool4 brbb => new(z, x, z, z); + public readonly bool4 brba => new(z, x, z, w); + public readonly bool4 brar => new(z, x, w, x); + public bool4 brag { readonly get => new(z, x, w, y); set { z = value.x; x = value.y; w = value.z; y = value.w; } } + public readonly bool4 brab => new(z, x, w, z); + public readonly bool4 braa => new(z, x, w, w); + public readonly bool4 bgrr => new(z, y, x, x); + public readonly bool4 bgrg => new(z, y, x, y); + public readonly bool4 bgrb => new(z, y, x, z); + public bool4 bgra { readonly get => new(z, y, x, w); set { z = value.x; y = value.y; x = value.z; w = value.w; } } + public readonly bool4 bggr => new(z, y, y, x); + public readonly bool4 bggg => new(z, y, y, y); + public readonly bool4 bggb => new(z, y, y, z); + public readonly bool4 bgga => new(z, y, y, w); + public readonly bool4 bgbr => new(z, y, z, x); + public readonly bool4 bgbg => new(z, y, z, y); + public readonly bool4 bgbb => new(z, y, z, z); + public readonly bool4 bgba => new(z, y, z, w); + public bool4 bgar { readonly get => new(z, y, w, x); set { z = value.x; y = value.y; w = value.z; x = value.w; } } + public readonly bool4 bgag => new(z, y, w, y); + public readonly bool4 bgab => new(z, y, w, z); + public readonly bool4 bgaa => new(z, y, w, w); + public readonly bool4 bbrr => new(z, z, x, x); + public readonly bool4 bbrg => new(z, z, x, y); + public readonly bool4 bbrb => new(z, z, x, z); + public readonly bool4 bbra => new(z, z, x, w); + public readonly bool4 bbgr => new(z, z, y, x); + public readonly bool4 bbgg => new(z, z, y, y); + public readonly bool4 bbgb => new(z, z, y, z); + public readonly bool4 bbga => new(z, z, y, w); + public readonly bool4 bbbr => new(z, z, z, x); + public readonly bool4 bbbg => new(z, z, z, y); + public readonly bool4 bbbb => new(z, z, z, z); + public readonly bool4 bbba => new(z, z, z, w); + public readonly bool4 bbar => new(z, z, w, x); + public readonly bool4 bbag => new(z, z, w, y); + public readonly bool4 bbab => new(z, z, w, z); + public readonly bool4 bbaa => new(z, z, w, w); + public readonly bool4 barr => new(z, w, x, x); + public bool4 barg { readonly get => new(z, w, x, y); set { z = value.x; w = value.y; x = value.z; y = value.w; } } + public readonly bool4 barb => new(z, w, x, z); + public readonly bool4 bara => new(z, w, x, w); + public bool4 bagr { readonly get => new(z, w, y, x); set { z = value.x; w = value.y; y = value.z; x = value.w; } } + public readonly bool4 bagg => new(z, w, y, y); + public readonly bool4 bagb => new(z, w, y, z); + public readonly bool4 baga => new(z, w, y, w); + public readonly bool4 babr => new(z, w, z, x); + public readonly bool4 babg => new(z, w, z, y); + public readonly bool4 babb => new(z, w, z, z); + public readonly bool4 baba => new(z, w, z, w); + public readonly bool4 baar => new(z, w, w, x); + public readonly bool4 baag => new(z, w, w, y); + public readonly bool4 baab => new(z, w, w, z); + public readonly bool4 baaa => new(z, w, w, w); + public readonly bool4 arrr => new(w, x, x, x); + public readonly bool4 arrg => new(w, x, x, y); + public readonly bool4 arrb => new(w, x, x, z); + public readonly bool4 arra => new(w, x, x, w); + public readonly bool4 argr => new(w, x, y, x); + public readonly bool4 argg => new(w, x, y, y); + public bool4 argb { readonly get => new(w, x, y, z); set { w = value.x; x = value.y; y = value.z; z = value.w; } } + public readonly bool4 arga => new(w, x, y, w); + public readonly bool4 arbr => new(w, x, z, x); + public bool4 arbg { readonly get => new(w, x, z, y); set { w = value.x; x = value.y; z = value.z; y = value.w; } } + public readonly bool4 arbb => new(w, x, z, z); + public readonly bool4 arba => new(w, x, z, w); + public readonly bool4 arar => new(w, x, w, x); + public readonly bool4 arag => new(w, x, w, y); + public readonly bool4 arab => new(w, x, w, z); + public readonly bool4 araa => new(w, x, w, w); + public readonly bool4 agrr => new(w, y, x, x); + public readonly bool4 agrg => new(w, y, x, y); + public bool4 agrb { readonly get => new(w, y, x, z); set { w = value.x; y = value.y; x = value.z; z = value.w; } } + public readonly bool4 agra => new(w, y, x, w); + public readonly bool4 aggr => new(w, y, y, x); + public readonly bool4 aggg => new(w, y, y, y); + public readonly bool4 aggb => new(w, y, y, z); + public readonly bool4 agga => new(w, y, y, w); + public bool4 agbr { readonly get => new(w, y, z, x); set { w = value.x; y = value.y; z = value.z; x = value.w; } } + public readonly bool4 agbg => new(w, y, z, y); + public readonly bool4 agbb => new(w, y, z, z); + public readonly bool4 agba => new(w, y, z, w); + public readonly bool4 agar => new(w, y, w, x); + public readonly bool4 agag => new(w, y, w, y); + public readonly bool4 agab => new(w, y, w, z); + public readonly bool4 agaa => new(w, y, w, w); + public readonly bool4 abrr => new(w, z, x, x); + public bool4 abrg { readonly get => new(w, z, x, y); set { w = value.x; z = value.y; x = value.z; y = value.w; } } + public readonly bool4 abrb => new(w, z, x, z); + public readonly bool4 abra => new(w, z, x, w); + public bool4 abgr { readonly get => new(w, z, y, x); set { w = value.x; z = value.y; y = value.z; x = value.w; } } + public readonly bool4 abgg => new(w, z, y, y); + public readonly bool4 abgb => new(w, z, y, z); + public readonly bool4 abga => new(w, z, y, w); + public readonly bool4 abbr => new(w, z, z, x); + public readonly bool4 abbg => new(w, z, z, y); + public readonly bool4 abbb => new(w, z, z, z); + public readonly bool4 abba => new(w, z, z, w); + public readonly bool4 abar => new(w, z, w, x); + public readonly bool4 abag => new(w, z, w, y); + public readonly bool4 abab => new(w, z, w, z); + public readonly bool4 abaa => new(w, z, w, w); + public readonly bool4 aarr => new(w, w, x, x); + public readonly bool4 aarg => new(w, w, x, y); + public readonly bool4 aarb => new(w, w, x, z); + public readonly bool4 aara => new(w, w, x, w); + public readonly bool4 aagr => new(w, w, y, x); + public readonly bool4 aagg => new(w, w, y, y); + public readonly bool4 aagb => new(w, w, y, z); + public readonly bool4 aaga => new(w, w, y, w); + public readonly bool4 aabr => new(w, w, z, x); + public readonly bool4 aabg => new(w, w, z, y); + public readonly bool4 aabb => new(w, w, z, z); + public readonly bool4 aaba => new(w, w, z, w); + public readonly bool4 aaar => new(w, w, w, x); + public readonly bool4 aaag => new(w, w, w, y); + public readonly bool4 aaab => new(w, w, w, z); + public readonly bool4 aaaa => new(w, w, w, w); +} + +public partial struct double2 +{ + public double2(double2 xy) : this(xy.x, xy.y) { } + public double r { readonly get => x; set => x = value; } + public double g { readonly get => y; set => y = value; } + public readonly double2 xx => new(x, x); + public double2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public double2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly double2 yy => new(y, y); + public readonly double3 xxx => new(x, x, x); + public readonly double3 xxy => new(x, x, y); + public readonly double3 xyx => new(x, y, x); + public readonly double3 xyy => new(x, y, y); + public readonly double3 yxx => new(y, x, x); + public readonly double3 yxy => new(y, x, y); + public readonly double3 yyx => new(y, y, x); + public readonly double3 yyy => new(y, y, y); + public readonly double2 rr => new(x, x); + public double2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public double2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly double2 gg => new(y, y); + public readonly double3 rrr => new(x, x, x); + public readonly double3 rrg => new(x, x, y); + public readonly double3 rgr => new(x, y, x); + public readonly double3 rgg => new(x, y, y); + public readonly double3 grr => new(y, x, x); + public readonly double3 grg => new(y, x, y); + public readonly double3 ggr => new(y, y, x); + public readonly double3 ggg => new(y, y, y); +} + +public partial struct double3 +{ + public double3(double x, double2 yz) : this(x, yz.x, yz.y) { } + public double3(double2 xy, double z) : this(xy.x, xy.y, z) { } + public double3(double3 xyz) : this(xyz.x, xyz.y, xyz.z) { } + public double r { readonly get => x; set => x = value; } + public double g { readonly get => y; set => y = value; } + public double b { readonly get => z; set => z = value; } + public readonly double2 xx => new(x, x); + public double2 xy { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public double2 xz { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public double2 yx { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly double2 yy => new(y, y); + public double2 yz { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public double2 zx { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public double2 zy { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly double2 zz => new(z, z); + public readonly double3 xxx => new(x, x, x); + public readonly double3 xxy => new(x, x, y); + public readonly double3 xxz => new(x, x, z); + public readonly double3 xyx => new(x, y, x); + public readonly double3 xyy => new(x, y, y); + public double3 xyz { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly double3 xzx => new(x, z, x); + public double3 xzy { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly double3 xzz => new(x, z, z); + public readonly double3 yxx => new(y, x, x); + public readonly double3 yxy => new(y, x, y); + public double3 yxz { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly double3 yyx => new(y, y, x); + public readonly double3 yyy => new(y, y, y); + public readonly double3 yyz => new(y, y, z); + public double3 yzx { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly double3 yzy => new(y, z, y); + public readonly double3 yzz => new(y, z, z); + public readonly double3 zxx => new(z, x, x); + public double3 zxy { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly double3 zxz => new(z, x, z); + public double3 zyx { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly double3 zyy => new(z, y, y); + public readonly double3 zyz => new(z, y, z); + public readonly double3 zzx => new(z, z, x); + public readonly double3 zzy => new(z, z, y); + public readonly double3 zzz => new(z, z, z); + public readonly double2 rr => new(x, x); + public double2 rg { readonly get => new(x, y); set { x = value.x; y = value.y; } } + public double2 rb { readonly get => new(x, z); set { x = value.x; z = value.y; } } + public double2 gr { readonly get => new(y, x); set { y = value.x; x = value.y; } } + public readonly double2 gg => new(y, y); + public double2 gb { readonly get => new(y, z); set { y = value.x; z = value.y; } } + public double2 br { readonly get => new(z, x); set { z = value.x; x = value.y; } } + public double2 bg { readonly get => new(z, y); set { z = value.x; y = value.y; } } + public readonly double2 bb => new(z, z); + public readonly double3 rrr => new(x, x, x); + public readonly double3 rrg => new(x, x, y); + public readonly double3 rrb => new(x, x, z); + public readonly double3 rgr => new(x, y, x); + public readonly double3 rgg => new(x, y, y); + public double3 rgb { readonly get => new(x, y, z); set { x = value.x; y = value.y; z = value.z; } } + public readonly double3 rbr => new(x, z, x); + public double3 rbg { readonly get => new(x, z, y); set { x = value.x; z = value.y; y = value.z; } } + public readonly double3 rbb => new(x, z, z); + public readonly double3 grr => new(y, x, x); + public readonly double3 grg => new(y, x, y); + public double3 grb { readonly get => new(y, x, z); set { y = value.x; x = value.y; z = value.z; } } + public readonly double3 ggr => new(y, y, x); + public readonly double3 ggg => new(y, y, y); + public readonly double3 ggb => new(y, y, z); + public double3 gbr { readonly get => new(y, z, x); set { y = value.x; z = value.y; x = value.z; } } + public readonly double3 gbg => new(y, z, y); + public readonly double3 gbb => new(y, z, z); + public readonly double3 brr => new(z, x, x); + public double3 brg { readonly get => new(z, x, y); set { z = value.x; x = value.y; y = value.z; } } + public readonly double3 brb => new(z, x, z); + public double3 bgr { readonly get => new(z, y, x); set { z = value.x; y = value.y; x = value.z; } } + public readonly double3 bgg => new(z, y, y); + public readonly double3 bgb => new(z, y, z); + public readonly double3 bbr => new(z, z, x); + public readonly double3 bbg => new(z, z, y); + public readonly double3 bbb => new(z, z, z); +} + +public static partial class math +{ + public static float2 float2(float2 xy) => new(xy); + public static float3 float3(float x, float2 yz) => new(x, yz); + public static float3 float3(float2 xy, float z) => new(xy, z); + public static float3 float3(float3 xyz) => new(xyz); + public static float4 float4(float x, float y, float2 zw) => new(x, y, zw); + public static float4 float4(float x, float2 yz, float w) => new(x, yz, w); + public static float4 float4(float x, float3 yzw) => new(x, yzw); + public static float4 float4(float2 xy, float z, float w) => new(xy, z, w); + public static float4 float4(float2 xy, float2 zw) => new(xy, zw); + public static float4 float4(float3 xyz, float w) => new(xyz, w); + public static float4 float4(float4 xyzw) => new(xyzw); + public static int2 int2(int2 xy) => new(xy); + public static int3 int3(int x, int2 yz) => new(x, yz); + public static int3 int3(int2 xy, int z) => new(xy, z); + public static int3 int3(int3 xyz) => new(xyz); + public static int4 int4(int x, int y, int2 zw) => new(x, y, zw); + public static int4 int4(int x, int2 yz, int w) => new(x, yz, w); + public static int4 int4(int x, int3 yzw) => new(x, yzw); + public static int4 int4(int2 xy, int z, int w) => new(xy, z, w); + public static int4 int4(int2 xy, int2 zw) => new(xy, zw); + public static int4 int4(int3 xyz, int w) => new(xyz, w); + public static int4 int4(int4 xyzw) => new(xyzw); + public static bool2 bool2(bool2 xy) => new(xy); + public static bool3 bool3(bool x, bool2 yz) => new(x, yz); + public static bool3 bool3(bool2 xy, bool z) => new(xy, z); + public static bool3 bool3(bool3 xyz) => new(xyz); + public static bool4 bool4(bool x, bool y, bool2 zw) => new(x, y, zw); + public static bool4 bool4(bool x, bool2 yz, bool w) => new(x, yz, w); + public static bool4 bool4(bool x, bool3 yzw) => new(x, yzw); + public static bool4 bool4(bool2 xy, bool z, bool w) => new(xy, z, w); + public static bool4 bool4(bool2 xy, bool2 zw) => new(xy, zw); + public static bool4 bool4(bool3 xyz, bool w) => new(xyz, w); + public static bool4 bool4(bool4 xyzw) => new(xyzw); +} diff --git a/packages/cultmath/src/CultMath/Swizzles.g.cs.meta b/packages/cultmath/src/CultMath/Swizzles.g.cs.meta new file mode 100644 index 00000000..035e577f --- /dev/null +++ b/packages/cultmath/src/CultMath/Swizzles.g.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: e89d6089b354459788eb6f0faebfd6c0 diff --git a/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs b/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs new file mode 100644 index 00000000..6e1e3148 --- /dev/null +++ b/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs @@ -0,0 +1,10 @@ +#if !NET7_0_OR_GREATER +namespace System.Diagnostics.CodeAnalysis; + +// Compiler-recognized polyfill so netstandard2.1 builds can return refs into a struct's +// own fields (the matrix row indexer). net7.0+ supplies the real attribute. +[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] +internal sealed class UnscopedRefAttribute : Attribute +{ +} +#endif diff --git a/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs.meta b/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs.meta new file mode 100644 index 00000000..61df7771 --- /dev/null +++ b/packages/cultmath/src/CultMath/UnscopedRefAttribute.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 3f204000f9854517a8dd754e2d9dc975 diff --git a/packages/cultmath/src/CultMath/bool2.cs b/packages/cultmath/src/CultMath/bool2.cs index 31fd10b0..29710f0c 100644 --- a/packages/cultmath/src/CultMath/bool2.cs +++ b/packages/cultmath/src/CultMath/bool2.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct bool2 : IEquatable +public partial struct bool2 : IEquatable { public static readonly bool2 @false = new(false, false); public static readonly bool2 @true = new(true, true); diff --git a/packages/cultmath/src/CultMath/bool3.cs b/packages/cultmath/src/CultMath/bool3.cs index 15c834ed..9e4029c7 100644 --- a/packages/cultmath/src/CultMath/bool3.cs +++ b/packages/cultmath/src/CultMath/bool3.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct bool3 : IEquatable +public partial struct bool3 : IEquatable { public static readonly bool3 @false = new(false, false, false); public static readonly bool3 @true = new(true, true, true); diff --git a/packages/cultmath/src/CultMath/bool4.cs b/packages/cultmath/src/CultMath/bool4.cs index 09300432..b12f15b6 100644 --- a/packages/cultmath/src/CultMath/bool4.cs +++ b/packages/cultmath/src/CultMath/bool4.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct bool4 : IEquatable +public partial struct bool4 : IEquatable { public static readonly bool4 @false = new(false, false, false, false); public static readonly bool4 @true = new(true, true, true, true); diff --git a/packages/cultmath/src/CultMath/double2.cs b/packages/cultmath/src/CultMath/double2.cs index e61d84ea..958b409d 100644 --- a/packages/cultmath/src/CultMath/double2.cs +++ b/packages/cultmath/src/CultMath/double2.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct double2 : IEquatable +public partial struct double2 : IEquatable { public static readonly double2 zero = new(0.0, 0.0); public static readonly double2 one = new(1.0, 1.0); diff --git a/packages/cultmath/src/CultMath/double3.cs b/packages/cultmath/src/CultMath/double3.cs index 98c79327..5fbe9c65 100644 --- a/packages/cultmath/src/CultMath/double3.cs +++ b/packages/cultmath/src/CultMath/double3.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct double3 : IEquatable +public partial struct double3 : IEquatable { public static readonly double3 zero = new(0.0, 0.0, 0.0); public static readonly double3 one = new(1.0, 1.0, 1.0); @@ -18,16 +18,6 @@ public struct double3 : IEquatable this.z = z; } - public double2 xy - { - readonly get => new(x, y); - set - { - x = value.x; - y = value.y; - } - } - public double this[int index] { readonly get => index switch diff --git a/packages/cultmath/src/CultMath/float2.cs b/packages/cultmath/src/CultMath/float2.cs index f1fb5ccd..e33655a8 100644 --- a/packages/cultmath/src/CultMath/float2.cs +++ b/packages/cultmath/src/CultMath/float2.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct float2 : IEquatable +public partial struct float2 : IEquatable { public static readonly float2 zero = new(0.0f, 0.0f); public static readonly float2 one = new(1.0f, 1.0f); @@ -16,16 +16,6 @@ public struct float2 : IEquatable this.y = y; } - public float2 yx - { - readonly get => new(y, x); - set - { - y = value.x; - x = value.y; - } - } - public float this[int index] { readonly get => index switch diff --git a/packages/cultmath/src/CultMath/float2x2.cs b/packages/cultmath/src/CultMath/float2x2.cs index 60f59fb2..9d5a2e54 100644 --- a/packages/cultmath/src/CultMath/float2x2.cs +++ b/packages/cultmath/src/CultMath/float2x2.cs @@ -1,49 +1,48 @@ using System; +using System.Diagnostics.CodeAnalysis; namespace CultMath; /// -/// HLSL float2x2: row-major. Constructors take rows, m[i] is row i, and -/// _mRC names row R, column C exactly as HLSL does. Use -/// for products; there is no * matrix product because HLSL's * is component-wise. +/// HLSL float2x2: row-major. Constructors take rows, m[i] is a writable reference to +/// row i (so m[1][0] = s works), and _mRC names row R, column C exactly as HLSL +/// does. Use for products; there is no * +/// matrix product because HLSL's * is component-wise. /// public struct float2x2 : IEquatable { public static readonly float2x2 identity = new(1.0f, 0.0f, 0.0f, 1.0f); public static readonly float2x2 zero = new(0.0f, 0.0f, 0.0f, 0.0f); - public float _m00; - public float _m01; - public float _m10; - public float _m11; + private float2 _row0; + private float2 _row1; public float2x2(float m00, float m01, float m10, float m11) { - _m00 = m00; - _m01 = m01; - _m10 = m10; - _m11 = m11; + _row0 = new float2(m00, m01); + _row1 = new float2(m10, m11); } public float2x2(float2 row0, float2 row1) - : this(row0.x, row0.y, row1.x, row1.y) { + _row0 = row0; + _row1 = row1; } - public float2 this[int row] + public float _m00 { readonly get => _row0.x; set => _row0.x = value; } + public float _m01 { readonly get => _row0.y; set => _row0.y = value; } + public float _m10 { readonly get => _row1.x; set => _row1.x = value; } + public float _m11 { readonly get => _row1.y; set => _row1.y = value; } + + [UnscopedRef] + public ref float2 this[int row] { - readonly get => row switch - { - 0 => new float2(_m00, _m01), - 1 => new float2(_m10, _m11), - _ => throw new ArgumentOutOfRangeException(nameof(row)), - }; - set + get { switch (row) { - case 0: _m00 = value.x; _m01 = value.y; break; - case 1: _m10 = value.x; _m11 = value.y; break; + case 0: return ref _row0; + case 1: return ref _row1; default: throw new ArgumentOutOfRangeException(nameof(row)); } } @@ -60,10 +59,8 @@ public struct float2x2 : IEquatable return new float2x2(c, -s, s, c); } - public readonly bool Equals(float2x2 other) => - _m00.Equals(other._m00) && _m01.Equals(other._m01) && _m10.Equals(other._m10) && _m11.Equals(other._m11); - + public readonly bool Equals(float2x2 other) => _row0.Equals(other._row0) && _row1.Equals(other._row1); public override readonly bool Equals(object? obj) => obj is float2x2 other && Equals(other); - public override readonly int GetHashCode() => HashCode.Combine(_m00, _m01, _m10, _m11); - public override readonly string ToString() => FormattableString.Invariant($"float2x2({_m00:R}, {_m01:R}, {_m10:R}, {_m11:R})"); + public override readonly int GetHashCode() => HashCode.Combine(_row0, _row1); + public override readonly string ToString() => FormattableString.Invariant($"float2x2({_row0.x:R}, {_row0.y:R}, {_row1.x:R}, {_row1.y:R})"); } diff --git a/packages/cultmath/src/CultMath/float3.cs b/packages/cultmath/src/CultMath/float3.cs index b4dfa854..ca83628b 100644 --- a/packages/cultmath/src/CultMath/float3.cs +++ b/packages/cultmath/src/CultMath/float3.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct float3 : IEquatable +public partial struct float3 : IEquatable { public static readonly float3 zero = new(0.0f, 0.0f, 0.0f); public static readonly float3 one = new(1.0f, 1.0f, 1.0f); @@ -18,105 +18,6 @@ public struct float3 : IEquatable this.z = z; } - public float3(float2 xy, float z) - : this(xy.x, xy.y, z) - { - } - - public float2 xy - { - readonly get => new(x, y); - set - { - x = value.x; - y = value.y; - } - } - - public float2 xz - { - readonly get => new(x, z); - set - { - x = value.x; - z = value.y; - } - } - - public float2 yx - { - readonly get => new(y, x); - set - { - y = value.x; - x = value.y; - } - } - - public float2 yz - { - readonly get => new(y, z); - set - { - y = value.x; - z = value.y; - } - } - - public float2 zy - { - readonly get => new(z, y); - set - { - z = value.x; - y = value.y; - } - } - - public float3 xyz - { - readonly get => new(x, y, z); - set - { - x = value.x; - y = value.y; - z = value.z; - } - } - - public float3 xzy - { - readonly get => new(x, z, y); - set - { - x = value.x; - z = value.y; - y = value.z; - } - } - - public float3 yzx - { - readonly get => new(y, z, x); - set - { - y = value.x; - z = value.y; - x = value.z; - } - } - - public float3 zyx - { - readonly get => new(z, y, x); - set - { - z = value.x; - y = value.y; - x = value.z; - } - } - public float this[int index] { readonly get => index switch diff --git a/packages/cultmath/src/CultMath/float3x3.cs b/packages/cultmath/src/CultMath/float3x3.cs index 41e39936..4c052a50 100644 --- a/packages/cultmath/src/CultMath/float3x3.cs +++ b/packages/cultmath/src/CultMath/float3x3.cs @@ -1,61 +1,57 @@ using System; +using System.Diagnostics.CodeAnalysis; namespace CultMath; /// -/// HLSL float3x3: row-major. Constructors take rows, m[i] is row i, and -/// _mRC names row R, column C exactly as HLSL does. Use -/// for products; there is no * matrix product because HLSL's * is component-wise. +/// HLSL float3x3: row-major. Constructors take rows, m[i] is a writable reference to +/// row i (so m[1][2] = s works), and _mRC names row R, column C exactly as HLSL +/// does. Use for products; there is no * +/// matrix product because HLSL's * is component-wise. /// public struct float3x3 : IEquatable { public static readonly float3x3 identity = new(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f); public static readonly float3x3 zero = new(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f); - public float _m00; - public float _m01; - public float _m02; - public float _m10; - public float _m11; - public float _m12; - public float _m20; - public float _m21; - public float _m22; + private float3 _row0; + private float3 _row1; + private float3 _row2; public float3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) { - _m00 = m00; - _m01 = m01; - _m02 = m02; - _m10 = m10; - _m11 = m11; - _m12 = m12; - _m20 = m20; - _m21 = m21; - _m22 = m22; + _row0 = new float3(m00, m01, m02); + _row1 = new float3(m10, m11, m12); + _row2 = new float3(m20, m21, m22); } public float3x3(float3 row0, float3 row1, float3 row2) - : this(row0.x, row0.y, row0.z, row1.x, row1.y, row1.z, row2.x, row2.y, row2.z) { + _row0 = row0; + _row1 = row1; + _row2 = row2; } - public float3 this[int row] + public float _m00 { readonly get => _row0.x; set => _row0.x = value; } + public float _m01 { readonly get => _row0.y; set => _row0.y = value; } + public float _m02 { readonly get => _row0.z; set => _row0.z = value; } + public float _m10 { readonly get => _row1.x; set => _row1.x = value; } + public float _m11 { readonly get => _row1.y; set => _row1.y = value; } + public float _m12 { readonly get => _row1.z; set => _row1.z = value; } + public float _m20 { readonly get => _row2.x; set => _row2.x = value; } + public float _m21 { readonly get => _row2.y; set => _row2.y = value; } + public float _m22 { readonly get => _row2.z; set => _row2.z = value; } + + [UnscopedRef] + public ref float3 this[int row] { - readonly get => row switch - { - 0 => new float3(_m00, _m01, _m02), - 1 => new float3(_m10, _m11, _m12), - 2 => new float3(_m20, _m21, _m22), - _ => throw new ArgumentOutOfRangeException(nameof(row)), - }; - set + get { switch (row) { - case 0: _m00 = value.x; _m01 = value.y; _m02 = value.z; break; - case 1: _m10 = value.x; _m11 = value.y; _m12 = value.z; break; - case 2: _m20 = value.x; _m21 = value.y; _m22 = value.z; break; + case 0: return ref _row0; + case 1: return ref _row1; + case 2: return ref _row2; default: throw new ArgumentOutOfRangeException(nameof(row)); } } @@ -110,16 +106,10 @@ public struct float3x3 : IEquatable public static float3x3 Euler(float x, float y, float z, math.RotationOrder order = math.RotationOrder.Default) => Euler(new float3(x, y, z), order); - public readonly bool Equals(float3x3 other) => - _m00.Equals(other._m00) && _m01.Equals(other._m01) && _m02.Equals(other._m02) && - _m10.Equals(other._m10) && _m11.Equals(other._m11) && _m12.Equals(other._m12) && - _m20.Equals(other._m20) && _m21.Equals(other._m21) && _m22.Equals(other._m22); - + public readonly bool Equals(float3x3 other) => _row0.Equals(other._row0) && _row1.Equals(other._row1) && _row2.Equals(other._row2); public override readonly bool Equals(object? obj) => obj is float3x3 other && Equals(other); - - public override readonly int GetHashCode() => - HashCode.Combine(HashCode.Combine(_m00, _m01, _m02), HashCode.Combine(_m10, _m11, _m12), HashCode.Combine(_m20, _m21, _m22)); + public override readonly int GetHashCode() => HashCode.Combine(_row0, _row1, _row2); public override readonly string ToString() => - FormattableString.Invariant($"float3x3({_m00:R}, {_m01:R}, {_m02:R}, {_m10:R}, {_m11:R}, {_m12:R}, {_m20:R}, {_m21:R}, {_m22:R})"); + FormattableString.Invariant($"float3x3({_row0.x:R}, {_row0.y:R}, {_row0.z:R}, {_row1.x:R}, {_row1.y:R}, {_row1.z:R}, {_row2.x:R}, {_row2.y:R}, {_row2.z:R})"); } diff --git a/packages/cultmath/src/CultMath/float4.cs b/packages/cultmath/src/CultMath/float4.cs index d73175d8..3f647971 100644 --- a/packages/cultmath/src/CultMath/float4.cs +++ b/packages/cultmath/src/CultMath/float4.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct float4 : IEquatable +public partial struct float4 : IEquatable { public static readonly float4 zero = new(0.0f, 0.0f, 0.0f, 0.0f); public static readonly float4 one = new(1.0f, 1.0f, 1.0f, 1.0f); @@ -20,64 +20,6 @@ public struct float4 : IEquatable this.w = w; } - public float4(float2 xy, float z, float w) - : this(xy.x, xy.y, z, w) - { - } - - public float4(float3 xyz, float w) - : this(xyz.x, xyz.y, xyz.z, w) - { - } - - public float4(float x, float3 yzw) - : this(x, yzw.x, yzw.y, yzw.z) - { - } - - public float2 xy - { - readonly get => new(x, y); - set - { - x = value.x; - y = value.y; - } - } - - public float3 xyz - { - readonly get => new(x, y, z); - set - { - x = value.x; - y = value.y; - z = value.z; - } - } - - public float3 xyw - { - readonly get => new(x, y, w); - set - { - x = value.x; - y = value.y; - w = value.z; - } - } - - public float3 yzx - { - readonly get => new(y, z, x); - set - { - y = value.x; - z = value.y; - x = value.z; - } - } - public float this[int index] { readonly get => index switch diff --git a/packages/cultmath/src/CultMath/int2.cs b/packages/cultmath/src/CultMath/int2.cs index 06b4c4f6..f690a25d 100644 --- a/packages/cultmath/src/CultMath/int2.cs +++ b/packages/cultmath/src/CultMath/int2.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct int2 : IEquatable +public partial struct int2 : IEquatable { public static readonly int2 zero = new(0, 0); public static readonly int2 one = new(1, 1); diff --git a/packages/cultmath/src/CultMath/int3.cs b/packages/cultmath/src/CultMath/int3.cs index 60cbff29..454a8970 100644 --- a/packages/cultmath/src/CultMath/int3.cs +++ b/packages/cultmath/src/CultMath/int3.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct int3 : IEquatable +public partial struct int3 : IEquatable { public static readonly int3 zero = new(0, 0, 0); public static readonly int3 one = new(1, 1, 1); diff --git a/packages/cultmath/src/CultMath/int4.cs b/packages/cultmath/src/CultMath/int4.cs index 4c301203..caaaeb9e 100644 --- a/packages/cultmath/src/CultMath/int4.cs +++ b/packages/cultmath/src/CultMath/int4.cs @@ -2,7 +2,7 @@ using System; namespace CultMath; -public struct int4 : IEquatable +public partial struct int4 : IEquatable { public static readonly int4 zero = new(0, 0, 0, 0); public static readonly int4 one = new(1, 1, 1, 1); diff --git a/packages/cultmath/src/CultMath/math.cs b/packages/cultmath/src/CultMath/math.cs index 3bed477b..c51a2758 100644 --- a/packages/cultmath/src/CultMath/math.cs +++ b/packages/cultmath/src/CultMath/math.cs @@ -1,8 +1,8 @@ -using System; +using System; namespace CultMath; -public static class math +public static partial class math { public const float PI = MathF.PI; public const float TAU = MathF.PI * 2.0f; @@ -30,13 +30,10 @@ public static class math public static bool2 bool2(bool value) => new(value, value); public static int2 int2(int x, int y) => new(x, y); public static int2 int2(int value) => new(value, value); + // Mixed constructor functions (float4(float2, float2), ...) are generated in Swizzles.g.cs. public static float3 float3(float x, float y, float z) => new(x, y, z); - public static float3 float3(float2 xy, float z) => new(xy, z); public static float3 float3(float value) => new(value, value, value); public static float4 float4(float x, float y, float z, float w) => new(x, y, z, w); - public static float4 float4(float2 xy, float z, float w) => new(xy, z, w); - public static float4 float4(float3 xyz, float w) => new(xyz, w); - public static float4 float4(float x, float3 yzw) => new(x, yzw); public static float4 float4(float value) => new(value, value, value, value); public static bool3 bool3(bool x, bool y, bool z) => new(x, y, z); public static bool3 bool3(bool value) => new(value, value, value); @@ -79,11 +76,20 @@ public static class math public static float2 abs(float2 value) => new(abs(value.x), abs(value.y)); public static float3 abs(float3 value) => new(abs(value.x), abs(value.y), abs(value.z)); public static float4 abs(float4 value) => new(abs(value.x), abs(value.y), abs(value.z), abs(value.w)); + public static int abs(int value) => Math.Abs(value); + public static int2 abs(int2 value) => new(abs(value.x), abs(value.y)); + public static int3 abs(int3 value) => new(abs(value.x), abs(value.y), abs(value.z)); + public static int4 abs(int4 value) => new(abs(value.x), abs(value.y), abs(value.z), abs(value.w)); - public static float sign(float value) => MathF.Sign(value); - public static float2 sign(float2 value) => new(sign(value.x), sign(value.y)); - public static float3 sign(float3 value) => new(sign(value.x), sign(value.y), sign(value.z)); - public static float4 sign(float4 value) => new(sign(value.x), sign(value.y), sign(value.z), sign(value.w)); + // HLSL sign returns int. NaN compares false both ways, so it yields 0 instead of throwing. + public static int sign(float value) => value > 0.0f ? 1 : value < 0.0f ? -1 : 0; + public static int2 sign(float2 value) => new(sign(value.x), sign(value.y)); + public static int3 sign(float3 value) => new(sign(value.x), sign(value.y), sign(value.z)); + public static int4 sign(float4 value) => new(sign(value.x), sign(value.y), sign(value.z), sign(value.w)); + public static int sign(int value) => value > 0 ? 1 : value < 0 ? -1 : 0; + public static int2 sign(int2 value) => new(sign(value.x), sign(value.y)); + public static int3 sign(int3 value) => new(sign(value.x), sign(value.y), sign(value.z)); + public static int4 sign(int4 value) => new(sign(value.x), sign(value.y), sign(value.z), sign(value.w)); public static float floor(float value) => MathF.Floor(value); public static float2 floor(float2 value) => new(floor(value.x), floor(value.y)); @@ -105,12 +111,18 @@ public static class math public static float2 min(float2 left, float2 right) => new(min(left.x, right.x), min(left.y, right.y)); public static float3 min(float3 left, float3 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z)); public static float4 min(float4 left, float4 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z), min(left.w, right.w)); + public static int2 min(int2 left, int2 right) => new(min(left.x, right.x), min(left.y, right.y)); + public static int3 min(int3 left, int3 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z)); + public static int4 min(int4 left, int4 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z), min(left.w, right.w)); public static float max(float left, float right) => MathF.Max(left, right); public static int max(int left, int right) => Math.Max(left, right); public static float2 max(float2 left, float2 right) => new(max(left.x, right.x), max(left.y, right.y)); public static float3 max(float3 left, float3 right) => new(max(left.x, right.x), max(left.y, right.y), max(left.z, right.z)); public static float4 max(float4 left, float4 right) => new(max(left.x, right.x), max(left.y, right.y), max(left.z, right.z), max(left.w, right.w)); + public static int2 max(int2 left, int2 right) => new(max(left.x, right.x), max(left.y, right.y)); + public static int3 max(int3 left, int3 right) => new(max(left.x, right.x), max(left.y, right.y), max(left.z, right.z)); + public static int4 max(int4 left, int4 right) => new(max(left.x, right.x), max(left.y, right.y), max(left.z, right.z), max(left.w, right.w)); public static float clamp(float value, float minimum, float maximum) => min(max(value, minimum), maximum); public static float2 clamp(float2 value, float2 minimum, float2 maximum) => min(max(value, minimum), maximum); @@ -138,7 +150,8 @@ public static class math public static double2 unlerp(double2 start, double2 end, double2 value) => (value - start) / (end - start); public static double3 unlerp(double3 start, double3 end, double3 value) => (value - start) / (end - start); - public static float step(float edge, float value) => value < edge ? 0.0f : 1.0f; + // HLSL: step(y, x) = x >= y ? 1 : 0, so a NaN on either side yields 0. + public static float step(float edge, float value) => value >= edge ? 1.0f : 0.0f; public static float2 step(float2 edge, float2 value) => new(step(edge.x, value.x), step(edge.y, value.y)); public static float3 step(float3 edge, float3 value) => new(step(edge.x, value.x), step(edge.y, value.y), step(edge.z, value.z)); public static float4 step(float4 edge, float4 value) => new(step(edge.x, value.x), step(edge.y, value.y), step(edge.z, value.z), step(edge.w, value.w)); @@ -396,6 +409,20 @@ public static class math public static bool all(bool3 value) => value.x && value.y && value.z; public static bool all(bool4 value) => value.x && value.y && value.z && value.w; + // HLSL any/all on numeric vectors test components against zero (NaN != 0 counts as true). + public static bool any(float2 value) => value.x != 0.0f || value.y != 0.0f; + public static bool any(float3 value) => value.x != 0.0f || value.y != 0.0f || value.z != 0.0f; + public static bool any(float4 value) => value.x != 0.0f || value.y != 0.0f || value.z != 0.0f || value.w != 0.0f; + public static bool all(float2 value) => value.x != 0.0f && value.y != 0.0f; + public static bool all(float3 value) => value.x != 0.0f && value.y != 0.0f && value.z != 0.0f; + public static bool all(float4 value) => value.x != 0.0f && value.y != 0.0f && value.z != 0.0f && value.w != 0.0f; + public static bool any(int2 value) => value.x != 0 || value.y != 0; + public static bool any(int3 value) => value.x != 0 || value.y != 0 || value.z != 0; + public static bool any(int4 value) => value.x != 0 || value.y != 0 || value.z != 0 || value.w != 0; + public static bool all(int2 value) => value.x != 0 && value.y != 0; + public static bool all(int3 value) => value.x != 0 && value.y != 0 && value.z != 0; + public static bool all(int4 value) => value.x != 0 && value.y != 0 && value.z != 0 && value.w != 0; + // HLSL 2021 argument order: select(condition, whenTrue, whenFalse). // Unity.Mathematics' select(falseValue, trueValue, condition) is the reverse. public static float select(bool condition, float whenTrue, float whenFalse) => condition ? whenTrue : whenFalse; diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs index bdb41cbf..908f80b3 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs @@ -1,4 +1,4 @@ -using System.Text.Json; +using System.Text.Json; using Xunit; namespace CultMath.Tests; @@ -84,6 +84,93 @@ public sealed class HlslSemanticsTests Assert.Equal(new float4(9.0f, 7.0f, 8.0f, 4.0f), d); } + [Fact] + public void GeneratedSwizzlesCoverRepeatsColorNamesAndAllVectorFamilies() + { + var v = new float4(1.0f, 2.0f, 3.0f, 4.0f); + Assert.Equal(new float4(4.0f, 4.0f, 1.0f, 2.0f), v.wwxy); + Assert.Equal(new float3(3.0f, 2.0f, 1.0f), v.bgr); + Assert.Equal(4.0f, v.a); + Assert.Equal(new float4(2.0f, 2.0f, 2.0f, 2.0f), new float2(1.0f, 2.0f).yyyy); + + v.wx = new float2(9.0f, 8.0f); + Assert.Equal(new float4(8.0f, 2.0f, 3.0f, 9.0f), v); + v.r = 0.5f; + v.gb += new float2(1.0f, 1.0f); + Assert.Equal(new float4(0.5f, 3.0f, 4.0f, 9.0f), v); + + Assert.Equal(new int3(3, 1, 1), new int3(1, 2, 3).zxx); + Assert.Equal(new bool2(false, true), new bool4(true, false, false, true).zw); + Assert.Equal(new double2(2.0, 1.0), new double3(1.0, 2.0, 3.0).yx); + + var cell = new int4(1, 2, 3, 4); + cell.xyz = new int3(7, 8, 9); + Assert.Equal(new int4(7, 8, 9, 4), cell); + } + + [Fact] + public void MixedConstructorsMatchHlsl() + { + var xy = new float2(1.0f, 2.0f); + var zw = new float2(3.0f, 4.0f); + var expected = new float4(1.0f, 2.0f, 3.0f, 4.0f); + + Assert.Equal(expected, math.float4(xy, zw)); + Assert.Equal(expected, math.float4(1.0f, new float3(2.0f, 3.0f, 4.0f))); + Assert.Equal(expected, math.float4(new float3(1.0f, 2.0f, 3.0f), 4.0f)); + Assert.Equal(expected, math.float4(xy, 3.0f, 4.0f)); + Assert.Equal(expected, math.float4(1.0f, 2.0f, zw)); + Assert.Equal(expected, math.float4(1.0f, new float2(2.0f, 3.0f), 4.0f)); + Assert.Equal(expected, new float4(xy, zw)); + Assert.Equal(new float3(1.0f, 2.0f, 3.0f), math.float3(1.0f, zw - 1.0f)); + Assert.Equal(new int4(1, 2, 3, 4), math.int4(new int2(1, 2), new int2(3, 4))); + Assert.Equal(new bool3(true, false, true), math.bool3(true, new bool2(false, true))); + Assert.Equal(new double3(1.0, 2.0, 3.0), new double3(new double2(1.0, 2.0), 3.0)); + } + + [Fact] + public void MatrixRowElementsAreWritable() + { + var m = float3x3.identity; + m[1][2] = 5.0f; + m[2].x = 7.0f; + m._m00 = 2.0f; + + Assert.Equal(5.0f, m._m12); + Assert.Equal(7.0f, m._m20); + Assert.Equal(math.float3x3(2.0f, 0.0f, 0.0f, 0.0f, 1.0f, 5.0f, 7.0f, 0.0f, 1.0f), m); + Assert.Equal(float3x3.identity, math.float3x3(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f)); + + var r = float2x2.identity; + r[0][1] = 3.0f; + Assert.Equal(math.float2x2(1.0f, 3.0f, 0.0f, 1.0f), r); + Assert.Equal(new float2(0.0f, 1.0f), float2x2.identity[1]); + } + + [Fact] + public void IntrinsicEdgeCasesFollowHlsl() + { + Assert.True(math.any(new float3(0.0f, 0.0f, -2.0f))); + Assert.False(math.any(float4.zero)); + Assert.True(math.all(new int2(1, -1))); + Assert.False(math.all(new int3(1, 0, 1))); + Assert.True(math.any(new float2(float.NaN, 0.0f))); + + Assert.Equal(new int3(1, 2, 3), math.min(new int3(1, 5, 3), new int3(4, 2, 6))); + Assert.Equal(new int2(4, 5), math.max(new int2(1, 5), new int2(4, 2))); + Assert.Equal(new int4(1, 2, 0, 3), math.abs(new int4(-1, 2, 0, -3))); + Assert.Equal(7, math.abs(-7)); + + Assert.Equal(0.0f, math.step(1.0f, float.NaN)); + Assert.Equal(0.0f, math.step(float.NaN, 1.0f)); + Assert.Equal(1.0f, math.step(1.0f, 1.0f)); + + Assert.Equal(0, math.sign(float.NaN)); + Assert.Equal(-1, math.sign(-0.5f)); + Assert.Equal(new int3(-1, 0, 1), math.sign(new float3(-2.0f, 0.0f, 4.0f))); + Assert.Equal(new int2(1, -1), math.sign(new int2(9, -9))); + } + [Fact] public void ComparisonOperatorsReturnComponentWiseBoolVectors() { diff --git a/packages/cultmath/tests/CultMath.Tests/MathTests.cs b/packages/cultmath/tests/CultMath.Tests/MathTests.cs index 956bea08..de1bf996 100644 --- a/packages/cultmath/tests/CultMath.Tests/MathTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/MathTests.cs @@ -170,10 +170,10 @@ public sealed class MathTests [Fact] public void SignIsComponentWiseForSimulationVectors() { - Assert.Equal(-1.0f, math.sign(-12.0f)); - Assert.Equal(0.0f, math.sign(0.0f)); - Assert.Equal(1.0f, math.sign(12.0f)); - Assert.Equal(new float3(-1.0f, 0.0f, 1.0f), math.sign(new float3(-2.0f, 0.0f, 4.0f))); + Assert.Equal(-1, math.sign(-12.0f)); + Assert.Equal(0, math.sign(0.0f)); + Assert.Equal(1, math.sign(12.0f)); + Assert.Equal(new int3(-1, 0, 1), math.sign(new float3(-2.0f, 0.0f, 4.0f))); } [Fact] diff --git a/packages/cultmath/tools/generate-swizzles.ps1 b/packages/cultmath/tools/generate-swizzles.ps1 new file mode 100644 index 00000000..9030f2be --- /dev/null +++ b/packages/cultmath/tools/generate-swizzles.ps1 @@ -0,0 +1,132 @@ +param( + [string]$OutputPath = "" +) + +# Writes src\CultMath\Swizzles.g.cs: HLSL swizzles and mixed constructors for +# CultMath's vector types. The output is checked in; rerun after changing the +# family table below and commit both files together. + +$ErrorActionPreference = "Stop" + +if (-not $OutputPath) { + $OutputPath = Join-Path $PSScriptRoot "..\src\CultMath\Swizzles.g.cs" +} + +# Functions: emit math.(...) constructor functions. double has none because +# a math.double3 method group would hide the double3 type name under +# `using static CultMath.math;` and HLSL shader code does not construct doubles. +$families = @( + @{ Scalar = "float"; Sizes = @(2, 3, 4); Functions = $true }, + @{ Scalar = "int"; Sizes = @(2, 3, 4); Functions = $true }, + @{ Scalar = "bool"; Sizes = @(2, 3, 4); Functions = $true }, + @{ Scalar = "double"; Sizes = @(2, 3); Functions = $false } +) +$componentFields = @("x", "y", "z", "w") +$namings = @(@("x", "y", "z", "w"), @("r", "g", "b", "a")) + +function Get-Compositions([int]$total) { + # Ordered part sizes summing to $total, excluding the all-scalar form that the + # hand-written base constructor already owns. + $results = [System.Collections.Generic.List[object]]::new() + function Expand([int]$remaining, [int[]]$prefix) { + if ($remaining -eq 0) { + if (@($prefix | Where-Object { $_ -ne 1 }).Count -gt 0) { + $results.Add($prefix) + } + return + } + for ($part = 1; $part -le $remaining; $part++) { + Expand ($remaining - $part) ($prefix + $part) + } + } + Expand $total @() + return , $results +} + +$builder = [System.Text.StringBuilder]::new() +function Line([string]$text = "") { [void]$builder.Append($text).Append("`n") } + +Line "// " +Line "// Generated by tools/generate-swizzles.ps1. Do not edit by hand." +Line "// " +Line "" +Line "namespace CultMath;" + +$functionLines = [System.Collections.Generic.List[string]]::new() + +foreach ($family in $families) { + $scalar = $family.Scalar + $maxSize = ($family.Sizes | Measure-Object -Maximum).Maximum + foreach ($size in $family.Sizes) { + $type = "$scalar$size" + Line "" + Line "public partial struct $type" + Line "{" + + foreach ($composition in (Get-Compositions $size)) { + $parameters = @() + $arguments = @() + $offset = 0 + foreach ($part in $composition) { + $name = -join $componentFields[$offset..($offset + $part - 1)] + if ($part -eq 1) { + $parameters += "$scalar $name" + $arguments += $name + } else { + $parameters += "$scalar$part $name" + for ($i = 0; $i -lt $part; $i++) { $arguments += "$name.$($componentFields[$i])" } + } + $offset += $part + } + $parameterList = $parameters -join ", " + Line " public $type($parameterList) : this($($arguments -join ', ')) { }" + if ($family.Functions) { + $names = @($parameters | ForEach-Object { ($_ -split " ")[1] }) + $functionLines.Add(" public static $type $type($parameterList) => new($($names -join ', '));") + } + } + + # Single-component color aliases; x/y/z/w are the fields themselves. + $letters = $namings[1] + for ($i = 0; $i -lt $size; $i++) { + Line " public $scalar $($letters[$i]) { readonly get => $($componentFields[$i]); set => $($componentFields[$i]) = value; }" + } + + foreach ($letters in $namings) { + for ($length = 2; $length -le $maxSize; $length++) { + $count = [math]::Pow($size, $length) + for ($index = 0; $index -lt $count; $index++) { + [int[]]$digits = @() + [int]$remainder = $index + for ($d = 0; $d -lt $length; $d++) { + $digits = @([int]($remainder % $size)) + $digits + $remainder = [int][math]::Floor($remainder / $size) + } + $name = -join ($digits | ForEach-Object { $letters[$_] }) + $getter = ($digits | ForEach-Object { $componentFields[$_] }) -join ", " + $resultType = "$scalar$length" + $unique = @($digits | Select-Object -Unique).Count -eq $length + if ($unique) { + $assignments = for ($d = 0; $d -lt $length; $d++) { "$($componentFields[$digits[$d]]) = value.$($componentFields[$d]);" } + Line " public $resultType $name { readonly get => new($getter); set { $($assignments -join ' ') } }" + } else { + Line " public readonly $resultType $name => new($getter);" + } + } + } + } + + Line "}" + } +} + +Line "" +Line "public static partial class math" +Line "{" +foreach ($functionLine in $functionLines) { Line $functionLine } +Line "}" + +$fullPath = [System.IO.Path]::GetFullPath($OutputPath) +$content = $builder.ToString() -replace "`n", "`r`n" +[System.IO.File]::WriteAllText($fullPath, $content, [System.Text.UTF8Encoding]::new($false)) +Write-Host "Wrote $fullPath ($((Get-Item -LiteralPath $fullPath).Length) bytes)" diff --git a/packages/cultmath/tools/generate-swizzles.ps1.meta b/packages/cultmath/tools/generate-swizzles.ps1.meta new file mode 100644 index 00000000..74842405 --- /dev/null +++ b/packages/cultmath/tools/generate-swizzles.ps1.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: d7a796fd2d87489c9f055fd6e73513b5 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: From 360176a7dab2c2e0e97845d5db2614b4513bf3f4 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:57:03 +0200 Subject: [PATCH 06/20] Compile the real HLSL mirror as C# and with dxc; fix its errors HlslSourceCompatibilityTests now reads shaders/CultMath.hlsl, applies only the documented transformations (drop include guards, drop Texture2D/ SamplerState functions, file-scope static const -> const, f literal suffixes, wrap in a class), and compiles it with Roslyn against CultMath. Any compile error fails the test (probed with an undeclared call). The compiled cultmath_snoise(float3/float2) also matches math.snoise. dxc -T lib_6_3 -HV 2021 rejected the mirror: cultmath_snoise(float2) called the undeclared cultmath_simplex_mod289/permute. Renamed to the declared cultmath_snoise_* helpers. Vector const locals became plain locals (C# const is primitives only), and cultmath_step uses value >= edge like HLSL step and the C# mirror. dxc 1.9.0.5402 now compiles the file cleanly. The Unity package's Shaders copy is synced. Co-Authored-By: Claude Opus 5 --- packages/cultmath/shaders/CultMath.hlsl | 12 +- .../CultMath.Tests/CultMath.Tests.csproj | 1 + .../HlslSourceCompatibilityTests.cs | 155 +++++++++++++----- .../Shaders/CultMath.hlsl | 12 +- 4 files changed, 125 insertions(+), 55 deletions(-) diff --git a/packages/cultmath/shaders/CultMath.hlsl b/packages/cultmath/shaders/CultMath.hlsl index f3c398d6..632bb94f 100644 --- a/packages/cultmath/shaders/CultMath.hlsl +++ b/packages/cultmath/shaders/CultMath.hlsl @@ -36,7 +36,7 @@ float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + ( float3 cultmath_lerp(float3 start, float3 end, float3 amount) { return start + (end - start) * amount; } float4 cultmath_lerp(float4 start, float4 end, float4 amount) { return start + (end - start) * amount; } -float cultmath_step(float edge, float value) { return value < edge ? 0.0 : 1.0; } +float cultmath_step(float edge, float value) { return value >= edge ? 1.0 : 0.0; } float2 cultmath_step(float2 edge, float2 value) { return float2(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y)); } float3 cultmath_step(float3 edge, float3 value) { return float3(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z)); } float4 cultmath_step(float4 edge, float4 value) { return float4(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z), cultmath_step(edge.w, value.w)); } @@ -83,7 +83,7 @@ float4 cultmath_snoise_permute(float4 value) { return cultmath_snoise_mod289(((v // order as the C# math.snoise(float3) mirror. float cultmath_snoise(float3 value) { - const float2 c = float2(1.0 / 6.0, 1.0 / 3.0); + float2 c = float2(1.0 / 6.0, 1.0 / 3.0); float3 i = floor(value + dot(value, c.yyy)); float3 x0 = value - i + dot(i, c.xxx); float3 g = step(x0.yzx, x0.xyz); @@ -132,7 +132,7 @@ float cultmath_snoise(float3 value) float cultmath_snoise(float2 value) { - const float4 c = float4( + float4 c = float4( 0.211324865405187, 0.366025403784439, -0.577350269189626, @@ -142,9 +142,9 @@ float cultmath_snoise(float2 value) float2 i1 = x0.x > x0.y ? float2(1.0, 0.0) : float2(0.0, 1.0); float4 x12 = float4(x0.x + c.x - i1.x, x0.y + c.x - i1.y, x0.x + c.z, x0.y + c.z); - i = cultmath_simplex_mod289(i); - float3 p = cultmath_simplex_permute( - cultmath_simplex_permute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0)); + i = cultmath_snoise_mod289(i); + float3 p = cultmath_snoise_permute( + cultmath_snoise_permute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0)); float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0); m *= m; m *= m; diff --git a/packages/cultmath/tests/CultMath.Tests/CultMath.Tests.csproj b/packages/cultmath/tests/CultMath.Tests/CultMath.Tests.csproj index 1e77eba1..d77fd05f 100644 --- a/packages/cultmath/tests/CultMath.Tests/CultMath.Tests.csproj +++ b/packages/cultmath/tests/CultMath.Tests/CultMath.Tests.csproj @@ -8,6 +8,7 @@ + diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs index 575952c3..3c5aae94 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -1,16 +1,111 @@ -using Xunit; +using System.Reflection; +using System.Text.RegularExpressions; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Xunit; using static CultMath.math; namespace CultMath.Tests; /// -/// HLSL written against CultMath compiles as C# under using static CultMath.math;. -/// The only spelling C# forces is float literal suffixes (0.5f): an unsuffixed -/// literal is a double in C#. +/// The real shader mirror, shaders/CultMath.hlsl, compiles as C# against CultMath under +/// using static CultMath.math; after exactly the source transformations listed in +/// docs/design.md (HLSL Target: Source Transformations). is +/// that list in code; if a body needs anything else, this test fails. /// public sealed class HlslSourceCompatibilityTests { - // ---- HLSL-shaped source: keep this block free of C#-only constructs. ---- + [Fact] + public void ShaderMirrorBodiesCompileAsCSharp() + { + var (assembly, errors) = CompileShaderMirror(); + Assert.True(assembly is not null, "HLSL mirror did not compile as C#:" + Environment.NewLine + string.Join(Environment.NewLine, errors)); + + var shader = assembly!.GetType("CultMathHlsl.HlslShader")!; + Assert.NotNull(ShaderFunction(shader, "cultmath_snoise", typeof(float3))); + Assert.NotNull(ShaderFunction(shader, "cultmath_snoise", typeof(float2))); + Assert.NotNull(ShaderFunction(shader, "cultmath_value_noise_bicubic", typeof(float2))); + } + + // HLSL functions carry no access modifier, so they compile as private instance methods. + private static MethodInfo? ShaderFunction(Type shader, string name, params Type[] parameters) => + shader.GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic, null, parameters, null); + + [Theory] + [InlineData(0.0f, 0.0f, 0.0f)] + [InlineData(0.25f, -0.5f, 1.75f)] + [InlineData(12.25f, -4.5f, 3.125f)] + [InlineData(-7.3f, 2.9f, 101.4f)] + public void CompiledShaderNoiseMatchesCSharpMirror(float x, float y, float z) + { + var (assembly, errors) = CompileShaderMirror(); + Assert.True(assembly is not null, string.Join(Environment.NewLine, errors)); + var shaderType = assembly!.GetType("CultMathHlsl.HlslShader")!; + var shader = Activator.CreateInstance(shaderType); + + var snoise3 = (float)ShaderFunction(shaderType, "cultmath_snoise", typeof(float3))!.Invoke(shader, new object[] { float3(x, y, z) })!; + var snoise2 = (float)ShaderFunction(shaderType, "cultmath_snoise", typeof(float2))!.Invoke(shader, new object[] { float2(x, y) })!; + + Assert.Equal(snoise(float3(x, y, z)), snoise3, precision: 6); + Assert.Equal(snoise(float2(x, y)), snoise2, precision: 6); + } + + /// The documented HLSL-to-C# transformations, and nothing else. + internal static string TransformHlslToCSharp(string hlsl) + { + // 1. Include guards (#ifndef/#define/#endif) are dropped; C# has no textual include. + var source = Regex.Replace(hlsl, @"(?m)^\s*#(ifndef|define|endif)\b.*$", string.Empty); + + // 2. Functions taking Texture2D/SamplerState resources are dropped; GPU resources have + // no CultMath analog. + source = Regex.Replace(source, @"(?ms)^\w+ \w+\([^)]*\b(Texture2D|SamplerState)\b[^)]*\)\s*\{.*?^\}[ \t]*\r?$", string.Empty); + + // 3. File-scope `static const` becomes `const` (C# consts are implicitly static). + source = Regex.Replace(source, @"(?m)^static const ", "const "); + + // 4. Floating literals gain the `f` suffix; an unsuffixed C# literal is a double. + source = Regex.Replace(source, @"(? Errors) CompileShaderMirror() + { + var hlsl = File.ReadAllText(Path.Combine(FindCultMathRoot(), "shaders", "CultMath.hlsl")); + var tree = CSharpSyntaxTree.ParseText(TransformHlslToCSharp(hlsl)); + var references = ((string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES")!) + .Split(Path.PathSeparator) + .Append(typeof(math).Assembly.Location) + .Distinct(StringComparer.OrdinalIgnoreCase) + .Select(path => MetadataReference.CreateFromFile(path)); + var compilation = CSharpCompilation.Create( + "CultMathHlslMirror", + new[] { tree }, + references, + new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); + + using var stream = new MemoryStream(); + var result = compilation.Emit(stream); + var errors = result.Diagnostics + .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error) + .Select(diagnostic => diagnostic.ToString()) + .ToList(); + return (result.Success ? Assembly.Load(stream.ToArray()) : null, errors); + } + + private static string FindCultMathRoot() + { + var directory = new DirectoryInfo(AppContext.BaseDirectory); + while (directory is not null && !File.Exists(Path.Combine(directory.FullName, "packages", "cultmath", "shaders", "CultMath.hlsl"))) + { + directory = directory.Parent; + } + + return Path.Combine(directory?.FullName ?? throw new InvalidOperationException("CultMath package root not found."), "packages", "cultmath"); + } + + // ---- Hand-written HLSL-shaped host code: swizzles, mixed constructors, matrix rows. ---- static float3 shade(float3 position, float3 normal, float2 wind, float time) { float3 p = position; @@ -18,19 +113,20 @@ public sealed class HlslSourceCompatibilityTests p.y = saturate(p.y); float3x3 basis = float3x3(float3(1, 0, 0), float3(0, 1, 0), float3(0, 0, 1)); + basis[1][1] = 1.0f; float3 n = normalize(mul(basis, normal)); float ndotl = saturate(dot(n, normalize(float3(0.3f, 1, 0.2f)))); - float3 color = lerp(float3(0.1f, 0.1f, 0.2f), float3(1, 0.9f, 0.7f), ndotl); + float4 color = float4(lerp(float3(0.1f, 0.1f, 0.2f), float3(1, 0.9f, 0.7f), ndotl), 1); if (any(p < 0.0f)) - color *= 0.5f; + color.rgb *= 0.5f; if (all(abs(n) <= 1.0f)) - color.yzx = color.yzx * float3(1, 1, 1); + color.bgr = color.bgr * float3(1, 1, 1); - color = select(p > 10.0f, float3(0), color); + color.rgb = select(p > 10.0f, float3(0), color.rgb); float2 uv = frac(p.xz * 0.25f); - color.xy = lerp(color.xy, uv, 0.1f); - return color; + color.rg = lerp(color.rg, uv, 0.1f); + return float4(color.xy, color.zw).xyz; } static float2 steer(float2 direction, float torque) @@ -40,46 +136,19 @@ public sealed class HlslSourceCompatibilityTests return normalize(turned) * pow(length(turned), 1.0f); } - static float fbm(float3 p, int octaves) - { - float sum = 0.0f; - float amp = 0.5f; - float freq = 1.0f; - for (int i = 0; i < octaves; i++) - { - sum += abs(snoise(p * freq)) * amp; - freq *= 2.0f; - amp *= 0.5f; - } - return sum; - } - // ---- end HLSL-shaped source ---- - [Fact] - public void ShaderStyleMathCompilesAndEvaluates() + public void HandWrittenShaderStyleMathEvaluates() { - var color = shade(new float3(1.0f, 0.5f, 2.0f), new float3(0.0f, 1.0f, 0.0f), new float2(1.0f, 0.0f), 0.0f); - + var color = shade(float3(1.0f, 0.5f, 2.0f), float3(0.0f, 1.0f, 0.0f), float2(1.0f, 0.0f), 0.0f); Assert.True(color.x > 0.1f && color.x <= 1.0f); Assert.True(float.IsFinite(color.y) && float.IsFinite(color.z)); - var far = shade(new float3(20.0f, 20.0f, 20.0f), new float3(0.0f, 1.0f, 0.0f), float2(0.0f), 0.0f); + var far = shade(float3(20.0f, 20.0f, 20.0f), float3(0.0f, 1.0f, 0.0f), float2(0.0f), 0.0f); Assert.Equal(0.0f, far.z); - } - - [Fact] - public void AetheriaStyleRotationAndNoiseCompile() - { - var steered = steer(new float2(1.0f, 0.0f), 0.5f); - var viaRotate = mul(new float2(1.0f, 0.0f), CultMath.float2x2.Rotate(0.5f)); + var steered = steer(float2(1.0f, 0.0f), 0.5f); + var viaRotate = mul(float2(1.0f, 0.0f), CultMath.float2x2.Rotate(0.5f)); Assert.Equal(viaRotate.x, steered.x, precision: 5); Assert.Equal(viaRotate.y, steered.y, precision: 5); - - var view = mul(float3(0, 0, 1), CultMath.float3x3.Euler(float3(float2(0.3f, -1.1f).yx, 0), RotationOrder.YXZ)); - Assert.Equal(1.0f, length(view), precision: 5); - - var noise = fbm(float3(1.5f, -2.25f, 0.75f), 4); - Assert.InRange(noise, 0.0f, 1.0f); } } diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl index f3c398d6..632bb94f 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl +++ b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl @@ -36,7 +36,7 @@ float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + ( float3 cultmath_lerp(float3 start, float3 end, float3 amount) { return start + (end - start) * amount; } float4 cultmath_lerp(float4 start, float4 end, float4 amount) { return start + (end - start) * amount; } -float cultmath_step(float edge, float value) { return value < edge ? 0.0 : 1.0; } +float cultmath_step(float edge, float value) { return value >= edge ? 1.0 : 0.0; } float2 cultmath_step(float2 edge, float2 value) { return float2(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y)); } float3 cultmath_step(float3 edge, float3 value) { return float3(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z)); } float4 cultmath_step(float4 edge, float4 value) { return float4(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z), cultmath_step(edge.w, value.w)); } @@ -83,7 +83,7 @@ float4 cultmath_snoise_permute(float4 value) { return cultmath_snoise_mod289(((v // order as the C# math.snoise(float3) mirror. float cultmath_snoise(float3 value) { - const float2 c = float2(1.0 / 6.0, 1.0 / 3.0); + float2 c = float2(1.0 / 6.0, 1.0 / 3.0); float3 i = floor(value + dot(value, c.yyy)); float3 x0 = value - i + dot(i, c.xxx); float3 g = step(x0.yzx, x0.xyz); @@ -132,7 +132,7 @@ float cultmath_snoise(float3 value) float cultmath_snoise(float2 value) { - const float4 c = float4( + float4 c = float4( 0.211324865405187, 0.366025403784439, -0.577350269189626, @@ -142,9 +142,9 @@ float cultmath_snoise(float2 value) float2 i1 = x0.x > x0.y ? float2(1.0, 0.0) : float2(0.0, 1.0); float4 x12 = float4(x0.x + c.x - i1.x, x0.y + c.x - i1.y, x0.x + c.z, x0.y + c.z); - i = cultmath_simplex_mod289(i); - float3 p = cultmath_simplex_permute( - cultmath_simplex_permute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0)); + i = cultmath_snoise_mod289(i); + float3 p = cultmath_snoise_permute( + cultmath_snoise_permute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0)); float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0); m *= m; m *= m; From 88eb365c05a6dfc84ad2a26df8ab21ee92ce471d Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:57:03 +0200 Subject: [PATCH 07/20] Check bridge declarations, not file names; strip manifest BOMs build-unity-package.ps1 read the bridge's file names to decide whether it re-declared core CultMath sources. It now parses declarations: core type names come from src/CultMath (comments stripped), and every bridge source may declare types only in CultMath.UnityBridge and never a core type name. Probed by injecting "struct float3" into UnityConversions.cs: the script throws. Strips the UTF-8 BOMs this branch added to both Unity package.json files. Co-Authored-By: Claude Opus 5 --- .../cultmath/scripts/build-unity-package.ps1 | 31 +++++++++++++++---- .../unity/org.gamecult.cultmath/package.json | 2 +- .../Assets/Caching/package.json | 2 +- 3 files changed, 27 insertions(+), 8 deletions(-) diff --git a/packages/cultmath/scripts/build-unity-package.ps1 b/packages/cultmath/scripts/build-unity-package.ps1 index 7bc3da7c..7db1fbda 100644 --- a/packages/cultmath/scripts/build-unity-package.ps1 +++ b/packages/cultmath/scripts/build-unity-package.ps1 @@ -110,13 +110,32 @@ foreach ($pair in @(@($freshAssembly, $trackedAssembly), @($freshSymbols, $track } } -$coreSourceNames = @(Get-ChildItem -LiteralPath (Join-Path $repoRoot "src\CultMath") -File -Filter "*.cs" | ForEach-Object Name) $trackedSourceFiles = @(Get-ChildItem -LiteralPath $templateRoot -Recurse -File -Filter "*.cs") -$strayOrCoreSources = @($trackedSourceFiles | Where-Object { - $_.DirectoryName -ne $bridgeRoot -or $coreSourceNames -contains $_.Name -}) -if ($trackedSourceFiles.Count -eq 0 -or $strayOrCoreSources.Count -ne 0) { - throw "CultMath Unity package may compile only bridge sources under Runtime\UnityBridge, never core sources: $($strayOrCoreSources.FullName -join ', ')" +$straySources = @($trackedSourceFiles | Where-Object { $_.DirectoryName -ne $bridgeRoot }) +if ($trackedSourceFiles.Count -eq 0 -or $straySources.Count -ne 0) { + throw "CultMath Unity package may compile only bridge sources under Runtime\UnityBridge: $($straySources.FullName -join ', ')" +} + +# Check what the bridge declares, not what its files are called: it may declare types only in +# CultMath.UnityBridge and never a type name the core CultMath sources declare. +$declarationPattern = '\b(?:struct|class|enum|interface|record|delegate\s+[\w<>.,\s]+?)\s+(\w+)' +function Get-CodeWithoutComments([string]$path) { + $text = Get-Content -LiteralPath $path -Raw + return [regex]::Replace($text, '(?s)/\*.*?\*/|//[^\r\n]*', '') +} +$coreTypeNames = @(Get-ChildItem -LiteralPath (Join-Path $repoRoot "src\CultMath") -File -Filter "*.cs" | ForEach-Object { + [regex]::Matches((Get-CodeWithoutComments $_.FullName), $declarationPattern) | ForEach-Object { $_.Groups[1].Value } +} | Sort-Object -Unique) +if ($coreTypeNames -notcontains "float3" -or $coreTypeNames -notcontains "math") { + throw "Could not read CultMath core type declarations; the bridge check would be vacuous" +} +foreach ($source in $trackedSourceFiles) { + $code = Get-CodeWithoutComments $source.FullName + $redeclared = @([regex]::Matches($code, $declarationPattern) | ForEach-Object { $_.Groups[1].Value } | Where-Object { $coreTypeNames -contains $_ }) + $foreignNamespaces = @([regex]::Matches($code, '\bnamespace\s+([\w.]+)') | ForEach-Object { $_.Groups[1].Value } | Where-Object { $_ -ne "CultMath.UnityBridge" }) + if ($redeclared.Count -ne 0 -or $foreignNamespaces.Count -ne 0) { + throw "CultMath.UnityBridge source $($source.Name) re-declares core types [$($redeclared -join ', ')] or uses namespaces [$($foreignNamespaces -join ', ')]; the precompiled DLL owns CultMath's types" + } } New-Item -ItemType Directory -Force -Path $outputRoot | Out-Null diff --git a/packages/cultmath/unity/org.gamecult.cultmath/package.json b/packages/cultmath/unity/org.gamecult.cultmath/package.json index 302eb481..c09bf6bb 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/package.json +++ b/packages/cultmath/unity/org.gamecult.cultmath/package.json @@ -1,4 +1,4 @@ -{ +{ "name": "org.gamecult.cultmath", "displayName": "CultMath", "version": "0.2.0", diff --git a/src/GameCult.Unity/Assets/Caching/package.json b/src/GameCult.Unity/Assets/Caching/package.json index 560600a9..9f3df603 100644 --- a/src/GameCult.Unity/Assets/Caching/package.json +++ b/src/GameCult.Unity/Assets/Caching/package.json @@ -1,4 +1,4 @@ -{ +{ "name": "org.gamecult.caching.unity", "displayName": "GameCult CultCache Unity Tools", "version": "1.1.0", From 7a1bd1ebb14ae9fcc7e7a8bf72980f5db1b4c999 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:57:03 +0200 Subject: [PATCH 08/20] Document the full HLSL target and its source transformations design.md states the generated swizzle and mixed-constructor surface, writable matrix rows, HLSL intrinsic types and NaN behavior, the deferred matrix items (float4x4, transpose, determinant, _11 names), the exact HLSL-to-C# transformations the compatibility test applies, and the dxc check. Co-Authored-By: Claude Opus 5 --- packages/cultmath/README.md | 4 ++- packages/cultmath/docs/design.md | 57 ++++++++++++++++++++++++++++---- 2 files changed, 53 insertions(+), 8 deletions(-) diff --git a/packages/cultmath/README.md b/packages/cultmath/README.md index 8fd3888c..0be46738 100644 --- a/packages/cultmath/README.md +++ b/packages/cultmath/README.md @@ -16,7 +16,9 @@ shader semantics. - `float2`, `float3`, `float4` - component-wise arithmetic - scalar-to-vector splats -- swizzles for common lanes +- every HLSL swizzle (`xyzw` and `rgba`, repeats readable, non-repeating + masks writable) and every HLSL mixed constructor, generated by + `tools/generate-swizzles.ps1` - conversions to and from `System.Numerics` - `Random`, a compact deterministic XORShift stream with scalar and vector draws - `BatchMath` SoA kernels over `Span` / `ReadOnlySpan` using diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index da28079f..a2ce5e33 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -12,20 +12,63 @@ rest of the spelling should survive the move. That makes these HLSL rules, not options: -- Components and swizzles are writable. `v.xz = f2;` and `v[1] = s;` work. - Swizzle setters exist only for non-repeating masks, because HLSL rejects - `v.xx = ...`. +- Every swizzle exists. `float2/3/4`, `int2/3/4`, and `bool2/3/4` expose every + read swizzle of length 2 to 4, repeats included (`v.wwxy`), in both `xyzw` and + `rgba` naming (never mixed), plus single-component `r/g/b/a`. `double2/3` get + lengths 2 and 3 only, because there is no `double4`. Components and swizzles are + writable: `v.xz = f2;`, `c.rgb *= 0.5f;`, and `v[1] = s;` work. Setters exist + only for non-repeating masks, because HLSL rejects `v.xx = ...`. +- Every HLSL mixed constructor exists, as a struct constructor and as a `math` + function: `float4(float2, float2)`, `float4(float, float2, float)`, + `float3(float, float2)`, the copy form `float3(float3)`, and the rest, for the + float, int, and bool families (double gets constructors only; a `math.double3` + function would hide the `double3` type name). +- Swizzles and mixed constructors are generated. `tools/generate-swizzles.ps1` + writes the checked-in `src/CultMath/Swizzles.g.cs` (partial structs plus a + partial `math`). Edit the generator, rerun it, and commit both; never edit the + output by hand. - Comparison operators (`<`, `>`, `<=`, `>=`, `==`, `!=`) are component-wise and return `bool2`/`bool3`/`bool4`. Reduce them with `any` and `all`. `Equals`/`GetHashCode` stay value-based so vectors still work as dictionary keys. - `select(condition, whenTrue, whenFalse)` uses HLSL's argument order. -- Matrices are row-major: constructors take rows, `m[i]` is row i, `_mRC` is - row R column C, and products go through `mul` (`mul(m, v)` treats `v` as a - column, `mul(v, m)` as a row). `*` on matrices would be component-wise in HLSL, - so CultMath does not define it. +- Matrices are row-major: constructors take rows, `m[i]` returns a reference to + row i (so `m[1][2] = s;` writes one element), `_mRC` is row R column C, and + products go through `mul` (`mul(m, v)` treats `v` as a column, `mul(v, m)` as a + row). `*` on matrices would be component-wise in HLSL, so CultMath does not + define it. - Scalar/vector arithmetic and comparisons have explicit overloads on both sides rather than leaning on implicit scalar splat. +- Intrinsics return HLSL's types and edge cases: `sign` returns `int`/`intN` + (NaN gives 0); `step(y, x)` is `x >= y ? 1 : 0` (NaN gives 0), in C# and in the + HLSL mirror; `any`/`all` accept numeric vectors (a component is true when it is + not 0); `min`, `max`, and `abs` on int vectors return int vectors. + +Deferred until a consumer needs them: `float4x4`, `transpose`, `determinant`, +and HLSL's one-based `_11`..`_33` element names. + +### HLSL Target: Source Transformations + +`HlslSourceCompatibilityTests` compiles the real `shaders/CultMath.hlsl` with +Roslyn against CultMath. These transformations are the complete list; if a body +needs anything else, the test fails: + +1. Include guards (`#ifndef`/`#define`/`#endif`) are dropped. +2. Functions taking `Texture2D`/`SamplerState` are dropped; GPU resources have + no CultMath analog. +3. File-scope `static const` becomes `const`. +4. Floating literals gain `f` (`0.5` becomes `0.5f`). +5. The file body is wrapped in a class, since C# has no free functions; HLSL + functions become private instance methods. + +HLSL constructs that stay outside the target and must not appear in the mirror: +`const` locals of vector type (C# `const` is primitives only; write a plain +local) and writes through a swizzle component (`v.xy.x = s`, which C# rejects as +modifying a temporary). + +The HLSL side is checked too: `tools/get-dxc.ps1` fetches Microsoft's +DirectXShaderCompiler, and +`dxc -T lib_6_3 -HV 2021 shaders/CultMath.hlsl` must compile cleanly. Where HLSL is silent, CultMath keeps its own decisions and does not defer to Unity.Mathematics: `normalize` is safe (divides by `max(length, 1e-20)`), From 10b2c15fb8e966dd9d0a324dfab6027443ef51fe Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 13:57:03 +0200 Subject: [PATCH 09/20] Rebuild the CultMath 0.2.0 Unity DLL with the generated surface Fresh deterministic netstandard2.1 build from the CRLF working copy a checkout produces; build-unity-package.ps1 byte check passes. The DLL grows from 66,048 to 297,472 bytes, almost all generated swizzles. Co-Authored-By: Claude Opus 5 --- .../Runtime/Plugins/CultMath.dll | Bin 66048 -> 297472 bytes .../Runtime/Plugins/CultMath.pdb | Bin 33440 -> 141072 bytes 2 files changed, 0 insertions(+), 0 deletions(-) diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 89a981c86647129de1d2639726f04be8e4504265..584d9b72efe2391777a62a6256e646894c4c0074 100644 GIT binary patch literal 297472 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

>*-2Zu<>%Q&l3G(_P`?}jaUJv1TwgLC} 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 SMJ=EGuhp#oZq1L^1OE%QqB%YQ literal 66048 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 NLQiqfD9qx8{|9iHJ>mcW From e0a054a7b4c5d15d19614c969fbec09142e4ac43 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:09:49 +0200 Subject: [PATCH 10/20] =?UTF-8?q?=EF=BB=BFMatch=20step's=20NaN=20result=20?= =?UTF-8?q?to=20what=20dxc=20emits?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit dxc 1.9.0.5402 (dxc_2026_07_29, lib_6_3, -HV 2021, -Od) lowers step(e, x) to fcmp olt x, e; select 0 : 1, so NaN on either side gives 1. The previous x >= e ? 1 : 0 rule came from prose, not the compiler. math.step and cultmath_step now use x < e ? 0 : 1 for every overload; the mirror's cultmath_step compiles to the same fcmp/select as the intrinsic. Unity shader copy synced; DLL rebuilt and byte-checked by build-unity-package.ps1. Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 4 ++-- packages/cultmath/shaders/CultMath.hlsl | 2 +- packages/cultmath/src/CultMath/math.cs | 4 ++-- .../CultMath.Tests/HlslSemanticsTests.cs | 4 ++-- .../Runtime/Plugins/CultMath.dll | Bin 297472 -> 297472 bytes .../Runtime/Plugins/CultMath.pdb | Bin 141072 -> 141076 bytes .../Shaders/CultMath.hlsl | 2 +- 7 files changed, 8 insertions(+), 8 deletions(-) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index a2ce5e33..863b5efe 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -40,8 +40,8 @@ That makes these HLSL rules, not options: - Scalar/vector arithmetic and comparisons have explicit overloads on both sides rather than leaning on implicit scalar splat. - Intrinsics return HLSL's types and edge cases: `sign` returns `int`/`intN` - (NaN gives 0); `step(y, x)` is `x >= y ? 1 : 0` (NaN gives 0), in C# and in the - HLSL mirror; `any`/`all` accept numeric vectors (a component is true when it is + (NaN gives 0); `step(y, x)` is `x < y ? 0 : 1` (NaN gives 1), which is how dxc + lowers it, in C# and in the HLSL mirror; `any`/`all` accept numeric vectors (a component is true when it is not 0); `min`, `max`, and `abs` on int vectors return int vectors. Deferred until a consumer needs them: `float4x4`, `transpose`, `determinant`, diff --git a/packages/cultmath/shaders/CultMath.hlsl b/packages/cultmath/shaders/CultMath.hlsl index 632bb94f..15137c4d 100644 --- a/packages/cultmath/shaders/CultMath.hlsl +++ b/packages/cultmath/shaders/CultMath.hlsl @@ -36,7 +36,7 @@ float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + ( float3 cultmath_lerp(float3 start, float3 end, float3 amount) { return start + (end - start) * amount; } float4 cultmath_lerp(float4 start, float4 end, float4 amount) { return start + (end - start) * amount; } -float cultmath_step(float edge, float value) { return value >= edge ? 1.0 : 0.0; } +float cultmath_step(float edge, float value) { return value < edge ? 0.0 : 1.0; } float2 cultmath_step(float2 edge, float2 value) { return float2(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y)); } float3 cultmath_step(float3 edge, float3 value) { return float3(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z)); } float4 cultmath_step(float4 edge, float4 value) { return float4(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z), cultmath_step(edge.w, value.w)); } diff --git a/packages/cultmath/src/CultMath/math.cs b/packages/cultmath/src/CultMath/math.cs index c51a2758..4414cd3a 100644 --- a/packages/cultmath/src/CultMath/math.cs +++ b/packages/cultmath/src/CultMath/math.cs @@ -150,8 +150,8 @@ public static partial class math public static double2 unlerp(double2 start, double2 end, double2 value) => (value - start) / (end - start); public static double3 unlerp(double3 start, double3 end, double3 value) => (value - start) / (end - start); - // HLSL: step(y, x) = x >= y ? 1 : 0, so a NaN on either side yields 0. - public static float step(float edge, float value) => value >= edge ? 1.0f : 0.0f; + // dxc lowers step(y, x) to x < y ? 0 : 1 (fcmp olt, then select), so a NaN on either side yields 1. + public static float step(float edge, float value) => value < edge ? 0.0f : 1.0f; public static float2 step(float2 edge, float2 value) => new(step(edge.x, value.x), step(edge.y, value.y)); public static float3 step(float3 edge, float3 value) => new(step(edge.x, value.x), step(edge.y, value.y), step(edge.z, value.z)); public static float4 step(float4 edge, float4 value) => new(step(edge.x, value.x), step(edge.y, value.y), step(edge.z, value.z), step(edge.w, value.w)); diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs index 908f80b3..03e729a5 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs @@ -161,8 +161,8 @@ public sealed class HlslSemanticsTests Assert.Equal(new int4(1, 2, 0, 3), math.abs(new int4(-1, 2, 0, -3))); Assert.Equal(7, math.abs(-7)); - Assert.Equal(0.0f, math.step(1.0f, float.NaN)); - Assert.Equal(0.0f, math.step(float.NaN, 1.0f)); + Assert.Equal(1.0f, math.step(1.0f, float.NaN)); + Assert.Equal(1.0f, math.step(float.NaN, 1.0f)); Assert.Equal(1.0f, math.step(1.0f, 1.0f)); Assert.Equal(0, math.sign(float.NaN)); diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 584d9b72efe2391777a62a6256e646894c4c0074..1b4d8b07aa217b59726799c5ab9d5767bf66408e 100644 GIT binary patch delta 275 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 delta 17963 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 ZZb-Va&Jzv)KY#7h<{Q3>uG6*7{{hR8F}nZ& diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl index 632bb94f..15137c4d 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl +++ b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl @@ -36,7 +36,7 @@ float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + ( float3 cultmath_lerp(float3 start, float3 end, float3 amount) { return start + (end - start) * amount; } float4 cultmath_lerp(float4 start, float4 end, float4 amount) { return start + (end - start) * amount; } -float cultmath_step(float edge, float value) { return value >= edge ? 1.0 : 0.0; } +float cultmath_step(float edge, float value) { return value < edge ? 0.0 : 1.0; } float2 cultmath_step(float2 edge, float2 value) { return float2(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y)); } float3 cultmath_step(float3 edge, float3 value) { return float3(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z)); } float4 cultmath_step(float4 edge, float4 value) { return float4(cultmath_step(edge.x, value.x), cultmath_step(edge.y, value.y), cultmath_step(edge.z, value.z), cultmath_step(edge.w, value.w)); } From 912d9c469ad34613a42036053959db856d7be4e3 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:12:06 +0200 Subject: [PATCH 11/20] Leave the CultCache Unity manifest to the routing branch The routing branch drops the org.gamecult.cultmath dependency from src/GameCult.Unity/Assets/Caching/package.json; bumping it to 0.2.0 here only manufactured a merge conflict. The file returns to the merge base (8be174b). Co-Authored-By: Claude Opus 5 --- src/GameCult.Unity/Assets/Caching/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/GameCult.Unity/Assets/Caching/package.json b/src/GameCult.Unity/Assets/Caching/package.json index 9f3df603..cde27289 100644 --- a/src/GameCult.Unity/Assets/Caching/package.json +++ b/src/GameCult.Unity/Assets/Caching/package.json @@ -11,7 +11,7 @@ ], "dependencies": { "org.gamecult.cultlib": "1.0.57", - "org.gamecult.cultmath": "0.2.0" + "org.gamecult.cultmath": "0.1.2" }, "license": "MIT", "category": "Scripting" From 2940ca094430ca04f22882aff05e5400d3990180 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:17:11 +0200 Subject: [PATCH 12/20] Compare every HLSL mirror function against C# math, bit for bit Only cultmath_snoise was compared, at four inputs, so a flipped cultmath_step, a changed hash constant, and a snoise2 tie change all passed. The mirror is now discovered by reflection: every cultmath_* overload with a math counterpart (26 functions) runs over 104 deterministic cases - each special value in every argument (0, -0, +-1, ties, 1e-7, +-1e4, 1e7, NaN), special pairs, seeded randoms, and vectors with x == y (snoise's x0.x == x0.y) - and must match exactly. Both sides are float32 C# over the same intrinsics, so no tolerance. A cultmath_* function with no counterpart must be named in MirrorOnly. The four-input snoise theory is gone. Mutations: flipped step args fail (349 mismatches); hash constants changed by more than one float32 ulp fail (43758.55: 467, 127.2: 289, 74.8: 97). 43758.5453 -> .5454 is the same float32 and cannot fail. snoise2 x0.x > x0.y -> >= is invisible: over 1,829,415 exact ties the result is bit-identical, because the off-simplex corner's kernel is <= 0 on the shared edge. Co-Authored-By: Claude Opus 5 --- .../HlslSourceCompatibilityTests.cs | 64 ++++++++++++++++--- 1 file changed, 54 insertions(+), 10 deletions(-) diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs index 3c5aae94..9c57ac70 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -31,25 +31,69 @@ public sealed class HlslSourceCompatibilityTests private static MethodInfo? ShaderFunction(Type shader, string name, params Type[] parameters) => shader.GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic, null, parameters, null); - [Theory] - [InlineData(0.0f, 0.0f, 0.0f)] - [InlineData(0.25f, -0.5f, 1.75f)] - [InlineData(12.25f, -4.5f, 3.125f)] - [InlineData(-7.3f, 2.9f, 101.4f)] - public void CompiledShaderNoiseMatchesCSharpMirror(float x, float y, float z) + // Mirror internals with no public C# math counterpart. Any other cultmath_* function must match one. + private static readonly string[] MirrorOnly = { "cultmath_snoise_mod289", "cultmath_snoise_permute" }; + + private static readonly float[] Specials = { 0.0f, -0.0f, 1.0f, -1.0f, 0.5f, -2.75f, 3.0f, 1.0e-7f, 1.0e4f, -1.0e4f, 1.0e7f, float.NaN }; + + ///

+ /// Every mirror function with a C# math counterpart returns the same bits (NaN equal to NaN, -0 equal + /// to 0) over random inputs, every special value in every argument (ties, zeros, negatives, NaN, + /// large values, integer lattice points), special pairs, and vectors whose first two components tie + /// (x0.x == x0.y in snoise). Equality is exact: both sides are float32 C# over the same intrinsics. + /// + [Fact] + public void EveryMirrorFunctionMatchesCSharpMath() { var (assembly, errors) = CompileShaderMirror(); Assert.True(assembly is not null, string.Join(Environment.NewLine, errors)); var shaderType = assembly!.GetType("CultMathHlsl.HlslShader")!; var shader = Activator.CreateInstance(shaderType); - var snoise3 = (float)ShaderFunction(shaderType, "cultmath_snoise", typeof(float3))!.Invoke(shader, new object[] { float3(x, y, z) })!; - var snoise2 = (float)ShaderFunction(shaderType, "cultmath_snoise", typeof(float2))!.Invoke(shader, new object[] { float2(x, y) })!; + var random = new System.Random(0x5EED); + float Next() => random.NextSingle() * 200.0f - 100.0f; + var cases = new List>(); + foreach (var s in Specials) cases.Add(_ => s); + for (var k = 0; k < Specials.Length; k++) { var o = k; cases.Add(i => Specials[(i + o + 1) % Specials.Length]); } + for (var k = 0; k < 64; k++) { var values = Enumerable.Range(0, 32).Select(_ => Next()).ToArray(); cases.Add(i => values[i]); } + for (var k = 0; k < 16; k++) { var values = Enumerable.Range(0, 32).Select(_ => Next()).ToArray(); cases.Add(i => values[i & ~1]); } - Assert.Equal(snoise(float3(x, y, z)), snoise3, precision: 6); - Assert.Equal(snoise(float2(x, y)), snoise2, precision: 6); + var mismatches = new List(); + var compared = new HashSet(); + foreach (var mirror in shaderType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).Where(m => m.Name.StartsWith("cultmath_"))) + { + var types = mirror.GetParameters().Select(p => p.ParameterType).ToArray(); + var counterpart = typeof(math).GetMethod(mirror.Name["cultmath_".Length..], BindingFlags.Public | BindingFlags.Static, null, types, null); + if (counterpart is null) + { + Assert.Contains(mirror.Name, MirrorOnly); + continue; + } + + compared.Add(mirror.Name); + foreach (var input in cases) + { + var slot = 0; + var args = types.Select(t => t == typeof(float) ? (object)input(slot++) + : Activator.CreateInstance(t, Enumerable.Range(0, Components(t)).Select(_ => (object)input(slot++)).ToArray())!).ToArray(); + var expected = Floats(counterpart.Invoke(null, args)!); + var actual = Floats(mirror.Invoke(shader, args)!); + if (!expected.SequenceEqual(actual)) + { + mismatches.Add($"{mirror.Name}({string.Join(", ", args.Select(a => string.Join(" ", Floats(a))))}): C# {string.Join(" ", expected)}, mirror {string.Join(" ", actual)}"); + } + } + } + + Assert.True(mismatches.Count == 0, $"{mismatches.Count} mismatches:{Environment.NewLine}{string.Join(Environment.NewLine, mismatches.Take(12))}"); + Assert.Equal(26, compared.Count); } + private static int Components(Type t) => t.GetFields().Count(f => f.FieldType == typeof(float) && !f.IsStatic); + + private static float[] Floats(object value) => value is float f ? new[] { f } + : value.GetType().GetFields().Where(field => field.FieldType == typeof(float) && !field.IsStatic).Select(field => (float)field.GetValue(value)!).ToArray(); + /// The documented HLSL-to-C# transformations, and nothing else. internal static string TransformHlslToCSharp(string hlsl) { From 77ee6fe488a10449c23fc0518db8617e45a1cc1f Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:17:11 +0200 Subject: [PATCH 13/20] Pin dxc to dxc_2026_07_29 and verify its SHA256 get-dxc.ps1 fetched releases/latest with no pin or hash, so the compiler that defines parity could change under the tests. It now downloads v1.9.2607's dxc_2026_07_29.zip (dxcompiler 1.9.0.5402) and refuses a zip whose SHA256 is not A1DFB116...CD241. The hash was taken from the zip downloaded from Microsoft's GitHub release and matches the digest GitHub publishes for the asset. Script ran end to end and installed 1.9.0.5402. Co-Authored-By: Claude Opus 5 --- packages/cultmath/tools/get-dxc.ps1 | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/packages/cultmath/tools/get-dxc.ps1 b/packages/cultmath/tools/get-dxc.ps1 index 2f3363f3..d9b12593 100644 --- a/packages/cultmath/tools/get-dxc.ps1 +++ b/packages/cultmath/tools/get-dxc.ps1 @@ -8,26 +8,27 @@ $repoRoot = Resolve-Path (Join-Path $PSScriptRoot "..") $installPath = Join-Path $repoRoot $InstallRoot New-Item -ItemType Directory -Force -Path $installPath | Out-Null -$release = Invoke-RestMethod ` - -Uri "https://api.github.com/repos/microsoft/DirectXShaderCompiler/releases/latest" ` - -Headers @{ "User-Agent" = "CultMath-DXC-Bootstrap" } +# Pinned: parity means this compiler's lowering (dxcompiler 1.9.0.5402). The hash is the SHA256 +# of dxc_2026_07_29.zip downloaded from Microsoft's GitHub release v1.9.2607, and matches the +# digest GitHub publishes for that asset. +$zipName = "dxc_2026_07_29.zip" +$zipUrl = "https://github.com/microsoft/DirectXShaderCompiler/releases/download/v1.9.2607/$zipName" +$zipSha256 = "A1DFB116BA3EEAE6A1582291B53A8E7BF65AD760676BD3194685C8F7367CD241" -$asset = $release.assets | - Where-Object { $_.name -like "dxc_*.zip" } | - Select-Object -First 1 - -if (-not $asset) { - throw "No Windows dxc_*.zip asset found on the latest DirectXShaderCompiler release." -} - -$zipPath = Join-Path $installPath $asset.name +$zipPath = Join-Path $installPath $zipName Remove-Item -LiteralPath $zipPath -Force -ErrorAction SilentlyContinue -& curl.exe -L --retry 5 --retry-delay 2 --fail -o $zipPath $asset.browser_download_url +& curl.exe -L --retry 5 --retry-delay 2 --fail -o $zipPath $zipUrl if ($LASTEXITCODE -ne 0) { throw "curl.exe failed with exit code $LASTEXITCODE." } +$actualSha256 = (Get-FileHash -LiteralPath $zipPath -Algorithm SHA256).Hash +if ($actualSha256 -ne $zipSha256) { + Remove-Item -LiteralPath $zipPath -Force + throw "$zipName SHA256 is $actualSha256, expected $zipSha256." +} + $currentPath = Join-Path $installPath "current" Remove-Item -LiteralPath $currentPath -Recurse -Force -ErrorAction SilentlyContinue New-Item -ItemType Directory -Force -Path $currentPath | Out-Null From 6bc6db68d454919ce704e23036099fd0cf9b8073 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:18:00 +0200 Subject: [PATCH 14/20] Document where matrix row writes are silently lost The operator kept the [UnscopedRef] ref this[int] row indexer as is. design.md and the float2x2/float3x3 indexers now say where m[r][c] = v lands: locals, array elements, class fields, and ref locals keep the write; a readonly field, in parameter, property (auto-properties too), or static readonly identity takes a defensive copy, so the write compiles and is lost. Fix: copy to a local, write, assign back. Verified by compiling and running each case with Roslyn against CultMath (no diagnostics; writes land 5, lost 0). Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 5 +++++ packages/cultmath/src/CultMath/float2x2.cs | 1 + packages/cultmath/src/CultMath/float3x3.cs | 1 + .../Runtime/Plugins/CultMath.dll | Bin 297472 -> 297472 bytes .../Runtime/Plugins/CultMath.pdb | Bin 141076 -> 141076 bytes 5 files changed, 7 insertions(+) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index 863b5efe..ee209fd4 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -37,6 +37,11 @@ That makes these HLSL rules, not options: products go through `mul` (`mul(m, v)` treats `v` as a column, `mul(v, m)` as a row). `*` on matrices would be component-wise in HLSL, so CultMath does not define it. +- `m[r][c] = v` writes through locals, array elements, fields of classes, and + ref locals. Through a readonly field, an `in` parameter, a property + (auto-properties included), or a static readonly value such as + `float3x3.identity`, C# takes a defensive copy: the write compiles and is + silently lost. Copy the matrix to a local, write to it, and assign it back. - Scalar/vector arithmetic and comparisons have explicit overloads on both sides rather than leaning on implicit scalar splat. - Intrinsics return HLSL's types and edge cases: `sign` returns `int`/`intN` diff --git a/packages/cultmath/src/CultMath/float2x2.cs b/packages/cultmath/src/CultMath/float2x2.cs index 9d5a2e54..bd8673ae 100644 --- a/packages/cultmath/src/CultMath/float2x2.cs +++ b/packages/cultmath/src/CultMath/float2x2.cs @@ -34,6 +34,7 @@ public struct float2x2 : IEquatable public float _m10 { readonly get => _row1.x; set => _row1.x = value; } public float _m11 { readonly get => _row1.y; set => _row1.y = value; } + /// Writes through a readonly field, in parameter, property, or identity hit a defensive copy and are lost; write to a local and assign it back. [UnscopedRef] public ref float2 this[int row] { diff --git a/packages/cultmath/src/CultMath/float3x3.cs b/packages/cultmath/src/CultMath/float3x3.cs index 4c052a50..d7aad21c 100644 --- a/packages/cultmath/src/CultMath/float3x3.cs +++ b/packages/cultmath/src/CultMath/float3x3.cs @@ -42,6 +42,7 @@ public struct float3x3 : IEquatable public float _m21 { readonly get => _row2.y; set => _row2.y = value; } public float _m22 { readonly get => _row2.z; set => _row2.z = value; } + /// Writes through a readonly field, in parameter, property, or identity hit a defensive copy and are lost; write to a local and assign it back. [UnscopedRef] public ref float3 this[int row] { diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 1b4d8b07aa217b59726799c5ab9d5767bf66408e..28e9c939caed3f388143698250fd014528d76745 100644 GIT binary patch delta 256 zcmZpeBGfQNXhH{z$)lZH8hcuM7+ZUoT6>tc_OR&W2%O9Hy7y0KyW74{8PPXqWKV5B zk;8IFK*QWTHPtLF)x^Rg(a^xe#4_2)I4#-0)X*X&$->OgJk`WB(J(pLFm3ypS{5Eg z7KUw%_om;eV+jz@Qcgct7IM>Zi(>dSTehl=({1WmLKUE*A5Ea5K=pAh^H%KRSm^zK z^W-CX+c(y;yl3?{XE0|-1wu21G$3ihU;%`Q42BE_K(+~kB||cU5rZ*ME*U6d3KX|s fNMT35o7@Xb+1q# delta 256 zcmZpeBGfQNXhH`|x2x-w#-7$5#?~ID)*j}qJuEso0@=%wA8;?LbX`+0V`1zcUd8Pv za#-#NXc!tK86_K=TASfQmOc=3zJp8FCD&*U=tPq(RO2~~iKTKs{E0@cShOw;-9IrXmm zC6Ob}+c(y;yl3?{WH4YzVlZMzW-w$hWk>_EEf`W6EE&vzFa-!Lf!Kf{k--?K#stVt h1G1BVat1)YIZ(s|D3b~lH3jNVV@TcpzLiCg1pwmLQ|bT! diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index 4745e11674c90139d756b7d7a9ed85cd3f20f891..c2dc244653945f45fb3a7e9b8730ed57e6fa88f2 100644 GIT binary patch delta 857 zcmbPoj$_I>jtMm)TFU9?%0g~BZcz-sX3JK!kzpI-y~YV!Col>|DlE&7u>06{Q8`eWB%xzcPKa}{z;%UamPqXek zy>mp~{`;$`QH#9aZ`X}toXS%F`=ON9e76%Zb^lI$`cd`XD2aPvh~blYT@@DucWrfh zTG4n_o0WlK?UeIbw;cqIy>Hxe_(5D$ly}*qBY8qxE4?l?@v8b=c7B<-Maq+VwXC7F z*9GOTrk_$=y|Ul@W1L#W&u#tt?fdAoH1odW)w1pEg*@UnH2S$esjQf?_hs|l9re1o z42LBTGPB*_P{?I;oEdw?)BMvCm-qmN)C=!Y@?;%bbtQ6`8o#!=p3qnl@@Q`=;}=Pr zi02Bb1u`Nz`xa(;`rk8axNvOG_LlA+{N?w`v-tRDCDby$Hq!`wzWelxwjy^o-QS=6 zez7_)&?bC$mP-2F~}&-Blh z7c>1fAFXFvKKbUGt(I2j&OS-mb>h;|mnD9ih37~apKZTgCvr||b8PQA!>|=k3y!S~ zb^q^r!};GXzEc5(%Pq6{!Xj_^KXO~25VGppL!CbE)v1%++E)K~9^A1zGxPGj4fSuY z-?sPvuD|A5zVvIOA39;04|~?Jba(A(DwJ@#GWRzhqd21=X{ja_ z7Kw%iCMK52M#gE$2BwA6(9V3YovH=K>_EYWxy9SPjx(N$ F2LPbuUGe|` delta 857 zcmbPoj$_I>jtMm)6IN*H2wwc+vFEjXx@NCj=ZUiaws?l6u| z=ZriT^)?)i+_S8C_1@~u*UoAB9;t#^(edExzgWo|}J~TvtKU+A52n z?ufr3ep6o@c(&&DcHJn(sVwz-g{J1#-7CJnhsogPYKOhEIs8xC*4%y;^R!QEngr*! z#f?|BSs57CPPv^WZ79(8p1HF9;NHy4y}Qd~wp#{xY**pE5%9=lug2aPQ`5qk)^6!Z zlm0gGmsIVh4YRM^ux)T&%iZXY|>hsquQhW>4?UX`+NuM?$k?3 zJF@x~^b1~N(y(%vAP{rO`}(Il3)X8iu}t`vk}2!hE31*C-1t??V6u?Li3jG=5*M;} zY(MAd_`peI!_!%6ZE|~aS(a`6nZWt{W&FE6@2|+nZMpc1D=b!I)%k7HPx4Ofn{wm9 z`Kp)VJriFYDqUXBHK}`kb>#}_FLzrxZZ8t8s<+#9Xx67|Ctn=BK38(zmeA8T+|51A zpKvJKvR*04(N>n8Ab&s6v#G${j_+#VLHj(mzTJ!O2Z!X$zMnV4+R6TzK-P)*j=f0= zQaK*Zk`i`0VcmsO&IuY+`uf;hvA=ou+a;@A%6+%DMH=~TQn@W#{Py&LuM^@+{y*3| zC*^2}Z{O+qN4#^-Jdc|Hf~S9(acq*|`DN?VH!ExPt3MTf^>Jcz-qkeIU&kUA&A2PM zJxu1Wcq0GL*VZ13AA}W~DMoSLsZBDkVpUeYbmX$h+BGw_d4#OE9Ph9Ac6qBV+u?^> z<8%Mn{N2AHW^eY|%O7U04UjX5H3~DWWPECHY>EAM21ap4LB{F(5*WQT3=NWuk_}DM zk}Og!&CF6#EK>{;jg3rF(h`%*42;Z8OpH_0Obydgw;LuhevGuxkz{8OWMW`vFlJ&B z5Mp4Ew&Y}IkOm1TGBL0*Fff?enXm~nFsRvEfp~Hb#vm%jaeLHmMqh3(6PR`sGwfkz z*fTMJ4RuEs@JAA`7G+=%kDmVV7^AgZHYdpV;9L_nF`%7!U^`XwjoE>M4RedOdmU#y G6%PPM)K?M! From a9a2ba69d2a525ab13a5d85ac5db7fd6bd40a271 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:27:44 +0200 Subject: [PATCH 15/20] Build the Unity CultMath DLL independent of the commit The tracked DLL is committed with its source, so a build that embeds the commit can never match it. Two places named the commit: the informational version (0.2.0+) and Source Link's commit URL in the pdb, whose content id the DLL also carries. The csproj drops the revision from the version, and the Unity build turns Source Link off; NuGet packs keep it. Co-Authored-By: Claude Opus 5 --- .../cultmath/scripts/build-unity-package.ps1 | 4 +++- .../cultmath/src/CultMath/CultMath.csproj | 2 ++ .../Runtime/Plugins/CultMath.dll | Bin 297472 -> 296448 bytes .../Runtime/Plugins/CultMath.pdb | Bin 141076 -> 141036 bytes 4 files changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/cultmath/scripts/build-unity-package.ps1 b/packages/cultmath/scripts/build-unity-package.ps1 index 7db1fbda..8c0cbb09 100644 --- a/packages/cultmath/scripts/build-unity-package.ps1 +++ b/packages/cultmath/scripts/build-unity-package.ps1 @@ -27,8 +27,10 @@ if (Test-Path -LiteralPath $outputRoot) { Remove-Item -LiteralPath $outputRoot -Recurse -Force } +# The tracked DLL and pdb are committed beside their source, so neither may name a commit: Source Link +# writes the commit SHA into the pdb, and the DLL carries that pdb's content id. dotnet build $projectPath -c $Configuration -f netstandard2.1 -o $buildRoot ` - --disable-build-servers -p:UseSharedCompilation=false -p:ContinuousIntegrationBuild=true -m:1 + --disable-build-servers -p:UseSharedCompilation=false -p:ContinuousIntegrationBuild=true -p:EnableSourceLink=false -m:1 if ($LASTEXITCODE -ne 0) { throw "CultMath Unity assembly build failed with exit code $LASTEXITCODE" } diff --git a/packages/cultmath/src/CultMath/CultMath.csproj b/packages/cultmath/src/CultMath/CultMath.csproj index 5dfe069c..7c567105 100644 --- a/packages/cultmath/src/CultMath/CultMath.csproj +++ b/packages/cultmath/src/CultMath/CultMath.csproj @@ -14,6 +14,8 @@ README.md $(NoWarn);CS8981 true + + false diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 28e9c939caed3f388143698250fd014528d76745..0af117fb667747e1d8125529944278ad6d6be609 100644 GIT binary patch delta 26181 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 K|7y!Wp7?()(#moG delta 26340 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 diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index c2dc244653945f45fb3a7e9b8730ed57e6fa88f2..a56960a0ae0af4a2c95f1f128ecf2c0d9a7331f7 100644 GIT binary patch delta 12043 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 NbH3=%P32O{{U7o!0)_wp delta 12228 zcmZ|VeSD5(<3I58B1WF_upz0IJhwEOS!-!&)^aZ`mZzjyqmjp2LR_JRSkje*Bnb&= zAqmM-@)VLJNlR`?lH5yfU;N(n`~CU-{qa7I&tAKBp6AZv;XICW`*l}^SH7t5(%|b~ z+8qQ9?s|Ms?;r@8HR$`rQ=Jc{u88gObxQdW#leT6?~7l0ITX%l6ber8JLf2E914<~ zgo4|ehJvBY;^U@ef`bIj$^>;uL#aha$VF~PMo;$~VCdxs*Mp5!rr0w(hcuP>i>MW;}>Q_Gm3 z2f6g;2?{A<4hvb$2DWjCqm*)yYOP{|+FVCtT98Ov(s`IZ45W}ErZJoOtzudRYlY41 zk@zCa6nuT9HO3+4N-)W0=S+=CP9SI>i=tv7f^n;}oS-zAYxGMRQt_%mZ|%H^Ujj zMBd~b*0Yt}9N-9la*62Vn4mrliA#=5>Gh@+gOOiD~}C9yOmo_n~Tt_)%rVP55p zNQ)~+=FPvuAZ8`&*g^>>IKz3O+xq=!NE`{IkVYoi^kg_=n8;LSFqcJf+{p6o+MHu>6MaWcS-v>%rQ<;F;!=wF0qk$mD0moq+RUiFvkep<&#vWF0nKv zo+MJqAddkQFp5Hom_{+H*}yjTa*z@(Qm&orZWj~DuN)iBmV1)N01BAO4CbXfenwFszHJXDQp*%Rx#w!5PjItsmB>A#o&-LK>N5)05$h zVIor_$yNJ?3+{2}DWr&LEMyrQ*v27_Qp!cjWteNZj(C#jKqvATKmp^K!dw=yhE43} zFvl{C-%~;<7b$nIn?f`N0TTsHi6@CvGRUGEIpkAF5!0B>e3r73y&R;36P)2Zp-!%whQxJ> ziOi@G8!nJXQAiQfC}uSq*v4KCQo=>bb@m$(O??^?M+RARBZqv3Fq|<=WGYKp$-2%l zk))bQu?g8)hBPwCW(dO>!^B9WW^!!wgU&`n;z%HiZsd?3IbE}M-co5L>)66BPH=|v zgu3VzRHrTpq>x4?+4Llj0TeKb8O&u7#gYECx_QWr>gv8x#587iy&{<3)uKHp7Zi8> zzdlm`ZTm`MAr#l63Tav391sqwcJ7*?&Sfx)0=(_Wdvh+ zp?g&Da`y_B@fCtM)aTV})tlJPUcTW7|K=3`;R0oPR0t~es1OdW5^8fT4Y{d@WfFIi zNq2hFkD-iUEHCgfGg-n4KI031;AeiP%tIC;T*HmD<__9(-$Q1<2Ze{}!$1ltVj4?W z!CE%6lcSvEEEg!-GbXs28)!yLZX=6sBGtazV|Z09?E;!iG7{$W!s z*VB^Q_!pgdh(~#xCwYeFn8iF6vytt5$+!H-c|yI60>af5b-9H$+{r!MPhSQxj2C&8 zH(0=Xy($DB_Nu4@R}40)>o%(x98&+t34Z4smnip0#h@}Zxtds-(BhGb;h?pU!rgS> z0lM)BeHlmr&oGV`n96I+VF627!5TKQjXfOTdyerdXZi0Ve)}Br7qxQ2_JYCT@#*v?r6! z^q@ES3}zUkDP%GcW-^y|SjLB}V>3JWl7sxfaenJvF(~bQWe^VKUKwQaFnK)A6O3RC z6PUuQyvrIkvW-0)$gO1jR|<}*&#Oa^RthRmjTq{4Bh6_^5_gi$eUDZO2id|yCAU<@!839a`mS|F%L09-teK z(3gP}@C@U4g;^|NIh)zRmmK96E>NbAZ8BFAOA}hqniTG)J2^ZSR*a^Q$wZjR`>f&< zwy={QIl=Fo;}W&{>cHGU8`{#IOghtp-sCfwVT`7b$wWsKGnvafEaSuF>+3~@!dvn^ zJ=xD;j&Y95RPSfnpgFBbCX;OXGKeuuWGXY5%OZ+d%^tqt2hMSssQ$(SwflP^akJ2x zJ7~{+s3!|MO@LZZV!D`t9-OaFnDf+q%64#G@hLT+W9x^l2s{(#kd z%2vK$Ki_ebUpT{GT&Db>%0U%sQIA_m<3ai|FRXZ%Vm@L$TL)F~Hl#|hPu)TNr}`pS z46YJXq6T%jp2plv0=LtSd�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 R|9`%{tKO>O8_Oh@`9DWIJO}^) From d298d666d0561efdeeaeec8e04a3676c4baf662a Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:28:44 +0200 Subject: [PATCH 16/20] Rebuild the Unity CultMath DLL without Source Link, non-incrementally The previous commit's DLL and pdb came from an incremental build that did not recompile after the Source Link switch, so the pdb still carried the commit URL. The script now builds with --no-incremental, so a stale obj directory cannot decide what the byte check compares. Co-Authored-By: Claude Opus 5 --- .../cultmath/scripts/build-unity-package.ps1 | 2 +- .../Runtime/Plugins/CultMath.dll | Bin 296448 -> 296448 bytes .../Runtime/Plugins/CultMath.pdb | Bin 141036 -> 140892 bytes 3 files changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/cultmath/scripts/build-unity-package.ps1 b/packages/cultmath/scripts/build-unity-package.ps1 index 8c0cbb09..b64e9446 100644 --- a/packages/cultmath/scripts/build-unity-package.ps1 +++ b/packages/cultmath/scripts/build-unity-package.ps1 @@ -29,7 +29,7 @@ if (Test-Path -LiteralPath $outputRoot) { # The tracked DLL and pdb are committed beside their source, so neither may name a commit: Source Link # writes the commit SHA into the pdb, and the DLL carries that pdb's content id. -dotnet build $projectPath -c $Configuration -f netstandard2.1 -o $buildRoot ` +dotnet build $projectPath -c $Configuration -f netstandard2.1 -o $buildRoot --no-incremental ` --disable-build-servers -p:UseSharedCompilation=false -p:ContinuousIntegrationBuild=true -p:EnableSourceLink=false -m:1 if ($LASTEXITCODE -ne 0) { throw "CultMath Unity assembly build failed with exit code $LASTEXITCODE" diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 0af117fb667747e1d8125529944278ad6d6be609..6f9fa0c69d0f19bdbd38975ad5ca0cc3b64e8732 100644 GIT binary patch delta 123 zcmZqZ5o+iWn$W?LZ~1>!V^3=jV`~pnYY+3*9u}P(f#zS80#{6Z9A?fC`*`@#9R2Ml za#&snvglv;Su%Y~9ZP^f{#CZ(;J0Z$Gv~!G-P2pRZMsN3OQ-@=bk0qvC{Vr1FYg)e Tt7bXf{=2YMX?tfqOF0_=OQ$&w delta 123 zcmZqZ5o+iWn$W@G_cQHYV^3=jV`~pnYY+3*9u}P(0iKc$tHo@Q-qU|?o6T=~+I9Ph z9F`Y?ED`@!-=4mujwL`q>{zN*(LNK0{SqBtQ==d3oi0+(5~=_bt%r(&)cb6mR8%{W R;oM$^zt^{S*0Yqe0RZ9>H){X@ diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index a56960a0ae0af4a2c95f1f128ecf2c0d9a7331f7..ee7e9b82ad6550d82a6e8adc9a08733ed816e5af 100644 GIT binary patch delta 16789 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 Date: Mon, 14 Sep 2026 14:32:19 +0200 Subject: [PATCH 17/20] Match float min, max, clamp, and saturate to DXIL FMin/FMax/Saturate dxc lowers float min/max/clamp to dx.op FMin/FMax (36/35) and saturate to dx.op Saturate (7). DXIL.rst defines them: FMin(a, b) is a < b ? a : b, FMax(a, b) is a >= b ? a : b, a NaN operand returns the other, and Saturate is FMin(1, FMax(0, x)). C# used MathF.Min/Max, which pass NaN through and order signed zeros, so saturate(NaN) was NaN instead of 0. Every float overload now follows the spec, normalize uses the same max as its mirror, and the mirror's saturate spells Saturate's operand order (which maps -0 to +0, where clamp(x, 0, 1) keeps -0). Non-NaN results change only in the sign of a zero. design.md records the rules and that dxc marks float math fast, so GPU NaN results are not guaranteed. Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 12 +++++++++- packages/cultmath/shaders/CultMath.hlsl | 9 ++++---- packages/cultmath/src/CultMath/math.cs | 21 ++++++++++-------- .../CultMath.Tests/HlslSemanticsTests.cs | 14 ++++++++++++ .../Runtime/Plugins/CultMath.dll | Bin 296448 -> 296960 bytes .../Runtime/Plugins/CultMath.pdb | Bin 140892 -> 140892 bytes .../Shaders/CultMath.hlsl | 9 ++++---- 7 files changed, 47 insertions(+), 18 deletions(-) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index ee209fd4..9153b63d 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -46,9 +46,19 @@ That makes these HLSL rules, not options: sides rather than leaning on implicit scalar splat. - Intrinsics return HLSL's types and edge cases: `sign` returns `int`/`intN` (NaN gives 0); `step(y, x)` is `x < y ? 0 : 1` (NaN gives 1), which is how dxc - lowers it, in C# and in the HLSL mirror; `any`/`all` accept numeric vectors (a component is true when it is + lowers it, in C# and in the HLSL mirror; float `min`, `max`, `clamp`, and + `saturate` follow the DXIL `FMin`/`FMax`/`Saturate` operations dxc emits for + them: `min(a, b)` is `a < b ? a : b`, `max(a, b)` is `a >= b ? a : b`, a NaN + operand returns the other (so `saturate(NaN)` is 0), `clamp(x, a, b)` is + `min(max(x, a), b)`, and `saturate(x)` is `min(1, max(0, x))`, which maps -0 + to +0; `any`/`all` accept numeric vectors (a component is true when it is not 0); `min`, `max`, and `abs` on int vectors return int vectors. +dxc marks float arithmetic and compares `fast` (no NaNs) unless a value is +`precise`, so drivers may optimize NaN handling away and NaN results on real +GPUs are not guaranteed. CultMath defines the CPU result by dxc's lowering and +the DXIL operation spec (DirectXShaderCompiler `docs/DXIL.rst`). + Deferred until a consumer needs them: `float4x4`, `transpose`, `determinant`, and HLSL's one-based `_11`..`_33` element names. diff --git a/packages/cultmath/shaders/CultMath.hlsl b/packages/cultmath/shaders/CultMath.hlsl index 15137c4d..365705f5 100644 --- a/packages/cultmath/shaders/CultMath.hlsl +++ b/packages/cultmath/shaders/CultMath.hlsl @@ -26,10 +26,11 @@ float2 cultmath_clamp(float2 value, float2 minimum, float2 maximum) { return min float3 cultmath_clamp(float3 value, float3 minimum, float3 maximum) { return min(max(value, minimum), maximum); } float4 cultmath_clamp(float4 value, float4 minimum, float4 maximum) { return min(max(value, minimum), maximum); } -float cultmath_saturate(float value) { return cultmath_clamp(value, 0.0, 1.0); } -float2 cultmath_saturate(float2 value) { return cultmath_clamp(value, float2(0.0, 0.0), float2(1.0, 1.0)); } -float3 cultmath_saturate(float3 value) { return cultmath_clamp(value, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0)); } -float4 cultmath_saturate(float4 value) { return cultmath_clamp(value, float4(0.0, 0.0, 0.0, 0.0), float4(1.0, 1.0, 1.0, 1.0)); } +// DXIL Saturate is FMin(1, FMax(0, x)); dxc lowers min/max to the same FMin/FMax, NaN rules included. +float cultmath_saturate(float value) { return min(1.0, max(0.0, value)); } +float2 cultmath_saturate(float2 value) { return min(float2(1.0, 1.0), max(float2(0.0, 0.0), value)); } +float3 cultmath_saturate(float3 value) { return min(float3(1.0, 1.0, 1.0), max(float3(0.0, 0.0, 0.0), value)); } +float4 cultmath_saturate(float4 value) { return min(float4(1.0, 1.0, 1.0, 1.0), max(float4(0.0, 0.0, 0.0, 0.0), value)); } float cultmath_lerp(float start, float end, float amount) { return start + (end - start) * amount; } float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + (end - start) * amount; } diff --git a/packages/cultmath/src/CultMath/math.cs b/packages/cultmath/src/CultMath/math.cs index 4414cd3a..99ad5ecb 100644 --- a/packages/cultmath/src/CultMath/math.cs +++ b/packages/cultmath/src/CultMath/math.cs @@ -106,7 +106,9 @@ public static partial class math public static float3 frac(float3 value) => value - floor(value); public static float4 frac(float4 value) => value - floor(value); - public static float min(float left, float right) => MathF.Min(left, right); + // dxc lowers float min/max/clamp to DXIL FMin/FMax (saturate to Saturate, defined as FMin(1, FMax(0, x))). + // DXIL.rst: FMin(a, b) is a < b ? a : b, FMax(a, b) is a >= b ? a : b, and a NaN operand returns the other. + public static float min(float left, float right) => left < right || float.IsNaN(right) ? left : right; public static int min(int left, int right) => Math.Min(left, right); public static float2 min(float2 left, float2 right) => new(min(left.x, right.x), min(left.y, right.y)); public static float3 min(float3 left, float3 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z)); @@ -115,7 +117,7 @@ public static partial class math public static int3 min(int3 left, int3 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z)); public static int4 min(int4 left, int4 right) => new(min(left.x, right.x), min(left.y, right.y), min(left.z, right.z), min(left.w, right.w)); - public static float max(float left, float right) => MathF.Max(left, right); + public static float max(float left, float right) => left >= right || float.IsNaN(right) ? left : right; public static int max(int left, int right) => Math.Max(left, right); public static float2 max(float2 left, float2 right) => new(max(left.x, right.x), max(left.y, right.y)); public static float3 max(float3 left, float3 right) => new(max(left.x, right.x), max(left.y, right.y), max(left.z, right.z)); @@ -129,10 +131,11 @@ public static partial class math public static float3 clamp(float3 value, float3 minimum, float3 maximum) => min(max(value, minimum), maximum); public static float4 clamp(float4 value, float4 minimum, float4 maximum) => min(max(value, minimum), maximum); - public static float saturate(float value) => clamp(value, 0.0f, 1.0f); - public static float2 saturate(float2 value) => clamp(value, 0.0f, 1.0f); - public static float3 saturate(float3 value) => clamp(value, 0.0f, 1.0f); - public static float4 saturate(float4 value) => clamp(value, 0.0f, 1.0f); + // DXIL Saturate is FMin(1, FMax(0, x)); that operand order, unlike clamp(x, 0, 1), maps -0 to +0. + public static float saturate(float value) => min(1.0f, max(0.0f, value)); + public static float2 saturate(float2 value) => min(1.0f, max(0.0f, value)); + public static float3 saturate(float3 value) => min(1.0f, max(0.0f, value)); + public static float4 saturate(float4 value) => min(1.0f, max(0.0f, value)); public static float lerp(float start, float end, float amount) => start + (end - start) * amount; public static double lerp(double start, double end, double amount) => start + (end - start) * amount; @@ -202,9 +205,9 @@ public static partial class math public static float distance(float3 left, float3 right) => length(left - right); public static float distance(float4 left, float4 right) => length(left - right); - public static float2 normalize(float2 value) => value / MathF.Max(length(value), 1.0e-20f); - public static float3 normalize(float3 value) => value / MathF.Max(length(value), 1.0e-20f); - public static float4 normalize(float4 value) => value / MathF.Max(length(value), 1.0e-20f); + public static float2 normalize(float2 value) => value / max(length(value), 1.0e-20f); + public static float3 normalize(float3 value) => value / max(length(value), 1.0e-20f); + public static float4 normalize(float4 value) => value / max(length(value), 1.0e-20f); public static quaternion normalize(quaternion value) { var length = MathF.Sqrt(value.x * value.x + value.y * value.y + value.z * value.z + value.w * value.w); diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs index 03e729a5..65845fc9 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs @@ -165,6 +165,20 @@ public sealed class HlslSemanticsTests Assert.Equal(1.0f, math.step(float.NaN, 1.0f)); Assert.Equal(1.0f, math.step(1.0f, 1.0f)); + // DXIL FMin/FMax/Saturate: a NaN operand returns the other; max(a, b) is a >= b ? a : b. + Assert.Equal(1.0f, math.min(float.NaN, 1.0f)); + Assert.Equal(1.0f, math.min(1.0f, float.NaN)); + Assert.Equal(1.0f, math.max(float.NaN, 1.0f)); + Assert.Equal(1.0f, math.max(1.0f, float.NaN)); + Assert.True(float.IsNaN(math.max(float.NaN, float.NaN))); + Assert.Equal(2.0f, math.clamp(float.NaN, 2.0f, 3.0f)); + Assert.Equal(new float3(0.0f, 1.0f, 0.0f), math.saturate(new float3(float.NaN, 2.0f, -1.0f))); + Assert.Equal(new float2(-1.0f, 4.0f), math.max(new float2(float.NaN, 4.0f), new float2(-1.0f, float.NaN))); + static int Bits(float value) => BitConverter.SingleToInt32Bits(value); + Assert.Equal(Bits(-0.0f), Bits(math.max(-0.0f, 0.0f))); + Assert.Equal(Bits(0.0f), Bits(math.min(-0.0f, 0.0f))); + Assert.Equal(Bits(0.0f), Bits(math.saturate(-0.0f))); + Assert.Equal(0, math.sign(float.NaN)); Assert.Equal(-1, math.sign(-0.5f)); Assert.Equal(new int3(-1, 0, 1), math.sign(new float3(-2.0f, 0.0f, 4.0f))); diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index 6f9fa0c69d0f19bdbd38975ad5ca0cc3b64e8732..f76850f776c92794db748acec93708535076841a 100644 GIT binary patch delta 91045 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 delta 91002 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 diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.pdb index ee7e9b82ad6550d82a6e8adc9a08733ed816e5af..66902438d3a06e3be893c11616ec478a9ceb80b6 100644 GIT binary patch delta 2429 zcmZY8eM}Q)0LSs?jwy6PgwobZfr0{aysSb6g#sE8MPU<#L>J7^uqj3ysOUhzdmg|S zR8&x`PEi*nM&0HNb4+m>6%?eH`L<;dvpF=;Ae)MA^JU9^&vR#Dwm&}oKF@Ra+_k;7 z$K}!E^4L;tXuUV*(H~3mQyRWJI(bj2fJSJ7 zFW@+Q2kp=eH{cfBg?@Mnf5V{jdg28}2!K$Cf>=m`RG105PynUCpys?@A$1t+gwNm* z9D@^Z7CPYy`~4#s=z{@x0b!jck^$K;2R?)XD28&VhK;ZdcEbVq9KMEA&<3tf zlR~az&;xhi0X%`1@Wv$*@dN|-LkL8|7)XRkka5YEWJ4kR22bH7xOMrGH^B$YV1=+Q z1Brrom;f0NJulxt3NWaEYS;kvuoL#dL1>1PaJI`xI^a6og$FPI&p~n-i3bb?69hmA zL_iFrxVB2Nzuioxxy)n+%!U>ifc$PVX@?(S;bk*f0;O;h?lo6Uy8TS@c7BvBDahSq z=}feV5OQMZAd*QWj0g#WlmD5wzCLfcFN z!rX%n-c?&U z168n4#Rq7$sD-YL;d2XJH%4uZ*7c%+bmJ7h9!P7`)o#+dS?d<9b<@@3^`cg~Esf8u zv>`+7c2waDPHka_)}5K^37?Ak(Z&QmkEVN)c+==!(OkMO$BA?7 zb;HHPz$ag6lVN=FjXL4i7)eh$c;gh>Dh5;ODPFfsdPc_&_|P`H+IFoML@l%t)dp`h6^45207IUX8Wr30XjI=#t1V*;!7V?W`;&0`S2o`mPM>Lgo;}|}$XNQ1GuU6AZ;sG;kYt(Y$UOcMCzJ31+=khm zd;R5bWuk5{@s`OTLf6Q|1J|J&SsHeTLHet~dpaLHE^jsy3%>lkc$ugx@BeRQu1?3# z(UH7Y=PY<_g}>DRRuJcjnpu&8?b7APH?cbV!_I4v;*r!9c+VW zFss!rv`M?rX3SPp z$-a%}89C+y`3Qb#kNX^)6^;ip|W(YZKC4wo`pb_B^aZc;_dh!8nm{uifo BY}Wt) delta 2490 zcmZY9eNYr-0LSrXmlQ6s;JCx{I5}R#u@gHGMd5gHOcF&C#nDDa9bZC|5fw}kF86sr z5fBwYJyCqem&zQ&5)sD?Phvqu=xFI^)zIpZo6f>^{58?JezX z9_?)&rB1`ro4vDAy3!_A?3r`u?8fD%?B7nT+EO}LTK!pV|Iv!GUQgCS32cQ*sDfkg zIh=(?XoDNj4tL=pJb{1Ul?FZW1Or%LAcVqjh=H*%1!hA!WCMl52E9T`v9Sa8!BIE? zr{O#_!PoE|+=hGb82$!BBQ6F5Arj)?ZFmQ!!)!={3|I+kpa3?(cGv@l8x=h{jt%1l z+%e36#gGL~SO+fn22a@{;A44^qfqH0xYj6uXpcA^`ImnlA1E2>p1c42PK{Skk2{09A!aPU^B?}+9 zkPjuW6)K?$a++{KxCI^13El7D<-lGvf&o|dNP0PooAAV>%BNhL4J;t zz6|#!gw(#?izE{XTZH(*ng5LIULM!njFs_8pT z8sr{OQTA@?kCm=_iyvflMP1)rR&>AdX%DF`4EO4omFrqCs3s*<3Oc9wE{W=miy1Q_ zcbe|tU9P&$sjmA_Bv6^;jw=LG zI)zsWq)coC(mYWUT|12LFwu3x)fQ-7FX~T=#_@T7TAZYIgVqwQ8?|nltnS||YNcBe z`PfR!CaNvxRWPwto7kpxd$M|fOVmtvM)Pqv-4)B5NGnC>(A}|~UW7!`{kpy+P$r&u zh|%9cwq9$4s2{x$ z&gcE;MXi@a4YYYQpEuAJt*xRqdU*t&x6vzFua5B36S9zA)5Vg0GI3@4$ws9;fgcn` ze@O7gP9wd8n=s16oh0%P{-ymgp4Xe+v-A4V`=TMVQ`Af!iZ9npyC(4cX8K6$Z(1LV zhhnC`YwZ@b(I@<&TX26*r}2e0`lr^vrlsK}7)g6vK^8g9G+5_B;$)&DbNNT4Ol$*i z85ZW+XOV46yskI#l1VQ@3uNMf^UxBOfE8jR@x?}x&Ku9mi%rIa4?iwSChE-e|IN(O z>G&}^GXKRf3tpPxw>p5mAL)sj*b)WHwQtIwEq{~m4P}|)n~7jqqF(HSp?u!TR*LaZ zwo25&vPHvLj{56jx$3WrIYk56nlQdDj47h=jEY)Wo_3ymySst|9Bi$au(ASe$9ho* zD-;c6#oCEBXeTNW4Pl!`@(V<=&7$L2si={a#qfC}D;L$XZJ~TTfNd8Y%v_>+wj)$g zcT{LQc8UhE-Qq7E!S;wIvb~}~Y@as2UzD;+@H5C)6i>kX4HbPxeI=KVvLAEyl5|jvpY?GIownxXoq_TAO)w%h**N zt@p>v%5J;*Tjd*)kL!_Dp7F*=@gKmRH%e=i)@bqa+VdO^TL9jQym(hefNYZ{)l>w? PMQ)O_CU~G6B}?RApC@%s diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl index 15137c4d..365705f5 100644 --- a/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl +++ b/packages/cultmath/unity/org.gamecult.cultmath/Shaders/CultMath.hlsl @@ -26,10 +26,11 @@ float2 cultmath_clamp(float2 value, float2 minimum, float2 maximum) { return min float3 cultmath_clamp(float3 value, float3 minimum, float3 maximum) { return min(max(value, minimum), maximum); } float4 cultmath_clamp(float4 value, float4 minimum, float4 maximum) { return min(max(value, minimum), maximum); } -float cultmath_saturate(float value) { return cultmath_clamp(value, 0.0, 1.0); } -float2 cultmath_saturate(float2 value) { return cultmath_clamp(value, float2(0.0, 0.0), float2(1.0, 1.0)); } -float3 cultmath_saturate(float3 value) { return cultmath_clamp(value, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 1.0)); } -float4 cultmath_saturate(float4 value) { return cultmath_clamp(value, float4(0.0, 0.0, 0.0, 0.0), float4(1.0, 1.0, 1.0, 1.0)); } +// DXIL Saturate is FMin(1, FMax(0, x)); dxc lowers min/max to the same FMin/FMax, NaN rules included. +float cultmath_saturate(float value) { return min(1.0, max(0.0, value)); } +float2 cultmath_saturate(float2 value) { return min(float2(1.0, 1.0), max(float2(0.0, 0.0), value)); } +float3 cultmath_saturate(float3 value) { return min(float3(1.0, 1.0, 1.0), max(float3(0.0, 0.0, 0.0), value)); } +float4 cultmath_saturate(float4 value) { return min(float4(1.0, 1.0, 1.0, 1.0), max(float4(0.0, 0.0, 0.0, 0.0), value)); } float cultmath_lerp(float start, float end, float amount) { return start + (end - start) * amount; } float2 cultmath_lerp(float2 start, float2 end, float2 amount) { return start + (end - start) * amount; } From 08e213dd7c5d7eb6ccbfec4d6d064d1178aaf149 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:32:43 +0200 Subject: [PATCH 18/20] Compare mirror results by bit pattern and say what that proves SequenceEqual on floats treats -0 as 0. The mirror test now compares SingleToInt32Bits, with any NaN equal to any NaN. Its summary and design.md now say the test proves CultMath.hlsl's text computes the same float32 results as C# math on the CPU, not that a GPU agrees: driver sin precision alone makes cultmath_hash and value noise differ on hardware. Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 5 +++++ .../CultMath.Tests/HlslSourceCompatibilityTests.cs | 13 ++++++++----- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index 9153b63d..e716bb6f 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -85,6 +85,11 @@ The HLSL side is checked too: `tools/get-dxc.ps1` fetches Microsoft's DirectXShaderCompiler, and `dxc -T lib_6_3 -HV 2021 shaders/CultMath.hlsl` must compile cleanly. +The mirror test compares bit patterns (any NaN equals any NaN; -0 differs from +0). It proves the text of `CultMath.hlsl` computes the same float32 results as +C# `math` on the CPU, not that a GPU agrees: driver `sin` precision alone makes +`cultmath_hash` and value noise differ bit for bit on hardware. + Where HLSL is silent, CultMath keeps its own decisions and does not defer to Unity.Mathematics: `normalize` is safe (divides by `max(length, 1e-20)`), `hash` returns float, and `Random` is CultMath's own xorshift32. Engine-shaped diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs index 9c57ac70..d0ce8bbd 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -37,10 +37,12 @@ public sealed class HlslSourceCompatibilityTests private static readonly float[] Specials = { 0.0f, -0.0f, 1.0f, -1.0f, 0.5f, -2.75f, 3.0f, 1.0e-7f, 1.0e4f, -1.0e4f, 1.0e7f, float.NaN }; ///

- /// Every mirror function with a C# math counterpart returns the same bits (NaN equal to NaN, -0 equal - /// to 0) over random inputs, every special value in every argument (ties, zeros, negatives, NaN, - /// large values, integer lattice points), special pairs, and vectors whose first two components tie - /// (x0.x == x0.y in snoise). Equality is exact: both sides are float32 C# over the same intrinsics. + /// Every mirror function with a C# math counterpart returns the same bits (any NaN equals any NaN; + /// -0 differs from 0) over random inputs, every special value in every argument (ties, zeros, + /// negatives, NaN, large values, integer lattice points), special pairs, and vectors whose first two + /// components tie (x0.x == x0.y in snoise). This proves the text of CultMath.hlsl computes the same + /// float32 results as C# math on the CPU. It does not prove GPU agreement: driver sin precision alone + /// makes cultmath_hash and value noise differ bit for bit on hardware. /// [Fact] public void EveryMirrorFunctionMatchesCSharpMath() @@ -78,7 +80,8 @@ public sealed class HlslSourceCompatibilityTests : Activator.CreateInstance(t, Enumerable.Range(0, Components(t)).Select(_ => (object)input(slot++)).ToArray())!).ToArray(); var expected = Floats(counterpart.Invoke(null, args)!); var actual = Floats(mirror.Invoke(shader, args)!); - if (!expected.SequenceEqual(actual)) + if (expected.Length != actual.Length || expected.Zip(actual).Any(p => !(float.IsNaN(p.First) && float.IsNaN(p.Second)) + && BitConverter.SingleToInt32Bits(p.First) != BitConverter.SingleToInt32Bits(p.Second))) { mismatches.Add($"{mirror.Name}({string.Join(", ", args.Select(a => string.Join(" ", Floats(a))))}): C# {string.Join(" ", expected)}, mirror {string.Join(" ", actual)}"); } From 19e23db2110136c30589e04fcb400944260ef2a3 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:47:10 +0200 Subject: [PATCH 19/20] Make double min/max follow DXIL FMin/FMax dxc lowers double min/max to dx.op.binary.f64 opcodes 36/35 (FMin/FMax), the same operations as float, so Math.Min/Math.Max (NaN-propagating) was the wrong rule. Double min/max now use the float formulas, with NaN and signed-zero assertions beside the float ones. Tracked Unity DLL rebuilt. Co-Authored-By: Claude Opus 5 --- packages/cultmath/src/CultMath/math.cs | 5 +++-- .../CultMath.Tests/HlslSemanticsTests.cs | 8 ++++++++ .../Runtime/Plugins/CultMath.dll | Bin 296960 -> 296960 bytes .../Runtime/Plugins/CultMath.pdb | Bin 140892 -> 140892 bytes 4 files changed, 11 insertions(+), 2 deletions(-) diff --git a/packages/cultmath/src/CultMath/math.cs b/packages/cultmath/src/CultMath/math.cs index 99ad5ecb..ca74857f 100644 --- a/packages/cultmath/src/CultMath/math.cs +++ b/packages/cultmath/src/CultMath/math.cs @@ -402,8 +402,9 @@ public static partial class math public static float3 atan2(float3 y, float3 x) => new(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z)); public static float4 atan2(float4 y, float4 x) => new(atan2(y.x, x.x), atan2(y.y, x.y), atan2(y.z, x.z), atan2(y.w, x.w)); - public static double min(double left, double right) => Math.Min(left, right); - public static double max(double left, double right) => Math.Max(left, right); + // DXIL FMin/FMax take double overloads with the same rules as float (see min/max above). + public static double min(double left, double right) => left < right || double.IsNaN(right) ? left : right; + public static double max(double left, double right) => left >= right || double.IsNaN(right) ? left : right; public static bool any(bool2 value) => value.x || value.y; public static bool any(bool3 value) => value.x || value.y || value.z; diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs index 65845fc9..7b845ea7 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSemanticsTests.cs @@ -178,6 +178,14 @@ public sealed class HlslSemanticsTests Assert.Equal(Bits(-0.0f), Bits(math.max(-0.0f, 0.0f))); Assert.Equal(Bits(0.0f), Bits(math.min(-0.0f, 0.0f))); Assert.Equal(Bits(0.0f), Bits(math.saturate(-0.0f))); + Assert.Equal(1.0, math.min(double.NaN, 1.0)); + Assert.Equal(1.0, math.min(1.0, double.NaN)); + Assert.Equal(1.0, math.max(double.NaN, 1.0)); + Assert.Equal(1.0, math.max(1.0, double.NaN)); + Assert.True(double.IsNaN(math.max(double.NaN, double.NaN))); + static long DoubleBits(double value) => BitConverter.DoubleToInt64Bits(value); + Assert.Equal(DoubleBits(-0.0), DoubleBits(math.max(-0.0, 0.0))); + Assert.Equal(DoubleBits(0.0), DoubleBits(math.min(-0.0, 0.0))); Assert.Equal(0, math.sign(float.NaN)); Assert.Equal(-1, math.sign(-0.5f)); diff --git a/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll b/packages/cultmath/unity/org.gamecult.cultmath/Runtime/Plugins/CultMath.dll index f76850f776c92794db748acec93708535076841a..bf712012ee75b870340835a98c75593f17d6d33e 100644 GIT binary patch literal 296960 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

yXUIFsG|bMBca$@+ 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�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 Br^NsO literal 296960 zcmeFaf3RiORVH@(-ur&^d)@E#?I*qdA^&JMmV9}yB^n9I#y`}JguvKf6B(QC*CSh& zkpMGTrW=FtQ`>EMFpRJn#zj(K2*tQ!NIaPzNzFJ6lZh!8O8h*=wDB*E)AnsmedoZEN3s_P5shzPANy!G@BYzq z?|Jw8-uLW}pL^=*bJsuczH>kPzH{IH*0-Je(Pw|)>HCf!-*{yS{k@NkM&Es8GJ4r> z{M5hd*uFA4e{S>0#nI@Ns9I&~#;-~JoYa3EN=GNOKBjIoXe%mTk(#vQ&t&xEPs0@d zx6g8jCi(OC|KsWCt*A)ce~v`7e|~2=Iwo!Z^jD{&?`yH4<8!0Yy2IDy_>J!Pz8`=3 zgFi0ECq7*Ib<1>jX5#YXeb;YXe~&b%Hqkhe|Bs$WVSg^maNT$P>A(D}7((kvG;0n% zzF_x=d9n7drT_Q?ZR63(=*c&XM<0CGcyvTt|KArc8_(|?jW+h)$c9l3jV z@~bx`%b)wVO+Ypl&>=B#e5oJStM`Q+AAEB75O z&i5YKJ2~1~ncpQ&Cyz||IWEVOEjG+wBIwR^{!)CboLoKslfSorznbputf}Cg_1XF- z_e9ms(XO)5RW`fIvDbXR$lo5#)@JMTmr1PI(fLfoZ6C3g4YsUm%ge=Peh!A4Y+h@c zk7@JC;}Yl(CwxN}^+3~sbb7NT{{9zZ&hFJUTn6t~)z-OT3xlvmJ(Anai+j?A#&oL*UNY<_)Nv z-J!%gyC-+0Uy`(q*)all8gPuj=C;ekNy*jh*tSc8wn#Rw>_}r7(b@XdhkxnCuYdhD zpO68cBHQzQ;dsl{ol`5wba!-mc4~I&V0LibL~(_rYsNE4kZh6fO4V3$JSRazRr5P-u3nP_H=cAzeK%T!>+B*Uy#7lqX+Y! zkE(H~03vy#K}nV)&t# zc75*7-c#G-a`v9yp49VrT54yvS4vG%U(WZJ$XTw}0L{`#={Zj1-Az3ykMWc|Ue3&E z`CKWVtL1a8e6E+zqp$g^B6RzR^cE*+IY*~*Xy@Z9&&QQs;~E>sy~ZgUC%wiMHm*ve zUI*5Byw)9)^Q3U&ggLn>XQEb)$>h??@!6D>t=S4I+j31&=tQ{~%r<9|COzRd>~!DR zoE@8;2-=U$j?XrO_T#gy*|DH~OI6|QJqcA>fhw&)6)LmU?V2~9tJ^hYdOY2(+0x^c z?V2bYudQF%Tq~18PU|0%(|Z3WWn_2`@6056IoY;XOXK)pHp6+iQjxU=8CRruzoqk; zRHS%!h@8Jw$ED}G`Tb>FU^UJnBT0Ok@H;7c%8w!8~g9yKC;UGZEjEe z*@ttnp5bFX1J|1KaC_WyDDHah#tuAj$ExN2kIRtlTpW+&wjiqrId6A=apTnH{+;8s zUtGO!^ZHwH;(m*a>W4HP1&-@JueOPEOsoxqote2%C-l zJI05w+SuQ`{+~hQgAlp8_bD2RDhUJ2y)K+HJ3k)Z*b)7EPcho=i$@quDg>S`}p<0FWF`LC$P99sMYzaCFgr@88b^1 zHP^hpj1GI}%aF=aPm`w&I=GbzW5k5iCK#~knG&1xf()D-Vhl6#G{y=PW1Rxk*dmva z?>ek1-s7f32dGCMaJ&)F^Dx_@wDa&l;9>BMz6SyG_)sSlJ@EA#vQS^$3t{z+V8@!n zfw%dUUiQ5`oO+v4qnv=16*iBs--|F>LT@u2fCF#yYx+&V!>P9!HQYXidDoNV_IaZh zfbjI_oy`k*)DtQ^G1RX=cl~K)qtJMhBK0-}b%+_({F?c*2nXC2cEH<=DtF7;crU_e z3BAp901mv(FXZ-c>TO01HvuaNKeM~5cZplFXqlcm#kwpkrh5l+kCL}9Saux8$I8tu zG|Rnm=i-sk>$~;GV-u;#!_8<@{<}l|+rMjk2)~W}myQqNscRDWwri3?97kr~N&jl!p>~q;Up!Jf%Pwd`AnbuM z40OXH$Wvhvg!LrWKr%OE4J6~JYao1L4fLa21IfZbXM@USjJYiM_xJwG>;FVoLO{z( z2t6xRaB)%etymO2KAuc*8xCSR|2{6$z5c1yTLSc69} z`=@GiI1NtkG&nn!1}B^bCmaMf&E>M#SMK2;xQEl=X4K@IfRzJq8k`*q(!#KWQ4fO? z4uV_QFfASqf_pd(PJw}PdJ|5A6HbGhf~MaDjA8)p1vj~ z22m5-!)b5|43yJ5O^b)q;515uTZ~XSVGCX#E;XQjPf(k*``T0=)LGS2d0uph>Xfl5AoKnm89vJ(_sJA!$Y_i(%`>()27LSBv_Afn>42>0 zgRV>sWQ$Wno-GvjPx9U4w~m&3kf;wG9zZ<=z(JrYQNQ3p45s!-XwjRv1Oh?=M%X-E z>RF?m3YEaG%Lzsm0@K?Mr`_z-#PuK2EY-aG z)+?z8I5TuSB5%TJaKbvwk+%(b$W1s6PB;ioR_jF*+`~a|52wM+C=5&W;5+ zH$UEDLT-8o!7XgFBw(gI94Pm28k_fKdRZbWb zVQ|7ha0}az7DQNmlz$gabUT_N-ofm8k}$%oNyZ4 z6oefkoCYUs!QZzl8w9Yrz9nDL%Lai{JdiJkr?QD^a#MCZV~2ozcaI$c@`yJbZ%uE? zJ^>8qGH{h$2IeXU<|+r~`fj>@ z%?rkk1M|g^IpfH@yZ%a6u}A++NV@##2dfEV2Fl(9AF?Kpnc!vxU3UMu5B0#l*M+SM z76e-tysqBN+3B#N+ZtB5)j>OpR=59Q zWv;F7MJp}`Q+*tr>f<^gaqxR1io=KdtuA5>sPXvZ$u|O1LU2VgI8vOX924TQcS27b z?5@y?G+?IaW(uuH0|rGKv?2`{7j4jrykug&QPxcjY(j|U?T!NFRgf}Ne}o?}R`zNP z>H*_U85pRqF;<|+fF!(RqA^Mu*QP+3_wSU^KTzh4J7sVRl_}6Dqp>Ng?+3jxV044V zC~G&^6e#oloicoe$`ojn(Kt}%jXPyDHf6ON-WV{tL1UEchP;2_q_VQU%CRPnVhAX2 z_d?8jC`TWF;*x_1(Edh%an!d$%2eJ8Y1s14PWxFqMM6`u)E%aHsl<*TSg4nP=?&wm zQIQ4HHZJfcrHs2ouaDc;i=$94fhBs?DAY@L(;IfzyTjDFOLvsDyBrvsE+JrgWkkG3 zphV#^AIjXo3XCh3#@&?Ej%4mIMMubP8XCO@hk)sALYa~Zz}AmpC{c~dP@%Ubk?zpb zC?S9{1Wd_N!hTM0v{bJeg?i~8=p|r!Ls>p9Of3&|M_Iee3B`vbt5SpG42$aynl+;|K zX=zT>D9j1nEhpiKcz2lEh|oRIO8{l8yPJ~Qk<1;Y=!kbmz0s?q ztM@vIdVRyYdOf8LcN7YXEOVrfch<_H8F=121SoMv;bWTyLqrUlB{E{ByhhoOLv#|<}!OM4l46V|@w zaLP^Zl$)tfxe2G-gi~(9DL02Ca+^`eO&H|> zoO07U<>rtCIj0}tl$&tMP1v}9VSwV z%DAdSIIfh#GF3}BRckTAOc6G<%_so~=al*REB(^GYP`}{NVZAi1EL?qsY}w|Hk9tl$+kh9VSvE1(ODDmPpTsdZ-pI1DPUhYM07Uhj3ge zhXGLz$Vt^QMsNlYU}L<6eZJAmldF0XXHRcgjsT z<%ZutzX_+@gi~(9#$D%^iYoU$&Huo?j~(DBaS(emWD!o)(%aN7m7@;Ly>F4v`X@7z zur~_SdKmR)*gb4&!{8~m#R!8FPPqxE+=NqZ4tv^f!YMc5l$&tM4IrG)rrF=gnxxV@ zkTG>0a;Jg5>C}xq-K8k;HI|bnJ~+g z+hT;lEye(xas%))WN9MRp(GNLaSyiccke^eOpyjrnVUd00W~$*tnPWRUJxS;f7P&`qy2?Qnlnm*>py8SibWN z#?`~7wsLzo;P$X_hkaGk;4%g`>nj6V*swEZGytb+>1}G8zFN-1;Dixl08Y8-opJ;4 zb82ZK)uFlfnZj<;q-x2RswIrF=_@JhYBc}{+}=Cj_HfG0K@8?Iy$Pq>gi~(9DYpp> z`)vva;FO!*DK`K=L+a!;zh?bRz{9AA(ilA8Hr9~a! zIzyO)XftG~9CZlKB_GiGS5xodR4wJCYB@fpwh2x+uyNFv=!4$HZpV032|8Z{rRVsiwhY3~n~A zK47ZWj6$`9Q4YYSwkFd2ILktB`1v`tw6E&WTq8Le zgi~(9C>w8TPUn<|t>0lH)ijtiaI;C{1EM}4CsoUYSf-ZBQHO9`DTe`3hH?m}Y6+)m zt;b<-Q!oIh-1JVl0r)eZoBh|Bg`SO8B+W0 z;gp-+DL3Jio4HH538&nIQ*Od3H@lZ|TkpfH5l*=YqolWN$p%vyV{u!>E^Rhx|Fr3u z@|P959S8a^R{%C+Wz3BMo3Zle#(-hWLDEe0jTLD2tkW1}-5}2 z#+@=a`JC0r3N*@Sj4+K1ZwwfHrZLLe4K@YJynm+*pP@1Z8f7#NlzHP$8I4U@?Xx!q zjBd~vCA%Rz$!wk#ef_QWZq7x3@*}MRhC{Z}r7~3iF?xv)6By)!;Izo2~(&#lf1Wa!e%9K<9 zwtfsliE7mBS)~TLquwYXfHDM3$x_08PH?nTuNsAV=^p4MV0uGYJ}yjcsOXNec9$6l z=9~viNhMS`m|8Fep?60;Bs3*UvP>0=)#5=vAXa*w;(i z-Z{-C)6*z1I0Q^d%{7{q=0uIcoY38J5{`&>hpCMS-J!bCO8{jB*c8k;4+KgS9+-39 z-IUahWbQCUN4z`gjb0sHy$2EqhC- z9B_N@fZM|3Cp--~d{ZKk0#!YBvel$+iuH;1H`bCc6Oo~GRNPPqvicb#8K z5qwpx4$U>v%R#7tQ6ikGC2VS!%29_R2W~j~7UjUI85wUB7$a!^R!M)Y6+X#I%&Lj z$_>Az1}G8zFN-1;Dixl08Y8-opJ;4b82ZK)uFjYn!;|BiXCCovz8M0K4I)vwv4`}_XsrPWImU2?H96nRq z1Sgzw6Hd7ar`*(^a$EPpJQGg238SpuYyux=Q!}R);aZj z6E^NTzcj{@#SGjq-52>%wQw286k$`lRE|0{>kTi50a1p@Bb=(WNTD}jQ`@A1aLP>> zWfPoZVl!(14!FIyafgXi)8H}&Hyc+UFjZ?tp<2Qy2VhfM6KQ_U_XPAPix4}Cg5j4PT@m-2IMqg`E>xG z`s)B%kp|dlgI1&g9@?N4X;4@E27y-in;)0u_Zj4eM`kx(FF&xbv3mW1Bct~}`v$4s zvwHo}T9==F_(#*x>V>1LFF*I}!-~HAW~n@T2|vw%-w*jUi6y_dFq>R|bM>5z=YLN; zH%^XT+`UJB079)vFuDGAZ}$1r>^w^Fko^Jc%Dn4Q|YZ#YV#XJa zk0+l+g}l3a7>CK|-OAkKp6D1q`-mvG@STo*qC?I0Zz}DepXi9Q{ZwfO|3n8~+vRsV zUMM5-_;fr+${$}D&ymx|x1<4CdwlOFIkaRz*Pdog6=B0kx_3+c5HP>C11! z$dyZf8wQ{FZJ0mAVD93to9O&eN%K|w9?X}oe?(5t)AdJSfPdnCxgh9|z<`NI^KTdO z`D0S-y+w9gQ5E31P87L{p-C@mT9F2z+Mt!n4VWWXn_$4EXG(0&bB-pbrx?SGJdLpe z#aP*^u|<}hn}B?I<7-Gu1E@zIaJ&)F^Dx_@wDa&l;9+o8#U?8W)TG_cqfUr0U7DMI z=G#1e^&85SeN-ztt8TqqW=U!KHT3`rrbHP26z>kalbe+lG`<} z$B#{N8WQ=lQEv5{3}-WV`e9W+KsWp$FcWOkQpYhsUh>Ng%5s_((B z!n^Sxph_bT3x&UC0)JlJc|qhQp4UTOaH|q_Dj+0agkfAYDsf?obqKpoca*gw>;mB) zp$CjmLV3VKRV50S9%|U8hjh0fjS_=HzzC}ncFMGeO4O(*fhlrAD!QZI5E4LH0XAu` zG@~J4p{f$~3vvQeDDiOvLJAFf=;NwU(?iCkJIY2cfq;;HMpz|Uz$O#{3stX18blZJ zwMms|Q$4darMItUx36Z4S4o{&x36a1-2x|%-Yw*gg4A$%arHo{sOyAeN znafLisQZS}U@b~~OWK3Sykh-tF45?fVx+I#Wc7;Yy?q?(IvDTWWaaDMyTL}E>0s49 z)AioF!4eN}8qPhy;l0}jv5c0hureOP;>LI2t&22$r+khN-zX)m_;wD4@^}Z!r`i5I zy(bz&p6CEgw7fzCc@l%yq{C`+=hCz8g_B1<3wO02uET0G!(Ek=06wL;7fzH|xPyMU z4y(-!Cy(FiQ<{6>UwabOOd^{bt&R=w~t$2+tw608~zG-=~~gQaM6x>ed%j7bNNwued%jN+Ju+B z_-+T!&Ue0l+I!~d0 zZ{CL+%*s|d`X+$*o?V-#H}&}b@pCxj-R>bCOnB4jAk4qL3h9wR@UC7sFfWBVFG70s z0>7U>y1zx9Jx1BPzC9kj|Hgx|82FIf_osT_moJ89tv{- zf+1fWL-gbjr7i~W)v+=iqU_cOlCW+aA&V1PM@Up%N8l6di2tLmBQz&;mVeiBU-loY zjGjWq<0u~_*Y`5Yg z;Py0O`IZmZL`!+pgT+KkIe^_n%PVz_q1K&YXH(%WP8Xu*-Q$wyK;x1FI^%Z z3X=;DjtGQL#3*o&OCA!9OAd_dpwHDAb~Y6z7oI8+2%m^i;2xJeK^m7F7}vEvS7+GS zRG3_NUm?wiz) z7l&$F&CG&~0+3QGh}2p1Nyj}>IdY`s+t^Cl*}mAB$>Xekq4{y)!n75jkfNfb_KmKc z1?8F5b(Rmhj#?j8HTLJaF4IPxN&vOzLvJxHGSsvvDRmWNQRRDLr-u)>P7fQL9(|_m z>v2x{L|jtGr{lgJH7$BdUG-ShFZT4vv#=8*M@~uk4!I6WXZvDj)_u!d2L%t%2qzY0 zQ0yCQmjpf~dtUtp+f&zXu_X%H4PuS8-4YG@p6jgz-;1M-kIPdw;_-o>rHS5 zaySi6?=(1joCYVH1}7W@H_c`0_LX}$2=3uDxEVD$Ct&3OoCasdg0wI!VbsImgoEG~ zHcX3$gWw)cgHvFjoZf`f;DpoQrl9FJ0izgzd%;a@cb4>&FTy?Li*Op;Osh0&>aLY( zaGIvU+3!?2;WRkmAh;J81ov#R7{vhG3vL0!lV}m{DPM%s;Otm0E#8}O8k}$%+#=O} zTT{1&NQ2Wf2u@aLZe|NTJRAh~a2ni<8s!A69Dvi{lo{llVXYToaKb@w3mc}z!ysyc zdpHeFfq`;*r)lwU8k|OHaElQtCv3s%!=(oNVEH-?2fQ^5Ja3{Kcu=FUhE)IhRHs0B z1OyCYmzut@0?qTHOH`+fO#zwr@5u032DwkBKto1jglYQhjRD_&IIWK41;IxM%xe)2nY!vO5?%l zV%kF`W$NHVUl5oQx(9>=P*y@VvFk?IJY8C-szm*QoWS(Z=KVtMIoCYVH1~&ywzX=${0Ne|1YP++fr+g9aDPM%s;AUE- zSyQ)KNQ2Wf4bFb2$_b~z2?xQwz#zDXgWw)cgPT#476Midz-e%HELBbz6k%|}L2wJ( zoJ3UX;UKt&)8LF0D5p2!G&tcjxG8A*O~5Dy;9hVG7@kCna8LOnoCasddTH_Agwx=J z)8H1V_S>3nKb*R=glVyKHaF-+7%fdweQJXN^>8qt9!`T(U>clo8k}$%+!TZzBb){& zY{CDa*|?-D;#(IbZQXvSZuc6V5^jC70DE7O-D@jqc=OeAEdTt_*2>l@8(yOgYg_AE zN7?YL@Q`gSG@ag5gO!`wEPK=tKp#@DeGLZ_uHrig9Wh9cItZOGNRI?U{2CAk7Eqxs zAfYaxLR~;YT|g+U0dZgf73u;K>H;d%1tg?L|JeR<1=+-gzr!=yzmq+ey>?)h57_s% z+{r$%qa&G5_{SKUJ$KzO`Q2x-4^M|xHsgIWc4%XdK<2+jOD!!{3GnaYU%9#vrsUQo ziKtwvJIZV^Y4`UCa-k!H%k532t*(3guGO{P@#ghkuKOL2VnZgM6j$co zg>=ex4V|fnD0PFy1=+5lv*r*bn@(~ZCx;l#ZW~6o*HQktDB0_HN7<`^PwdrrGotHW z4MZMmurd8*OJMhJ7<^GOfIrtiD;i&Zv~GHYk51IOV}oZGrexi=!6r<_(j=Q6q1ij0 zEltkxuF~WjU&8)*$Cs8S=lHVHWR7mP2<&g*uQfJ*v=+DN#JVLLQp25>5~_(( z4(axgxaq&8CjVRtwq(jbY=$kF@-LX_zojPsa#{E9smNb{;oq}+Y$~;}{MYTxe5us; zUpYQRh>iVw#)k-^8#NI|H)JxWC#QU`{2%BZPC19<%zK-b-zO!#Wk2T& z?2l~Z1gm@?gnS^z)3o|CnoP9gvP%<&6D{Qc<`XUD08SGvuh8|=#kKS596H--)&=k4 zb|HJwdO~CirwNe*6CwvDCj#RWF^gGGh;05eA#z|skH|;I)~1-no$V0jv_if z5g4C{S`tw6}w>s5wrH>X>Pd})~m!W*Pc*q@LFqc>-=z0%8uG1+I;z!So^sxyKAW)rdwD2E3vSuPi>2ID_t+5<2fvrMIDEL@>LS*F8js(UaHHLn z5L`J9Og*!W1QVCNzJPVFuU4c1mfD~dX@HY9Xhj;}uMJvxQwVg_FN*<7$uEsQ=rWIcgpA=DD%dhGB}0G6lj#u z*p$_;sJ$^@e78$ul(idd3Y2;OP8mK!WePOPXdEc>#+@=6o3h#sZwwgSpfO5z<0(JS zioWj4Rn9gy=ORFPBS1O&02GHD1hl`AhjG+zG0TLC{t1a*!nRH zC8|*wD)iPQ(j9slB?M50fGJr@*v|=$mg-fbP%qsBy#!2eD9gu%spWz0C~J3_fnd&g zz?4)%g@dUDQxJN0)I&m3vNSGCEiPEX{CZhx)Z~}4=#H|HMIg{iV2NHeDujK#q(zn+ zLemohff9O{lA3EYEzOAdy>o<3EKNzx9D#tt{77CO)@;s|%yb(}TA(~nqdB1dN@@JAzXDZkxS*MLy-f0_*R7z#q(MJD$I_jbIQYkS`VY%47-O@ZVC*> zmEMF?Zo(-yVdD-HsYHB1*NrhensKEZmZ@68salH>W{R+>ZAJ+|IH%0dU+I_jRpXUO z1IadNd_dGgwUiU6HJzba4+oj@aKP|jl-rD|G>!)Nx=UJ*dlBw&FTy?U zMHmV~ZZjQ#Q*L^v+=NqZ_%$=ctRzX)182aQ*JW~rCFo_IOV2y%B`cwC%|rT zZhQlCibnKKxe2G-0K)lfn*E)uNh-ZlZo&aKMd?hA`t4!pXmal1fZM~y9Zp^~E$31> zui#PF8$QFV2eXrWgj2N^DeMekQ(N=Q;MS$k+Y}7IFdBeUZUBCUEKQ_3l&b*Jg?q4d zzk45&W{P~NTEZxs&JalFl!pUu4;y#bS2YbL4cx4+J|OC$TBaqKQ}iaBswHe{Yo5J# z$_>AzHv_00u^huyHT# zt2&gv!VRak^{=~(rE1BCvgwTGu)Goo#?`~7wsLzo;P$X_hkaGk;4%g`>nj6V*swEZ zGytb+>1}G8zFN-1;Dixl08Y8-opJ;4b82ZK)uFlfnZj<;q-x2RswIrF=_@JhYBc}{ z+}=Cj_HfG0K@8?Iy$Pq>gi~(9DYpp>`)vva;FO!*DK`K=L+a!;zh?bRz{9AA(ilA8 zHr9~a!IzyO)XftG~9CZlKB_GiGS5xodR4wJCYB@fp zwh2x+uyN zFv=!4$HZpV032|8Z{rRVsiwhY3~n~AK47ZWj6$`9Q4YYSwkFd2ILktB`1v`tw6E&W zTq8Legi~(9C>w8TPUn<|t>0lH)ijtiaI;C{1EM}4 zCsoUYSf-ZBQHO9`DTe`3hH?m}Y6+)mt;b<-Q!oIh-1JVl0r)eZoBh|Bg`SO8B+W0;gp-+DL3Jio4HH538&nIQ*Od3H@lZ|TkpfH z5l*=YqolWN$p%vy;}4d9X^lf>r8Cm&rW56)x zAZaH0#tJlh)@f{-tAC)(`*+IdA1L$2oiaH2oYe#=&?uv^DGQAO-`?l1LteMB+05j7 zrV!8(`-}4LvDw5eqZ0u-5)pubB1heVrvb|jzA_Pd`?@`$DOu{S^GJ5r(cR6azAQI$ z6bR$0QQ26iv#5z{y=s6ZdVSo!UL1w_C1Cjt^{P>*m+q!_sXI)u5t3=7JIXpybjbV_ zuFJ0nOs|CUK%hk7U}J2j#Jii4+L6p1rsxRWElAT5gG0ddHla*O1z_vPFqEi9&7M_i zpgZb~5&|egz?3W{?B@hWOZBQzsF&`6UIL~!l;z{X)P{=gC~J3_0ZvJjAz(@>q51_= z3#K6SaZwNBnv$h)VQO)~66V*-Qllonltp)xjVuCzUII(>s!<{A>m_ZFU(?elArL4b zU`lGP(X=!tY82*#?v|5qM7%ppZA9oE=p}%%_K;1%oby1SMB#xs=iN<7?MUVhQ*^|; zqu%J%(bcOnfiSKbHTh*+x?8U*A%P`&ecZlYx(9k;7S0FNQ_`qLp zx}$8;NFdP5H1*CAHnB7%HFE?44)Y_qJdD|F^Y!{rvIr|*x1DDZR@NMbf-pG3mQjhk z38&nIQ*Od3H&d?}j<^Y@+=NqZ!YMb0B;_WYauZIu38QRs&V<nkzM_U(QCIL(9HGHslZL2f;4xvkeP!W_O} zTs@p}(>vuRY~10vDp7g!st)B78;DHtssVlp^@5S{<5eq?f}%Ow|%j z)e<(fOXa9TkpnlJeT#Bn)eM|B3eBpT%sT0 zl$&tMO*rKSFu+YXLkFq=B3D)dxg9RLfxx#+BZLQ?-OmZJjjUJLQJo(s9*DrLXD`jw|^X zFjY$!Wta-WsajH`nIfEWo4}BpFv<#3j?E^YDarF9+~Zz^(J~M`<>nao`t5@gPPqxE z+=Pw0PIsjU)*I^3tT((ItA~9hoT?>^a=_cvHp2j5V3Y_O_tL(qL+LBraB5rsy4Sj? zTJoW6I-@ys?+piFQ(L*ccfjpo;|}|(rom+lZq`=@w6LLCGa7(Xwe&W%OwDS8u5 zxe2G-gi~%481~x~48SQjy;E)geumV^YkvMsPza~o3?6VBYsl?k%Xv6?)ik&Yz|F1# zK475M!>BiTCd@&!8M0K4I)vwv4`}_Xx%F_WmU2?H96nRq1Sgzw6Hd7ar`*(^a$EPp zJQGg238SpuYyux=Q!}R);aZj6E^NTzcj{@#SGjq-52>% zwQw286k$`lRE|0{>kTi50a1p@Bb=(WNTD}jQ`@A1aLP>>WfPoZVl!(14!FIyafgXi z)8H}&Hyc+UFjZ?tp<2Qy2VhfM6KQ^&WuZ6x{G3|aS9NHvksJ;3F<`2eFvS8cZ6v*`)CSQ6G?#s%1hfQ%mKjLpZLK!+7=Tl5dZ*j~{25TsAM?qq#9V%HL4I*;Ho34mId$LW{>kwnO!Q}* zVATGM)2C>-v429Mz!JaAq|w|jGo6>;W%}%f{G`|8jP@hrLzw&s|FQVC@jK*)m|*#x z^7+H#!#CoC?()M-#aMod2@#%V`|}JtQK|AHN`NL>UI`53$BoS3YG82S4GsbW`7t1i za4j&9AL%iJCus137m1(EF$?)YoE=F!esu~dWIymDHqK;Blh5=`^d~{Q6@K7DWAzQE ztsxpBQu(=)6=Z^W*qEkS||w&M|c*Qa4O$aMr1UuFo4!q5; z^s?{m;ndrV8s!A6tgv~6{a%F85_+5I033LmU(;^_9!|Z@sNwc8%)6c>x6d2B0EDN9 z=H~W!gA1F@qGo!vSB(MKW}jS67?9pp54}@v^ZWnpym@AKSML(HF3UyW)G5}#P3rnv z!Lk;@@=TUO_+3s}3U$B7DGN-l(;k~hZ7lzFzsI?M*Z2@_`V*XR)U_L2+qK)D*iZ0w zKf1YpTG-%?WgMLGskCl6cMpDNQ)lt}NG0nz*vbb?e}sFftFzai9wXE~ZS`N(m z30i;A_Y#XfGsltH%M$QCSOWGP#ytl)at>oUe6`0g)^(mEVS{(WVoj;~o?Ib1Pc}GD zT`~qDWy$E=t3ndElj<3hPVn(_3H48dH8(Sbl*{*O&Oj`f|3Z z>&vH@GX`Uj`4(20{B1uu6ZOyaPs@_?OkHx~w6G;7t<46(2PeH_0YhYQkFFHUnk zWu(!qN~dhZauVTr0&wONk@cybj##j2MH)b@3s$X21G1nET9G?3ELm~|TASd}EK1e3 zEJ`(CHAb`n|jQils~51ci;SXU+NR6t0; z2*bE)RN}%E&minN-BH$#z@USBgdQ+L3FQF`Rh1}QdZ?^T59w|}8YKpYfDu+D?38H_ zm8els0#oFKRCGtZAtZpZ0&LP=X+}f9LRBT|7vuz{P~zhTgcKU|(8pDyriYA6ca)7@ z0s$fYjIc_yfK4a@7D`rjmL^}XE4xKl6?Tt$i?9ZdV0J^*=5QL^B_Z-=$I{@0)8K>y z<))d*Y0~21Ah?Iq;ARvCC!7W+oCasdg0z@lxyJUB>fs=`g$>i<;Xt{E)8JGPD5p2! zG&tcjxG89IPQWMz;9hW38=gdqa8LOnoCY`3D$Sa@Yh@aorfG2YyO(nxoNyYPa1h+b z2!eY!2=3uDxEVERAzfL|mlp3$I1NrX4Q`QYzpbfTL!`lJ8U!aRG&i$_ z9v%*YdpHelMvZa;Rt~^vaLNpF&al>tFgW2LxP=YV;$aXq!9AP?r@%ltz0UT1=NxQF2^+63*@|5$aeDHNtHP(>1F01sXCMBTVy*?TrE7emJd=~EBc@-Qv=!J)R1Qj#r>0f_b{!a z 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 RJOw5##(?cJ6_^gQ0st?lYN!AJ From d4c43ed2659c08223308ea843b610a567fe58490 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 14 Sep 2026 14:47:10 +0200 Subject: [PATCH 20/20] Say where intrinsic rules are pinned and that NaN does not propagate The mirror compiles under using static CultMath.math, so it proves composition, not intrinsic rules; HlslSemanticsTests alone pins those. design.md also states where FMin/FMax/Saturate turn NaN or infinity into numbers and tells callers to check isnan first. Co-Authored-By: Claude Opus 5 --- packages/cultmath/docs/design.md | 19 ++++++++++++++++--- .../HlslSourceCompatibilityTests.cs | 4 +++- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/packages/cultmath/docs/design.md b/packages/cultmath/docs/design.md index e716bb6f..de09ee26 100644 --- a/packages/cultmath/docs/design.md +++ b/packages/cultmath/docs/design.md @@ -46,8 +46,8 @@ That makes these HLSL rules, not options: sides rather than leaning on implicit scalar splat. - Intrinsics return HLSL's types and edge cases: `sign` returns `int`/`intN` (NaN gives 0); `step(y, x)` is `x < y ? 0 : 1` (NaN gives 1), which is how dxc - lowers it, in C# and in the HLSL mirror; float `min`, `max`, `clamp`, and - `saturate` follow the DXIL `FMin`/`FMax`/`Saturate` operations dxc emits for + lowers it, in C# and in the HLSL mirror; float and double `min` and `max`, and + float `clamp` and `saturate`, follow the DXIL `FMin`/`FMax`/`Saturate` operations dxc emits for them: `min(a, b)` is `a < b ? a : b`, `max(a, b)` is `a >= b ? a : b`, a NaN operand returns the other (so `saturate(NaN)` is 0), `clamp(x, a, b)` is `min(max(x, a), b)`, and `saturate(x)` is `min(1, max(0, x))`, which maps -0 @@ -59,6 +59,16 @@ dxc marks float arithmetic and compares `fast` (no NaNs) unless a value is GPUs are not guaranteed. CultMath defines the CPU result by dxc's lowering and the DXIL operation spec (DirectXShaderCompiler `docs/DXIL.rst`). +NaN does not reliably propagate through CultMath, just as it does not on the +GPU. Because `min`, `max`, and `saturate` return the non-NaN operand, some +functions turn NaN or infinity into numbers: `smoothstep(a, a, a)` is 0; +infinite inputs to `smoothstep` and the intercept helpers give numbers; the +bezier, `smoothstep01`, and `smootherstep` functions return finite values for +NaN input; and `normalize((NaN, 2.41))` is `(NaN, 2.41e20)`, because the NaN +length is clamped to the epsilon and the other component is divided by it. +Callers that must detect bad data should check `isnan` before calling these +functions. + Deferred until a consumer needs them: `float4x4`, `transpose`, `determinant`, and HLSL's one-based `_11`..`_33` element names. @@ -88,7 +98,10 @@ DirectXShaderCompiler, and The mirror test compares bit patterns (any NaN equals any NaN; -0 differs from 0). It proves the text of `CultMath.hlsl` computes the same float32 results as C# `math` on the CPU, not that a GPU agrees: driver `sin` precision alone makes -`cultmath_hash` and value noise differ bit for bit on hardware. +`cultmath_hash` and value noise differ bit for bit on hardware. The mirror is +compiled under `using static CultMath.math;`, so its intrinsics are C# `math` +itself: the test proves the composition in the text, not the intrinsic rules, +which only `HlslSemanticsTests` pins. Where HLSL is silent, CultMath keeps its own decisions and does not defer to Unity.Mathematics: `normalize` is safe (divides by `max(length, 1e-20)`), diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs index d0ce8bbd..ca4584c7 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -42,7 +42,9 @@ public sealed class HlslSourceCompatibilityTests /// negatives, NaN, large values, integer lattice points), special pairs, and vectors whose first two /// components tie (x0.x == x0.y in snoise). This proves the text of CultMath.hlsl computes the same /// float32 results as C# math on the CPU. It does not prove GPU agreement: driver sin precision alone - /// makes cultmath_hash and value noise differ bit for bit on hardware. + /// makes cultmath_hash and value noise differ bit for bit on hardware. The mirror's intrinsics are C# + /// math itself (it compiles under using static CultMath.math), so this proves the composition in the + /// text, not the intrinsic rules; HlslSemanticsTests alone pins those. /// [Fact] public void EveryMirrorFunctionMatchesCSharpMath()