@aura3d/engine 3.0.0 → 4.0.0

package/dist/rendering/shaders/chunks/lighting_mirrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_mirrors.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_mirrors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,oDAAoD;AACpD,MAAM,UAAU,kBAAkB,CAAC,aAAqB,EAAE,cAAsB,EAAE,aAAqB;IACrG,MAAM,eAAe,GAAG,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,IAAI,CAAC,CAAC;IACrF,IAAI,cAAc,GAAG,GAAG,EAAE,CAAC;QACzB,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,cAAc,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAC5F,OAAO,eAAe,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,eAAe,CAAC;AACzB,CAAC;AAED,MAAM,IAAI,GAAG,CAAC,CAAK,EAAE,CAAK,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,MAAM,SAAS,GAAG,CAAC,CAAK,EAAM,EAAE;IAC9B,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC5C,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CACrC,QAAY,EACZ,WAAe,EACf,SAAa,EACb,MAAU;IAEV,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,GAAG,GAAG,CAAC;IACpE,OAAO;QACL,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QACnD,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QACnD,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;KACpD,CAAC;AACJ,CAAC"}

package/dist/rendering/shaders/chunks/lighting_punctual.glsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * a3d_prd02_lighting_punctual — punctual light evaluation (PRD-02 §6.3/§8).
+ * Units are physical: point/spot intensities are candela, directional is
+ * lux (dimensionless in shader), decay exponent applies 1/d^decay with the
+ * Frostbite window saturate(1−(d/range)⁴)² when range > 0.
+ *
+ * Light data lives in the `AuraLights` std140 block (u_lightData, 32×6
+ * vec4 — 3KB). Per-light layout:
+ *   [0] position.xyz,     w = kind (0 dir, 1 point, 2 spot, 3 rect)
+ *   [1] direction.xyz,    w = range (0 = infinite)
+ *   [2] color.rgb,        w = intensity
+ *   [3] spot: cosOuter, cosInner, decay, shadowIndex
+ *   [4] shadow matrix column a (rect: right.xyz, width)
+ *   [5] shadow matrix column b (rect: up.xyz, height)
+ */
+export declare const LIGHTING_PUNCTUAL_CHUNK_GLSL = "\n#ifndef A3D_MAX_LIGHTS\n#define A3D_MAX_LIGHTS 32\n#endif\nuniform int u_prd02LightCount;\n// AuraLights std140 block, flattened for WebGL2 (PRD-02 \u00A78.1): 6 vec4 per light.\nuniform vec4 u_lightData[A3D_MAX_LIGHTS * 6];\n\n// Frostbite range window \u2014 only applies when range > 0.\nfloat a3d_rangeWindow(float d, float range) {\n  if (range <= 0.0) return 1.0;\n  float x = clamp(1.0 - pow(d / range, 4.0), 0.0, 1.0);\n  return x * x;\n}\n\n// three r185 getDistanceAttenuation verbatim (Frostbite E[window1]):\n// 1/max(d^decay, 0.01) with the range window folded in when range > 0.\nfloat a3dDistanceFalloff(float d, float range, float decay) {\n  float att = 1.0 / max(pow(d, decay), 0.01);\n  return att * a3d_rangeWindow(d, range);\n}\n\n// Spot cone: smooth falloff between cosOuter and cosInner angles.\nfloat a3d_spotWindow(float cosLightDir, float cosOuter, float cosInner) {\n  float w = clamp((cosLightDir - cosOuter) / max(cosInner - cosOuter, 1e-4), 0.0, 1.0);\n  return w * w;\n}\n\n// Fetch helper \u2014 per-light record base index.\nint a3d_lightBase(int i) { return i * 6; }\n\n// Incident radiance contribution of punctual light i at worldPos with\n// surface normal n. Shadow factor is applied by the caller.\nvec3 a3d_punctualRadiance(int i, vec3 worldPos, vec3 n, out vec3 l, out float atten) {\n  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];\n  vec4 d1 = u_lightData[a3d_lightBase(i) + 1];\n  vec4 d2 = u_lightData[a3d_lightBase(i) + 2];\n  int kind = int(d0.w + 0.5);\n  vec3 lightColor = d2.rgb * d2.w;\n  if (kind == 0) {\n    l = -normalize(d1.xyz);\n    atten = 1.0;\n    return lightColor * max(dot(n, l), 0.0);\n  }\n  vec3 toLight = d0.xyz - worldPos;\n  float d = length(toLight);\n  l = toLight / max(d, 1e-4);\n  vec4 d3 = u_lightData[a3d_lightBase(i) + 3];\n  atten = a3dDistanceFalloff(d, d1.w, d3.z);\n  if (kind == 2) {\n    float c = dot(-l, normalize(d1.xyz));\n    atten *= a3d_spotWindow(c, d3.x, d3.y);\n  }\n  return lightColor * max(dot(n, l), 0.0) * atten;\n}\n\n// Shadow factor for punctual light i (PRD-02 Phase 4): the composed program\n// must also #include a3d_prd02_shadow_lookup and define A3D_PUNCTUAL_SHADOWS\n// to activate it; otherwise this returns 1.0. Directional shadows come from\n// the CSM samplers; spot/point sample their atlas tile via shadowIndex\n// (u_lightData[i][3].w \u2014 the tile slot stamped by the shadow planner).\nfloat a3d_punctualShadowFactor(int i, vec3 worldPos, vec3 worldNormal, float viewDepth) {\n#if defined(A3D_PUNCTUAL_SHADOWS) && A3D_PUNCTUAL_SHADOWS\n  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];\n  int kind = int(d0.w + 0.5);\n  if (kind == 0) {\n    return a3d_sunShadow(worldPos, worldNormal, viewDepth);\n  }\n  if (kind == 1 || kind == 2) {\n    vec4 d3 = u_lightData[a3d_lightBase(i) + 3];\n    return a3d_localShadow(int(d3.w + 0.5), worldPos, worldNormal);\n  }\n#endif\n  return 1.0;\n}\n\n\n// ---- Area lights (rect, kind == 3) \u2014 PRD-02 \u00A78.5: LTC on High/Ultra\n// (A3D_AREA_LTC; LUTs u_prd02LtcMInv / u_prd02LtcFresnel, 64x64 RGBA16F,\n// fetched lazily from the three.js RectAreaLightTexturesLib tables, MIT),\n// Gauss\u2013Legendre 4-tap integrator on Low/Medium (A3D_AREA_GAUSS).\n// Rect layout in the AuraLights block: d0.xyz center, d4 = right.xyz+width,\n// d5 = up.xyz+height. Luminance in nits (d2.rgb).\n#if defined(A3D_AREA_LTC) && A3D_AREA_LTC\nuniform sampler2D u_prd02LtcMInv;\nuniform sampler2D u_prd02LtcFresnel;\n\nvec2 a3d_ltcUv(vec3 n, vec3 v, float roughness) {\n  float lod = roughness * roughness;\n  float theta = acos(clamp(dot(n, v), -1.0, 1.0)) / 3.14159265;\n  return vec2(lod, theta) * (63.0 / 64.0) + 0.5 / 64.0;\n}\n\nmat3 a3d_ltcMinv(vec2 uv) {\n  vec4 t = texture2D(u_prd02LtcMInv, uv);\n  return mat3(\n    vec3(1.0, 0.0, t.y),\n    vec3(0.0, t.z, 0.0),\n    vec3(t.w, 0.0, t.x));\n}\n\n// Edge-integral of a quad through LTC matrix M (Real-Time Polygonal-Light\n// Shading, Heitz et al.): sum of cross-edge arc cosines.\nfloat a3d_ltcEdgeIntegrate(mat3 Minv, vec3 n, vec3 v, vec3 p,\n                         vec3 c0, vec3 c1, vec3 c2, vec3 c3) {\n  vec3 vs[4];\n  vs[0] = Minv * (c0 - p); vs[1] = Minv * (c1 - p);\n  vs[2] = Minv * (c2 - p); vs[3] = Minv * (c3 - p);\n  for (int k = 0; k < 4; k++) vs[k] = normalize(vs[k]);\n  float sum = 0.0;\n  sum += a3d_ltcEdge(vs[0], vs[1]);\n  sum += a3d_ltcEdge(vs[1], vs[2]);\n  sum += a3d_ltcEdge(vs[2], vs[3]);\n  sum += a3d_ltcEdge(vs[3], vs[0]);\n  return max(sum, 0.0);\n}\n#endif\n\n#if (defined(A3D_AREA_LTC) && A3D_AREA_LTC) || (defined(A3D_AREA_GAUSS) && A3D_AREA_GAUSS)\n// Edge integral (Heitz et al. 2016): acos(dot) \u00D7 normalize(cross).z \u2014\n// the arc length weighted by its projection onto the shading normal's axis\n// in the transformed (identity-irradiance) space.\nfloat a3d_ltcEdge(vec3 v1, vec3 v2) {\n  float theta = acos(clamp(dot(v1, v2), -0.9999, 0.9999));\n  vec3 n = cross(v1, v2);\n  float nl = length(n);\n  if (nl < 1e-6) return 0.0;\n  return theta * (n.z / nl);\n}\n#endif\n\n// Gauss\u2013Legendre 4-tap: subdivide the rect into 4 quadrants; diffuse from\n// each quadrant centroid (a point light of area\u00B7luminance/4). Cheap on\n// Low/Medium; within ~10% total energy of the LTC integral (unit test).\nvec3 a3d_rectGaussDiffuse(vec3 center, vec3 right, vec3 up, vec2 halfSize,\n                          vec3 luminanceNits, vec3 worldPos, vec3 worldNormal) {\n  const float g = 0.25; // quadrant centroid offsets at \u00B1halfSize*0.5\n  vec3 acc = vec3(0.0);\n  for (int i = 0; i < 4; i++) {\n    vec3 c = center\n      + right * (halfSize.x * (i == 0 || i == 3 ? -g : g))\n      + up * (halfSize.y * (i < 2 ? -g : g));\n    vec3 toLight = c - worldPos;\n    float d2 = dot(toLight, toLight);\n    vec3 l = toLight * inversesqrt(max(d2, 1e-6));\n    float nl = max(dot(worldNormal, l), 0.0);\n    // Solid angle of the quadrant: A_quadrant\u00B7cos_s / d2 (small-aperture).\n    float area = halfSize.x * halfSize.y; // quadrant area = rect area /4\n    float cosS = max(dot(-l, normalize(cross(right, up))), 0.0);\n    acc += luminanceNits * (nl * area * cosS / max(d2, 1e-6));\n  }\n  return acc / 3.14159265;\n}\n\nvec3 a3d_rectLightDiffuse(int i, vec3 worldPos, vec3 worldNormal, vec3 viewDir, float roughness) {\n  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];\n  vec4 d2 = u_lightData[a3d_lightBase(i) + 2];\n  vec4 d4 = u_lightData[a3d_lightBase(i) + 4];\n  vec4 d5 = u_lightData[a3d_lightBase(i) + 5];\n  vec3 center = d0.xyz;\n  vec3 right = d4.xyz;\n  vec3 up = d5.xyz;\n  vec2 halfSize = vec2(d4.w, d5.w) * 0.5;\n#if defined(A3D_AREA_LTC) && A3D_AREA_LTC\n  vec3 c0 = center - right * halfSize.x - up * halfSize.y;\n  vec3 c1 = center + right * halfSize.x - up * halfSize.y;\n  vec3 c2 = center + right * halfSize.x + up * halfSize.y;\n  vec3 c3 = center - right * halfSize.x + up * halfSize.y;\n  // Diffuse irradiance = edge integral with the identity transform (the LUT\n  // path fits the GGX-specular distribution \u2014 specular evaluation arrives\n  // with the shading seam; diffuse is exact here).\n  float sum = a3d_ltcEdgeIntegrate(mat3(1.0), worldNormal, viewDir, worldPos, c0, c1, c2, c3);\n  return d2.rgb * (sum / (2.0 * 3.14159265));\n#elif defined(A3D_AREA_GAUSS) && A3D_AREA_GAUSS\n  return a3d_rectGaussDiffuse(center, right, up, halfSize, d2.rgb, worldPos, worldNormal);\n#else\n  return vec3(0.0);\n#endif\n}\n\n";
+//# sourceMappingURL=lighting_punctual.glsl.d.ts.map

