@aura3d/rendering 3.0.1 → 4.0.2

package/dist/post/chunks/indirectFraction.glsl.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `prd03.indirectFraction` — C-02 chunk + feature writing the §6.3
+ * indirect-fraction into `color0.a` (PRD-03 §6.3).
+ *
+ * The forward shader computes `a3dColor = direct + indirect + emissive`; this
+ * chunk's `fragment:end` hook computes
+ * `f_ind = clamp(luminance(indirectDiffuse + indirectSpecular) /
+ * max(luminance(a3dColor), 1e-4), 0, 1)` so S2's apply can do
+ * `mix(1.0, aoMB, f_ind)` — ambient-dominated pixels get full occlusion while
+ * emissive, sky and direct-lit pixels stay untouched.
+ *
+ * Tagged encoding: the alpha written is `AO_INDIRECT_FRACTION_TAG + f_ind`
+ * (∈ [2, 3]) so the S2 apply can tell generated-program pixels (which carry
+ * f_ind) from legacy shaderKey draws, custom shaders and the clear (alpha
+ * ≤ 1, which carry none). Legacy pixels take the conservative
+ * `u_aoFallbackStrength` path. The tag also keeps C-05 alpha coverage intact:
+ * `clamp(alpha, 0, 1)` is still 1 for every drawn opaque pixel; the S2 apply
+ * restores alpha to 1 after decoding. Blended (`ALPHA_BLEND`) and
+ * alpha-to-coverage draws keep their real alpha (overwriting it would change
+ * blending / A2C coverage; keeping f_ind there needs Q-01-1
+ * `blendFuncSeparate(srcRGB, dstRGB, ZERO, ONE)`).
+ */
+import type { ShaderChunk, ShaderFeature } from "../../contracts/program.js";
+/** `fragment:pars` — luminance + fraction helper (declaration-level). */
+export declare const indirectFractionParsChunk: ShaderChunk;
+/**
+ * `fragment:end` — the alpha write itself, in the C-02 generator's
+ * forward-fragment scope (`program/ProgramGenerator.ts`
+ * `forwardFragmentSource`): at `fragment:end` the final linear colour is
+ * `a3dColor` (vec3), the alpha is `a3dAlpha`, and the indirect accumulators
+ * `indirectDiffuse`/`indirectSpecular` are always declared (zero on unlit
+ * programs). The generator then writes `outColor = vec4(a3dColor, a3dAlpha)`,
+ * so the fraction goes into `a3dAlpha`. Blended draws keep their real alpha:
+ * overwriting it would change blending (keeping f_ind there needs Q-01-1).
+ *
+ * The previous body wrote `o_color` and read `a3dIndirectRadiance`, which the
+ * generator never declares, so every forward program under `A3D_QR_POST`
+ * failed to compile ("'o_color' : undeclared identifier", #1139).
+ */
+export declare const indirectFractionWriteChunk: ShaderChunk;
+/**
+ * Offset added to f_ind in `color0.a` (see the module doc). The S2 apply
+ * treats `alpha ≥ AO_INDIRECT_FRACTION_TAG − 0.5` as tagged and decodes
+ * `w = clamp(alpha − AO_INDIRECT_FRACTION_TAG, 0, 1)`.
+ */
+export declare const AO_INDIRECT_FRACTION_TAG = 2;
+export declare const INDIRECT_FRACTION_BIT = "indirectFraction";
+export declare const indirectFractionFeature: ShaderFeature;
+export declare function registerIndirectFractionShader(registerChunk: (c: ShaderChunk) => void, registerFeature: (f: ShaderFeature) => () => void): () => void;
+//# sourceMappingURL=indirectFraction.glsl.d.ts.map

package/dist/post/chunks/indirectFraction.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indirectFraction.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/chunks/indirectFraction.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE1E,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,EAAE,WAoBvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B,EAAE,WASxC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD,eAAO,MAAM,uBAAuB,EAAE,aAoBrC,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,EACvC,eAAe,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,MAAM,IAAI,GAChD,MAAM,IAAI,CAIZ"}

package/dist/post/chunks/indirectFraction.glsl.js

