@aura3d/engine 3.0.0 → 4.0.0

package/dist/rendering/world/vegetation/shaders/foliage.js

@@ -0,0 +1,104 @@
+const glsl = /* glsl */ `
+uniform sampler2D u_baseColor;
+uniform float u_alphaCutoff;          // default 0.5
+uniform float u_alphaToCoverage;      // C-15 alphaToCoverage active (MSAA on); float: no int upload (#491)
+
+// Alpha handling: A2C path sharpens for multisample resolve; otherwise a hard
+// alpha test (Path S, where the C-15 stub ignores alphaToCoverage).
+float a3dFoliageAlpha(vec2 uv) {
+  float alpha = texture(u_baseColor, uv).a;
+  if (u_alphaToCoverage < 0.5) {
+    if (alpha < u_alphaCutoff) discard;
+    return 1.0;
+  }
+  return clamp((alpha - u_alphaCutoff) / max(fwidth(alpha), 1e-4) + 0.5, 0.0, 1.0);
+}
+
+// Two-sided: flip the back-face normal.
+vec3 a3dFoliageNormal(vec3 n) {
+  return gl_FrontFacing ? n : -n;
+}
+
+// Sun-only translucency term added inside the shared direct-light loop:
+// translucencyColor * albedo * pow(saturate(dot(V, -L)), 4) * thickness * shadow * sunColor.
+vec3 a3dFoliageTranslucency(vec3 albedo, vec3 translucencyColor, float thickness, vec3 V, vec3 L, vec3 sunColor, float shadow) {
+  float t = pow(clamp(dot(V, -L), 0.0, 1.0), 4.0);
+  return translucencyColor * albedo * t * thickness * shadow * sunColor;
+}
+
+// Per-instance colour variation: albedo *= 1 + (variation - 0.5) * (0.08, 0.12, 0.04).
+vec3 a3dInstanceVariation(vec3 albedo, float variation) {
+  return albedo * (1.0 + (variation - 0.5) * vec3(0.08, 0.12, 0.04));
+}
+
+// 4x4 Bayer matrix for the screen-door LOD1<->impostor crossfade.
+float a3dBayer4x4(vec2 fragCoord) {
+  ivec2 p = ivec2(fragCoord) & 3;
+  const mat4 b = mat4(
+     0.0,  8.0,  2.0, 10.0,
+    12.0,  4.0, 14.0,  6.0,
+     3.0, 11.0,  1.0,  9.0,
+    15.0,  7.0, 13.0,  5.0
+  );
+  return (b[p.x][p.y] + 0.5) / 16.0;
+}
+
+// Dithered crossfade: discard when the Bayer threshold exceeds the per-instance
+// fade (written per band in the vertex stage from distance).
+void a3dFoliageCrossfade(vec2 fragCoord, float fade) {
+  if (a3dBayer4x4(fragCoord) > fade) discard;
+}
+`;
+const wgsl = /* wgsl */ `
+@group(0) @binding(0) var u_baseColor : texture_2d<f32>;
+@group(0) @binding(1) var u_samp : sampler;
+struct A3dFoliageUniforms {
+  alphaCutoff : f32,
+  alphaToCoverage : i32,
+  pad0 : f32,
+  pad1 : f32,
+};
+@group(0) @binding(2) var<uniform> u_foliage : A3dFoliageUniforms;
+
+fn a3dFoliageAlpha(uv : vec2f) -> f32 {
+  let alpha = textureSample(u_baseColor, u_samp, uv).a;
+  if (u_foliage.alphaToCoverage == 0) {
+    if (alpha < u_foliage.alphaCutoff) { discard; }
+    return 1.0;
+  }
+  return clamp((alpha - u_foliage.alphaCutoff) / max(fwidth(alpha), 1e-4) + 0.5, 0.0, 1.0);
+}
+
+fn a3dFoliageNormal(n : vec3f, frontFacing : bool) -> vec3f {
+  return select(-n, n, frontFacing);
+}
+
+fn a3dFoliageTranslucency(albedo : vec3f, translucencyColor : vec3f, thickness : f32, V : vec3f, L : vec3f, sunColor : vec3f, shadow : f32) -> vec3f {
+  let t = pow(clamp(dot(V, -L), 0.0, 1.0), 4.0);
+  return translucencyColor * albedo * t * thickness * shadow * sunColor;
+}
+
+fn a3dInstanceVariation(albedo : vec3f, variation : f32) -> vec3f {
+  return albedo * (1.0 + (variation - 0.5) * vec3f(0.08, 0.12, 0.04));
+}
+
+fn a3dBayer4x4(fragCoord : vec2f) -> f32 {
+  let x = i32(fragCoord.x) & 3;
+  let y = i32(fragCoord.y) & 3;
+  let b = array<array<f32, 4>, 4>(
+    array<f32, 4>(0.0, 8.0, 2.0, 10.0),
+    array<f32, 4>(12.0, 4.0, 14.0, 6.0),
+    array<f32, 4>(3.0, 11.0, 1.0, 9.0),
+    array<f32, 4>(15.0, 7.0, 13.0, 5.0)
+  );
+  return (b[y][x] + 0.5) / 16.0;
+}
+`;
+export const a3d_prd10_foliage = {
+    name: "a3d_prd10_foliage",
+    owner: "prd10",
+    stage: "fragment",
+    glsl,
+    wgsl
+};
+//# sourceMappingURL=foliage.js.map