package/dist/rendering/shaders/chunks/lighting_punctual.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_punctual.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_punctual.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,4BAA4B,2uOAoLxC,CAAC"}

package/dist/rendering/shaders/chunks/lighting_punctual.glsl.js

@@ -0,0 +1,197 @@
+/**
+ * a3d_prd02_lighting_punctual — punctual light evaluation (PRD-02 §6.3/§8).
+ * Units are physical: point/spot intensities are candela, directional is
+ * lux (dimensionless in shader), decay exponent applies 1/d^decay with the
+ * Frostbite window saturate(1−(d/range)⁴)² when range > 0.
+ *
+ * Light data lives in the `AuraLights` std140 block (u_lightData, 32×6
+ * vec4 — 3KB). Per-light layout:
+ *   [0] position.xyz,     w = kind (0 dir, 1 point, 2 spot, 3 rect)
+ *   [1] direction.xyz,    w = range (0 = infinite)
+ *   [2] color.rgb,        w = intensity
+ *   [3] spot: cosOuter, cosInner, decay, shadowIndex
+ *   [4] shadow matrix column a (rect: right.xyz, width)
+ *   [5] shadow matrix column b (rect: up.xyz, height)
+ */
+export const LIGHTING_PUNCTUAL_CHUNK_GLSL = /* glsl */ `
+#ifndef A3D_MAX_LIGHTS
+#define A3D_MAX_LIGHTS 32
+#endif
+uniform int u_prd02LightCount;
+// AuraLights std140 block, flattened for WebGL2 (PRD-02 §8.1): 6 vec4 per light.
+uniform vec4 u_lightData[A3D_MAX_LIGHTS * 6];
+
+// Frostbite range window — only applies when range > 0.
+float a3d_rangeWindow(float d, float range) {
+  if (range <= 0.0) return 1.0;
+  float x = clamp(1.0 - pow(d / range, 4.0), 0.0, 1.0);
+  return x * x;
+}
+
+// three r185 getDistanceAttenuation verbatim (Frostbite E[window1]):
+// 1/max(d^decay, 0.01) with the range window folded in when range > 0.
+float a3dDistanceFalloff(float d, float range, float decay) {
+  float att = 1.0 / max(pow(d, decay), 0.01);
+  return att * a3d_rangeWindow(d, range);
+}
+
+// Spot cone: smooth falloff between cosOuter and cosInner angles.
+float a3d_spotWindow(float cosLightDir, float cosOuter, float cosInner) {
+  float w = clamp((cosLightDir - cosOuter) / max(cosInner - cosOuter, 1e-4), 0.0, 1.0);
+  return w * w;
+}
+
+// Fetch helper — per-light record base index.
+int a3d_lightBase(int i) { return i * 6; }
+
+// Incident radiance contribution of punctual light i at worldPos with
+// surface normal n. Shadow factor is applied by the caller.
+vec3 a3d_punctualRadiance(int i, vec3 worldPos, vec3 n, out vec3 l, out float atten) {
+  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];
+  vec4 d1 = u_lightData[a3d_lightBase(i) + 1];
+  vec4 d2 = u_lightData[a3d_lightBase(i) + 2];
+  int kind = int(d0.w + 0.5);
+  vec3 lightColor = d2.rgb * d2.w;
+  if (kind == 0) {
+    l = -normalize(d1.xyz);
+    atten = 1.0;
+    return lightColor * max(dot(n, l), 0.0);
+  }
+  vec3 toLight = d0.xyz - worldPos;
+  float d = length(toLight);
+  l = toLight / max(d, 1e-4);
+  vec4 d3 = u_lightData[a3d_lightBase(i) + 3];
+  atten = a3dDistanceFalloff(d, d1.w, d3.z);
+  if (kind == 2) {
+    float c = dot(-l, normalize(d1.xyz));
+    atten *= a3d_spotWindow(c, d3.x, d3.y);
+  }
+  return lightColor * max(dot(n, l), 0.0) * atten;
+}
+
+// Shadow factor for punctual light i (PRD-02 Phase 4): the composed program
+// must also #include a3d_prd02_shadow_lookup and define A3D_PUNCTUAL_SHADOWS
+// to activate it; otherwise this returns 1.0. Directional shadows come from
+// the CSM samplers; spot/point sample their atlas tile via shadowIndex
+// (u_lightData[i][3].w — the tile slot stamped by the shadow planner).
+float a3d_punctualShadowFactor(int i, vec3 worldPos, vec3 worldNormal, float viewDepth) {
+#if defined(A3D_PUNCTUAL_SHADOWS) && A3D_PUNCTUAL_SHADOWS
+  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];
+  int kind = int(d0.w + 0.5);
+  if (kind == 0) {
+    return a3d_sunShadow(worldPos, worldNormal, viewDepth);
+  }
+  if (kind == 1 || kind == 2) {
+    vec4 d3 = u_lightData[a3d_lightBase(i) + 3];
+    return a3d_localShadow(int(d3.w + 0.5), worldPos, worldNormal);
+  }
+#endif
+  return 1.0;
+}
+
+
+// ---- Area lights (rect, kind == 3) — PRD-02 §8.5: LTC on High/Ultra
+// (A3D_AREA_LTC; LUTs u_prd02LtcMInv / u_prd02LtcFresnel, 64x64 RGBA16F,
+// fetched lazily from the three.js RectAreaLightTexturesLib tables, MIT),
+// Gauss–Legendre 4-tap integrator on Low/Medium (A3D_AREA_GAUSS).
+// Rect layout in the AuraLights block: d0.xyz center, d4 = right.xyz+width,
+// d5 = up.xyz+height. Luminance in nits (d2.rgb).
+#if defined(A3D_AREA_LTC) && A3D_AREA_LTC
+uniform sampler2D u_prd02LtcMInv;
+uniform sampler2D u_prd02LtcFresnel;
+
+vec2 a3d_ltcUv(vec3 n, vec3 v, float roughness) {
+  float lod = roughness * roughness;
+  float theta = acos(clamp(dot(n, v), -1.0, 1.0)) / 3.14159265;
+  return vec2(lod, theta) * (63.0 / 64.0) + 0.5 / 64.0;
+}
+
+mat3 a3d_ltcMinv(vec2 uv) {
+  vec4 t = texture2D(u_prd02LtcMInv, uv);
+  return mat3(
+    vec3(1.0, 0.0, t.y),
+    vec3(0.0, t.z, 0.0),
+    vec3(t.w, 0.0, t.x));
+}
+
+// Edge-integral of a quad through LTC matrix M (Real-Time Polygonal-Light
+// Shading, Heitz et al.): sum of cross-edge arc cosines.
+float a3d_ltcEdgeIntegrate(mat3 Minv, vec3 n, vec3 v, vec3 p,
+                         vec3 c0, vec3 c1, vec3 c2, vec3 c3) {
+  vec3 vs[4];
+  vs[0] = Minv * (c0 - p); vs[1] = Minv * (c1 - p);
+  vs[2] = Minv * (c2 - p); vs[3] = Minv * (c3 - p);
+  for (int k = 0; k < 4; k++) vs[k] = normalize(vs[k]);
+  float sum = 0.0;
+  sum += a3d_ltcEdge(vs[0], vs[1]);
+  sum += a3d_ltcEdge(vs[1], vs[2]);
+  sum += a3d_ltcEdge(vs[2], vs[3]);
+  sum += a3d_ltcEdge(vs[3], vs[0]);
+  return max(sum, 0.0);
+}
+#endif
+
+#if (defined(A3D_AREA_LTC) && A3D_AREA_LTC) || (defined(A3D_AREA_GAUSS) && A3D_AREA_GAUSS)
+// Edge integral (Heitz et al. 2016): acos(dot) × normalize(cross).z —
+// the arc length weighted by its projection onto the shading normal's axis
+// in the transformed (identity-irradiance) space.
+float a3d_ltcEdge(vec3 v1, vec3 v2) {
+  float theta = acos(clamp(dot(v1, v2), -0.9999, 0.9999));
+  vec3 n = cross(v1, v2);
+  float nl = length(n);
+  if (nl < 1e-6) return 0.0;
+  return theta * (n.z / nl);
+}
+#endif
+
+// Gauss–Legendre 4-tap: subdivide the rect into 4 quadrants; diffuse from
+// each quadrant centroid (a point light of area·luminance/4). Cheap on
+// Low/Medium; within ~10% total energy of the LTC integral (unit test).
+vec3 a3d_rectGaussDiffuse(vec3 center, vec3 right, vec3 up, vec2 halfSize,
+                          vec3 luminanceNits, vec3 worldPos, vec3 worldNormal) {
+  const float g = 0.25; // quadrant centroid offsets at ±halfSize*0.5
+  vec3 acc = vec3(0.0);
+  for (int i = 0; i < 4; i++) {
+    vec3 c = center
+      + right * (halfSize.x * (i == 0 || i == 3 ? -g : g))
+      + up * (halfSize.y * (i < 2 ? -g : g));
+    vec3 toLight = c - worldPos;
+    float d2 = dot(toLight, toLight);
+    vec3 l = toLight * inversesqrt(max(d2, 1e-6));
+    float nl = max(dot(worldNormal, l), 0.0);
+    // Solid angle of the quadrant: A_quadrant·cos_s / d2 (small-aperture).
+    float area = halfSize.x * halfSize.y; // quadrant area = rect area /4
+    float cosS = max(dot(-l, normalize(cross(right, up))), 0.0);
+    acc += luminanceNits * (nl * area * cosS / max(d2, 1e-6));
+  }
+  return acc / 3.14159265;
+}
+
+vec3 a3d_rectLightDiffuse(int i, vec3 worldPos, vec3 worldNormal, vec3 viewDir, float roughness) {
+  vec4 d0 = u_lightData[a3d_lightBase(i) + 0];
+  vec4 d2 = u_lightData[a3d_lightBase(i) + 2];
+  vec4 d4 = u_lightData[a3d_lightBase(i) + 4];
+  vec4 d5 = u_lightData[a3d_lightBase(i) + 5];
+  vec3 center = d0.xyz;
+  vec3 right = d4.xyz;
+  vec3 up = d5.xyz;
+  vec2 halfSize = vec2(d4.w, d5.w) * 0.5;
+#if defined(A3D_AREA_LTC) && A3D_AREA_LTC
+  vec3 c0 = center - right * halfSize.x - up * halfSize.y;
+  vec3 c1 = center + right * halfSize.x - up * halfSize.y;
+  vec3 c2 = center + right * halfSize.x + up * halfSize.y;
+  vec3 c3 = center - right * halfSize.x + up * halfSize.y;
+  // Diffuse irradiance = edge integral with the identity transform (the LUT
+  // path fits the GGX-specular distribution — specular evaluation arrives
+  // with the shading seam; diffuse is exact here).
+  float sum = a3d_ltcEdgeIntegrate(mat3(1.0), worldNormal, viewDir, worldPos, c0, c1, c2, c3);
+  return d2.rgb * (sum / (2.0 * 3.14159265));
+#elif defined(A3D_AREA_GAUSS) && A3D_AREA_GAUSS
+  return a3d_rectGaussDiffuse(center, right, up, halfSize, d2.rgb, worldPos, worldNormal);
+#else
+  return vec3(0.0);
+#endif
+}
+
+`;
+//# sourceMappingURL=lighting_punctual.glsl.js.map

