@aura3d/rendering 3.0.1 → 4.0.2

package/dist/atmosphere/fogChunks.js

@@ -0,0 +1,39 @@
+// PRD-07 P4-T4 — C-02 chunks: "a3d_prd07_fog" and "a3d_prd07_wetness".
+// Registered now so programs can `requires` them; the fog uniforms land with
+// P4-T5's FOG_PROGRAM_DEFINES material hook-up.
+import { registerShaderChunk } from "../contracts/program.js";
+export const FOG_CHUNK_NAME = "a3d_prd07_fog";
+export const WETNESS_CHUNK_NAME = "a3d_prd07_wetness";
+/** #880 / T0-05 call chunks (statements only) for the C-02 body hooks. */
+export const FOG_APPLY_CHUNK_NAME = "a3d_prd07_fog_apply";
+export const WETNESS_APPLY_CHUNK_NAME = "a3d_prd07_wetness_apply";
+import { PRD07_FOG_APPLY_CHUNK_GLSL, PRD07_FOG_CHUNK_GLSL } from "./shaders/fog.glsl.js";
+import { PRD07_WETNESS_APPLY_CHUNK_GLSL, PRD07_WETNESS_CHUNK_GLSL } from "./shaders/wetness.glsl.js";
+// §8.4 uniform-block chunk (u_fogA/u_fogB/u_fogColor/u_fogAbsorption/u_fogMode/
+// u_fogNear/u_fogFar/u_fogVolumes + env uniforms u_cameraPosition/u_sunDirection/
+// u_sunColor). Packed by HeightFog.packV2; modes 0-6 incl. legacy-parity 6.
+const FOG_GLSL = PRD07_FOG_CHUNK_GLSL;
+// §6.8 wetness chunk (u_wetness/u_puddleThreshold/u_rainRipples/u_snowCover +
+// u_puddleNoise). Real §6.8 formulas live in shaders/wetness.glsl.ts.
+const WETNESS_GLSL = PRD07_WETNESS_CHUNK_GLSL;
+/** Idempotent chunk registration (P1-T1). */
+export function registerPrd07Chunks() {
+    const chunks = [
+        { name: FOG_CHUNK_NAME, owner: "prd07", stage: "fragment", glsl: FOG_GLSL },
+        { name: WETNESS_CHUNK_NAME, owner: "prd07", stage: "fragment", glsl: WETNESS_GLSL },
+        // Pars/call split (#880): the declaration chunks above go to
+        // `fragment:pars`; these run inside main() and require them.
+        { name: FOG_APPLY_CHUNK_NAME, owner: "prd07", stage: "fragment", glsl: PRD07_FOG_APPLY_CHUNK_GLSL, requires: [FOG_CHUNK_NAME] },
+        { name: WETNESS_APPLY_CHUNK_NAME, owner: "prd07", stage: "fragment", glsl: PRD07_WETNESS_APPLY_CHUNK_GLSL, requires: [WETNESS_CHUNK_NAME] }
+    ];
+    for (const chunk of chunks) {
+        try {
+            registerShaderChunk(chunk);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message.startsWith("SHADER_CHUNK_DUPLICATE")))
+                throw error;
+        }
+    }
+}
+//# sourceMappingURL=fogChunks.js.map

package/dist/atmosphere/fogChunks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fogChunks.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/atmosphere/fogChunks.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,6EAA6E;AAC7E,gDAAgD;AAEhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,CAAC,MAAM,cAAc,GAAG,eAAwB,CAAC;AACvD,MAAM,CAAC,MAAM,kBAAkB,GAAG,mBAA4B,CAAC;AAC/D,0EAA0E;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,qBAA8B,CAAC;AACnE,MAAM,CAAC,MAAM,wBAAwB,GAAG,yBAAkC,CAAC;AAE3E,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAAE,8BAA8B,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAElG,gFAAgF;AAChF,kFAAkF;AAClF,4EAA4E;AAC5E,MAAM,QAAQ,GAAG,oBAAoB,CAAC;AAEtC,8EAA8E;AAC9E,sEAAsE;AACtE,MAAM,YAAY,GAAG,wBAAwB,CAAC;AAE9C,6CAA6C;AAC7C,MAAM,UAAU,mBAAmB;IACjC,MAAM,MAAM,GAAG;QACb,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,OAAgB,EAAE,KAAK,EAAE,UAAmB,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC7F,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAgB,EAAE,KAAK,EAAE,UAAmB,EAAE,IAAI,EAAE,YAAY,EAAE;QACrG,6DAA6D;QAC7D,6DAA6D;QAC7D,EAAE,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAgB,EAAE,KAAK,EAAE,UAAmB,EAAE,IAAI,EAAE,0BAA0B,EAAE,QAAQ,EAAE,CAAC,cAAc,CAAC,EAAE;QACjJ,EAAE,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,OAAgB,EAAE,KAAK,EAAE,UAAmB,EAAE,IAAI,EAAE,8BAA8B,EAAE,QAAQ,EAAE,CAAC,kBAAkB,CAAC,EAAE;KAC9J,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,CAAC;YACH,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAC;gBAAE,MAAM,KAAK,CAAC;QACnG,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/atmosphere/fogUniformStore.d.ts

@@ -0,0 +1,20 @@
+import type { UniformValue } from "../RenderDevice.js";
+import type { PackedFogUniforms, Vec3 } from "./HeightFog.js";
+import { type Prd07FogVolume } from "./FogVolumes.js";
+export interface Prd07ForwardFogState {
+    readonly uniforms: PackedFogUniforms;
+    readonly volumes: readonly Prd07FogVolume[];
+    readonly sunDirection: Vec3;
+    readonly sunColor: Vec3;
+    readonly cameraPosition: Vec3;
+}
+/** Called by the prd07.fog contributor each frame; `null` = no live fog node (IC-0: mode 0). */
+export declare function setPrd07ForwardFog(state: Prd07ForwardFogState | null): void;
+export declare function prd07ForwardFog(): Prd07ForwardFogState | null;
+/**
+ * `prd07.fog` ShaderFeature.bindUniforms body. Always writes `u_fogMode` so a
+ * program that selected the feature never reads a stale mode from a previous
+ * draw's uniform packet; the remaining slots are written only while fog is live.
+ */
+export declare function bindPrd07FogUniforms(set: (name: string, value: UniformValue) => void): void;
+//# sourceMappingURL=fogUniformStore.d.ts.map