@@ -0,0 +1,82 @@
+/** `fragment:pars` — luminance + fraction helper (declaration-level). */
+export const indirectFractionParsChunk = {
+    name: "a3d_prd03_indirectFractionPars",
+    owner: "prd03",
+    stage: "fragment",
+    glsl: `// f_ind = luminance(indirect) / max(luminance(radiance), 1e-4)  (§6.3)
+vec4 a3dWriteIndirectFraction(vec4 color, vec3 indirectRadiance) {
+  float indLuma = dot(indirectRadiance, vec3(0.2126, 0.7152, 0.0722));
+  float radLuma = max(dot(color.rgb, vec3(0.2126, 0.7152, 0.0722)), 1e-4);
+  color.a = clamp(indLuma / radLuma, 0.0, 1.0);
+  return color;
+}
+`,
+    wgsl: `fn a3dWriteIndirectFraction(colorIn: vec4<f32>, indirectRadiance: vec3<f32>) -> vec4<f32> {
+  var color = colorIn;
+  let indLuma = dot(indirectRadiance, vec3<f32>(0.2126, 0.7152, 0.0722));
+  let radLuma = max(dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), 1e-4);
+  color.a = clamp(indLuma / radLuma, 0.0, 1.0);
+  return color;
+}
+`
+};
+/**
+ * `fragment:end` — the alpha write itself, in the C-02 generator's
+ * forward-fragment scope (`program/ProgramGenerator.ts`
+ * `forwardFragmentSource`): at `fragment:end` the final linear colour is
+ * `a3dColor` (vec3), the alpha is `a3dAlpha`, and the indirect accumulators
+ * `indirectDiffuse`/`indirectSpecular` are always declared (zero on unlit
+ * programs). The generator then writes `outColor = vec4(a3dColor, a3dAlpha)`,
+ * so the fraction goes into `a3dAlpha`. Blended draws keep their real alpha:
+ * overwriting it would change blending (keeping f_ind there needs Q-01-1).
+ *
+ * The previous body wrote `o_color` and read `a3dIndirectRadiance`, which the
+ * generator never declares, so every forward program under `A3D_QR_POST`
+ * failed to compile ("'o_color' : undeclared identifier", #1139).
+ */
+export const indirectFractionWriteChunk = {
+    name: "a3d_prd03_indirectFractionWrite",
+    owner: "prd03",
+    stage: "fragment",
+    requires: ["a3d_prd03_indirectFractionPars"],
+    glsl: `#if !defined(ALPHA_BLEND) && !defined(ALPHA_TO_COVERAGE)
+a3dAlpha = 2.0 + a3dWriteIndirectFraction(vec4(a3dColor, a3dAlpha), indirectDiffuse + indirectSpecular).a;
+#endif`,
+    wgsl: `a3dAlpha = 2.0 + a3dWriteIndirectFraction(vec4<f32>(a3dColor, a3dAlpha), indirectDiffuse + indirectSpecular).a;`
+};
+/**
+ * Offset added to f_ind in `color0.a` (see the module doc). The S2 apply
+ * treats `alpha ≥ AO_INDIRECT_FRACTION_TAG − 0.5` as tagged and decodes
+ * `w = clamp(alpha − AO_INDIRECT_FRACTION_TAG, 0, 1)`.
+ */
+export const AO_INDIRECT_FRACTION_TAG = 2;
+export const INDIRECT_FRACTION_BIT = "indirectFraction";
+export const indirectFractionFeature = {
+    id: "prd03.indirectFraction",
+    owner: "prd03",
+    // The registry filters entries by `flags.on(flag)`, so the entry flag is the
+    // lane flag; `A3D_QR_POST_AO` applies §15 sub-flag semantics in `select`:
+    // default-on under `A3D_QR_POST`, explicit `A3D_QR_POST_AO=0` opts out.
+    flag: "A3D_QR_POST",
+    chunks: ["a3d_prd03_indirectFractionPars", "a3d_prd03_indirectFractionWrite"],
+    hooks: ["fragment:pars", "fragment:end"],
+    select(input) {
+        // Only forward HDR draws write f_ind; depth/distance/velocity variants
+        // never produce a color0.a worth reading.
+        if (input.pass !== "forward")
+            return undefined;
+        const explicit = input.flags.values.A3D_QR_POST_AO;
+        if (explicit !== undefined && !input.flags.on("A3D_QR_POST_AO"))
+            return undefined;
+        return INDIRECT_FRACTION_BIT;
+    },
+    defines() {
+        return { A3D_INDIRECT_FRACTION: true };
+    }
+};
+export function registerIndirectFractionShader(registerChunk, registerFeature) {
+    registerChunk(indirectFractionParsChunk);
+    registerChunk(indirectFractionWriteChunk);
+    return registerFeature(indirectFractionFeature);
+}
+//# sourceMappingURL=indirectFraction.glsl.js.map

package/dist/post/chunks/indirectFraction.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indirectFraction.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/chunks/indirectFraction.glsl.ts"],"names":[],"mappings":"AAwBA,yEAAyE;AACzE,MAAM,CAAC,MAAM,yBAAyB,GAAgB;IACpD,IAAI,EAAE,gCAAgC;IACtC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI,EAAE;;;;;;;CAOP;IACC,IAAI,EAAE;;;;;;;CAOP;CACA,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAgB;IACrD,IAAI,EAAE,iCAAiC;IACvC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,gCAAgC,CAAC;IAC5C,IAAI,EAAE;;OAED;IACL,IAAI,EAAE,iHAAiH;CACxH,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAExD,MAAM,CAAC,MAAM,uBAAuB,GAAkB;IACpD,EAAE,EAAE,wBAAwB;IAC5B,KAAK,EAAE,OAAO;IACd,6EAA6E;IAC7E,0EAA0E;IAC1E,wEAAwE;IACxE,IAAI,EAAE,aAAa;IACnB,MAAM,EAAE,CAAC,gCAAgC,EAAE,iCAAiC,CAAC;IAC7E,KAAK,EAAE,CAAC,eAAe,EAAE,cAAc,CAAC;IACxC,MAAM,CAAC,KAAK;QACV,uEAAuE;QACvE,0CAA0C;QAC1C,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC;QACnD,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC;YAAE,OAAO,SAAS,CAAC;QAClF,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IACD,OAAO;QACL,OAAO,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC;IACzC,CAAC;CACF,CAAC;AAEF,MAAM,UAAU,8BAA8B,CAC5C,aAAuC,EACvC,eAAiD;IAEjD,aAAa,CAAC,yBAAyB,CAAC,CAAC;IACzC,aAAa,CAAC,0BAA0B,CAAC,CAAC;IAC1C,OAAO,eAAe,CAAC,uBAAuB,CAAC,CAAC;AAClD,CAAC"}

package/dist/post/chunks/velocity.glsl.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `prd03.velocity` — C-14 velocity MRT chunk (PRD-03 §8.6, Phase 4).
+ *
+ * Emits per-object motion vectors for TAA/motion blur from inside the real
+ * forward draw instead of TemporalHistory's separate re-render pass:
+ *
+ *   `vertex:pars`    — u_previousModel / u_previousViewProjection /
+ *                      u_unjitteredViewProjection (bound by the C-14
+ *                      `velocityMrtBinder`) + clip varyings.
+ *   `vertex:end`     — writes both clip positions from the object-space
+ *                      position: current via u_unjitteredViewProjection,
+ *                      previous via u_previousViewProjection · u_previousModel.
+ *   `fragment:pars`  — AURA_VELOCITY outputs: `layout(location = 1) out vec4`
+ *                      (velocity, rg16f on the wire) and `layout(location = 2)
+ *                      out float` (reactive mask, r8) per VELOCITY_MRT.
+ *   `fragment:end`   — `v = (ndcCurr − ndcPrev) · 0.5`, the same units and
+ *                      sign convention as the S1-C camera-velocity pass.
+ *
+ * Selection is gated on `A3D_QR_POST_VELOCITY_MRT` (default-off sub-flag):
+ * the chunk only emits meaningfully when the forward target actually carries
+ * the location-1/2 attachments — Q-01-2 (lane 01 MRT) is still pending, so
+ * the feature is registered and ChunkHarness-compiled but never selected by
+ * default. Skinned and morph items remain covered: skinned pose/morph weight
+ * varyings are applied by the vertex deform stages before this hook reads
+ * the position.
+ */
+import type { ShaderChunk, ShaderFeature } from "../../contracts/program.js";
+export declare const velocityParsVertexChunk: ShaderChunk;
+export declare const velocityWriteVertexChunk: ShaderChunk;
+export declare const velocityParsFragmentChunk: ShaderChunk;
+export declare const velocityWriteFragmentChunk: ShaderChunk;
+export declare const VELOCITY_BIT = "velocity";
+export declare const velocityFeature: ShaderFeature;
+export declare function registerVelocityShader(registerChunk: (c: ShaderChunk) => void, registerFeature: (f: ShaderFeature) => () => void): () => void;
+//# sourceMappingURL=velocity.glsl.d.ts.map