package/dist/rendering/shaders/chunks/lighting_punctual.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lighting_punctual.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/lighting_punctual.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoLtD,CAAC"}

package/dist/rendering/shaders/chunks/sh9.glsl.d.ts

@@ -0,0 +1,9 @@
+/**
+ * a3d_prd02_sh9 — SH9 irradiance evaluation (PRD-02 §8).
+ * Coefficient order and irradiance basis scale match
+ * environment/SphericalHarmonics.ts exactly (c0, -c1y, c1z, -c1x,
+ * c2xy, c2yz, c3(3z²−1), c2xz, c4(x²−y²)). The shTexture is a 9×1 RGBA32F
+ * strip of RGB radiance coefficients produced by projectCubeToSH9.
+ */
+export declare const SH9_CHUNK_GLSL = "\nuniform sampler2D u_sh9Texture;\nuniform int u_sh9Bound; // 0 = no SH bound; callers must keep a fallback\n\n// f = per-channel vec3 coefficient texture, index 0..8\nvec3 a3d_sh9Coefficient(int i) {\n  return texelFetch(u_sh9Texture, ivec2(i, 0), 0).rgb;\n}\n\n// Folded irradiance basis at n \u2014 Y_k\u00B7A_l, identical to the contract's\n// evaluateSH9Irradiance constants (c0\u00B7\u03C0, c1\u00B72\u03C0/3, c2\u00B7\u03C0/4 \u2026).\nvoid a3d_sh9IrradianceBasis(vec3 n, out float b[9]) {\n  b[0] = 0.886227;\n  b[1] = -1.023328 * n.y;\n  b[2] = 1.023328 * n.z;\n  b[3] = -1.023328 * n.x;\n  b[4] = 0.858086 * (n.x * n.y);\n  b[5] = 0.858086 * (n.y * n.z);\n  b[6] = 0.247708 * (3.0 * n.z * n.z - 1.0);\n  b[7] = 0.858086 * (n.x * n.z);\n  b[8] = 0.429043 * (n.x * n.x - n.y * n.y);\n}\n\nvec3 a3d_sh9Irradiance(vec3 n) {\n  float b[9];\n  a3d_sh9IrradianceBasis(normalize(n), b);\n  vec3 acc = vec3(0.0);\n  for (int i = 0; i < 9; i += 1) {\n    acc += a3d_sh9Coefficient(i) * b[i];\n  }\n  return max(acc, vec3(0.0));\n}\n";
+//# sourceMappingURL=sh9.glsl.d.ts.map

