@aura3d/engine 3.0.0 → 4.0.0

package/dist/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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"}

package/dist/rendering/world/vegetation/FoliageMaterial.js

@@ -0,0 +1,107 @@
+import { registerMaterialLobe } from "../../contracts/materialLobes.js";
+import { a3d_prd10_foliage } from "./shaders/foliage.js";
+import { a3d_prd10_wind } from "./shaders/wind.js";
+const FOLIAGE_VERT = /* glsl */ `#version 300 es
+precision highp float;
+in vec3 a_position;
+in vec3 a_normal;
+in vec2 a_uv;
+in vec4 a_colorWeights;          // vertex colour wind weights (r bend, g flutter, b phase, a -)
+// compact32 instance record (yaw arrives normalized 0..1 from u16, scale from
+// a HALF_FLOAT attribute — GL converts both before the VS sees them)
+in vec3 a_instancePosition;
+in float a_instanceYaw;          // u16 unorm -> 0..1
+in float a_instanceScale;        // f16 -> f32
+in vec4 a_instanceVariation;     // unorm8x4 -> 0..1 per channel
+in vec4 a_instanceExtra;
+uniform mat4 u_viewProjection;
+uniform vec3 u_cameraPosition;
+uniform vec4 u_terrain;          // not used for foliage; keeps std layout
+uniform float u_time;
+uniform float u_assetHeight;
+uniform float u_lodFade;         // distance fade 0..1 (screen-door discard vs bayer)
+${a3d_prd10_wind.glsl}
+out vec3 v_worldPosition;
+out vec3 v_normal;
+out vec2 v_uv;
+out vec4 v_weights;
+out float v_variation;
+out float v_fade;
+void main() {
+  float yaw = a_instanceYaw * 6.28318530718;
+  float scale = a_instanceScale;
+  float cs = cos(yaw); float sn = sin(yaw);
+  vec3 local = vec3(a_position.x * cs + a_position.z * sn, a_position.y, -a_position.x * sn + a_position.z * cs) * scale;
+  vec3 world = local + a_instancePosition;
+  vec3 wind = a3dWindOffset(local, a_instancePosition, a_colorWeights, u_assetHeight);
+  world += wind;
+  vec3 n = normalize(vec3(a_normal.x * cs + a_normal.z * sn, a_normal.y, -a_normal.x * sn + a_normal.z * cs));
+  v_worldPosition = world;
+  v_normal = n;
+  v_uv = a_uv;
+  v_weights = a_colorWeights;
+  v_variation = a_instanceVariation.x;
+  v_fade = a_instanceVariation.y * u_lodFade;
+  gl_Position = u_viewProjection * vec4(world, 1.0);
+}
+`;
+const FOLIAGE_FRAG = /* glsl */ `#version 300 es
+precision highp float;
+in vec3 v_worldPosition;
+in vec3 v_normal;
+in vec2 v_uv;
+in vec4 v_weights;
+in float v_variation;
+in float v_fade;
+out vec4 o_color;
+uniform vec3 u_cameraPosition;
+uniform vec3 u_ambient;
+uniform vec3 u_keyLightDir;
+uniform vec3 u_keyLightColor;
+uniform vec3 u_translucencyColor;
+uniform float u_thickness;
+uniform float u_lod1Fade;        // 1 = keep, 0 = discard all (band fade)
+${a3d_prd10_foliage.glsl}
+void main() {
+  if (a3dBayer4x4(gl_FragCoord.xy) > v_fade * u_lod1Fade + 0.001) discard;
+  float alpha = a3dFoliageAlpha(v_uv);
+  vec3 n = a3dFoliageNormal(normalize(v_normal));
+  vec3 albedo = a3dInstanceVariation(texture(u_baseColor, v_uv).rgb, v_variation);
+  vec3 V = normalize(u_cameraPosition - v_worldPosition);
+  float ndl = max(dot(n, -u_keyLightDir), 0.0);
+  vec3 direct = albedo * (u_ambient + u_keyLightColor * ndl);
+  direct += a3dFoliageTranslucency(albedo, u_translucencyColor, u_thickness, V, u_keyLightDir, u_keyLightColor, 1.0);
+  o_color = vec4(direct, alpha);
+}
+`;
+/** Full sources for the standalone Path S foliage program. */
+export function foliageShaderSources() {
+    return {
+        label: "prd10-foliage",
+        marker: "prd10-foliage",
+        vertex: FOLIAGE_VERT,
+        fragment: FOLIAGE_FRAG
+    };
+}
+/** T3.4 — the C-03 lobe that adds the sun translucency term on Path G. */
+export function registerPrd10FoliageLobe() {
+    return registerMaterialLobe({
+        id: "prd10.foliageTranslucency",
+        owner: "prd10",
+        flag: "A3D_QR_WORLD",
+        chunks: { pars: "a3d_prd10_foliage", fragment: "a3d_prd10_foliage" },
+        samplerSlots: [],
+        feature(material) {
+            const translucency = material.parameters["translucencyColor"];
+            return translucency === undefined ? undefined : { lobe: "prd10.foliageTranslucency", maps: [], bits: { "prd10.foliageTranslucency": 1 } };
+        },
+        bind(material, set) {
+            const t = material.parameters["translucencyColor"];
+            if (t)
+                set("u_translucencyColor", [t[0] ?? 0, t[1] ?? 0, t[2] ?? 0]);
+            set("u_thickness", material.parameters["translucencyThickness"] ?? 1);
+            set("u_alphaCutoff", material.parameters["alphaCutoff"] ?? 0.5);
+        }
+    });
+}
+//# sourceMappingURL=FoliageMaterial.js.map

