@aura3d/rendering 3.0.1 → 4.0.2

package/dist/world/space/shaders/planet.js

@@ -0,0 +1,55 @@
+const glsl = /* glsl */ `
+uniform sampler2D u_planetAlbedo;
+uniform sampler2D u_planetNight;
+uniform sampler2D u_planetClouds;
+uniform vec3 u_atmosphereColor;
+
+// Terminator wrap: wrap = saturate((dot(n,L) + 0.2) / 1.2).
+float a3dPlanetTerminator(vec3 n, vec3 L) {
+  return clamp((dot(n, L) + 0.2) / 1.2, 0.0, 1.0);
+}
+
+// Day side albedo; night map blends in where dot(n,L) < 0 with a 0.1 ramp.
+vec3 a3dPlanetSurface(vec2 uv, vec3 n, vec3 L) {
+  vec3 day = texture(u_planetAlbedo, uv).rgb * a3dPlanetTerminator(n, L);
+  float night = 1.0 - smoothstep(-0.1, 0.0, dot(n, L));
+  vec3 city = texture(u_planetNight, uv).rgb * night;
+  // Cloud shadow: sample the cloud map offset toward the sun.
+  float cloud = texture(u_planetClouds, uv + L.xz * 0.01).r;
+  day *= 1.0 - cloud * 0.4;
+  return day + city;
+}
+
+// Additive atmosphere shell (second sphere at 1.025x):
+// rim = pow(1 - saturate(dot(n,V)), 3.5) * saturate(dot(n,L) + 0.35) * color.
+vec3 a3dPlanetAtmosphere(vec3 n, vec3 V, vec3 L) {
+  float rim = pow(1.0 - clamp(dot(n, V), 0.0, 1.0), 3.5);
+  float day = clamp(dot(n, L) + 0.35, 0.0, 1.0);
+  return u_atmosphereColor * rim * day;
+}
+`;
+const wgsl = /* wgsl */ `
+@group(0) @binding(0) var u_planetAlbedo : texture_2d<f32>;
+@group(0) @binding(1) var u_planetNight : texture_2d<f32>;
+@group(0) @binding(2) var u_planetClouds : texture_2d<f32>;
+@group(0) @binding(3) var u_samp : sampler;
+@group(0) @binding(4) var<uniform> u_atmosphereColor : vec3f;
+
+fn a3dPlanetTerminator(n : vec3f, L : vec3f) -> f32 {
+  return clamp((dot(n, L) + 0.2) / 1.2, 0.0, 1.0);
+}
+
+fn a3dPlanetAtmosphere(n : vec3f, V : vec3f, L : vec3f) -> vec3f {
+  let rim = pow(1.0 - clamp(dot(n, V), 0.0, 1.0), 3.5);
+  let day = clamp(dot(n, L) + 0.35, 0.0, 1.0);
+  return u_atmosphereColor * rim * day;
+}
+`;
+export const a3d_prd10_planet = {
+    name: "a3d_prd10_planet",
+    owner: "prd10",
+    stage: "fragment",
+    glsl,
+    wgsl
+};
+//# sourceMappingURL=planet.js.map

package/dist/world/space/shaders/planet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planet.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/space/shaders/planet.ts"],"names":[],"mappings":"AAOA,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BvB,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBvB,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAgB;IAC3C,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI;IACJ,IAAI;CACL,CAAC"}

package/dist/world/space/shaders/spaceBake.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `a3d_prd10_space_bake` — PRD-10 §8.8 space bake fragment chunk.
+ * Runs once per face into an RGBA16F cube (the `space-bake` C-09 environment
+ * source): Gaussian stars on a magnitude-banded hash grid, domain-warped fbm
+ * nebula through two colour ramps, subtracted dust lanes.
+ */
+import type { ShaderChunk } from "../../../contracts/program.js";
+export declare const a3d_prd10_space_bake: ShaderChunk;
+//# sourceMappingURL=spaceBake.d.ts.map

package/dist/world/space/shaders/spaceBake.d.ts.map

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

package/dist/world/space/shaders/spaceBake.js