package/dist/post/chunks/velocity.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/chunks/velocity.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG1E,eAAO,MAAM,uBAAuB,EAAE,WAerC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,WAStC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,WAcvC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,WAUxC,CAAC;AAEF,eAAO,MAAM,YAAY,aAAa,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,aAqB7B,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,IAAI,EACvC,eAAe,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,MAAM,IAAI,GAChD,MAAM,IAAI,CAMZ"}

package/dist/post/chunks/velocity.glsl.js

@@ -0,0 +1,86 @@
+import { VELOCITY_MRT } from "../../contracts/velocity.js";
+export const velocityParsVertexChunk = {
+    name: "a3d_prd03_velocityParsVertex",
+    owner: "prd03",
+    stage: "vertex",
+    glsl: `// AURA_VELOCITY — C-14 velocity MRT (PRD-03 §8.6)
+uniform mat4 u_model;
+uniform mat4 u_previousModel;
+uniform mat4 u_previousViewProjection;
+uniform mat4 u_unjitteredViewProjection;
+out vec4 a3d_velPrevClip;
+out vec4 a3d_velCurrClip;
+`,
+    wgsl: `// WGSL mirror lands in Phase 7 (§7 parity pass).
+struct A3dVelOut { @location(10) prevClip: vec4<f32>, @location(11) currClip: vec4<f32> };
+`
+};
+export const velocityWriteVertexChunk = {
+    name: "a3d_prd03_velocityWriteVertex",
+    owner: "prd03",
+    stage: "vertex",
+    requires: ["a3d_prd03_velocityParsVertex"],
+    glsl: `vec4 a3dWorldPos = u_model * vec4(a_position, 1.0);
+a3d_velCurrClip = u_unjitteredViewProjection * a3dWorldPos;
+a3d_velPrevClip = u_previousViewProjection * (u_previousModel * vec4(a_position, 1.0));`,
+    wgsl: `// see vertex pars`
+};
+export const velocityParsFragmentChunk = {
+    name: "a3d_prd03_velocityParsFragment",
+    owner: "prd03",
+    stage: "fragment",
+    glsl: `// AURA_VELOCITY outputs (VELOCITY_MRT contract): velocity location 1
+// (rg16f wire format — emitted as vec4, .rg carry the delta), reactive
+// location 2 (r8).
+layout(location = 1) out vec4 a3d_o_velocity;
+layout(location = 2) out float a3d_o_reactive;
+in vec4 a3d_velPrevClip;
+in vec4 a3d_velCurrClip;
+uniform float a3d_u_reactive;
+`,
+    wgsl: `// WGSL mirror lands in Phase 7.`
+};
+export const velocityWriteFragmentChunk = {
+    name: "a3d_prd03_velocityWriteFragment",
+    owner: "prd03",
+    stage: "fragment",
+    requires: ["a3d_prd03_velocityParsFragment"],
+    glsl: `vec3 a3dNdcCurr = a3d_velCurrClip.xyz / max(a3d_velCurrClip.w, 1e-5);
+vec3 a3dNdcPrev = a3d_velPrevClip.xyz / max(a3d_velPrevClip.w, 1e-5);
+a3d_o_velocity = vec4(clamp((a3dNdcCurr.xy - a3dNdcPrev.xy) * 0.5, vec2(-0.25), vec2(0.25)), 0.0, 1.0);
+a3d_o_reactive = a3d_u_reactive;`,
+    wgsl: `// see fragment pars`
+};
+export const VELOCITY_BIT = "velocity";
+export const velocityFeature = {
+    id: "prd03.velocity",
+    owner: "prd03",
+    flag: "A3D_QR_POST",
+    chunks: [
+        "a3d_prd03_velocityParsVertex",
+        "a3d_prd03_velocityWriteVertex",
+        "a3d_prd03_velocityParsFragment",
+        "a3d_prd03_velocityWriteFragment"
+    ],
+    hooks: ["vertex:pars", "vertex:end", "fragment:pars", "fragment:end"],
+    select(input) {
+        // Opt-in until Q-01-2 lands the location-1/2 attachments: nothing selects
+        // the feature unless A3D_QR_POST_VELOCITY_MRT is explicitly on.
+        if (input.pass !== "forward")
+            return undefined;
+        if (!input.flags.on("A3D_QR_POST_VELOCITY_MRT"))
+            return undefined;
+        return VELOCITY_BIT;
+    },
+    defines() {
+        return { [VELOCITY_MRT.define]: true };
+    }
+};
+export function registerVelocityShader(registerChunk, registerFeature) {
+    registerChunk(velocityParsVertexChunk);
+    registerChunk(velocityWriteVertexChunk);
+    registerChunk(velocityParsFragmentChunk);
+    registerChunk(velocityWriteFragmentChunk);
+    return registerFeature(velocityFeature);
+}
+//# sourceMappingURL=velocity.glsl.js.map

package/dist/post/chunks/velocity.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/chunks/velocity.glsl.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,MAAM,CAAC,MAAM,uBAAuB,GAAgB;IAClD,IAAI,EAAE,8BAA8B;IACpC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE;;;;;;;CAOP;IACC,IAAI,EAAE;;CAEP;CACA,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAgB;IACnD,IAAI,EAAE,+BAA+B;IACrC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,CAAC,8BAA8B,CAAC;IAC1C,IAAI,EAAE;;wFAEgF;IACtF,IAAI,EAAE,oBAAoB;CAC3B,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAgB;IACpD,IAAI,EAAE,gCAAgC;IACtC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI,EAAE;;;;;;;;CAQP;IACC,IAAI,EAAE,kCAAkC;CACzC,CAAC;AAEF,MAAM,CAAC,MAAM,0BAA0B,GAAgB;IACrD,IAAI,EAAE,iCAAiC;IACvC,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,QAAQ,EAAE,CAAC,gCAAgC,CAAC;IAC5C,IAAI,EAAE;;;iCAGyB;IAC/B,IAAI,EAAE,sBAAsB;CAC7B,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;AAEvC,MAAM,CAAC,MAAM,eAAe,GAAkB;IAC5C,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,aAAa;IACnB,MAAM,EAAE;QACN,8BAA8B;QAC9B,+BAA+B;QAC/B,gCAAgC;QAChC,iCAAiC;KAClC;IACD,KAAK,EAAE,CAAC,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,CAAC;IACrE,MAAM,CAAC,KAAK;QACV,0EAA0E;QAC1E,gEAAgE;QAChE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC/C,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,0BAA0B,CAAC;YAAE,OAAO,SAAS,CAAC;QAClE,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,OAAO;QACL,OAAO,EAAE,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC;IACzC,CAAC;CACF,CAAC;AAEF,MAAM,UAAU,sBAAsB,CACpC,aAAuC,EACvC,eAAiD;IAEjD,aAAa,CAAC,uBAAuB,CAAC,CAAC;IACvC,aAAa,CAAC,wBAAwB,CAAC,CAAC;IACxC,aAAa,CAAC,yBAAyB,CAAC,CAAC;IACzC,aAAa,CAAC,0BAA0B,CAAC,CAAC;IAC1C,OAAO,eAAe,CAAC,eAAe,CAAC,CAAC;AAC1C,CAAC"}

