@aethervtt/shard-scatter 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,3 @@
-# Temporary Holding Version
+# @aethervtt/shard-scatter
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/components.d.ts

@@ -0,0 +1,44 @@
+import { type Entity, type World } from '@aethervtt/shard-core';
+export declare const ScatterSurface: import("@aethervtt/shard-core").ComponentDef<{
+    readonly set: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"scatter/ScatterSet"> | null, "object">;
+    readonly seed: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export declare const Prop: import("@aethervtt/shard-core").ComponentDef<{
+    readonly index: import("@aethervtt/shard-core").FieldType<number, "u32">;
+}>;
+export declare const ScatterChunk: import("@aethervtt/shard-core").ComponentDef<{
+    readonly surface: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly rule: import("@aethervtt/shard-core").FieldType<string, "object">;
+    readonly chunk: import("@aethervtt/shard-core").FieldType<string, "object">;
+}>;
+/** A prop's rule, chunk and index (the rule and chunk from its parent scatter/Chunk). */
+export declare function propIdentity(world: World, prop: Entity): {
+    rule: string;
+    chunk: string;
+    index: number;
+} | undefined;
+export interface ScatterBudgetValue {
+    /**
+     * Props spawned per frame, at most (a chunk spawns over several frames when it has more). Each
+     * costs a few microseconds of main-thread time with its LODs and collider: 250 keeps a frame
+     * under a millisecond.
+     */
+    propsPerFrame: number;
+    /** Chunks of props that start placement per frame. */
+    chunksPerFrame: number;
+    /** Placed chunks kept after they leave range, so walking back doesn't place them again. */
+    cache: number;
+}
+export declare const ScatterBudget: import("@aethervtt/shard-core").ResourceDef<ScatterBudgetValue>;
+/** Props despawned by gameplay: saved (0038), and skipped when their chunk spawns again. */
+export interface RemovedProps {
+    /** "rule|chunk|index" keys (`removedKey`). */
+    props: string[];
+}
+export declare const Removed: import("@aethervtt/shard-core").ResourceDef<RemovedProps>;
+/** The key a removed prop is recorded under. */
+export declare function removedKey(rule: string, chunk: string, index: number): string;
+/** Whether a prop was removed (a set per list, rebuilt when a load replaces the list). */
+export declare function isRemoved(removed: RemovedProps, key: string): boolean;
+/** Records a removed prop (once). */
+export declare function addRemoved(removed: RemovedProps, key: string): void;

package/dist/components.js

@@ -0,0 +1,98 @@
+import {
+  ChildOf,
+  defineComponent,
+  defineResource,
+  defineSchema,
+  t
+} from "@aethervtt/shard-core";
+import { Mesh3d } from "@aethervtt/shard-render";
+const ScatterSurface = defineComponent(
+  "scatter/ScatterSurface",
+  {
+    set: t.handle("scatter/ScatterSet", {
+      description: "The rules (*.scatter.json) to place on this mesh."
+    }),
+    seed: t.u32({ description: "Mixed into every rule: the same rules, other places." })
+  },
+  {
+    description: "Scatters props and foliage on this entity\u2019s mesh by a ScatterSet, as on a planet: items sit where a ray straight down (local \u2212Y) meets the mesh. For flat levels; planets use Planet.scatter and Biome.scatter.",
+    requires: [Mesh3d]
+  }
+);
+const Prop = defineComponent(
+  "scatter/Prop",
+  {
+    index: t.u32({
+      readonly: true,
+      description: "Its stable id within its chunk (a lattice cell); the parent scatter/Chunk names the rule and chunk."
+    })
+  },
+  {
+    description: "A prop a ScatterSet placed, a child of its scatter/Chunk. Rebuilt when its chunk comes back in range; despawning it records it as removed (saved), so it stays gone.",
+    serialize: false
+  }
+);
+const ScatterChunk = defineComponent(
+  "scatter/Chunk",
+  {
+    surface: t.entity({ readonly: true }),
+    rule: t.string({ readonly: true, description: "The rule\u2019s id (set path, biome, name)." }),
+    chunk: t.string({ readonly: true, description: "face/depth/x/y on a planet, x/z on a mesh." })
+  },
+  {
+    description: "The parent of one chunk of one rule\u2019s props (scatter/Prop): rebuilt from the scatter rules, never saved.",
+    serialize: false
+  }
+);
+function propIdentity(world, prop) {
+  const p = world.tryGet(prop, Prop);
+  const parent = world.tryGet(prop, ChildOf)?.parent;
+  if (!p || parent === void 0 || parent === null) return void 0;
+  const c = world.tryGet(parent, ScatterChunk);
+  if (!c) return void 0;
+  return { rule: c.rule, chunk: c.chunk, index: p.index };
+}
+const ScatterBudget = defineResource("scatter/Budget", {
+  description: "How much scatter work a frame may do, and how many placed chunks stay cached.",
+  init: () => ({ propsPerFrame: 250, chunksPerFrame: 16, cache: 512 })
+});
+const RemovedSchema = defineSchema("scatter/RemovedProps", {
+  props: t.list(t.string, {
+    description: 'Removed props as "rule|chunk|index" (chunk: face/depth/x/y, or x/z on a mesh).'
+  })
+});
+const Removed = defineResource("scatter/Removed", {
+  description: "Props the game removed (destroyed rocks, felled trees), by rule, chunk, and index: saved, so they stay gone however far the player travels.",
+  schema: RemovedSchema,
+  persist: true,
+  init: () => ({ props: [] })
+});
+function removedKey(rule, chunk, index) {
+  return `${rule}|${chunk}|${index}`;
+}
+const lookups = /* @__PURE__ */ new WeakMap();
+function isRemoved(removed, key) {
+  if (removed.props.length === 0) return false;
+  let set = lookups.get(removed.props);
+  if (!set || set.size !== removed.props.length) {
+    set = new Set(removed.props);
+    lookups.set(removed.props, set);
+  }
+  return set.has(key);
+}
+function addRemoved(removed, key) {
+  if (isRemoved(removed, key)) return;
+  removed.props.push(key);
+  lookups.get(removed.props)?.add(key);
+}
+export {
+  Prop,
+  Removed,
+  ScatterBudget,
+  ScatterChunk,
+  ScatterSurface,
+  addRemoved,
+  isRemoved,
+  propIdentity,
+  removedKey
+};

package/dist/foliage.d.ts

@@ -0,0 +1,43 @@
+import { type AssetRef, type World } from '@aethervtt/shard-core';
+import type { Workers } from '@aethervtt/shard-platform';
+import { FoliageLayer } from '@aethervtt/shard-render';
+import { type SurfaceScatter } from './runtime.js';
+import { type PatchJob, type SurfaceChunk } from './surface.js';
+export interface WindValue {
+    /** World-space direction (normalized when used). */
+    direction: [number, number, number];
+    /** 0 calm, 1 a breeze, 2+ a gale. */
+    strength: number;
+    /** Gust waves per metre. */
+    gustScale: number;
+}
+/** The wind foliage and swaying props feel (0049 replaces it with the planet's wind field). */
+export declare const Wind: import("@aethervtt/shard-core").ResourceDef<WindValue>;
+interface FoliageChunkState {
+    id: string;
+    chunk: SurfaceChunk;
+    job: PatchJob | undefined;
+    slot: number;
+    kept: number;
+    distance: number;
+    /** The patch's four corners (chunk frame, xyz each, counter-clockwise), for the overlay. */
+    corners: Float32Array | undefined;
+}
+/** A foliage rule's GPU layer and the chunks fed to it. */
+export declare class FoliageRule {
+    readonly rule: number;
+    readonly layer: FoliageLayer;
+    readonly chunks: Map<string, FoliageChunkState>;
+    constructor(rule: number, layer: FoliageLayer);
+}
+/**
+ * One frame of a surface's foliage (0045): a GPU layer per foliage rule, its chunks around the
+ * cameras (ground patches built on the pool, props' footprints kept clear), and each chunk's
+ * transform for this frame's origin. Only with a renderer: headless runs have no foliage.
+ */
+export declare function updateFoliage(world: World, ss: SurfaceScatter, frame: number, workers: Workers | undefined): void;
+/** Drops a surface's foliage layers (its rules changed, or it went away). */
+export declare function clearFoliage(world: World, ss: SurfaceScatter): void;
+/** Writes the Wind resource into every Vegetation material scatter uses, when it changed. */
+export declare function applyWind(world: World, materials: Iterable<AssetRef<'Material'> | null>): void;
+export {};

package/dist/foliage.js

@@ -0,0 +1,175 @@
+import { defineResource } from "@aethervtt/shard-core";
+import { FoliageLayer, FoliageLayers, Materials } from "@aethervtt/shard-render";
+import { Vegetation } from "./material.js";
+import { FOLIAGE } from "./rules.js";
+import { finalPlacements, neighborChunks } from "./runtime.js";
+import { P_RADIUS, P_X, PLACEMENT_STRIDE } from "./surface.js";
+const KEEP = 1.1;
+const PATCHES_PER_FRAME = 8;
+const Wind = defineResource("scatter/Wind", {
+  description: "Wind for scatter materials (scatter/Vegetation): direction, strength and gust scale. Foliage and leaves sway with it.",
+  init: () => ({ direction: [1, 0, 0.35], strength: 1, gustScale: 0.05 })
+});
+class FoliageRule {
+  rule;
+  layer;
+  chunks = /* @__PURE__ */ new Map();
+  constructor(rule, layer) {
+    this.rule = rule;
+    this.layer = layer;
+  }
+}
+const viewers = { points: new Float64Array(24), cameras: 0, anchors: 0 };
+const rows = new Float32Array(12);
+const order = [];
+function updateFoliage(world, ss, frame, workers) {
+  const layers = world.tryResource(FoliageLayers);
+  if (!layers) return;
+  const surface = ss.surface;
+  if (ss.foliageVersion !== surface.version) clearFoliage(world, ss);
+  ss.foliageVersion = surface.version;
+  surface.viewers(world, viewers);
+  let started = 0;
+  for (const rule of surface.rules) {
+    if (rule.kind !== FOLIAGE) continue;
+    let fr = ss.foliage.get(rule.index);
+    if (!fr) {
+      const layer = makeLayer(ss, rule.index);
+      if (!layer) continue;
+      fr = new FoliageRule(rule.index, layers.add(layer));
+      ss.foliage.set(rule.index, fr);
+    }
+    const f = fr;
+    surface.chunksNear(rule, viewers.points, 0, viewers.cameras, rule.range * KEEP, (chunk, d) => {
+      const id = chunk.key;
+      let c = f.chunks.get(id);
+      if (!c) {
+        c = { id, chunk, job: void 0, slot: -1, kept: frame, distance: d, corners: void 0 };
+        f.chunks.set(id, c);
+      }
+      if (c.kept !== frame) c.distance = d;
+      else c.distance = Math.min(c.distance, d);
+      c.kept = frame;
+    });
+    order.length = 0;
+    for (const c of f.chunks.values()) if (c.kept === frame && c.slot < 0 && !c.job) order.push(c);
+    order.sort((a, b) => a.distance - b.distance || (a.id < b.id ? -1 : 1));
+    for (const c of order) {
+      if (started >= PATCHES_PER_FRAME) break;
+      c.job = surface.startPatch(c.chunk, workers);
+      started++;
+    }
+    for (const c of f.chunks.values()) {
+      if (c.kept !== frame) {
+        if (c.job) c.job.cancelled = true;
+        if (c.slot >= 0) f.layer.removeChunk(c.slot);
+        f.chunks.delete(c.id);
+        continue;
+      }
+      if (c.job && (c.job.ready || !workers || workers.size === 0)) {
+        const patch = surface.finishPatch(c.job);
+        c.job = void 0;
+        const n = patch.grid;
+        c.corners = new Float32Array(12);
+        for (const [k, v] of [0, n - 1, n * n - 1, n * (n - 1)].entries())
+          c.corners.set(patch.positions.subarray(v * 3, v * 3 + 3), k * 3);
+        c.slot = f.layer.allocate();
+        f.layer.setChunk(c.slot, { ...patch, avoid: footprints(ss, c.chunk, frame) });
+      }
+      if (c.slot >= 0) {
+        surface.chunkTransform(world, c.chunk, rows);
+        f.layer.setTransform(c.slot, rows);
+      }
+    }
+  }
+}
+function makeLayer(ss, index) {
+  const rule = ss.surface.rules[index];
+  const meshes = [];
+  const lods = [];
+  const weights = [];
+  let material = null;
+  let prev = 0;
+  for (const [i, variants] of ss.variants[index].entries()) {
+    const w = (rule.weights[i] - prev) / variants.length;
+    prev = rule.weights[i];
+    for (const v of variants) {
+      if (!v.mesh) continue;
+      meshes.push(v.mesh);
+      lods.push(v.lods);
+      weights.push((weights.at(-1) ?? 0) + w);
+      material ??= v.material;
+    }
+  }
+  if (meshes.length === 0 || !material) return void 0;
+  weights[weights.length - 1] = 1;
+  const kind = ss.surface.kind === "planet" ? "planet" : "mesh";
+  return new FoliageLayer({
+    label: `${kind}:${rule.name}`,
+    meshes: meshes.slice(0, 32),
+    lods: lods.slice(0, 32),
+    weights,
+    material,
+    seed: rule.seed,
+    cells: ss.surface.cells[index],
+    range: rule.range,
+    shadowRange: rule.shadowRange,
+    scale: [rule.scaleMin, rule.scaleMax],
+    align: rule.align
+  });
+}
+function footprints(ss, chunk, frame) {
+  const rule = ss.surface.rules[chunk.rule];
+  if (rule.avoid.length === 0) return void 0;
+  const out = [];
+  for (const a of rule.avoid) {
+    for (const other of neighborChunks(ss, ss.surface.rules[a], chunk, frame)) {
+      const p = finalPlacements(ss, other, frame);
+      for (let i = 0; i < p.count; i++) {
+        const o = i * PLACEMENT_STRIDE;
+        out.push(
+          other.chunk.center[0] + p.data[o + P_X] - chunk.center[0],
+          other.chunk.center[1] + p.data[o + P_X + 1] - chunk.center[1],
+          other.chunk.center[2] + p.data[o + P_X + 2] - chunk.center[2],
+          p.data[o + P_RADIUS]
+        );
+      }
+    }
+  }
+  return out.length > 0 ? Float32Array.from(out) : void 0;
+}
+function clearFoliage(world, ss) {
+  const layers = world.tryResource(FoliageLayers);
+  for (const f of ss.foliage.values()) {
+    for (const c of f.chunks.values()) if (c.job) c.job.cancelled = true;
+    layers?.remove(f.layer);
+  }
+  ss.foliage.clear();
+}
+const applied = /* @__PURE__ */ new WeakMap();
+const direction = [1, 0, 0];
+function applyWind(world, materials) {
+  const wind = world.tryResource(Wind);
+  const store = world.tryResource(Materials);
+  if (!wind || !store) return;
+  const d = wind.direction;
+  const key = `${d[0]},${d[1]},${d[2]}|${wind.strength}|${wind.gustScale}`;
+  const l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]) || 1;
+  direction[0] = d[0] / l;
+  direction[1] = d[1] / l;
+  direction[2] = d[2] / l;
+  for (const ref of materials) {
+    if (!ref) continue;
+    const m = store.get(ref);
+    if (!m || m.type !== Vegetation || applied.get(m) === key) continue;
+    applied.set(m, key);
+    m.set({ windDirection: [...direction], windStrength: wind.strength, gustScale: wind.gustScale });
+  }
+}
+export {
+  FoliageRule,
+  Wind,
+  applyWind,
+  clearFoliage,
+  updateFoliage
+};