@@ -0,0 +1,102 @@
+const glsl = /* glsl */ `
+uniform float u_spaceSeed;
+uniform vec3 u_nebulaColorA;    // ramp start
+uniform vec3 u_nebulaColorB;    // ramp end
+uniform float u_nebulaIntensity; // 0.05..0.3 so stars stay dominant
+uniform float u_starPeak;        // mag0 reference luminance
+
+float a3dHash13(vec3 p) {
+  p = fract(p * 0.1031);
+  p += dot(p, p.zyx + 31.32);
+  return fract((p.x + p.y) * p.z);
+}
+
+vec3 a3dHash33(vec3 p) {
+  p = fract(p * vec3(0.1031, 0.1030, 0.0973));
+  p += dot(p, p.yxz + 33.33);
+  return fract((p.xxy + p.yxx) * p.zyx);
+}
+
+// fbm over domain-warped direction, 6 octaves.
+float a3dFbm(vec3 p) {
+  float sum = 0.0;
+  float amp = 0.5;
+  for (int i = 0; i < 6; i++) {
+    vec3 q = p + vec3(a3dHash13(p + float(i) * 0.31), a3dHash13(p.yzx + float(i) * 0.17), a3dHash13(p.zxy + float(i) * 0.23)) - 0.5;
+    sum += amp * (a3dHash13(q) * 2.0 - 1.0);
+    p *= 2.03;
+    amp *= 0.5;
+  }
+  return sum * 0.5 + 0.5;
+}
+
+// Blackbody-ish colour from a 0..1 temperature index.
+vec3 a3dStarColor(float t) {
+  return mix(vec3(0.6, 0.72, 1.0), vec3(1.0, 0.95, 0.85), smoothstep(0.0, 0.5, t))
+       + vec3(0.35, 0.1, -0.05) * smoothstep(0.5, 1.0, t);
+}
+
+// Star field: hash grid per magnitude band, Gaussian sigma 0.6 texel,
+// peak luminance pow(10, -0.4*(mag - mag0)).
+vec3 a3dSpaceStars(vec3 dir) {
+  vec3 col = vec3(0.0);
+  for (int band = 0; band < 3; band++) {
+    float cells = 24.0 + float(band) * 24.0;
+    vec3 p = dir * cells;
+    vec3 cell = floor(p);
+    vec3 f = fract(p) - 0.5;
+    vec3 h = a3dHash33(cell + u_spaceSeed + float(band) * 7.13);
+    float mag = float(band) * 1.6;
+    float peak = pow(10.0, -0.4 * (mag - 2.0)) * u_starPeak;
+    float present = step(0.96 - float(band) * 0.02, h.z); // sparser in dim bands
+    vec3 starPos = cell + 0.5 + (h - 0.5) * 0.6;
+    float d = length(p - starPos) * cells / 24.0;
+    float g = exp(-d * d / (2.0 * 0.6 * 0.6));
+    col += a3dStarColor(h.y) * g * peak * present;
+  }
+  return col;
+}
+
+// Nebula + dust lanes at nebula intensity so stars stay dominant.
+vec3 a3dSpaceNebula(vec3 dir) {
+  float n = a3dFbm(dir * 2.3 + u_spaceSeed * 0.1);
+  float dust = a3dFbm(dir * 1.1 - u_spaceSeed * 0.2);
+  vec3 nebula = mix(u_nebulaColorA, u_nebulaColorB, n) * u_nebulaIntensity;
+  return max(nebula - dust * 0.4 * u_nebulaIntensity, vec3(0.0));
+}
+
+vec3 a3dSpaceBakeFace(vec3 dir) {
+  return a3dSpaceStars(normalize(dir)) + a3dSpaceNebula(normalize(dir));
+}
+`;
+const wgsl = /* wgsl */ `
+struct A3dSpaceBake {
+  seed : f32,
+  nebulaColorA : vec3f,
+  nebulaColorB : vec3f,
+  nebulaIntensity : f32,
+  starPeak : f32,
+  pad0 : f32,
+  pad1 : f32,
+};
+@group(0) @binding(0) var<uniform> u_space : A3dSpaceBake;
+
+fn a3dHash13(p : vec3f) -> f32 {
+  var q = fract(p * 0.1031);
+  q = q + vec3f(dot(q, q.zyx + vec3f(31.32)));
+  return fract((q.x + q.y) * q.z);
+}
+
+fn a3dStarColor(t : f32) -> vec3f {
+  return mix(vec3f(0.6, 0.72, 1.0), vec3f(1.0, 0.95, 0.85), smoothstep(0.0, 0.5, t))
+       + vec3f(0.35, 0.1, -0.05) * smoothstep(0.5, 1.0, t);
+}
+`;
+export const a3d_prd10_space_bake = {
+    name: "a3d_prd10_space_bake",
+    owner: "prd10",
+    stage: "fragment",
+    glsl,
+    wgsl
+};
+//# sourceMappingURL=spaceBake.js.map

package/dist/world/space/shaders/spaceBake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceBake.js","sourceRoot":"","sources":["../../../../../../../packages/rendering/src/world/space/shaders/spaceBake.ts"],"names":[],"mappings":"AAQA,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEvB,CAAC;AAEF,MAAM,IAAI,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAsBvB,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAgB;IAC/C,IAAI,EAAE,sBAAsB;IAC5B,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,UAAU;IACjB,IAAI;IACJ,IAAI;CACL,CAAC"}

package/dist/world/terrain/SplatBake.d.ts

