CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
using System.Reflection ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
using System.Runtime.InteropServices ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
using System.Text ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
using System.Text.Json.Nodes ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
using System.Text.RegularExpressions ;
using CultMath ;
using Xunit ;
namespace CultMath.Tests ;
/// <summary>
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
/// shaders/CultMath.glsl and shaders/CultMath.Phacelle.glsl are derived: each is exactly its
/// <see cref="GlslLowering.Lower"/> output from the committed HLSL, no HLSL-only token survives the
/// lowering, no public function is dropped except the texture samplers, the MPL-2.0 Phacelle code lives
/// only in its own file, and the golden fixture a WebGL2 consumer evaluates is C#'s current output. With
/// CULTMATH_WRITE_GLSL=1 set, the first and last tests write the committed files before comparing, which
/// is the one regeneration path.
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
/// </summary>
2026-10-16 19:41:14 +02:00
public sealed partial class GlslMirrorTests
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
{
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
private readonly ITestOutputHelper output ;
public GlslMirrorTests ( ITestOutputHelper output ) = > this . output = output ;
2026-10-17 16:09:18 +02:00
// The fixture is written by Yggdrasil's mcr.microsoft.com/dotnet/sdk:10.0 image (Ubuntu 24.04) only: its platform families record
// that platform's libm, so a write from another OS would move them.
private static bool Write = > Environment . GetEnvironmentVariable ( "CULTMATH_WRITE_GLSL" ) = = "1"
? OperatingSystem . IsLinux ( ) ? true : throw new InvalidOperationException ( "CULTMATH_WRITE_GLSL=1 writes glsl-parity.json, whose platform families belong to Yggdrasil's Ubuntu image (mcr.microsoft.com/dotnet/sdk:10.0): regenerate it there." )
: false ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
private static string Root = > HlslSourceCompatibilityTests . FindCultMathRoot ( ) ;
private static string FixturePath = > Path . Combine ( Root , "tests" , "CultMath.Tests" , "fixtures" , "glsl-parity.json" ) ;
private static string Hlsl = > HlslSourceCompatibilityTests . ReadShaderSource ( Root ) . ReplaceLineEndings ( "\n" ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
private static IReadOnlyList < ( string File , string Text ) > Lowered = > GlslLowering . Lower ( Root ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
[Fact]
public void CommittedGlslEqualsLowering ( )
{
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
foreach ( var ( file , expected ) in Lowered )
{
var path = Path . Combine ( Root , "shaders" , file ) ;
if ( Write )
File . WriteAllText ( path , expected ) ;
var committed = File . ReadAllText ( path ) . ReplaceLineEndings ( "\n" ) ;
Assert . True ( committed = = expected , $"shaders/{file} is not the lowering of the committed HLSL (regenerate with CULTMATH_WRITE_GLSL=1):\n" + UnifiedDiff ( committed , expected ) ) ;
}
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
}
2026-10-16 01:01:54 +02:00
// Counting stand-ins for the mirror's clamp, one per overload, declared in the mirror's class so they
// hide math.clamp for every function in it. Each counts a call whose minimum exceeds its maximum in any
// component and forwards to math.clamp. (The int vector overloads only forward: no mirror function
// clamps integer vectors with swapped bounds, and counting them would be unreachable.)
private const string CountingClampShadows = @ "
public static int ClampMinAboveMax ;
static float clamp ( float x , float a , float b ) { if ( a > b ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static float2 clamp ( float2 x , float2 a , float2 b ) { if ( a . x > b . x | | a . y > b . y ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static float3 clamp ( float3 x , float3 a , float3 b ) { if ( a . x > b . x | | a . y > b . y | | a . z > b . z ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static float4 clamp ( float4 x , float4 a , float4 b ) { if ( a . x > b . x | | a . y > b . y | | a . z > b . z | | a . w > b . w ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static int clamp ( int x , int a , int b ) { if ( a > b ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static int2 clamp ( int2 x , int2 a , int2 b ) { if ( a . x > b . x | | a . y > b . y ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static int3 clamp ( int3 x , int3 a , int3 b ) { if ( a . x > b . x | | a . y > b . y | | a . z > b . z ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
static int4 clamp ( int4 x , int4 a , int4 b ) { if ( a . x > b . x | | a . y > b . y | | a . z > b . z | | a . w > b . w ) ClampMinAboveMax + + ; return math . clamp ( x , a , b ) ; }
";
2026-10-14 20:42:04 +02:00
/// <summary>
2026-10-16 01:01:54 +02:00
/// The lowering keeps HLSL's statement order (CommittedGlslEqualsLowering pins the GLSL as that
/// lowering), and GLSL leaves clamp(x, minVal, maxVal) undefined for minVal above maxVal, so no clamp
/// reached by cultmath_integral_clamp_linear may see lo above hi, on any path and for any spelling of the
/// normalisation. The mirror is compiled with counting clamps and the function is run over the edge grid
/// (lo above hi, infinite bounds, zero-length spans, b = 0 and b != 0): the count of such clamp calls
2026-10-16 02:58:05 +02:00
/// stays 0 after every call. The cases are HlslSourceCompatibilityTests.IntegralClampLinearCases: the grid fixes
/// a in {-2.5, 0, 1.5}, so a normalisation keyed on a past 1.75 never clamps wrongly there; the committed
/// fixture's random cases reach it.
2026-10-14 20:42:04 +02:00
/// </summary>
[Fact]
2026-10-16 01:01:54 +02:00
public void IntegralClampLinearNeverClampsWithMinAboveMax ( )
2026-10-14 20:42:04 +02:00
{
2026-10-16 01:01:54 +02:00
var ( assembly , errors ) = HlslSourceCompatibilityTests . CompileShaderMirror ( CountingClampShadows ) ;
Assert . True ( assembly is not null , string . Join ( Environment . NewLine , errors ) ) ;
var shaderType = assembly ! . GetType ( "CultMathHlsl.HlslShader" ) ! ;
var shader = Activator . CreateInstance ( shaderType ) ;
var count = shaderType . GetField ( "ClampMinAboveMax" ) ! ;
var function = shaderType . GetMethod ( "cultmath_integral_clamp_linear" , BindingFlags . Instance | BindingFlags . NonPublic ) ! ;
var bad = new List < string > ( ) ;
2026-10-16 02:58:05 +02:00
foreach ( var c in HlslSourceCompatibilityTests . IntegralClampLinearCases )
2026-10-14 20:42:04 +02:00
{
2026-10-16 01:01:54 +02:00
count . SetValue ( null , 0 ) ;
function . Invoke ( shader , c . Cast < object > ( ) . ToArray ( ) ) ;
if ( ( int ) count . GetValue ( null ) ! > 0 )
bad . Add ( $"({string.Join(" , ", c)})" ) ;
2026-10-14 20:42:04 +02:00
}
2026-10-16 01:01:54 +02:00
Assert . True ( bad . Count = = 0 , $"{bad.Count} cases clamp with the minimum above the maximum:{Environment.NewLine}{string.Join(Environment.NewLine, bad.Take(12))}" ) ;
2026-10-14 20:42:04 +02:00
}
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
// Identifier boundaries: cultmath_lerp is a CultMath function, lerp( is HLSL.
private static readonly Regex HlslOnly = new (
2026-10-14 06:31:43 +02:00
@"\b(float|u?int|bool)[234]\b|\bfloat3x3\b|\blerp\(|\bfrac\(|\bsaturate\(|\brsqrt\(|\basuint\(|\basfloat\(|\batan2\(|static const|\((float|int|uint)\)|Texture2D|SamplerState|#include|precision (high|medium|low)p" ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
[Fact]
public void NoHlslOnlyTokensSurvive ( )
{
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
foreach ( var ( file , text ) in Lowered )
{
var survivors = HlslOnly . Matches ( text ) . Select ( m = > m . Value ) . Distinct ( ) . ToArray ( ) ;
Assert . True ( survivors . Length = = 0 , $"HLSL-only tokens in {file}: " + string . Join ( ", " , survivors ) ) ;
}
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
}
private static readonly Regex Definition = new ( @"(?m)^\w+\s+(cultmath_\w+)\s*\(([^)]*)\)" ) ;
2026-10-03 14:15:32 +02:00
// A definition's signature, its name and parameter types, so an overload counts on its own:
// "cultmath_pcg3d(vec2)". HLSL type names are mapped by the lowering's own step 3.
private static string Signature ( Match definition ) = >
definition . Groups [ 1 ] . Value + "(" + string . Join ( ", " , definition . Groups [ 2 ] . Value
. Split ( ',' , StringSplitOptions . TrimEntries | StringSplitOptions . RemoveEmptyEntries )
. Select ( parameter = > GlslLowering . LowerTypeNames ( string . Join ( ' ' , Regex . Split ( parameter , @"\s+" ) [ . . ^ 1 ] ) ) ) ) + ")" ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
[Fact]
public void EveryPublicFunctionIsLowered ( )
{
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
var lowered = Lowered ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
var hlsl = Definition . Matches ( Hlsl ) . Where ( m = > ! Regex . IsMatch ( m . Groups [ 2 ] . Value , @"\b(Texture2D|SamplerState)\b" ) )
2026-10-03 14:15:32 +02:00
. Select ( Signature ) . ToHashSet ( ) ;
var glsl = lowered . SelectMany ( output = > Definition . Matches ( output . Text ) ) . Select ( Signature ) . ToHashSet ( ) ;
Assert . Contains ( "cultmath_pcg3d(vec2)" , glsl ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
Assert . True ( hlsl . SetEquals ( glsl ) , "HLSL only: " + string . Join ( ", " , hlsl . Except ( glsl ) ) + "; GLSL only: " + string . Join ( ", " , glsl . Except ( hlsl ) ) ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
// The MPL-2.0 code is in its own file and nowhere in the MIT library.
var library = lowered . Single ( output = > output . File = = "CultMath.glsl" ) . Text ;
var phacelle = lowered . Single ( output = > output . File = = "CultMath.Phacelle.glsl" ) . Text ;
foreach ( var token in new [ ] { "cultmath_phacelle(" , "CultPhasor" } )
{
Assert . DoesNotContain ( token , library ) ;
Assert . Contains ( token , phacelle ) ;
}
2026-10-12 04:07:08 +02:00
// The Apache-2.0 code is in its own file too, and the MPL-2.0 file holds none of it.
var cycles = lowered . Single ( output = > output . File = = "CultMath.Cycles.glsl" ) . Text ;
Assert . DoesNotContain ( "cultmath_cycles_divide(" , library ) ;
Assert . DoesNotContain ( "cultmath_cycles_divide(" , phacelle ) ;
Assert . Contains ( "float cultmath_cycles_divide(" , cycles ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
}
2026-10-03 14:15:32 +02:00
// The two-file contract a consumer relies on when it concatenates CultMath.Phacelle.glsl after
// CultMath.glsl: distinct guards (a shared one would hide the second file's body), each provenance
// line naming its file's licence, and the MIT file pointing at the one that holds cultmath_phacelle.
[Fact]
public void TwoFileHeaderContract ( )
{
var lowered = Lowered ;
var guards = lowered . Select ( output = > Regex . Match ( output . Text , @"^[^\n]*\n#ifndef (\w+)\n#define \1\n" ) . Groups [ 1 ] . Value ) . ToArray ( ) ;
Assert . All ( guards , guard = > Assert . NotEqual ( string . Empty , guard ) ) ;
Assert . Equal ( guards . Length , guards . Distinct ( ) . Count ( ) ) ;
var library = lowered . Single ( output = > output . File = = "CultMath.glsl" ) . Text . Split ( '\n' ) [ 0 ] ;
var phacelle = lowered . Single ( output = > output . File = = "CultMath.Phacelle.glsl" ) . Text . Split ( '\n' ) [ 0 ] ;
Assert . Contains ( " MIT." , library ) ;
Assert . DoesNotContain ( "MPL" , library ) ;
Assert . Contains ( "cultmath_phacelle is in CultMath.Phacelle.glsl" , library ) ;
Assert . Contains ( " MPL-2.0;" , phacelle ) ;
Assert . DoesNotContain ( "MIT" , phacelle ) ;
2026-10-12 04:07:08 +02:00
2026-10-12 04:41:18 +02:00
var cycles = lowered . Single ( output = > output . File = = "CultMath.Cycles.glsl" ) . Text . Split ( '\n' ) [ 0 ] ;
2026-10-12 04:07:08 +02:00
Assert . Contains ( "cultmath_cycles_ramp_index is in CultMath.Cycles.glsl" , library ) ;
Assert . Contains ( " Apache-2.0;" , cycles ) ;
Assert . DoesNotContain ( "MIT" , cycles ) ;
Assert . DoesNotContain ( "MPL" , cycles ) ;
2026-10-03 14:15:32 +02:00
}
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
[Fact]
public void GoldenFixtureMatchesCSharp ( )
{
2026-10-03 14:35:48 +02:00
// Arguments are drawn only here, when regenerating: Interval draws widths through MathF.Pow, whose
// bits differ by OS. Checking evaluates C# on the committed fixture's own arguments.
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
if ( Write )
{
2026-10-03 14:35:48 +02:00
var random = new System . Random ( Seed ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
Directory . CreateDirectory ( Path . GetDirectoryName ( FixturePath ) ! ) ;
2026-10-03 14:35:48 +02:00
File . WriteAllText ( FixturePath , GoldenFixture ( ( f , _ ) = > Families [ f ] . Arguments ( random ) ) ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
}
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
var committed = JsonNode . Parse ( File . ReadAllText ( FixturePath ) ) ! . AsObject ( ) ;
var committedFamilies = committed [ "functions" ] ! . AsArray ( ) ;
2026-10-03 14:35:48 +02:00
Assert . Equal ( Families . Length , committedFamilies . Count ) ;
for ( var f = 0 ; f < Families . Length ; f + + )
Assert . True ( committedFamilies [ f ] ! [ "cases" ] ! . AsArray ( ) . Count = = Points , $"{Families[f].Glsl}: the fixture does not hold {Points} cases" ) ;
var current = JsonNode . Parse ( GoldenFixture ( ( f , p ) = >
Arguments ( Resolve ( Families [ f ] . Glsl ) , ( ( string ) committedFamilies [ f ] ! [ "cases" ] ! [ p ] ! ) . Split ( " -> " ) [ 0 ] ) ) ) ! . AsObject ( ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
var currentFamilies = current [ "functions" ] ! . AsArray ( ) ;
2026-10-03 14:35:48 +02:00
// Family by family: every family is compared as text, except those whose C# bits come from the
// platform's libm, which are compared case by case within their family's platform bound. A family
// with a check must also pass it on C#'s own results, so the rule the WebGL2 consumer applies holds
// for the reference.
for ( var f = 0 ; f < Families . Length ; f + + )
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
{
var want = currentFamilies [ f ] ! . AsObject ( ) ;
var have = committedFamilies [ f ] ! . AsObject ( ) ;
var name = ( string ) want [ "glsl" ] ! ;
Assert . Equal ( name , ( string? ) have [ "glsl" ] ) ;
Assert . Equal ( ( string ) want [ "tolerance" ] ! , ( string? ) have [ "tolerance" ] ) ;
2026-10-03 14:35:48 +02:00
Assert . Equal ( ( string? ) want [ "check" ] , ( string? ) have [ "check" ] ) ;
switch ( Families [ f ] . Platform )
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
{
2026-10-03 14:35:48 +02:00
case Platform . Ulp :
var ulps = MaxDistance ( have [ "cases" ] ! . AsArray ( ) , want [ "cases" ] ! . AsArray ( ) , ( x , y ) = > Math . Abs ( ( long ) Ordered ( x ) - Ordered ( y ) ) ) ;
output . WriteLine ( $"{name}: within {ulps} ulp of this platform's libm ({RuntimeInformation.OSDescription}); fixture generated on {have[" platform "]}" ) ;
Assert . True ( ulps < = 1 , $"{name}: {ulps} ulp from this platform's result, more than 1" ) ;
break ;
case Platform . Scaled :
var scaled = MaxDistance ( have [ "cases" ] ! . AsArray ( ) , want [ "cases" ] ! . AsArray ( ) , ( x , y ) = >
{
double v = BitConverter . Int32BitsToSingle ( x ) , w = BitConverter . Int32BitsToSingle ( y ) ;
return x = = y ? 0.0 : Math . Abs ( v - w ) / Math . Max ( Math . Abs ( v ) , 1.0 ) ;
} ) ;
output . WriteLine ( $"{name}: |diff| / max(|v|, 1) at most {scaled:R} from this platform's libm ({RuntimeInformation.OSDescription}); fixture generated on {have[" platform "]}" ) ;
Assert . True ( scaled < = ScaledPlatformBound , $"{name}: {scaled:R} max(|v|, 1) from this platform's result, more than 2^-20" ) ;
break ;
default :
Assert . True ( JsonNode . DeepEquals ( want , have ) , $"fixtures/glsl-parity.json family {name} is not C#'s current output (regenerate with CULTMATH_WRITE_GLSL=1)" ) ;
break ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
}
2026-10-03 14:15:33 +02:00
if ( want [ "check" ] is not null )
2026-10-04 09:47:49 +02:00
output . WriteLine ( $"{name}: {Families[f].Verify!(want[" cases "]!.AsArray())}" ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
}
committed . Remove ( "functions" ) ;
current . Remove ( "functions" ) ;
Assert . True ( JsonNode . DeepEquals ( current , committed ) , "fixtures/glsl-parity.json header is not the generator's (regenerate with CULTMATH_WRITE_GLSL=1)" ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
}
2026-10-03 14:35:48 +02:00
// The largest distance, component by component, between two families' results (committed first).
private static double MaxDistance ( JsonArray committed , JsonArray current , Func < int , int , double > distance )
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
{
2026-10-03 14:35:48 +02:00
var max = 0.0 ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
for ( var c = 0 ; c < current . Count ; c + + )
{
2026-10-03 14:35:48 +02:00
var haveBits = ( ( string ) committed [ c ] ! ) . Split ( " -> " ) [ 1 ] . Split ( ' ' ) . Select ( h = > ( int ) Convert . ToUInt32 ( h , 16 ) ) . ToArray ( ) ;
var wantBits = ( ( string ) current [ c ] ! ) . Split ( " -> " ) [ 1 ] . Split ( ' ' ) . Select ( h = > ( int ) Convert . ToUInt32 ( h , 16 ) ) . ToArray ( ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
Assert . Equal ( wantBits . Length , haveBits . Length ) ;
2026-10-03 14:35:48 +02:00
max = Math . Max ( max , haveBits . Zip ( wantBits , distance ) . Max ( ) ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
}
return max ;
}
2026-10-03 14:35:48 +02:00
// FrustumBall applied to C#'s own results: every case's ball encloses the exact one and is no wider
// than its rounding widening allows.
2026-10-04 09:47:49 +02:00
private static string AssertFrustumBall ( JsonArray cases )
2026-10-03 14:15:33 +02:00
{
2026-10-04 09:47:49 +02:00
double low = double . PositiveInfinity , high = double . PositiveInfinity ;
2026-10-03 14:15:33 +02:00
foreach ( var entry in cases )
{
var sides = ( ( string ) entry ! ) . Split ( " -> " ) ;
var a = Floats ( sides [ 0 ] ) ;
var b = Floats ( sides [ 1 ] ) ;
double mx = a [ 0 ] , my = a [ 1 ] , z0 = a [ 2 ] , z1 = a [ 3 ] , footprint = a [ 4 ] , warp = a [ 5 ] ;
var zm = ( z0 + z1 ) / 2.0 ;
var radius = ( z1 - z0 ) / 2.0 * Math . Sqrt ( mx * mx + my * my + 1.0 ) + z1 * footprint + warp ;
double dx = b [ 0 ] - mx * zm , dy = b [ 1 ] - my * zm , dz = b [ 2 ] - zm ;
2026-10-03 14:35:48 +02:00
var reach = radius + Math . Sqrt ( dx * dx + dy * dy + dz * dz ) ;
var c1 = Math . Abs ( mx * zm ) + Math . Abs ( my * zm ) + Math . Abs ( zm ) ;
Assert . True ( b [ 3 ] > = reach , $"iv_frustum_ball case {entry}: radius short of the exact ball by {reach - b[3]}" ) ;
Assert . True ( b [ 3 ] < = reach + Math . ScaleB ( radius + c1 , - 19 ) , $"iv_frustum_ball case {entry}: radius past the exact ball by {b[3] - reach}, more than 2^-19 (r + |c|_1)" ) ;
2026-10-04 09:47:49 +02:00
low = Math . Min ( low , ( b [ 3 ] - reach ) / radius ) ;
high = Math . Min ( high , ( reach + Math . ScaleB ( radius + c1 , - 19 ) - b [ 3 ] ) / Math . ScaleB ( radius + c1 , - 19 ) ) ;
2026-10-03 14:15:33 +02:00
}
2026-10-04 09:47:49 +02:00
return $"least slack: {low:E3} of r above the exact ball, {high:F3} of 2^-19 (r + |c|_1) below its widening" ;
}
private static readonly double [ ] CheckEps = { - 1.0 , - 0.5 , 0.0 , 0.5 , 1.0 } ;
// The origin, the six axis directions and the eight cube corners, normalised.
private static readonly ( double X , double Y , double Z ) [ ] CheckDirections = CheckDirectionList ( ) . ToArray ( ) ;
private static IEnumerable < ( double X , double Y , double Z ) > CheckDirectionList ( )
{
yield return ( 0.0 , 0.0 , 0.0 ) ;
foreach ( var s in new [ ] { - 1.0 , 1.0 } )
{
yield return ( s , 0.0 , 0.0 ) ;
yield return ( 0.0 , s , 0.0 ) ;
yield return ( 0.0 , 0.0 , s ) ;
}
var corner = 1.0 / Math . Sqrt ( 3.0 ) ;
foreach ( var sx in new [ ] { - corner , corner } )
foreach ( var sy in new [ ] { - corner , corner } )
foreach ( var sz in new [ ] { - corner , corner } )
yield return ( sx , sy , sz ) ;
}
// SampledForm applied to C#'s own results, with C#'s own snoise or fBm as the reference value. A form
// must enclose its reference at every sample, and be no wider than the Lipschitz form's allowance.
2026-10-04 11:09:35 +02:00
// allowance is the part of e that is the float32 allowance; a family that allowanceDecides must have a
// sample that falls outside the form once it is removed, so the family can tell a device whose error
// passes the allowance from one that does not.
private static string AssertSampledForm ( JsonArray cases , string name , Func < string [ ] , float3 , float > reference , Func < string [ ] , double [ ] , double > widthBound ,
Func < string [ ] , double [ ] , double > allowance , bool allowanceDecides )
2026-10-04 09:47:49 +02:00
{
double least = double . PositiveInfinity , leastRelative = double . PositiveInfinity , tightest = double . PositiveInfinity ;
2026-10-04 11:09:35 +02:00
var decided = 0 ;
2026-10-04 09:47:49 +02:00
foreach ( var entry in cases )
{
var sides = ( ( string ) entry ! ) . Split ( " -> " ) ;
var tokens = sides [ 0 ] . Split ( ' ' ) ;
double [ ] a = Floats ( string . Join ( ' ' , tokens . Take ( 7 ) ) ) , form = Floats ( sides [ 1 ] ) ;
double x0 = form [ 0 ] , slope = form [ 1 ] , e = form [ 2 ] ;
2026-10-04 11:09:35 +02:00
var withoutAllowance = e - allowance ( tokens , a ) ;
var allowanceNeeded = false ;
2026-10-04 09:47:49 +02:00
foreach ( var eps in CheckEps )
foreach ( var d in CheckDirections )
{
var p = new float3 ( ( float ) ( a [ 0 ] + a [ 3 ] * eps + a [ 6 ] * d . X ) , ( float ) ( a [ 1 ] + a [ 4 ] * eps + a [ 6 ] * d . Y ) , ( float ) ( a [ 2 ] + a [ 5 ] * eps + a [ 6 ] * d . Z ) ) ;
double value = reference ( tokens , p ) , middle = x0 + slope * eps ;
var inside = Math . Min ( value - ( middle - e ) , middle + e - value ) ;
Assert . True ( inside > = 0.0 , $"{name} case {entry}: the reference {value:R} at eps {eps} and direction {d} is outside the form's range [{middle - e:R}, {middle + e:R}] by {-inside:R}" ) ;
least = Math . Min ( least , inside ) ;
leastRelative = Math . Min ( leastRelative , inside / e ) ;
2026-10-04 11:09:35 +02:00
allowanceNeeded | = Math . Abs ( value - middle ) > withoutAllowance ;
2026-10-04 09:47:49 +02:00
}
2026-10-04 11:09:35 +02:00
if ( allowanceNeeded )
decided + + ;
2026-10-04 09:47:49 +02:00
var bound = widthBound ( tokens , a ) ;
Assert . True ( Math . Abs ( slope ) + e < = bound + Math . ScaleB ( 1.0 + bound , - 16 ) , $"{name} case {entry}: the width {Math.Abs(slope) + e:R} is past B + 2^-16 (1 + B) = {bound + Math.ScaleB(1.0 + bound, -16):R}" ) ;
tightest = Math . Min ( tightest , ( bound + Math . ScaleB ( 1.0 + bound , - 16 ) - Math . Abs ( slope ) - e ) / bound ) ;
}
2026-10-04 11:09:35 +02:00
Assert . True ( ! allowanceDecides | | decided > 0 , $"{name}: no sample falls outside the form once the float32 allowance is removed, so the family cannot fail a device whose error passes it" ) ;
return $"least enclosure slack {least:E3} ({leastRelative:E3} of e), least tightness slack {tightest:E3} of B, {decided} of {cases.Count} cases need the allowance" ;
2026-10-04 09:47:49 +02:00
}
2026-10-04 11:09:35 +02:00
// The float32 allowance of one octave of af_snoise: 2^-14 + 2^-12 R + L 2^-20 (|c|_1 + R).
private static double SnoiseAllowance ( double centre1 , double reach ) = >
2026-10-16 06:34:21 +02:00
math . SNOISE_READ_VALUE + math . SNOISE_READ_GRADIENT * reach + math . SNOISE_LIPSCHITZ * Math . ScaleB ( centre1 + reach , - 20 ) ;
2026-10-04 11:09:35 +02:00
2026-10-04 09:47:49 +02:00
// The Lipschitz form's width bound for one octave of the sampled-form check.
2026-10-04 11:09:35 +02:00
private static double SnoiseWidthBound ( double centre1 , double reach ) = > math . SNOISE_LIPSCHITZ * reach + SnoiseAllowance ( centre1 , reach ) ;
2026-10-04 09:47:49 +02:00
private static double Length3 ( double [ ] a , int first ) = > Math . Sqrt ( a [ first ] * a [ first ] + a [ first + 1 ] * a [ first + 1 ] + a [ first + 2 ] * a [ first + 2 ] ) ;
2026-10-04 11:09:35 +02:00
private static double SnoiseOctave ( Func < double , double , double > octave , double [ ] a , double frequency ) = >
octave ( ( Math . Abs ( a [ 0 ] ) + Math . Abs ( a [ 1 ] ) + Math . Abs ( a [ 2 ] ) ) * frequency , ( Length3 ( a , 3 ) + a [ 6 ] ) * frequency ) ;
// The amplitude-weighted sum of a per-octave quantity over the fBm's octaves.
private static double FbmOctaves ( string [ ] t , double [ ] a , Func < double , double , double > octave )
{
var ( octaves , lacunarity , gain ) = ( ( int ) Convert . ToUInt32 ( t [ 7 ] , 16 ) , Floats ( t [ 8 ] ) [ 0 ] , Floats ( t [ 9 ] ) [ 0 ] ) ;
double sum = 0.0 , amplitude = 1.0 , frequency = 1.0 ;
for ( var i = 0 ; i < Math . Clamp ( octaves , 0 , 16 ) ; i + + )
{
sum + = amplitude * SnoiseOctave ( octave , a , frequency ) ;
amplitude * = gain ;
frequency * = lacunarity ;
}
return sum ;
}
2026-10-16 19:41:14 +02:00
private static float SnoiseReference ( string [ ] tokens , float3 p ) = > math . snoise ( p ) ;
private static float FbmReference ( string [ ] t , float3 p ) = > math . fbm_grad ( p , ( int ) Convert . ToUInt32 ( t [ 7 ] , 16 ) , ( float ) Floats ( t [ 8 ] ) [ 0 ] , ( float ) Floats ( t [ 9 ] ) [ 0 ] ) . w ;
private static string AssertSnoiseForm ( JsonArray cases , bool allowanceDecides = false , Func < string [ ] , float3 , float > ? reference = null ) = >
AssertSampledForm ( cases , "af_snoise" , reference ? ? SnoiseReference ,
2026-10-04 11:09:35 +02:00
( _ , a ) = > SnoiseOctave ( SnoiseWidthBound , a , 1.0 ) , ( _ , a ) = > SnoiseOctave ( SnoiseAllowance , a , 1.0 ) , allowanceDecides ) ;
2026-10-04 09:47:49 +02:00
2026-10-16 19:41:14 +02:00
private static string AssertFbmForm ( JsonArray cases , bool allowanceDecides = false , Func < string [ ] , float3 , float > ? reference = null ) = >
2026-10-04 09:47:49 +02:00
AssertSampledForm ( cases , "af_fbm" ,
2026-10-16 19:41:14 +02:00
reference ? ? FbmReference ,
2026-10-04 11:09:35 +02:00
( t , a ) = > FbmOctaves ( t , a , SnoiseWidthBound ) , ( t , a ) = > FbmOctaves ( t , a , SnoiseAllowance ) , allowanceDecides ) ;
2026-10-04 09:47:49 +02:00
// AffineFrustumBall applied to C#'s own results.
private static string AssertAffineFrustumBall ( JsonArray cases )
{
double enclosure = double . PositiveInfinity , lower = double . PositiveInfinity , upper = double . PositiveInfinity ;
var diagonal = new [ ] { ( 0.0 , 0.0 ) , ( 1.0 , 0.0 ) , ( - 1.0 , 0.0 ) , ( 0.0 , 1.0 ) , ( 0.0 , - 1.0 ) , ( Math . Sqrt ( 0.5 ) , Math . Sqrt ( 0.5 ) ) , ( Math . Sqrt ( 0.5 ) , - Math . Sqrt ( 0.5 ) ) , ( - Math . Sqrt ( 0.5 ) , Math . Sqrt ( 0.5 ) ) , ( - Math . Sqrt ( 0.5 ) , - Math . Sqrt ( 0.5 ) ) } ;
foreach ( var entry in cases )
{
var sides = ( ( string ) entry ! ) . Split ( " -> " ) ;
var a = Floats ( sides [ 0 ] ) ;
var b = Floats ( sides [ 1 ] ) ;
double mx = a [ 0 ] , my = a [ 1 ] , z0 = a [ 2 ] , z1 = a [ 3 ] , fp = a [ 4 ] , warp = a [ 5 ] ;
double zm = ( z0 + z1 ) / 2.0 , h = ( z1 - z0 ) / 2.0 ;
var r0 = z1 * fp + warp ;
var c1 = Math . Abs ( mx * zm ) + Math . Abs ( my * zm ) + Math . Abs ( zm ) ;
var spread = ( Math . Abs ( mx ) + Math . Abs ( my ) + 1.0 ) * h ;
double dx = b [ 0 ] - mx * zm , dy = b [ 1 ] - my * zm , dz = b [ 2 ] - zm ;
var d = Math . Sqrt ( dx * dx + dy * dy + dz * dz ) ;
foreach ( var z in new [ ] { z0 , ( 3.0 * z0 + z1 ) / 4.0 , zm , ( z0 + 3.0 * z1 ) / 4.0 , z1 } )
{
var eps = h > 0.0 ? Math . Clamp ( ( z - zm ) / h , - 1.0 , 1.0 ) : 0.0 ;
foreach ( var ( ex , ey ) in diagonal )
{
double px = ( mx + fp * ex ) * z - ( b [ 0 ] + mx * h * eps ) , py = ( my + fp * ey ) * z - ( b [ 1 ] + my * h * eps ) , pz = z - ( b [ 2 ] + h * eps ) ;
var slack = b [ 3 ] - ( Math . Sqrt ( px * px + py * py + pz * pz ) + warp ) ;
Assert . True ( slack > = 0.0 , $"af_frustum_ball case {entry}: the ray point at depth {z:R} and offset ({ex}, {ey}) is outside the ball by {-slack:R}" ) ;
enclosure = Math . Min ( enclosure , slack / b [ 3 ] ) ;
}
}
Assert . True ( b [ 3 ] > = r0 + d , $"af_frustum_ball case {entry}: radius short of R0 + d by {r0 + d - b[3]}" ) ;
Assert . True ( b [ 3 ] < = r0 + d + Math . ScaleB ( r0 + c1 + spread , - 19 ) , $"af_frustum_ball case {entry}: radius past R0 + d by {b[3] - r0 - d}, more than 2^-19 (R0 + |c0|_1 + spread)" ) ;
lower = Math . Min ( lower , ( b [ 3 ] - r0 - d ) / r0 ) ;
upper = Math . Min ( upper , ( r0 + d + Math . ScaleB ( r0 + c1 + spread , - 19 ) - b [ 3 ] ) / Math . ScaleB ( r0 + c1 + spread , - 19 ) ) ;
}
return $"least enclosure slack {enclosure:E3} of the radius, least slack above R0 + d {lower:E3} of R0, below its widening {upper:F3} of 2^-19 (R0 + |c0|_1 + spread)" ;
2026-10-03 14:15:33 +02:00
}
2026-10-16 04:49:13 +02:00
private const string SpanAllowanceRead =
"Read at the case's point x, with S = |x|_1 and (e_n, e_g, e_h) = math.span_slack(math.span_rounding(1, x, zero stage, 0, 0, 0)), " +
"against the kernel's exact values in double: |n - n_exact| <= e_n and |g - g_exact|_2 <= e_g for snoise_grad, " +
"||H - H_exact||_F <= e_h for snoise_hessian, no tolerance. " +
"Report the largest fraction of each allowance per decade of S and the largest absolute error at S < 1e-2." ;
// SpanAllowanceRead applied to a family's results (C#'s own, or a device's): every read is within the
// allowance math.span_slack gives at its point, the owner's own numbers and no restated literal. A small
// family (bands 1e-4 to 1e2) must also fail the check once the absolute term is removed in at least 16
// cases, and hold at least 48 cases with S <= 1e-2: the allowance's absolute term is what decides there.
private static string AssertSpanAllowance ( JsonArray cases , bool hessian , bool small )
{
var absolute = math . span_slack ( 0.0f ) ;
var fractions = new SortedDictionary < int , ( double Value , double Gradient ) > ( ) ;
double smallestError = 0.0 ;
int absoluteDecides = 0 , nearOrigin = 0 ;
foreach ( var entry in cases )
{
var sides = ( ( string ) entry ! ) . Split ( " -> " ) ;
double [ ] x = Floats ( sides [ 0 ] ) , result = Floats ( sides [ 1 ] ) ;
var s = Math . Abs ( x [ 0 ] ) + Math . Abs ( x [ 1 ] ) + Math . Abs ( x [ 2 ] ) ;
var slack = math . span_slack ( math . span_rounding ( 1.0f , new float3 ( ( float ) x [ 0 ] , ( float ) x [ 1 ] , ( float ) x [ 2 ] ) , default , new float3 ( 0.0f , 0.0f , 0.0f ) , 0.0f , 0.0f ) ) ;
double valueError = 0.0 , gradientError , valueFraction = 0.0 , gradientFraction ;
bool needsAbsolute ;
if ( hessian )
{
var exact = NoiseBoundTests . HessianDouble ( x [ 0 ] , x [ 1 ] , x [ 2 ] ) ;
var sum = 0.0 ;
for ( var i = 0 ; i < 9 ; i + + )
sum + = ( result [ i ] - exact [ i ] ) * ( result [ i ] - exact [ i ] ) ;
gradientError = Math . Sqrt ( sum ) ;
Assert . True ( gradientError < = slack . z , $"snoise_hessian case {entry}: ||H - H_exact||_F is {gradientError:R}, past the allowance {slack.z:R}" ) ;
gradientFraction = gradientError / slack . z ;
needsAbsolute = gradientError > slack . z - absolute . z ;
}
else
{
var exact = NoiseBoundTests . GradDouble ( x [ 0 ] , x [ 1 ] , x [ 2 ] ) ;
valueError = Math . Abs ( result [ 3 ] - NoiseBoundTests . ValueDouble ( x [ 0 ] , x [ 1 ] , x [ 2 ] ) ) ;
gradientError = Math . Sqrt ( ( result [ 0 ] - exact [ 0 ] ) * ( result [ 0 ] - exact [ 0 ] ) + ( result [ 1 ] - exact [ 1 ] ) * ( result [ 1 ] - exact [ 1 ] ) + ( result [ 2 ] - exact [ 2 ] ) * ( result [ 2 ] - exact [ 2 ] ) ) ;
Assert . True ( valueError < = slack . x , $"snoise_grad case {entry}: |n - n_exact| is {valueError:R}, past the allowance {slack.x:R}" ) ;
Assert . True ( gradientError < = slack . y , $"snoise_grad case {entry}: |g - g_exact|_2 is {gradientError:R}, past the allowance {slack.y:R}" ) ;
valueFraction = valueError / slack . x ;
gradientFraction = gradientError / slack . y ;
needsAbsolute = valueError > slack . x - absolute . x | | gradientError > slack . y - absolute . y ;
}
var decade = ( int ) Math . Floor ( Math . Log10 ( s ) ) ;
fractions . TryGetValue ( decade , out var largest ) ;
fractions [ decade ] = ( Math . Max ( largest . Value , valueFraction ) , Math . Max ( largest . Gradient , gradientFraction ) ) ;
if ( needsAbsolute )
absoluteDecides + + ;
if ( s < 1.0e-2 )
smallestError = Math . Max ( smallestError , Math . Max ( valueError , gradientError ) ) ;
if ( s < = 1.0e-2 )
nearOrigin + + ;
}
if ( small )
{
Assert . True ( absoluteDecides > = 16 , $"only {absoluteDecides} of {cases.Count} cases fail once the absolute term is removed: the family cannot tell a device that needs it from one that does not" ) ;
Assert . True ( nearOrigin > = 48 , $"only {nearOrigin} of {cases.Count} cases have |x|_1 <= 1e-2" ) ;
}
var report = string . Join ( ", " , fractions . Select ( f = > hessian ? $"1e{f.Key}: {f.Value.Gradient:F3}" : $"1e{f.Key}: {f.Value.Value:F3}/{f.Value.Gradient:F3}" ) ) ;
return $"largest fraction of {(hessian ? " e_h " : " e_n / e_g ")} per decade of |x|_1: {report}; largest absolute error at |x|_1 < 1e-2 {smallestError:E3}; {absoluteDecides} of {cases.Count} cases need the absolute term" ;
}
2026-10-03 14:35:48 +02:00
// A committed case's arguments, decoded into the C# method's parameter types in Hex's field order.
private static object [ ] Arguments ( MethodInfo method , string hex )
{
var scalars = new Queue < uint > ( hex . Split ( ' ' ) . Select ( h = > Convert . ToUInt32 ( h , 16 ) ) ) ;
var arguments = method . GetParameters ( ) . Select ( parameter = > FromScalars ( parameter . ParameterType , scalars ) ) . ToArray ( ) ;
Assert . Empty ( scalars ) ;
return arguments ;
}
private static object FromScalars ( Type type , Queue < uint > scalars )
{
if ( type = = typeof ( float ) )
return BitConverter . Int32BitsToSingle ( ( int ) scalars . Dequeue ( ) ) ;
if ( type = = typeof ( int ) )
return ( int ) scalars . Dequeue ( ) ;
if ( type = = typeof ( uint ) )
return scalars . Dequeue ( ) ;
2026-10-17 16:09:18 +02:00
if ( type . IsArray )
{
var array = Array . CreateInstance ( type . GetElementType ( ) ! , SiteArrays . Capacity ) ;
for ( var i = 0 ; i < array . Length ; i + + )
array . SetValue ( FromScalars ( type . GetElementType ( ) ! , scalars ) , i ) ;
return array ;
}
2026-10-03 14:35:48 +02:00
var value = Activator . CreateInstance ( type ) ! ;
foreach ( var field in type . GetFields ( ) . Where ( f = > ! f . IsStatic ) )
field . SetValue ( value , FromScalars ( field . FieldType , scalars ) ) ;
return value ;
}
2026-10-03 14:15:33 +02:00
private static double [ ] Floats ( string hex ) = >
hex . Split ( ' ' ) . Select ( h = > ( double ) BitConverter . Int32BitsToSingle ( ( int ) Convert . ToUInt32 ( h , 16 ) ) ) . ToArray ( ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
// A float32 bit pattern as an integer whose order and differences are the floats' order and ulps.
private static int Ordered ( int bits ) = > bits < 0 ? int . MinValue - bits : bits ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
// ---- The golden fixture ----
private const int Seed = 20261002 ;
private const int Points = 256 ;
2026-10-03 14:35:48 +02:00
// How GoldenFixtureMatchesCSharp compares a family whose C# bits come from the platform's libm (exp,
// sin, cos) and so differ by OS; such an entry records the platform that generated it. Every other
// family is compared as text.
private enum Platform { None , Ulp , Scaled }
// Platform.Scaled: |diff| <= 2^-20 max(|v|, 1) per component. Ulps mean nothing near zero, where
// phacelle's sums of exp, sin and cos cancel; Windows differs from Linux by up to 3.6e-7 of it.
private const double ScaledPlatformBound = 9.5367431640625e-7 ;
2026-10-04 09:47:49 +02:00
private sealed record Family ( string Glsl , string Tolerance , Func < System . Random , object [ ] > Arguments , string? Check = null , Platform Platform = Platform . None , Func < JsonArray , string > ? Verify = null ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
private static float Uniform ( System . Random r , float lo , float hi ) = > lo + ( hi - lo ) * r . NextSingle ( ) ;
2026-10-16 21:01:16 +02:00
private static float2 Point2 ( System . Random r ) = > new ( Uniform ( r , - 50.0f , 50.0f ) , Uniform ( r , - 50.0f , 50.0f ) ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
private static float3 Point3 ( System . Random r ) = > new ( Uniform ( r , - 50.0f , 50.0f ) , Uniform ( r , - 50.0f , 50.0f ) , Uniform ( r , - 50.0f , 50.0f ) ) ;
GLSL fixture: tie families, regenerated CultMath.glsl and glsl-parity.json
Two families appended after phacelle, cultmath_snoise(vec3) and
cultmath_snoise_grad(vec3) over TiePoint3 (seven of eight cases on lattice
diagonals, one of eight on (t, t, t)); the shared Random leaves every earlier
family's draws unchanged. Both carry the tolerance text "ulp-bounded, on the
simplex tie set" and share a glsl name with the random families, so a consumer
tells them apart by index or tolerance.
Regenerated on Yggdrasil (Linux, the fixture's platform) with
CULTMATH_WRITE_GLSL=1. CultMath.glsl: the two tie lines, the constant, one
comment sentence. Fixture: 41 cases of iv_snoise_ball(vec3) and iv_fbm_ball move
with L, everything else is byte-identical before the appended families. Full
suite on Yggdrasil: 290 of 290.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-04 03:25:43 +02:00
// A point on the simplex tie set, where snoise's x0 has equal components (NoiseGradTests.SnoiseIsContinuousOnTheSimplexDiagonal):
// seven of eight draws lie on a lattice diagonal v + s (1, 1, 1), v = L - sum(L) / 6 for an integer L, and one of eight on
// the line (t, t, t). A device that runs a different tie rule reads a different function here.
private static float3 TiePoint3 ( System . Random r )
{
if ( r . Next ( 8 ) = = 0 )
{
var t = Uniform ( r , - 50.0f , 50.0f ) ;
return new float3 ( t , t , t ) ;
}
var lx = r . Next ( - 64 , 65 ) ;
var ly = r . Next ( - 64 , 65 ) ;
var lz = r . Next ( - 64 , 65 ) ;
var shift = ( lx + ly + lz ) / 6.0f ;
var s = r . NextSingle ( ) ;
return new float3 ( lx - shift + s , ly - shift + s , lz - shift + s ) ;
}
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
private static int Bits ( System . Random r ) = > r . Next ( int . MinValue , int . MaxValue ) ;
private static float2 Interval ( System . Random r )
{
var centre = Uniform ( r , - 20.0f , 20.0f ) ;
var width = MathF . Pow ( 10.0f , Uniform ( r , - 4.0f , 1.0f ) ) ;
return new float2 ( centre - width * 0.5f , centre + width * 0.5f ) ;
}
2026-10-03 14:15:33 +02:00
// iv_frustum_ball's sqrt is not correctly rounded on WebGL2 and its compilers may reassociate, so its
2026-10-03 14:35:48 +02:00
// bits are not portable; what the march needs is enclosure, and what culling needs is a ball no wider
// than its rounding widening. The consumer checks both in double from each case's arguments. It is
// written into the family's fixture entry, where the consumer reads it.
private const string FrustumBall =
"enclosure and tightness: from the arguments (mx, my, z0, z1, fp, warp) compute in double zm = (z0 + z1) / 2, " +
"c = (mx zm, my zm, zm), |c|_1 = |mx zm| + |my zm| + |zm|, r = (z1 - z0) / 2 sqrt(mx^2 + my^2 + 1) + z1 fp + warp " +
"and d = |GPU centre - c| (Euclidean); every case must have r + d <= GPU radius <= r + d + 2^-19 (r + |c|_1). " +
"Report the largest ulp distance per component as for any ulp-bounded family; only the two bounds fail the check." ;
2026-10-03 14:15:33 +02:00
2026-10-04 09:47:49 +02:00
// An affine form (x0, a, e): e >= 0, spanning the widths a probe's forms take.
private static float3 Form ( System . Random r ) = > new ( Uniform ( r , - 20.0f , 20.0f ) , Uniform ( r , - 5.0f , 5.0f ) , MathF . Pow ( 10.0f , Uniform ( r , - 4.0f , 1.0f ) ) ) ;
// A slice's axis and radius in noise space, log-uniform from 1e-3 to 0.5: below about 0.15 the
// centred form of af_snoise wins, above it the Lipschitz form does, so both are drawn.
private static float3 Axis3 ( System . Random r )
{
var scale = MathF . Pow ( 10.0f , Uniform ( r , - 3.0f , - 0.3f ) ) ;
return new float3 ( Uniform ( r , - 1.0f , 1.0f ) * scale , Uniform ( r , - 1.0f , 1.0f ) * scale , Uniform ( r , - 1.0f , 1.0f ) * scale ) ;
}
private static float BallRadius ( System . Random r ) = > MathF . Pow ( 10.0f , Uniform ( r , - 3.0f , - 0.3f ) ) ;
2026-10-04 11:09:35 +02:00
// A slice of reach 1e-6 to 1e-3, the short slices and small footprints near a camera, where the float32
// allowance is most of the form's width: the centre in [-50, 50] or [-1, 1], an axis of random direction
// (zero in one case of four) and a radius, each log-uniform in 1e-6 to 1e-3.
private static object [ ] SmallReachSlice ( System . Random r )
{
var span = r . Next ( 2 ) = = 0 ? 50.0f : 1.0f ;
var centre = new float3 ( Uniform ( r , - span , span ) , Uniform ( r , - span , span ) , Uniform ( r , - span , span ) ) ;
var axis = new float3 ( 0.0f , 0.0f , 0.0f ) ;
if ( r . Next ( 4 ) ! = 0 )
{
var direction = math . normalize ( new float3 ( Uniform ( r , - 1.0f , 1.0f ) , Uniform ( r , - 1.0f , 1.0f ) , Uniform ( r , - 1.0f , 1.0f ) ) ) ;
axis = direction * MathF . Pow ( 10.0f , Uniform ( r , - 6.0f , - 3.0f ) ) ;
}
return new object [ ] { centre , axis , MathF . Pow ( 10.0f , Uniform ( r , - 6.0f , - 3.0f ) ) } ;
}
2026-10-04 09:47:49 +02:00
private const string SampledForm =
"the arguments are (cx, cy, cz, ax, ay, az, radius, ...) and the result is the form (x0, a, e). Enclosure: for eps in " +
"{-1, -0.5, 0, 0.5, 1} and d in {0, +-ex, +-ey, +-ez, (+-1, +-1, +-1) / sqrt(3)} (15 directions), form the point " +
"p = c + axis eps + radius d in double and round it to float32; the device's own reference value at p must lie in " +
"[x0 + a eps - e, x0 + a eps + e] with no tolerance, so a device whose gradient error exceeds the allowance fails. " +
"Tightness: with L = 7.9640074 and, for each octave (one for af_snoise), R = |axis| + radius, " +
"B = L R + 2^-14 + 2^-12 R + L 2^-20 (|c|_1 + R), the width |a| + e must be at most B + 2^-16 (1 + B). " +
"Report the least slack of each side, absolutely and as a fraction of e; only the two bounds fail the check. " ;
private const string SnoiseForm = SampledForm + "The reference value is cultmath_snoise(p)." ;
private const string FbmForm = SampledForm +
"The reference value is cultmath_fbm_grad(p, octaves, lacunarity, gain).w, and B is the sum over octaves i of gain^i B_i, " +
"where B_i is B for the centre lacunarity^i c, the axis lacunarity^i axis and the radius lacunarity^i radius." ;
2026-10-04 11:09:35 +02:00
// The two small-reach families add the centre leg to every af_snoise and af_fbm family. The device's
// reference value is its own noise, so a device whose noise is wrong everywhere encloses its own wrong
// values; C#'s value at the centre, the form's own x0 in the fixture, is the independent reading.
private const string CentreLeg =
" Centre leg, for every cultmath_af_snoise and cultmath_af_fbm family of this fixture, the earlier ones included: " +
"the fixture's own x0 in the result (C#'s value at the centre) must lie in [x0 - e, x0 + e] of the GPU's form, with " +
"no tolerance, so a device whose noise differs from C#'s by more than its e fails." ;
private const string SmallReach =
" These cases have reach |axis| + radius of 1e-6 to 1e-3, where the float32 allowance is most of e and the second order " +
"remainder is not; the enclosure above fails a device whose gradient error exceeds the allowance." ;
private const string SnoiseSmallForm = SnoiseForm + SmallReach + CentreLeg ;
private const string FbmSmallForm = FbmForm + SmallReach + CentreLeg ;
2026-10-04 09:47:49 +02:00
private const string AffineFrustumBall =
"enclosure and tightness: from the arguments (mx, my, z0, z1, fp, warpVariation) compute in double zm = (z0 + z1) / 2, " +
"h = (z1 - z0) / 2, axis = (mx h, my h, h), c0 = (mx zm, my zm, zm), |c0|_1 = |mx zm| + |my zm| + |zm|, R0 = z1 fp + warpVariation, " +
"spread = (|mx| + |my| + 1) h and d = |GPU centre - c0|. Enclosure: for z in {z0, (3 z0 + z1) / 4, zm, (z0 + 3 z1) / 4, z1}, " +
"eps = clamp((z - zm) / h, -1, 1) and the nine footprint offsets e in {(0, 0), (+-1, 0), (0, +-1), (+-1, +-1) / sqrt(2)}, " +
"the point P = ((mx + fp e.x) z, (my + fp e.y) z, z) satisfies |P - (GPU centre + axis eps)| + warpVariation <= GPU radius. " +
"Tightness: R0 + d <= GPU radius <= R0 + d + 2^-19 (R0 + |c0|_1 + spread). " +
"Report the least slack of each side; only the bounds fail the check." ;
CultMath: Cycles node semantics (Math, Map Range, Clamp, Mix, RGB to BW, ramp index) as math.Cycles.cs and CultMath.Cycles.hlsl under Apache-2.0
Ports of Blender v5.2.2's intern/cycles kernel functions, one function per node
operation, with the HLSL mirror, the Unity copy, the lowering table entry for a
separate Apache-2.0 GLSL file, the golden-fixture families, the package licence
expressions and the notices section.
Builds. Does not pass yet: CultMath.Cycles.glsl and the regenerated golden
fixture arrive in a later commit, so CommittedGlslEqualsLowering and
GoldenFixtureMatchesCSharp fail at this commit.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 03:59:59 +02:00
// The Cycles node families' operands: values past [0, 1] on both sides, so the clamps, the extrapolating
// factors and the divisions by a small number all show.
private static float CyclesValue ( System . Random r ) = > Uniform ( r , - 20.0f , 20.0f ) ;
private static float CyclesFactor ( System . Random r ) = > Uniform ( r , - 0.5f , 1.5f ) ;
private static float3 CyclesColor ( System . Random r ) = > new ( Uniform ( r , - 0.25f , 1.25f ) , Uniform ( r , - 0.25f , 1.25f ) , Uniform ( r , - 0.25f , 1.25f ) ) ;
2026-10-03 14:15:33 +02:00
// A Phacelle stripe wave vector: each component in [-6, 6], about one stripe per cell.
private static float3 Side ( System . Random r ) = > new ( Uniform ( r , - 6.0f , 6.0f ) , Uniform ( r , - 6.0f , 6.0f ) , Uniform ( r , - 6.0f , 6.0f ) ) ;
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
// Every family the site's WebGL2 readback evaluates, in a fixed order. A new family is appended, so the
2026-10-03 14:15:33 +02:00
// seeded stream and every earlier family's cases stay as they were. pcg3d and pcg4d are "exact"; the
// float families are ulp-bounded, with the bound measured on the device by the consumer, and
2026-10-16 04:49:13 +02:00
// iv_frustum_ball also carries an enclosure check; the four coordinate-band snoise_grad and snoise_hessian
// families carry an allowance check, applied to C#'s own results here and to a device's by the device judge. phacelle is in CultMath.Phacelle.glsl, so its
2026-10-03 14:15:33 +02:00
// evaluator concatenates that file after CultMath.glsl; the site, which does not vendor it, skips it.
CultMath: Cycles node semantics (Math, Map Range, Clamp, Mix, RGB to BW, ramp index) as math.Cycles.cs and CultMath.Cycles.hlsl under Apache-2.0
Ports of Blender v5.2.2's intern/cycles kernel functions, one function per node
operation, with the HLSL mirror, the Unity copy, the lowering table entry for a
separate Apache-2.0 GLSL file, the golden-fixture families, the package licence
expressions and the notices section.
Builds. Does not pass yet: CultMath.Cycles.glsl and the regenerated golden
fixture arrive in a later commit, so CommittedGlslEqualsLowering and
GoldenFixtureMatchesCSharp fail at this commit.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 03:59:59 +02:00
private static readonly Family [ ] Families = new Family [ ]
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
{
new ( "float cultmath_snoise(vec3)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) } ) ,
new ( "float cultmath_snoise(vec2)" , "ulp-bounded" , r = > new object [ ] { new float2 ( Uniform ( r , - 50.0f , 50.0f ) , Uniform ( r , - 50.0f , 50.0f ) ) } ) ,
new ( "vec4 cultmath_snoise_grad(vec3)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) } ) ,
new ( "vec4 cultmath_fbm_grad(vec3, int, float, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , 4 , 2.0f , 0.5f } ) ,
new ( "vec4 cultmath_ridged_grad(vec3, int, float, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , 4 , 2.0f , 0.5f } ) ,
new ( "CultCellular cultmath_cellular(vec3)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) } ) ,
new ( "ivec3 cultmath_pcg3d(ivec3)" , "exact" , r = > new object [ ] { new int3 ( Bits ( r ) , Bits ( r ) , Bits ( r ) ) } ) ,
new ( "ivec4 cultmath_pcg4d(ivec4)" , "exact" , r = > new object [ ] { new int4 ( Bits ( r ) , Bits ( r ) , Bits ( r ) , Bits ( r ) ) } ) ,
new ( "vec2 cultmath_iv_point(float)" , "ulp-bounded" , r = > new object [ ] { Uniform ( r , - 20.0f , 20.0f ) } ) ,
new ( "vec2 cultmath_iv_add(vec2, vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_sub(vec2, vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_neg(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_mul(vec2, vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_scale(vec2, float)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Uniform ( r , - 4.0f , 4.0f ) } ) ,
new ( "vec2 cultmath_iv_abs(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_min(vec2, vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_max(vec2, vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_sqr(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_sqrt(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_clamp(vec2, float, float)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Uniform ( r , - 25.0f , 0.0f ) , Uniform ( r , 0.0f , 25.0f ) } ) ,
new ( "vec2 cultmath_iv_saturate(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_smoothstep(float, float, vec2)" , "ulp-bounded" , r = > new object [ ] { Uniform ( r , - 25.0f , 0.0f ) , Uniform ( r , 0.0f , 25.0f ) , Interval ( r ) } ) ,
new ( "vec2 cultmath_iv_lerp(vec2, vec2, float)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) , Interval ( r ) , Uniform ( r , 0.0f , 1.0f ) } ) ,
new ( "vec2 cultmath_iv_snoise_ball(vec3, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Uniform ( r , 0.001f , 2.0f ) } ) ,
new ( "vec2 cultmath_iv_fbm_ball(vec3, float, int, float, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Uniform ( r , 0.001f , 2.0f ) , 4 , 2.0f , 0.5f } ) ,
2026-10-03 14:15:33 +02:00
new ( "vec4 cultmath_iv_frustum_ball(vec2, float, float, float, float)" , "ulp-bounded" , r = >
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
{
var slope = new float2 ( Uniform ( r , - 1.0f , 1.0f ) , Uniform ( r , - 1.0f , 1.0f ) ) ;
var z0 = Uniform ( r , 0.1f , 100.0f ) ;
return new object [ ] { slope , z0 , z0 + Uniform ( r , 0.01f , 50.0f ) , Uniform ( r , 0.0001f , 0.05f ) , Uniform ( r , 0.0f , 2.0f ) } ;
2026-10-04 09:47:49 +02:00
} , FrustumBall , Verify : AssertFrustumBall ) ,
2026-10-03 14:35:48 +02:00
new ( "vec2 cultmath_iv_exp(vec2)" , "ulp-bounded, platform exp" , r = > new object [ ] { Interval ( r ) } , Platform : Platform . Ulp ) ,
2026-10-16 21:22:14 +02:00
new ( "CultPhasor cultmath_phacelle(vec3, vec3, float, float)" , "ulp-bounded, platform exp, sin, cos; across platforms |diff| <= 2^-20 max(|v|, 1); on a device |diff| <= 2^-18 max(|v|, 1)" ,
2026-10-03 14:35:48 +02:00
r = > new object [ ] { Point3 ( r ) , Side ( r ) , Uniform ( r , 0.0f , 1.0f ) , 0.5f } , Platform : Platform . Scaled ) ,
GLSL fixture: tie families, regenerated CultMath.glsl and glsl-parity.json
Two families appended after phacelle, cultmath_snoise(vec3) and
cultmath_snoise_grad(vec3) over TiePoint3 (seven of eight cases on lattice
diagonals, one of eight on (t, t, t)); the shared Random leaves every earlier
family's draws unchanged. Both carry the tolerance text "ulp-bounded, on the
simplex tie set" and share a glsl name with the random families, so a consumer
tells them apart by index or tolerance.
Regenerated on Yggdrasil (Linux, the fixture's platform) with
CULTMATH_WRITE_GLSL=1. CultMath.glsl: the two tie lines, the constant, one
comment sentence. Fixture: 41 cases of iv_snoise_ball(vec3) and iv_fbm_ball move
with L, everything else is byte-identical before the appended families. Full
suite on Yggdrasil: 290 of 290.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-04 03:25:43 +02:00
new ( "float cultmath_snoise(vec3)" , "ulp-bounded, on the simplex tie set" , r = > new object [ ] { TiePoint3 ( r ) } ) ,
new ( "vec4 cultmath_snoise_grad(vec3)" , "ulp-bounded, on the simplex tie set" , r = > new object [ ] { TiePoint3 ( r ) } ) ,
2026-10-04 09:47:49 +02:00
new ( "vec3 cultmath_af_point(float)" , "ulp-bounded" , r = > new object [ ] { Uniform ( r , - 20.0f , 20.0f ) } ) ,
new ( "vec3 cultmath_af_symbol(float, float)" , "ulp-bounded" , r = > new object [ ] { Uniform ( r , - 20.0f , 20.0f ) , Uniform ( r , - 5.0f , 5.0f ) } ) ,
new ( "vec3 cultmath_af_from_iv(vec2)" , "ulp-bounded" , r = > new object [ ] { Interval ( r ) } ) ,
new ( "vec2 cultmath_af_range(vec3)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) } ) ,
new ( "vec3 cultmath_af_add(vec3, vec3)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) , Form ( r ) } ) ,
new ( "vec3 cultmath_af_sub(vec3, vec3)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) , Form ( r ) } ) ,
new ( "vec3 cultmath_af_neg(vec3)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) } ) ,
new ( "vec3 cultmath_af_scale(vec3, float)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) , Uniform ( r , - 4.0f , 4.0f ) } ) ,
new ( "vec3 cultmath_af_add_iv(vec3, vec2)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) , Interval ( r ) } ) ,
new ( "vec3 cultmath_af_mul(vec3, vec3)" , "ulp-bounded" , r = > new object [ ] { Form ( r ) , Form ( r ) } ) ,
2026-10-04 11:09:35 +02:00
new ( "vec3 cultmath_af_snoise(vec3, vec3, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Axis3 ( r ) , BallRadius ( r ) } , SnoiseForm , Verify : cases = > AssertSnoiseForm ( cases ) ) ,
new ( "vec3 cultmath_af_fbm(vec3, vec3, float, int, float, float)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Axis3 ( r ) , BallRadius ( r ) , 4 , 2.0f , 0.5f } , FbmForm , Verify : cases = > AssertFbmForm ( cases ) ) ,
2026-10-04 09:47:49 +02:00
new ( "vec3 cultmath_af_frustum_axis(vec2, float, float)" , "ulp-bounded" , r = >
{
var z0 = Uniform ( r , 0.1f , 100.0f ) ;
return new object [ ] { new float2 ( Uniform ( r , - 1.0f , 1.0f ) , Uniform ( r , - 1.0f , 1.0f ) ) , z0 , z0 + Uniform ( r , 0.01f , 50.0f ) } ;
} ) ,
new ( "vec4 cultmath_af_frustum_ball(vec2, float, float, float, float)" , "ulp-bounded" , r = >
{
var slope = new float2 ( Uniform ( r , - 1.0f , 1.0f ) , Uniform ( r , - 1.0f , 1.0f ) ) ;
var z0 = Uniform ( r , 0.1f , 100.0f ) ;
return new object [ ] { slope , z0 , z0 + Uniform ( r , 0.01f , 50.0f ) , Uniform ( r , 0.0001f , 0.05f ) , Uniform ( r , 0.0f , 2.0f ) } ;
} , AffineFrustumBall , Verify : AssertAffineFrustumBall ) ,
new ( "vec2 cultmath_iv_snoise_ball(vec2, float)" , "ulp-bounded" , r = > new object [ ] { new float2 ( Uniform ( r , - 50.0f , 50.0f ) , Uniform ( r , - 50.0f , 50.0f ) ) , Uniform ( r , 0.001f , 2.0f ) } ) ,
2026-10-04 11:09:35 +02:00
new ( "vec3 cultmath_af_snoise(vec3, vec3, float)" , "ulp-bounded, reach 1e-6 to 1e-3" , SmallReachSlice , SnoiseSmallForm , Verify : cases = > AssertSnoiseForm ( cases , allowanceDecides : true ) ) ,
new ( "vec3 cultmath_af_fbm(vec3, vec3, float, int, float, float)" , "ulp-bounded, reach 1e-6 to 1e-3" , r = > SmallReachSlice ( r ) . Concat ( new object [ ] { 4 , 2.0f , 0.5f } ) . ToArray ( ) , FbmSmallForm , Verify : cases = > AssertFbmForm ( cases , allowanceDecides : true ) ) ,
CultMath: Cycles node semantics (Math, Map Range, Clamp, Mix, RGB to BW, ramp index) as math.Cycles.cs and CultMath.Cycles.hlsl under Apache-2.0
Ports of Blender v5.2.2's intern/cycles kernel functions, one function per node
operation, with the HLSL mirror, the Unity copy, the lowering table entry for a
separate Apache-2.0 GLSL file, the golden-fixture families, the package licence
expressions and the notices section.
Builds. Does not pass yet: CultMath.Cycles.glsl and the regenerated golden
fixture arrive in a later commit, so CommittedGlslEqualsLowering and
GoldenFixtureMatchesCSharp fail at this commit.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 03:59:59 +02:00
new ( "float cultmath_cycles_divide(float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_power(float, float)" , "ulp-bounded, platform pow" , r = > new object [ ] { Uniform ( r , - 4.0f , 4.0f ) , r . Next ( 2 ) = = 0 ? r . Next ( - 4 , 5 ) : Uniform ( r , - 3.0f , 3.0f ) } , Platform : Platform . Ulp ) ,
new ( "float cultmath_cycles_logarithm(float, float)" , "ulp-bounded, platform log" , r = > new object [ ] { Uniform ( r , 0.01f , 20.0f ) , Uniform ( r , 0.01f , 20.0f ) } , Platform : Platform . Ulp ) ,
new ( "float cultmath_cycles_sqrt(float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_inverse_sqrt(float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_modulo(float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_floored_modulo(float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_wrap(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , Uniform ( r , - 10.0f , 10.0f ) , Uniform ( r , - 10.0f , 10.0f ) } ) ,
new ( "float cultmath_cycles_snap(float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_pingpong(float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_smooth_min(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , Uniform ( r , - 5.0f , 5.0f ) } ) ,
new ( "float cultmath_cycles_smooth_max(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , Uniform ( r , - 5.0f , 5.0f ) } ) ,
new ( "float cultmath_cycles_compare(float, float, float)" , "ulp-bounded" , r = > { var a = CyclesValue ( r ) ; return new object [ ] { a , a + Uniform ( r , - 1.0f , 1.0f ) * 1.0e-3f , Uniform ( r , 0.0f , 2.0e-3f ) } ; } ) ,
new ( "float cultmath_cycles_round(float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_trunc(float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_fract(float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_sign(float)" , "ulp-bounded" , r = > new object [ ] { r . Next ( 4 ) = = 0 ? 0.0f : CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_map_range_linear(float, float, float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_map_range_stepped(float, float, float, float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , Uniform ( r , - 1.0f , 8.0f ) } ) ,
new ( "float cultmath_cycles_map_range_smoothstep(float, float, float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_map_range_smootherstep(float, float, float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_clamp_minmax(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_clamp_range(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesValue ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "float cultmath_cycles_mix_float(float, float, float)" , "ulp-bounded" , r = > new object [ ] { CyclesFactor ( r ) , CyclesValue ( r ) , CyclesValue ( r ) } ) ,
new ( "vec3 cultmath_cycles_mix_vector(float, vec3, vec3)" , "ulp-bounded" , r = > new object [ ] { CyclesFactor ( r ) , CyclesColor ( r ) , CyclesColor ( r ) } ) ,
new ( "vec3 cultmath_cycles_rgb_to_hsv(vec3)" , "ulp-bounded" , r = > new object [ ] { CyclesColor ( r ) } ) ,
new ( "vec3 cultmath_cycles_hsv_to_rgb(vec3)" , "ulp-bounded" , r = > new object [ ] { new float3 ( r . NextSingle ( ) , r . NextSingle ( ) , Uniform ( r , 0.0f , 2.0f ) ) } ) ,
new ( "float cultmath_cycles_rgb_to_bw(vec3)" , "ulp-bounded" , r = > new object [ ] { CyclesColor ( r ) } ) ,
2026-10-12 06:14:44 +02:00
new ( "vec2 cultmath_cycles_ramp_index(float, int)" , "ulp-bounded" , r = > new object [ ] { Uniform ( r , - 0.25f , 1.25f ) , 257 } ) ,
CultMath: Cycles node semantics (Math, Map Range, Clamp, Mix, RGB to BW, ramp index) as math.Cycles.cs and CultMath.Cycles.hlsl under Apache-2.0
Ports of Blender v5.2.2's intern/cycles kernel functions, one function per node
operation, with the HLSL mirror, the Unity copy, the lowering table entry for a
separate Apache-2.0 GLSL file, the golden-fixture families, the package licence
expressions and the notices section.
Builds. Does not pass yet: CultMath.Cycles.glsl and the regenerated golden
fixture arrive in a later commit, so CommittedGlslEqualsLowering and
GoldenFixtureMatchesCSharp fail at this commit.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-12 03:59:59 +02:00
} . Concat ( new [ ]
{
"blend" , "add" , "mul" , "screen" , "overlay" , "sub" , "div" , "diff" , "exclusion" , "dark" , "light" , "dodge" , "burn" , "hue" , "sat" , "val" , "color" , "soft" , "linear" ,
2026-10-14 02:45:51 +02:00
} . Select ( mode = > new Family ( $"vec3 cultmath_cycles_mix_{mode}(float, vec3, vec3)" , "ulp-bounded" , r = > new object [ ] { CyclesFactor ( r ) , CyclesColor ( r ) , CyclesColor ( r ) } ) ) ) . Concat ( new [ ]
{
new Family ( "float cultmath_cycles_arcsine(float)" , "ulp-bounded, platform asin" , r = > new object [ ] { Uniform ( r , - 1.5f , 1.5f ) } , Platform : Platform . Ulp ) ,
new Family ( "float cultmath_cycles_arccosine(float)" , "ulp-bounded, platform acos" , r = > new object [ ] { Uniform ( r , - 1.5f , 1.5f ) } , Platform : Platform . Ulp ) ,
new Family ( "float cultmath_cycles_arctan2(float, float)" , "ulp-bounded, platform atan" , r = > new object [ ] { Uniform ( r , - 20.0f , 20.0f ) , Uniform ( r , - 20.0f , 20.0f ) } , Platform : Platform . Ulp ) ,
2026-10-14 06:31:43 +02:00
new Family ( "mat3 cultmath_snoise_hessian(vec3)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) } ) ,
new Family ( "mat3 cultmath_snoise_hessian(vec3)" , "ulp-bounded, on the simplex tie set" , r = > new object [ ] { TiePoint3 ( r ) } ) ,
new Family ( "float cultmath_integral_clamp_linear(float, float, float, float, float, float)" , "ulp-bounded" ,
r = >
{
var lo = Uniform ( r , - 2.0f , 0.5f ) ;
return new object [ ] { Uniform ( r , - 4.0f , 4.0f ) , r . Next ( 8 ) = = 0 ? 0.0f : Uniform ( r , - 4.0f , 4.0f ) , lo , lo + Uniform ( r , 0.0f , 3.0f ) , Uniform ( r , - 3.0f , 3.0f ) , Uniform ( r , - 3.0f , 3.0f ) } ;
} ) ,
2026-10-14 20:42:04 +02:00
// The edge cases the family above never draws: lo above hi (b = 0 and b != 0; the lowering must
// normalise before any clamp sees it) and infinite bounds (hi = +inf, lo = -inf, both).
new Family ( "float cultmath_integral_clamp_linear(float, float, float, float, float, float)" , "ulp-bounded, lo above hi and infinite bounds" ,
r = >
{
var a = Uniform ( r , - 4.0f , 4.0f ) ;
var slope = Uniform ( r , - 4.0f , 4.0f ) ;
var ( t0 , t1 ) = ( Uniform ( r , - 3.0f , 3.0f ) , Uniform ( r , - 3.0f , 3.0f ) ) ;
return r . Next ( 5 ) switch
{
0 = > new object [ ] { a , 0.0f , Uniform ( r , 0.5f , 2.0f ) , Uniform ( r , - 2.0f , 0.4f ) , t0 , t1 } ,
1 = > new object [ ] { a , slope , Uniform ( r , 0.5f , 2.0f ) , Uniform ( r , - 2.0f , 0.4f ) , t0 , t1 } ,
2 = > new object [ ] { a , slope , Uniform ( r , - 2.0f , 1.0f ) , float . PositiveInfinity , t0 , t1 } ,
3 = > new object [ ] { a , slope , float . NegativeInfinity , Uniform ( r , - 1.0f , 2.0f ) , t0 , t1 } ,
_ = > new object [ ] { a , slope , float . NegativeInfinity , float . PositiveInfinity , t0 , t1 } ,
} ;
} ) ,
2026-10-16 01:01:54 +02:00
// Zero-length spans (t1 = t0 three times in four) with a flat or sloped line, and infinite clamp bounds
// on either side or both: an infinite bound times a zero length must give +0, and a flat line clamped
// to an infinite bound over a nonzero span is infinite, never NaN.
new Family ( "float cultmath_integral_clamp_linear(float, float, float, float, float, float)" , "ulp-bounded, zero-length spans and flat infinite clamps" ,
r = >
{
float Line ( ) = > r . Next ( 3 ) switch { 0 = > 0.0f , 1 = > - 0.0f , _ = > Uniform ( r , - 4.0f , 4.0f ) } ;
float Bound ( ) = > r . Next ( 3 ) switch { 0 = > float . NegativeInfinity , 1 = > float . PositiveInfinity , _ = > Uniform ( r , - 2.0f , 2.0f ) } ;
var ( a , b , lo , hi ) = ( Line ( ) , Line ( ) , Bound ( ) , Bound ( ) ) ;
var t0 = Uniform ( r , - 3.0f , 3.0f ) ;
var t1 = r . Next ( 4 ) ! = 0 ? t0 : Uniform ( r , - 3.0f , 3.0f ) ;
return new object [ ] { a , b , lo , hi , t0 , t1 } ;
} ) ,
2026-10-16 02:58:05 +02:00
// The span stages over their struct arguments: realistic stages and spans (SpanStageTests' own draw), the
// midpoint a Point3, one span in four a point.
new Family ( "SpanNoise cultmath_span_fbm(SpanPath, SpanStage, int, float, float)" , "ulp-bounded" , SpanArguments ) ,
new Family ( "SpanNoise cultmath_span_ridged(SpanPath, SpanStage, int, float, float)" , "ulp-bounded" , SpanArguments ) ,
2026-10-16 04:49:13 +02:00
// The kernel's reads over coordinate bands, the magnitude log-uniform in the band: the allowance of
// math.span_slack is checked against the exact kernel at every case (SpanAllowanceRead).
new Family ( "vec4 cultmath_snoise_grad(vec3)" , "ulp-bounded, coordinate bands 1e-4 to 1e2" , r = > new object [ ] { BandPoint3 ( r , 1.0e-4 , 1.0e2 ) } , SpanAllowanceRead , Verify : cases = > AssertSpanAllowance ( cases , hessian : false , small : true ) ) ,
new Family ( "vec4 cultmath_snoise_grad(vec3)" , "ulp-bounded, coordinate bands 1e2 to 4e6" , r = > new object [ ] { BandPoint3 ( r , 1.0e2 , 4.0e6 ) } , SpanAllowanceRead , Verify : cases = > AssertSpanAllowance ( cases , hessian : false , small : false ) ) ,
new Family ( "mat3 cultmath_snoise_hessian(vec3)" , "ulp-bounded, coordinate bands 1e-4 to 1e2" , r = > new object [ ] { BandPoint3 ( r , 1.0e-4 , 1.0e2 ) } , SpanAllowanceRead , Verify : cases = > AssertSpanAllowance ( cases , hessian : true , small : true ) ) ,
new Family ( "mat3 cultmath_snoise_hessian(vec3)" , "ulp-bounded, coordinate bands 1e2 to 4e6" , r = > new object [ ] { BandPoint3 ( r , 1.0e2 , 4.0e6 ) } , SpanAllowanceRead , Verify : cases = > AssertSpanAllowance ( cases , hessian : true , small : false ) ) ,
2026-10-16 18:21:50 +02:00
// Segment distance in 2D and 3D (one segment in eight degenerate), then the site cells: scores, fold step
// over states built by inserting 0-3 random scores (one in four with an exactly tied score), border, margin.
2026-10-16 21:01:16 +02:00
new Family ( "float cultmath_distance_to_segment(vec2, vec2, vec2)" , "ulp-bounded" , r = >
{
var start = Point2 ( r ) ;
return new object [ ] { Point2 ( r ) , start , r . Next ( 8 ) = = 0 ? start : Point2 ( r ) } ;
} ) ,
new Family ( "vec2 cultmath_segment_closest(vec2, vec2, vec2)" , "ulp-bounded" , r = >
{
var start = Point2 ( r ) ;
return new object [ ] { Point2 ( r ) , start , r . Next ( 8 ) = = 0 ? start : Point2 ( r ) } ;
} ) ,
2026-10-16 19:15:55 +02:00
new Family ( "float cultmath_distance_to_segment(vec3, vec3, vec3)" , "ulp-bounded" , r = >
2026-10-16 18:21:50 +02:00
{
2026-10-16 19:15:55 +02:00
var start = Point3 ( r ) ;
return new object [ ] { Point3 ( r ) , start , r . Next ( 8 ) = = 0 ? start : Point3 ( r ) } ;
2026-10-16 18:21:50 +02:00
} ) ,
2026-10-16 19:15:55 +02:00
new Family ( "vec3 cultmath_segment_closest(vec3, vec3, vec3)" , "ulp-bounded" , r = >
2026-10-16 18:21:50 +02:00
{
var start = Point3 ( r ) ;
return new object [ ] { Point3 ( r ) , start , r . Next ( 8 ) = = 0 ? start : Point3 ( r ) } ;
} ) ,
2026-10-16 19:15:55 +02:00
// The border step: owner and other random (one in six coincident), a running border either empty or a
2026-10-16 21:01:16 +02:00
// random (normal, distance); one in six other is a distinct site within 1e-3 of the owner (inside the 1e-2 guard a
// changed length test would trip), one in six coincident.
2026-10-16 19:15:55 +02:00
new Family ( "vec4 cultmath_power_border_step(vec3, vec4, vec4, vec4)" , "ulp-bounded" , r = >
{
var owner = Site ( r , 0.1f , 20.0f ) ;
var border = r . Next ( 2 ) = = 0 ? new float4 ( 0.0f , 0.0f , 0.0f , 1.0e30f ) : new float4 ( Point3 ( r ) , Uniform ( r , 0.0f , 50.0f ) ) ;
2026-10-16 21:01:16 +02:00
var pick = r . Next ( 6 ) ;
var near = new float4 ( owner . xyz + new float3 ( Uniform ( r , 1.0e-4f , 1.0e-3f ) , Uniform ( r , - 1.0e-3f , 1.0e-3f ) , Uniform ( r , - 1.0e-3f , 1.0e-3f ) ) , Uniform ( r , 0.1f , 20.0f ) ) ;
return new object [ ] { Point3 ( r ) , owner , pick = = 0 ? owner : pick = = 1 ? near : Site ( r , 0.1f , 20.0f ) , border } ;
2026-10-16 19:15:55 +02:00
} ) ,
2026-10-16 18:21:50 +02:00
new Family ( "vec4 cultmath_power_score(vec3, vec4)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Site ( r , 0.1f , 20.0f ) } ) ,
new Family ( "vec4 cultmath_multiplicative_score(vec3, vec4)" , "ulp-bounded" , r = > new object [ ] { Point3 ( r ) , Site ( r , 0.1f , 100.0f , logWeight : true ) } ) ,
new Family ( "CultSiteCells cultmath_site_cells_insert(CultSiteCells, vec4, int)" , "ulp-bounded" , r = >
{
var ( cells , scores ) = CellsState ( r ) ;
var score = r . Next ( 4 ) = = 0 & & scores . Count > 0 ? scores [ r . Next ( scores . Count ) ] : PowerOrMultiplicative ( r ) ;
return new object [ ] { cells , score , scores . Count } ;
} ) ,
new Family ( "vec4 cultmath_site_cells_border(CultSiteCells)" , "ulp-bounded" , r = >
{
var ( cells , _ ) = CellsState ( r , minimum : r . Next ( 8 ) = = 0 ? 0 : 2 ) ;
return new object [ ] { cells } ;
} ) ,
new Family ( "float cultmath_gabriel_margin(vec3, vec3, vec3)" , "ulp-bounded" , r = >
{
var a = Point3 ( r ) ;
return new object [ ] { a , r . Next ( 8 ) = = 0 ? a : Point3 ( r ) , Point3 ( r ) } ;
} ) ,
2026-10-17 11:31:46 +02:00
// The lattice steps. The cell is an integer-valued vec2 (negative and large included), time and drift span
// zero and the accepted range; the weight's border covers 0, near the falloff, and the 1.0e30 of no body.
new Family ( "vec3 cultmath_lattice_site(vec2, float, float)" , "ulp-bounded" , r = >
new object [ ] { new float2 ( r . Next ( - 4000 , 4000 ) , r . Next ( - 4000 , 4000 ) ) , r . Next ( 6 ) = = 0 ? 0.0f : Uniform ( r , - 200.0f , 200.0f ) , r . Next ( 6 ) = = 0 ? 0.0f : Uniform ( r , - 3.0f , 3.0f ) } ) ,
new Family ( "float cultmath_lattice_weight(float, float, float, float)" , "ulp-bounded" , r = >
{
var falloff = Uniform ( r , 0.05f , 40.0f ) ;
var border = r . Next ( 5 ) switch { 0 = > 0.0f , 1 = > 1.0e30f , 2 = > falloff * Uniform ( r , 0.9f , 1.1f ) , _ = > Uniform ( r , 0.0f , 3.0f * falloff ) } ;
var boost = r . Next ( 5 ) switch { 0 = > 0.0f , 1 = > 4.0f , _ = > Uniform ( r , 0.0f , 4.0f ) } ;
return new object [ ] { Uniform ( r , 0.5f , 1.0f ) , border , boost , falloff } ;
} ) ,
new Family ( "float cultmath_lattice_distance(vec2, vec2, float, vec2, float)" , "ulp-bounded" , r = >
{
var angle = Uniform ( r , 0.0f , 6.2831855f ) ;
var normal = r . Next ( 6 ) = = 0 ? new float2 ( 1.0f , 0.0f ) : new float2 ( MathF . Cos ( angle ) , MathF . Sin ( angle ) ) ;
var stretch = r . Next ( 5 ) switch { 0 = > 1.0f , 1 = > 2.0f , _ = > Uniform ( r , 1.0f , 2.0f ) } ;
return new object [ ] { Point2 ( r ) , Point2 ( r ) , Uniform ( r , 0.5f , 5.0f ) , normal , stretch } ;
} ) ,
// The smooth step: d exactly at f1 + 2 smoothing one in four (the equal branch), near it one in four, the
// smoothing near 0 and at 1, m anywhere up to f1 + smoothing.
2026-10-17 16:09:18 +02:00
// One draw in four is the cap point: m = f1 + smoothing exactly and d = f1 + smoothing (1 + U(0.3, 0.9)) with smoothing in
// [0.5, 1], where next exceeds f1 + smoothing and the min clamps; a step that returns next reads another function there.
2026-10-17 11:31:46 +02:00
new Family ( "float cultmath_lattice_smooth_step(float, float, float, float)" , "ulp-bounded" , r = >
{
2026-10-17 16:09:18 +02:00
if ( r . Next ( 4 ) = = 0 )
{
var cappedSmoothing = Uniform ( r , 0.5f , 1.0f ) ;
var cappedF1 = Uniform ( r , 0.0f , 10.0f ) ;
return new object [ ] { cappedF1 + cappedSmoothing , cappedF1 + cappedSmoothing * ( 1.0f + Uniform ( r , 0.3f , 0.9f ) ) , cappedF1 , cappedSmoothing } ;
}
2026-10-17 11:31:46 +02:00
var smoothing = r . Next ( 5 ) switch { 0 = > 1.0f , 1 = > Uniform ( r , 1.0e-3f , 1.0e-2f ) , _ = > Uniform ( r , 0.01f , 1.0f ) } ;
var f1 = Uniform ( r , 0.0f , 10.0f ) ;
var edge = f1 + 2.0f * smoothing ;
var d = r . Next ( 4 ) switch { 0 = > edge , 1 = > edge * Uniform ( r , 0.99f , 1.01f ) , _ = > Uniform ( r , f1 , edge + 1.0f ) } ;
return new object [ ] { Uniform ( r , f1 , f1 + smoothing ) , d , f1 , smoothing } ;
} ) ,
2026-10-17 16:09:18 +02:00
// The site-array functions: a fixed-capacity array and a count, killed on the device (the lattice at rings up to 17).
new Family ( $"vec4 cultmath_power_border(vec3, vec4[{SiteArrays.Capacity}], int)" , "ulp-bounded" , SiteArrays . PowerBorderArguments ) ,
new Family ( $"vec4 cultmath_weighted_lattice_cells(vec2, float, vec4[{SiteArrays.Capacity}], int, float, float, float, float, float, vec2, float)" , "ulp-bounded" , SiteArrays . LatticeArguments ) ,
2026-10-14 02:45:51 +02:00
} ) . ToArray ( ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
2026-10-16 04:49:13 +02:00
// A point of magnitude m, m log-uniform in [lo, hi]: one component at +-m, the other two uniform in [-m, m],
// the axis of the large one random.
private static float3 BandPoint3 ( System . Random r , double lo , double hi )
{
var m = lo * Math . Pow ( hi / lo , r . NextDouble ( ) ) ;
var v = new double [ ] { ( r . NextDouble ( ) * 2.0 - 1.0 ) * m , ( r . NextDouble ( ) * 2.0 - 1.0 ) * m , ( r . NextDouble ( ) * 2.0 - 1.0 ) * m } ;
v [ r . Next ( 3 ) ] = r . Next ( 2 ) = = 0 ? m : - m ;
return new float3 ( ( float ) v [ 0 ] , ( float ) v [ 1 ] , ( float ) v [ 2 ] ) ;
}
2026-10-16 18:21:50 +02:00
// A site float4(position.xyz, weight): the weight uniform in [lo, hi], or log-uniform when logWeight.
private static float4 Site ( System . Random r , float lo , float hi , bool logWeight = false )
{
var p = Point3 ( r ) ;
return new float4 ( p . x , p . y , p . z , logWeight ? lo * MathF . Pow ( hi / lo , r . NextSingle ( ) ) : Uniform ( r , lo , hi ) ) ;
}
private static float4 PowerOrMultiplicative ( System . Random r ) = >
r . Next ( 2 ) = = 0 ? math . power_score ( Point3 ( r ) , Site ( r , 0.1f , 20.0f ) ) : math . multiplicative_score ( Point3 ( r ) , Site ( r , 0.1f , 100.0f , logWeight : true ) ) ;
// A fold state made by the production path: site_cells_insert over a few random scores (at least minimum).
private static ( CultSiteCells Cells , List < float4 > Scores ) CellsState ( System . Random r , int minimum = 0 )
{
var scores = new List < float4 > ( ) ;
var cells = math . site_cells_empty ( ) ;
for ( var i = minimum + r . Next ( 4 - minimum ) ; i > 0 ; i - - )
{
var score = r . Next ( 4 ) = = 0 & & scores . Count > 0 ? scores [ ^ 1 ] : PowerOrMultiplicative ( r ) ;
cells = math . site_cells_insert ( cells , score , scores . Count ) ;
scores . Add ( score ) ;
}
return ( cells , scores ) ;
}
2026-10-16 02:58:05 +02:00
private static object [ ] SpanArguments ( System . Random r )
{
var stage = SpanStageTests . Stage . Draw ( r ) ;
var halfLength = r . Next ( 4 ) = = 0 ? 0.0f : new [ ] { 0.02f , 0.1f , 0.5f } [ r . Next ( 3 ) ] ;
var span = SpanStageTests . Span . Draw ( r , Point3 ( r ) , halfLength , Uniform ( r , 0.0f , 2.0f ) ) ;
return new object [ ] { span . Path , stage . S , stage . Octaves , stage . Lacunarity , stage . Gain } ;
}
/// <summary>
/// The committed fixture's cases of the three cultmath_integral_clamp_linear families, decoded into the
/// C# arguments (a, b, lo, hi, t0, t1): the random cases the clamp-normalisation tests also run.
/// </summary>
internal static IReadOnlyList < float [ ] > IntegralClampLinearFixtureCases
{
get
{
const string clamp = "float cultmath_integral_clamp_linear(float, float, float, float, float, float)" ;
var method = Resolve ( clamp ) ;
return JsonNode . Parse ( File . ReadAllText ( FixturePath ) ) ! [ "functions" ] ! . AsArray ( )
. Where ( family = > ( string ) family ! [ "glsl" ] ! = = clamp )
. SelectMany ( family = > family ! [ "cases" ] ! . AsArray ( ) )
. Select ( entry = > Arguments ( method , ( ( string ) entry ! ) . Split ( " -> " ) [ 0 ] ) . Select ( a = > ( float ) a ) . ToArray ( ) )
. ToArray ( ) ;
}
}
2026-10-03 14:35:48 +02:00
// The fixture text, each case's arguments given by family and point index.
private static string GoldenFixture ( Func < int , int , object [ ] > arguments )
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
{
var json = new StringBuilder ( ) ;
json . Append ( "{\n" ) ;
json . Append ( " \"generator\": \"GlslMirrorTests.GoldenFixtureMatchesCSharp (packages/cultmath/tests/CultMath.Tests); regenerate with CULTMATH_WRITE_GLSL=1\",\n" ) ;
json . Append ( $" \" seed \ ": {Seed},\n" ) ;
json . Append ( $" \" points \ ": {Points},\n" ) ;
json . Append ( " \"encoding\": \"each case is 'arguments -> result', every scalar a float32 or 32-bit integer bit pattern in hex, vectors and structs flattened in field order\",\n" ) ;
json . Append ( " \"functions\": [\n" ) ;
for ( var f = 0 ; f < Families . Length ; f + + )
{
var family = Families [ f ] ;
var method = Resolve ( family . Glsl ) ;
json . Append ( " {\n" ) ;
json . Append ( $" \" glsl \ ": \"{family.Glsl}\",\n" ) ;
json . Append ( $" \" tolerance \ ": \"{family.Tolerance}\",\n" ) ;
2026-10-03 14:15:33 +02:00
if ( family . Check is not null )
json . Append ( $" \" check \ ": \"{family.Check}\",\n" ) ;
2026-10-03 14:35:48 +02:00
if ( family . Platform ! = Platform . None )
CultMath GLSL: Phacelle lowered into its own MPL-2.0 file; iv_frustum_ball and iv_exp in the fixture
GlslLowering.SeparateFiles is the one name-keyed rule: CultMath.Phacelle.hlsl
lowers into shaders/CultMath.Phacelle.glsl (MPL-2.0, guard
CULTMATH_PHACELLE_GLSL) and its include line leaves CultMath.glsl, which is
now MIT and says so in its provenance line. ReadShaderSource takes an
include predicate (one resolver); the C# mirror still inlines everything.
GlslMirrorTests pins both files, checks tokens in each, takes the union of
definitions and asserts cultmath_phacelle( and CultPhasor live only in the
Phacelle file. The fixture appends cultmath_iv_frustum_ball (exact) and
cultmath_iv_exp ("ulp-bounded, platform exp", platform named); the
comparison is per family, the platform family within 1 ulp with the
maximum printed. THIRD-PARTY-NOTICES lists CultMath.Phacelle.glsl, not
CultMath.glsl, as MPL-2.0.
Regenerated on Yggdrasil (Ubuntu 24.04.5, .NET 10.0.12); 286/286 green,
iv_exp within 0 ulp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 13:40:16 +02:00
json . Append ( $" \" platform \ ": \"{RuntimeInformation.OSDescription}; {RuntimeInformation.FrameworkDescription}\",\n" ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
json . Append ( " \"cases\": [\n" ) ;
for ( var p = 0 ; p < Points ; p + + )
{
2026-10-03 14:35:48 +02:00
var values = arguments ( f , p ) ;
var result = method . Invoke ( null , values ) ! ;
json . Append ( " \"" ) . Append ( Hex ( values ) ) . Append ( " -> " ) . Append ( Hex ( new [ ] { result } ) ) . Append ( '"' ) ;
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
json . Append ( p + 1 < Points ? ",\n" : "\n" ) ;
}
json . Append ( " ]\n" ) ;
json . Append ( f + 1 < Families . Length ? " },\n" : " }\n" ) ;
}
json . Append ( " ]\n}\n" ) ;
return json . ToString ( ) ;
}
private static readonly Dictionary < string , Type > GlslTypes = new ( )
{
["float"] = typeof ( float ) , [ "int" ] = typeof ( int ) , [ "vec2" ] = typeof ( float2 ) , [ "vec3" ] = typeof ( float3 ) ,
["vec4"] = typeof ( float4 ) , [ "ivec3" ] = typeof ( int3 ) , [ "ivec4" ] = typeof ( int4 ) ,
2026-10-16 02:58:05 +02:00
["SpanPath"] = typeof ( SpanPath ) , [ "SpanStage" ] = typeof ( SpanStage ) ,
2026-10-16 18:21:50 +02:00
["CultSiteCells"] = typeof ( CultSiteCells ) ,
2026-10-17 16:09:18 +02:00
[$"vec4[{SiteArrays.Capacity}] "] = typeof(float4[]),
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
} ;
// The C# math method a GLSL signature names: cultmath_ dropped, parameter types mapped.
private static MethodInfo Resolve ( string glsl )
{
var match = Regex . Match ( glsl , @"^\w+ cultmath_(\w+)\(([^)]*)\)$" ) ;
var types = match . Groups [ 2 ] . Value . Split ( ", " ) . Select ( t = > GlslTypes [ t ] ) . ToArray ( ) ;
return typeof ( math ) . GetMethod ( match . Groups [ 1 ] . Value , BindingFlags . Public | BindingFlags . Static , null , types , null )
2026-10-17 16:09:18 +02:00
? ? typeof ( SiteArrays ) . GetMethod ( match . Groups [ 1 ] . Value , BindingFlags . NonPublic | BindingFlags . Static , null , types , null )
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
? ? throw new InvalidOperationException ( "no C# math counterpart for " + glsl ) ;
}
private static string Hex ( IEnumerable < object > values ) = > string . Join ( " " , values . SelectMany ( Scalars ) . Select ( v = > v switch
{
float f = > BitConverter . SingleToInt32Bits ( f ) . ToString ( "x8" ) ,
int i = > i . ToString ( "x8" ) ,
uint u = > u . ToString ( "x8" ) ,
_ = > throw new InvalidOperationException ( v . GetType ( ) . Name ) ,
} ) ) ;
2026-10-14 06:31:43 +02:00
// A float3x3 flattens row by row; the matrices the library exports are symmetric, so the order is
// the same read as GLSL's columns.
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
private static IEnumerable < object > Scalars ( object value ) = > value is float or int or uint
? new [ ] { value }
2026-10-17 16:09:18 +02:00
: value is Array array
? array . Cast < object > ( ) . SelectMany ( Scalars )
2026-10-14 06:31:43 +02:00
: value is float3x3 matrix
? new object [ ] { matrix . _m00 , matrix . _m01 , matrix . _m02 , matrix . _m10 , matrix . _m11 , matrix . _m12 , matrix . _m20 , matrix . _m21 , matrix . _m22 }
CultMath GLSL: shaders/CultMath.glsl generated from the HLSL by one enumerated lowering, pinned
GlslLowering (test project) is the HLSL -> GLSL ES 3.00 transformation as named steps: includes
inlined by the C# mirror's own resolver, guards and texture functions dropped, type names,
static const, casts by a balanced scanner, intrinsic renames, literals passed through, the
CULTMATH_GLSL guard and a provenance line. GlslMirrorTests pins the committed file to the
lowering (CULTMATH_WRITE_GLSL=1 regenerates it), finds no HLSL-only token, finds every public
function but the texture samplers, and pins fixtures/glsl-parity.json (256 seeded cases per
family as float32 bit patterns) to C#.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 20:09:44 +02:00
: value . GetType ( ) . GetFields ( ) . Where ( f = > ! f . IsStatic ) . SelectMany ( f = > Scalars ( f . GetValue ( value ) ! ) ) ;
// ---- A small unified diff for the failure message ----
private static string UnifiedDiff ( string before , string after )
{
var a = before . Split ( '\n' ) ;
var b = after . Split ( '\n' ) ;
if ( ( long ) a . Length * b . Length > 4_000_000 )
{
var first = Enumerable . Range ( 0 , Math . Min ( a . Length , b . Length ) ) . FirstOrDefault ( i = > a [ i ] ! = b [ i ] , Math . Min ( a . Length , b . Length ) ) ;
return $"@@ first difference at line {first + 1} @@\n-{(first < a.Length ? a[first] : "")}\n+{(first < b.Length ? b[first] : "")}" ;
}
var lcs = new int [ a . Length + 1 , b . Length + 1 ] ;
for ( var i = a . Length - 1 ; i > = 0 ; i - - )
for ( var j = b . Length - 1 ; j > = 0 ; j - - )
lcs [ i , j ] = a [ i ] = = b [ j ] ? lcs [ i + 1 , j + 1 ] + 1 : Math . Max ( lcs [ i + 1 , j ] , lcs [ i , j + 1 ] ) ;
var lines = new List < string > { "--- committed" , "+++ lowering" } ;
int x = 0 , y = 0 ;
while ( x < a . Length | | y < b . Length )
{
if ( x < a . Length & & y < b . Length & & a [ x ] = = b [ y ] ) { x + + ; y + + ; continue ; }
lines . Add ( $"@@ -{x + 1} +{y + 1} @@" ) ;
while ( x < a . Length & & ( y > = b . Length | | lcs [ x + 1 , y ] > = lcs [ x , y + 1 ] ) & & ! ( y < b . Length & & a [ x ] = = b [ y ] ) )
lines . Add ( "-" + a [ x + + ] ) ;
while ( y < b . Length & & ( x > = a . Length | | a [ x ] ! = b [ y ] ) )
lines . Add ( "+" + b [ y + + ] ) ;
if ( lines . Count > 200 )
break ;
}
return string . Join ( "\n" , lines . Take ( 200 ) ) ;
}
}