@aura3d/rendering 3.0.1 → 4.0.2

package/dist/vfx/decalLighting.js

@@ -0,0 +1,53 @@
+// PRD-07 §8.8 / I3 — scene lighting for the merged decal pass. Decals must
+// shade like the surface they sit on (promote run 38196483050: a fixed
+// half-Lambert sun + 0.14 SH ambient + unweighted GGX lit a #0a0a0c scorch mark
+// brighter than the asphalt under it). Reads the same light list the forward
+// pass shades with (`source.collectedLights`) and the
+// ambient `environmentLighting` colour × intensity.
+/** Mirrors DECAL_MAX_LIGHTS in DecalPass.ts (kept local: no runtime import cycle). */
+const DECAL_MAX_LIGHTS = 5;
+function unit(v) {
+    const l = Math.hypot(v[0] ?? 0, v[1] ?? 0, v[2] ?? 0);
+    return l > 0 ? [(v[0] ?? 0) / l, (v[1] ?? 0) / l, (v[2] ?? 0) / l] : null;
+}
+function luminance(c) {
+    return 0.2126 * (c[0] ?? 0) + 0.7152 * (c[1] ?? 0) + 0.0722 * (c[2] ?? 0);
+}
+/** Collected lights → decal lights (directional + point/spot as point), brightest first. */
+export function decalLightsFrom(collected) {
+    const out = [];
+    for (const light of collected) {
+        if (light.source?.visible === false || !(light.intensity > 0))
+            continue;
+        const radiance = [light.color[0] * light.intensity, light.color[1] * light.intensity, light.color[2] * light.intensity];
+        if (light.kind === "directional") {
+            // CollectedLight.direction is the travel direction; the BRDF wants L.
+            const toward = unit([-light.direction[0], -light.direction[1], -light.direction[2]]);
+            if (toward)
+                out.push({ light: { kind: "directional", vector: toward, radiance }, weight: luminance(radiance) * 4 });
+        }
+        else if (light.kind === "point" || light.kind === "spot") {
+            out.push({
+                light: { kind: "point", vector: [light.position[0], light.position[1], light.position[2]], radiance, range: Number.isFinite(light.range) ? light.range : 0 },
+                weight: luminance(radiance)
+            });
+        }
+    }
+    out.sort((a, b) => b.weight - a.weight);
+    return out.slice(0, DECAL_MAX_LIGHTS).map((entry) => entry.light);
+}
+/** Per-frame decal lighting from the render source; null when nothing is published. */
+export function resolveDecalLighting(ctx) {
+    const source = ctx.source;
+    // The compiled light list the forward pass shades with; without one the
+    // pass falls back to its default rig.
+    const collected = source.collectedLights ?? null;
+    const env = source.environmentLighting;
+    const ambient = env
+        ? [env.color[0] * env.intensity, env.color[1] * env.intensity, env.color[2] * env.intensity]
+        : [0, 0, 0];
+    if (collected === null && !env)
+        return null;
+    return { lights: collected ? decalLightsFrom(collected) : [], ambient };
+}
+//# sourceMappingURL=decalLighting.js.map

package/dist/vfx/decalLighting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decalLighting.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/vfx/decalLighting.ts"],"names":[],"mappings":"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"}

package/dist/vfx/depthSampler.d.ts

@@ -0,0 +1,3 @@
+import { Sampler } from "../Sampler.js";
+export declare const PRD07_DEPTH_SAMPLER: Sampler;
+//# sourceMappingURL=depthSampler.d.ts.map

package/dist/vfx/depthSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthSampler.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/vfx/depthSampler.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,eAAO,MAAM,mBAAmB,SAAoH,CAAC"}

package/dist/vfx/depthSampler.js

@@ -0,0 +1,10 @@
+// PRD-07 — sampler for every lane-07 read of the scene depth texture
+// (soft particles/ribbons/beams, low-res composite, volumetric apply).
+// A depth texture with compare mode NONE is incomplete under LINEAR filtering
+// (GLES 3.0 §3.8.13) and samples 0 on WebGL2, so the default TextureBinding
+// sampler made sceneZ = near everywhere: the soft-depth fade went to zero and
+// particles drew 0 pixels under A3D_QR_CORE (frame identical to -vfx).
+// Same filter/address as lane 01's DEPTH_TEXTURE_SAMPLER (SceneDepthCopyPass).
+import { Sampler } from "../Sampler.js";
+export const PRD07_DEPTH_SAMPLER = new Sampler({ minFilter: "nearest", magFilter: "nearest", addressU: "clamp-to-edge", addressV: "clamp-to-edge" });
+//# sourceMappingURL=depthSampler.js.map

package/dist/vfx/depthSampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthSampler.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/vfx/depthSampler.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,uEAAuE;AACvE,8EAA8E;AAC9E,4EAA4E;AAC5E,8EAA8E;AAC9E,uEAAuE;AACvE,+EAA+E;AAE/E,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAC"}

