@aura3d/rendering 3.0.1 → 4.0.2

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

@@ -0,0 +1,101 @@
+// PRD-07 P5-T5 — `a3d_prd07_wetness` chunk (§6.8, C-21 WETNESS_CHUNK).
+// Guarded by #define A3D_WETNESS (the prd07.wetness ShaderFeature emits it
+// when selected). Uniforms are global: u_wetness, u_puddleThreshold,
+// u_rainRipples (atlas frame), u_snowCover; the puddle mask is world-space
+// tiled noise thresholded by wet. While the C-02 program generator is a
+// stub the chunk is registered but never spliced — WETNESS_PENDING reports
+// once via noteWetnessPending().
+export const PRD07_WETNESS_CHUNK_GLSL = `
+// a3d_prd07_wetness — §6.8 wet-look material response.
+#ifdef A3D_WETNESS
+#ifndef A3D_PRD07_WETNESS_CHUNK
+#define A3D_PRD07_WETNESS_CHUNK
+uniform float u_wetness;          // global wetness [0,1] (AtmosphereWetness)
+uniform float u_puddleThreshold;  // noise threshold for puddles
+uniform float u_rainRipples;      // ripple flipbook frame; 0 = off
+uniform float u_snowCover;        // snow cover [0,1]
+uniform sampler2D u_puddleNoise;  // world-space tiled noise (u puddleNoise)
+
+// World-space puddle mask: tiled noise at worldPos.xz / 6 thresholded by wet.
+float a3dWetnessPuddle(vec3 worldPos, float wet) {
+  float n = texture(u_puddleNoise, worldPos.xz / 6.0).r;
+  return smoothstep(u_puddleThreshold, 1.0, n) * wet;
+}
+
+// §6.8: albedo *= mix(1, 0.55, wet·porosity); snow cover → snow white.
+vec3 a3dWetnessAlbedo(vec3 albedo, float porosity) {
+  float wet = clamp(u_wetness, 0.0, 1.0);
+  vec3 a = albedo * mix(1.0, 0.55, wet * clamp(porosity, 0.0, 1.0));
+  return mix(a, vec3(0.95, 0.96, 1.0), clamp(u_snowCover, 0.0, 1.0));
+}
+
+// §6.8: roughness = mix(roughness, 0.06, wet·puddle); snow cover → 0.9.
+float a3dWetnessRoughness(float roughness, vec3 worldPos) {
+  float wet = clamp(u_wetness, 0.0, 1.0);
+  float puddle = a3dWetnessPuddle(worldPos, wet);
+  float r = mix(roughness, 0.06, clamp(wet * puddle, 0.0, 1.0));
+  return mix(r, 0.9, clamp(u_snowCover, 0.0, 1.0));
+}
+#endif // A3D_PRD07_WETNESS_CHUNK
+#endif // A3D_WETNESS
+`;
+export 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 const PRD07_WETNESS_APPLY_CHUNK_GLSL = `
+#ifdef A3D_WETNESS
+  material.baseColor = a3dWetnessAlbedo(material.baseColor, 1.0);
+  material.diffuseContribution = material.baseColor * (1.0 - material.metallic);
+  material.specularColorBlended = mix(material.specularColor, material.baseColor, material.metallic);
+  material.roughness = clamp(a3dWetnessRoughness(material.roughness, v_worldPosition), 0.0525, 1.0);
+#endif
+`;
+let wetnessState = {
+    wetness: 0,
+    puddleThreshold: 0.62,
+    rainRipples: 0,
+    snowCover: 0,
+    puddleNoise: null
+};
+let wetnessPendingNoted = false;
+/** Called when the wetness feature selected but couldn't splice (stub gen). */
+export function noteWetnessPending() {
+    if (wetnessPendingNoted)
+        return null;
+    wetnessPendingNoted = true;
+    return "WETNESS_PENDING";
+}
+/** Test hook. */
+export function resetWetnessPending() {
+    wetnessPendingNoted = false;
+}
+export function setPrd07WetnessState(state) {
+    wetnessState = { ...wetnessState, ...state };
+}
+export function prd07WetnessState() {
+    return wetnessState;
+}
+/**
+ * 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 function applyWetnessMaterialCpu(albedo, roughness, wet, porosity, puddle, snowCover = 0) {
+    const w = Math.min(1, Math.max(0, wet));
+    const por = Math.min(1, Math.max(0, porosity));
+    const snow = Math.min(1, Math.max(0, snowCover));
+    const wetFactor = 1 + (0.55 - 1) * w * por;
+    const wetRough = roughness + (0.06 - roughness) * Math.min(1, Math.max(0, w * puddle));
+    const a = albedo.map((c) => c * wetFactor);
+    const snowed = a.map((c, i) => c + ([0.95, 0.96, 1.0][i] - c) * snow);
+    return {
+        albedo: [snowed[0], snowed[1], snowed[2]],
+        roughness: wetRough + (0.9 - wetRough) * snow
+    };
+}
+//# sourceMappingURL=wetness.glsl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wetness.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/atmosphere/shaders/wetness.glsl.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,2EAA2E;AAC3E,qEAAqE;AACrE,2EAA2E;AAC3E,wEAAwE;AACxE,2EAA2E;AAC3E,iCAAiC;AAIjC,MAAM,CAAC,MAAM,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,mBAAmB,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG;;;;;;;CAO7C,CAAC;AAgBF,IAAI,YAAY,GAAwB;IACtC,OAAO,EAAE,CAAC;IACV,eAAe,EAAE,IAAI;IACrB,WAAW,EAAE,CAAC;IACd,SAAS,EAAE,CAAC;IACZ,WAAW,EAAE,IAAI;CAClB,CAAC;AAEF,IAAI,mBAAmB,GAAG,KAAK,CAAC;AAEhC,+EAA+E;AAC/E,MAAM,UAAU,kBAAkB;IAChC,IAAI,mBAAmB;QAAE,OAAO,IAAI,CAAC;IACrC,mBAAmB,GAAG,IAAI,CAAC;IAC3B,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,iBAAiB;AACjB,MAAM,UAAU,mBAAmB;IACjC,mBAAmB,GAAG,KAAK,CAAC;AAC9B,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAmC;IACtE,YAAY,GAAG,EAAE,GAAG,YAAY,EAAE,GAAG,KAAK,EAAE,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,MAAyC,EACzC,SAAiB,EACjB,GAAW,EACX,QAAgB,EAChB,MAAc,EACd,SAAS,GAAG,CAAC;IAEb,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IACxC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;IAC3C,MAAM,QAAQ,GAAG,SAAS,GAAG,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;IACvF,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAW,CAAC,CAAC,CAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAClF,OAAO;QACL,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAE,EAAE,MAAM,CAAC,CAAC,CAAE,EAAE,MAAM,CAAC,CAAC,CAAE,CAAC;QAC5C,SAAS,EAAE,QAAQ,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,GAAG,IAAI;KAC9C,CAAC;AACJ,CAAC"}

package/dist/atmosphere/sky.glsl.d.ts

@@ -0,0 +1,8 @@
+import { type ShaderChunk } from "../contracts/program.js";
+import type { SkyProgramDefines } from "./SkyEval.js";
+export declare const SKY_SHADER_MARKER = "aura3d.prd07.sky";
+export declare function skyVertexSource(): string;
+export declare function skyFragmentSource(d: SkyProgramDefines): string;
+export declare const SKY_CHUNKS: readonly ShaderChunk[];
+export declare function registerSkyChunks(): void;
+//# sourceMappingURL=sky.glsl.d.ts.map

package/dist/atmosphere/sky.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.glsl.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/atmosphere/sky.glsl.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAGnD,eAAO,MAAM,iBAAiB,qBAAqB,CAAC;AAiOpD,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAM9D;AAED,eAAO,MAAM,UAAU,EAAE,SAAS,WAAW,EAG5C,CAAC;AAEF,wBAAgB,iBAAiB,IAAI,IAAI,CAQxC"}

package/dist/atmosphere/sky.glsl.js

@@ -0,0 +1,249 @@
+// PRD-07 P3 — sky background program (GLSL ES 3.00).
+// Fragment mirrors the CPU evaluators in PreethamSky.ts / GradientSky.ts so
+// `horizonRadiance` (CPU) and rendered pixels agree within f32 tolerance.
+import { registerShaderChunk } from "../contracts/program.js";
+import { PRD07_FOG_CHUNK_GLSL } from "./shaders/fog.glsl.js";
+export const SKY_SHADER_MARKER = "aura3d.prd07.sky";
+/** Where skyFragmentSource splices the §8.4 fog chunk (inside `#if SKY_FOG`). */
+const SKY_FOG_CHUNK_SLOT = "// @a3d-prd07-sky-fog-chunk";
+const VERT = `
+// ${SKY_SHADER_MARKER} vertex
+in vec2 a_pos;
+out vec2 v_clip;
+void main() {
+  v_clip = a_pos;
+  gl_Position = vec4(a_pos, 0.999999, 1.0); // at far plane
+}
+`;
+const FRAG = `
+// ${SKY_SHADER_MARKER} fragment
+precision highp float;
+uniform mat4 u_invViewProj;
+uniform vec3 u_sunDirection;
+uniform float u_sunE;
+uniform float u_sunfade;
+uniform vec3 u_betaR;
+uniform vec3 u_betaM;
+uniform float u_mieDirectionalG;
+uniform vec3 u_zenith;
+uniform vec3 u_horizon;
+uniform vec3 u_ground;
+uniform float u_exponent;
+uniform float u_horizonGlow;
+uniform float u_intensity;
+uniform int u_bandCount;
+uniform vec4 u_bandParams[4];  // xyz: elevationDeg, widthDeg, intensity
+uniform vec3 u_bandColors[4];
+uniform float u_showSunDisc;
+uniform float u_time;
+uniform float u_starDensity;
+uniform float u_starIntensity;
+uniform float u_cloudCoverage;
+uniform float u_cloudDensity;
+uniform float u_cloudElevation;
+uniform vec2 u_cloudScaleSpeed;
+uniform vec3 u_moonDirection;
+uniform vec3 u_moonColor;
+uniform float u_moonPhase;
+uniform float u_moonIntensity;
+uniform float u_moonAngularCos;  // cos(moon angular radius) for the disc
+
+in vec2 v_clip;
+layout(location=0) out vec4 o_color;
+
+const float PI = 3.141592653589793238462643383279502884197169;
+const float RAYLEIGH_ZENITH = 8.4E3;
+const float MIE_ZENITH = 1.25E3;
+const float SUN_ANGULAR_DIAMETER_COS = 0.999956676946448443553574619906976478926848692873900859324;
+const float THREE_OVER_SIXTEEN_PI = 0.05968310365946075;
+const float ONE_OVER_FOUR_PI = 0.07957747154594767;
+const vec3 UP = vec3(0.0, 1.0, 0.0);
+
+float rayleighPhase(float c) { return THREE_OVER_SIXTEEN_PI * (1.0 + c * c); }
+float hgPhase(float c, float g) {
+  float g2 = g * g;
+  return ONE_OVER_FOUR_PI * ((1.0 - g2) / pow(1.0 - 2.0 * g * c + g2, 1.5));
+}
+float hash2(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123); }
+float vnoise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  float a = hash2(i);
+  float b = hash2(i + vec2(1.0, 0.0));
+  float c = hash2(i + vec2(0.0, 1.0));
+  float d = hash2(i + vec2(1.0, 1.0));
+  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+float fbm(vec2 p) {
+  float v = 0.0;
+  float a = 0.5;
+  for (int i = 0; i < 5; i++) { v += a * vnoise(p); p *= 2.0; a *= 0.5; }
+  return v;
+}
+
+vec3 preetham(vec3 direction) {
+  float zenithAngle = acos(max(0.0, dot(UP, direction)));
+  float inverse = 1.0 / (cos(zenithAngle) + 0.15 * pow(93.885 - (zenithAngle * 180.0) / PI, -1.253));
+  float sR = RAYLEIGH_ZENITH * inverse;
+  float sM = MIE_ZENITH * inverse;
+  vec3 Fex = exp(-(u_betaR * sR + u_betaM * sM));
+  float cosTheta = dot(direction, u_sunDirection);
+  float rP = rayleighPhase(cosTheta * 0.5 + 0.5);
+  vec3 betaRTheta = u_betaR * rP;
+  float mP = hgPhase(cosTheta, u_mieDirectionalG);
+  vec3 betaMTheta = u_betaM * mP;
+  vec3 ratio = (betaRTheta + betaMTheta) / (u_betaR + u_betaM);
+  vec3 Lin = pow(max(vec3(0.0), u_sunE * ratio * (1.0 - Fex)), vec3(1.5));
+  Lin *= mix(vec3(1.0), pow(max(vec3(0.0), u_sunE * ratio * Fex), vec3(0.5)),
+             clamp(pow(1.0 - dot(UP, u_sunDirection), 5.0), 0.0, 1.0));
+  vec3 L0 = vec3(0.1) * Fex;
+  float sundisc = smoothstep(SUN_ANGULAR_DIAMETER_COS, SUN_ANGULAR_DIAMETER_COS + 0.00002, cosTheta) * u_showSunDisc;
+  L0 += (u_sunE * 19000.0 * Fex) * sundisc;
+  vec3 texColor = (Lin + L0) * 0.04 + vec3(0.0, 0.0003, 0.00075);
+  if (direction.y < 0.0) {
+    float t = clamp(-direction.y * 4.0, 0.0, 1.0);
+    texColor = mix(texColor, u_ground * 0.04, t);
+  }
+  return texColor;
+}
+
+vec3 gradient(vec3 direction) {
+  float y = direction.y;
+  if (y >= 0.0) {
+    float t = pow(clamp(y, 0.0, 1.0), 1.0 / u_exponent);
+    float glow = u_horizonGlow * smoothstep(0.25, 0.0, abs(y));
+    vec3 c = mix(u_horizon, u_zenith, t) + glow * u_horizon;
+    float cdot = dot(direction, u_sunDirection);
+    float disc = smoothstep(0.9995, 0.9999, cdot);
+    float halo = pow(max(0.0, cdot), 350.0) * 0.6;
+    c += vec3(disc * 40.0 + halo, disc * 36.0 + halo * 0.9, disc * 30.0 + halo * 0.7);
+    if (u_bandCount > 0) {
+      float elev = degrees(asin(clamp(y, -1.0, 1.0)));
+      for (int i = 0; i < u_bandCount && i < 4; i++) {
+        vec4 b = u_bandParams[i];
+        float dy = elev - b.x;
+        float w = exp(-(dy * dy) / (b.y * b.y * 0.5)) * b.z;
+        c += u_bandColors[i] * w;
+      }
+    }
+    return c * u_intensity;
+  }
+  float t = clamp(-y * 3.0, 0.0, 1.0);
+  return mix(u_horizon, u_ground, t) * u_intensity;
+}
+
+vec3 moonDisc(vec3 direction) {
+  float c = dot(direction, u_moonDirection);
+  float disc = smoothstep(u_moonAngularCos, u_moonAngularCos + 0.00004, c);
+  // Phase: 0/1 = new (dark), 0.5 = full. Lit fraction is 1 - |2p - 1|.
+  float illumination = 1.0 - abs(2.0 * u_moonPhase - 1.0);
+  return u_moonColor * u_moonIntensity * illumination * 6.0 * disc;
+}
+
+float starfield(vec3 direction) {
+  if (u_starDensity <= 0.0) return 0.0;
+  // Equirect cell hash; a cell holds one star when hash < density*0.01.
+  float theta = acos(clamp(direction.y, -1.0, 1.0));
+  float phi = atan(direction.z, direction.x);
+  vec2 uv = vec2(phi / (2.0 * PI) + 0.5, theta / PI) * 512.0;
+  vec2 cell = floor(uv);
+  float h = hash2(cell);
+  if (h > u_starDensity * 0.01) return 0.0;
+  vec2 centre = cell + 0.5;
+  float d = length((uv - centre) / 0.5);
+  float star = smoothstep(0.5, 0.05, d);
+  float mag = 0.25 + 0.75 * hash2(cell + 17.0);
+  return star * mag * u_starIntensity;
+}
+
+#if SKY_FOG
+// P4-T7 — fog on the background: apply §8.4 a3dApplyFog at backgroundDistance.
+// A3D_PRD07_FOG_ENV_UNIFORMS is pre-defined so the chunk does not redeclare
+// u_sunDirection (bound by this program already); we provide camera/sunColor.
+uniform vec3 u_cameraPosition;
+uniform vec3 u_sunColor;
+uniform float u_fogBackgroundDistance;
+${SKY_FOG_CHUNK_SLOT}
+#endif
+
+void main() {
+  vec4 world4 = u_invViewProj * vec4(v_clip, 1.0, 1.0);
+  vec3 direction = normalize(world4.xyz / world4.w);
+  vec3 color = vec3(0.0);
+#if MODEL_PREETHAM
+  color = preetham(direction);
+#elif MODEL_GRADIENT
+  color = gradient(direction);
+#elif MODEL_COLOR
+  color = u_zenith;
+#else
+  color = vec3(0.0);
+#endif
+#if SKY_STARS
+  // Stars shine where the sky is dark (sunfade low = night).
+  color += vec3(starfield(direction)) * (1.0 - u_sunfade) * 2.0;
+#endif
+#if SKY_MOON
+  color += moonDisc(direction) * (1.0 - u_sunfade);
+#endif
+#if SKY_CLOUDS
+  if (direction.y > 0.0 && u_cloudCoverage > 0.0) {
+    float elevation = mix(1.0, 0.1, u_cloudElevation);
+    vec2 cloudUV = direction.xz / (direction.y * elevation) * u_cloudScaleSpeed.x;
+    cloudUV += u_time * u_cloudScaleSpeed.y;
+    float cloudNoise = fbm(cloudUV * 1000.0) + 0.5 * fbm(cloudUV * 2000.0 + 3.7);
+    cloudNoise = cloudNoise * 0.5 + 0.5;
+    float cloudMask = smoothstep(1.0 - u_cloudCoverage, 1.0 - u_cloudCoverage + 0.3, cloudNoise);
+    cloudMask *= smoothstep(0.0, 0.1 + 0.2 * u_cloudElevation, direction.y);
+    float sunInfluence = dot(direction, u_sunDirection) * 0.5 + 0.5;
+    float daylight = max(0.0, u_sunDirection.y * 2.0);
+    vec3 cloudColor = mix(vec3(0.3), vec3(1.0), daylight);
+    cloudColor = mix(cloudColor, color + vec3(1.0), sunInfluence * 0.5);
+    cloudColor *= u_sunE * 0.00002;
+    color = mix(color, cloudColor, cloudMask * u_cloudDensity);
+  }
+#endif
+#if SKY_FOG
+  color = a3dApplyFog(color, u_cameraPosition + direction * u_fogBackgroundDistance);
+#endif
+  o_color = vec4(color, 1.0);
+}
+`;
+function defines(d) {
+    // Every macro read by `#if` is defined (0/1): an undefined identifier in an
+    // ESSL 3.00 `#if` is a compile error, which broke gradient/colour skies.
+    return (`#define MODEL_PREETHAM ${d.model === "PREETHAM" ? 1 : 0}\n` +
+        `#define MODEL_GRADIENT ${d.model === "GRADIENT" ? 1 : 0}\n` +
+        `#define MODEL_COLOR ${d.model === "COLOR" ? 1 : 0}\n` +
+        `${d.stars ? "#define SKY_STARS 1\n" : "#define SKY_STARS 0\n"}` +
+        `${d.clouds ? "#define SKY_CLOUDS 1\n" : "#define SKY_CLOUDS 0\n"}` +
+        `${d.moon ? "#define SKY_MOON 1\n" : "#define SKY_MOON 0\n"}` +
+        `${d.fog ? "#define SKY_FOG 1\n#define A3D_PRD07_FOG_ENV_UNIFORMS 1\n" : "#define SKY_FOG 0\n"}`);
+}
+export function skyVertexSource() {
+    return `#version 300 es\n${VERT}`;
+}
+export function skyFragmentSource(d) {
+    // The fog chunk is spliced into the SKY_FOG block, after this program's
+    // precision statement and its camera/sun uniforms: prepended before FRAG
+    // it hit "no default precision" and used u_cameraPosition before its
+    // declaration, so every fogged sky failed to compile on WebGL2.
+    return `#version 300 es\n${defines(d)}${FRAG.replace(SKY_FOG_CHUNK_SLOT, d.fog ? PRD07_FOG_CHUNK_GLSL : "")}`;
+}
+export const SKY_CHUNKS = [
+    { name: "a3d_prd07_sky_vertex", owner: "prd07", stage: "vertex", glsl: VERT },
+    { name: "a3d_prd07_sky_fragment", owner: "prd07", stage: "fragment", glsl: FRAG }
+];
+export function registerSkyChunks() {
+    for (const chunk of SKY_CHUNKS) {
+        try {
+            registerShaderChunk(chunk);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message.startsWith("SHADER_CHUNK_DUPLICATE")))
+                throw error;
+        }
+    }
+}
+//# sourceMappingURL=sky.glsl.js.map

