onejs-sl 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.1.3
+
+`onejs-sl/tables` names every parameter, so an editor can offer `lerp(x, y, s)` rather than an argument count. Nothing a program compiles to changes.
+
+- `BUILTIN_PARAMS` names every builtin's parameters
+- `SL_SDF_PARAM_NAMES` names every shape's parameters
+- `LIB_SIGNATURES` gives every library function's parameter names and types
+
+## 0.1.2
+
+The helper library has one source, `lib/*.hlsl`, translated at build time into GLSL ES, WGSL and the shared subset and copied into OneJS as its `.cginc` files. The web draws exactly what it drew; the Unity shader's text changes where Metal needed it to, and draws the same.
+
+- `emitLibrary` prints the library functions a body calls, in the shared subset
+- `emitBody` prints no scalar swizzles, and types every literal and scalar it passes to an intrinsic
+- `atan2` of vectors is refused; no web backend compiled it
+- `onejs-sl/goldens.json` exports the goldens
+- The tests compile the shared subset as Metal on a Mac with Xcode
+
 ## 0.1.1
 
 A host can now supply its own frame for a program's body and get goldens for the pictures it should draw. Nothing an existing program draws changes, and OneJS's generated Unity shader is byte for byte what 0.1.0 printed.

package/README.md

@@ -37,12 +37,13 @@ only what it calls.
 |---|---|
 | `onejs-sl` | `parse` and `analyze`, the TypeScript form `sl`, the IR types, `SL_IR_VERSION`, `toJSON`/`fromJSON`, `SLParseError` (file, line, column, length) |
 | `onejs-sl/core` | the same without the parser: what a game needs at run time |
-| `onejs-sl/tables` | `BUILTINS`, `SL_HLSL`, `INPUTS`, `SL_SDF_SHAPES`, `SL_SDF_PARAMS`: what completion and highlighting read |
+| `onejs-sl/tables` | `BUILTINS`, `SL_HLSL`, `INPUTS`, `SL_SDF_SHAPES`, `SL_SDF_PARAMS`: what completion and highlighting read. `BUILTIN_PARAMS`, `SL_SDF_PARAM_NAMES` and `LIB_SIGNATURES` name every parameter, so an editor can show `lerp(x, y, s)` |
 | `onejs-sl/limits` | `vmFit(program)`: whether the VM runs it, and why not, without encoding |
 | `onejs-sl/vm` | `encode`, `SL_WIRE_VERSION` |
-| `onejs-sl/emit/hlsl-body` | `emitBody`: a program as a function body for a host's own frame |
+| `onejs-sl/emit/hlsl-body` | `emitBody`: a program as a function body for a host's own frame; `emitLibrary`: the library functions it calls |
 | `onejs-sl/emit/unity` | `emitShader`: the `.shader` a Unity editor generates, a frame over `emitBody` |
 | `onejs-sl/emit/web` | `emitWGSL`, `emitGLSL`: OneJS's web frame |
+| `onejs-sl/goldens.json` | the goldens (below), as data |
 
 `src/entries.test.ts` pins every name, since removing one breaks a host.
 
@@ -50,16 +51,25 @@ only what it calls.
 
 `emitBody(program, target)` prints the body only: one local per node, in the
 HLSL and Metal shared subset (HLSL spelling, `fmod`, no `mul`, no `static`, no
-derivatives). The `BodyTarget` says what differs between hosts: an expression
+derivatives, no swizzle of a scalar, and every literal and scalar in an
+intrinsic at its exact type, since Metal overloads where HLSL converts). The `BodyTarget` says what differs between hosts: an expression
 for each input, the float4 holding a uniform slot, a texture sample, whether
 `toLinear` is real (`colour: "linear"`) or the identity (`"gamma"`), and
 optionally a local to assign the result to. It returns the uniform and texture
 slots the body uses and the library functions it calls. OneJS's Unity shader is
 one frame over it (`hlsl.ts`); Magerie's compute kernel is another, and its
 target is in `src/body.test.ts` so an opcode cannot change without the text