package/dist/vfx/prd07FeaturePars.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderFeatureSelectInput } from "../contracts/program.js";
+/** "prd07.fog" — height fog model on analytic tiers, volumetric otherwise. */
+export declare function prd07FogSelect(input: Pick<ShaderFeatureSelectInput, "flags" | "tier">): "height" | "volumetric" | undefined;
+/** "prd07.wetness" — only while a wetness driver is live (§6.8; IC-0: no
+ *  chunk injected into a dry scene), and only for lit forward draws: the
+ *  `fragment:material` call chunk edits `PhysicalMaterial material`, which
+ *  unlit / depth / shadow programs do not have (wetness landmine, #880). */
+export declare function prd07WetnessSelect(input?: Pick<ShaderFeatureSelectInput, "item" | "pass">): true | undefined;
+/** Evaluate every lane-07 feature bit for one item. Sparse — only active
+ *  features appear; merge over `f.features` without overwriting set bits. */
+export declare function prd07FeatureBits(input: ShaderFeatureSelectInput): Record<string, string | number | boolean>;
+//# sourceMappingURL=prd07FeaturePars.d.ts.map

package/dist/vfx/prd07FeaturePars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prd07FeaturePars.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/vfx/prd07FeaturePars.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,wBAAwB,EAAE,OAAO,GAAG,MAAM,CAAC,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,CAG3H;AAMD;;;4EAG4E;AAC5E,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,CAO5G;AAED;6EAC6E;AAC7E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAO3G"}

package/dist/vfx/prd07FeaturePars.js

@@ -0,0 +1,54 @@
+// PRD-07 P4/P5 — lane-07 *pars* library for the T0-05(b) per-item
+// ShaderFeature.select evaluation. The registered features in lanes/prd07.ts
+// delegate here so a program-acquire path (ProgramGenerator per-item
+// evaluation, or MaterialFeatures bit population) resolves identical values.
+//
+// Call snippet for the prd01 T0-05 consumer (see qr issue #490):
+//
+//   import { prd07FeatureBits } from ".../vfx/prd07FeaturePars";
+//   // inside contributingFeatures(f, flags, input) — per RenderItem:
+//   for (const [id, value] of Object.entries(prd07FeatureBits(input))) {
+//     if (f.features[id] === undefined) out.push({ feature: byId(id), value });
+//   }
+//
+// or, populating bits at MaterialFeatures build time when ctx.item is known:
+//
+//   Object.assign(features, prd07FeatureBits({ item, pass: f.pass, tier, flags }));
+import { prd07WetnessState } from "../atmosphere/shaders/wetness.glsl.js";
+/** "prd07.fog" — height fog model on analytic tiers, volumetric otherwise. */
+export function prd07FogSelect(input) {
+    if (!input.flags.on("A3D_QR_VFX_FOG"))
+        return undefined;
+    return input.tier.volumetricFog === "analytic" ? "height" : "volumetric";
+}
+/** Lit shader keys — mirrors the C-02 `lighting: "lit"` rule in
+ *  `program/MaterialFeatures.ts` (`/pbr|skinned-lit/i`, lane 01). */
+const LIT_SHADER_KEY = /pbr|skinned-lit/i;
+/** "prd07.wetness" — only while a wetness driver is live (§6.8; IC-0: no
+ *  chunk injected into a dry scene), and only for lit forward draws: the
+ *  `fragment:material` call chunk edits `PhysicalMaterial material`, which
+ *  unlit / depth / shadow programs do not have (wetness landmine, #880). */
+export function prd07WetnessSelect(input) {
+    const w = prd07WetnessState();
+    if (!(w.wetness > 0 || w.rainRipples > 0 || w.snowCover > 0))
+        return undefined;
+    if (input === undefined)
+        return true;
+    if (input.pass !== "forward")
+        return undefined;
+    const shaderKey = input.item.material?.shaderKey ?? "";
+    return LIT_SHADER_KEY.test(shaderKey) ? true : undefined;
+}
+/** Evaluate every lane-07 feature bit for one item. Sparse — only active
+ *  features appear; merge over `f.features` without overwriting set bits. */
+export function prd07FeatureBits(input) {
+    const out = {};
+    const fog = prd07FogSelect(input);
+    if (fog !== undefined)
+        out["prd07.fog"] = fog;
+    const wet = prd07WetnessSelect(input);
+    if (wet !== undefined)
+        out["prd07.wetness"] = wet;
+    return out;
+}
+//# sourceMappingURL=prd07FeaturePars.js.map