@@ -0,0 +1,76 @@
+/**
+ * PRD-10 T2.5 — GPU auto-splat bake. A fullscreen pass per 4-layer group writes
+ * RGBA8 splat weights from the rule set; the fragment shader mirrors
+ * `evalSplatRules` (agent-api/world/terrain.ts) 1:1 — same `rangeWeight`
+ * smooth01 edges, same value-noise gate — so baked maps agree with the CPU
+ * weights within ±1/255 (§15.2 `terrain-splat-bake`).
+ *
+ * Noise gates replicate the CPU `hash2` via uint32 arithmetic (mod-2^32
+ * multiply == JS `Math.imul`/`(x*C)|0`); the only divergence is fp32 rounding
+ * of `float(h)/4294967295`, which can flip a threshold boundary pixel — inside
+ * the ±1/255 tolerance budget.
+ *
+ * The bake runs through `RenderDevice` primitives (createRenderTarget + draw),
+ * so the same code path serves WebGL2 (Path S) and WebGPU (Path G).
+ */
+import type { RenderDevice, ShaderSources } from "../../RenderDevice.js";
+import type { Texture } from "../../Texture.js";
+/** One encoded splat rule — the uniform flat view of `AuraSplatRule`. */
+export interface SplatBakeRule {
+    /** Target layer channel (index into the terrain's layer list). */
+    readonly layer: number;
+    readonly weight: number;
+    /** `[lo, hi]` degrees; `undefined` = unconstrained. */
+    readonly slopeDeg?: readonly [number, number];
+    /** `[lo, hi]` normalized height; `undefined` = unconstrained. */
+    readonly height?: readonly [number, number];
+    readonly falloff?: number;
+    readonly noise?: {
+        readonly scale: number;
+        readonly threshold: number;
+        readonly seed?: number;
+    };
+}
+export interface SplatBakeSpec {
+    /** Height texture (R32F or RGBA32F-packed; `.r` holds normalized height). */
+    readonly heightTexture: Texture;
+    readonly heightTexSize: readonly [number, number];
+    /** World metres per height texel (matches `terrainMacroNormal`'s texel arg). */
+    readonly texelWorld: number;
+    readonly heightScale: number;
+    /** Splat map resolution (square). */
+    readonly resolution: number;
+    readonly layerCount: number;
+    readonly rules: readonly SplatBakeRule[];
+}
+export interface SplatBakeResult {
+    /** Layers 0–3 splat weights (RGBA8). */
+    readonly splat0: Texture;
+    /** Layers 4–7, present only when `layerCount > 4`. */
+    readonly splat1: Texture | null;
+    /** Keeps the bake render targets alive; call when the maps are replaced. */
+    readonly dispose: () => void;
+}
+/** Fullscreen-triangle sources for the splat bake (GLSL Path S / WGSL Path G). */
+/** (layer, weight) per rule as vec4[MAX_RULES] — see BAKE_FRAG `u_ruleLW`. */
+export declare function packRuleLW(ruleLayer: ArrayLike<number>, ruleWeight: ArrayLike<number>): Float32Array;
+export declare function splatBakeShaderSources(): ShaderSources;
+/** Pack JS rules into the uniform flat layout the bake program reads. */
+export declare function encodeSplatBakeRules(rules: readonly SplatBakeRule[]): {
+    readonly ruleCount: number;
+    readonly ruleLayer: Int32Array;
+    readonly ruleWeight: Float32Array;
+    /** vec4[MAX_RULES] (layer, weight, 0, 0) — the uploaded form (`u_ruleLW`). */
+    readonly ruleLW: Float32Array;
+    readonly ruleSlope: Float32Array;
+    readonly ruleHeight: Float32Array;
+    readonly ruleNoise: Float32Array;
+    readonly dropped: number;
+};
+/**
+ * Bake the splat weights into RGBA8 render-target textures on `device`.
+ * One fullscreen draw per 4-layer group; returns the target textures (caller
+ * binds them into the terrain program and keeps/disposes via `dispose`).
+ */
+export declare function bakeTerrainSplat(device: RenderDevice, spec: SplatBakeSpec): SplatBakeResult;
+//# sourceMappingURL=SplatBake.d.ts.map

package/dist/world/terrain/SplatBake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplatBake.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/terrain/SplatBake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,YAAY,EAAgB,aAAa,EAAgB,MAAM,uBAAuB,CAAC;AAKrG,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAGhD,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,iEAAiE;IACjE,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACjG;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,gFAAgF;IAChF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,qCAAqC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAgND,kFAAkF;AAClF,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,YAAY,CAOpG;AAED,wBAAgB,sBAAsB,IAAI,aAAa,CAQtD;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,GAAG;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;IAClC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAmBA;AAKD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,eAAe,CAuD3F"}

package/dist/world/terrain/SplatBake.js