package/dist/heightfield-surface.d.ts

@@ -0,0 +1,35 @@
+import type { Entity, Query, World } from '@aethervtt/shard-core';
+import type { HeightfieldRuntime } from '@aethervtt/shard-terrain';
+import { MeshSurface } from './mesh-surface.js';
+import type { SurfaceChunk } from './surface.js';
+/**
+ * A heightfield's ground for scatter (0045 on 0071): heights and face normals from its leaf pages,
+ * the triangles its colliders and mesh have, so a prop stands on what a character stands on. Leaf
+ * pages come from the CPU cache, or are baked on the spot (the same bytes), so placement never
+ * depends on what has streamed in.
+ */
+export declare class HeightfieldIndex {
+    readonly rt: HeightfieldRuntime;
+    readonly minX = 0;
+    readonly minZ = 0;
+    readonly maxX: number;
+    readonly maxZ: number;
+    readonly minY: number;
+    readonly maxY: number;
+    constructor(rt: HeightfieldRuntime);
+    /** The ground under (x, z): writes [height, nx, ny, nz] (up-facing) and returns true on the terrain. */
+    heightAt(x: number, z: number, out: Float64Array): boolean;
+}
+/**
+ * A heightfield terrain as a scatter surface (`Terrain.scatter`): the mesh surface's square
+ * lattice in the terrain's frame (its corner at 0, +Y up), heights from its pages, chunk roots as
+ * grid children of the terrain.
+ */
+export declare class HeightfieldSurface extends MeshSurface {
+    readonly kind = "heightfield";
+    readonly rt: HeightfieldRuntime;
+    constructor(world: World, rt: HeightfieldRuntime, cameras: Query);
+    /** Takes the terrain's pages (again after a rebake). */
+    setTerrain(): void;
+    placeChunkRoot(world: World, root: Entity, chunk: SurfaceChunk): void;
+}