package/dist/atmosphere/fogUniformStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fogUniformStore.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/atmosphere/fogUniformStore.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC;CAC/B;AAID,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED,wBAAgB,eAAe,IAAI,oBAAoB,GAAG,IAAI,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI,CAkB3F"}

package/dist/atmosphere/fogUniformStore.js

@@ -0,0 +1,45 @@
+// PRD-07 P4-T4 / #187 / #82 — forward-geometry binding for the C-21 fog chunk.
+//
+// The `prd07.fog` ShaderFeature splices `a3d_prd07_fog` into C-02 generated
+// forward programs (pars at fragment:pars, call at fragment:fog — #880), but a
+// per-draw `bindUniforms` sees no frame blackboard. The prd07.fog contributor
+// therefore publishes the frame's packed §8.4 uniforms here during collect, and
+// the feature's `bindUniforms` reads them per draw (same module-store pattern
+// as wetness). Without this binding every u_fog* uniform stays 0 → mode 0 →
+// forward geometry is never fogged, so `setFog({ mode: "absorption" })` only
+// reached the sky and decals. With it, mode 5 (Beer-Lambert per-channel
+// T = exp(-σ·d)) shades forward geometry on the real C-02 path.
+import { packFogVolumes } from "./FogVolumes.js";
+let forwardFog = null;
+/** Called by the prd07.fog contributor each frame; `null` = no live fog node (IC-0: mode 0). */
+export function setPrd07ForwardFog(state) {
+    forwardFog = state;
+}
+export function prd07ForwardFog() {
+    return forwardFog;
+}
+/**
+ * `prd07.fog` ShaderFeature.bindUniforms body. Always writes `u_fogMode` so a
+ * program that selected the feature never reads a stale mode from a previous
+ * draw's uniform packet; the remaining slots are written only while fog is live.
+ */
+export function bindPrd07FogUniforms(set) {
+    const state = forwardFog;
+    if (!state) {
+        set("u_fogMode", 0);
+        return;
+    }
+    const f = state.uniforms;
+    set("u_fogA", [...f.fogA]);
+    set("u_fogB", [...f.fogB]);
+    set("u_fogColor", [...f.fogColor]);
+    set("u_fogAbsorption", [...f.fogAbsorption]);
+    set("u_fogMode", f.fogMode);
+    set("u_fogNear", f.fogNear);
+    set("u_fogFar", f.fogFar);
+    set("u_fogVolumes", packFogVolumes(state.volumes));
+    set("u_cameraPosition", [...state.cameraPosition]);
+    set("u_sunDirection", [...state.sunDirection]);
+    set("u_sunColor", [...state.sunColor]);
+}
+//# sourceMappingURL=fogUniformStore.js.map

package/dist/atmosphere/fogUniformStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fogUniformStore.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/atmosphere/fogUniformStore.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,8EAA8E;AAC9E,gFAAgF;AAChF,8EAA8E;AAC9E,4EAA4E;AAC5E,6EAA6E;AAC7E,wEAAwE;AACxE,gEAAgE;AAIhE,OAAO,EAAE,cAAc,EAAuB,MAAM,cAAc,CAAC;AAUnE,IAAI,UAAU,GAAgC,IAAI,CAAC;AAEnD,gGAAgG;AAChG,MAAM,UAAU,kBAAkB,CAAC,KAAkC;IACnE,UAAU,GAAG,KAAK,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAgD;IACnF,MAAM,KAAK,GAAG,UAAU,CAAC;IACzB,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QACpB,OAAO;IACT,CAAC;IACD,MAAM,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC;IACzB,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3B,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3B,GAAG,CAAC,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACnC,GAAG,CAAC,iBAAiB,EAAE,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IAC7C,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;IAC5B,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;IAC5B,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAC1B,GAAG,CAAC,cAAc,EAAE,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,GAAG,CAAC,kBAAkB,EAAE,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;IACnD,GAAG,CAAC,gBAAgB,EAAE,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;IAC/C,GAAG,CAAC,YAAY,EAAE,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;AACzC,CAAC"}

package/dist/atmosphere/shaders/fog.glsl.d.ts