package/dist/vfx/prd07FeaturePars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prd07FeaturePars.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/vfx/prd07FeaturePars.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,6EAA6E;AAC7E,qEAAqE;AACrE,6EAA6E;AAC7E,EAAE;AACF,iEAAiE;AACjE,EAAE;AACF,iEAAiE;AACjE,sEAAsE;AACtE,yEAAyE;AACzE,gFAAgF;AAChF,MAAM;AACN,EAAE;AACF,6EAA6E;AAC7E,EAAE;AACF,oFAAoF;AAGpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAEvE,8EAA8E;AAC9E,MAAM,UAAU,cAAc,CAAC,KAAuD;IACpF,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC;QAAE,OAAO,SAAS,CAAC;IACxD,OAAO,KAAK,CAAC,IAAI,CAAC,aAAa,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC;AAC3E,CAAC;AAED;qEACqE;AACrE,MAAM,cAAc,GAAG,kBAAkB,CAAC;AAE1C;;;4EAG4E;AAC5E,MAAM,UAAU,kBAAkB,CAAC,KAAuD;IACxF,MAAM,CAAC,GAAG,iBAAiB,EAAE,CAAC;IAC9B,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/E,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACrC,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC/C,MAAM,SAAS,GAAI,KAAK,CAAC,IAAI,CAAC,QAAwD,EAAE,SAAS,IAAI,EAAE,CAAC;IACxG,OAAO,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3D,CAAC;AAED;6EAC6E;AAC7E,MAAM,UAAU,gBAAgB,CAAC,KAA+B;IAC9D,MAAM,GAAG,GAA8C,EAAE,CAAC;IAC1D,MAAM,GAAG,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IAClC,IAAI,GAAG,KAAK,SAAS;QAAE,GAAG,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;IAC9C,MAAM,GAAG,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,GAAG,KAAK,SAAS;QAAE,GAAG,CAAC,eAAe,CAAC,GAAG,GAAG,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/vfx/shaders/beam.glsl.d.ts

@@ -0,0 +1,11 @@
+export declare const BEAM_SHADER_MARKER = "prd07-beam-v1";
+export declare function beamVertexSource(): string;
+export declare function beamFragmentSource(defines: {
+    readonly softParticles?: boolean;
+    readonly aurora?: boolean;
+}): string;
+export declare function beamProgramKey(defines: {
+    readonly softParticles?: boolean;
+    readonly aurora?: boolean;
+}): string;
+//# sourceMappingURL=beam.glsl.d.ts.map

package/dist/vfx/shaders/beam.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beam.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/beam.glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,wBAAgB,gBAAgB,IAAI,MAAM,CA6BzC;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAgDnH;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAE/G"}

package/dist/vfx/shaders/beam.glsl.js

@@ -0,0 +1,89 @@
+// PRD-07 P2-T9 — beam/cone/aurora shaders (§6.2.10). Same vertex layout as
+// ribbon.glsl (pos3 normal3 uv2 color4): the CPU pass bakes taper + falloff
+// into per-vertex color/alpha; the fragment adds soft-depth fade, the output
+// encode, and — for the aurora curtain — the scrolling shimmer bands
+// (PRD 14 §8.2: curtain fold + shimmer are fragment-time effects).
+export const BEAM_SHADER_MARKER = "prd07-beam-v1";
+export function beamVertexSource() {
+    return `#version 300 es
+// ${BEAM_SHADER_MARKER} vertex
+precision highp float;
+in vec3 a_position;
+in vec3 a_normal;
+in vec2 a_uv;
+in vec4 a_color;
+uniform mat4 u_viewProjection;
+uniform float u_time;
+uniform float u_sway;
+uniform float u_aurora;
+out vec2 v_uv;
+out vec4 v_color;
+out vec3 v_world;
+void main() {
+  v_uv = a_uv;
+  v_color = a_color;
+  vec3 p = a_position;
+  if (u_aurora > 0.5) {
+    // curtain sway: lateral offset grows with uv.y (height), slow phase scroll
+    float sway = sin(u_time * 0.4 + a_uv.x * 6.28318 * 2.0) * u_sway * a_uv.y;
+    p.x += sway;
+    p.z += sway * 0.35;
+  }
+  v_world = p;
+  gl_Position = u_viewProjection * vec4(p, 1.0);
+}
+`;
+}
+export function beamFragmentSource(defines) {
+    const aurora = defines.aurora ? "#define AURORA" : "";
+    const soft = defines.softParticles ? "#define SOFT_PARTICLES" : "";
+    return `#version 300 es
+// ${BEAM_SHADER_MARKER} fragment
+precision highp float;
+${aurora}
+${soft}
+in vec2 v_uv;
+in vec4 v_color;
+in vec3 v_world;
+uniform sampler2D u_sceneDepth;
+uniform vec4 u_depthLinearize;
+uniform float u_outputColorSpace;
+uniform float u_time;
+uniform float u_shimmer;
+layout(location = 0) out vec4 o_color;
+void main() {
+  float alpha = v_color.a;
+  vec3 rgb = v_color.rgb;
+#ifdef AURORA
+  // curtain folds: uv.x bands drifting with time, brightness clipped soft
+  float band = sin(v_uv.x * 18.0 + u_time * 1.7) * 0.5 + 0.5;
+  float fold = mix(0.55, 1.0, band * band);
+  rgb *= fold * (1.0 + u_shimmer * 0.5);
+  alpha *= fold;
+#endif
+#ifdef SOFT_PARTICLES
+  vec2 ndc = gl_FragCoord.xy / vec2(textureSize(u_sceneDepth, 0));
+  float d = texture(u_sceneDepth, ndc).r;
+  float sceneZ = u_depthLinearize.z > 0.5
+    ? mix(u_depthLinearize.x, u_depthLinearize.y, d)
+    : (u_depthLinearize.x * u_depthLinearize.y) / max(u_depthLinearize.y - d * (u_depthLinearize.y - u_depthLinearize.x), 1e-4);
+  float fragZ = gl_FragCoord.z / gl_FragCoord.w;
+  alpha *= clamp((sceneZ - fragZ) / 0.5, 0.0, 1.0);
+#endif
+  rgb *= alpha;
+  // GLSL pow(x, y) is undefined for x < 0: the interpolated cone-base alpha
+  // (0 at the rim) dips to -ε on NVIDIA and the encode returned NaN, which
+  // failed the HDR tone-map finite check (prd07-volumetric-shafts, run 38196483050).
+  rgb = max(rgb, vec3(0.0));
+  alpha = clamp(alpha, 0.0, 1.0);
+  if (u_outputColorSpace > 0.5) {
+    rgb = pow(rgb, vec3(1.0 / 2.2));
+  }
+  o_color = vec4(rgb, alpha);
+}
+`;
+}
+export function beamProgramKey(defines) {
+    return `beam.${defines.softParticles ? "S" : "x"}${defines.aurora ? "A" : "x"}`;
+}
+//# sourceMappingURL=beam.glsl.js.map