package/dist/rendering/shaders/chunks/sh9.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh9.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/sh9.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,6gCAgC1B,CAAC"}

package/dist/rendering/shaders/chunks/sh9.glsl.js

@@ -0,0 +1,41 @@
+/**
+ * a3d_prd02_sh9 — SH9 irradiance evaluation (PRD-02 §8).
+ * Coefficient order and irradiance basis scale match
+ * environment/SphericalHarmonics.ts exactly (c0, -c1y, c1z, -c1x,
+ * c2xy, c2yz, c3(3z²−1), c2xz, c4(x²−y²)). The shTexture is a 9×1 RGBA32F
+ * strip of RGB radiance coefficients produced by projectCubeToSH9.
+ */
+export const SH9_CHUNK_GLSL = /* glsl */ `
+uniform sampler2D u_sh9Texture;
+uniform int u_sh9Bound; // 0 = no SH bound; callers must keep a fallback
+
+// f = per-channel vec3 coefficient texture, index 0..8
+vec3 a3d_sh9Coefficient(int i) {
+  return texelFetch(u_sh9Texture, ivec2(i, 0), 0).rgb;
+}
+
+// Folded irradiance basis at n — Y_k·A_l, identical to the contract's
+// evaluateSH9Irradiance constants (c0·π, c1·2π/3, c2·π/4 …).
+void a3d_sh9IrradianceBasis(vec3 n, out float b[9]) {
+  b[0] = 0.886227;
+  b[1] = -1.023328 * n.y;
+  b[2] = 1.023328 * n.z;
+  b[3] = -1.023328 * n.x;
+  b[4] = 0.858086 * (n.x * n.y);
+  b[5] = 0.858086 * (n.y * n.z);
+  b[6] = 0.247708 * (3.0 * n.z * n.z - 1.0);
+  b[7] = 0.858086 * (n.x * n.z);
+  b[8] = 0.429043 * (n.x * n.x - n.y * n.y);
+}
+
+vec3 a3d_sh9Irradiance(vec3 n) {
+  float b[9];
+  a3d_sh9IrradianceBasis(normalize(n), b);
+  vec3 acc = vec3(0.0);
+  for (int i = 0; i < 9; i += 1) {
+    acc += a3d_sh9Coefficient(i) * b[i];
+  }
+  return max(acc, vec3(0.0));
+}
+`;
+//# sourceMappingURL=sh9.glsl.js.map