@@ -0,0 +1,10 @@
+export declare const PRD07_FOG_CHUNK_GLSL = "\n#ifndef A3D_PRD07_FOG_CHUNK\n#define A3D_PRD07_FOG_CHUNK\n#ifndef A3D_MAX_FOG_VOLUMES\n#define A3D_MAX_FOG_VOLUMES 8\n#endif\nuniform vec4 u_fogA;   // \u03C3_d, \u03C3_h, b, h0 \u2014 mode 6: density, heightFalloff, heightReference, legacyMode\nuniform vec4 u_fogB;   // start, maxOpacity, sunInscatter, anisotropy g \u2014 mode 6: near, far, maxOpacity, 0\n// #880: the C-02 generator's fog_default chunk already declares u_fogColor\n// (same meaning) under FOG_LINEAR / FOG_EXP2 / FOG_HEIGHT and is emitted\n// before feature declarations, so share it instead of redeclaring.\n#if !defined(FOG_LINEAR) && !defined(FOG_EXP2) && !defined(FOG_HEIGHT)\nuniform vec3 u_fogColor;\n#endif\nuniform vec3 u_fogAbsorption; uniform float u_fogMode;  // 0 off,1 height,2 exp,3 exp2,4 linear,5 absorption,6 legacy-parity\nuniform float u_fogNear; uniform float u_fogFar;                               // linear (mode 4) + legacy-parity distances\nuniform vec4 u_fogVolumes[2 * A3D_MAX_FOG_VOLUMES];             // centre.xyz+shape, halfSize.xyz+density\n#ifndef A3D_PRD07_FOG_ENV_UNIFORMS\n#define A3D_PRD07_FOG_ENV_UNIFORMS\nuniform vec3 u_cameraPosition;\nuniform vec3 u_sunDirection;\nuniform vec3 u_sunColor;\n#endif\n\nfloat a3dHeightFogTau(vec3 c, vec3 v, float d) {\n  float dd = max(d - u_fogB.x, 0.0);\n  float tau = u_fogA.x * dd;\n  float k = u_fogA.z * v.y * dd;\n  float line = abs(k) < 1e-4 ? 1.0 : (1.0 - exp(-k)) / k;\n  tau += u_fogA.y * exp(-u_fogA.z * (c.y - u_fogA.w)) * dd * line;\n  return tau;\n}\n\nfloat a3dFogVolumesTau(vec3 c, vec3 v, float d) {\n  float tau = 0.0;\n  for (int i = 0; i < A3D_MAX_FOG_VOLUMES; i++) {\n    vec4 a = u_fogVolumes[i * 2];\n    vec4 b = u_fogVolumes[i * 2 + 1];\n    if (b.w <= 0.0) continue;\n    vec3 lo = a.xyz - b.xyz;\n    vec3 hi = a.xyz + b.xyz;\n    float t0 = 0.0;\n    float t1 = d;\n    bool hit = true;\n    for (int axis = 0; axis < 3; axis++) {\n      float o = c[axis] - a.xyz[axis];\n      float dv = v[axis];\n      float half_ = b.xyz[axis];\n      if (abs(dv) < 1e-9) {\n        if (abs(o) > half_) { hit = false; }\n        continue;\n      }\n      float ta = (-half_ - o) / dv;\n      float tb = (half_ - o) / dv;\n      t0 = max(t0, min(ta, tb));\n      t1 = min(t1, max(ta, tb));\n    }\n    if (a.w > 0.5) {\n      // ellipsoid \u2192 unit-sphere quadratic\n      vec3 os = (c - a.xyz) / max(b.xyz, vec3(1e-9));\n      vec3 vs = v / max(b.xyz, vec3(1e-9));\n      float qa = dot(vs, vs);\n      if (qa < 1e-12) { hit = false; }\n      float qb = dot(os, vs);\n      float qc = dot(os, os) - 1.0;\n      float qd = qb * qb - qa * qc;\n      if (qd < 0.0 || !hit) { hit = false; }\n      else {\n        float qr = sqrt(qd);\n        t0 = max((-qb - qr) / qa, 0.0);\n        t1 = min((-qb + qr) / qa, d);\n      }\n    } else {\n      t0 = max(t0, 0.0);\n      t1 = min(t1, d);\n    }\n    if (hit && t1 > t0) tau += (t1 - t0) * b.w;\n  }\n  return tau;\n}\n\nfloat a3dLegacyFogFactor(vec3 worldPosition) {\n  // u_fogMode == 6.0 \u2014 verbatim a3dEnvironmentFogFactor over the aliased slots.\n  float distanceToCamera = length(u_cameraPosition - worldPosition);\n  float factor = 0.0;\n  float legacyMode = u_fogA.w;\n  if (legacyMode < 1.5) {\n    factor = (distanceToCamera - u_fogB.x) / max(u_fogB.y - u_fogB.x, 0.000001);\n  } else if (legacyMode < 2.5) {\n    factor = 1.0 - exp(-max(u_fogA.x, 0.0) * distanceToCamera);\n  } else {\n    float scaledDensity = max(u_fogA.x, 0.0) * distanceToCamera;\n    factor = 1.0 - exp(-(scaledDensity * scaledDensity));\n  }\n  float heightMultiplier = u_fogA.y > 0.0\n    ? exp(-max(0.0, worldPosition.y - u_fogA.z) * u_fogA.y)\n    : 1.0;\n  return clamp(factor * heightMultiplier, 0.0, 1.0) * clamp(u_fogB.z, 0.0, 1.0);\n}\n\nfloat a3dFogAmount(vec3 worldPos) {\n  if (u_fogMode == 6.0) return a3dLegacyFogFactor(worldPos);\n  vec3 r = worldPos - u_cameraPosition; float d = length(r); vec3 v = r / max(d, 1e-5);\n  float tau = (u_fogMode == 1.0) ? a3dHeightFogTau(u_cameraPosition, v, d)\n            : (u_fogMode == 2.0) ? u_fogA.x * d\n            : (u_fogMode == 3.0) ? (u_fogA.x * d) * (u_fogA.x * d) : 0.0;\n  tau += a3dFogVolumesTau(u_cameraPosition, v, d);\n  float f = (u_fogMode == 4.0) ? clamp((d - u_fogNear) / (u_fogFar - u_fogNear), 0.0, 1.0) : 1.0 - exp(-tau);\n  return min(f, u_fogB.y);\n}\n\nvec3 a3dFogInscatter(vec3 v) {\n  float g = u_fogB.w; float mu = dot(v, u_sunDirection);\n  float hg = (1.0 - g * g) / (12.5663706 * pow(1.0 + g * g - 2.0 * g * mu, 1.5));\n  return u_fogColor + u_sunColor * hg * u_fogB.z;\n}\n\nvec3 a3dApplyFog(vec3 color, vec3 worldPos) {                  // stable entry point (PRD 10)\n  if (u_fogMode == 0.0) return color;\n  vec3 r = worldPos - u_cameraPosition; vec3 v = normalize(r);\n  if (u_fogMode == 5.0) { vec3 T = exp(-u_fogAbsorption * length(r)); return color * T + u_fogColor * (1.0 - T); }\n#if defined(FOG_VOLUMETRIC)\n  // Consumer contract: a FOG_VOLUMETRIC program defines a3dSampleFroxel()\n  // before this chunk. Forward programs never set FOG_VOLUMETRIC; the froxel\n  // volume is composited there by VolumetricFogPass apply (\u00A78.7).\n  vec4 s = a3dSampleFroxel(worldPos);                          // rgb inscatter, a transmittance\n  color = color * s.a + s.rgb;                                 // near part from the volume\n#endif\n  float f = a3dFogAmount(worldPos);\n  // Mode 6 (legacy parity): the legacy formula has no sun inscatter \u2014 u_fogB.z\n  // is maxOpacity, NOT sunInscatter. Blend to the plain fog colour.\n  vec3 fogged = (u_fogMode == 6.0) ? u_fogColor : a3dFogInscatter(v);\n  return mix(color, fogged, f);\n}\n#endif // A3D_PRD07_FOG_CHUNK\n";
+export declare const PRD07_FOG_SHADER_MARKER = "a3d_prd07_fog_v2";
+/**
+ * #880 / T0-05 — `fragment:fog` call chunk (statements only, inside `main()`).
+ * The declarations above are the pars chunk at `fragment:pars`; this replaces
+ * the generator's default fog body (`a3dColor`, `v_worldPosition` are the
+ * C-02 forward fragment's names).
+ */
+export declare const PRD07_FOG_APPLY_CHUNK_GLSL = "\n#ifdef A3D_FOG\n  a3dColor = a3dApplyFog(a3dColor, v_worldPosition);\n#endif\n";
+//# sourceMappingURL=fog.glsl.d.ts.map

