@aura3d/rendering 3.0.1 → 4.0.2

package/dist/world/terrain/shaders/terrain.vert.glsl.js

@@ -0,0 +1,162 @@
+/**
+ * PRD-10 T2.4 — the standalone Path S terrain program sources, composed from
+ * the `a3d_prd10_terrain_cdlod` / `a3d_prd10_terrain_splat` chunk bodies so the
+ * vertex displacement is bit-identical to the harnessed chunk.
+ */
+import { terrainCdlodGlsl, terrainCdlodWgslBindings, terrainCdlodWgslFunctions, terrainCdlodWgslUniformStruct } from "./terrainCdlod.js";
+import { terrainSplatGlsl, terrainSplatWgslBindings, terrainSplatWgslFunctions, terrainSplatWgslUniformStruct } from "./terrainSplat.js";
+export const TERRAIN_VERT_GLSL = /* glsl */ `#version 300 es
+// prd10.terrain — RenderDevice shader marker (both stages; the device rejects a program without it)
+precision highp float;
+in vec2 a_grid;
+in vec4 a_node;
+uniform vec3 u_cameraPosition;
+uniform mat4 u_viewProjection;
+${terrainCdlodGlsl}
+void main() {
+  vec2 uv;
+  vec3 pos = a3dTerrainCdlod(a_grid, a_node, uv);
+  v_worldPosition = pos;
+  v_terrainUv = uv;
+  gl_Position = u_viewProjection * vec4(pos, 1.0);
+}
+`;
+const terrainFragBody = /* glsl */ `// prd10.terrain — RenderDevice shader marker
+precision highp float;
+in vec3 v_worldPosition;
+in vec2 v_terrainUv;
+out vec4 o_color;
+// float, not int: the device uploads JS numbers with uniform1f, which is
+// INVALID_OPERATION on an int uniform (the count stayed 0 → black terrain).
+uniform float u_layerCount;
+uniform vec3 u_cameraPosition;
+uniform vec3 u_ambient;
+uniform vec3 u_keyLightDir;      // direction light travels (e.g. sun → scene)
+uniform vec3 u_keyLightColor;
+${terrainSplatGlsl}
+void main() {
+  if (a3dTerrainDiscardHole(v_terrainUv)) discard;
+  int layerCount = int(u_layerCount + 0.5);
+  vec3 n = a3dTerrainMacroNormal(v_terrainUv);
+  float w[8];
+  a3dTerrainSplatWeights(v_terrainUv, layerCount, w);
+  float viewDist = distance(u_cameraPosition, v_worldPosition);
+  a3dTerrainHeightBlend(w, v_worldPosition.xz, viewDist, layerCount);
+  float macro = texture(u_macroVariation, v_worldPosition.xz / 256.0).r;
+  vec3 albedo = vec3(0.0);
+  float roughness = 0.0;
+  for (int i = 0; i < 8; i++) {
+    if (i >= layerCount) break;
+    vec4 params = u_layerParams[i];
+    vec3 tint = u_layerTintOrm[i].rgb;
+#ifdef A3D_TERRAIN_SOLID
+    albedo += tint * (0.85 + 0.3 * macro) * w[i];
+    roughness += 0.85 * w[i];
+#else
+    vec2 uvA = v_worldPosition.xz / max(params.x, 1e-3);
+    vec2 uvB = mat2(0.80902, 0.58779, -0.58779, 0.80902) * uvA; // rot(0.62) second-scale anti-tiling
+    vec4 ah = mix(texture(u_layerAlbedoHeight, vec3(uvA, float(i))),
+                  texture(u_layerAlbedoHeight, vec3(uvB, float(i))),
+                  clamp(macro * 2.0, 0.0, 1.0));
+    albedo += ah.rgb * tint * w[i];
+    roughness += texture(u_layerOrm, vec3(uvA, float(i))).g * w[i];
+#endif
+    roughness += u_layerTintOrm[i].a * w[i];
+  }
+  float ndl = max(dot(n, -u_keyLightDir), 0.0);
+  vec3 col = albedo * (u_ambient + u_keyLightColor * ndl);
+  o_color = vec4(col, 1.0);
+}
+`;
+/** Textured terrain program (layer albedo/height + ORM texture arrays bound). */
+export const TERRAIN_FRAG_GLSL = `#version 300 es\n${terrainFragBody}`;
+/** Tint-only terrain program for Path S: declares no sampler2DArray (see the splat chunk). */
+export const TERRAIN_FRAG_SOLID_GLSL = `#version 300 es\n#define A3D_TERRAIN_SOLID 1\n${terrainFragBody}`;
+/**
+ * T2.4 — WGSL twin of the Path S terrain program (TERRAIN_VERT_GLSL +
+ * TERRAIN_FRAG_GLSL), composed from the same chunk function bodies.
+ *
+ * Bind layout (one module, no collisions):
+ *   @group(0): 0 `u_terrain` (CDLOD), 1 `u_height`, 2 `u_camera`, 3 `u_view`
+ *   @group(1): 0..6 splat/hole/layer/macro textures, 7 `u_samp`, 8 `u_terrainFrag`
+ * The fragment entry takes every derivative first, in uniform control flow,
+ * and defers `discard` to the end, so the layer loop uses explicit-gradient
+ * fetches (`textureSampleGrad`) exactly like the GLSL implicit-derivative path.
+ * Validated by naga in `qr-prd10-wgsl.yml`; WebGPU consumption needs #260.
+ */
+export const TERRAIN_WGSL = /* wgsl */ `
+${terrainCdlodWgslUniformStruct}
+${terrainSplatWgslUniformStruct}
+struct A3dTerrainView {
+  viewProjection : mat4x4f,
+  ambient : vec3f,
+  keyLightDir : vec3f,        // direction light travels (e.g. sun -> scene)
+  keyLightColor : vec3f,
+};
+${terrainCdlodWgslBindings}
+@group(0) @binding(3) var<uniform> u_view : A3dTerrainView;
+${terrainSplatWgslBindings}
+${terrainCdlodWgslFunctions}
+${terrainSplatWgslFunctions}
+struct TerrainVsOut {
+  @builtin(position) position : vec4f,
+  @location(0) terrainUv : vec2f,
+  @location(1) worldPosition : vec3f,
+};
+
+@vertex
+fn terrainVs(@location(0) a_grid : vec2f, @location(1) a_node : vec4f) -> TerrainVsOut {
+  let v = a3dTerrainCdlod(a_grid, a_node);
+  var o : TerrainVsOut;
+  o.position = u_view.viewProjection * vec4f(v.world, 1.0);
+  o.terrainUv = v.uv;
+  o.worldPosition = v.world;
+  return o;
+}
+
+@fragment
+fn terrainFs(in_ : TerrainVsOut) -> @location(0) vec4f {
+  let uv = in_.terrainUv;
+  let xz = in_.worldPosition.xz;
+  // Uniform control flow: all derivatives before any branch, loop or discard.
+  let dUvDx = dpdx(uv);
+  let dUvDy = dpdy(uv);
+  let dXZDx = dpdx(xz);
+  let dXZDy = dpdy(xz);
+  let hole = a3dTerrainDiscardHole(uv);
+  let n = a3dTerrainMacroNormal(uv);
+  let layerCount = u_terrainFrag.layerCount;
+  var w = a3dTerrainSplatWeights(uv, dUvDx, dUvDy, layerCount);
+  let viewDist = distance(u_camera, in_.worldPosition);
+  w = a3dTerrainHeightBlend(w, xz, dXZDx, dXZDy, viewDist, layerCount);
+  let macroN = textureSampleGrad(u_macroVariation, u_samp, xz / 256.0, dXZDx / 256.0, dXZDy / 256.0).r;
+  let rot = mat2x2f(0.80902, 0.58779, -0.58779, 0.80902); // rot(0.62) second-scale anti-tiling
+  var albedo = vec3f(0.0);
+  var roughness = 0.0;
+  for (var i = 0; i < 8; i = i + 1) {
+    if (i >= layerCount) { break; }
+    let params = u_terrainFrag.layerParams[i];
+    let tint = u_terrainFrag.layerTintOrm[i].rgb;
+    if (u_terrainFrag.solidMode == 0) {
+      let inv = 1.0 / max(params.x, 1e-3);
+      let uvA = xz * inv;
+      let gAx = dXZDx * inv;
+      let gAy = dXZDy * inv;
+      let ah = mix(textureSampleGrad(u_layerAlbedoHeight, u_samp, uvA, i, gAx, gAy),
+                   textureSampleGrad(u_layerAlbedoHeight, u_samp, rot * uvA, i, rot * gAx, rot * gAy),
+                   clamp(macroN * 2.0, 0.0, 1.0));
+      albedo = albedo + ah.rgb * tint * w[i];
+      roughness = roughness + textureSampleGrad(u_layerOrm, u_samp, uvA, i, gAx, gAy).g * w[i];
+    } else {
+      albedo = albedo + tint * (0.85 + 0.3 * macroN) * w[i];
+      roughness = roughness + 0.85 * w[i];
+    }
+    roughness = roughness + u_terrainFrag.layerTintOrm[i].a * w[i];
+  }
+  if (hole) { discard; }
+  let ndl = max(dot(n, -u_view.keyLightDir), 0.0);
+  let col = albedo * (u_view.ambient + u_view.keyLightColor * ndl);
+  return vec4f(col, 1.0);
+}
+`;
+//# sourceMappingURL=terrain.vert.glsl.js.map