package/dist/post/shaders/bloom.glsl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * PRD-03 §6.6 / §8.10 — v2 bloom shaders (linear HDR, additive pyramid).
+ *
+ * Three programs:
+ * - `BLOOM_PREFILTER_GLSL`: Karis-averaged 13-tap (five overlapping 2x2 boxes,
+ *   centre box 0.5, corners 0.125 each, each box Karis-weighted 1/(1+luma)),
+ *   firefly clamp, soft-knee threshold weight, tint. Output is half-res.
+ * - `BLOOM_DOWNSAMPLE_GLSL`: the same 13-tap pattern without Karis for
+ *   N-1 further mips.
+ * - `BLOOM_UPSAMPLE_GLSL`: progressive 9-tap tent with `radiusTexels =
+ *   scatter`, accumulated as `up_i = down_i + tent(up_{i+1})`.
+ *
+ * The composite applies `u_bloomNorm = bloomNormalization(N, scatter)` — the
+ * analytic factor in `postprocess/NativeBloomPyramid.ts` — so a constant
+ * above-threshold input of excess E produces bloom = E. There is no other
+ * gain (§6.6).
+ */
+export declare const BLOOM_PREFILTER_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_hdr;\nuniform vec2 u_texelSize;\nuniform float u_threshold;\nuniform float u_knee;          // kneeRatio * threshold\nuniform vec3 u_tint;\nuniform float u_clampLuminance;\nin vec2 v_uv;\nout vec4 outColor;\n\nfloat luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }\n\n// One 2x2 box sample averaged at bilinear footprint centre.\nvec3 box4(vec2 uv, vec2 halfTexel) {\n  vec3 s = texture(u_hdr, uv + vec2(-halfTexel.x, -halfTexel.y)).rgb;\n  s += texture(u_hdr, uv + vec2(halfTexel.x, -halfTexel.y)).rgb;\n  s += texture(u_hdr, uv + vec2(-halfTexel.x, halfTexel.y)).rgb;\n  s += texture(u_hdr, uv + vec2(halfTexel.x, halfTexel.y)).rgb;\n  return s * 0.25;\n}\n\nvoid main() {\n  // Jimenez 2014 13-tap as five overlapping boxes; Karis weight per box.\n  vec2 halfTexel = u_texelSize * 0.5;\n  vec3 centre = box4(v_uv, halfTexel);\n  vec3 c = centre * (0.5 / (1.0 + luma(centre)));\n  vec2 corner = u_texelSize + halfTexel;\n  vec3 b;\n  b = box4(v_uv + vec2(-corner.x, -corner.y) * 0.5, halfTexel);\n  c += b * (0.125 / (1.0 + luma(b)));\n  b = box4(v_uv + vec2(corner.x, -corner.y) * 0.5, halfTexel);\n  c += b * (0.125 / (1.0 + luma(b)));\n  b = box4(v_uv + vec2(-corner.x, corner.y) * 0.5, halfTexel);\n  c += b * (0.125 / (1.0 + luma(b)));\n  b = box4(v_uv + vec2(corner.x, corner.y) * 0.5, halfTexel);\n  c += b * (0.125 / (1.0 + luma(b)));\n\n  c = min(c, vec3(u_clampLuminance));           // firefly clamp\n  float br = max(c.r, max(c.g, c.b));           // max channel (Unity/UE)\n  float knee = u_threshold * u_knee;\n  float soft = clamp(br - u_threshold + knee, 0.0, 2.0 * knee);\n  soft = soft * soft / (4.0 * knee + 1e-5);\n  float w = max(soft, br - u_threshold) / max(br, 1e-5);\n  outColor = vec4(c * w * u_tint, 1.0);\n}\n";
+export declare const BLOOM_DOWNSAMPLE_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_src;\nuniform vec2 u_texelSize;\nin vec2 v_uv;\nout vec4 outColor;\n\nvec3 box4(vec2 uv, vec2 halfTexel) {\n  vec3 s = texture(u_src, uv + vec2(-halfTexel.x, -halfTexel.y)).rgb;\n  s += texture(u_src, uv + vec2(halfTexel.x, -halfTexel.y)).rgb;\n  s += texture(u_src, uv + vec2(-halfTexel.x, halfTexel.y)).rgb;\n  s += texture(u_src, uv + vec2(halfTexel.x, halfTexel.y)).rgb;\n  return s * 0.25;\n}\n\nvoid main() {\n  vec2 halfTexel = u_texelSize * 0.5;\n  vec3 c = box4(v_uv, halfTexel) * 0.5;\n  vec2 corner = u_texelSize + halfTexel;\n  c += box4(v_uv + vec2(-corner.x, -corner.y) * 0.5, halfTexel) * 0.125;\n  c += box4(v_uv + vec2(corner.x, -corner.y) * 0.5, halfTexel) * 0.125;\n  c += box4(v_uv + vec2(-corner.x, corner.y) * 0.5, halfTexel) * 0.125;\n  c += box4(v_uv + vec2(corner.x, corner.y) * 0.5, halfTexel) * 0.125;\n  outColor = vec4(c, 1.0);\n}\n";
+export declare const BLOOM_UPSAMPLE_GLSL = "#version 300 es\nprecision highp float;\nuniform sampler2D u_lower;      // up_{i+1}\nuniform sampler2D u_current;    // down_i\nuniform vec2 u_lowerTexel;\nuniform float u_scatter;        // radiusTexels\nin vec2 v_uv;\nout vec4 outColor;\n\n// 9-tap tent (3x3 tent kernel, weights 1-2-1 separable).\nvec3 tent9(sampler2D tex, vec2 uv, vec2 radiusTexels) {\n  vec2 r = radiusTexels;\n  vec3 s = texture(tex, uv + vec2(-r.x, -r.y)).rgb * 1.0;\n  s += texture(tex, uv + vec2(0.0, -r.y)).rgb * 2.0;\n  s += texture(tex, uv + vec2(r.x, -r.y)).rgb * 1.0;\n  s += texture(tex, uv + vec2(-r.x, 0.0)).rgb * 2.0;\n  s += texture(tex, uv).rgb * 4.0;\n  s += texture(tex, uv + vec2(r.x, 0.0)).rgb * 2.0;\n  s += texture(tex, uv + vec2(-r.x, r.y)).rgb * 1.0;\n  s += texture(tex, uv + vec2(0.0, r.y)).rgb * 2.0;\n  s += texture(tex, uv + vec2(r.x, r.y)).rgb * 1.0;\n  return s / 16.0;\n}\n\nvoid main() {\n  // up_i = down_i + tent(up_{i+1})\n  outColor = vec4(texture(u_current, v_uv).rgb + tent9(u_lower, v_uv, u_lowerTexel * u_scatter), 1.0);\n}\n";
+//# sourceMappingURL=bloom.glsl.d.ts.map