package/dist/atmosphere/shaders/fog.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/fog.glsl.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,oBAAoB,+hLAuIhC,CAAC;AAEF,eAAO,MAAM,uBAAuB,qBAAqB,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,qFAItC,CAAC"}

package/dist/atmosphere/shaders/fog.glsl.js

@@ -0,0 +1,161 @@
+// PRD-07 P4-T2 — `a3d_prd07_fog` chunk source (§8.4, C-21 FOG_CHUNK).
+// Uniform-block variant: PRD 07 programs include this chunk and bind the
+// u_fog* uniforms packed by HeightFog.packV2 (rendering side, CPU mirror in
+// HeightFog.ts). Modes: 0 off, 1 height, 2 exp, 3 exp2, 4 linear,
+// 5 absorption, 6 legacy-parity.
+//
+// Mode-6 slot aliasing (parity rule, §6.6): while forward geometry is on the
+// legacy path this chunk evaluates a3dEnvironmentFogFactor verbatim, reading
+// the packLegacy layout written into the same uniforms:
+//   u_fogA = (legacyDensity, heightFalloff, heightReference, legacyMode)
+//   u_fogB = (near, far, maxOpacity, 0)
+// so sky/VFX/geometry never seam.
+export const PRD07_FOG_CHUNK_GLSL = `
+#ifndef A3D_PRD07_FOG_CHUNK
+#define A3D_PRD07_FOG_CHUNK
+#ifndef A3D_MAX_FOG_VOLUMES
+#define A3D_MAX_FOG_VOLUMES 8
+#endif
+uniform vec4 u_fogA;   // σ_d, σ_h, b, h0 — mode 6: density, heightFalloff, heightReference, legacyMode
+uniform vec4 u_fogB;   // start, maxOpacity, sunInscatter, anisotropy g — mode 6: near, far, maxOpacity, 0
+// #880: the C-02 generator's fog_default chunk already declares u_fogColor
+// (same meaning) under FOG_LINEAR / FOG_EXP2 / FOG_HEIGHT and is emitted
+// before feature declarations, so share it instead of redeclaring.
+#if !defined(FOG_LINEAR) && !defined(FOG_EXP2) && !defined(FOG_HEIGHT)
+uniform vec3 u_fogColor;
+#endif
+uniform vec3 u_fogAbsorption; uniform float u_fogMode;  // 0 off,1 height,2 exp,3 exp2,4 linear,5 absorption,6 legacy-parity
+uniform float u_fogNear; uniform float u_fogFar;                               // linear (mode 4) + legacy-parity distances
+uniform vec4 u_fogVolumes[2 * A3D_MAX_FOG_VOLUMES];             // centre.xyz+shape, halfSize.xyz+density
+#ifndef A3D_PRD07_FOG_ENV_UNIFORMS
+#define A3D_PRD07_FOG_ENV_UNIFORMS
+uniform vec3 u_cameraPosition;
+uniform vec3 u_sunDirection;
+uniform vec3 u_sunColor;
+#endif
+
+float a3dHeightFogTau(vec3 c, vec3 v, float d) {
+  float dd = max(d - u_fogB.x, 0.0);
+  float tau = u_fogA.x * dd;
+  float k = u_fogA.z * v.y * dd;
+  float line = abs(k) < 1e-4 ? 1.0 : (1.0 - exp(-k)) / k;
+  tau += u_fogA.y * exp(-u_fogA.z * (c.y - u_fogA.w)) * dd * line;
+  return tau;
+}
+
+float a3dFogVolumesTau(vec3 c, vec3 v, float d) {
+  float tau = 0.0;
+  for (int i = 0; i < A3D_MAX_FOG_VOLUMES; i++) {
+    vec4 a = u_fogVolumes[i * 2];
+    vec4 b = u_fogVolumes[i * 2 + 1];
+    if (b.w <= 0.0) continue;
+    vec3 lo = a.xyz - b.xyz;
+    vec3 hi = a.xyz + b.xyz;
+    float t0 = 0.0;
+    float t1 = d;
+    bool hit = true;
+    for (int axis = 0; axis < 3; axis++) {
+      float o = c[axis] - a.xyz[axis];
+      float dv = v[axis];
+      float half_ = b.xyz[axis];
+      if (abs(dv) < 1e-9) {
+        if (abs(o) > half_) { hit = false; }
+        continue;
+      }
+      float ta = (-half_ - o) / dv;
+      float tb = (half_ - o) / dv;
+      t0 = max(t0, min(ta, tb));
+      t1 = min(t1, max(ta, tb));
+    }
+    if (a.w > 0.5) {
+      // ellipsoid → unit-sphere quadratic
+      vec3 os = (c - a.xyz) / max(b.xyz, vec3(1e-9));
+      vec3 vs = v / max(b.xyz, vec3(1e-9));
+      float qa = dot(vs, vs);
+      if (qa < 1e-12) { hit = false; }
+      float qb = dot(os, vs);
+      float qc = dot(os, os) - 1.0;
+      float qd = qb * qb - qa * qc;
+      if (qd < 0.0 || !hit) { hit = false; }
+      else {
+        float qr = sqrt(qd);
+        t0 = max((-qb - qr) / qa, 0.0);
+        t1 = min((-qb + qr) / qa, d);
+      }
+    } else {
+      t0 = max(t0, 0.0);
+      t1 = min(t1, d);
+    }
+    if (hit && t1 > t0) tau += (t1 - t0) * b.w;
+  }
+  return tau;
+}
+
+float a3dLegacyFogFactor(vec3 worldPosition) {
+  // u_fogMode == 6.0 — verbatim a3dEnvironmentFogFactor over the aliased slots.
+  float distanceToCamera = length(u_cameraPosition - worldPosition);
+  float factor = 0.0;
+  float legacyMode = u_fogA.w;
+  if (legacyMode < 1.5) {
+    factor = (distanceToCamera - u_fogB.x) / max(u_fogB.y - u_fogB.x, 0.000001);
+  } else if (legacyMode < 2.5) {
+    factor = 1.0 - exp(-max(u_fogA.x, 0.0) * distanceToCamera);
+  } else {
+    float scaledDensity = max(u_fogA.x, 0.0) * distanceToCamera;
+    factor = 1.0 - exp(-(scaledDensity * scaledDensity));
+  }
+  float heightMultiplier = u_fogA.y > 0.0
+    ? exp(-max(0.0, worldPosition.y - u_fogA.z) * u_fogA.y)
+    : 1.0;
+  return clamp(factor * heightMultiplier, 0.0, 1.0) * clamp(u_fogB.z, 0.0, 1.0);
+}
+
+float a3dFogAmount(vec3 worldPos) {
+  if (u_fogMode == 6.0) return a3dLegacyFogFactor(worldPos);
+  vec3 r = worldPos - u_cameraPosition; float d = length(r); vec3 v = r / max(d, 1e-5);
+  float tau = (u_fogMode == 1.0) ? a3dHeightFogTau(u_cameraPosition, v, d)
+            : (u_fogMode == 2.0) ? u_fogA.x * d
+            : (u_fogMode == 3.0) ? (u_fogA.x * d) * (u_fogA.x * d) : 0.0;
+  tau += a3dFogVolumesTau(u_cameraPosition, v, d);
+  float f = (u_fogMode == 4.0) ? clamp((d - u_fogNear) / (u_fogFar - u_fogNear), 0.0, 1.0) : 1.0 - exp(-tau);
+  return min(f, u_fogB.y);
+}
+
+vec3 a3dFogInscatter(vec3 v) {
+  float g = u_fogB.w; float mu = dot(v, u_sunDirection);
+  float hg = (1.0 - g * g) / (12.5663706 * pow(1.0 + g * g - 2.0 * g * mu, 1.5));
+  return u_fogColor + u_sunColor * hg * u_fogB.z;
+}
+
+vec3 a3dApplyFog(vec3 color, vec3 worldPos) {                  // stable entry point (PRD 10)
+  if (u_fogMode == 0.0) return color;
+  vec3 r = worldPos - u_cameraPosition; vec3 v = normalize(r);
+  if (u_fogMode == 5.0) { vec3 T = exp(-u_fogAbsorption * length(r)); return color * T + u_fogColor * (1.0 - T); }
+#if defined(FOG_VOLUMETRIC)
+  // Consumer contract: a FOG_VOLUMETRIC program defines a3dSampleFroxel()
+  // before this chunk. Forward programs never set FOG_VOLUMETRIC; the froxel
+  // volume is composited there by VolumetricFogPass apply (§8.7).
+  vec4 s = a3dSampleFroxel(worldPos);                          // rgb inscatter, a transmittance
+  color = color * s.a + s.rgb;                                 // near part from the volume
+#endif
+  float f = a3dFogAmount(worldPos);
+  // Mode 6 (legacy parity): the legacy formula has no sun inscatter — u_fogB.z
+  // is maxOpacity, NOT sunInscatter. Blend to the plain fog colour.
+  vec3 fogged = (u_fogMode == 6.0) ? u_fogColor : a3dFogInscatter(v);
+  return mix(color, fogged, f);
+}
+#endif // A3D_PRD07_FOG_CHUNK
+`;
+export const PRD07_FOG_SHADER_MARKER = "a3d_prd07_fog_v2";
+/**
+ * #880 / T0-05 — `fragment:fog` call chunk (statements only, inside `main()`).
+ * The declarations above are the pars chunk at `fragment:pars`; this replaces
+ * the generator's default fog body (`a3dColor`, `v_worldPosition` are the
+ * C-02 forward fragment's names).
+ */
+export const PRD07_FOG_APPLY_CHUNK_GLSL = `
+#ifdef A3D_FOG
+  a3dColor = a3dApplyFog(a3dColor, v_worldPosition);
+#endif
+`;
+//# sourceMappingURL=fog.glsl.js.map