package/dist/world/terrain/shaders/terrain.vert.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.vert.glsl.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/terrain/shaders/terrain.vert.glsl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;EAO1C,gBAAgB;;;;;;;;CAQjB,CAAC;AAEF,MAAM,eAAe,GAAG,UAAU,CAAC;;;;;;;;;;;;EAYjC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCjB,CAAC;AAEF,iFAAiF;AACjF,MAAM,CAAC,MAAM,iBAAiB,GAAG,oBAAoB,eAAe,EAAE,CAAC;AAEvE,8FAA8F;AAC9F,MAAM,CAAC,MAAM,uBAAuB,GAAG,iDAAiD,eAAe,EAAE,CAAC;AAE1G;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;EACrC,6BAA6B;EAC7B,6BAA6B;;;;;;;EAO7B,wBAAwB;;EAExB,wBAAwB;EACxB,yBAAyB;EACzB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D1B,CAAC"}

package/dist/world/terrain/shaders/terrainCdlod.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `a3d_prd10_terrain_cdlod` — PRD-10 §8.1 terrain CDLOD vertex chunk.
+ * Patch-instanced heightfield: manual bilinear height fetch (matches the CPU
+ * `heightAt` within 1e-4 m) + geometric morph toward the parent grid.
+ * Path S links this body; Path G consumes it through the `prd10.terrain` feature.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+/** Shared by the terrain program and the SplatBake pass so both run the §8.1 kernel verbatim. */
+export declare const a3dTerrainHeightBilinearGlsl = "\nuniform highp sampler2D u_height;       // R32F (or RGBA32F-packed), texelFetch only\nuniform float u_heightScale;\nuniform vec2 u_heightTexSize;\n\n// Must match AuraTerrainHandle.heightAt bit-for-bit within 1e-4 m: border\n// texels clamp so the CPU and GPU kernels agree at the last texel.\nfloat a3dTerrainHeightBilinear(vec2 uv) {\n  vec2 p = uv * (u_heightTexSize - 1.0);\n  ivec2 i = ivec2(floor(p));\n  ivec2 hi = ivec2(u_heightTexSize) - ivec2(1);\n  vec2 f = fract(p);\n  float h00 = texelFetch(u_height, clamp(i,                 ivec2(0), hi), 0).r;\n  float h10 = texelFetch(u_height, clamp(i + ivec2(1, 0),   ivec2(0), hi), 0).r;\n  float h01 = texelFetch(u_height, clamp(i + ivec2(0, 1),   ivec2(0), hi), 0).r;\n  float h11 = texelFetch(u_height, clamp(i + ivec2(1, 1),   ivec2(0), hi), 0).r;\n  return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y) * u_heightScale;\n}\n";
+export declare const terrainCdlodGlsl = "\n\nuniform highp sampler2D u_height;       // R32F (or RGBA32F-packed), texelFetch only\nuniform float u_heightScale;\nuniform vec2 u_heightTexSize;\n\n// Must match AuraTerrainHandle.heightAt bit-for-bit within 1e-4 m: border\n// texels clamp so the CPU and GPU kernels agree at the last texel.\nfloat a3dTerrainHeightBilinear(vec2 uv) {\n  vec2 p = uv * (u_heightTexSize - 1.0);\n  ivec2 i = ivec2(floor(p));\n  ivec2 hi = ivec2(u_heightTexSize) - ivec2(1);\n  vec2 f = fract(p);\n  float h00 = texelFetch(u_height, clamp(i,                 ivec2(0), hi), 0).r;\n  float h10 = texelFetch(u_height, clamp(i + ivec2(1, 0),   ivec2(0), hi), 0).r;\n  float h01 = texelFetch(u_height, clamp(i + ivec2(0, 1),   ivec2(0), hi), 0).r;\n  float h11 = texelFetch(u_height, clamp(i + ivec2(1, 1),   ivec2(0), hi), 0).r;\n  return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y) * u_heightScale;\n}\n\nuniform vec4 u_terrain;                 // originX, originZ, sizeX, sizeZ\nuniform vec4 u_morph[8];                // per LOD: x morphStart, y morphEnd (distance); vec4 so the\n                                        // 32-float upload is a vec4 array, not a 16-float \"mat4\"\nuniform float u_gridDim;                // patch quads per side (32 or 64)\n\nout vec3 v_worldPosition;\nout vec2 v_terrainUv;\n\n// Full patch displacement for one vertex. a_grid: patch-local [0,1];\n// a_node: per-instance {offsetX, offsetZ, nodeSize, lod}.\nvec3 a3dTerrainCdlod(vec2 a_grid, vec4 a_node, out vec2 outTerrainUv) {\n  vec2 world = a_node.xy + a_grid * a_node.z;\n  float h = a3dTerrainHeightBilinear((world - u_terrain.xy) / u_terrain.zw);\n  float d = distance(u_cameraPosition, vec3(world.x, h, world.y));\n  int lod = int(a_node.w);\n  float morph = clamp((d - u_morph[lod].x) / (u_morph[lod].y - u_morph[lod].x), 0.0, 1.0);\n  vec2 fracPart = fract(a_grid * u_gridDim * 0.5) * 2.0 / u_gridDim; // odd vertices\n  world -= fracPart * a_node.z * morph;                              // snap toward parent grid\n  vec2 uv = (world - u_terrain.xy) / u_terrain.zw;\n  h = a3dTerrainHeightBilinear(uv);\n  outTerrainUv = uv;\n  return vec3(world.x, h, world.y);\n}\n";
+/**
+ * WGSL twin, split into binding declarations and function bodies so the
+ * standalone chunk twin and the composed `TERRAIN_WGSL` program share the
+ * function text verbatim while the program owns one non-colliding layout.
+ * `morph` is `array<vec4f, 8>` (xy used): uniform-space arrays need a
+ * 16-byte stride, matching the std140 layout of the GLSL `u_morph[8]`.
+ */
+export declare const terrainCdlodWgslUniformStruct = "\nstruct A3dTerrainUniforms {\n  terrain : vec4f,            // originX, originZ, sizeX, sizeZ\n  heightScale : f32,\n  gridDim : f32,\n  heightTexSize : vec2f,\n  morph : array<vec4f, 8>,    // per LOD: xy = morphStart, morphEnd (distance)\n};\n";
+export declare const terrainCdlodWgslBindings = "\n@group(0) @binding(0) var<uniform> u_terrain : A3dTerrainUniforms;\n@group(0) @binding(1) var u_height : texture_2d<f32>;\n@group(0) @binding(2) var<uniform> u_camera : vec3f;\n";
+export declare const terrainCdlodWgslFunctions = "\nfn a3dTerrainHeightBilinear(uv : vec2f) -> f32 {\n  let p = uv * (u_terrain.heightTexSize - vec2f(1.0));\n  let i = vec2i(floor(p));\n  let hi = vec2i(u_terrain.heightTexSize) - vec2i(1);\n  let f = fract(p);\n  let h00 = textureLoad(u_height, clamp(i,                    vec2i(0), hi), 0).r;\n  let h10 = textureLoad(u_height, clamp(i + vec2i(1, 0),      vec2i(0), hi), 0).r;\n  let h01 = textureLoad(u_height, clamp(i + vec2i(0, 1),      vec2i(0), hi), 0).r;\n  let h11 = textureLoad(u_height, clamp(i + vec2i(1, 1),      vec2i(0), hi), 0).r;\n  return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y) * u_terrain.heightScale;\n}\n\nstruct A3dTerrainVertex {\n  world : vec3f,\n  uv : vec2f,\n};\n\n// Full patch displacement for one vertex (mirrors the GLSL a3dTerrainCdlod,\n// returning the terrain UV the GLSL passes through its out parameter).\nfn a3dTerrainCdlod(aGrid : vec2f, aNode : vec4f) -> A3dTerrainVertex {\n  var world = aNode.xy + aGrid * aNode.z;\n  var h = a3dTerrainHeightBilinear((world - u_terrain.terrain.xy) / u_terrain.terrain.zw);\n  let d = distance(u_camera, vec3f(world.x, h, world.y));\n  let lod = clamp(i32(aNode.w), 0, 7);\n  let m = u_terrain.morph[lod];\n  let morph = clamp((d - m.x) / (m.y - m.x), 0.0, 1.0);\n  let fracPart = fract(aGrid * u_terrain.gridDim * 0.5) * 2.0 / u_terrain.gridDim;\n  world = world - fracPart * aNode.z * morph;\n  let uv = (world - u_terrain.terrain.xy) / u_terrain.terrain.zw;\n  h = a3dTerrainHeightBilinear(uv);\n  return A3dTerrainVertex(vec3f(world.x, h, world.y), uv);\n}\n";
+export declare const terrainCdlodWgsl: string;
+export declare const a3d_prd10_terrain_cdlod: ShaderChunk;
+//# sourceMappingURL=terrainCdlod.d.ts.map

