onejs-sl 0.1.12 → 0.1.13

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.13
+
+Unity's Metal compile of OneJS's effects no longer warns of an uninitialized variable. Nothing draws differently.
+
+- `onejsFbmKind` returns once, so FxSources compiles on Metal with no warning
+- A WGSL noise kind no longer evaluates both fBm kinds to pick one
+
 ## 0.1.12
 
 The noise hashes are integer arithmetic, so every GPU draws the same bits. Value noise and voronoi look different, seed 0 included; program hashes do not change.

package/README.md

@@ -115,8 +115,8 @@ know the project's colour space when it prints.
 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
+WebGPU and WebGL2 and draw every fixture; OneJS's parity harness draws every
+fixture through a real WebGL player and holds it to the goldens; `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.
 
@@ -125,9 +125,11 @@ them to agree; and the Metal check above compiles the shared subset.
 `goldens/goldens.json` is every corpus fixture drawn as a Linear OneJS game
 stores it: the package's WGSL and GLSL ES in OneJS's web frame, into an
 `rgba8unorm-srgb` target (the format the element's render texture has), read
-back raw, with no Unity, no UI Toolkit and no browser colour management. A
-second host's own backend is checked against it; OneJS's parity harness is what
-proves the web emitters equal the VM in the first place.
+back raw, with no Unity, no UI Toolkit and no browser colour management. The
+goldens stand on their own: the two backends must agree, and the anchors and
+the hash probes must match arithmetic. A host's own backend is checked against
+them, as OneJS's parity harness (`Tools/sl-web-parity` in the container) checks
+what a WebGL player draws.
 
 `npm run goldens` draws it on WebGPU and WebGL2 in a Chrome with its own
 profile (set `CHROME` to choose one). The two backends must agree within 1/255
@@ -202,17 +204,17 @@ container this package is checked out at `JSModules/onejs-sl`, and
 
 ## The one idea
 
-**One authoring surface, one IR, two backends.** Unity cannot compile a shader
-at runtime in a player build, on any graphics API, so in the browser a program
-has to become data that a fixed shader evaluates. Ejecting to a Unity project
-does not change what the author wrote, it changes what is possible, because an
-editor compiles shaders at build time.
+**One authoring surface, one IR, several backends.** Unity cannot compile a
+shader at runtime in a player build, on any graphics API, so the first backend
+made a program data that a fixed shader evaluates: a VM. An editor does compile
+shaders, at build time, so the second prints HLSL for it.
 
-So the same source is interpreted by a VM on play.onejs.com and compiled from
-generated HLSL after an eject, with no edit in between. Both backends exist:
+So the same source draws compiled from generated HLSL in the editor and in a
+native player, with no edit in between, and the VM stays behind a switch: OneJS
+leaves it out unless a project defines `ONEJS_SL_VM`. Both backends exist:
 `encode.ts` feeds OneJS's `Runtime/SL/SLProgramBridge.cs` and `FxProgram.shader`,
 and `hlsl.ts` feeds its `Editor/SLShaderGenerator.cs`. Nobody writes a manifest for the
-second: an editor that interprets a program asks the encoded program for its
+second: an editor that draws a program asks the encoded program for its
 `hlsl` (a lazy getter, never read in Play), records it into
 `Assets/OneJS/Recorded.sl.json`, generates the shader and
 moves the live material onto it. `manifest()` is still there for an app that
@@ -223,10 +225,11 @@ shader, but the page it runs in can. `web.ts` prints every program as WGSL and
 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
-lazy getters, like `hlsl`. The VM draws until the compiled program is ready,
-and for good if it fails to compile. The host contract (the frame block, the
+and draws it into the element's target. A `.sl` import carries both strings,
+printed at build time; an `encode()` result has them as lazy getters, like
+`hlsl`. A WebGL player has no VM: the element draws nothing until the compiled
+program is ready, and nothing after a compile error, which the page reports.
+The host contract (the frame block, the
 16 uniform slots, one binding pair per sampled texture) is written out at the
 top of `web.ts`.
 
@@ -234,7 +237,7 @@ The emitters match the HLSL emitter's semantics rather than each language's
 own: `%` truncates like `fmod`, `pow` takes `abs` of its base, `asin` and
 `acos` clamp, `log` and `sqrt` guard their argument, a select is the VM's
 branchless `lerp`. `web.test.ts` checks the structure (every shape, every
-opcode, the library order); whether the output matches the VM within 1/255 is
+opcode, the library order); whether the output matches the goldens is
 measured in a browser, through the real element, by `Tools/sl-web-parity` in
 the container.
 
@@ -294,8 +297,10 @@ baseline, which is the one resource neither backend can widen.
 
 `Program.hash` is what will link a program to its compiled shader. If it differs
 between the machine that generated the shader and the machine that runs it, the
-runtime falls back to the VM and **nobody is told**: correct output, quietly
-slow, no error. That is the worst failure this design can have.
+player finds no shader for the program: it draws nothing and logs one error
+naming the hash. Before OneJS 3.6.0 it fell back to the VM and **nobody was
+told**: correct output, quietly slow, no error, the worst failure this design
+could have, and the reason the hash is built the way it is.
 
 So it is a Merkle hash over the graph reachable from the result, not a walk of
 the node array. An earlier version hashed storage order, which meant hoisting a

package/goldens/goldens.json

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

package/lib/noise2d.hlsl

@@ -213,10 +213,16 @@ float onejsRidged(float2 p, float seed, int octaves, float lacunarity, float gai
 
 /// 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.
+///
+/// One return, at the end. Written with early returns, every path still
+/// returns, but Unity's Metal compile warns of a potentially uninitialized
+/// variable named after this function in every project that imports OneJS.
 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);
+    float n;
+    if (kind == 2) n = onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    else if (kind == 3) n = onejsRidged(p, seed, octaves, lacunarity, gain);
+    else if (kind == 1) n = onejsFbmSimplex(p, seed, octaves, lacunarity, gain);
+    else n = onejsFbm(p, seed, octaves, lacunarity, gain);
+    return n;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onejs-sl",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "The OneJS shader language: a small typed language for per pixel programs, compiled to a portable IR and emitted as HLSL, WGSL, GLSL ES or a VM buffer",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/lib/glsl.ts

@@ -710,13 +710,17 @@ float onejsRidged(vec2 p, float seed, int octaves, float lacunarity, float gain)
 `,
     `
 float onejsFbmKind(int kind, vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    float n;
     if (kind == 2) {
-        return onejsTurbulence(p, seed, octaves, lacunarity, gain);
-    }
-    if (kind == 3) {
-        return onejsRidged(p, seed, octaves, lacunarity, gain);
+        n = onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 3) {
+        n = onejsRidged(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 1) {
+        n = onejsFbmSimplex(p, seed, octaves, lacunarity, gain);
+    } else {
+        n = onejsFbm(p, seed, octaves, lacunarity, gain);
     }
-    return kind == 1 ? onejsFbmSimplex(p, seed, octaves, lacunarity, gain) : onejsFbm(p, seed, octaves, lacunarity, gain);
+    return n;
 }
 `,
     `

package/src/lib/hlsl.ts

@@ -710,13 +710,17 @@ float onejsRidged(float2 p, float seed, int octaves, float lacunarity, float gai
 `,
     `
 float onejsFbmKind(int kind, float2 p, float seed, int octaves, float lacunarity, float gain) {
+    float n;
     if (kind == 2) {
-        return onejsTurbulence(p, seed, octaves, lacunarity, gain);
-    }
-    if (kind == 3) {
-        return onejsRidged(p, seed, octaves, lacunarity, gain);
+        n = onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 3) {
+        n = onejsRidged(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 1) {
+        n = onejsFbmSimplex(p, seed, octaves, lacunarity, gain);
+    } else {
+        n = onejsFbm(p, seed, octaves, lacunarity, gain);
     }
-    return kind == 1 ? onejsFbmSimplex(p, seed, octaves, lacunarity, gain) : onejsFbm(p, seed, octaves, lacunarity, gain);
+    return n;
 }
 `,
     `

package/src/lib/wgsl.ts

@@ -761,13 +761,17 @@ fn onejsRidged(pIn: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32)
 `,
     `
 fn onejsFbmKind(kind: i32, p: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    var n: f32;
     if (kind == 2) {
-        return onejsTurbulence(p, seed, octaves, lacunarity, gain);
-    }
-    if (kind == 3) {
-        return onejsRidged(p, seed, octaves, lacunarity, gain);
+        n = onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 3) {
+        n = onejsRidged(p, seed, octaves, lacunarity, gain);
+    } else if (kind == 1) {
+        n = onejsFbmSimplex(p, seed, octaves, lacunarity, gain);
+    } else {
+        n = onejsFbm_f2_f_i_f_f(p, seed, octaves, lacunarity, gain);
     }
-    return select(onejsFbm_f2_f_i_f_f(p, seed, octaves, lacunarity, gain), onejsFbmSimplex(p, seed, octaves, lacunarity, gain), kind == 1);
+    return n;
 }
 `,
     `