package/dist/atmosphere/shaders/fog.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/fog.glsl.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,yEAAyE;AACzE,4EAA4E;AAC5E,kEAAkE;AAClE,iCAAiC;AACjC,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,wDAAwD;AACxD,yEAAyE;AACzE,wCAAwC;AACxC,kCAAkC;AAElC,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuInC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,kBAAkB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;CAIzC,CAAC"}

package/dist/atmosphere/shaders/volumetric-apply.glsl.d.ts

@@ -0,0 +1,3 @@
+export declare function volumetricApplyVertexSource(): string;
+export declare function volumetricApplyFragmentSource(): string;
+//# sourceMappingURL=volumetric-apply.glsl.d.ts.map

package/dist/atmosphere/shaders/volumetric-apply.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-apply.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-apply.glsl.ts"],"names":[],"mappings":"AA0DA,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD"}

package/dist/atmosphere/shaders/volumetric-apply.glsl.js

@@ -0,0 +1,61 @@
+// PRD-07 P5-T6 — §8.7 froxel apply: fullscreen premultiplied-alpha-over blend
+// (src.rgb = S, src.a = 1−T → dst = S + dst·T, equal to color·T + S).
+// Slice lookup: k = log(viewZ/n)/log(f/n)·N with a 2-tile lerp (§6.7).
+// GLSL ES 3.00.
+import { PRD07_VOLUMETRIC_MARKER } from "./volumetric-inject.glsl.js";
+const VERT = `
+// ${PRD07_VOLUMETRIC_MARKER} apply vertex
+in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+  v_uv = a_pos * 0.5 + 0.5;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+const FRAG = `
+// ${PRD07_VOLUMETRIC_MARKER} apply fragment
+precision highp float;
+uniform sampler2D u_integrateAtlas; // (S_acc, T_acc) per tile
+uniform highp sampler2D u_sceneDepth;
+uniform vec4 u_depthLinearize;     // near, far, orthographic, unused
+uniform vec2 u_atlasSize;
+uniform vec2 u_tileSize;
+uniform float u_tilesX;
+uniform float u_near;
+uniform float u_far;
+uniform float u_slices;
+in vec2 v_uv;
+layout(location=0) out vec4 o_apply;
+
+float a3dSceneViewZ(float depth) {
+  if (u_depthLinearize.z > 0.5) return mix(u_depthLinearize.x, u_depthLinearize.y, depth);
+  return u_depthLinearize.x * u_depthLinearize.y /
+    max(u_depthLinearize.y - depth * (u_depthLinearize.y - u_depthLinearize.x), 1e-4);
+}
+
+vec4 a3dSampleSlice(int k, vec2 uv) {
+  if (k < 0 || k >= int(u_slices)) return vec4(0.0, 0.0, 0.0, 1.0);
+  vec2 tile = vec2(float(k % int(u_tilesX)), float(k / int(u_tilesX)));
+  return texture(u_integrateAtlas, (tile * u_tileSize + uv * u_tileSize) / u_atlasSize);
+}
+
+void main() {
+  float depth = texelFetch(u_sceneDepth, ivec2(gl_FragCoord.xy), 0).r;
+  float viewZ = a3dSceneViewZ(depth);
+  float fslice = clamp(log(viewZ / u_near) / log(u_far / u_near) * u_slices - 0.5, 0.0, u_slices - 1.0);
+  int k0 = int(floor(fslice));
+  int k1 = min(k0 + 1, int(u_slices) - 1);
+  vec2 uv = v_uv;                    // tile-local uv equals screen uv (view-aligned grid)
+  vec4 s0 = a3dSampleSlice(k0, uv);
+  vec4 s1 = a3dSampleSlice(k1, uv);
+  vec4 s = mix(s0, s1, fslice - float(k0));   // rgb = S, a = T
+  o_apply = vec4(s.rgb, 1.0 - s.a);           // premultiplied-over encode
+}
+`;
+export function volumetricApplyVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function volumetricApplyFragmentSource() {
+    return `#version 300 es\n${FRAG}`;
+}
+//# sourceMappingURL=volumetric-apply.glsl.js.map