package/dist/world/terrain/shaders/terrainCdlod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainCdlod.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/terrain/shaders/terrainCdlod.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,iGAAiG;AACjG,eAAO,MAAM,4BAA4B,83BAkBxC,CAAC;AAEF,eAAO,MAAM,gBAAgB,6mEAyB5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,2PAQzC,CAAC;AAEF,eAAO,MAAM,wBAAwB,wLAIpC,CAAC;AAEF,eAAO,MAAM,yBAAyB,ihDAiCrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAuF,CAAC;AAErH,eAAO,MAAM,uBAAuB,EAAE,WAMrC,CAAC"}

package/dist/world/terrain/shaders/terrainCdlod.js

@@ -0,0 +1,110 @@
+/** Shared by the terrain program and the SplatBake pass so both run the §8.1 kernel verbatim. */
+export const a3dTerrainHeightBilinearGlsl = /* glsl */ `
+uniform highp sampler2D u_height;       // R32F (or RGBA32F-packed), texelFetch only
+uniform float u_heightScale;
+uniform vec2 u_heightTexSize;
+
+// Must match AuraTerrainHandle.heightAt bit-for-bit within 1e-4 m: border
+// texels clamp so the CPU and GPU kernels agree at the last texel.
+float a3dTerrainHeightBilinear(vec2 uv) {
+  vec2 p = uv * (u_heightTexSize - 1.0);
+  ivec2 i = ivec2(floor(p));
+  ivec2 hi = ivec2(u_heightTexSize) - ivec2(1);
+  vec2 f = fract(p);
+  float h00 = texelFetch(u_height, clamp(i,                 ivec2(0), hi), 0).r;
+  float h10 = texelFetch(u_height, clamp(i + ivec2(1, 0),   ivec2(0), hi), 0).r;
+  float h01 = texelFetch(u_height, clamp(i + ivec2(0, 1),   ivec2(0), hi), 0).r;
+  float h11 = texelFetch(u_height, clamp(i + ivec2(1, 1),   ivec2(0), hi), 0).r;
+  return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y) * u_heightScale;
+}
+`;
+export const terrainCdlodGlsl = /* glsl */ `
+${a3dTerrainHeightBilinearGlsl}
+uniform vec4 u_terrain;                 // originX, originZ, sizeX, sizeZ
+uniform vec4 u_morph[8];                // per LOD: x morphStart, y morphEnd (distance); vec4 so the
+                                        // 32-float upload is a vec4 array, not a 16-float "mat4"
+uniform float u_gridDim;                // patch quads per side (32 or 64)
+
+out vec3 v_worldPosition;
+out vec2 v_terrainUv;
+
+// Full patch displacement for one vertex. a_grid: patch-local [0,1];
+// a_node: per-instance {offsetX, offsetZ, nodeSize, lod}.
+vec3 a3dTerrainCdlod(vec2 a_grid, vec4 a_node, out vec2 outTerrainUv) {
+  vec2 world = a_node.xy + a_grid * a_node.z;
+  float h = a3dTerrainHeightBilinear((world - u_terrain.xy) / u_terrain.zw);
+  float d = distance(u_cameraPosition, vec3(world.x, h, world.y));
+  int lod = int(a_node.w);
+  float morph = clamp((d - u_morph[lod].x) / (u_morph[lod].y - u_morph[lod].x), 0.0, 1.0);
+  vec2 fracPart = fract(a_grid * u_gridDim * 0.5) * 2.0 / u_gridDim; // odd vertices
+  world -= fracPart * a_node.z * morph;                              // snap toward parent grid
+  vec2 uv = (world - u_terrain.xy) / u_terrain.zw;
+  h = a3dTerrainHeightBilinear(uv);
+  outTerrainUv = uv;
+  return vec3(world.x, h, world.y);
+}
+`;
+/**
+ * WGSL twin, split into binding declarations and function bodies so the
+ * standalone chunk twin and the composed `TERRAIN_WGSL` program share the
+ * function text verbatim while the program owns one non-colliding layout.
+ * `morph` is `array<vec4f, 8>` (xy used): uniform-space arrays need a
+ * 16-byte stride, matching the std140 layout of the GLSL `u_morph[8]`.
+ */
+export const terrainCdlodWgslUniformStruct = /* wgsl */ `
+struct A3dTerrainUniforms {
+  terrain : vec4f,            // originX, originZ, sizeX, sizeZ
+  heightScale : f32,
+  gridDim : f32,
+  heightTexSize : vec2f,
+  morph : array<vec4f, 8>,    // per LOD: xy = morphStart, morphEnd (distance)
+};
+`;
+export const terrainCdlodWgslBindings = /* wgsl */ `
+@group(0) @binding(0) var<uniform> u_terrain : A3dTerrainUniforms;
+@group(0) @binding(1) var u_height : texture_2d<f32>;
+@group(0) @binding(2) var<uniform> u_camera : vec3f;
+`;
+export const terrainCdlodWgslFunctions = /* wgsl */ `
+fn a3dTerrainHeightBilinear(uv : vec2f) -> f32 {
+  let p = uv * (u_terrain.heightTexSize - vec2f(1.0));
+  let i = vec2i(floor(p));
+  let hi = vec2i(u_terrain.heightTexSize) - vec2i(1);
+  let f = fract(p);
+  let h00 = textureLoad(u_height, clamp(i,                    vec2i(0), hi), 0).r;
+  let h10 = textureLoad(u_height, clamp(i + vec2i(1, 0),      vec2i(0), hi), 0).r;
+  let h01 = textureLoad(u_height, clamp(i + vec2i(0, 1),      vec2i(0), hi), 0).r;
+  let h11 = textureLoad(u_height, clamp(i + vec2i(1, 1),      vec2i(0), hi), 0).r;
+  return mix(mix(h00, h10, f.x), mix(h01, h11, f.x), f.y) * u_terrain.heightScale;
+}
+
+struct A3dTerrainVertex {
+  world : vec3f,
+  uv : vec2f,
+};
+
+// Full patch displacement for one vertex (mirrors the GLSL a3dTerrainCdlod,
+// returning the terrain UV the GLSL passes through its out parameter).
+fn a3dTerrainCdlod(aGrid : vec2f, aNode : vec4f) -> A3dTerrainVertex {
+  var world = aNode.xy + aGrid * aNode.z;
+  var h = a3dTerrainHeightBilinear((world - u_terrain.terrain.xy) / u_terrain.terrain.zw);
+  let d = distance(u_camera, vec3f(world.x, h, world.y));
+  let lod = clamp(i32(aNode.w), 0, 7);
+  let m = u_terrain.morph[lod];
+  let morph = clamp((d - m.x) / (m.y - m.x), 0.0, 1.0);
+  let fracPart = fract(aGrid * u_terrain.gridDim * 0.5) * 2.0 / u_terrain.gridDim;
+  world = world - fracPart * aNode.z * morph;
+  let uv = (world - u_terrain.terrain.xy) / u_terrain.terrain.zw;
+  h = a3dTerrainHeightBilinear(uv);
+  return A3dTerrainVertex(vec3f(world.x, h, world.y), uv);
+}
+`;
+export const terrainCdlodWgsl = terrainCdlodWgslUniformStruct + terrainCdlodWgslBindings + terrainCdlodWgslFunctions;
+export const a3d_prd10_terrain_cdlod = {
+    name: "a3d_prd10_terrain_cdlod",
+    owner: "prd10",
+    stage: "vertex",
+    glsl: terrainCdlodGlsl,
+    wgsl: terrainCdlodWgsl
+};
+//# sourceMappingURL=terrainCdlod.js.map