package/dist/post/shaders/bloom.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/bloom.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,oBAAoB,0xDA8ChC,CAAC;AAEF,eAAO,MAAM,qBAAqB,+5BAyBjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,ohCA4B/B,CAAC"}

package/dist/post/shaders/bloom.glsl.js

@@ -0,0 +1,120 @@
+/**
+ * PRD-03 §6.6 / §8.10 — v2 bloom shaders (linear HDR, additive pyramid).
+ *
+ * Three programs:
+ * - `BLOOM_PREFILTER_GLSL`: Karis-averaged 13-tap (five overlapping 2x2 boxes,
+ *   centre box 0.5, corners 0.125 each, each box Karis-weighted 1/(1+luma)),
+ *   firefly clamp, soft-knee threshold weight, tint. Output is half-res.
+ * - `BLOOM_DOWNSAMPLE_GLSL`: the same 13-tap pattern without Karis for
+ *   N-1 further mips.
+ * - `BLOOM_UPSAMPLE_GLSL`: progressive 9-tap tent with `radiusTexels =
+ *   scatter`, accumulated as `up_i = down_i + tent(up_{i+1})`.
+ *
+ * The composite applies `u_bloomNorm = bloomNormalization(N, scatter)` — the
+ * analytic factor in `postprocess/NativeBloomPyramid.ts` — so a constant
+ * above-threshold input of excess E produces bloom = E. There is no other
+ * gain (§6.6).
+ */
+export const BLOOM_PREFILTER_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_hdr;
+uniform vec2 u_texelSize;
+uniform float u_threshold;
+uniform float u_knee;          // kneeRatio * threshold
+uniform vec3 u_tint;
+uniform float u_clampLuminance;
+in vec2 v_uv;
+out vec4 outColor;
+
+float luma(vec3 c) { return dot(c, vec3(0.2126, 0.7152, 0.0722)); }
+
+// One 2x2 box sample averaged at bilinear footprint centre.
+vec3 box4(vec2 uv, vec2 halfTexel) {
+  vec3 s = texture(u_hdr, uv + vec2(-halfTexel.x, -halfTexel.y)).rgb;
+  s += texture(u_hdr, uv + vec2(halfTexel.x, -halfTexel.y)).rgb;
+  s += texture(u_hdr, uv + vec2(-halfTexel.x, halfTexel.y)).rgb;
+  s += texture(u_hdr, uv + vec2(halfTexel.x, halfTexel.y)).rgb;
+  return s * 0.25;
+}
+
+void main() {
+  // Jimenez 2014 13-tap as five overlapping boxes; Karis weight per box.
+  vec2 halfTexel = u_texelSize * 0.5;
+  vec3 centre = box4(v_uv, halfTexel);
+  vec3 c = centre * (0.5 / (1.0 + luma(centre)));
+  vec2 corner = u_texelSize + halfTexel;
+  vec3 b;
+  b = box4(v_uv + vec2(-corner.x, -corner.y) * 0.5, halfTexel);
+  c += b * (0.125 / (1.0 + luma(b)));
+  b = box4(v_uv + vec2(corner.x, -corner.y) * 0.5, halfTexel);
+  c += b * (0.125 / (1.0 + luma(b)));
+  b = box4(v_uv + vec2(-corner.x, corner.y) * 0.5, halfTexel);
+  c += b * (0.125 / (1.0 + luma(b)));
+  b = box4(v_uv + vec2(corner.x, corner.y) * 0.5, halfTexel);
+  c += b * (0.125 / (1.0 + luma(b)));
+
+  c = min(c, vec3(u_clampLuminance));           // firefly clamp
+  float br = max(c.r, max(c.g, c.b));           // max channel (Unity/UE)
+  float knee = u_threshold * u_knee;
+  float soft = clamp(br - u_threshold + knee, 0.0, 2.0 * knee);
+  soft = soft * soft / (4.0 * knee + 1e-5);
+  float w = max(soft, br - u_threshold) / max(br, 1e-5);
+  outColor = vec4(c * w * u_tint, 1.0);
+}
+`;
+export const BLOOM_DOWNSAMPLE_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_src;
+uniform vec2 u_texelSize;
+in vec2 v_uv;
+out vec4 outColor;
+
+vec3 box4(vec2 uv, vec2 halfTexel) {
+  vec3 s = texture(u_src, uv + vec2(-halfTexel.x, -halfTexel.y)).rgb;
+  s += texture(u_src, uv + vec2(halfTexel.x, -halfTexel.y)).rgb;
+  s += texture(u_src, uv + vec2(-halfTexel.x, halfTexel.y)).rgb;
+  s += texture(u_src, uv + vec2(halfTexel.x, halfTexel.y)).rgb;
+  return s * 0.25;
+}
+
+void main() {
+  vec2 halfTexel = u_texelSize * 0.5;
+  vec3 c = box4(v_uv, halfTexel) * 0.5;
+  vec2 corner = u_texelSize + halfTexel;
+  c += box4(v_uv + vec2(-corner.x, -corner.y) * 0.5, halfTexel) * 0.125;
+  c += box4(v_uv + vec2(corner.x, -corner.y) * 0.5, halfTexel) * 0.125;
+  c += box4(v_uv + vec2(-corner.x, corner.y) * 0.5, halfTexel) * 0.125;
+  c += box4(v_uv + vec2(corner.x, corner.y) * 0.5, halfTexel) * 0.125;
+  outColor = vec4(c, 1.0);
+}
+`;
+export const BLOOM_UPSAMPLE_GLSL = /* glsl */ `#version 300 es
+precision highp float;
+uniform sampler2D u_lower;      // up_{i+1}
+uniform sampler2D u_current;    // down_i
+uniform vec2 u_lowerTexel;
+uniform float u_scatter;        // radiusTexels
+in vec2 v_uv;
+out vec4 outColor;
+
+// 9-tap tent (3x3 tent kernel, weights 1-2-1 separable).
+vec3 tent9(sampler2D tex, vec2 uv, vec2 radiusTexels) {
+  vec2 r = radiusTexels;
+  vec3 s = texture(tex, uv + vec2(-r.x, -r.y)).rgb * 1.0;
+  s += texture(tex, uv + vec2(0.0, -r.y)).rgb * 2.0;
+  s += texture(tex, uv + vec2(r.x, -r.y)).rgb * 1.0;
+  s += texture(tex, uv + vec2(-r.x, 0.0)).rgb * 2.0;
+  s += texture(tex, uv).rgb * 4.0;
+  s += texture(tex, uv + vec2(r.x, 0.0)).rgb * 2.0;
+  s += texture(tex, uv + vec2(-r.x, r.y)).rgb * 1.0;
+  s += texture(tex, uv + vec2(0.0, r.y)).rgb * 2.0;
+  s += texture(tex, uv + vec2(r.x, r.y)).rgb * 1.0;
+  return s / 16.0;
+}
+
+void main() {
+  // up_i = down_i + tent(up_{i+1})
+  outColor = vec4(texture(u_current, v_uv).rgb + tent9(u_lower, v_uv, u_lowerTexel * u_scatter), 1.0);
+}
+`;
+//# sourceMappingURL=bloom.glsl.js.map