package/dist/atmosphere/sky.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.glsl.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/atmosphere/sky.glsl.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,4EAA4E;AAC5E,0EAA0E;AAE1E,OAAO,EAAE,mBAAmB,EAAoB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,MAAM,CAAC,MAAM,iBAAiB,GAAG,kBAAkB,CAAC;AAEpD,iFAAiF;AACjF,MAAM,kBAAkB,GAAG,6BAA6B,CAAC;AAEzD,MAAM,IAAI,GAAG;KACR,iBAAiB;;;;;;;CAOrB,CAAC;AAEF,MAAM,IAAI,GAAG;KACR,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoJpB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CnB,CAAC;AAEF,SAAS,OAAO,CAAC,CAAoB;IACnC,4EAA4E;IAC5E,yEAAyE;IACzE,OAAO,CACL,0BAA0B,CAAC,CAAC,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;QAC5D,0BAA0B,CAAC,CAAC,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;QAC5D,uBAAuB,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;QACtD,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,uBAAuB,EAAE;QAChE,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,wBAAwB,EAAE;QACnE,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,sBAAsB,EAAE;QAC7D,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,2DAA2D,CAAC,CAAC,CAAC,qBAAqB,EAAE,CACjG,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,oBAAoB,IAAI,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,CAAoB;IACpD,wEAAwE;IACxE,yEAAyE;IACzE,qEAAqE;IACrE,gEAAgE;IAChE,OAAO,oBAAoB,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AAChH,CAAC;AAED,MAAM,CAAC,MAAM,UAAU,GAA2B;IAChD,EAAE,IAAI,EAAE,sBAAsB,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE;IAC7E,EAAE,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;CAClF,CAAC;AAEF,MAAM,UAAU,iBAAiB;IAC/B,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;QAC/B,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/batching/BatchedGeometryPool.d.ts