package/dist/world/terrain/shaders/terrainCdlod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainCdlod.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/terrain/shaders/terrainCdlod.ts"],"names":[],"mappings":"AAQA,iGAAiG;AACjG,MAAM,CAAC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;CAkBtD,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;EACzC,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;CAwB7B,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,UAAU,CAAC;;;;;;;;CAQvD,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;CAIlD,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCnD,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,6BAA6B,GAAG,wBAAwB,GAAG,yBAAyB,CAAC;AAErH,MAAM,CAAC,MAAM,uBAAuB,GAAgB;IAClD,IAAI,EAAE,yBAAyB;IAC/B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE,gBAAgB;IACtB,IAAI,EAAE,gBAAgB;CACvB,CAAC"}

package/dist/world/terrain/shaders/terrainSplat.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `a3d_prd10_terrain_splat` — PRD-10 §8.1 terrain splat fragment chunk.
+ * Macro normal from the height texture, splat weights, per-layer height-blend
+ * and anti-tiling second-scale sampling. Provides `a3dSurface` inputs to the
+ * shared PBR lighting on Path G; Path S links it directly.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+export declare const terrainSplatGlsl = "\nuniform highp sampler2D u_height;       // shared with the vertex stage\nuniform highp sampler2D u_splat0;       // layers 0..3 weights in RGBA\nuniform highp sampler2D u_splat1;       // layers 4..7 weights (optional)\nuniform highp sampler2D u_holes;        // 1-bit hole mask\n// A3D_TERRAIN_SOLID (tint-only Path S program): no layer texture arrays are\n// declared. An unbound sampler2DArray defaults to texture unit 0 next to the\n// sampler2D u_height, and two sampler types on one unit make every draw fail\n// with INVALID_OPERATION \u2014 the terrain never reached the frame.\n#ifndef A3D_TERRAIN_SOLID\nuniform highp sampler2DArray u_layerAlbedoHeight; // per layer: albedo RGB + height A\nuniform highp sampler2DArray u_layerNormal;       // per layer: tangent normal RG\nuniform highp sampler2DArray u_layerOrm;          // per layer: occlusion/roughness/metalness\n#endif\nuniform sampler2D u_macroVariation;     // macro anti-tiling noise\nuniform vec4 u_layerParams[8];          // x: uvScale, y: triplanar flag, z: heightBlendContrast, w: layer count\nuniform vec4 u_layerTintOrm[8];         // rgb: tint, a: roughness bias\nuniform float u_terrainWorldSize;       // world size per heightmap edge (for macro normal texel)\nuniform float u_terrainHeightScale;\n\n// Macro normal: central differences on 4 texelFetch of u_height (\u00A78.1).\nvec3 a3dTerrainMacroNormal(vec2 uv) {\n  ivec2 ts = textureSize(u_height, 0);\n  ivec2 i = ivec2(clamp(uv, vec2(0.0), vec2(1.0)) * vec2(ts - 1));\n  float texel = u_terrainWorldSize / float(ts.x);\n  float hL = texelFetch(u_height, clamp(i - ivec2(1, 0), ivec2(0), ts - 1), 0).r;\n  float hR = texelFetch(u_height, clamp(i + ivec2(1, 0), ivec2(0), ts - 1), 0).r;\n  float hD = texelFetch(u_height, clamp(i - ivec2(0, 1), ivec2(0), ts - 1), 0).r;\n  float hU = texelFetch(u_height, clamp(i + ivec2(0, 1), ivec2(0), ts - 1), 0).r;\n  return normalize(vec3((hL - hR) * u_terrainHeightScale, 2.0 * texel, (hD - hU) * u_terrainHeightScale));\n}\n\n// Splat weights w[0..7] from the two splat maps (w[4..7] zero without u_splat1).\nvoid a3dTerrainSplatWeights(vec2 uv, int layerCount, out float w[8]) {\n  vec4 s0 = texture(u_splat0, uv);\n  w[0] = s0.r; w[1] = s0.g; w[2] = s0.b; w[3] = s0.a;\n  if (layerCount > 4) {\n    vec4 s1 = texture(u_splat1, uv);\n    w[4] = s1.r; w[5] = s1.g; w[6] = s1.b; w[7] = s1.a;\n  } else {\n    w[4] = 0.0; w[5] = 0.0; w[6] = 0.0; w[7] = 0.0;\n  }\n}\n\n// Height-blend (\"height lerp\"): hb_i = w_i + height_i * contrast; renormalize\n// above (max(hb) - 0.2). Mutates w in place.\nvoid a3dTerrainHeightBlend(inout float w[8], vec2 worldXZ, float viewDist, int layerCount) {\n  float macro = texture(u_macroVariation, worldXZ / 256.0).r;\n  float t = smoothstep(20.0, 80.0, viewDist);\n  float hbMax = 0.0;\n  for (int i = 0; i < 8; i++) {\n    if (i >= layerCount) break;\n    vec4 params = u_layerParams[i];\n    vec2 uvA = worldXZ / max(params.x, 1e-3);\n#ifdef A3D_TERRAIN_SOLID\n    float heightA = 0.0 * uvA.x; // tint-only: no per-layer height maps\n#else\n    float heightA = texture(u_layerAlbedoHeight, vec3(uvA, float(i))).a;\n#endif\n    w[i] += heightA * params.z + macro * t * 0.05;\n    hbMax = max(hbMax, w[i]);\n  }\n  float m = hbMax - 0.2;\n  float sum = 0.0;\n  for (int i = 0; i < 8; i++) { w[i] = max(w[i] - m, 0.0); sum += w[i]; }\n  if (sum > 1e-6) {\n    for (int i = 0; i < 8; i++) w[i] /= sum;\n  }\n}\n\n// Holes: fragments under mask 0.5 are discarded (also feeds collider holes).\nbool a3dTerrainDiscardHole(vec2 uv) {\n  return texture(u_holes, uv).r < 0.5;\n}\n";
+/**
+ * WGSL twin, split like the CDLOD twin: the fragment resources live in
+ * `@group(1)` so they never collide with the vertex stage's `@group(0)`
+ * (`u_terrain`, `u_height`, `u_camera`) when `TERRAIN_WGSL` composes both.
+ * Every filtered fetch takes explicit gradients (`textureSampleGrad`) or an
+ * explicit level, so the bodies are valid in non-uniform control flow (the
+ * layer loop, the `layerCount > 4` branch) — WGSL forbids implicit-derivative
+ * `textureSample` there. Callers compute the gradients once at the top of the
+ * fragment entry point, in uniform control flow.
+ */
+export declare const terrainSplatWgslUniformStruct = "\nstruct A3dTerrainFragUniforms {\n  layerParams : array<vec4f, 8>,   // x: uvScale, y: triplanar flag, z: heightBlendContrast, w: layer count\n  layerTintOrm : array<vec4f, 8>,  // rgb: tint, a: roughness bias\n  terrainWorldSize : f32,\n  terrainHeightScale : f32,\n  layerCount : i32,\n  solidMode : i32,                 // 1 = no layer texture arrays bound (tint-only fallback)\n};\n";
+/** Height texture declaration for the standalone fragment twin (the program shares the vertex binding). */
+export declare const terrainSplatWgslHeightBinding = "\n@group(0) @binding(1) var u_height : texture_2d<f32>;\n";
+export declare const terrainSplatWgslBindings = "\n@group(1) @binding(0) var u_splat0 : texture_2d<f32>;\n@group(1) @binding(1) var u_splat1 : texture_2d<f32>;\n@group(1) @binding(2) var u_holes : texture_2d<f32>;\n@group(1) @binding(3) var u_layerAlbedoHeight : texture_2d_array<f32>;\n@group(1) @binding(4) var u_layerNormal : texture_2d_array<f32>;\n@group(1) @binding(5) var u_layerOrm : texture_2d_array<f32>;\n@group(1) @binding(6) var u_macroVariation : texture_2d<f32>;\n@group(1) @binding(7) var u_samp : sampler;\n@group(1) @binding(8) var<uniform> u_terrainFrag : A3dTerrainFragUniforms;\n";
+export declare const terrainSplatWgslFunctions = "\n// Macro normal: central differences on 4 textureLoad of u_height (\u00A78.1).\nfn a3dTerrainMacroNormal(uv : vec2f) -> vec3f {\n  let ts = vec2i(textureDimensions(u_height, 0));\n  let hi = ts - vec2i(1);\n  let i = vec2i(clamp(uv, vec2f(0.0), vec2f(1.0)) * vec2f(hi));\n  let texel = u_terrainFrag.terrainWorldSize / f32(ts.x);\n  let hL = textureLoad(u_height, clamp(i - vec2i(1, 0), vec2i(0), hi), 0).r;\n  let hR = textureLoad(u_height, clamp(i + vec2i(1, 0), vec2i(0), hi), 0).r;\n  let hD = textureLoad(u_height, clamp(i - vec2i(0, 1), vec2i(0), hi), 0).r;\n  let hU = textureLoad(u_height, clamp(i + vec2i(0, 1), vec2i(0), hi), 0).r;\n  let s = u_terrainFrag.terrainHeightScale;\n  return normalize(vec3f((hL - hR) * s, 2.0 * texel, (hD - hU) * s));\n}\n\n// Splat weights w[0..7] from the two splat maps (w[4..7] zero without u_splat1).\nfn a3dTerrainSplatWeights(uv : vec2f, dUvDx : vec2f, dUvDy : vec2f, layerCount : i32) -> array<f32, 8> {\n  var w : array<f32, 8>;\n  let s0 = textureSampleGrad(u_splat0, u_samp, uv, dUvDx, dUvDy);\n  w[0] = s0.r; w[1] = s0.g; w[2] = s0.b; w[3] = s0.a;\n  if (layerCount > 4) {\n    let s1 = textureSampleGrad(u_splat1, u_samp, uv, dUvDx, dUvDy);\n    w[4] = s1.r; w[5] = s1.g; w[6] = s1.b; w[7] = s1.a;\n  }\n  return w;\n}\n\n// Height-blend (\"height lerp\"): hb_i = w_i + height_i * contrast; renormalize\n// above (max(hb) - 0.2). Mirrors the GLSL a3dTerrainHeightBlend; WGSL has no\n// inout arrays, so the blended weights are returned.\nfn a3dTerrainHeightBlend(wIn : array<f32, 8>, worldXZ : vec2f, dXZDx : vec2f, dXZDy : vec2f,\n                         viewDist : f32, layerCount : i32) -> array<f32, 8> {\n  var w = wIn;\n  let macroN = textureSampleGrad(u_macroVariation, u_samp, worldXZ / 256.0, dXZDx / 256.0, dXZDy / 256.0).r; // \"macro\" is a WGSL reserved word\n  let t = smoothstep(20.0, 80.0, viewDist);\n  var hbMax = 0.0;\n  for (var i = 0; i < 8; i = i + 1) {\n    if (i >= layerCount) { break; }\n    let params = u_terrainFrag.layerParams[i];\n    let inv = 1.0 / max(params.x, 1e-3);\n    var heightA = 0.0;\n    if (u_terrainFrag.solidMode == 0) {\n      heightA = textureSampleGrad(u_layerAlbedoHeight, u_samp, worldXZ * inv, i, dXZDx * inv, dXZDy * inv).a;\n    }\n    w[i] = w[i] + heightA * params.z + macroN * t * 0.05;\n    hbMax = max(hbMax, w[i]);\n  }\n  let m = hbMax - 0.2;\n  var sum = 0.0;\n  for (var i = 0; i < 8; i = i + 1) { w[i] = max(w[i] - m, 0.0); sum = sum + w[i]; }\n  if (sum > 1e-6) {\n    for (var i = 0; i < 8; i = i + 1) { w[i] = w[i] / sum; }\n  }\n  return w;\n}\n\n// Holes: fragments under mask 0.5 are discarded (also feeds collider holes).\n// Level 0 keeps the 1-bit mask crisp, exactly like the collider reads it.\nfn a3dTerrainDiscardHole(uv : vec2f) -> bool {\n  return textureSampleLevel(u_holes, u_samp, uv, 0.0).r < 0.5;\n}\n";
+export declare const terrainSplatWgsl: string;
+export declare const a3d_prd10_terrain_splat: ShaderChunk;
+//# sourceMappingURL=terrainSplat.d.ts.map