package/dist/post/shaders/bloom.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/bloom.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8C9C,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/C,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B7C,CAAC"}

package/dist/post/shaders/bloom.wgsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PRD-03 §6.6 / §8.10 Phase 7 — v2 bloom WGSL twins (linear HDR, additive
+ * pyramid): Karis-averaged 13-tap prefilter with soft-knee threshold,
+ * 13-tap downsample, progressive 9-tap tent upsample. Same math as the
+ * GLSL twins; §6.6 `bloomNormalization` stays in the composite.
+ */
+export declare const BLOOM_PREFILTER_WGSL = "struct BloomPrefilterParams {\n  texel_size: vec2<f32>,\n  threshold: f32,\n  knee: f32,               // kneeRatio * threshold\n  tint: vec3<f32>,\n  clamp_luminance: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: BloomPrefilterParams;\n@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_hdr_smp: sampler;\n\n\nfn bloom_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }\n\n\n// One 2x2 box sample averaged at bilinear footprint centre.\nfn bloom_box4(uv: vec2<f32>, half_texel: vec2<f32>) -> vec3<f32> {\n  var s = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(-half_texel.x, -half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(half_texel.x, -half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(-half_texel.x, half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(half_texel.x, half_texel.y), 0.0).rgb;\n  return s * 0.25;\n}\n\n@fragment\nfn fs_bloom_prefilter(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // Jimenez 2014 13-tap as five overlapping boxes; Karis weight per box.\n  let half_texel = u_params.texel_size * 0.5;\n  let centre = bloom_box4(uv, half_texel);\n  var c = centre * (0.5 / (1.0 + bloom_luma(centre)));\n  let corner = u_params.texel_size + half_texel;\n  var b = bloom_box4(uv + vec2<f32>(-corner.x, -corner.y) * 0.5, half_texel);\n  c = c + b * (0.125 / (1.0 + bloom_luma(b)));\n  b = bloom_box4(uv + vec2<f32>(corner.x, -corner.y) * 0.5, half_texel);\n  c = c + b * (0.125 / (1.0 + bloom_luma(b)));\n  b = bloom_box4(uv + vec2<f32>(-corner.x, corner.y) * 0.5, half_texel);\n  c = c + b * (0.125 / (1.0 + bloom_luma(b)));\n  b = bloom_box4(uv + vec2<f32>(corner.x, corner.y) * 0.5, half_texel);\n  c = c + b * (0.125 / (1.0 + bloom_luma(b)));\n\n  c = min(c, vec3<f32>(u_params.clamp_luminance));           // firefly clamp\n  let br = max(c.r, max(c.g, c.b));                           // max channel (Unity/UE)\n  let knee = u_params.threshold * u_params.knee;\n  var soft = clamp(br - u_params.threshold + knee, 0.0, 2.0 * knee);\n  soft = soft * soft / (4.0 * knee + 1e-5);\n  let w = max(soft, br - u_params.threshold) / max(br, 1e-5);\n  return vec4<f32>(c * w * u_params.tint, 1.0);\n}\n";
+export declare const BLOOM_DOWNSAMPLE_WGSL = "struct BloomDownsampleParams {\n  texel_size: vec2<f32>,\n  _pad: vec2<f32>,\n};\n\n@group(0) @binding(0) var<uniform> u_params: BloomDownsampleParams;\n@group(0) @binding(1) var u_src_tex: texture_2d<f32>;\n@group(0) @binding(2) var u_src_smp: sampler;\n\nfn bloom_box4(uv: vec2<f32>, half_texel: vec2<f32>) -> vec3<f32> {\n  var s = textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(-half_texel.x, -half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(half_texel.x, -half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(-half_texel.x, half_texel.y), 0.0).rgb;\n  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(half_texel.x, half_texel.y), 0.0).rgb;\n  return s * 0.25;\n}\n\n@fragment\nfn fs_bloom_downsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  let half_texel = u_params.texel_size * 0.5;\n  var c = bloom_box4(uv, half_texel) * 0.5;\n  let corner = u_params.texel_size + half_texel;\n  c = c + bloom_box4(uv + vec2<f32>(-corner.x, -corner.y) * 0.5, half_texel) * 0.125;\n  c = c + bloom_box4(uv + vec2<f32>(corner.x, -corner.y) * 0.5, half_texel) * 0.125;\n  c = c + bloom_box4(uv + vec2<f32>(-corner.x, corner.y) * 0.5, half_texel) * 0.125;\n  c = c + bloom_box4(uv + vec2<f32>(corner.x, corner.y) * 0.5, half_texel) * 0.125;\n  return vec4<f32>(c, 1.0);\n}\n";
+export declare const BLOOM_UPSAMPLE_WGSL = "struct BloomUpsampleParams {\n  lower_texel: vec2<f32>,\n  scatter: f32,            // radiusTexels\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> u_params: BloomUpsampleParams;\n@group(0) @binding(1) var u_lower_tex: texture_2d<f32>;   // up_{i+1}\n@group(0) @binding(2) var u_lower_smp: sampler;\n@group(0) @binding(3) var u_current_tex: texture_2d<f32>; // down_i\n@group(0) @binding(4) var u_current_smp: sampler;\n\n// 9-tap tent (3x3 tent kernel, weights 1-2-1 separable).\nfn tent9(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>, radius_texels: vec2<f32>) -> vec3<f32> {\n  let r = radius_texels;\n  var s = textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, -r.y), 0.0).rgb * 1.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, -r.y), 0.0).rgb * 2.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, -r.y), 0.0).rgb * 1.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, 0.0), 0.0).rgb * 2.0;\n  s = s + textureSampleLevel(tex, smp, uv, 0.0).rgb * 4.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, 0.0), 0.0).rgb * 2.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, r.y), 0.0).rgb * 1.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, r.y), 0.0).rgb * 2.0;\n  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, r.y), 0.0).rgb * 1.0;\n  return s / 16.0;\n}\n\n@fragment\nfn fs_bloom_upsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n  // up_i = down_i + tent(up_{i+1})\n  return vec4<f32>(textureSampleLevel(u_current_tex, u_current_smp, uv, 0.0).rgb\n    + tent9(u_lower_tex, u_lower_smp, uv, u_params.lower_texel * u_params.scatter), 1.0);\n}\n";
+//# sourceMappingURL=bloom.wgsl.d.ts.map