package/dist/vfx/shaders/beam.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beam.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/beam.glsl.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,qEAAqE;AACrE,mEAAmE;AAEnE,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAElD,MAAM,UAAU,gBAAgB;IAC9B,OAAO;KACJ,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BtB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,OAAwE;IACzG,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;IACtD,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,EAAE,CAAC;IACnE,OAAO;KACJ,kBAAkB;;EAErB,MAAM;EACN,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCL,CAAC;AACF,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,OAAwE;IACrG,OAAO,QAAQ,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAClF,CAAC"}

package/dist/vfx/shaders/decal.glsl.d.ts

@@ -0,0 +1,14 @@
+export declare const DECAL_SHADER_MARKER = "prd07-decal-v1";
+export interface DecalProgramDefines {
+    /** Page albedo texture (decal atlas page or flat texture). */
+    readonly albedoTexture: boolean;
+    /** Page normal map — perturbs the projected mesh normal. */
+    readonly normalTexture: boolean;
+    /** Multiply grime blend → C-04-stub alpha-over emulation. */
+    readonly multiply: boolean;
+    readonly fog: boolean;
+}
+export declare function decalVertexSource(): string;
+export declare function decalFragmentSource(defines: DecalProgramDefines): string;
+export declare function decalProgramKey(defines: DecalProgramDefines): string;
+//# sourceMappingURL=decal.glsl.d.ts.map

package/dist/vfx/shaders/decal.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decal.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/decal.glsl.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;CACvB;AAyID,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAExE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAEpE"}

package/dist/vfx/shaders/decal.glsl.js