package/dist/rendering/shaders/chunks/sh9.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh9.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/sh9.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCxC,CAAC"}

package/dist/rendering/shaders/chunks/shadow_caster.glsl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * a3d_prd02_shadow_caster — depth-material path for shadow casters
+ * (PRD-02 §8). Vertex-stage: forwards world position and handles the
+ * alpha-test/alpha-hash coverage for the depth write. Variant selection
+ * (skinning lanes, morph targets, instanced, batched, alphaTest/alphaHash,
+ * doubleSided) is resolved CPU-side by ShadowCasterVariantKey — this chunk
+ * is the fragment-visible half.
+ */
+export declare const SHADOW_CASTER_CHUNK_GLSL = "\nuniform sampler2D u_prd02BaseColorAlpha;   // alphaTest/alphaHash variants only\nuniform float u_prd02AlphaCutoff;\nuniform vec4 u_prd02CasterParams;          // x: alphaTest on, y: alphaHash on, z: doubleSided, w: shadowFar\nin vec2 v_prd02ShadowUv;\n\n// Analytic hash for alpha-hash coverage (deterministic per texel).\nfloat a3d_shadowHash(vec2 p) {\n  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);\n}\n\n// Returns false when the texel must not write depth.\nbool a3d_casterCovers() {\n  if (u_prd02CasterParams.x > 0.5) {\n    return texture(u_prd02BaseColorAlpha, v_prd02ShadowUv).a >= u_prd02AlphaCutoff;\n  }\n  if (u_prd02CasterParams.y > 0.5) {\n    float a = texture(u_prd02BaseColorAlpha, v_prd02ShadowUv).a;\n    return a >= a3d_shadowHash(gl_FragCoord.xy);\n  }\n  return true;\n}\n";
+//# sourceMappingURL=shadow_caster.glsl.d.ts.map

package/dist/rendering/shaders/chunks/shadow_caster.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_caster.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/shadow_caster.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,qzBAsBpC,CAAC"}

package/dist/rendering/shaders/chunks/shadow_caster.glsl.js

@@ -0,0 +1,32 @@
+/**
+ * a3d_prd02_shadow_caster — depth-material path for shadow casters
+ * (PRD-02 §8). Vertex-stage: forwards world position and handles the
+ * alpha-test/alpha-hash coverage for the depth write. Variant selection
+ * (skinning lanes, morph targets, instanced, batched, alphaTest/alphaHash,
+ * doubleSided) is resolved CPU-side by ShadowCasterVariantKey — this chunk
+ * is the fragment-visible half.
+ */
+export const SHADOW_CASTER_CHUNK_GLSL = /* glsl */ `
+uniform sampler2D u_prd02BaseColorAlpha;   // alphaTest/alphaHash variants only
+uniform float u_prd02AlphaCutoff;
+uniform vec4 u_prd02CasterParams;          // x: alphaTest on, y: alphaHash on, z: doubleSided, w: shadowFar
+in vec2 v_prd02ShadowUv;
+
+// Analytic hash for alpha-hash coverage (deterministic per texel).
+float a3d_shadowHash(vec2 p) {
+  return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+// Returns false when the texel must not write depth.
+bool a3d_casterCovers() {
+  if (u_prd02CasterParams.x > 0.5) {
+    return texture(u_prd02BaseColorAlpha, v_prd02ShadowUv).a >= u_prd02AlphaCutoff;
+  }
+  if (u_prd02CasterParams.y > 0.5) {
+    float a = texture(u_prd02BaseColorAlpha, v_prd02ShadowUv).a;
+    return a >= a3d_shadowHash(gl_FragCoord.xy);
+  }
+  return true;
+}
+`;
+//# sourceMappingURL=shadow_caster.glsl.js.map

package/dist/rendering/shaders/chunks/shadow_caster.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_caster.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/shadow_caster.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBlD,CAAC"}

package/dist/rendering/shaders/chunks/shadow_receive.glsl.d.ts