package/dist/rendering/world/vegetation/FoliageMaterial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageMaterial.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/vegetation/FoliageMaterial.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;EAmB9B,cAAc,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;CAwBpB,CAAC;AAEF,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;EAgB9B,iBAAiB,CAAC,IAAI;;;;;;;;;;;;CAYvB,CAAC;AAEF,8DAA8D;AAC9D,MAAM,UAAU,oBAAoB;IAClC,OAAO;QACL,KAAK,EAAE,eAAe;QACtB,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,YAAY;QACpB,QAAQ,EAAE,YAAY;KACvB,CAAC;AACJ,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,wBAAwB;IACtC,OAAO,oBAAoB,CAAC;QAC1B,EAAE,EAAE,2BAA2B;QAC/B,KAAK,EAAE,OAAO;QACd,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,QAAQ,EAAE,mBAAmB,EAAE;QACpE,YAAY,EAAE,EAAE;QAChB,OAAO,CAAC,QAAQ;YACd,MAAM,YAAY,GAAG,QAAQ,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;YAC9D,OAAO,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,2BAA2B,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,2BAA2B,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5I,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,GAAG;YAChB,MAAM,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,mBAAmB,CAAkC,CAAC;YACpF,IAAI,CAAC;gBAAE,GAAG,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACrE,GAAG,CAAC,aAAa,EAAG,QAAQ,CAAC,UAAU,CAAC,uBAAuB,CAAwB,IAAI,CAAC,CAAC,CAAC;YAC9F,GAAG,CAAC,eAAe,EAAG,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAwB,IAAI,GAAG,CAAC,CAAC;QAC1F,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/rendering/world/vegetation/GrassField.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PRD-10 T3.7 §8.5 — `GrassField`: the camera-following ring of 8 m grass
+ * chunks. Blades are generated entirely in the vertex stage (§8.5
+ * `a3d_prd10_grass` — stratified jitter hash per `gl_InstanceID`, quadratic
+ * Bézier blade, density falloff); this module only computes which chunk
+ * origins + seeds draw this frame, and the shared blade index/vertex data.
+ *
+ * Tier rules (§7.1.5 grass options + §17):
+ * - Medium+ draws 7-vertex blades; Low draws 2-triangle cards with the same
+ *   placement hash.
+ * - The chunk ring extends to `radius`; chunks whose centre is farther than
+ *   `radius` from the camera are dropped before upload.
+ */
+export declare const GRASS_CHUNK_SIZE = 8;
+export declare const GRASS_BLADE_VERTS = 7;
+export declare const GRASS_CARD_VERTS = 4;
+export interface GrassChunkDraw {
+    /** world XZ of the chunk's min corner */
+    readonly originX: number;
+    readonly originZ: number;
+    readonly size: number;
+    readonly seed: number;
+    readonly bladeCount: number;
+}
+/**
+ * The chunk ring centred on `cameraXZ`: all GRASS_CHUNK_SIZE cells whose
+ * centre falls within `radius`. Deterministic order (sorted by key) so draw
+ * order and seeds are stable across frames.
+ */
+export declare function grassChunkRing(cameraXZ: readonly [number, number], radius: number, cellSize?: number): readonly GrassChunkDraw[];
+/**
+ * Shared blade vertex buffer for the blades path (7 verts per blade, drawn
+ * `TRIANGLE_STRIP` per instance — the VS maps `gl_VertexID` inside a blade):
+ * per vertex: [t, side] pairs (t 0..1 root→tip; side −1/+1; final tip vertex
+ * has side 0). Per-instance data comes from the chunk uniform + instance id,
+ * not vertex attributes.
+ */
+export declare function grassBladeVertices(): Float32Array;
+/** Strip → triangles (device topologies are triangles/lines/points only). */
+export declare function grassBladeIndices(): Uint16Array;
+/** 2-triangle card for Low tier (quad in [-1,1] x [0,1]). */
+export declare function grassCardVertices(): Float32Array;
+//# sourceMappingURL=GrassField.d.ts.map