package/dist/post/shaders/bloom.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/bloom.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,oBAAoB,oyEA+ChC,CAAC;AAEF,eAAO,MAAM,qBAAqB,g3CA4BjC,CAAC;AAEF,eAAO,MAAM,mBAAmB,uoDAiC/B,CAAC"}

package/dist/post/shaders/bloom.wgsl.js

@@ -0,0 +1,121 @@
+/**
+ * PRD-03 §6.6 / §8.10 Phase 7 — v2 bloom WGSL twins (linear HDR, additive
+ * pyramid): Karis-averaged 13-tap prefilter with soft-knee threshold,
+ * 13-tap downsample, progressive 9-tap tent upsample. Same math as the
+ * GLSL twins; §6.6 `bloomNormalization` stays in the composite.
+ */
+const BLOOM_FNS = /* wgsl */ `
+fn bloom_luma(c: vec3<f32>) -> f32 { return dot(c, vec3<f32>(0.2126, 0.7152, 0.0722)); }
+`;
+export const BLOOM_PREFILTER_WGSL = /* wgsl */ `struct BloomPrefilterParams {
+  texel_size: vec2<f32>,
+  threshold: f32,
+  knee: f32,               // kneeRatio * threshold
+  tint: vec3<f32>,
+  clamp_luminance: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: BloomPrefilterParams;
+@group(0) @binding(1) var u_hdr_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_hdr_smp: sampler;
+
+${BLOOM_FNS}
+
+// One 2x2 box sample averaged at bilinear footprint centre.
+fn bloom_box4(uv: vec2<f32>, half_texel: vec2<f32>) -> vec3<f32> {
+  var s = textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(-half_texel.x, -half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(half_texel.x, -half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(-half_texel.x, half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_hdr_tex, u_hdr_smp, uv + vec2<f32>(half_texel.x, half_texel.y), 0.0).rgb;
+  return s * 0.25;
+}
+
+@fragment
+fn fs_bloom_prefilter(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // Jimenez 2014 13-tap as five overlapping boxes; Karis weight per box.
+  let half_texel = u_params.texel_size * 0.5;
+  let centre = bloom_box4(uv, half_texel);
+  var c = centre * (0.5 / (1.0 + bloom_luma(centre)));
+  let corner = u_params.texel_size + half_texel;
+  var b = bloom_box4(uv + vec2<f32>(-corner.x, -corner.y) * 0.5, half_texel);
+  c = c + b * (0.125 / (1.0 + bloom_luma(b)));
+  b = bloom_box4(uv + vec2<f32>(corner.x, -corner.y) * 0.5, half_texel);
+  c = c + b * (0.125 / (1.0 + bloom_luma(b)));
+  b = bloom_box4(uv + vec2<f32>(-corner.x, corner.y) * 0.5, half_texel);
+  c = c + b * (0.125 / (1.0 + bloom_luma(b)));
+  b = bloom_box4(uv + vec2<f32>(corner.x, corner.y) * 0.5, half_texel);
+  c = c + b * (0.125 / (1.0 + bloom_luma(b)));
+
+  c = min(c, vec3<f32>(u_params.clamp_luminance));           // firefly clamp
+  let br = max(c.r, max(c.g, c.b));                           // max channel (Unity/UE)
+  let knee = u_params.threshold * u_params.knee;
+  var soft = clamp(br - u_params.threshold + knee, 0.0, 2.0 * knee);
+  soft = soft * soft / (4.0 * knee + 1e-5);
+  let w = max(soft, br - u_params.threshold) / max(br, 1e-5);
+  return vec4<f32>(c * w * u_params.tint, 1.0);
+}
+`;
+export const BLOOM_DOWNSAMPLE_WGSL = /* wgsl */ `struct BloomDownsampleParams {
+  texel_size: vec2<f32>,
+  _pad: vec2<f32>,
+};
+
+@group(0) @binding(0) var<uniform> u_params: BloomDownsampleParams;
+@group(0) @binding(1) var u_src_tex: texture_2d<f32>;
+@group(0) @binding(2) var u_src_smp: sampler;
+
+fn bloom_box4(uv: vec2<f32>, half_texel: vec2<f32>) -> vec3<f32> {
+  var s = textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(-half_texel.x, -half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(half_texel.x, -half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(-half_texel.x, half_texel.y), 0.0).rgb;
+  s = s + textureSampleLevel(u_src_tex, u_src_smp, uv + vec2<f32>(half_texel.x, half_texel.y), 0.0).rgb;
+  return s * 0.25;
+}
+
+@fragment
+fn fs_bloom_downsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  let half_texel = u_params.texel_size * 0.5;
+  var c = bloom_box4(uv, half_texel) * 0.5;
+  let corner = u_params.texel_size + half_texel;
+  c = c + bloom_box4(uv + vec2<f32>(-corner.x, -corner.y) * 0.5, half_texel) * 0.125;
+  c = c + bloom_box4(uv + vec2<f32>(corner.x, -corner.y) * 0.5, half_texel) * 0.125;
+  c = c + bloom_box4(uv + vec2<f32>(-corner.x, corner.y) * 0.5, half_texel) * 0.125;
+  c = c + bloom_box4(uv + vec2<f32>(corner.x, corner.y) * 0.5, half_texel) * 0.125;
+  return vec4<f32>(c, 1.0);
+}
+`;
+export const BLOOM_UPSAMPLE_WGSL = /* wgsl */ `struct BloomUpsampleParams {
+  lower_texel: vec2<f32>,
+  scatter: f32,            // radiusTexels
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> u_params: BloomUpsampleParams;
+@group(0) @binding(1) var u_lower_tex: texture_2d<f32>;   // up_{i+1}
+@group(0) @binding(2) var u_lower_smp: sampler;
+@group(0) @binding(3) var u_current_tex: texture_2d<f32>; // down_i
+@group(0) @binding(4) var u_current_smp: sampler;
+
+// 9-tap tent (3x3 tent kernel, weights 1-2-1 separable).
+fn tent9(tex: texture_2d<f32>, smp: sampler, uv: vec2<f32>, radius_texels: vec2<f32>) -> vec3<f32> {
+  let r = radius_texels;
+  var s = textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, -r.y), 0.0).rgb * 1.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, -r.y), 0.0).rgb * 2.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, -r.y), 0.0).rgb * 1.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, 0.0), 0.0).rgb * 2.0;
+  s = s + textureSampleLevel(tex, smp, uv, 0.0).rgb * 4.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, 0.0), 0.0).rgb * 2.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(-r.x, r.y), 0.0).rgb * 1.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(0.0, r.y), 0.0).rgb * 2.0;
+  s = s + textureSampleLevel(tex, smp, uv + vec2<f32>(r.x, r.y), 0.0).rgb * 1.0;
+  return s / 16.0;
+}
+
+@fragment
+fn fs_bloom_upsample(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {
+  // up_i = down_i + tent(up_{i+1})
+  return vec4<f32>(textureSampleLevel(u_current_tex, u_current_smp, uv, 0.0).rgb
+    + tent9(u_lower_tex, u_lower_smp, uv, u_params.lower_texel * u_params.scatter), 1.0);
+}
+`;
+//# sourceMappingURL=bloom.wgsl.js.map