-Magerie compiles changing in front of a test. The library functions' own text
-arrives with the translator (`Specs/SL_PACKAGE.md` section 5); until then a host
-takes them from OneJS's `SLCommon.cginc`, `Noise2D.cginc` and `SDF2D.cginc`.
+Magerie compiles changing in front of a test.
+
+`emitLibrary(body.uses.helpers, colour)` prints the library functions the body
+calls, and everything they call, in the same subset and dependency order, with
+the colour branch asked for: the text a host puts ahead of its frame. It is a
+separate call because OneJS's own frame never needs it (the Unity shader
+includes `SLCommon.cginc`), and a bundle that prints only Unity shaders should
+not carry the library too. On a Mac with Xcode, `src/metal.test.ts` compiles
+the whole library and a body for every corpus program and every builtin at
+every width as Metal, behind the two defines a host's compatibility header
+supplies (`frac`, `lerp`).
 
 A uniform declared with a hex default (`uniform float4 tint = #ff8040;`), or
 with `sl.uniform.colour`, is marked `colour: true`: its value is sRGB as
@@ -67,6 +77,44 @@ written, which is what a colour picker shows, and its reads convert. `inputsUsed
 says which inputs the result depends on, dead nodes aside, so a host knows
 whether a program animates.
 
+## The helper library: one source
+
+Value and simplex noise, the octave kinds, voronoi, hsv2rgb, `toLinear` and the
+42 distance shapes are written once, in HLSL, in `lib/sdf2d.hlsl`,
+`lib/noise2d.hlsl` and `lib/common.hlsl`. Everything else is printed from them
+by `npm run lib`, and nobody edits the copies:
+
+- **OneJS's `.cginc` files** (`SDF2D`, `Noise2D`, `SLCommon` in
+  `Resources/OneJS/`) are the source with an include guard and a generated
+  header around it. The VM, the generated Unity shaders and `fx` include them.
+  `npm run lib` writes them when the package sits in the OneJS container.
+- **`src/lib/`**: `table.ts` (every function, its signature, what it calls, and
+  the shape table read from `sl_sdfDistance`'s switch), and the text of each
+  function as GLSL ES (`glsl.ts`), WGSL (`wgsl.ts`) and the shared subset
+  (`hlsl.ts`). The web emitters and `emitLibrary` take only what a program calls.
+  `names.ts` holds each function's parameter names, which only
+  `onejs-sl/tables` reads.
+
+`lib/translate.ts` does the printing, at build time only. It reads a subset of
+HLSL, listed at its top (functions, locals, `if`, bounded `for`, `switch`,
+intrinsics, `mul(v, float2x2(...))`, and one preprocessor switch,
+`UNITY_COLORSPACE_GAMMA`, which becomes the target's colour), and anything
+outside it is an error with a file and line rather than a guess. HLSL converts
+where GLSL, WGSL and Metal refuse, so it makes every conversion explicit first;
+the printers then differ in spelling, plus what WGSL lacks (overloading,
+ternaries, swizzle assignment, assignable parameters). On the web the colour
+switch stays a runtime branch on the frame's `opt.x`, since a web build does not
+know the project's colour space when it prints.
+
+`src/lib/lib.test.ts` regenerates everything and fails on any byte of
+difference, the `.cginc` copies included in the container, and OneJS's
+`SLSharedLibraryTests` checks them from the other side. What proves the
+translations draw the same picture: the goldens compile the whole library on
+WebGPU and WebGL2 and draw every fixture; OneJS's parity harness holds the web
+output to the VM; `SLSharedLibraryTests` draws every corpus program in Unity
+through `SLCommon.cginc` and through the translated shared subset and requires
+them to agree; and the Metal check above compiles the shared subset.
+
 ## Goldens
 
 `goldens/goldens.json` is every corpus fixture drawn as a Linear OneJS game
@@ -81,8 +129,10 @@ profile (set `CHROME` to choose one). The two backends must agree within 1/255
 over every pixel, and three anchors must match arithmetic, not each other:
 `orient.sl` (orientation, and the linear to sRGB store), `hex.sl` (a hex colour
 stores as written) and `texture.sl` (a texture's orientation and sRGB decode).
-The file describes the sampling grid, the times and the texture every sampled
-slot gets. No CI runner here has a GPU, so `src/goldens.test.ts` checks instead
+The whole translated library must also compile on both backends, including
+the functions no fixture reaches. The file describes the sampling grid, the
+times and the texture every sampled slot gets. A host imports it as
+`onejs-sl/goldens.json`. No CI runner here has a GPU, so `src/goldens.test.ts` checks instead
 that the file still covers the corpus at today's hashes; a change that moves a
 hash fails there until the goldens are drawn again.
 
@@ -131,8 +181,8 @@ would rather write its programs out at build time.
 
 **A third and fourth backend, for the browser.** A player cannot compile a
 shader, but the page it runs in can. `web.ts` prints every program as WGSL and
-as GLSL ES 3.00 (`weblib.ts` holds the noise, colour and 42 distance functions
-ported from `SLCommon.cginc`, `Noise2D.cginc` and `SDF2D.cginc`), and OneJS's
+as GLSL ES 3.00 (carrying the library functions it calls, translated from
+`lib/*.hlsl`), and OneJS's
 `Plugins/WebGL/OneJSSLWeb.jslib` compiles whichever one Unity's device speaks
 and draws it into the element's target in place of the VM. A `.sl` import
 carries both strings, printed at build time; an `encode()` result has them as
@@ -294,13 +344,13 @@ linear light. `sl.ramp` mixes its stops in sRGB, which is what reads as an even
 ramp, and converts the result once through `TO_LINEAR`; `sl.color("#hex")` is
 `parseColor` plus that conversion, and `sl.toLinear` is the conversion on its
 own for a vec4 built from raw components. Both backends implement it gamma
-aware (`sl_toLinear` in `SLCommon.cginc`), so a Gamma project gets the value as
-written. Alpha is coverage and is never converted. Same rule as `fx`.
+aware (`sl_toLinear` in `lib/common.hlsl`), so a Gamma project gets the value
+as written. Alpha is coverage and is never converted. Same rule as `fx`.
 
 ## Noise
 
 `sl.noise`, `sl.simplex`, `sl.fbm(p, octaves, base)`, `sl.turbulence` and
-`sl.ridged` are the fields `fx.noise` draws, from the same `Noise2D.cginc`, so
+`sl.ridged` are the fields `fx.noise` draws, from the same `lib/noise2d.hlsl`, so
 a simplex here is the simplex there. Octaves are 1 to 4. A program has no seed;
 offset the input for a different field. `sl.simplex` used to be value noise on
 a rotated lattice, and `sl.fbm` had its own value noise; both changed on

package/goldens/goldens.json

@@ -1,6 +1,6 @@
 {
  "generatedBy": "onejs-sl goldens/run.mjs",
- "package": "0.1.0",
+ "package": "0.1.2",
  "ir": 2,
  "target": "rgba8unorm-srgb: straight alpha, 8 bit, sRGB encoded, the stored bytes of a Linear OneJS game's element",
  "size": [

package/lib/common.hlsl

@@ -0,0 +1,155 @@
+// Helpers shared by EVERY shader language backend.
+//
+// The VM (OneJS/FxProgram.shader) includes this as SLCommon.cginc, and every
+// shader generated from a program by the HLSL emitter includes it too. The web
+// emitters and a host's own frame (`emitBody`) get it translated, by
+// `lib/translate.ts`, from this one text. That sharing is the whole reason this
+// file exists: the backends have to agree, and the fastest way to make them
+// disagree is to write `noise` twice.
+//
+// Anything an opcode needs that is more than one expression belongs here rather
+// than in either backend. If it lives in only one, the golden image comparison
+// fails on every program that touches it, and the failure looks like a bug in
+// the program.
+
+// Noise is the same code fx draws with (noise2d.hlsl), so `sl.simplex` and
+// `fx.noise({ type: "simplex" })` mean one thing, and turbulence and ridged
+// exist here for the same reason they exist there. A program has no seed of
+// its own: offset the input to get a different field. The four kinds and
+// their numbers are the contract with `onejsFbmKind`: 0 value fBm, 1 simplex
+// fBm, 2 turbulence, 3 ridged, with the classic lacunarity 2 and gain 0.5.
+// Voronoi keeps its own hash: the fx side has no voronoi to share yet.
+float sl_hash21(float2 p)
+{
+    p = frac(p * float2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return frac(p.x * p.y);
+}
+
+float sl_valueNoise(float2 p) { return onejsVNoise(p, 0.0); }
+float sl_simplex(float2 p)    { return onejsSimplex(p, 0.0); }
+float sl_fbm(float2 p, int octaves, int kind)
+{
+    return onejsFbmKind(kind, p, 0.0, clamp(octaves, 1, 4), 2.0, 0.5);
+}
+
+float3 sl_hsv2rgb(float3 c)
+{
+    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * lerp(K.xxx, saturate(p - K.xxx), c.y);
+}
+
+/**
+ * Signed distance to a shape, positive outside.
+ *
+ * The id table is SDF_SHAPES in onejs-unity/src/fx/sdf.ts, shared with the fx
+ * pipeline so a shape means the same thing in both. A contract test compares
+ * them, because this dispatcher is a second copy of the one in FxSources and a
+ * copy is exactly the thing that drifts.
+ *
+ * The shader language passes four parameters where fx passes six. Position and
+ * rotation are deliberately absent: a program transforms the point before
+ * calling this, which is both how signed distance code is normally written and
+ * more composable than baking a transform into every shape.
+ */
+float sl_sdfDistance(int id, float2 p, float4 a, float2 b)
+    {
+        switch (id)
+        {
+        case 0:  return sdCircle(p, a.x);
+        case 1:  return sdRoundedBox(p, a.xy, float4(a.z, a.w, b.x, b.y));
+        case 2:  return sdBox(p, a.xy);
+        case 3:  return sdOrientedBox(p, a.xy, a.zw, b.x);
+        case 4:  return sdSegment(p, a.xy, a.zw);
+        case 5:  return sdRhombus(p, a.xy);
+        case 6:  return sdTrapezoid(p, a.x, a.y, a.z);
+        case 7:  return sdParallelogram(p, a.x, a.y, a.z);
+        case 8:  return sdEquilateralTriangle(p, a.x);
+        case 9:  return sdTriangleIsosceles(p, a.xy);
+        case 10: return sdTriangle(p, a.xy, a.zw, b.xy);
+        case 11: return sdUnevenCapsule(p, a.x, a.y, a.z);
+        case 12: return sdPentagon(p, a.x);
+        case 13: return sdHexagon(p, a.x);
+        case 14: return sdOctogon(p, a.x);
+        case 15: return sdHexagram(p, a.x);
+        case 16: return sdStar5(p, a.x, a.y);
+        case 17: return sdStar(p, a.x, (int)a.y, a.z);
+        case 18: return sdPie(p, a.xy, a.z);
+        case 19: return sdCutDisk(p, a.x, a.y);
+        case 20: return sdArc(p, a.xy, a.z, a.w);
+        case 21: return sdRing(p, a.xy, a.z, a.w);
+        case 22: return sdHorseshoe(p, a.xy, a.z, float2(a.w, b.x));
+        case 23: return sdVesica(p, a.x, a.y);
+        case 24: return sdOrientedVesica(p, a.xy, a.zw, b.x);
+        case 25: return sdMoon(p, a.x, a.y, a.z);
+        case 26: return sdRoundedCross(p, a.x);
+        case 27: return sdEgg(p, a.x, a.y, a.z, a.w);
+        case 28: return sdHeart(p);
+        case 29: return sdCross(p, a.xy, a.z);
+        case 30: return sdRoundedX(p, a.x, a.y);
+        case 31: return sdEllipse(p, a.xy);
+        case 32: return sdParabola(p, a.x);
+        case 33: return sdParabolaSegment(p, a.x, a.y);
+        case 34: return sdBezier(p, a.xy, a.zw, b.xy);
+        case 35: return sdBlobbyCross(p, a.x);
+        case 36: return sdTunnel(p, a.xy);
+        case 37: return sdStairs(p, a.xy, a.z);
+        case 38: return sdQuadraticCircle(p);
+        case 39: return sdHyberbola(p, a.x, a.y);
+        case 40: return sdCoolS(p);
+        case 41: return sdCircleWave(p, a.x, a.y);
+        default: return 1e6;
+        }
+    }
+
+float sl_voronoi(float2 p)
+{
+    // Distance to the nearest of a jittered lattice of points. Written here
+    // rather than in either backend, for the same reason as the noise above.
+    float2 cell = floor(p);
+    float2 f = frac(p);
+    float best = 8.0;
+    [unroll]
+    for (int y = -1; y <= 1; y++)
+    {
+        [unroll]
+        for (int x = -1; x <= 1; x++)
+        {
+            float2 o = float2(x, y);
+            float2 jitter = float2(sl_hash21(cell + o), sl_hash21(cell + o + 37.7));
+            best = min(best, length(o + jitter - f));
+        }
+    }
+    return best;
+}
+
+float sl_luminance(float3 c) { return dot(c, float3(0.2126, 0.7152, 0.0722)); }
+
+// A colour as written (sRGB, like CSS) to the working space the target holds.
+// Fx targets are linear float textures that a Linear colour space project
+// encodes on display, so a stop stored as written drew lighter than its swatch.
+// In a Gamma project the written value is already right. The float4 form keeps
+// alpha, which is coverage rather than light. Mirrors fxColorToWorking.
+//
+// Every width uses Unity's cubic approximation, lane by lane. The VM has one
+// TO_LINEAR for all widths (its registers are float4, so it converts .rgb),
+// and a scalar or float2 on the exact curve here drew up to 5/255 apart from
+// it in the dark range: the editor and a player disagreed.
+//
+// The curve is Unity's GammaToLinearSpace, written out here so that a target
+// without UnityCG.cginc has it too. The switch below is the one piece of
+// preprocessor the translator reads: it becomes the target's colour setting.
+float3 sl_gammaToLinear(float3 c) { return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878); }
+
+#ifdef UNITY_COLORSPACE_GAMMA
+float  sl_toLinear(float c)  { return c; }
+float2 sl_toLinear(float2 c) { return c; }
+float3 sl_toLinear(float3 c) { return c; }
+float4 sl_toLinear(float4 c) { return c; }
+#else
+float  sl_toLinear(float c)  { return sl_gammaToLinear(float3(c, 0, 0)).x; }
+float2 sl_toLinear(float2 c) { return sl_gammaToLinear(float3(c, 0)).xy; }
+float3 sl_toLinear(float3 c) { return sl_gammaToLinear(c); }
+float4 sl_toLinear(float4 c) { return float4(sl_gammaToLinear(c.rgb), c.a); }
+#endif