@@ -0,0 +1,13 @@
+/**
+ * a3d_prd02_shadow_lookup — receiver-side shadow sampling (PRD-02 §8).
+ * Compare-texture path (sampler2DShadow) with three kernels selected by
+ * A3D_SHADOW_FILTER: 1 = HW single tap (pcf2 tiers), 2 = Castaño 5×5
+ * tent-weighted (pcf3), 3 = Vogel disk 16-tap (pcf5). PCSS is opted-in via
+ * A3D_SHADOW_PCSS + the raw depth sampler (u_prd02ShadowRaw).
+ *
+ * Samplers are individually named (u_prd02CascadeCompare0..3) because sampler
+ * arrays need constant-index access in ES 3.00 and the device binds one
+ * texture unit per named uniform.
+ */
+export declare const SHADOW_RECEIVE_CHUNK_GLSL = "\n#ifndef A3D_SHADOW_FILTER\n#define A3D_SHADOW_FILTER 1\n#endif\n#ifndef A3D_CASCADE_COUNT\n#define A3D_CASCADE_COUNT 1\n#endif\n\nuniform highp sampler2DShadow u_prd02CascadeCompare0;\nuniform highp sampler2DShadow u_prd02CascadeCompare1;\nuniform highp sampler2DShadow u_prd02CascadeCompare2;\nuniform highp sampler2DShadow u_prd02CascadeCompare3;\nuniform highp sampler2DShadow u_prd02LocalCompare;  // local-light atlas (compare)\nuniform highp sampler2D u_prd02ShadowRaw;           // atlas raw depth (PCSS source)\nuniform mat4 u_prd02CascadeMatrix[4];\nuniform vec4 u_prd02CascadeSplits;                  // far split distance per cascade\nuniform vec4 u_prd02CascadeTexelWorld;              // world-space texel per cascade\nuniform float u_prd02ShadowMapSize;\nuniform float u_prd02NormalBias;                    // normal bias in texel units\nuniform float u_prd02ShadowStrength;                // 0..1 receive strength\nuniform vec4 u_prd02ShadowAtlasRect[6];             // local tile rect (normalized u0,v0,du,dv)\nuniform mat4 u_prd02LocalShadowMatrix[6];\nuniform vec4 u_prd02LocalShadowIndex[6];            // (lightIndex, tileSlot) packed vec4\n\n// Vogel disk 16-tap offsets (unit disk, golden angle spiral).\nconst vec2 A3D_VOGEL_16[16] = vec2[16](\n  vec2( 0.0000,  0.0000), vec2( 0.2955, -0.1907), vec2(-0.3635,  0.5008),\n  vec2( 0.1674, -0.7286), vec2( 0.2355,  0.7716), vec2(-0.6167, -0.6063),\n  vec2( 0.8144,  0.2760), vec2(-0.7660,  0.1240), vec2( 0.4848, -0.4589),\n  vec2(-0.0575,  0.6503), vec2(-0.3834, -0.6652), vec2( 0.6893,  0.4934),\n  vec2(-0.8225, -0.1722), vec2( 0.7588, -0.2061), vec2(-0.5091,  0.5230),\n  vec2( 0.1339, -0.6999)\n);\n\nfloat a3d_shadowTap(highp sampler2DShadow tex, vec3 proj) {\n  return texture(tex, proj);\n}\n\nfloat a3d_shadowFiltered(highp sampler2DShadow tex, vec3 proj, float texel) {\n#if A3D_SHADOW_FILTER == 1\n  return a3d_shadowTap(tex, proj);\n#elif A3D_SHADOW_FILTER == 2\n  // Casta\u00F1o 5\u00D75 tent filter.\n  vec2 offset = fract(proj.xy / texel - 0.5) * 0.5;\n  vec2 base = proj.xy - offset * texel;\n  vec2 uw = vec2(3.0 - 2.0 * offset.x, 1.0 + 2.0 * offset.x);\n  vec2 vw = vec2(3.0 - 2.0 * offset.y, 1.0 + 2.0 * offset.y);\n  float sum = 0.0;\n  sum += uw.x * vw.x * a3d_shadowTap(tex, vec3(base + vec2(-1.5, -1.5) * texel, proj.z));\n  sum += uw.y * vw.x * a3d_shadowTap(tex, vec3(base + vec2( 0.5, -1.5) * texel, proj.z));\n  sum += uw.x * vw.y * a3d_shadowTap(tex, vec3(base + vec2(-1.5,  0.5) * texel, proj.z));\n  sum += uw.y * vw.y * a3d_shadowTap(tex, vec3(base + vec2( 0.5,  0.5) * texel, proj.z));\n  return sum / ((uw.x + uw.y) * (vw.x + vw.y));\n#else\n  // Vogel 16-tap disk.\n  float radius = texel * 1.5;\n  float sum = 0.0;\n  for (int i = 0; i < 16; i += 1) {\n    sum += a3d_shadowTap(tex, vec3(proj.xy + A3D_VOGEL_16[i] * radius, proj.z));\n  }\n  return sum / 16.0;\n#endif\n}\n\n// Which cascade covers this view-space depth (linear distance).\nint a3d_selectCascade(float viewDepth) {\n  int c = A3D_CASCADE_COUNT - 1;\n  if (viewDepth < u_prd02CascadeSplits.x) c = 0;\n#if A3D_CASCADE_COUNT >= 2\n  else if (viewDepth < u_prd02CascadeSplits.y) c = 1;\n#endif\n#if A3D_CASCADE_COUNT >= 3\n  else if (viewDepth < u_prd02CascadeSplits.z) c = 2;\n#endif\n#if A3D_CASCADE_COUNT >= 4\n  else if (viewDepth < u_prd02CascadeSplits.w) c = 3;\n#endif\n  return c;\n}\n\nfloat a3d_cascadeTap0(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare0, proj, 1.0 / u_prd02ShadowMapSize); }\nfloat a3d_cascadeTap1(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare1, proj, 1.0 / u_prd02ShadowMapSize); }\nfloat a3d_cascadeTap2(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare2, proj, 1.0 / u_prd02ShadowMapSize); }\nfloat a3d_cascadeTap3(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare3, proj, 1.0 / u_prd02ShadowMapSize); }\n\nfloat a3d_sunShadow(vec3 worldPos, vec3 worldNormal, float viewDepth) {\n  int c = a3d_selectCascade(viewDepth);\n  // Normal bias in world units: N \u00D7 texelWorld(c) \u00D7 configured texel count.\n  vec3 biased = worldPos + worldNormal * (u_prd02CascadeTexelWorld[c] * u_prd02NormalBias);\n  vec4 p = u_prd02CascadeMatrix[c] * vec4(biased, 1.0);\n  vec3 proj = p.xyz / max(p.w, 1e-6);\n  if (proj.x < 0.0 || proj.x > 1.0 || proj.y < 0.0 || proj.y > 1.0) return 1.0;\n  float lit;\n  if (c == 0) lit = a3d_cascadeTap0(proj);\n#if A3D_CASCADE_COUNT >= 2\n  else if (c == 1) lit = a3d_cascadeTap1(proj);\n#endif\n#if A3D_CASCADE_COUNT >= 3\n  else if (c == 2) lit = a3d_cascadeTap2(proj);\n#endif\n#if A3D_CASCADE_COUNT >= 4\n  else lit = a3d_cascadeTap3(proj);\n#endif\n#if A3D_CASCADE_COUNT < 4\n  else lit = a3d_cascadeTap0(proj);\n#endif\n  return mix(1.0, lit, u_prd02ShadowStrength);\n}\n\n// Local (point/spot) tile lookup in the atlas \u2014 compare path.\n// shadowIndex indexes the packed u_prd02ShadowAtlasRect/u_prd02LocalShadowMatrix\n// slot for this light (from u_prd02LocalShadowIndex / perLightShadowIndex).\nfloat a3d_localShadow(int shadowIndex, vec3 worldPos, vec3 worldNormal) {\n  if (shadowIndex < 0 || shadowIndex >= 6) return 1.0;\n  vec3 biased = worldPos + worldNormal * (u_prd02NormalBias / max(u_prd02ShadowMapSize, 1.0));\n  vec4 p = u_prd02LocalShadowMatrix[shadowIndex] * vec4(biased, 1.0);\n  vec3 proj = p.xyz / max(p.w, 1e-6);\n  if (proj.x < 0.0 || proj.x > 1.0 || proj.y < 0.0 || proj.y > 1.0) return 1.0;\n  vec4 rect = u_prd02ShadowAtlasRect[shadowIndex];\n  vec2 uv = rect.xy + proj.xy * rect.zw;\n  float lit = a3d_shadowFiltered(u_prd02LocalCompare, vec3(uv, proj.z), 1.0 / u_prd02ShadowMapSize);\n  return mix(1.0, lit, u_prd02ShadowStrength);\n}\n";
+//# sourceMappingURL=shadow_receive.glsl.d.ts.map