package/dist/rendering/world/vegetation/shaders/foliage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foliage.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/foliage.ts"],"names":[],"mappings":"AAOA,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDvB,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CvB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAgB;IAC5C,IAAI,EAAE,mBAAmB;IACzB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI;IACJ,IAAI;CACL,CAAC"}

package/dist/rendering/world/vegetation/shaders/grass.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `a3d_prd10_grass` — PRD-10 §8.5 grass chunk (vertex stage).
+ * Per-chunk uniform placement with a stratified-jitter hash per
+ * `gl_InstanceID`, quadratic-Bézier blade shape and density falloff.
+ * The fragment side (two-sided translucency + root->tip AO) lands with the
+ * `prd10.grass` feature wiring; Low tier draws alpha-tested cards instead.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+export declare const a3d_prd10_grass: ShaderChunk;
+//# sourceMappingURL=grass.d.ts.map

package/dist/rendering/world/vegetation/shaders/grass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/grass.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AA2EjE,eAAO,MAAM,eAAe,EAAE,WAM7B,CAAC"}

package/dist/rendering/world/vegetation/shaders/grass.js

@@ -0,0 +1,79 @@
+const glsl = /* glsl */ `
+uniform vec4 u_grassChunk;   // chunkOriginXZ, chunkSize, seed
+uniform float u_grassBladeCount; // float: no int uniform upload (#491)
+uniform float u_grassRadius; // density falloff radius from the camera
+uniform float u_grassBladeHeight;
+uniform float u_grassBladeWidth;
+
+// Stratified jitter hash per (seed, instance): position, yaw, height, bend.
+vec4 a3dGrassHash(float seed, int instance) {
+  uint h = uint(seed * 1664525.0) ^ uint(instance * 1013904223.0) ^ uint(instance * 2654435761.0);
+  h ^= h >> 16u; h *= 2246822519u; h ^= h >> 13u;
+  uvec4 v = uvec4(h, h * 3266489917u + 1u, h ^ 668265263u, h * 374761393u);
+  return fract(vec4(v) * (1.0 / 4294967296.0));
+}
+
+// Quadratic Bézier blade vertex. t in [0,1] from root to tip; side in {-1,1}.
+vec3 a3dGrassBladeVertex(vec3 root, float yaw, float height, float bend, float t, float side) {
+  vec2 facing = vec2(cos(yaw), sin(yaw));
+  vec2 rightV = vec2(-facing.y, facing.x);
+  float width = mix(1.0, 0.05, t * t);            // taper to the tip
+  vec2 lean = facing * bend * t * t;              // quadratic lean forward
+  vec3 p = vec3(root.x + lean.x * height, root.y + t * height, root.z + lean.y * height);
+  p.xz += rightV * (u_grassBladeWidth * width * side);
+  return p;
+}
+
+// Per-instance placement inside the chunk (returns zero-height for culled blades).
+vec3 a3dGrassBladeRoot(int instance, out float yaw, out float height, out float bend, out float phase) {
+  vec4 h = a3dGrassHash(u_grassChunk.w, instance);
+  vec2 cell = vec2(instance % 32, instance / 32) / 32.0;
+  vec2 jitter = (h.xy * 0.9 + 0.05) / 32.0;
+  vec2 xz = u_grassChunk.xy + (cell + jitter) * u_grassChunk.z;
+  yaw = h.z * 6.2831853;
+  height = u_grassBladeHeight * (0.6 + 0.8 * h.w);
+  bend = 0.15 + 0.35 * h.y;
+  phase = h.x * 6.2831853;
+  // Density falloff: blades beyond radius*(0.5+0.5*h.w) collapse (zero height).
+  float d = distance(u_cameraPosition, vec3(xz.x, 0.0, xz.y));
+  float falloff = u_grassRadius * (0.5 + 0.5 * h.w);
+  if (d > falloff) height = 0.0;
+  return vec3(xz.x, 0.0, xz.y); // y filled by terrain heightBilinear at draw
+}
+`;
+const wgsl = /* wgsl */ `
+struct A3dGrassChunk {
+  chunk : vec4f,      // chunkOriginXZ, chunkSize, seed
+  bladeCount : i32,
+  radius : f32,
+  bladeHeight : f32,
+  bladeWidth : f32,
+};
+@group(0) @binding(0) var<uniform> u_grass : A3dGrassChunk;
+@group(0) @binding(1) var<uniform> u_camera : vec3f;
+
+fn a3dGrassHash(seed : f32, instance : i32) -> vec4f {
+  var h = u32(seed * 1664525.0) ^ u32(f32(instance) * 1013904223.0) ^ u32(f32(instance) * 2654435761.0);
+  h = h ^ (h >> 16u); h = h * 2246822519u; h = h ^ (h >> 13u);
+  let v = vec4u(h, h * 3266489917u + 1u, h ^ 668265263u, h * 374761393u);
+  return fract(vec4f(v) * (1.0 / 4294967296.0));
+}
+
+fn a3dGrassBladeVertex(root : vec3f, yaw : f32, height : f32, bend : f32, t : f32, side : f32, bladeWidth : f32) -> vec3f {
+  let facing = vec2f(cos(yaw), sin(yaw));
+  let rightV = vec2f(-facing.y, facing.x);
+  let width = mix(1.0, 0.05, t * t);
+  let lean = facing * bend * t * t;
+  var p = vec3f(root.x + lean.x * height, root.y + t * height, root.z + lean.y * height);
+  p = vec3f(p.x + rightV.x * (bladeWidth * width * side), p.y, p.z + rightV.y * (bladeWidth * width * side));
+  return p;
+}
+`;
+export const a3d_prd10_grass = {
+    name: "a3d_prd10_grass",
+    owner: "prd10",
+    stage: "vertex",
+    glsl,
+    wgsl
+};
+//# sourceMappingURL=grass.js.map