package/dist/rendering/world/vegetation/GrassField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrassField.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/vegetation/GrassField.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAmB,GAAG,SAAS,cAAc,EAAE,CAwB1I;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAGjD;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,IAAI,YAAY,CAEhD"}

package/dist/rendering/world/vegetation/GrassField.js

@@ -0,0 +1,68 @@
+/**
+ * PRD-10 T3.7 §8.5 — `GrassField`: the camera-following ring of 8 m grass
+ * chunks. Blades are generated entirely in the vertex stage (§8.5
+ * `a3d_prd10_grass` — stratified jitter hash per `gl_InstanceID`, quadratic
+ * Bézier blade, density falloff); this module only computes which chunk
+ * origins + seeds draw this frame, and the shared blade index/vertex data.
+ *
+ * Tier rules (§7.1.5 grass options + §17):
+ * - Medium+ draws 7-vertex blades; Low draws 2-triangle cards with the same
+ *   placement hash.
+ * - The chunk ring extends to `radius`; chunks whose centre is farther than
+ *   `radius` from the camera are dropped before upload.
+ */
+export const GRASS_CHUNK_SIZE = 8;
+export const GRASS_BLADE_VERTS = 7; // quadratic Bézier strips: root L/R, mid L/R, tip L/R + tip
+export const GRASS_CARD_VERTS = 4;
+/**
+ * The chunk ring centred on `cameraXZ`: all GRASS_CHUNK_SIZE cells whose
+ * centre falls within `radius`. Deterministic order (sorted by key) so draw
+ * order and seeds are stable across frames.
+ */
+export function grassChunkRing(cameraXZ, radius, cellSize = GRASS_CHUNK_SIZE) {
+    if (radius <= 0)
+        return [];
+    const cx0 = Math.floor((cameraXZ[0] - radius) / cellSize);
+    const cx1 = Math.floor((cameraXZ[0] + radius) / cellSize);
+    const cz0 = Math.floor((cameraXZ[1] - radius) / cellSize);
+    const cz1 = Math.floor((cameraXZ[1] + radius) / cellSize);
+    const out = [];
+    for (let cz = cz0; cz <= cz1; cz += 1) {
+        for (let cx = cx0; cx <= cx1; cx += 1) {
+            const ox = cx * cellSize;
+            const oz = cz * cellSize;
+            const d = Math.hypot(ox + cellSize / 2 - cameraXZ[0], oz + cellSize / 2 - cameraXZ[1]);
+            if (d > radius)
+                continue;
+            out.push({
+                originX: ox,
+                originZ: oz,
+                size: cellSize,
+                seed: (((cx * 73856093) ^ (cz * 19349663)) >>> 0) % 4096,
+                bladeCount: Math.min(1024, Math.round(cellSize * cellSize)) // density applied by the caller via bladeCount scale
+            });
+        }
+    }
+    out.sort((a, b) => a.originZ - b.originZ || a.originX - b.originX);
+    return out;
+}
+/**
+ * Shared blade vertex buffer for the blades path (7 verts per blade, drawn
+ * `TRIANGLE_STRIP` per instance — the VS maps `gl_VertexID` inside a blade):
+ * per vertex: [t, side] pairs (t 0..1 root→tip; side −1/+1; final tip vertex
+ * has side 0). Per-instance data comes from the chunk uniform + instance id,
+ * not vertex attributes.
+ */
+export function grassBladeVertices() {
+    // 7 verts: [t, side] = (0,-1),(0,1),(0.5,-1),(0.5,1),(0.8,-1),(0.8,1),(1,0 tip)
+    return Float32Array.from([0, -1, 0, 1, 0.5, -1, 0.5, 1, 0.8, -1, 0.8, 1, 1, 0]);
+}
+/** Strip → triangles (device topologies are triangles/lines/points only). */
+export function grassBladeIndices() {
+    return Uint16Array.from([0, 1, 2, 2, 1, 3, 2, 3, 4, 4, 3, 5, 4, 5, 6]);
+}
+/** 2-triangle card for Low tier (quad in [-1,1] x [0,1]). */
+export function grassCardVertices() {
+    return Float32Array.from([-1, 0, 1, 0, -1, 1, 1, 1]);
+}
+//# sourceMappingURL=GrassField.js.map