package/dist/atmosphere/shaders/volumetric-apply.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-apply.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-apply.glsl.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,sEAAsE;AACtE,uEAAuE;AACvE,gBAAgB;AAEhB,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;;;CAO3B,CAAC;AAEF,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC3B,CAAC;AAEF,MAAM,UAAU,2BAA2B;IACzC,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,6BAA6B;IAC3C,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC"}

package/dist/atmosphere/shaders/volumetric-inject.glsl.d.ts

@@ -0,0 +1,4 @@
+export declare const PRD07_VOLUMETRIC_MARKER = "a3d_prd07_volumetric";
+export declare function volumetricInjectVertexSource(): string;
+export declare function volumetricInjectFragmentSource(): string;
+//# sourceMappingURL=volumetric-inject.glsl.d.ts.map

package/dist/atmosphere/shaders/volumetric-inject.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-inject.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-inject.glsl.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAyH9D,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD"}

package/dist/atmosphere/shaders/volumetric-inject.glsl.js

@@ -0,0 +1,129 @@
+// PRD-07 P5-T6 — §8.7 froxel inject (per-slice draw into a 2D tiled atlas).
+// Each draw is scissored to one tile; the fragment reconstructs the froxel
+// world position from the view ray and slice depth, then writes (L, σ).
+// GLSL ES 3.00.
+export const PRD07_VOLUMETRIC_MARKER = "a3d_prd07_volumetric";
+const VERT = `
+// ${PRD07_VOLUMETRIC_MARKER} inject vertex
+in vec2 a_pos;
+out vec2 v_ndc;
+void main() {
+  v_ndc = a_pos;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+const FRAG = `
+// ${PRD07_VOLUMETRIC_MARKER} inject fragment
+precision highp float;
+uniform sampler2D u_noiseTex;    // unused placeholder channel (real 3D noise below)
+uniform vec2 u_tileSize;         // tile pixel dims
+uniform vec2 u_projTan;          // tanHalfFovX, tanHalfFovY
+uniform mat4 u_invView;          // camera world matrix (rotation+translation)
+uniform vec3 u_cameraPosition;
+uniform float u_near;            // slice near (0.5)
+uniform float u_far;             // volumetricFar (64 / 96)
+uniform float u_slice;
+uniform float u_slices;
+uniform float u_jitter;          // Ultra temporal jitter in [0,1)
+uniform vec4 u_fogDensity;       // σ_d, σ_h, b, h0 — height fog coefficients
+uniform vec4 u_fogVolumes[16];   // centre.xyz+shape, halfSize.xyz+density (≤8)
+uniform float u_noiseScale;
+uniform float u_noiseSpeed;
+uniform float u_noiseStrength;
+uniform float u_time;
+uniform vec3 u_sunDirection;
+uniform vec3 u_sunColor;
+uniform float u_anisotropy;      // HG g
+uniform vec3 u_ambientColor;
+uniform vec4 u_localLights[8];   // ≤4 lights: pos.xyz+intensity, color.rgb packed in second vec4
+in vec2 v_ndc;
+layout(location=0) out vec4 o_inject;
+
+// --- density terms -------------------------------------------------------
+float a3dInjectHeightDensity(vec3 p) {
+  return u_fogDensity.y * exp(-u_fogDensity.z * (p.y - u_fogDensity.w)) + u_fogDensity.x;
+}
+
+float a3dInjectVolumeDensity(vec3 p) {
+  float d = 0.0;
+  for (int i = 0; i < 8; i++) {
+    vec4 a = u_fogVolumes[i * 2];
+    vec4 b = u_fogVolumes[i * 2 + 1];
+    if (b.w <= 0.0) continue;
+    vec3 q = (p - a.xyz) / max(b.xyz, vec3(1e-9));
+    float inside = a.w > 0.5
+      ? (1.0 - smoothstep(0.85, 1.0, dot(q, q)))
+      : (1.0 - smoothstep(0.85, 1.0, max(max(abs(q.x), abs(q.y)), abs(q.z))));
+    d += inside * b.w;
+  }
+  return d;
+}
+
+// 3D value noise — same hash family as the GPU-sim chunk (deterministic).
+uint a3dVolHash(uint x) {
+  x += 0x6d2b79f5u;
+  uint t = (x ^ (x >> 15u)) * (1u | x);
+  t = (t + ((t ^ (t >> 7u)) * (61u | t))) ^ t;
+  return (t ^ (t >> 14u));
+}
+float a3dVolRand01(uint h) { return float(h) * (1.0 / 4294967296.0); }
+float a3dVolLattice(ivec3 c) { return a3dVolRand01(a3dVolHash(uint(c.x * 3 ^ c.y * 7 ^ c.z * 13))); }
+float a3dVolNoise(vec3 p) {
+  ivec3 ip = ivec3(floor(p));
+  vec3 fp = fract(p);
+  vec3 u = fp * fp * (3.0 - 2.0 * fp);
+  float n000 = a3dVolLattice(ip);
+  float n100 = a3dVolLattice(ip + ivec3(1, 0, 0));
+  float n010 = a3dVolLattice(ip + ivec3(0, 1, 0));
+  float n110 = a3dVolLattice(ip + ivec3(1, 1, 0));
+  float n001 = a3dVolLattice(ip + ivec3(0, 0, 1));
+  float n101 = a3dVolLattice(ip + ivec3(1, 0, 1));
+  float n011 = a3dVolLattice(ip + ivec3(0, 1, 1));
+  float n111 = a3dVolLattice(ip + ivec3(1, 1, 1));
+  float nx00 = mix(n000, n100, u.x);
+  float nx10 = mix(n010, n110, u.x);
+  float nx01 = mix(n001, n101, u.x);
+  float nx11 = mix(n011, n111, u.x);
+  return mix(mix(nx00, nx10, u.y), mix(nx01, nx11, u.y), u.z);   // [0,1]
+}
+
+// Henyey-Greenstein phase.
+float a3dHG(float mu, float g) {
+  float g2 = g * g;
+  return (1.0 - g2) / (12.5663706 * pow(1.0 + g2 - 2.0 * g * mu, 1.5));
+}
+
+void main() {
+  // Tile-local uv → view ray at slice depth z_k (exponential distribution).
+  vec2 uv = gl_FragCoord.xy / u_tileSize - floor(gl_FragCoord.xy / u_tileSize);
+  vec2 ndc = uv * 2.0 - 1.0;
+  float zk = u_near * pow(u_far / u_near, (u_slice + u_jitter) / u_slices);
+  vec3 viewDir = vec3(ndc * u_projTan, -1.0);
+  vec3 p = u_cameraPosition + (u_invView * vec4(viewDir * zk, 0.0)).xyz;
+
+  float sigma = a3dInjectHeightDensity(p) + a3dInjectVolumeDensity(p);
+  sigma += (a3dVolNoise(p * u_noiseScale + vec3(0.0, 0.0, -u_time * u_noiseSpeed)) * 2.0 - 1.0) * u_noiseStrength;
+  sigma = max(sigma, 0.0);
+
+  // Lighting: sun × visibility(stub 1.0) × HG + ambient SH stub + ≤4 locals.
+  vec3 v = normalize(p - u_cameraPosition);
+  float mu = dot(v, u_sunDirection);
+  vec3 L = u_sunColor * a3dHG(mu, u_anisotropy) + u_ambientColor;
+  for (int i = 0; i < 4; i++) {
+    vec4 la = u_localLights[i * 2];
+    vec4 lb = u_localLights[i * 2 + 1];
+    if (la.w <= 0.0) continue;
+    vec3 toLight = la.xyz - p;
+    float d = max(length(toLight), 1e-4);
+    L += lb.rgb * (la.w / (d * d)) * a3dHG(dot(v, toLight / d), u_anisotropy);
+  }
+  o_inject = vec4(L * sigma, sigma);
+}
+`;
+export function volumetricInjectVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function volumetricInjectFragmentSource() {
+    return `#version 300 es\n${FRAG}`;
+}
+//# sourceMappingURL=volumetric-inject.glsl.js.map