package/dist/rendering/world/vegetation/shaders/grass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grass.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/grass.ts"],"names":[],"mappings":"AASA,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CvB,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BvB,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,iBAAiB;IACvB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,IAAI;IACJ,IAAI;CACL,CAAC"}

package/dist/rendering/world/vegetation/shaders/impostor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `a3d_prd10_impostor` — PRD-10 §8.4 octahedral impostor fragment chunk.
+ * Hemi-octahedral 8x8 view mapping, 3-frame barycentric blend, per-frame
+ * parallax offset, alpha test and (High+) `gl_FragDepth` write. Vertex-side
+ * billboard math lands with the `prd10.impostor` feature wiring.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+export declare const a3d_prd10_impostor: ShaderChunk;
+//# sourceMappingURL=impostor.d.ts.map

package/dist/rendering/world/vegetation/shaders/impostor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impostor.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/impostor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AA6FjE,eAAO,MAAM,kBAAkB,EAAE,WAMhC,CAAC"}

package/dist/rendering/world/vegetation/shaders/impostor.js

@@ -0,0 +1,97 @@
+const glsl = /* glsl */ `
+uniform highp sampler2D u_impostorAlbedo;  // 8x8 atlas: albedo RGB + alpha A
+uniform highp sampler2D u_impostorNormalDepth; // 8x8 atlas: tile-space normal XY in RG, depth B, coverage A
+uniform float u_impostorGridDim;           // 8.0
+uniform float u_impostorParallax;          // parallax offset scale
+uniform float u_impostorAlphaCutoff;
+uniform float u_impostorWriteDepth;          // High+ only; Low skips for early-Z
+
+// World/view direction -> hemi-octahedral UV on the 8x8 grid.
+vec2 a3dOctahedralUV(vec3 dir) {
+  vec2 uv = dir.xz / (abs(dir.x) + abs(dir.z) + abs(dir.y));
+  if (dir.y < 0.0) {
+    vec2 s = vec2(uv.x >= 0.0 ? 1.0 : -1.0, uv.y >= 0.0 ? 1.0 : -1.0);
+    uv = (1.0 - abs(uv.yx)) * s;
+  }
+  return uv * 0.5 + 0.5; // [0,1]
+}
+
+// 3 nearest frames in grid space + barycentric weights for one view dir.
+// Frame (i, j) was baked from the direction at oct-UV ((i, j) + 0.5) / grid
+// (tools/impostor-bake impostorViewGrid), so the continuous frame coordinate
+// is octUv * grid - 0.5. The enclosing grid quad is split on its anti-diagonal
+// and the view is blended barycentrically across that triangle's 3 frames.
+void a3dImpostorFrames(vec2 octUv, out vec2 frameUV[3], out vec3 weights) {
+  float g = u_impostorGridDim;
+  vec2 grid = clamp(octUv * g - 0.5, vec2(0.0), vec2(g - 1.0));
+  vec2 cell = min(floor(grid), vec2(g - 2.0));
+  vec2 f = grid - cell;
+  if (f.x + f.y < 1.0) {
+    frameUV[0] = cell;
+    frameUV[1] = cell + vec2(1.0, 0.0);
+    frameUV[2] = cell + vec2(0.0, 1.0);
+    weights = vec3(1.0 - f.x - f.y, f.x, f.y);
+  } else {
+    frameUV[0] = cell + vec2(1.0, 1.0);
+    frameUV[1] = cell + vec2(0.0, 1.0);
+    frameUV[2] = cell + vec2(1.0, 0.0);
+    weights = vec3(f.x + f.y - 1.0, 1.0 - f.x, 1.0 - f.y);
+  }
+}
+
+// Atlas UV for frame f with local texel uv in [0,1].
+vec2 a3dImpostorAtlasUV(vec2 frame, vec2 uv) {
+  return (frame + uv) / u_impostorGridDim;
+}
+
+// Sample + blend the three frames; parallax per frame via the depth channel.
+vec4 a3dImpostorShade(vec2 octUv, vec2 localUv, vec2 frameViewDirXY[3], out vec3 outNormal, out float outDepth) {
+  vec2 frames[3]; vec3 w;
+  a3dImpostorFrames(octUv, frames, w);
+  vec4 albedo = vec4(0.0);
+  vec4 nd = vec4(0.0);
+  for (int i = 0; i < 3; i++) {
+    vec4 ndi = texture(u_impostorNormalDepth, a3dImpostorAtlasUV(frames[i], localUv));
+    vec2 parallaxUv = localUv + (ndi.z - 0.5) * frameViewDirXY[i] * u_impostorParallax;
+    albedo += w[i] * texture(u_impostorAlbedo, a3dImpostorAtlasUV(frames[i], parallaxUv));
+    nd += w[i] * ndi;
+  }
+  if (albedo.a < u_impostorAlphaCutoff) discard;
+  outNormal = vec3(nd.xy * 2.0 - 1.0, 0.0); // XY in impostor (tile) space; the caller reconstructs Z
+  outDepth = nd.z;
+  return albedo;
+}
+`;
+const wgsl = /* wgsl */ `
+@group(0) @binding(0) var u_impostorAlbedo : texture_2d<f32>;
+@group(0) @binding(1) var u_impostorNormalDepth : texture_2d<f32>;
+@group(0) @binding(2) var u_samp : sampler;
+struct A3dImpostorUniforms {
+  gridDim : f32,
+  parallax : f32,
+  alphaCutoff : f32,
+  writeDepth : i32,
+};
+@group(0) @binding(3) var<uniform> u_impostor : A3dImpostorUniforms;
+
+fn a3dOctahedralUV(dir : vec3f) -> vec2f {
+  var uv = dir.xz / (abs(dir.x) + abs(dir.z) + abs(dir.y));
+  if (dir.y < 0.0) {
+    let s = vec2f(sign(uv.x), sign(uv.y));
+    uv = (vec2f(1.0) - abs(uv.yx)) * s;
+  }
+  return uv * 0.5 + vec2f(0.5);
+}
+
+fn a3dImpostorAtlasUV(frame : vec2f, uv : vec2f) -> vec2f {
+  return (frame + uv) / u_impostor.gridDim;
+}
+`;
+export const a3d_prd10_impostor = {
+    name: "a3d_prd10_impostor",
+    owner: "prd10",
+    stage: "fragment",
+    glsl,
+    wgsl
+};
+//# sourceMappingURL=impostor.js.map