package/dist/rendering/shaders/chunks/shadow_receive.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_receive.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/shadow_receive.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,yhLA2HrC,CAAC"}

package/dist/rendering/shaders/chunks/shadow_receive.glsl.js

@@ -0,0 +1,136 @@
+/**
+ * a3d_prd02_shadow_lookup — receiver-side shadow sampling (PRD-02 §8).
+ * Compare-texture path (sampler2DShadow) with three kernels selected by
+ * A3D_SHADOW_FILTER: 1 = HW single tap (pcf2 tiers), 2 = Castaño 5×5
+ * tent-weighted (pcf3), 3 = Vogel disk 16-tap (pcf5). PCSS is opted-in via
+ * A3D_SHADOW_PCSS + the raw depth sampler (u_prd02ShadowRaw).
+ *
+ * Samplers are individually named (u_prd02CascadeCompare0..3) because sampler
+ * arrays need constant-index access in ES 3.00 and the device binds one
+ * texture unit per named uniform.
+ */
+export const SHADOW_RECEIVE_CHUNK_GLSL = /* glsl */ `
+#ifndef A3D_SHADOW_FILTER
+#define A3D_SHADOW_FILTER 1
+#endif
+#ifndef A3D_CASCADE_COUNT
+#define A3D_CASCADE_COUNT 1
+#endif
+
+uniform highp sampler2DShadow u_prd02CascadeCompare0;
+uniform highp sampler2DShadow u_prd02CascadeCompare1;
+uniform highp sampler2DShadow u_prd02CascadeCompare2;
+uniform highp sampler2DShadow u_prd02CascadeCompare3;
+uniform highp sampler2DShadow u_prd02LocalCompare;  // local-light atlas (compare)
+uniform highp sampler2D u_prd02ShadowRaw;           // atlas raw depth (PCSS source)
+uniform mat4 u_prd02CascadeMatrix[4];
+uniform vec4 u_prd02CascadeSplits;                  // far split distance per cascade
+uniform vec4 u_prd02CascadeTexelWorld;              // world-space texel per cascade
+uniform float u_prd02ShadowMapSize;
+uniform float u_prd02NormalBias;                    // normal bias in texel units
+uniform float u_prd02ShadowStrength;                // 0..1 receive strength
+uniform vec4 u_prd02ShadowAtlasRect[6];             // local tile rect (normalized u0,v0,du,dv)
+uniform mat4 u_prd02LocalShadowMatrix[6];
+uniform vec4 u_prd02LocalShadowIndex[6];            // (lightIndex, tileSlot) packed vec4
+
+// Vogel disk 16-tap offsets (unit disk, golden angle spiral).
+const vec2 A3D_VOGEL_16[16] = vec2[16](
+  vec2( 0.0000,  0.0000), vec2( 0.2955, -0.1907), vec2(-0.3635,  0.5008),
+  vec2( 0.1674, -0.7286), vec2( 0.2355,  0.7716), vec2(-0.6167, -0.6063),
+  vec2( 0.8144,  0.2760), vec2(-0.7660,  0.1240), vec2( 0.4848, -0.4589),
+  vec2(-0.0575,  0.6503), vec2(-0.3834, -0.6652), vec2( 0.6893,  0.4934),
+  vec2(-0.8225, -0.1722), vec2( 0.7588, -0.2061), vec2(-0.5091,  0.5230),
+  vec2( 0.1339, -0.6999)
+);
+
+float a3d_shadowTap(highp sampler2DShadow tex, vec3 proj) {
+  return texture(tex, proj);
+}
+
+float a3d_shadowFiltered(highp sampler2DShadow tex, vec3 proj, float texel) {
+#if A3D_SHADOW_FILTER == 1
+  return a3d_shadowTap(tex, proj);
+#elif A3D_SHADOW_FILTER == 2
+  // Castaño 5×5 tent filter.
+  vec2 offset = fract(proj.xy / texel - 0.5) * 0.5;
+  vec2 base = proj.xy - offset * texel;
+  vec2 uw = vec2(3.0 - 2.0 * offset.x, 1.0 + 2.0 * offset.x);
+  vec2 vw = vec2(3.0 - 2.0 * offset.y, 1.0 + 2.0 * offset.y);
+  float sum = 0.0;
+  sum += uw.x * vw.x * a3d_shadowTap(tex, vec3(base + vec2(-1.5, -1.5) * texel, proj.z));
+  sum += uw.y * vw.x * a3d_shadowTap(tex, vec3(base + vec2( 0.5, -1.5) * texel, proj.z));
+  sum += uw.x * vw.y * a3d_shadowTap(tex, vec3(base + vec2(-1.5,  0.5) * texel, proj.z));
+  sum += uw.y * vw.y * a3d_shadowTap(tex, vec3(base + vec2( 0.5,  0.5) * texel, proj.z));
+  return sum / ((uw.x + uw.y) * (vw.x + vw.y));
+#else
+  // Vogel 16-tap disk.
+  float radius = texel * 1.5;
+  float sum = 0.0;
+  for (int i = 0; i < 16; i += 1) {
+    sum += a3d_shadowTap(tex, vec3(proj.xy + A3D_VOGEL_16[i] * radius, proj.z));
+  }
+  return sum / 16.0;
+#endif
+}
+
+// Which cascade covers this view-space depth (linear distance).
+int a3d_selectCascade(float viewDepth) {
+  int c = A3D_CASCADE_COUNT - 1;
+  if (viewDepth < u_prd02CascadeSplits.x) c = 0;
+#if A3D_CASCADE_COUNT >= 2
+  else if (viewDepth < u_prd02CascadeSplits.y) c = 1;
+#endif
+#if A3D_CASCADE_COUNT >= 3
+  else if (viewDepth < u_prd02CascadeSplits.z) c = 2;
+#endif
+#if A3D_CASCADE_COUNT >= 4
+  else if (viewDepth < u_prd02CascadeSplits.w) c = 3;
+#endif
+  return c;
+}
+
+float a3d_cascadeTap0(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare0, proj, 1.0 / u_prd02ShadowMapSize); }
+float a3d_cascadeTap1(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare1, proj, 1.0 / u_prd02ShadowMapSize); }
+float a3d_cascadeTap2(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare2, proj, 1.0 / u_prd02ShadowMapSize); }
+float a3d_cascadeTap3(vec3 proj) { return a3d_shadowFiltered(u_prd02CascadeCompare3, proj, 1.0 / u_prd02ShadowMapSize); }
+
+float a3d_sunShadow(vec3 worldPos, vec3 worldNormal, float viewDepth) {
+  int c = a3d_selectCascade(viewDepth);
+  // Normal bias in world units: N × texelWorld(c) × configured texel count.
+  vec3 biased = worldPos + worldNormal * (u_prd02CascadeTexelWorld[c] * u_prd02NormalBias);
+  vec4 p = u_prd02CascadeMatrix[c] * vec4(biased, 1.0);
+  vec3 proj = p.xyz / max(p.w, 1e-6);
+  if (proj.x < 0.0 || proj.x > 1.0 || proj.y < 0.0 || proj.y > 1.0) return 1.0;
+  float lit;
+  if (c == 0) lit = a3d_cascadeTap0(proj);
+#if A3D_CASCADE_COUNT >= 2
+  else if (c == 1) lit = a3d_cascadeTap1(proj);
+#endif
+#if A3D_CASCADE_COUNT >= 3
+  else if (c == 2) lit = a3d_cascadeTap2(proj);
+#endif
+#if A3D_CASCADE_COUNT >= 4
+  else lit = a3d_cascadeTap3(proj);
+#endif
+#if A3D_CASCADE_COUNT < 4
+  else lit = a3d_cascadeTap0(proj);
+#endif
+  return mix(1.0, lit, u_prd02ShadowStrength);
+}
+
+// Local (point/spot) tile lookup in the atlas — compare path.
+// shadowIndex indexes the packed u_prd02ShadowAtlasRect/u_prd02LocalShadowMatrix
+// slot for this light (from u_prd02LocalShadowIndex / perLightShadowIndex).
+float a3d_localShadow(int shadowIndex, vec3 worldPos, vec3 worldNormal) {
+  if (shadowIndex < 0 || shadowIndex >= 6) return 1.0;
+  vec3 biased = worldPos + worldNormal * (u_prd02NormalBias / max(u_prd02ShadowMapSize, 1.0));
+  vec4 p = u_prd02LocalShadowMatrix[shadowIndex] * vec4(biased, 1.0);
+  vec3 proj = p.xyz / max(p.w, 1e-6);
+  if (proj.x < 0.0 || proj.x > 1.0 || proj.y < 0.0 || proj.y > 1.0) return 1.0;
+  vec4 rect = u_prd02ShadowAtlasRect[shadowIndex];
+  vec2 uv = rect.xy + proj.xy * rect.zw;
+  float lit = a3d_shadowFiltered(u_prd02LocalCompare, vec3(uv, proj.z), 1.0 / u_prd02ShadowMapSize);
+  return mix(1.0, lit, u_prd02ShadowStrength);
+}
+`;
+//# sourceMappingURL=shadow_receive.glsl.js.map