package/dist/atmosphere/shaders/volumetric-inject.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-inject.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-inject.glsl.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,2EAA2E;AAC3E,wEAAwE;AACxE,gBAAgB;AAEhB,MAAM,CAAC,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE9D,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;;;CAO3B,CAAC;AAEF,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0G3B,CAAC;AAEF,MAAM,UAAU,4BAA4B;IAC1C,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,8BAA8B;IAC5C,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC"}

package/dist/atmosphere/shaders/volumetric-integrate.glsl.d.ts

@@ -0,0 +1,3 @@
+export declare function volumetricIntegrateVertexSource(): string;
+export declare function volumetricIntegrateFragmentSource(): string;
+//# sourceMappingURL=volumetric-integrate.glsl.d.ts.map

package/dist/atmosphere/shaders/volumetric-integrate.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-integrate.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-integrate.glsl.ts"],"names":[],"mappings":"AAoDA,wBAAgB,+BAA+B,IAAI,MAAM,CAExD;AAED,wBAAgB,iCAAiC,IAAI,MAAM,CAE1D"}

package/dist/atmosphere/shaders/volumetric-integrate.glsl.js

@@ -0,0 +1,55 @@
+// PRD-07 P5-T6 — §8.7 froxel integrate: one draw covering the whole atlas;
+// each fragment computes the front-to-back prefix sum for ITS tile's slice k
+// (O(N²) texel reads total — spec-faithful "one pass that loops the slices").
+// Writes (S_acc, T_acc) per slice; apply reads it with a 2-tile lerp.
+// GLSL ES 3.00.
+import { PRD07_VOLUMETRIC_MARKER } from "./volumetric-inject.glsl.js";
+const VERT = `
+// ${PRD07_VOLUMETRIC_MARKER} integrate vertex
+in vec2 a_pos;
+void main() {
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+const FRAG = `
+// ${PRD07_VOLUMETRIC_MARKER} integrate fragment
+precision highp float;
+uniform sampler2D u_injectAtlas;  // (L, σ) per tile
+uniform vec2 u_atlasSize;         // atlas pixels (tilesX*tileW, tilesY*tileH)
+uniform vec2 u_tileSize;
+uniform float u_tilesX;
+uniform float u_near;
+uniform float u_far;
+uniform float u_slices;
+layout(location=0) out vec4 o_integrate;
+
+float a3dSliceZ(float k) {
+  return u_near * pow(u_far / u_near, float(k) / u_slices);
+}
+
+void main() {
+  vec2 tileF = floor(gl_FragCoord.xy / u_tileSize);
+  int k = int(tileF.y) * int(u_tilesX) + int(tileF.x);
+  vec2 uv = fract(gl_FragCoord.xy / u_tileSize);
+
+  vec3 S = vec3(0.0);
+  float T = 1.0;
+  for (int j = 0; j <= k; j++) {
+    vec2 tile = vec2(float(j % int(u_tilesX)), float(j / int(u_tilesX)));
+    vec4 inj = texture(u_injectAtlas, (tile * u_tileSize + uv * u_tileSize) / u_atlasSize);
+    float sigma = inj.a;
+    float dz = a3dSliceZ(float(j) + 1.0) - a3dSliceZ(float(j));
+    // energy-conserving step (Hillaire 2015): S += L·(1-e^{-σΔz})/σ · T
+    S += inj.rgb * ((1.0 - exp(-sigma * dz)) / max(sigma, 1e-5)) * T;
+    T *= exp(-sigma * dz);
+  }
+  o_integrate = vec4(S, T);
+}
+`;
+export function volumetricIntegrateVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function volumetricIntegrateFragmentSource() {
+    return `#version 300 es\n${FRAG}`;
+}
+//# sourceMappingURL=volumetric-integrate.glsl.js.map