package/dist/rendering/world/vegetation/shaders/impostor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"impostor.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/impostor.ts"],"names":[],"mappings":"AAQA,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DvB,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBvB,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAgB;IAC7C,IAAI,EAAE,oBAAoB;IAC1B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI;IACJ,IAAI;CACL,CAAC"}

package/dist/rendering/world/vegetation/shaders/wind.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `a3d_prd10_wind` — PRD-10 §8.2 wind chunk (frozen C-26 `WIND_CHUNK`).
+ * Shared by foliage, grass and the depth pass (`prd10.wind` feature, hook
+ * `vertex:deform`). Length-preserving offset, quadratic-in-height bend.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+export declare const a3d_prd10_wind: ShaderChunk;
+export declare const a3d_prd10_wind_deform: ShaderChunk;
+//# sourceMappingURL=wind.d.ts.map

package/dist/rendering/world/vegetation/shaders/wind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/wind.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAwDjE,eAAO,MAAM,cAAc,EAAE,WAM5B,CAAC;AAwCF,eAAO,MAAM,qBAAqB,EAAE,WAMnC,CAAC"}

package/dist/rendering/world/vegetation/shaders/wind.js

@@ -0,0 +1,103 @@
+/** `a3dWindOffset` body, shared by the Path S UBO chunk and the Path G deform chunk. */
+const WIND_OFFSET_FN_GLSL = /* glsl */ `
+vec3 a3dWindOffset(vec3 localPos, vec3 instanceOrigin, vec4 weights /* vertex colour */, float assetHeight) {
+  vec2 dir = u_windDirStrength.xy; float strength = u_windDirStrength.z; float t = u_windDirStrength.w;
+  vec2 gustUv = instanceOrigin.xz * u_windGust.y - dir * t * 0.08;
+  float gust = texture(u_windNoise, gustUv).r * u_windGust.x;
+  float h = clamp(localPos.y / max(assetHeight, 0.01), 0.0, 1.0);
+  float bend = (strength + gust) * h * h * weights.r;                  // trunk/branch bend, quadratic in height
+  float sway = sin(t * (1.1 + weights.b) + dot(instanceOrigin.xz, vec2(0.37, 0.71))) * 0.25 * strength * weights.r;
+  vec3 offset = vec3(dir.x, 0.0, dir.y) * (bend + sway) * 0.35 * assetHeight;
+  float flutter = sin(t * 7.3 + weights.b * 6.2831 + dot(localPos, vec3(2.1, 1.7, 2.9))) * 0.035 * (strength + gust) * weights.g;
+  offset += vec3(flutter, flutter * 0.4, -flutter);
+  // length preservation: keep the vertex on a sphere around the root to avoid stretching
+  vec3 bent = localPos + offset;
+  float len = length(localPos);
+  if (len < 1e-5) return vec3(0.0);                                    // root vertex (WindCpu parity)
+  return normalize(bent) * len - localPos;                             // length-preserving offset
+}
+`;
+const glsl = /* glsl */ `
+layout(std140) uniform A3DWind {
+  vec4 u_windDirStrength;   // dir.xz, strength, time
+  vec4 u_windGust;          // gustStrength, 1/gustScale, -, -
+};
+uniform sampler2D u_windNoise; // 64² RG8, repeat
+${WIND_OFFSET_FN_GLSL}`;
+const wgsl = /* wgsl */ `
+struct A3DWind {
+  dirStrength : vec4f,   // dir.xz, strength, time
+  gust : vec4f,          // gustStrength, 1/gustScale, -, -
+};
+@group(0) @binding(0) var<uniform> u_wind : A3DWind;
+@group(0) @binding(1) var u_windNoise : texture_2d<f32>;
+@group(0) @binding(2) var u_windNoiseSampler : sampler;
+
+fn a3dWindOffset(localPos : vec3f, instanceOrigin : vec3f, weights : vec4f, assetHeight : f32) -> vec3f {
+  let dir = u_wind.dirStrength.xy;
+  let strength = u_wind.dirStrength.z;
+  let t = u_wind.dirStrength.w;
+  let gustUv = instanceOrigin.xz * u_wind.gust.y - dir * t * 0.08;
+  let gust = textureSample(u_windNoise, u_windNoiseSampler, gustUv).r * u_wind.gust.x;
+  let h = clamp(localPos.y / max(assetHeight, 0.01), 0.0, 1.0);
+  let bend = (strength + gust) * h * h * weights.r;
+  let sway = sin(t * (1.1 + weights.b) + dot(instanceOrigin.xz, vec2f(0.37, 0.71))) * 0.25 * strength * weights.r;
+  var offset = vec3f(dir.x, 0.0, dir.y) * (bend + sway) * 0.35 * assetHeight;
+  let flutter = sin(t * 7.3 + weights.b * 6.2831 + dot(localPos, vec3f(2.1, 1.7, 2.9))) * 0.035 * (strength + gust) * weights.g;
+  offset = offset + vec3f(flutter, flutter * 0.4, -flutter);
+  let bent = localPos + offset;
+  return normalize(bent) * length(localPos) - localPos;
+}
+`;
+export const a3d_prd10_wind = {
+    name: "a3d_prd10_wind",
+    owner: "prd10",
+    stage: "vertex",
+    glsl,
+    wgsl
+};
+/**
+ * #1143 — `a3d_prd10_wind_deform`: the generated-program (C-02, Path G) form
+ * of the wind chunk at `vertex:deform`. The generated path binds per-draw
+ * uniforms by name and only assigns binding points for AuraFrame/AuraLights,
+ * so an `A3DWind` block there would alias binding 0 (AuraFrame). This chunk
+ * declares the same two vec4s as plain uniforms (bound by the `prd10.wind`
+ * feature's `bindUniforms`) and defines the canonical C-18 entry
+ * `a3dDeform(inout vec4, inout vec3, inout vec4)` that the generator and the
+ * PRD-02 depth library call.
+ *
+ * Instance origin: the attribute-instancing translation column when present.
+ * Weights: vertex colour when present, else a trunk-bend default. A program
+ * that already defines a C-18 entry (prd06.deform, emitted first by id
+ * order) sets `A3D_DEFORM_ENTRY` and exports `a3dDeformBeforeWind`, so wind
+ * composes after morph/skin instead of silently suppressing either effect.
+ */
+const deformGlsl = /* glsl */ `
+uniform vec4 u_windDirStrength;   // dir.xz, strength, time
+uniform vec4 u_windGust;          // gustStrength, 1/gustScale, -, -
+uniform sampler2D u_windNoise;    // 64² RG8, repeat
+uniform float u_windAssetHeight;  // metres, asset bounds height
+${WIND_OFFSET_FN_GLSL}
+void a3dDeform(inout vec4 localPos, inout vec3 localNormal, inout vec4 localTangent) {
+#ifdef A3D_DEFORM_ENTRY
+  a3dDeformBeforeWind(localPos, localNormal, localTangent);
+#endif
+  vec3 origin = vec3(0.0);
+#if defined(USE_INSTANCING) && defined(A3D_STAGE_VERTEX)
+  origin = a_instanceMatrix3.xyz;
+#endif
+  vec4 weights = vec4(1.0, 1.0, 0.5, 1.0);
+#if defined(VERTEX_COLORS) && defined(A3D_STAGE_VERTEX)
+  weights = a_color;
+#endif
+  localPos.xyz += a3dWindOffset(localPos.xyz, origin, weights, max(u_windAssetHeight, 0.01));
+}
+`;
+export const a3d_prd10_wind_deform = {
+    name: "a3d_prd10_wind_deform",
+    owner: "prd10",
+    stage: "vertex",
+    glsl: deformGlsl,
+    wgsl
+};
+//# sourceMappingURL=wind.js.map