package/dist/rendering/shaders/chunks/shadow_receive.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow_receive.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/chunks/shadow_receive.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2HnD,CAAC"}

package/dist/rendering/shaders/debug-view.glsl.d.ts

@@ -0,0 +1,18 @@
+import type { ShaderChunk, ShaderFeature } from "../contracts/program.js";
+/** `u_prd05DebugView` value → channel define suffix. */
+export declare const PRD05_DEBUG_VIEW_CHANNELS: readonly ["TEXEL_DENSITY", "MIP_LEVEL", "FACET", "LOD_LEVEL", "BASE_COLOR", "WORLD_NORMAL", "ROUGHNESS", "METALLIC", "OCCLUSION", "UV_LAYOUT"];
+export type Prd05DebugViewChannel = "texelDensity" | "mipLevel" | "facet" | "lodLevel" | "baseColor" | "normal" | "roughness" | "metallic" | "occlusion" | "uvLayout";
+/** Material-param value for a named channel (what the look-dev app sets). */
+export declare function prd05DebugViewValue(channel: Prd05DebugViewChannel): number;
+export declare function prd05DebugViewDefineName(value: number): string | undefined;
+/** fragment:pars chunk — declares the debug sampler/uniforms + helpers. */
+export declare const debugViewParsChunk: ShaderChunk;
+/**
+ * fragment:end body. Entirely inside the channel `#ifdef`s: outside a
+ * generated program (ChunkHarness) it is empty, so the chunk compiles even
+ * though it names `v_uv`/`v_worldPosition`/`u_baseColorMap`.
+ */
+export declare const debugViewEndChunk: ShaderChunk;
+/** Forward-pass feature: active only while a material carries `u_prd05DebugView`. */
+export declare const debugViewFeature: ShaderFeature;
+//# sourceMappingURL=debug-view.glsl.d.ts.map

package/dist/rendering/shaders/debug-view.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-view.glsl.d.ts","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/debug-view.glsl.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGvE,wDAAwD;AACxD,eAAO,MAAM,yBAAyB,gJAG5B,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC7B,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAClD,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC;AAejF,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAE1E;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG1E;AA+BD,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,EAAE,WAMhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAyD/B,CAAC;AAIF,qFAAqF;AACrF,eAAO,MAAM,gBAAgB,EAAE,aAyB9B,CAAC"}