onejs-sl 0.1.0 → 0.1.2

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);
+}