@@ -0,0 +1,157 @@
+// PRD-07 P6-T1 — decal program (§8.8): lit projected marks. Albedo from the
+// atlas page (or flat colour), tangent-space normal perturb (optional page
+// normal map), page roughness; scene lights through the r185 standard BRDF +
+// ambient irradiance + a3dApplyFog (§8.4 chunk,
+// embedded — PRD 07 programs include it directly while the C-02 generator is
+// a stub). Angle fade + distance fade are folded into alpha per §6.9.
+// Blend is `alpha` for marks; `multiply` grime is emulated under the C-04
+// stub as alpha-over with black at 1 − luminance (VFX_BLEND_FALLBACK).
+//
+// Uniform-int latent bug (C-28): scalar uniforms bind via gl.uniform1f —
+// declare `float`, never `int`, on WebGL2.
+// GLSL ES 3.00.
+import { PRD07_FOG_CHUNK_GLSL } from "../../atmosphere/shaders/fog.glsl.js";
+export const DECAL_SHADER_MARKER = "prd07-decal-v1";
+const VERT = `
+// ${DECAL_SHADER_MARKER} vertex
+in vec3 a_position;   // world-space (projected / offset by the CPU merge)
+in vec3 a_normal;
+in vec2 a_uv;
+in vec4 a_color;      // albedo.rgb × alpha (life curve applied on CPU)
+in vec4 a_fade;       // angleStartDeg, angleEndDeg, nearFade, farFade
+uniform mat4 u_viewProjection;
+out vec3 v_world;
+out vec3 v_normal;
+out vec2 v_uv;
+out vec4 v_color;
+out vec4 v_fade;
+void main() {
+  v_world = a_position;
+  v_normal = a_normal;
+  v_uv = a_uv;
+  v_color = a_color;
+  v_fade = a_fade;
+  gl_Position = u_viewProjection * vec4(a_position, 1.0);
+}
+`;
+const FRAG = (d) => `
+// ${DECAL_SHADER_MARKER} fragment
+precision highp float;
+in vec3 v_world;
+in vec3 v_normal;
+in vec2 v_uv;
+in vec4 v_color;
+in vec4 v_fade;
+uniform mat4 u_viewProjection;
+${d.albedoTexture ? "uniform sampler2D u_albedo;" : ""}
+${d.normalTexture ? "uniform sampler2D u_normalMap;" : ""}
+// Same guard as the embedded fog chunk, so fogged variants don't redeclare.
+#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
+uniform float u_roughness;
+// Scene lights (three.js MeshStandardMaterial parity, PRD-07 I3 "decal BRDF
+// matches surroundings"): ≤4 punctual lights, xyz = direction TOWARD the
+// light (w 0) or world position (w 1); rgb = colour × intensity, w = range.
+uniform vec4 u_lightVector[5];   // 5 × vec4 = 20 floats (a 16-float array binds as mat4)
+uniform vec4 u_lightRadiance[5];
+uniform float u_lightCount;
+uniform vec3 u_ambientIrradiance;  // ambient colour × intensity (× BRDF_Lambert below)
+${d.fog ? PRD07_FOG_CHUNK_GLSL : ""}
+layout(location = 0) out vec4 o_color;
+
+// r185 BRDF_GGX pieces: GGX D, height-correlated Smith V, Schlick F (F0 0.04).
+float a3dDecalD(float nDotH, float alpha) {
+  float a2 = alpha * alpha;
+  float dn = nDotH * nDotH * (a2 - 1.0) + 1.0;
+  return 0.31830989 * a2 / max(dn * dn, 1e-6);
+}
+float a3dDecalV(float nDotL, float nDotV, float alpha) {
+  float a2 = alpha * alpha;
+  float gv = nDotL * sqrt(a2 + (1.0 - a2) * nDotV * nDotV);
+  float gl = nDotV * sqrt(a2 + (1.0 - a2) * nDotL * nDotL);
+  return 0.5 / max(gv + gl, 1e-6);
+}
+vec3 a3dDecalDirect(vec3 albedo, vec3 N, vec3 V, vec3 L, vec3 radiance, float alpha) {
+  float nDotL = clamp(dot(N, L), 0.0, 1.0);
+  if (nDotL <= 0.0) return vec3(0.0);
+  vec3 H = normalize(L + V);
+  float nDotH = clamp(dot(N, H), 0.0, 1.0);
+  float nDotV = clamp(dot(N, V), 1e-3, 1.0);
+  float vDotH = clamp(dot(V, H), 0.0, 1.0);
+  float f = 0.04 + 0.96 * pow(1.0 - vDotH, 5.0);
+  float spec = f * a3dDecalV(nDotL, nDotV, alpha) * a3dDecalD(nDotH, alpha);
+  return radiance * nDotL * (albedo * 0.31830989 + vec3(spec));
+}
+
+void main() {
+  vec4 albedo = ${d.albedoTexture ? "texture(u_albedo, v_uv)" : "vec4(1.0)"} * v_color;
+
+  // §6.9 fades — angle (grazing) then distance, both smoothstep windows.
+  vec3 V = u_cameraPosition - v_world;
+  float dist = length(V);
+  V /= max(dist, 1e-4);
+  vec3 N = normalize(v_normal);
+  ${d.normalTexture ? `
+  // Tangent-space normal map from the page — the projected quad's TBN is the
+  // plane frame (u along the decal's local +X), cheap derivative TBN.
+  {
+    vec3 t = normalize(dFdx(v_world));
+    vec3 b = normalize(dFdy(v_world));
+    vec3 nTex = texture(u_normalMap, v_uv).xyz * 2.0 - 1.0;
+    N = normalize(mat3(t, b, N) * nTex);
+  }` : ""}
+  float facing = abs(dot(N, V));
+  float cosStart = cos(radians(v_fade.x));
+  float cosEnd = cos(radians(v_fade.y));
+  // facing=cos(incidence): 1 head-on → 0 grazing; fade runs start→end.
+  // angleEnd <= angleStart disables the angle fade (surface-pinned trails).
+  float angleFade = v_fade.y > v_fade.x ? smoothstep(cosEnd, cosStart, facing) : 1.0;
+  float distFade = 1.0 - smoothstep(v_fade.z, v_fade.w, dist);
+
+  // Lighting: the scene's lights through the r185 standard BRDF (Lambert/π +
+  // GGX, F0 0.04) plus ambient irradiance × BRDF_Lambert — the same response
+  // as the surface the decal sits on (+ §8.4 fog below).
+  if (dot(N, V) < 0.0) N = -N;     // double-sided projected quads
+  float alphaR = max(u_roughness * u_roughness, 0.0025);
+  vec3 lit = albedo.rgb * 0.31830989 * u_ambientIrradiance;
+  for (int i = 0; i < 5; i++) {
+    if (float(i) >= u_lightCount) break;
+    vec4 lv = u_lightVector[i];
+    vec4 lr = u_lightRadiance[i];
+    vec3 L = lv.xyz;
+    vec3 radiance = lr.rgb;
+    if (lv.w > 0.5) {
+      vec3 toLight = lv.xyz - v_world;
+      float d = max(length(toLight), 1e-4);
+      L = toLight / d;
+      // r185 getDistanceAttenuation (decay 2): inverse square, range cutoff.
+      float att = 1.0 / max(d * d, 0.01);
+      if (lr.w > 0.0) { float x = clamp(1.0 - pow(d / lr.w, 4.0), 0.0, 1.0); att *= x * x; }
+      radiance *= att;
+    }
+    lit += a3dDecalDirect(albedo.rgb, N, V, normalize(L), radiance, alphaR);
+  }
+  ${d.fog ? "lit = a3dApplyFog(lit, v_world);" : ""}
+
+  float alpha = albedo.a * angleFade * distFade;
+  ${d.multiply
+    ? `// C-04 stub: multiply grime → alpha-over with black at 1−luminance.
+  float lum = dot(lit, vec3(0.2126, 0.7152, 0.0722));
+  o_color = vec4(lit * lum, alpha);`
+    : "o_color = vec4(lit, alpha);"}
+}
+`;
+export function decalVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function decalFragmentSource(defines) {
+    return `#version 300 es\n${FRAG(defines)}`;
+}
+export function decalProgramKey(defines) {
+    return `prd07.decal.${defines.albedoTexture ? 1 : 0}${defines.normalTexture ? 1 : 0}${defines.multiply ? 1 : 0}${defines.fog ? 1 : 0}`;
+}
+//# sourceMappingURL=decal.glsl.js.map