package/dist/world/terrain/shaders/terrainSplat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainSplat.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/terrain/shaders/terrainSplat.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,eAAO,MAAM,gBAAgB,sgHA0E5B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,wYASzC,CAAC;AAEF,2GAA2G;AAC3G,eAAO,MAAM,6BAA6B,8DAEzC,CAAC;AAEF,eAAO,MAAM,wBAAwB,4iBAUpC,CAAC;AAEF,eAAO,MAAM,yBAAyB,+xFA6DrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,QACyF,CAAC;AAEvH,eAAO,MAAM,uBAAuB,EAAE,WAMrC,CAAC"}

package/dist/world/terrain/shaders/terrainSplat.js

@@ -0,0 +1,181 @@
+export const terrainSplatGlsl = /* glsl */ `
+uniform highp sampler2D u_height;       // shared with the vertex stage
+uniform highp sampler2D u_splat0;       // layers 0..3 weights in RGBA
+uniform highp sampler2D u_splat1;       // layers 4..7 weights (optional)
+uniform highp sampler2D u_holes;        // 1-bit hole mask
+// A3D_TERRAIN_SOLID (tint-only Path S program): no layer texture arrays are
+// declared. An unbound sampler2DArray defaults to texture unit 0 next to the
+// sampler2D u_height, and two sampler types on one unit make every draw fail
+// with INVALID_OPERATION — the terrain never reached the frame.
+#ifndef A3D_TERRAIN_SOLID
+uniform highp sampler2DArray u_layerAlbedoHeight; // per layer: albedo RGB + height A
+uniform highp sampler2DArray u_layerNormal;       // per layer: tangent normal RG
+uniform highp sampler2DArray u_layerOrm;          // per layer: occlusion/roughness/metalness
+#endif
+uniform sampler2D u_macroVariation;     // macro anti-tiling noise
+uniform vec4 u_layerParams[8];          // x: uvScale, y: triplanar flag, z: heightBlendContrast, w: layer count
+uniform vec4 u_layerTintOrm[8];         // rgb: tint, a: roughness bias
+uniform float u_terrainWorldSize;       // world size per heightmap edge (for macro normal texel)
+uniform float u_terrainHeightScale;
+
+// Macro normal: central differences on 4 texelFetch of u_height (§8.1).
+vec3 a3dTerrainMacroNormal(vec2 uv) {
+  ivec2 ts = textureSize(u_height, 0);
+  ivec2 i = ivec2(clamp(uv, vec2(0.0), vec2(1.0)) * vec2(ts - 1));
+  float texel = u_terrainWorldSize / float(ts.x);
+  float hL = texelFetch(u_height, clamp(i - ivec2(1, 0), ivec2(0), ts - 1), 0).r;
+  float hR = texelFetch(u_height, clamp(i + ivec2(1, 0), ivec2(0), ts - 1), 0).r;
+  float hD = texelFetch(u_height, clamp(i - ivec2(0, 1), ivec2(0), ts - 1), 0).r;
+  float hU = texelFetch(u_height, clamp(i + ivec2(0, 1), ivec2(0), ts - 1), 0).r;
+  return normalize(vec3((hL - hR) * u_terrainHeightScale, 2.0 * texel, (hD - hU) * u_terrainHeightScale));
+}
+
+// Splat weights w[0..7] from the two splat maps (w[4..7] zero without u_splat1).
+void a3dTerrainSplatWeights(vec2 uv, int layerCount, out float w[8]) {
+  vec4 s0 = texture(u_splat0, uv);
+  w[0] = s0.r; w[1] = s0.g; w[2] = s0.b; w[3] = s0.a;
+  if (layerCount > 4) {
+    vec4 s1 = texture(u_splat1, uv);
+    w[4] = s1.r; w[5] = s1.g; w[6] = s1.b; w[7] = s1.a;
+  } else {
+    w[4] = 0.0; w[5] = 0.0; w[6] = 0.0; w[7] = 0.0;
+  }
+}
+
+// Height-blend ("height lerp"): hb_i = w_i + height_i * contrast; renormalize
+// above (max(hb) - 0.2). Mutates w in place.
+void a3dTerrainHeightBlend(inout float w[8], vec2 worldXZ, float viewDist, int layerCount) {
+  float macro = texture(u_macroVariation, worldXZ / 256.0).r;
+  float t = smoothstep(20.0, 80.0, viewDist);
+  float hbMax = 0.0;
+  for (int i = 0; i < 8; i++) {
+    if (i >= layerCount) break;
+    vec4 params = u_layerParams[i];
+    vec2 uvA = worldXZ / max(params.x, 1e-3);
+#ifdef A3D_TERRAIN_SOLID
+    float heightA = 0.0 * uvA.x; // tint-only: no per-layer height maps
+#else
+    float heightA = texture(u_layerAlbedoHeight, vec3(uvA, float(i))).a;
+#endif
+    w[i] += heightA * params.z + macro * t * 0.05;
+    hbMax = max(hbMax, w[i]);
+  }
+  float m = hbMax - 0.2;
+  float sum = 0.0;
+  for (int i = 0; i < 8; i++) { w[i] = max(w[i] - m, 0.0); sum += w[i]; }
+  if (sum > 1e-6) {
+    for (int i = 0; i < 8; i++) w[i] /= sum;
+  }
+}
+
+// Holes: fragments under mask 0.5 are discarded (also feeds collider holes).
+bool a3dTerrainDiscardHole(vec2 uv) {
+  return texture(u_holes, uv).r < 0.5;
+}
+`;
+/**
+ * WGSL twin, split like the CDLOD twin: the fragment resources live in
+ * `@group(1)` so they never collide with the vertex stage's `@group(0)`
+ * (`u_terrain`, `u_height`, `u_camera`) when `TERRAIN_WGSL` composes both.
+ * Every filtered fetch takes explicit gradients (`textureSampleGrad`) or an
+ * explicit level, so the bodies are valid in non-uniform control flow (the
+ * layer loop, the `layerCount > 4` branch) — WGSL forbids implicit-derivative
+ * `textureSample` there. Callers compute the gradients once at the top of the
+ * fragment entry point, in uniform control flow.
+ */
+export const terrainSplatWgslUniformStruct = /* wgsl */ `
+struct A3dTerrainFragUniforms {
+  layerParams : array<vec4f, 8>,   // x: uvScale, y: triplanar flag, z: heightBlendContrast, w: layer count
+  layerTintOrm : array<vec4f, 8>,  // rgb: tint, a: roughness bias
+  terrainWorldSize : f32,
+  terrainHeightScale : f32,
+  layerCount : i32,
+  solidMode : i32,                 // 1 = no layer texture arrays bound (tint-only fallback)
+};
+`;
+/** Height texture declaration for the standalone fragment twin (the program shares the vertex binding). */
+export const terrainSplatWgslHeightBinding = /* wgsl */ `
+@group(0) @binding(1) var u_height : texture_2d<f32>;
+`;
+export const terrainSplatWgslBindings = /* wgsl */ `
+@group(1) @binding(0) var u_splat0 : texture_2d<f32>;
+@group(1) @binding(1) var u_splat1 : texture_2d<f32>;
+@group(1) @binding(2) var u_holes : texture_2d<f32>;
+@group(1) @binding(3) var u_layerAlbedoHeight : texture_2d_array<f32>;
+@group(1) @binding(4) var u_layerNormal : texture_2d_array<f32>;
+@group(1) @binding(5) var u_layerOrm : texture_2d_array<f32>;
+@group(1) @binding(6) var u_macroVariation : texture_2d<f32>;
+@group(1) @binding(7) var u_samp : sampler;
+@group(1) @binding(8) var<uniform> u_terrainFrag : A3dTerrainFragUniforms;
+`;
+export const terrainSplatWgslFunctions = /* wgsl */ `
+// Macro normal: central differences on 4 textureLoad of u_height (§8.1).
+fn a3dTerrainMacroNormal(uv : vec2f) -> vec3f {
+  let ts = vec2i(textureDimensions(u_height, 0));
+  let hi = ts - vec2i(1);
+  let i = vec2i(clamp(uv, vec2f(0.0), vec2f(1.0)) * vec2f(hi));
+  let texel = u_terrainFrag.terrainWorldSize / f32(ts.x);
+  let hL = textureLoad(u_height, clamp(i - vec2i(1, 0), vec2i(0), hi), 0).r;
+  let hR = textureLoad(u_height, clamp(i + vec2i(1, 0), vec2i(0), hi), 0).r;
+  let hD = textureLoad(u_height, clamp(i - vec2i(0, 1), vec2i(0), hi), 0).r;
+  let hU = textureLoad(u_height, clamp(i + vec2i(0, 1), vec2i(0), hi), 0).r;
+  let s = u_terrainFrag.terrainHeightScale;
+  return normalize(vec3f((hL - hR) * s, 2.0 * texel, (hD - hU) * s));
+}
+
+// Splat weights w[0..7] from the two splat maps (w[4..7] zero without u_splat1).
+fn a3dTerrainSplatWeights(uv : vec2f, dUvDx : vec2f, dUvDy : vec2f, layerCount : i32) -> array<f32, 8> {
+  var w : array<f32, 8>;
+  let s0 = textureSampleGrad(u_splat0, u_samp, uv, dUvDx, dUvDy);
+  w[0] = s0.r; w[1] = s0.g; w[2] = s0.b; w[3] = s0.a;
+  if (layerCount > 4) {
+    let s1 = textureSampleGrad(u_splat1, u_samp, uv, dUvDx, dUvDy);
+    w[4] = s1.r; w[5] = s1.g; w[6] = s1.b; w[7] = s1.a;
+  }
+  return w;
+}
+
+// Height-blend ("height lerp"): hb_i = w_i + height_i * contrast; renormalize
+// above (max(hb) - 0.2). Mirrors the GLSL a3dTerrainHeightBlend; WGSL has no
+// inout arrays, so the blended weights are returned.
+fn a3dTerrainHeightBlend(wIn : array<f32, 8>, worldXZ : vec2f, dXZDx : vec2f, dXZDy : vec2f,
+                         viewDist : f32, layerCount : i32) -> array<f32, 8> {
+  var w = wIn;
+  let macroN = textureSampleGrad(u_macroVariation, u_samp, worldXZ / 256.0, dXZDx / 256.0, dXZDy / 256.0).r; // "macro" is a WGSL reserved word
+  let t = smoothstep(20.0, 80.0, viewDist);
+  var hbMax = 0.0;
+  for (var i = 0; i < 8; i = i + 1) {
+    if (i >= layerCount) { break; }
+    let params = u_terrainFrag.layerParams[i];
+    let inv = 1.0 / max(params.x, 1e-3);
+    var heightA = 0.0;
+    if (u_terrainFrag.solidMode == 0) {
+      heightA = textureSampleGrad(u_layerAlbedoHeight, u_samp, worldXZ * inv, i, dXZDx * inv, dXZDy * inv).a;
+    }
+    w[i] = w[i] + heightA * params.z + macroN * t * 0.05;
+    hbMax = max(hbMax, w[i]);
+  }
+  let m = hbMax - 0.2;
+  var sum = 0.0;
+  for (var i = 0; i < 8; i = i + 1) { w[i] = max(w[i] - m, 0.0); sum = sum + w[i]; }
+  if (sum > 1e-6) {
+    for (var i = 0; i < 8; i = i + 1) { w[i] = w[i] / sum; }
+  }
+  return w;
+}
+
+// Holes: fragments under mask 0.5 are discarded (also feeds collider holes).
+// Level 0 keeps the 1-bit mask crisp, exactly like the collider reads it.
+fn a3dTerrainDiscardHole(uv : vec2f) -> bool {
+  return textureSampleLevel(u_holes, u_samp, uv, 0.0).r < 0.5;
+}
+`;
+export const terrainSplatWgsl = terrainSplatWgslUniformStruct + terrainSplatWgslHeightBinding + terrainSplatWgslBindings + terrainSplatWgslFunctions;
+export const a3d_prd10_terrain_splat = {
+    name: "a3d_prd10_terrain_splat",
+    owner: "prd10",
+    stage: "fragment",
+    glsl: terrainSplatGlsl,
+    wgsl: terrainSplatWgsl
+};
+//# sourceMappingURL=terrainSplat.js.map