@@ -0,0 +1,72 @@
+/**
+ * PRD 11 Phase 3 (§6.6 layer 3) — `BatchedGeometryPool` packs many same-layout
+ * `Geometry` objects into one shared vertex arena and one shared index arena so
+ * a `WEBGL_multi_draw` call (or the `u_drawId` uniform-loop fallback) can issue
+ * every member draw against a single buffer pair. Index values are rebased by
+ * each member's `baseVertex` so a packed index stream addresses the arena
+ * directly; `firstIndex` is the element offset into the shared index buffer.
+ *
+ * The pool is a pure CPU structure until `upload(device)` materializes the
+ * arenas once per build — buffers are never re-uploaded per frame.
+ */
+import type { Geometry } from "../Geometry.js";
+import type { RenderBuffer, RenderDevice } from "../RenderDevice.js";
+import type { VertexFormat } from "../VertexFormat.js";
+export interface PackedGeometryEntry {
+    readonly geometry: Geometry;
+    /** First element index of this member inside the shared index arena. */
+    readonly firstIndex: number;
+    readonly indexCount: number;
+    /** Vertex offset applied to every packed index (and used as `firstVertex` when unindexed). */
+    readonly baseVertex: number;
+    readonly vertexCount: number;
+    /** Element type after unification — `uint32` when any member needed it. */
+    readonly indexType: "uint16" | "uint32";
+}
+export declare class BatchedGeometryPool {
+    private vertexFloats;
+    private indexData;
+    private entries;
+    private totalVertices;
+    private format;
+    private vertexArena;
+    private indexArena;
+    private dirty;
+    /** Set when any packed member needed 32-bit indices. */
+    private needsUint32;
+    /** Device that performed the last `upload`, for context-restore rebuild. */
+    private lastDevice;
+    private restoreRegistered;
+    /**
+     * Appends `geometry` to the arenas. Every member must share the vertex
+     * format and indexed/non-indexed shape — the planner groups by
+     * `vertexLayoutKey` before calling this.
+     */
+    pack(geometry: Geometry): PackedGeometryEntry;
+    entryFor(geometry: Geometry): PackedGeometryEntry | undefined;
+    /** One upload per build; subsequent calls return the live arenas. */
+    upload(device: RenderDevice): {
+        vertexBuffer: RenderBuffer;
+        indexBuffer: RenderBuffer | null;
+        indexType: "uint16" | "uint32";
+    };
+    /**
+     * PRD 11 Phase 5 (§6.9): register with the C-29 `ResourceRegistry` once.
+     * The CPU-side `vertexFloats`/`indexData` arrays are the retained source —
+     * rebuild marks the arenas dirty and re-uploads on the last device.
+     */
+    registerForRestore(registry: {
+        register<T extends object>(handle: T, descriptor: {
+            kind: string;
+            rebuild: () => Promise<void> | void;
+        }): T;
+    }): void;
+    get vertexFormat(): VertexFormat | null;
+    stats(): {
+        geometries: number;
+        vertexFloats: number;
+        indexElements: number;
+    };
+    dispose(): void;
+}
+//# sourceMappingURL=BatchedGeometryPool.d.ts.map