package/dist/vfx/shaders/decal.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decal.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/decal.glsl.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,2EAA2E;AAC3E,6EAA6E;AAC7E,gDAAgD;AAChD,6EAA6E;AAC7E,sEAAsE;AACtE,0EAA0E;AAC1E,uEAAuE;AACvE,EAAE;AACF,yEAAyE;AACzE,2CAA2C;AAC3C,gBAAgB;AAEhB,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAYpD,MAAM,IAAI,GAAG;KACR,mBAAmB;;;;;;;;;;;;;;;;;;;;CAoBvB,CAAC;AAEF,MAAM,IAAI,GAAG,CAAC,CAAsB,EAAU,EAAE,CAAC;KAC5C,mBAAmB;;;;;;;;EAQtB,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,6BAA6B,CAAC,CAAC,CAAC,EAAE;EACpD,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;EAgBvD,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjB,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,WAAW;;;;;;;IAOvE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;;;;;;;;IAQlB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgCL,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC,EAAE;;;IAG/C,CAAC,CAAC,QAAQ;IACV,CAAC,CAAC;;oCAE8B;IAChC,CAAC,CAAC,6BAA6B;;CAElC,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC/B,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,OAA4B;IAC9D,OAAO,oBAAoB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,OAA4B;IAC1D,OAAO,eAAe,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACzI,CAAC"}

package/dist/vfx/shaders/gpu-sim.glsl.d.ts

@@ -0,0 +1,5 @@
+export declare const PRD07_GPU_SIM_MARKER = "a3d_prd07_gpu_sim";
+export declare function gpuSimVertexSource(): string;
+export declare function gpuSimPositionFragmentSource(): string;
+export declare function gpuSimVelocityFragmentSource(): string;
+//# sourceMappingURL=gpu-sim.glsl.d.ts.map

package/dist/vfx/shaders/gpu-sim.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-sim.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/gpu-sim.glsl.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAuKxD,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAErD"}

package/dist/vfx/shaders/gpu-sim.glsl.js