package/dist/world/terrain/shaders/terrainSplat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainSplat.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/terrain/shaders/terrainSplat.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0E1C,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,UAAU,CAAC;;;;;;;;;CASvD,CAAC;AAEF,2GAA2G;AAC3G,MAAM,CAAC,MAAM,6BAA6B,GAAG,UAAU,CAAC;;CAEvD,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;;;;;;;;;;CAUlD,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6DnD,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAC3B,6BAA6B,GAAG,6BAA6B,GAAG,wBAAwB,GAAG,yBAAyB,CAAC;AAEvH,MAAM,CAAC,MAAM,uBAAuB,GAAgB;IAClD,IAAI,EAAE,yBAAyB;IAC/B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI,EAAE,gBAAgB;IACtB,IAAI,EAAE,gBAAgB;CACvB,CAAC"}

package/dist/world/vegetation/FoliageMaterial.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PRD-10 T3.4 §8.3 — the standalone Path S foliage program for scatter draws:
+ * `a3d_prd10_wind` vertex deform + `a3d_prd10_foliage` fragment behaviour
+ * (alpha cutoff/A2C sharpen, two-sided normals, sun translucency, per-instance
+ * colour variation, screen-door crossfade) over the §9.3 compact32 instance
+ * layout. Path G reaches the same behaviour through `programCacheSlot`
+ * features (`prd10.wind` + `prd10.foliageTranslucency`).
+ */
+import type { ShaderSources } from "../../RenderDevice.js";
+/** Full sources for the standalone Path S foliage program. */
+export declare function foliageShaderSources(): ShaderSources;
+/** T3.4 — the C-03 lobe that adds the sun translucency term on Path G. */
+export declare function registerPrd10FoliageLobe(): () => void;
+//# sourceMappingURL=FoliageMaterial.d.ts.map

package/dist/world/vegetation/FoliageMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageMaterial.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/vegetation/FoliageMaterial.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAgF3D,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,aAAa,CAOpD;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,IAAI,MAAM,IAAI,CAkBrD"}