package/dist/batching/BatchedGeometryPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchedGeometryPool.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/batching/BatchedGeometryPool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,8FAA8F;IAC9F,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACzC;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,KAAK,CAAS;IACtB,wDAAwD;IACxD,OAAO,CAAC,WAAW,CAAS;IAC5B,4EAA4E;IAC5E,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,iBAAiB,CAAS;IAElC;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB;IAwC7C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,GAAG,SAAS;IAO7D,qEAAqE;IACrE,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG;QAAE,YAAY,EAAE,YAAY,CAAC;QAAC,WAAW,EAAE,YAAY,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;KAAE;IAmB9H;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;SAAE,GAAG,CAAC,CAAA;KAAE,GAAG,IAAI;IAanJ,IAAI,YAAY,IAAI,YAAY,GAAG,IAAI,CAEtC;IAED,KAAK,IAAI;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE;IAI5E,OAAO,IAAI,IAAI;CAahB"}

package/dist/batching/BatchedGeometryPool.js

@@ -0,0 +1,138 @@
+/**
+ * PRD 11 Phase 3 (§6.6 layer 3) — `BatchedGeometryPool` packs many same-layout
+ * `Geometry` objects into one shared vertex arena and one shared index arena so
+ * a `WEBGL_multi_draw` call (or the `u_drawId` uniform-loop fallback) can issue
+ * every member draw against a single buffer pair. Index values are rebased by
+ * each member's `baseVertex` so a packed index stream addresses the arena
+ * directly; `firstIndex` is the element offset into the shared index buffer.
+ *
+ * The pool is a pure CPU structure until `upload(device)` materializes the
+ * arenas once per build — buffers are never re-uploaded per frame.
+ */
+export class BatchedGeometryPool {
+    vertexFloats = [];
+    indexData = [];
+    entries = new Map();
+    totalVertices = 0;
+    format = null;
+    vertexArena = null;
+    indexArena = null;
+    dirty = false;
+    /** Set when any packed member needed 32-bit indices. */
+    needsUint32 = false;
+    /** Device that performed the last `upload`, for context-restore rebuild. */
+    lastDevice = null;
+    restoreRegistered = false;
+    /**
+     * Appends `geometry` to the arenas. Every member must share the vertex
+     * format and indexed/non-indexed shape — the planner groups by
+     * `vertexLayoutKey` before calling this.
+     */
+    pack(geometry) {
+        const existing = this.entries.get(geometry);
+        if (existing)
+            return existing;
+        const floats = geometry.vertexBuffer.floats;
+        const strideFloats = Math.max(1, geometry.vertexBuffer.format.stride >> 2);
+        if (this.format === null)
+            this.format = geometry.vertexBuffer.format;
+        const baseVertex = this.totalVertices;
+        const vertexBase = this.vertexFloats.length;
+        for (let i = 0; i < geometry.vertexBuffer.vertexCount * strideFloats; i += 1) {
+            this.vertexFloats.push(floats[i] ?? 0);
+        }
+        void vertexBase;
+        let entry;
+        if (geometry.indexBuffer) {
+            const data = geometry.indexBuffer.data;
+            if (geometry.indexBuffer.type === "uint32" || baseVertex + geometry.vertexBuffer.vertexCount > 0xffff) {
+                this.needsUint32 = true;
+            }
+            const firstIndex = this.indexData.length;
+            for (let i = 0; i < data.length; i += 1) {
+                this.indexData.push(data[i] + baseVertex);
+            }
+            entry = {
+                geometry, firstIndex, indexCount: data.length,
+                baseVertex, vertexCount: geometry.vertexBuffer.vertexCount,
+                indexType: "uint16" // final type resolved at upload (needsUint32 upgrades all)
+            };
+        }
+        else {
+            entry = {
+                geometry, firstIndex: -1, indexCount: 0,
+                baseVertex, vertexCount: geometry.vertexBuffer.vertexCount,
+                indexType: "uint16"
+            };
+        }
+        this.entries.set(geometry, entry);
+        this.totalVertices += geometry.vertexBuffer.vertexCount;
+        this.dirty = true;
+        return entry;
+    }
+    entryFor(geometry) {
+        const entry = this.entries.get(geometry);
+        return entry
+            ? { ...entry, indexType: this.needsUint32 ? "uint32" : entry.indexType }
+            : undefined;
+    }
+    /** One upload per build; subsequent calls return the live arenas. */
+    upload(device) {
+        this.lastDevice = device;
+        if (!this.dirty && this.vertexArena) {
+            return { vertexBuffer: this.vertexArena, indexBuffer: this.indexArena, indexType: this.needsUint32 ? "uint32" : "uint16" };
+        }
+        this.vertexArena?.dispose();
+        this.indexArena?.dispose();
+        const vertexData = new Float32Array(this.vertexFloats);
+        this.vertexArena = device.createBuffer("vertex", vertexData.byteLength, vertexData);
+        if (this.indexData.length > 0) {
+            const indexData = this.needsUint32 ? new Uint32Array(this.indexData) : new Uint16Array(this.indexData);
+            this.indexArena = device.createBuffer("index", indexData.byteLength, indexData);
+        }
+        else {
+            this.indexArena = null;
+        }
+        this.dirty = false;
+        return { vertexBuffer: this.vertexArena, indexBuffer: this.indexArena, indexType: this.needsUint32 ? "uint32" : "uint16" };
+    }
+    /**
+     * PRD 11 Phase 5 (§6.9): register with the C-29 `ResourceRegistry` once.
+     * The CPU-side `vertexFloats`/`indexData` arrays are the retained source —
+     * rebuild marks the arenas dirty and re-uploads on the last device.
+     */
+    registerForRestore(registry) {
+        if (this.restoreRegistered)
+            return;
+        this.restoreRegistered = true;
+        registry.register(this, {
+            kind: "a3d-prd11-geometry-pool",
+            rebuild: () => {
+                if (!this.lastDevice)
+                    return;
+                this.dirty = true;
+                this.upload(this.lastDevice);
+            }
+        });
+    }
+    get vertexFormat() {
+        return this.format;
+    }
+    stats() {
+        return { geometries: this.entries.size, vertexFloats: this.vertexFloats.length, indexElements: this.indexData.length };
+    }
+    dispose() {
+        this.vertexArena?.dispose();
+        this.indexArena?.dispose();
+        this.vertexArena = null;
+        this.indexArena = null;
+        this.vertexFloats = [];
+        this.indexData = [];
+        this.entries.clear();
+        this.totalVertices = 0;
+        this.needsUint32 = false;
+        this.format = null;
+        this.dirty = false;
+    }
+}
+//# sourceMappingURL=BatchedGeometryPool.js.map