package/dist/post/shaders/bloom.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/bloom.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,SAAS,GAAG,UAAU,CAAC;;CAE5B,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,UAAU,CAAC;;;;;;;;;;;;EAY7C,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCV,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B/C,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC7C,CAAC"}

package/dist/post/shaders/common.glsl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PRD-03 — shared v2/legacy post GLSL chunks.
+ *
+ * `linearizeDepth` is the §6.11 shared formula (view-space metres).
+ * `triangularDither(fragCoord, frame)` is the §1096 dither: a PCG2D integer
+ * hash (replacing `fract(sin(dot(...)))`) produces two uniform samples whose
+ * sum minus 1 gives the triangular distribution, scaled by 1/255 — ±1 LSB of
+ * the 8-bit output, applied at the last write (S12).
+ */
+export declare const POST_COMMON_GLSL = "\nfloat linearizeDepth(float d, float n, float f, bool ortho) {\n  float z = d * 2.0 - 1.0;\n  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));\n}\n\nuvec2 pcg2d(uvec2 v) {\n  v = v * 1664525u + 1013904223u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  v.x += v.y * 1664525u;\n  v.y += v.x * 1664525u;\n  v ^= v >> 16u;\n  return v;\n}\n\n// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 \u2192 \u00B11 LSB of 8-bit output.\nfloat triangularDither(vec2 fragCoord, float frame) {\n  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);\n  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;\n  return (rand.x + rand.y - 1.0) / 255.0;\n}\n";
+//# sourceMappingURL=common.glsl.d.ts.map

package/dist/post/shaders/common.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/common.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,gBAAgB,2rBAuB5B,CAAC"}

package/dist/post/shaders/common.glsl.js

@@ -0,0 +1,34 @@
+/**
+ * PRD-03 — shared v2/legacy post GLSL chunks.
+ *
+ * `linearizeDepth` is the §6.11 shared formula (view-space metres).
+ * `triangularDither(fragCoord, frame)` is the §1096 dither: a PCG2D integer
+ * hash (replacing `fract(sin(dot(...)))`) produces two uniform samples whose
+ * sum minus 1 gives the triangular distribution, scaled by 1/255 — ±1 LSB of
+ * the 8-bit output, applied at the last write (S12).
+ */
+export const POST_COMMON_GLSL = /* glsl */ `
+float linearizeDepth(float d, float n, float f, bool ortho) {
+  float z = d * 2.0 - 1.0;
+  return ortho ? mix(n, f, d) : (2.0 * n * f) / (f + n - z * (f - n));
+}
+
+uvec2 pcg2d(uvec2 v) {
+  v = v * 1664525u + 1013904223u;
+  v.x += v.y * 1664525u;
+  v.y += v.x * 1664525u;
+  v ^= v >> 16u;
+  v.x += v.y * 1664525u;
+  v.y += v.x * 1664525u;
+  v ^= v >> 16u;
+  return v;
+}
+
+// Triangular-PDF dither: (rand0 + rand1 - 1) / 255 → ±1 LSB of 8-bit output.
+float triangularDither(vec2 fragCoord, float frame) {
+  uvec2 seed = uvec2(fragCoord) + uvec2(uint(frame) * 747796405u);
+  vec2 rand = vec2(pcg2d(seed)) / 4294967296.0;
+  return (rand.x + rand.y - 1.0) / 255.0;
+}
+`;
+//# sourceMappingURL=common.glsl.js.map

package/dist/post/shaders/common.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/post/shaders/common.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuB1C,CAAC"}