package/dist/rendering/world/vegetation/shaders/wind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wind.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/vegetation/shaders/wind.ts"],"names":[],"mappings":"AAOA,wFAAwF;AACxF,MAAM,mBAAmB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;CAiBtC,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;EAMtB,mBAAmB,EAAE,CAAC;AAExB,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAwBvB,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAgB;IACzC,IAAI,EAAE,gBAAgB;IACtB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,IAAI;IACJ,IAAI;CACL,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,GAAG,UAAU,CAAC;;;;;EAK5B,mBAAmB;;;;;;;;;;;;;;;CAepB,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,QAAQ;IACf,IAAI,EAAE,UAAU;IAChB,IAAI;CACL,CAAC"}

package/dist/rendering/world/water/GerstnerWaves.d.ts

@@ -0,0 +1,65 @@
+/**
+ * PRD-10 §8.6 / T4.1 — Gerstner waves: the shared CPU/GPU source of truth.
+ *
+ * Two layers:
+ *
+ * 1. Spec layer (`GerstnerWaveSpec` → `packGerstnerWaves` → `gerstnerEvaluate`)
+ *    mirrors the `a3d_prd10_gerstner` shader chunk exactly: `k = 2π/λ`,
+ *    `c = sqrt(9.81/k) * speed`, `f = k·(d·xz − c·t)`, `a = steepness/k`.
+ *    The CPU clamps Σ steepness ≤ 1 per the spec's loop-prevention rule.
+ *    `water.surface`/`app.world.water(id)` heightAt/normalAt run through
+ *    `gerstnerEvaluate`, so physics and pixels share one formula (§"one
+ *    source for physics and pixels").
+ *
+ * 2. Fixture layer (`oceanPresetWaves`, `evaluateWaves`, `waveCompression`)
+ *    is the T4.1 move out of `OceanSurface.ts` — the external-parity ocean
+ *    fixture consumes them; `OceanSurface.ts` re-exports to keep its public
+ *    surface unchanged until T4.7 retires the capture path.
+ */
+import type { OceanFixturePreset, OceanWaveDescriptor } from "../../OceanSurface.js";
+/** §7.1.6 `AuraGerstnerWave` — authored wave descriptor (metres/degrees). */
+export interface GerstnerWaveSpec {
+    readonly directionDeg: number;
+    readonly wavelength: number;
+    readonly steepness: number;
+    readonly speed?: number;
+}
+/** Flat uniform layout matching `a3d_prd10_gerstner` (§8.6). */
+export interface GerstnerWaveUniforms {
+    /** vec4[8]: dir.x, dir.y, steepness, wavelength — zeros beyond waveCount. */
+    readonly waves: Float32Array;
+    /** float[8]: speed multiplier per wave — zeros beyond waveCount. */
+    readonly waveSpeed: Float32Array;
+    readonly waveCount: number;
+    /** Steepness values that were rescaled to satisfy Σ ≤ 1 (0 when no clamp). */
+    readonly steepnessClamped: number;
+}
+export declare const GERSTNER_MAX_WAVES = 8;
+/** `waves` presets (§7.1.6): calm/moderate resolve to 4 waves, rough to 8. */
+export declare const GERSTNER_PRESETS: Record<"calm" | "moderate" | "rough", readonly GerstnerWaveSpec[]>;
+export declare function resolveGerstnerWaves(waves: readonly GerstnerWaveSpec[] | "calm" | "moderate" | "rough" | undefined): readonly GerstnerWaveSpec[];
+/**
+ * Pack specs into the shader's flat uniform layout. Steepness is rescaled
+ * uniformly when Σ steepness > 1 (§8.6 loop prevention). `maxWaves` is the
+ * tier cap (4 Low / 8 High — §4.5 counts down by tier).
+ */
+export declare function packGerstnerWaves(specs: readonly GerstnerWaveSpec[], maxWaves?: number): GerstnerWaveUniforms;
+export interface GerstnerEvaluation {
+    /** Displaced surface point (x, y, z) — xz is displaced by the wave field. */
+    readonly position: readonly [number, number, number];
+    readonly normal: readonly [number, number, number];
+    /** Jacobian proxy `1 − Σ steepness·sin(f)` — crest foam input. */
+    readonly crest: number;
+}
+/** CPU twin of the `a3d_prd10_gerstner` GLSL — keep the two in lockstep. */
+export declare function gerstnerEvaluate(packed: GerstnerWaveUniforms, x: number, z: number, timeSeconds: number): GerstnerEvaluation;
+/** Convenience: surface height only (the `AuraWaterHandle.heightAt` path). */
+export declare function gerstnerHeightAt(packed: GerstnerWaveUniforms, x: number, z: number, timeSeconds: number): number;
+export declare function oceanPresetWaves(preset: OceanFixturePreset): readonly OceanWaveDescriptor[];
+export declare function evaluateWaves(waves: readonly OceanWaveDescriptor[], x: number, z: number, time: number): {
+    readonly height: number;
+    readonly horizontalDisplacement: readonly [number, number];
+    readonly normal: readonly [number, number, number];
+};
+export declare function waveCompression(waves: readonly OceanWaveDescriptor[], x: number, z: number, time: number): number;
+//# sourceMappingURL=GerstnerWaves.d.ts.map

package/dist/rendering/world/water/GerstnerWaves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GerstnerWaves.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/water/GerstnerWaves.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAIrF,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,gEAAgE;AAChE,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8EAA8E;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,GAAG,UAAU,GAAG,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAuBtF,CAAC;AAEX,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,gBAAgB,EAAE,CAIhJ;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAAE,QAAQ,GAAE,MAA2B,GAAG,oBAAoB,CAYjI;AAED,MAAM,WAAW,kBAAkB;IACjC,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAwC5H;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAEhH;AAKD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,mBAAmB,EAAE,CA6B3F;AAaD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG;IACxG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,sBAAsB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3D,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpD,CA4BA;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CASjH"}