package/dist/atmosphere/shaders/volumetric-integrate.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumetric-integrate.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/volumetric-integrate.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,6EAA6E;AAC7E,8EAA8E;AAC9E,sEAAsE;AACtE,gBAAgB;AAEhB,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;CAK3B,CAAC;AAEF,MAAM,IAAI,GAAG;KACR,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC3B,CAAC;AAEF,MAAM,UAAU,+BAA+B;IAC7C,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,iCAAiC;IAC/C,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC"}

package/dist/atmosphere/shaders/wetness.glsl.d.ts

@@ -0,0 +1,34 @@
+import type { Texture } from "../../Texture.js";
+export declare const PRD07_WETNESS_CHUNK_GLSL = "\n// a3d_prd07_wetness \u2014 \u00A76.8 wet-look material response.\n#ifdef A3D_WETNESS\n#ifndef A3D_PRD07_WETNESS_CHUNK\n#define A3D_PRD07_WETNESS_CHUNK\nuniform float u_wetness;          // global wetness [0,1] (AtmosphereWetness)\nuniform float u_puddleThreshold;  // noise threshold for puddles\nuniform float u_rainRipples;      // ripple flipbook frame; 0 = off\nuniform float u_snowCover;        // snow cover [0,1]\nuniform sampler2D u_puddleNoise;  // world-space tiled noise (u puddleNoise)\n\n// World-space puddle mask: tiled noise at worldPos.xz / 6 thresholded by wet.\nfloat a3dWetnessPuddle(vec3 worldPos, float wet) {\n  float n = texture(u_puddleNoise, worldPos.xz / 6.0).r;\n  return smoothstep(u_puddleThreshold, 1.0, n) * wet;\n}\n\n// \u00A76.8: albedo *= mix(1, 0.55, wet\u00B7porosity); snow cover \u2192 snow white.\nvec3 a3dWetnessAlbedo(vec3 albedo, float porosity) {\n  float wet = clamp(u_wetness, 0.0, 1.0);\n  vec3 a = albedo * mix(1.0, 0.55, wet * clamp(porosity, 0.0, 1.0));\n  return mix(a, vec3(0.95, 0.96, 1.0), clamp(u_snowCover, 0.0, 1.0));\n}\n\n// \u00A76.8: roughness = mix(roughness, 0.06, wet\u00B7puddle); snow cover \u2192 0.9.\nfloat a3dWetnessRoughness(float roughness, vec3 worldPos) {\n  float wet = clamp(u_wetness, 0.0, 1.0);\n  float puddle = a3dWetnessPuddle(worldPos, wet);\n  float r = mix(roughness, 0.06, clamp(wet * puddle, 0.0, 1.0));\n  return mix(r, 0.9, clamp(u_snowCover, 0.0, 1.0));\n}\n#endif // A3D_PRD07_WETNESS_CHUNK\n#endif // A3D_WETNESS\n";
+export declare const PRD07_WETNESS_CHUNK_NAME = "a3d_prd07_wetness";
+/**
+ * #880 / T0-05 — `fragment:material` call chunk (statements only). Appends to
+ * the generator's default material: it runs after `PhysicalMaterial material`
+ * is built and updates its fields in place (no replace). Lit forward items
+ * only — `prd07WetnessSelect` gates on that, since unlit programs have no
+ * `material`. Porosity 1 (fully porous) until a per-material input exists.
+ */
+export declare const PRD07_WETNESS_APPLY_CHUNK_GLSL = "\n#ifdef A3D_WETNESS\n  material.baseColor = a3dWetnessAlbedo(material.baseColor, 1.0);\n  material.diffuseContribution = material.baseColor * (1.0 - material.metallic);\n  material.specularColorBlended = mix(material.specularColor, material.baseColor, material.metallic);\n  material.roughness = clamp(a3dWetnessRoughness(material.roughness, v_worldPosition), 0.0525, 1.0);\n#endif\n";
+export interface WetnessUniformState {
+    readonly wetness: number;
+    readonly puddleThreshold: number;
+    readonly rainRipples: number;
+    readonly snowCover: number;
+    readonly puddleNoise: Texture | null;
+}
+/** Called when the wetness feature selected but couldn't splice (stub gen). */
+export declare function noteWetnessPending(): string | null;
+/** Test hook. */
+export declare function resetWetnessPending(): void;
+export declare function setPrd07WetnessState(state: Partial<WetnessUniformState>): void;
+export declare function prd07WetnessState(): WetnessUniformState;
+/**
+ * CPU mirror of the §6.8 response (noise-free: `puddle` supplied directly).
+ * albedo *= mix(1, 0.55, wet·porosity); roughness = mix(r, 0.06, wet·puddle);
+ * snow cover mixes albedo → snow white and roughness → 0.9.
+ */
+export declare function applyWetnessMaterialCpu(albedo: readonly [number, number, number], roughness: number, wet: number, porosity: number, puddle: number, snowCover?: number): {
+    readonly albedo: readonly [number, number, number];
+    readonly roughness: number;
+};
+//# sourceMappingURL=wetness.glsl.d.ts.map

package/dist/atmosphere/shaders/wetness.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wetness.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/wetness.glsl.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,eAAO,MAAM,wBAAwB,0+CAiCpC,CAAC;AAEF,eAAO,MAAM,wBAAwB,sBAAsB,CAAC;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,qYAO1C,CAAC;AAQF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAAC;CACtC;AAYD,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAIlD;AAED,iBAAiB;AACjB,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAE9E;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACzC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,SAAI,GACZ;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAYpF"}