@@ -0,0 +1,308 @@
+import { VertexBuffer } from "../../VertexBuffer.js";
+import { VertexFormat } from "../../VertexFormat.js";
+import { TextureBinding } from "../../TextureBinding.js";
+import { Sampler } from "../../Sampler.js";
+import { a3dTerrainHeightBilinearGlsl } from "./shaders/terrainCdlod.js";
+const MAX_RULES = 8;
+const BAKE_VERT = /* glsl */ `#version 300 es
+// prd10-terrain-splat-bake — RenderDevice shader marker (both stages)
+in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+  v_uv = a_pos * 0.5 + 0.5;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+/**
+ * Fragment mirrors `evalSplatRules` + `rangeWeight` + `smooth01` +
+ * `hash2`/`valueNoise` from agent-api/world/terrain.ts exactly. Keep the two in
+ * lockstep — the ±1/255 agreement test reads baked texels against the CPU
+ * weights.
+ */
+const BAKE_FRAG = /* glsl */ `#version 300 es
+// prd10-terrain-splat-bake — RenderDevice shader marker (both stages)
+precision highp float;
+precision highp int;
+in vec2 v_uv;
+out vec4 o_weights;
+// Counts are floats and (layer, weight) pack into vec4s: the RenderDevice
+// uploads only float types (#491), so int/float[] uniforms never arrived.
+uniform float u_layerOffset;        // 0 for splat0, 4 for splat1
+uniform float u_layerCount;
+uniform float u_ruleCount;
+uniform vec4 u_ruleLW[${MAX_RULES}];   // x: layer index, y: weight
+uniform vec4 u_ruleSlope[${MAX_RULES}];  // lo, hi, falloff, has
+uniform vec4 u_ruleHeight[${MAX_RULES}]; // lo, hi, falloff, has
+uniform vec4 u_ruleNoise[${MAX_RULES}];  // scale, threshold, seed, has
+uniform float u_texelWorld;
+
+${a3dTerrainHeightBilinearGlsl}
+
+float a3dBakeSmooth01(float t) {
+  float x = clamp(t, 0.0, 1.0);
+  return x * x * (3.0 - 2.0 * x);
+}
+// CPU rangeWeight(): hard outside bounds, smooth01 edges of (hi-lo)*falloff.
+float a3dBakeRangeWeight(float value, vec4 range) {
+  if (range.w < 0.5) return 1.0;
+  float lo = range.x;
+  float hi = range.y;
+  if (value < lo || value > hi) return 0.0;
+  float edge = max(1e-6, (hi - lo) * range.z);
+  return min(a3dBakeSmooth01((value - lo) / edge), a3dBakeSmooth01((hi - value) / edge));
+}
+// CPU hash2() — uint32 ops match (x*C)|0 / Math.imul bitwise.
+uint a3dBakeHash2(int ix, int iz, int seed) {
+  uint h = uint(ix) * 374761393u + uint(iz) * 668265263u + uint(seed) * 2641260675u;
+  h = (h ^ (h >> 13u)) * 1274126177u;
+  h = h ^ (h >> 16u);
+  return h;
+}
+float a3dBakeNoise(float x, float z, int seed) {
+  int ix = int(floor(x));
+  int iz = int(floor(z));
+  float fx = x - float(ix);
+  float fz = z - float(iz);
+  float sx = fx * fx * (3.0 - 2.0 * fx);
+  float sz = fz * fz * (3.0 - 2.0 * fz);
+  float a = float(a3dBakeHash2(ix, iz, seed)) / 4294967295.0;
+  float b = float(a3dBakeHash2(ix + 1, iz, seed)) / 4294967295.0;
+  float c = float(a3dBakeHash2(ix, iz + 1, seed)) / 4294967295.0;
+  float d = float(a3dBakeHash2(ix + 1, iz + 1, seed)) / 4294967295.0;
+  return a + (b - a) * sx + (c + (d - c) * sx - a - (b - a) * sx) * sz;
+}
+void main() {
+  float du = 1.0 / max(u_heightTexSize.x - 1.0, 1.0);
+  float dv = 1.0 / max(u_heightTexSize.y - 1.0, 1.0);
+  float h = a3dTerrainHeightBilinear(v_uv);
+  float hL = a3dTerrainHeightBilinear(v_uv - vec2(du, 0.0));
+  float hR = a3dTerrainHeightBilinear(v_uv + vec2(du, 0.0));
+  float hD = a3dTerrainHeightBilinear(v_uv - vec2(0.0, dv));
+  float hU = a3dTerrainHeightBilinear(v_uv + vec2(0.0, dv));
+  vec3 n = normalize(vec3(hL - hR, 2.0 * u_texelWorld, hD - hU));
+  float slopeDeg = degrees(acos(clamp(n.y, -1.0, 1.0)));
+  float hNorm = h / max(u_heightScale, 1e-6);
+
+  float w[8];
+  for (int i = 0; i < 8; i++) w[i] = 0.0;
+  for (int r = 0; r < ${MAX_RULES}; r++) {
+    if (float(r) >= u_ruleCount) break;
+    float rw = u_ruleLW[r].y
+      * a3dBakeRangeWeight(slopeDeg, u_ruleSlope[r])
+      * a3dBakeRangeWeight(hNorm, u_ruleHeight[r]);
+    if (u_ruleNoise[r].w > 0.5) {
+      float nn = a3dBakeNoise(v_uv.x * u_ruleNoise[r].x, v_uv.y * u_ruleNoise[r].x, int(u_ruleNoise[r].z));
+      rw *= nn >= u_ruleNoise[r].y ? 1.0 : 0.0;
+    }
+    w[int(u_ruleLW[r].x + 0.5)] += rw;
+  }
+  float total = 0.0;
+  for (int i = 0; i < 8; i++) total += w[i];
+  w[0] += max(0.0, 1.0 - total);                 // remainder -> layer 0
+  float sum = 0.0;
+  for (int i = 0; i < 8; i++) sum += w[i];
+  vec4 outW = vec4(0.0);
+  for (int i = 0; i < 4; i++) {
+    int layer = int(u_layerOffset + 0.5) + i;
+    outW[i] = float(layer) < u_layerCount ? w[layer] / max(sum, 1e-6) : 0.0;
+  }
+  o_weights = outW;
+}
+`;
+const BAKE_WGSL = /* wgsl */ `
+// SplatBake WGSL twin — Path G runs this when WebGPU is the backend. Same
+// rule evaluation as the GLSL body (see BAKE_FRAG comments).
+struct BakeUniforms {
+  layerOffset : i32, layerCount : i32, ruleCount : i32, texelWorld : f32,
+  heightTexSize : vec2f, heightScale : f32, pad : f32,
+  ruleLayer : array<i32, ${MAX_RULES}>,
+  ruleWeight : array<f32, ${MAX_RULES}>,
+  ruleSlope : array<vec4f, ${MAX_RULES}>,
+  ruleHeight : array<vec4f, ${MAX_RULES}>,
+  ruleNoise : array<vec4f, ${MAX_RULES}>,
+};
+@group(0) @binding(0) var<uniform> u : BakeUniforms;
+@group(0) @binding(1) var u_height : texture_2d<f32>;
+
+fn bakeHeightBilinear(uv : vec2f) -> f32 {
+  let p = uv * (u.heightTexSize - vec2f(1.0));
+  let i = vec2i(floor(p));
+  let hi = vec2i(u.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.heightScale;
+}
+fn bakeSmooth01(t : f32) -> f32 { let x = clamp(t, 0.0, 1.0); return x * x * (3.0 - 2.0 * x); }
+fn bakeRangeWeight(v : f32, r : vec4f) -> f32 {
+  if (r.w < 0.5) { return 1.0; }
+  if (v < r.x || v > r.y) { return 0.0; }
+  let edge = max(1e-6, (r.y - r.x) * r.z);
+  return min(bakeSmooth01((v - r.x) / edge), bakeSmooth01((r.y - v) / edge));
+}
+fn bakeHash2(ix : i32, iz : i32, seed : i32) -> u32 {
+  var h = u32(ix) * 374761393u + u32(iz) * 668265263u + u32(seed) * 2641260675u;
+  h = (h ^ (h >> 13u)) * 1274126177u;
+  h = h ^ (h >> 16u);
+  return h;
+}
+fn bakeNoise(x : f32, z : f32, seed : i32) -> f32 {
+  let ix = i32(floor(x)); let iz = i32(floor(z));
+  let fx = x - f32(ix); let fz = z - f32(iz);
+  let sx = fx * fx * (3.0 - 2.0 * fx); let sz = fz * fz * (3.0 - 2.0 * fz);
+  let a = f32(bakeHash2(ix, iz, seed)) / 4294967295.0;
+  let b = f32(bakeHash2(ix + 1, iz, seed)) / 4294967295.0;
+  let c = f32(bakeHash2(ix, iz + 1, seed)) / 4294967295.0;
+  let d = f32(bakeHash2(ix + 1, iz + 1, seed)) / 4294967295.0;
+  return a + (b - a) * sx + (c + (d - c) * sx - a - (b - a) * sx) * sz;
+}
+fn bakeSlopeDeg(uv : vec2f) -> vec2f {
+  let du = 1.0 / max(u.heightTexSize.x - 1.0, 1.0);
+  let dv = 1.0 / max(u.heightTexSize.y - 1.0, 1.0);
+  let hL = bakeHeightBilinear(uv - vec2f(du, 0.0));
+  let hR = bakeHeightBilinear(uv + vec2f(du, 0.0));
+  let hD = bakeHeightBilinear(uv - vec2f(0.0, dv));
+  let hU = bakeHeightBilinear(uv + vec2f(0.0, dv));
+  let n = normalize(vec3f(hL - hR, 2.0 * u.texelWorld, hD - hU));
+  return vec2f(degrees(acos(clamp(n.y, -1.0, 1.0))), bakeHeightBilinear(uv) / max(u.heightScale, 1e-6));
+}
+
+struct VsOut { @builtin(position) pos : vec4f, @location(0) uv : vec2f };
+@vertex fn vsMain(@location(0) aPos : vec2f) -> VsOut {
+  var o : VsOut;
+  o.pos = vec4f(aPos, 0.0, 1.0);
+  o.uv = aPos * 0.5 + vec2f(0.5);
+  return o;
+}
+fn bakeWeights(uv : vec2f) -> vec4f {
+  let sh = bakeSlopeDeg(uv);
+  var w : array<f32, 8>;
+  for (var i = 0; i < 8; i++) { w[i] = 0.0; }
+  for (var r = 0; r < ${MAX_RULES}; r++) {
+    if (r >= u.ruleCount) { break; }
+    var rw = u.ruleWeight[r] * bakeRangeWeight(sh.x, u.ruleSlope[r]) * bakeRangeWeight(sh.y, u.ruleHeight[r]);
+    if (u.ruleNoise[r].w > 0.5) {
+      let nn = bakeNoise(uv.x * u.ruleNoise[r].x, uv.y * u.ruleNoise[r].x, i32(u.ruleNoise[r].z));
+      rw = rw * select(0.0, 1.0, nn >= u.ruleNoise[r].y);
+    }
+    w[u.ruleLayer[r]] = w[u.ruleLayer[r]] + rw;
+  }
+  var total = 0.0;
+  for (var i = 0; i < 8; i++) { total += w[i]; }
+  w[0] = w[0] + max(0.0, 1.0 - total);
+  var sum = 0.0;
+  for (var i = 0; i < 8; i++) { sum += w[i]; }
+  var outW = vec4f(0.0);
+  for (var i = 0; i < 4; i++) {
+    let layer = u.layerOffset + i;
+    outW[i] = select(0.0, w[layer] / max(sum, 1e-6), layer < u.layerCount);
+  }
+  return outW;
+}
+@fragment fn fsMain(@location(0) uv : vec2f) -> @location(0) vec4f {
+  return bakeWeights(uv);
+}
+`;
+/** Fullscreen-triangle sources for the splat bake (GLSL Path S / WGSL Path G). */
+/** (layer, weight) per rule as vec4[MAX_RULES] — see BAKE_FRAG `u_ruleLW`. */
+export function packRuleLW(ruleLayer, ruleWeight) {
+    const out = new Float32Array(MAX_RULES * 4);
+    for (let r = 0; r < MAX_RULES; r += 1) {
+        out[r * 4] = ruleLayer[r] ?? 0;
+        out[r * 4 + 1] = ruleWeight[r] ?? 0;
+    }
+    return out;
+}
+export function splatBakeShaderSources() {
+    return {
+        label: "prd10-terrain-splat-bake",
+        marker: "prd10-terrain-splat-bake",
+        vertex: BAKE_VERT,
+        fragment: BAKE_FRAG,
+        webgpu: { vertex: BAKE_WGSL, fragment: BAKE_WGSL }
+    };
+}
+/** Pack JS rules into the uniform flat layout the bake program reads. */
+export function encodeSplatBakeRules(rules) {
+    const capped = rules.slice(0, MAX_RULES);
+    const ruleLayer = new Int32Array(MAX_RULES);
+    const ruleWeight = new Float32Array(MAX_RULES);
+    const ruleSlope = new Float32Array(MAX_RULES * 4);
+    const ruleHeight = new Float32Array(MAX_RULES * 4);
+    const ruleNoise = new Float32Array(MAX_RULES * 4);
+    capped.forEach((rule, r) => {
+        const falloff = rule.falloff ?? 0.1;
+        ruleLayer[r] = rule.layer;
+        ruleWeight[r] = rule.weight;
+        ruleSlope.set([rule.slopeDeg?.[0] ?? 0, rule.slopeDeg?.[1] ?? 0, falloff, rule.slopeDeg ? 1 : 0], r * 4);
+        ruleHeight.set([rule.height?.[0] ?? 0, rule.height?.[1] ?? 0, falloff, rule.height ? 1 : 0], r * 4);
+        ruleNoise.set([rule.noise?.scale ?? 0, rule.noise?.threshold ?? 0, rule.noise?.seed ?? 0, rule.noise ? 1 : 0], r * 4);
+    });
+    return { ruleCount: capped.length, ruleLayer, ruleWeight, ruleLW: packRuleLW(ruleLayer, ruleWeight), ruleSlope, ruleHeight, ruleNoise, dropped: Math.max(0, rules.length - MAX_RULES) };
+}
+const BAKE_FORMAT = new VertexFormat([{ semantic: "position", components: 2, offset: 0, shaderName: "a_pos" }]);
+const BAKE_SAMPLER = new Sampler({ minFilter: "nearest", magFilter: "nearest" });
+/**
+ * Bake the splat weights into RGBA8 render-target textures on `device`.
+ * One fullscreen draw per 4-layer group; returns the target textures (caller
+ * binds them into the terrain program and keeps/disposes via `dispose`).
+ */
+export function bakeTerrainSplat(device, spec) {
+    const res = Math.max(1, spec.resolution | 0);
+    const groupCount = spec.layerCount > 4 ? 2 : 1;
+    const program = device.createShaderProgram(splatBakeShaderSources());
+    const tri = new VertexBuffer(BAKE_FORMAT, 3);
+    tri.setAttribute(0, "position", [-1, -1]);
+    tri.setAttribute(1, "position", [3, -1]);
+    tri.setAttribute(2, "position", [-1, 3]);
+    const vb = device.createBuffer("vertex", tri.byteLength, new Uint8Array(tri.data));
+    const rules = encodeSplatBakeRules(spec.rules);
+    const heightBinding = new TextureBinding({ name: "u_height", texture: spec.heightTexture, sampler: BAKE_SAMPLER });
+    const targets = [];
+    const textures = [];
+    // The bake runs lazily inside the terrain pass, with the scene target bound.
+    // Restore that target afterwards; `setRenderTarget(null)` sent the rest of
+    // the pass (the terrain draw itself) to the canvas framebuffer.
+    const previousTarget = device.getRenderTarget?.() ?? null;
+    for (let group = 0; group < groupCount; group += 1) {
+        const rt = device.createRenderTarget({ width: res, height: res, label: `prd10-splat-${group}`, format: "rgba8", depth: false });
+        device.setRenderTarget(rt);
+        device.draw({
+            label: `prd10-splat-bake-${group}`,
+            topology: "triangles",
+            vertexBuffer: vb,
+            vertexFormat: BAKE_FORMAT,
+            vertexCount: 3,
+            shader: program,
+            uniforms: new Map([
+                ["u_height", heightBinding],
+                ["u_heightTexSize", spec.heightTexSize],
+                ["u_heightScale", spec.heightScale],
+                ["u_texelWorld", spec.texelWorld],
+                ["u_layerOffset", group * 4],
+                ["u_layerCount", spec.layerCount],
+                ["u_ruleCount", rules.ruleCount],
+                ["u_ruleLW", rules.ruleLW],
+                ["u_ruleSlope", rules.ruleSlope],
+                ["u_ruleHeight", rules.ruleHeight],
+                ["u_ruleNoise", rules.ruleNoise]
+            ])
+        });
+        device.setRenderTarget(previousTarget);
+        targets.push(rt);
+        textures.push(rt.colorTexture);
+    }
+    return {
+        splat0: textures[0],
+        splat1: textures[1] ?? null,
+        dispose() {
+            for (const rt of targets)
+                rt.dispose();
+            vb.dispose();
+            program.dispose();
+        }
+    };
+}
+//# sourceMappingURL=SplatBake.js.map

package/dist/world/terrain/SplatBake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplatBake.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/terrain/SplatBake.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAqCzE,MAAM,SAAS,GAAG,CAAC,CAAC;AAEpB,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;CAQ5B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;;;;;;wBAWL,SAAS;2BACN,SAAS;4BACR,SAAS;2BACV,SAAS;;;EAGlC,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiDN,SAAS;;;;;;;;;;;;;;;;;;;;;;;CAuBhC,CAAC;AAEF,MAAM,SAAS,GAAG,UAAU,CAAC;;;;;;2BAMF,SAAS;4BACR,SAAS;6BACR,SAAS;8BACR,SAAS;6BACV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6Dd,SAAS;;;;;;;;;;;;;;;;;;;;;;;;CAwBhC,CAAC;AAEF,kFAAkF;AAClF,8EAA8E;AAC9E,MAAM,UAAU,UAAU,CAAC,SAA4B,EAAE,UAA6B;IACpF,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC/B,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,KAAK,EAAE,0BAA0B;QACjC,MAAM,EAAE,0BAA0B;QAClC,MAAM,EAAE,SAAS;QACjB,QAAQ,EAAE,SAAS;QACnB,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE;KACnD,CAAC;AACJ,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,oBAAoB,CAAC,KAA+B;IAWlE,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IACzC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAG,IAAI,YAAY,CAAC,SAAS,CAAC,CAAC;IAC/C,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,UAAU,GAAG,IAAI,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IAClD,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;QACpC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QAC1B,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAC5B,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACzG,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACpG,SAAS,CAAC,GAAG,CACX,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAC/F,CAAC,GAAG,CAAC,CACN,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;AAC1L,CAAC;AAED,MAAM,WAAW,GAAG,IAAI,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAChH,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;AAEjF;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAoB,EAAE,IAAmB;IACxE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,MAAM,CAAC,mBAAmB,CAAC,sBAAsB,EAAE,CAAC,CAAC;IACrE,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC7C,GAAG,CAAC,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1C,GAAG,CAAC,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACzC,GAAG,CAAC,YAAY,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzC,MAAM,EAAE,GAAG,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,MAAM,KAAK,GAAG,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/C,MAAM,aAAa,GAAG,IAAI,cAAc,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC;IAEnH,MAAM,OAAO,GAAmB,EAAE,CAAC;IACnC,MAAM,QAAQ,GAAc,EAAE,CAAC;IAC/B,6EAA6E;IAC7E,2EAA2E;IAC3E,gEAAgE;IAChE,MAAM,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,EAAE,IAAI,IAAI,CAAC;IAC1D,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACnD,MAAM,EAAE,GAAG,MAAM,CAAC,kBAAkB,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,eAAe,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAChI,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;QAC3B,MAAM,CAAC,IAAI,CAAC;YACV,KAAK,EAAE,oBAAoB,KAAK,EAAE;YAClC,QAAQ,EAAE,WAAW;YACrB,YAAY,EAAE,EAAE;YAChB,YAAY,EAAE,WAAW;YACzB,WAAW,EAAE,CAAC;YACd,MAAM,EAAE,OAAO;YACf,QAAQ,EAAE,IAAI,GAAG,CAAuB;gBACtC,CAAC,UAAU,EAAE,aAAa,CAAC;gBAC3B,CAAC,iBAAiB,EAAE,IAAI,CAAC,aAAoC,CAAC;gBAC9D,CAAC,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC;gBACnC,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC;gBACjC,CAAC,eAAe,EAAE,KAAK,GAAG,CAAC,CAAC;gBAC5B,CAAC,cAAc,EAAE,IAAI,CAAC,UAAU,CAAC;gBACjC,CAAC,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC;gBAChC,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC;gBAC1B,CAAC,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC;gBAChC,CAAC,cAAc,EAAE,KAAK,CAAC,UAAU,CAAC;gBAClC,CAAC,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC;aACjC,CAAC;SACH,CAAC,CAAC;QACH,MAAM,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QACvC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACjB,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC;IACjC,CAAC;IACD,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAE;QACpB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI;QAC3B,OAAO;YACL,KAAK,MAAM,EAAE,IAAI,OAAO;gBAAE,EAAE,CAAC,OAAO,EAAE,CAAC;YACvC,EAAE,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/world/terrain/TerrainCdlod.d.ts

@@ -0,0 +1,67 @@
+/**
+ * PRD-10 T2.2 — CDLOD quadtree (Strugar 2009) over a height grid.
+ *
+ * Node layout: quadtree depth `levels`; depth 0 is the root covering the whole
+ * footprint, leaves sit at depth `levels - 1`. `lod` = `levels - 1 - depth`
+ * (0 = finest). Distance ranges `range_l = range_0 · 2^l` with
+ * `range_0 = patchWorldSize · 1.5 · lodBias` (§6.1, targets ≤ 1.5 px geometry
+ * error); the morph band is the last `morphRatio` of each range.
+ */
+import type { TerrainHeightGrid } from "./TerrainHeightTexture.js";
+export interface TerrainTierLod {
+    readonly patchSize: {
+        readonly low: number;
+        readonly medium: number;
+        readonly high: number;
+        readonly ultra: number;
+    };
+    readonly levels: {
+        readonly low: number;
+        readonly medium: number;
+        readonly high: number;
+        readonly ultra: number;
+    };
+    readonly layers: {
+        readonly low: number;
+        readonly medium: number;
+        readonly high: number;
+        readonly ultra: number;
+    };
+}
+/** §17 tier table. */
+export declare const TERRAIN_TIER_LOD: TerrainTierLod;
+export interface CdlodNode {
+    readonly level: number;
+    readonly origin: readonly [number, number];
+    readonly size: number;
+    readonly minHeight: number;
+    readonly maxHeight: number;
+    readonly children: readonly CdlodNode[];
+}
+export interface CdlodTree {
+    readonly root: CdlodNode;
+    readonly levels: number;
+    readonly leafSize: number;
+    readonly all: readonly CdlodNode[];
+}
+export interface CdlodRange {
+    readonly lod: number;
+    readonly morphStart: number;
+    readonly morphEnd: number;
+}
+export interface CdlodSelectionOptions {
+    readonly morphRatio?: number;
+    readonly lodBias?: number;
+    readonly frustumPlanes?: readonly (readonly [number, number, number, number])[];
+}
+/** Per-LOD morph ranges (§8.1 `u_morph`): {start,end} in metres. */
+export declare function cdlodRanges(levels: number, patchWorldSize: number, lodBias?: number, morphRatio?: number): readonly CdlodRange[];
+/** Build the quadtree + per-node min/max height (subsampled interior nodes). */
+export declare function buildCdlodTree(grid: TerrainHeightGrid, worldSize: readonly [number, number], worldOrigin: readonly [number, number], levels: number): CdlodTree;
+/**
+ * Select the CDLOD node set for a camera position: descend while the camera is
+ * inside the finer level's range; emit the node otherwise. Returns the drawn
+ * nodes (one instanced patch draw per node at its `level`).
+ */
+export declare function selectCdlodNodes(tree: CdlodTree, cameraPosition: readonly [number, number, number], ranges: readonly CdlodRange[], options?: CdlodSelectionOptions): readonly CdlodNode[];
+//# sourceMappingURL=TerrainCdlod.d.ts.map

package/dist/world/terrain/TerrainCdlod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainCdlod.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/world/terrain/TerrainCdlod.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACrH,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClH,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACnH;AAED,sBAAsB;AACtB,eAAO,MAAM,gBAAgB,EAAE,cAI9B,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,SAAS,SAAS,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;CACjF;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EACtB,OAAO,SAAI,EACX,UAAU,SAAO,GAChB,SAAS,UAAU,EAAE,CAQvB;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,iBAAiB,EACvB,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,MAAM,GACb,SAAS,CAmDX;AAoBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,EACf,cAAc,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACjD,MAAM,EAAE,SAAS,UAAU,EAAE,EAC7B,OAAO,GAAE,qBAA0B,GAClC,SAAS,SAAS,EAAE,CAoBtB"}