package/dist/heightfield-surface.js

@@ -0,0 +1,61 @@
+import { mainNoise, pageHeight } from "@aethervtt/shard-terrain";
+import { placeInGrid } from "@aethervtt/shard-transform";
+import { MeshSurface } from "./mesh-surface.js";
+class HeightfieldIndex {
+  rt;
+  minX = 0;
+  minZ = 0;
+  maxX;
+  maxZ;
+  minY;
+  maxY;
+  constructor(rt) {
+    this.rt = rt;
+    this.maxX = rt.layout.sizeX;
+    this.maxZ = rt.layout.sizeZ;
+    this.minY = rt.lo;
+    this.maxY = rt.hi;
+  }
+  /** The ground under (x, z): writes [height, nx, ny, nz] (up-facing) and returns true on the terrain. */
+  heightAt(x, z, out) {
+    const rt = this.rt;
+    const l = rt.layout;
+    if (!(x >= 0 && z >= 0 && x <= l.sizeX && z <= l.sizeZ)) return false;
+    const size = l.leafSize;
+    const px = Math.min(l.leavesX - 1, Math.floor(x / size));
+    const pz = Math.min(l.leavesZ - 1, Math.floor(z / size));
+    const page = rt.pages.leafNow(mainNoise(), rt.stack, px, pz);
+    const e = 0.05;
+    const h = pageHeight(rt, page, x, z);
+    const hx = pageHeight(rt, page, Math.min(x + e, (px + 1) * size), z);
+    const hz = pageHeight(rt, page, x, Math.min(z + e, (pz + 1) * size));
+    const dx = (hx - h) / Math.max(1e-6, Math.min(x + e, (px + 1) * size) - x);
+    const dz = (hz - h) / Math.max(1e-6, Math.min(z + e, (pz + 1) * size) - z);
+    const len = Math.sqrt(dx * dx + 1 + dz * dz);
+    out[0] = h;
+    out[1] = -dx / len;
+    out[2] = 1 / len;
+    out[3] = -dz / len;
+    return true;
+  }
+}
+class HeightfieldSurface extends MeshSurface {
+  kind = "heightfield";
+  rt;
+  constructor(world, rt, cameras) {
+    super(world, rt.entity, cameras);
+    this.rt = rt;
+    this.scale = 1;
+  }
+  /** Takes the terrain's pages (again after a rebake). */
+  setTerrain() {
+    this.index = new HeightfieldIndex(this.rt);
+  }
+  placeChunkRoot(world, root, chunk) {
+    placeInGrid(world, root, this.entity, chunk.center);
+  }
+}
+export {
+  HeightfieldIndex,
+  HeightfieldSurface
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { addRemoved, isRemoved, Prop, propIdentity, Removed, type RemovedProps, removedKey, ScatterBudget, type ScatterBudgetValue, ScatterChunk, ScatterSurface, } from './components.js';
+export { applyWind, clearFoliage, FoliageRule, updateFoliage, Wind, type WindValue, } from './foliage.js';
+export { GENERATOR_LOOKS, SCATTER_SHADERS, SWAY_WGSL, Vegetation } from './material.js';
+export { HeightIndex, MeshSurface } from './mesh-surface.js';
+export { resolveSurface, samplePlacements, scatterMethods } from './methods.js';
+export { foliageChunksOverlay, scatterOverlay } from './overlays.js';
+export { cellsPerChunk, nodeMetres, PlanetSurface, ruleDepth, writeRotation } from './planet.js';
+export { type ScatterPluginOptions, scatterPlugin, updateScatter } from './plugin.js';
+export { scatterSetPreview } from './preview.js';
+export { type CompiledItem, type CompiledRule, cellRandom, cellSize, compileRules, FOLIAGE, jitterFor, MAX_FOLIAGE_PER_CHUNK, MAX_PROPS_PER_CHUNK, PROP, type SetSource, } from './rules.js';
+export { type ChunkState, defaultMaterial, finalPlacements, type ItemVariant, neighborChunks, PLACEMENT_DELAY, type RuleStats, Scatter, ScatterState, SurfaceScatter, } from './runtime.js';
+export { PROP_COLLIDERS, type PropCollider, type ScatterItemValue, type ScatterRuleValue, ScatterSet, type ScatterSetValue, } from './set.js';
+export { type ChunkPlacements, type FoliagePatch, P_CELL, P_ITEM, P_QX, P_RADIUS, P_SCALE, P_SHADE, P_VARIANT, P_X, type PatchJob, PLACEMENT_STRIDE, type PlacementJob, type Surface, type SurfaceChunk, } from './surface.js';

package/dist/index.js

@@ -0,0 +1,120 @@
+import {
+  addRemoved,
+  isRemoved,
+  Prop,
+  propIdentity,
+  Removed,
+  removedKey,
+  ScatterBudget,
+  ScatterChunk,
+  ScatterSurface
+} from "./components.js";
+import {
+  applyWind,
+  clearFoliage,
+  FoliageRule,
+  updateFoliage,
+  Wind
+} from "./foliage.js";
+import { GENERATOR_LOOKS, SCATTER_SHADERS, SWAY_WGSL, Vegetation } from "./material.js";
+import { HeightIndex, MeshSurface } from "./mesh-surface.js";
+import { resolveSurface, samplePlacements, scatterMethods } from "./methods.js";
+import { foliageChunksOverlay, scatterOverlay } from "./overlays.js";
+import { cellsPerChunk, nodeMetres, PlanetSurface, ruleDepth, writeRotation } from "./planet.js";
+import { scatterPlugin, updateScatter } from "./plugin.js";
+import { scatterSetPreview } from "./preview.js";
+import {
+  cellRandom,
+  cellSize,
+  compileRules,
+  FOLIAGE,
+  jitterFor,
+  MAX_FOLIAGE_PER_CHUNK,
+  MAX_PROPS_PER_CHUNK,
+  PROP
+} from "./rules.js";
+import {
+  defaultMaterial,
+  finalPlacements,
+  neighborChunks,
+  PLACEMENT_DELAY,
+  Scatter,
+  ScatterState,
+  SurfaceScatter
+} from "./runtime.js";
+import {
+  PROP_COLLIDERS,
+  ScatterSet
+} from "./set.js";
+import {
+  P_CELL,
+  P_ITEM,
+  P_QX,
+  P_RADIUS,
+  P_SCALE,
+  P_SHADE,
+  P_VARIANT,
+  P_X,
+  PLACEMENT_STRIDE
+} from "./surface.js";
+export {
+  FOLIAGE,
+  FoliageRule,
+  GENERATOR_LOOKS,
+  HeightIndex,
+  MAX_FOLIAGE_PER_CHUNK,
+  MAX_PROPS_PER_CHUNK,
+  MeshSurface,
+  PLACEMENT_DELAY,
+  PLACEMENT_STRIDE,
+  PROP,
+  PROP_COLLIDERS,
+  P_CELL,
+  P_ITEM,
+  P_QX,
+  P_RADIUS,
+  P_SCALE,
+  P_SHADE,
+  P_VARIANT,
+  P_X,
+  PlanetSurface,
+  Prop,
+  Removed,
+  SCATTER_SHADERS,
+  SWAY_WGSL,
+  Scatter,
+  ScatterBudget,
+  ScatterChunk,
+  ScatterSet,
+  ScatterState,
+  ScatterSurface,
+  SurfaceScatter,
+  Vegetation,
+  Wind,
+  addRemoved,
+  applyWind,
+  cellRandom,
+  cellSize,
+  cellsPerChunk,
+  clearFoliage,
+  compileRules,
+  defaultMaterial,
+  finalPlacements,
+  foliageChunksOverlay,
+  isRemoved,
+  jitterFor,
+  neighborChunks,
+  nodeMetres,
+  propIdentity,
+  removedKey,
+  resolveSurface,
+  ruleDepth,
+  samplePlacements,
+  scatterMethods,
+  scatterOverlay,
+  scatterPlugin,
+  scatterSetPreview,
+  updateFoliage,
+  updateScatter,
+  writeRotation
+};

package/dist/material.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Vegetation and stone for scatter items (0045): the standard material, tinted by the part code
+ * the engine generators write in the second uv set (x: 0 bark/base to 1 leaf/tip, y: a per-vertex
+ * shade), and swayed by the wind (scaled by the part code, so trunks and roots stay put).
+ */
+export declare const Vegetation: import("@aethervtt/shard-render").MaterialType;
+/**
+ * The sway every scatter material shares: a world-space wind vector, made tangent to the item's
+ * up axis, moved into object space, scaled by the vertex's part code squared (roots don't move).
+ */
+export declare const SWAY_WGSL: (u: string) => string;
+export declare const SCATTER_SHADERS: Record<string, string>;
+/** Default looks per engine generator: tints, roughness, sway. */
+export declare const GENERATOR_LOOKS: Record<string, {
+    baseTint: number[];
+    tipTint: number[];
+    roughness: number;
+    sway: number;
+    doubleSided?: boolean;
+}>;