@@ -0,0 +1,177 @@
+// PRD-07 P5-T1 — §8.3 GPU particle sim (WebGL2 ping-pong, GLSL ES 3.00).
+// Two single-target rgba32f passes per step until C-01/RenderTarget MRT lands
+// (§6.2.3): pass A writes the pos+age texture, pass B writes vel+seed. Both
+// read u_prevPos/u_prevVel and run the identical integration so A and B stay
+// in lockstep. One texel per particle; index = y * u_stateWidth + x.
+export const PRD07_GPU_SIM_MARKER = "a3d_prd07_gpu_sim";
+const VERT = `
+// ${PRD07_GPU_SIM_MARKER} vertex
+in vec2 a_pos;
+void main() {
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+const COMMON = `
+// ${PRD07_GPU_SIM_MARKER} shared
+precision highp float;
+uniform sampler2D u_prevPos;      // xyz = position, w = age
+uniform sampler2D u_prevVel;      // xyz = velocity, w = seed
+uniform float u_stateWidth;
+uniform float u_capacity;
+uniform float u_emitHead;         // ring head (texel index)
+uniform float u_emitCount;        // texels to (re)emit this step
+uniform float u_frame;
+uniform float u_seed;
+uniform float u_dt;
+uniform float u_time;
+uniform vec3 u_gravity;
+uniform vec3 u_wind;
+uniform float u_drag;
+uniform float u_noiseFreq;
+uniform float u_noiseScroll;
+uniform float u_noiseStrength;
+uniform float u_groundPlane;
+uniform float u_bounce;
+uniform float u_lifeLoss;
+uniform float u_useHeightfield;
+uniform sampler2D u_heightfield;
+uniform float u_heightUvScale;
+uniform float u_heightMax;
+uniform float u_lifetimeMax;
+uniform vec3 u_emitOrigin;
+uniform vec3 u_emitDirection;
+uniform float u_emitSpread;
+uniform vec2 u_emitSpeed;
+uniform float u_emitDisc;         // spawn-disc radius (matches CpuEmitter 0.05)
+
+// uint hash → [0,1) — identical to the TS mirror (mulberry32-style round).
+uint a3dHash(uint x) {
+  x += 0x6d2b79f5u;
+  uint t = (x ^ (x >> 15u)) * (1u | x);
+  t = (t + ((t ^ (t >> 7u)) * (61u | t))) ^ t;
+  return (t ^ (t >> 14u));
+}
+float a3dRand01(uint h) {
+  return float(h) * (1.0 / 4294967296.0);
+}
+vec3 a3dRand3(uint h) {
+  return vec3(
+    a3dRand01(a3dHash(h)),
+    a3dRand01(a3dHash(h ^ 0x9e3779b9u)),
+    a3dRand01(a3dHash(h ^ 0x85ebca6bu))
+  );
+}
+
+// true when index is inside the ring slice [head, head+count) mod capacity.
+bool a3dInRing(int index, int head, int count, int capacity) {
+  int m = index - head;
+  if (m < 0) m += capacity;
+  return m >= 0 && m < count;
+}
+
+// 3D value noise (lattice hash + smoothstep trilinear). CPU mirror in
+// ParticleGpuSim.ts (a3dValueNoise) — keep constants identical.
+float a3dLattice(ivec3 c) {
+  // int lattice coords → uint hash (uint(float) of negatives is UB — keep int).
+  return a3dRand01(a3dHash(uint(c.x * 3 ^ c.y * 7 ^ c.z * 13)));
+}
+float a3dValueNoise(vec3 p) {
+  ivec3 ip = ivec3(floor(p));
+  vec3 fp = fract(p);
+  vec3 u = fp * fp * (3.0 - 2.0 * fp);
+  float n000 = a3dLattice(ip);
+  float n100 = a3dLattice(ip + ivec3(1, 0, 0));
+  float n010 = a3dLattice(ip + ivec3(0, 1, 0));
+  float n110 = a3dLattice(ip + ivec3(1, 1, 0));
+  float n001 = a3dLattice(ip + ivec3(0, 0, 1));
+  float n101 = a3dLattice(ip + ivec3(1, 0, 1));
+  float n011 = a3dLattice(ip + ivec3(0, 1, 1));
+  float n111 = a3dLattice(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) * 2.0 - 1.0;
+}
+
+// Curl of the vector noise field F = (N(p), N(p+o1), N(p+o2)), ε = 0.1.
+vec3 a3dCurlNoise(vec3 p) {
+  const float e = 0.1;
+  const vec3 o1 = vec3(31.416, -47.853, 12.793);
+  const vec3 o2 = vec3(-233.145, -11.719, 95.637);
+  float dFx_dz = (a3dValueNoise(p + vec3(0.0, 0.0, e)) - a3dValueNoise(p - vec3(0.0, 0.0, e))) / (2.0 * e);
+  float dFx_dy = (a3dValueNoise(p + vec3(0.0, e, 0.0)) - a3dValueNoise(p - vec3(0.0, e, 0.0))) / (2.0 * e);
+  float dFy_dx = (a3dValueNoise(p + o1 + vec3(e, 0.0, 0.0)) - a3dValueNoise(p + o1 - vec3(e, 0.0, 0.0))) / (2.0 * e);
+  float dFy_dz = (a3dValueNoise(p + o1 + vec3(0.0, 0.0, e)) - a3dValueNoise(p + o1 - vec3(0.0, 0.0, e))) / (2.0 * e);
+  float dFz_dx = (a3dValueNoise(p + o2 + vec3(e, 0.0, 0.0)) - a3dValueNoise(p + o2 - vec3(e, 0.0, 0.0))) / (2.0 * e);
+  float dFz_dy = (a3dValueNoise(p + o2 + vec3(0.0, e, 0.0)) - a3dValueNoise(p + o2 - vec3(0.0, e, 0.0))) / (2.0 * e);
+  return vec3(dFz_dy - dFy_dz, dFx_dz - dFz_dx, dFy_dx - dFx_dy);
+}
+
+float a3dSampleHeight(vec2 xz) {
+  return texture(u_heightfield, xz * u_heightUvScale).r * u_heightMax;
+}
+
+// Emit slot index (ring): origin disc + cone jitter + speed range.
+void a3dEmit(int index, inout vec4 pa, inout vec4 va) {
+  uint h = a3dHash(uint(index) ^ uint(u_seed) ^ uint(u_frame) * 0x9e3779b9u);
+  float r = a3dRand01(h);
+  vec3 jitter = (a3dRand3(h ^ 0x51ed270bu) - 0.5) * 2.0 * u_emitSpread;
+  vec3 dir = normalize(u_emitDirection + jitter);
+  float theta = a3dRand01(h ^ 0x27d4eb2fu) * 6.283185307;
+  pa = vec4(u_emitOrigin + vec3(cos(theta), 0.0, sin(theta)) * u_emitDisc, 0.0);
+  va = vec4(dir * mix(u_emitSpeed.x, u_emitSpeed.y, r), a3dRand01(h ^ 0x165667b1u));
+}
+
+// §8.3 step — identical math in both passes so pos/vel stay consistent.
+void a3dSimStep(ivec2 texel, inout vec4 pa, inout vec4 va) {
+  int index = int(float(texel.y) * u_stateWidth + float(texel.x));
+  if (a3dInRing(index, int(u_emitHead), int(u_emitCount), int(u_capacity))) {
+    a3dEmit(index, pa, va);
+  } else if (pa.w < u_lifetimeMax) {
+    vec3 acc = u_gravity + u_wind + a3dCurlNoise(pa.xyz * u_noiseFreq + u_time * u_noiseScroll) * u_noiseStrength;
+    va.xyz = (va.xyz + acc * u_dt) * exp(-u_drag * u_dt);
+    pa.xyz += va.xyz * u_dt;
+    pa.w += u_dt;
+    float ground = u_useHeightfield > 0.5 ? a3dSampleHeight(pa.xz) : u_groundPlane;
+    if (pa.y < ground) {
+      pa.y = ground;
+      va.y = -va.y * u_bounce;
+      va.xz *= 0.7;
+      pa.w += u_lifeLoss;
+    }
+  }
+}
+`;
+const FRAG_POS = `
+${COMMON}
+layout(location=0) out vec4 o_out;
+void main() {
+  ivec2 texel = ivec2(gl_FragCoord.xy);
+  vec4 pa = texelFetch(u_prevPos, texel, 0);
+  vec4 va = texelFetch(u_prevVel, texel, 0);
+  a3dSimStep(texel, pa, va);
+  o_out = pa;
+}
+`;
+const FRAG_VEL = `
+${COMMON}
+layout(location=0) out vec4 o_out;
+void main() {
+  ivec2 texel = ivec2(gl_FragCoord.xy);
+  vec4 pa = texelFetch(u_prevPos, texel, 0);
+  vec4 va = texelFetch(u_prevVel, texel, 0);
+  a3dSimStep(texel, pa, va);
+  o_out = va;
+}
+`;
+export function gpuSimVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function gpuSimPositionFragmentSource() {
+    return `#version 300 es\n${FRAG_POS}`;
+}
+export function gpuSimVelocityFragmentSource() {
+    return `#version 300 es\n${FRAG_VEL}`;
+}
+//# sourceMappingURL=gpu-sim.glsl.js.map

package/dist/vfx/shaders/gpu-sim.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-sim.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/vfx/shaders/gpu-sim.glsl.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,8EAA8E;AAC9E,4EAA4E;AAC5E,6EAA6E;AAC7E,qEAAqE;AAErE,MAAM,CAAC,MAAM,oBAAoB,GAAG,mBAAmB,CAAC;AAExD,MAAM,IAAI,GAAG;KACR,oBAAoB;;;;;CAKxB,CAAC;AAEF,MAAM,MAAM,GAAG;KACV,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkIxB,CAAC;AAEF,MAAM,QAAQ,GAAG;EACf,MAAM;;;;;;;;;CASP,CAAC;AAEF,MAAM,QAAQ,GAAG;EACf,MAAM;;;;;;;;;CASP,CAAC;AAEF,MAAM,UAAU,kBAAkB;IAChC,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO,oBAAoB,QAAQ,EAAE,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,OAAO,oBAAoB,QAAQ,EAAE,CAAC;AACxC,CAAC"}