package/lib/noise2d.hlsl

@@ -0,0 +1,167 @@
+// Scrolling fBm value noise, shared by OneJS/TextureFX and OneJS/FxSources.
+//
+// Computed from a seed rather than sampled, so an effect needs no texture, any
+// seed works without shipping art for it, and the field is infinite: scrolling
+// never repeats and never has to tile.
+//
+// This lives in its own include because two shaders want it. Keeping a second
+// copy in each would let them drift, and a noise field that differs by shader
+// is the kind of thing nobody notices until two effects that should match do
+// not.
+
+float onejsHash21(float2 p, float seed)
+{
+    p = frac(p * float2(123.34, 456.21) + seed * 0.1731);
+    p += dot(p, p + 45.32);
+    return frac(p.x * p.y);
+}
+
+float onejsVNoise(float2 p, float seed)
+{
+    float2 i = floor(p), f = frac(p);
+    f = f * f * (3.0 - 2.0 * f);
+    float a = onejsHash21(i, seed);
+    float b = onejsHash21(i + float2(1, 0), seed);
+    float c = onejsHash21(i + float2(0, 1), seed);
+    float d = onejsHash21(i + float2(1, 1), seed);
+    return lerp(lerp(a, b, f.x), lerp(c, d, f.x), f.y);
+}
+
+// Octaves are capped at 4 and the loop is unrolled to that, because a dynamic
+// trip count here costs more than the octaves it saves.
+/// lacunarity is how much finer each octave gets, gain how much quieter.
+/// The classic pair is 2 and 0.5; pushing lacunarity up and gain toward 1 gives
+/// the stringy, turbulent look that reads as fire or smoke rather than cloud.
+float onejsFbm(float2 p, float seed, int octaves, float lacunarity, float gain)
+{
+    float sum = 0, amp = 0.5, norm = 0;
+    [unroll(4)]
+    for (int o = 0; o < 4; o++)
+    {
+        if (o >= octaves) break;
+        sum += onejsVNoise(p, seed + o * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+
+/// The classic parameters, for callers that do not care.
+float onejsFbm(float2 p, float seed, int octaves)
+{
+    return onejsFbm(p, seed, octaves, 2.0, 0.5);
+}
+
+// MARK: simplex
+//
+// Ashima/McEwan 2D simplex. Worth carrying next to the value noise because the
+// two fail differently: value noise interpolates a square grid, so at high
+// octave gain its cells show through as blocks, which is exactly what spoiled
+// the first pass at the fire sample. Simplex is built on triangles and has no
+// axis-aligned structure to leak.
+
+float2 onejsMod289(float2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+float3 onejsMod289(float3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
+float3 onejsPermute(float3 x) { return onejsMod289(((x * 34.0) + 1.0) * x); }
+
+/// Raw simplex, roughly -1..1.
+float onejsSimplexRaw(float2 v)
+{
+    const float4 C = float4(0.211324865405187, 0.366025403784439,
+                            -0.577350269189626, 0.024390243902439);
+    float2 i = floor(v + dot(v, C.yy));
+    float2 x0 = v - i + dot(i, C.xx);
+    float2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
+    float4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+    i = onejsMod289(i);
+    float3 p = onejsPermute(onejsPermute(i.y + float3(0.0, i1.y, 1.0))
+                            + i.x + float3(0.0, i1.x, 1.0));
+    float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
+    m = m * m; m = m * m;
+    float3 x = 2.0 * frac(p * C.www) - 1.0;
+    float3 h = abs(x) - 0.5;
+    float3 ox = floor(x + 0.5);
+    float3 a0 = x - ox;
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+    float3 g;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
+}
+
+/// 0..1, and seeded by displacing the input: simplex has no seed of its own.
+float onejsSimplex(float2 p, float seed)
+{
+    return onejsSimplexRaw(p + seed * 137.13) * 0.5 + 0.5;
+}
+
+float onejsFbmSimplex(float2 p, float seed, int octaves, float lacunarity, float gain)
+{
+    float sum = 0, amp = 0.5, norm = 0;
+    [unroll(4)]
+    for (int o = 0; o < 4; o++)
+    {
+        if (o >= octaves) break;
+        sum += onejsSimplex(p, seed + o * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+
+// MARK: turbulence and ridged
+//
+// fBm above sums signed octaves, so octaves cancel as often as they add and the
+// field reads as cloud. Turbulence sums the ABSOLUTE value of each octave: the
+// zero crossings become creases, and the creases of every octave stack into
+// the veins and licks that read as fire, smoke and marble. Ridged inverts the
+// same crease so it is the bright line rather than the dark one, and squares
+// it so the ridges stay sharp under the finer octaves. Both are built on
+// simplex; a value noise crease follows the grid and shows as blocks.
+
+/// 0..1. Perlin's turbulence: sum over octaves of |signed simplex|.
+float onejsTurbulence(float2 p, float seed, int octaves, float lacunarity, float gain)
+{
+    float sum = 0, amp = 0.5, norm = 0;
+    [unroll(4)]
+    for (int o = 0; o < 4; o++)
+    {
+        if (o >= octaves) break;
+        sum += abs(onejsSimplexRaw(p + (seed + o * 19.0) * 137.13)) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+
+/// 0..1. Musgrave's ridged multifractal, without the feedback term: the
+/// crease of |signed simplex| turned into a bright ridge and squared.
+float onejsRidged(float2 p, float seed, int octaves, float lacunarity, float gain)
+{
+    float sum = 0, amp = 0.5, norm = 0;
+    [unroll(4)]
+    for (int o = 0; o < 4; o++)
+    {
+        if (o >= octaves) break;
+        float r = 1.0 - abs(onejsSimplexRaw(p + (seed + o * 19.0) * 137.13));
+        sum += r * r * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+
+/// Dispatches on the noise kind: 0 value fBm, 1 simplex fBm, 2 turbulence,
+/// 3 ridged. The numbers are the contract with onejs-unity/src/fx/image.ts.
+float onejsFbmKind(int kind, float2 p, float seed, int octaves, float lacunarity, float gain)
+{
+    if (kind == 2) return onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    if (kind == 3) return onejsRidged(p, seed, octaves, lacunarity, gain);
+    return kind == 1 ? onejsFbmSimplex(p, seed, octaves, lacunarity, gain)
+                     : onejsFbm(p, seed, octaves, lacunarity, gain);
+}