package/dist/rendering/world/vegetation/GrassField.js.map

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

package/dist/rendering/world/vegetation/ImpostorMaterial.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PRD-10 T3.5 §8.4 — octahedral-impostor program for the far LOD band. The
+ * vertex stage builds a camera-facing (Y-up cylindrical) billboard at the
+ * instance's bounding-sphere centre, maps the object-space view direction
+ * onto the hemi-octahedral grid (`v_octUv`) and passes the billboard-local UV.
+ * The fragment stage is the registered `a3d_prd10_impostor` chunk: it picks
+ * the 3 nearest baked frames, blends them barycentrically with per-frame
+ * parallax, alpha-tests, and (High+) writes `gl_FragDepth` from the depth
+ * channel. The far-band crossfade uses the `a3d_prd10_foliage` Bayer dither.
+ *
+ * Bake contract (tools/impostor-bake): frame (i, j) is an orthographic view
+ * from `impostorViewGrid` direction j*grid+i, basis right = normalize(cross(Y,
+ * horizontal view)), up = cross(view, right), clip x/y = dot(p - centre,
+ * right/up) / radius — the same basis this billboard spans, so tile UV (0..1)
+ * maps 1:1 onto `a_position * 0.5 + 0.5`.
+ */
+import type { ShaderSources } from "../../RenderDevice.js";
+/** Full sources for the standalone Path S impostor program. */
+export declare function impostorShaderSources(): ShaderSources;
+//# sourceMappingURL=ImpostorMaterial.d.ts.map

package/dist/rendering/world/vegetation/ImpostorMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImpostorMaterial.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/vegetation/ImpostorMaterial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AA0E3D,+DAA+D;AAC/D,wBAAgB,qBAAqB,IAAI,aAAa,CAOrD"}