package/dist/batching/BatchedGeometryPool.js.map

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

package/dist/batching/ContentKeys.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PRD 11 Phase 3 (§6.6 layer 1) — content-keyed dedupe keys the renderer can
+ * trust. The engine compiler creates a unique `Geometry` and `Material` per
+ * primitive node (lane 15, `compiler/primitives.ts`); identical primitive
+ * instances therefore miss every identity-based merge. These keys recover
+ * value equality:
+ *
+ * - `geometryContentKey(geometry)` — the C-07 primitive/tessellation
+ *   descriptor when one was stamped on the geometry, else a hash of vertex
+ *   count, index count and a strided sample of the position/normal/uv data,
+ *   memoised per `Geometry` in a `WeakMap` and verified by a full-array
+ *   compare on the first collision (a collision between unequal arrays yields
+ *   different keys).
+ * - `materialSpecKey(material)` — stable key over every scalar field and
+ *   texture identity, excluding `baseColor`, `emissive`/`emissiveIntensity`
+ *   and `opacity` (when ≥ 0.999): per-node colour and emissive ride
+ *   `RenderItem.instanceColors`/`instanceEmissive` instead, so materials that
+ *   differ only there still merge.
+ *
+ * Both are pure functions; no GPU work happens here.
+ */
+import type { Geometry } from "../Geometry.js";
+import type { RenderMaterial } from "../ForwardPass.js";
+import type { UniformValue } from "../RenderDevice.js";
+/** True when `name` is a colour/emissive slot or an opacity slot equal to 1. */
+export declare function materialKeyExcludesParameter(name: string, parameters: ReadonlyMap<string, UniformValue>): boolean;
+export declare function materialSpecKey(material: RenderMaterial): string;
+export declare function geometryContentKey(geometry: Geometry): string;
+//# sourceMappingURL=ContentKeys.d.ts.map

package/dist/batching/ContentKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContentKeys.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/batching/ContentKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AA0EpD,gFAAgF;AAChF,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,OAAO,CAQjH;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAqBhE;AAmDD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAsC7D"}