@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/kinds/vegetation-impostor.d.ts

@@ -0,0 +1,9 @@
+import { type Mesh, type Rng } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+export interface Impostor {
+    readonly trunk: Mesh;
+    readonly leaves: Mesh;
+}
+export declare function blob(stems: readonly Stem[], p: TreeParams, rng: Rng): Impostor;
+export declare function frondCards(stems: readonly Stem[], p: TreeParams, level: number): Impostor;

package/dist/kinds/vegetation-leaves.d.ts

@@ -0,0 +1,15 @@
+import { type Mesh, type Rng, type Vec3 } from '../core/index.js';
+import { type LeafParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+/** Crown occlusion: cards deep inside / low in the crown are darker. */
+export interface CrownShade {
+    readonly centre: Vec3;
+    readonly radius: number;
+    readonly zMin: number;
+    readonly zMax: number;
+}
+export declare function crownShade(stems: readonly Stem[], level: number): CrownShade;
+/** LOD0: `perStem` cards along the outer 70% of every terminal stem, rooted on a ring vertex. */
+export declare function leafCards(stems: readonly Stem[], level: number, ringSegments: number, leaf: LeafParams, shade: CrownShade, rng: Rng): Mesh;
+/** LOD1: one cluster card per (unemitted) twig, rooted where the twig would leave its parent. */
+export declare function clusterCards(stems: readonly Stem[], level: number, leaf: LeafParams, shade: CrownShade, rng: Rng): Mesh;

package/dist/kinds/vegetation-mesh.d.ts

@@ -0,0 +1,21 @@
+import { type Mesh, type Rng, type Vec3 } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+export declare const radialSegments: (level: number, lod: number) => number;
+/** Every `step`-th path point (always keeping both ends): LOD1 halves path resolution. */
+export declare function coarsen(st: Stem, step: number): {
+    pts: Vec3[];
+    radii: number[];
+};
+/** All stems with level in [lo, hi], merged. */
+export declare function stemsMesh(stems: readonly Stem[], lo: number, hi: number, lod: number, color: Vec3): Mesh;
+/** Bark colour by height (bark → barkTop) with seeded marks; rewrites the mesh's colours. */
+export declare function barkTint(m: Mesh, p: TreeParams, top: number, rng: Rng): Mesh;
+/** The trunk, radius scaled by `radiusScale` (the fit's 1/sy keeps DBH exact after scaling). */
+export declare function trunkMesh(trunk: Stem, p: TreeParams, lod: number, radiusScale: number, rng: Rng): Mesh;
+/** Buttressed flare: `p.roots` lobes, wide at the ground, melting into the trunk by ~2·DBH. */
+export declare function rootsMesh(trunk: Stem, p: TreeParams, lod: number, radiusScale: number, rng: Rng): Mesh;
+/** Per-axis factors that bring the union of `meshes` to `target` = [X, Y, Z] spans. */
+export declare function fitFactors(meshes: readonly Mesh[], target: Vec3): Vec3;
+/** Non-uniform scale about the origin; normals by the inverse transpose, renormalised. */
+export declare function scaleMesh(m: Mesh, s: Vec3): Mesh;

package/dist/kinds/vegetation-params.d.ts

@@ -0,0 +1,90 @@
+import type { Vec2, Vec3 } from '../core/index.js';
+/** Crown envelope: how level-1 branch length varies up the trunk (Weber–Penn `Shape`). */
+export type CrownShape = 'conical' | 'spherical' | 'hemispherical' | 'cylindrical' | 'tapered' | 'flame';
+/** One recursion level. Level 0 is the trunk; levels 1–3 are branches, sub-branches, twigs. */
+export interface BranchLevel {
+    /** Children per parent (level 1: along the trunk). Ignored for level 0. */
+    readonly branches: number;
+    /** Level 0: fraction of tree height. Level ≥ 1: fraction of the parent's length. */
+    readonly length: number;
+    /** ± relative random length variation. */
+    readonly lengthVar?: number;
+    /** Degrees between child and parent axis at the attachment. */
+    readonly downAngle: number;
+    /** Added to downAngle from the first child (bottom) to the last (top) of the parent's zone. */
+    readonly downAngleV?: number;
+    /** Phyllotaxis step about the parent, degrees (golden angle 137.5° by default). */
+    readonly rotate?: number;
+    /** Total bend over the stem, degrees: + towards the sky, − towards the ground. Trunk: + bends
+     * back against `lean` (towards −X). */
+    readonly curve?: number;
+    /** If set, the second half bends by this instead (S-curves, weeping tips). */
+    readonly curveBack?: number;
+    /** Seeded wobble per path segment, ± degrees. */
+    readonly curveVar?: number;
+    /** Where children start along this stem's parent, as a fraction (level 1 uses `baseSize`). */
+    readonly start?: number;
+    /** Path segments at LOD0 (LOD1 halves them). */
+    readonly segments: number;
+}
+export type LeafShape = 'oval' | 'lobed' | 'tuft' | 'strand' | 'frond';
+/** Card outlines: u along the card (0 = stem end), v across (±0.5). */
+export declare const OUTLINES: Record<Exclude<LeafShape, 'frond'>, readonly Vec2[]>;
+export interface LeafParams {
+    readonly shape: LeafShape;
+    /** Card length at LOD0, metres. Cards stand for a cluster of leaves, not one leaf. */
+    readonly size: number;
+    /** Card width as a fraction of its length (fronds: leaflet length as a fraction of frond). */
+    readonly width: number;
+    /** Cards per terminal stem (fronds: leaflets per side). */
+    readonly perStem: number;
+    /** Where cards start along a terminal stem, 0–1 (default 0.3; tufts sit near the tip). */
+    readonly from?: number;
+    readonly color: Vec3;
+    /** ± relative colour variation per card. */
+    readonly colorVar: number;
+    /** 0–1: lay cards level, like the horizontal needle pads of a pine. */
+    readonly flat?: number;
+    /** 0 = cards splay outward, 1 = they hang straight down (willow strands). */
+    readonly hang?: number;
+}
+export interface TreeParams {
+    readonly shape: CrownShape;
+    /** Fraction of the trunk free of branches (clear bole). */
+    readonly baseSize: number;
+    /** [trunk, level 1, level 2?, level 3?]. */
+    readonly levels: readonly BranchLevel[];
+    /** Child radius = parent radius · (child length / parent length)^ratioPower. */
+    readonly ratioPower: number;
+    /** Trunk radius at the top as a fraction of its radius at breast height. */
+    readonly taper: number;
+    /** Trunk lean from vertical towards +X, degrees. The trunk stays in the XZ plane. */
+    readonly lean?: number;
+    readonly bark: Vec3;
+    /** Bark colour at the top of the trunk (Scots pine's orange upper bark); default `bark`. */
+    readonly barkTop?: Vec3;
+    /** Dark bark marks scattered per vertex (birch lenticels): colour + fraction of vertices. */
+    readonly barkMarks?: {
+        readonly color: Vec3;
+        readonly amount: number;
+    };
+    readonly leaves: LeafParams;
+    /** Buttress lobes in the root flare at the base (LOD0/1); 0 or absent = no `roots` part. */
+    readonly roots?: number;
+    /** Fruit hung under the crown (coconuts), merged into `branches`. LOD0 only. */
+    readonly fruit?: {
+        readonly count: number;
+        readonly radius: number;
+        readonly color: Vec3;
+    };
+    /** LOD2 stand-in: a lathe of the crown envelope, or a few coarse frond cards. */
+    readonly impostor: 'blob' | 'cards';
+    /** Typical mature size this preset was tuned on (used when the caller omits spread/dbh). */
+    readonly typical: {
+        readonly height: number;
+        readonly spread: number;
+        readonly dbh: number;
+    };
+}
+/** Weber–Penn ShapeRatio; `r` is 1 at the crown base and 0 at the trunk tip. */
+export declare function shapeRatio(shape: CrownShape, r: number): number;

package/dist/kinds/vegetation-presets.d.ts

@@ -0,0 +1,20 @@
+import type { TreeParams } from './vegetation-params.js';
+/** Quercus robur (English oak): 20–25 m, crown about as wide; girth 4–12 m. Spreading, crooked limbs. */
+export declare const oak: TreeParams;
+/** Pinus sylvestris (Scots pine): 25–35 m, DBH up to 1 m; long clean bole, orange upper bark,
+ * flat-topped crown in the top third, dark blue-green needle tufts on upturned tips. */
+export declare const pine: TreeParams;
+/** Cocos nucifera (coconut palm): up to 30 m; single ringed stem 30–40 cm; 4–6 m pinnate fronds. */
+export declare const palm: TreeParams;
+/** Betula pendula (silver birch): 15–25 m, narrow crown, white bark with black marks, weeping twigs. */
+export declare const birch: TreeParams;
+/** Salix babylonica (weeping willow): 10–15 m, wider than tall; long hanging leafy strands. */
+export declare const willow: TreeParams;
+export declare const SPECIES: {
+    readonly oak: TreeParams;
+    readonly pine: TreeParams;
+    readonly palm: TreeParams;
+    readonly birch: TreeParams;
+    readonly willow: TreeParams;
+};
+export type SpeciesName = keyof typeof SPECIES;

package/dist/kinds/vegetation-skeleton.d.ts

@@ -0,0 +1,20 @@
+import type { Rng, Vec3 } from '../core/index.js';
+import { type TreeParams } from './vegetation-params.js';
+export interface Stem {
+    readonly level: number;
+    readonly pts: readonly Vec3[];
+    readonly radii: readonly number[];
+    readonly length: number;
+    /** Index of the parent stem, −1 for the trunk. */
+    readonly parent: number;
+    /** Attachment point on the parent's bark (cluster cards root here at LOD1). */
+    readonly surface: Vec3;
+    /** Nominal length before shape/variation: drives the child count. */
+    readonly maxLength: number;
+}
+/** Rodrigues rotation of v about unit axis k by angle a (radians). */
+export declare function rotate(v: Vec3, k: Vec3, a: number): Vec3;
+export declare function grow(p: TreeParams, size: {
+    height: number;
+    dbh: number;
+}, rng: Rng): Stem[];

package/dist/kinds/vegetation.d.ts

@@ -0,0 +1,42 @@
+import { type BuildContext, type RealDimensions } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+export interface TreeOptions {
+    /** A preset name (`oak`, `pine`, `palm`, `birch`, `willow`) or a full parameter set. */
+    readonly species?: string | TreeParams;
+    /** Overrides on top of the species. */
+    readonly params?: Partial<TreeParams>;
+    /** Total height, metres (ground to crown top). */
+    readonly height: number;
+    /** Crown spread (X and Y), metres. Default: the species' typical ratio to height. */
+    readonly spread?: number;
+    /** Trunk diameter at breast height (1.3 m), metres. Default: the species' typical ratio. */
+    readonly dbh?: number;
+    readonly seed?: number;
+    /** Part-name prefix: `oak_3` → `oak_3_trunk`, `oak_3_crown`, … */
+    readonly prefix?: string;
+}
+export interface TreeInfo {
+    readonly parts: {
+        trunk: string;
+        crown: string;
+        branches: string;
+        leaves: string;
+        roots: string;
+    };
+    readonly height: number;
+    readonly spread: number;
+    readonly dbh: number;
+}
+export declare function treeParams(o: Pick<TreeOptions, 'species' | 'params'>): TreeParams;
+export declare function tree(ctx: BuildContext, o: TreeOptions): TreeInfo;
+/** `real` for a tree recipe: overall envelope plus DBH (trunk across Y) and total height. */
+export declare function treeReal(o: {
+    height: number;
+    spread: number;
+    dbh: number;
+    prefix?: string;
+    source?: string;
+}): RealDimensions;
+export type TreeFamilyParams = Omit<TreeOptions, 'prefix'>;
+/** One family, many species: `trees.variant({ name: 'oak', params: { species: 'oak', height: 22 } })`. */
+export declare const trees: import("../index.ts").Family<TreeFamilyParams>;

package/dist/kinds/vehicle.d.ts

@@ -0,0 +1,42 @@
+import { type BuildContext, type Vec3 } from '../core/index.js';
+/** A pair of wheels on one spinning axle. */
+export declare function axle(ctx: BuildContext, o: {
+    name: string;
+    at: Vec3;
+    radius: number;
+    gauge: number;
+    width: number;
+    color: Vec3;
+    rps: number;
+}): void;
+/** Lays out wheel groups from a Whyte arrangement along X; returns axle x-positions per role. */
+export declare function whyteAxles(arrangement: string, o: {
+    leading: number;
+    driving: number;
+    trailing: number;
+    spacing: number;
+}): {
+    role: string;
+    x: number;
+    radius: number;
+}[];
+/** One side of a tracked running gear: road wheels (spinning) + a flat track loop. */
+export declare function trackRun(ctx: BuildContext, o: {
+    side: 'l' | 'r';
+    y: number;
+    length: number;
+    wheels: number;
+    radius: number;
+    width: number;
+    color: Vec3;
+    track: Vec3;
+}): void;
+/** A propeller hub + blades that spin about X (nose direction). */
+export declare function propeller(ctx: BuildContext, o: {
+    name: string;
+    at: Vec3;
+    radius: number;
+    blades: number;
+    color: Vec3;
+    parent?: string;
+}): void;

package/dist/material/generator.d.ts

@@ -0,0 +1,4 @@
+import type { PaintedSheet, SheetRecipe } from './paint/types.js';
+export { DEFAULT_SHEET } from './paint/default-sheet.js';
+export type { CellImage, PaintedSheet, SheetRecipe, StripKind, StripRecipe, } from './paint/types.js';
+export declare function paintTrimSheet(recipe?: SheetRecipe): PaintedSheet;

package/dist/material/index.d.ts

@@ -0,0 +1,4 @@
+export { type CellImage, DEFAULT_SHEET, type PaintedSheet, paintTrimSheet, type SheetRecipe, type StripKind, type StripRecipe, } from './generator.js';
+export { definePalette, hex, type Palette, palettes } from './palette.js';
+export { godotShaderSource, type ShaderHints, threeMaterialSource } from './shader.js';
+export { CELLS, type CellId, cellRect, DECAL_CELLS, type DecalCellId, FOLIAGE_CELLS, type FoliageCellId, isFoliage, STRIPS, type StripId, stripRect, TRIM_SHEET_SIZE, type UvRect, } from './trim-sheet.js';

package/dist/material/index.js

@@ -0,0 +1,38 @@
+import {
+  TRIM_SHEET_SIZE2,
+  stripRect2,
+  cellRect2,
+  STRIPS2,
+  CELLS2,
+  DECAL_CELLS2,
+  FOLIAGE_CELLS2,
+  isFoliage2,
+  DEFAULT_SHEET2,
+  paintTrimSheet2,
+  hex2,
+  definePalette2,
+  palettes2,
+  threeMaterialSource2,
+  godotShaderSource2
+} from "../chunk-kvcep7ft.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  CELLS2 as CELLS,
+  DECAL_CELLS2 as DECAL_CELLS,
+  DEFAULT_SHEET2 as DEFAULT_SHEET,
+  FOLIAGE_CELLS2 as FOLIAGE_CELLS,
+  STRIPS2 as STRIPS,
+  TRIM_SHEET_SIZE2 as TRIM_SHEET_SIZE,
+  cellRect2 as cellRect,
+  definePalette2 as definePalette,
+  godotShaderSource2 as godotShaderSource,
+  hex2 as hex,
+  isFoliage2 as isFoliage,
+  paintTrimSheet2 as paintTrimSheet,
+  palettes2 as palettes,
+  stripRect2 as stripRect,
+  threeMaterialSource2 as threeMaterialSource
+};
+
+//# debugId=00CB682D745D7A0764756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/material/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "00CB682D745D7A0764756E2164756E21",
+  "names": []
+}

package/dist/material/paint/bond.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintBond(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/canvas.d.ts

@@ -0,0 +1,32 @@
+export interface Canvas {
+    readonly w: number;
+    readonly h: number;
+    /** World metres the canvas spans along U (x) and V (y). Row y grows with world up (+V). */
+    readonly metresU: number;
+    readonly metresV: number;
+    /** Strips wrap along U (tile seamlessly); cells clamp. */
+    readonly wrapU: boolean;
+    readonly height: Float32Array;
+    readonly tone: Float32Array;
+    readonly rough: Float32Array;
+    readonly metal: Float32Array;
+    /** Extra occlusion multiplied into the cavity AO (foliage darkens toward the twig). */
+    readonly occl: Float32Array;
+    /** sRGB RGBA override (stamped images, coloured foliage); null when painted greyscale. */
+    rgba: Uint8Array | null;
+}
+export declare function createCanvas(w: number, h: number, metresU: number, metresV: number, wrapU: boolean): Canvas;
+/** Metres per pixel along x and y. */
+export declare const pxU: (c: Canvas) => number;
+export declare const pxV: (c: Canvas) => number;
+/** Noise period (lattice cells across the canvas width) for a feature size in metres. */
+export declare function periodFor(c: Canvas, featureMetres: number): number;
+/**
+ * fBm sampled at metres (xm, ym) with feature size `sizeU` along U and `sizeV` along V,
+ * snapped so it tiles along U. Returns [-1, 1].
+ */
+export declare function noiseAt(c: Canvas, xm: number, ym: number, sizeU: number, sizeV: number, seed: number, octaves?: number): number;
+/** Read a parameter with a default, rejecting nothing (validation happens in the generator). */
+export declare const param: (params: Readonly<Record<string, number>> | undefined, key: string, fallback: number) => number;
+export declare const clamp01: (v: number) => number;
+export declare const smooth: (e0: number, e1: number, v: number) => number;

package/dist/material/paint/cell.d.ts

@@ -0,0 +1,4 @@
+import { type CellId } from '../trim-sheet.js';
+import type { Canvas } from './canvas.js';
+import type { CellImage, StripRecipe } from './types.js';
+export declare function paintCell(c: Canvas, id: CellId, entry: StripRecipe | CellImage, seed: number): void;

package/dist/material/paint/cells-round.d.ts

@@ -0,0 +1,5 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintClock(c: Canvas, r: StripRecipe, _seed: number): void;
+export declare function paintSmokebox(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintPorthole(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/cells.d.ts

@@ -0,0 +1,7 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+/** Pane tone: dark enough that `luma < 0.3` marks glass for window glow. */
+export declare const PANE_TONE = 0.12;
+export declare function paintWindowSash(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintDoorPanel(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintSign(c: Canvas, r: StripRecipe, _seed: number): void;

package/dist/material/paint/compose.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+import type { PaintedSheet } from './types.js';
+/** An empty sheet: white albedo (vertex colour reads true), flat normal, AO 1, rough 0.8. */
+export declare function blankSheet(size: number): PaintedSheet;
+export declare function composeRegion(sheet: PaintedSheet, c: Canvas, x0: number, y0: number, pad: number): void;

package/dist/material/paint/concrete.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintConcrete(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/courses.d.ts

@@ -0,0 +1,31 @@
+import type { Canvas } from './canvas.js';
+export interface CourseSpec {
+    /** Course height, metres (along V). */
+    readonly course: number;
+    /** Mean tile length, metres (along U). */
+    readonly length: number;
+    /** 0 = regular; 0.5 = sizes vary ±25 %. */
+    readonly irregular: number;
+    /** Fraction of a tile each odd course shifts; random offsets when irregular. */
+    readonly stagger: number;
+    readonly seed: number;
+}
+export declare class Courses {
+    /** Tile index within the current course, per column. */
+    readonly id: Int32Array;
+    /** Distance to the nearest vertical joint, metres, per column. */
+    readonly dx: Float32Array;
+    /** Distance from the tile's left joint, metres, per column. */
+    readonly ux: Float32Array;
+    /** The current course: index and its bottom / top in metres. */
+    index: number;
+    y0: number;
+    y1: number;
+    private readonly bounds;
+    private readonly c;
+    private readonly spec;
+    constructor(c: Canvas, spec: CourseSpec);
+    /** Point the tables at the course containing metres `ym`; returns the course index. */
+    at(ym: number): number;
+    private fill;
+}

package/dist/material/paint/decode-png.d.ts

@@ -0,0 +1,6 @@
+export interface Rgba {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+export declare function decodePng(bytes: Uint8Array): Rgba;

package/dist/material/paint/default-sheet.d.ts

@@ -0,0 +1,2 @@
+import type { SheetRecipe } from './types.js';
+export declare const DEFAULT_SHEET: SheetRecipe;

package/dist/material/paint/foliage-broad.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+export declare function paintBroadleaf(c: Canvas, seed: number): void;
+export declare function paintMaple(c: Canvas, seed: number): void;
+export declare function paintMapleAutumn(c: Canvas, seed: number): void;
+export declare function paintBirch(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-common.d.ts

@@ -0,0 +1,35 @@
+import type { Rng } from '../../core/index.js';
+import type { Foliage, Rgb } from './foliage-raster.js';
+/** A quadratic Bézier from p0 via p1 to p2, metres in the cell (anchor usually 0.5, 0.02). */
+export interface Curve {
+    readonly x: readonly number[];
+    readonly y: readonly number[];
+    /** Tangent angle per sample (0 = +V, + toward +U), the convention `Foliage.leaf` takes. */
+    readonly a: readonly number[];
+}
+export declare function curve(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, n?: number): Curve;
+/** Sample index nearest parameter t ∈ [0, 1]. */
+export declare const at: (c: Curve, t: number) => number;
+/** Draw a curve as a tapered stem. */
+export declare function drawStem(f: Foliage, c: Curve, w0: number, w1: number, col: Rgb): void;
+/** Jitter a colour per leaf: brightness ±amt and a small hue drift between R and G. */
+export declare function vary(rng: Rng, col: Rgb, amt: number): Rgb;
+export declare const dim: (col: Rgb, k: number) => Rgb;
+/** Leaf palettes, linear RGB (multiply by a near-white vertex colour on the card). */
+export declare const LEAF: {
+    readonly beech: Rgb;
+    readonly maple: Rgb;
+    readonly birch: Rgb;
+    readonly acacia: Rgb;
+    readonly palm: Rgb;
+    readonly dry: Rgb;
+    readonly spruce: Rgb;
+    readonly pine: Rgb;
+    readonly willow: Rgb;
+    readonly reed: Rgb;
+    readonly snow: Rgb;
+    readonly bark: Rgb;
+    readonly twig: Rgb;
+};
+/** Autumn maple: each leaf picks one of these, then gets jittered. */
+export declare const AUTUMN: readonly Rgb[];

package/dist/material/paint/foliage-compound.d.ts

@@ -0,0 +1,4 @@
+import type { Canvas } from './canvas.js';
+export declare function paintAcacia(c: Canvas, seed: number): void;
+export declare function paintPalm(c: Canvas, seed: number): void;
+export declare function paintWillow(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-conifer.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+export declare const paintSpruce: (c: Canvas, seed: number) => void;
+export declare const paintSpruceSnow: (c: Canvas, seed: number) => void;
+export declare function paintNeedles(c: Canvas, seed: number): void;
+export declare function paintReeds(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-raster.d.ts

@@ -0,0 +1,26 @@
+import { type Canvas } from './canvas.js';
+export type Rgb = readonly [number, number, number];
+/** Width profile of a leaf along its length t ∈ [0, 1]; 1 = full half-width. */
+export type LeafShape = 'ovate' | 'lance' | 'needle' | 'blade' | 'palmate';
+export declare class Foliage {
+    private readonly r;
+    private readonly g;
+    private readonly b;
+    private readonly a;
+    private readonly c;
+    private readonly px;
+    constructor(c: Canvas);
+    /** Composite `cov` of colour (cr, cg, cb) × shade over texel i. */
+    private put;
+    /** Pixel bounds of a metre-space box, clipped to the canvas. */
+    private span;
+    /** A tapered stem / twig / rachis from (ax, ay) width w0 to (bx, by) width w1, metres. */
+    stem(ax: number, ay: number, bx: number, by: number, w0: number, w1: number, col: Rgb): void;
+    /**
+     * A leaf from its base (bx, by) along `angle` (radians, 0 = +V, positive = toward +U), `len`
+     * long and `wid` wide at its widest. `serrate` adds teeth; `lift` raises it over earlier layers.
+     */
+    leaf(shape: LeafShape, bx: number, by: number, angle: number, len: number, wid: number, col: Rgb, serrate?: number, lift?: number): void;
+    /** Write the layers to the canvas: sRGB RGBA with bled colour, occlusion toward the twig. */
+    finish(axisX?: number, reach?: number): void;
+}

package/dist/material/paint/foliage.d.ts

@@ -0,0 +1,3 @@
+import type { FoliageCellId } from '../trim-sheet.js';
+import type { Canvas } from './canvas.js';
+export declare const FOLIAGE_PAINTERS: Readonly<Record<FoliageCellId, (c: Canvas, seed: number) => void>>;

package/dist/material/paint/masks.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+export declare function rustStreaks(c: Canvas, amount: number, seed: number): void;
+export declare function grime(c: Canvas, amount: number, seed: number): void;

package/dist/material/paint/noise.d.ts

@@ -0,0 +1,9 @@
+/** Integer hash of a lattice point to [0, 1). */
+export declare function hash2(ix: number, iy: number, seed: number): number;
+/** Value noise in [0, 1] on a unit lattice, periodic in x with an integer `period` (cells). */
+export declare function valueNoise(x: number, y: number, period: number, seed: number): number;
+/**
+ * Fractal Brownian motion in [-1, 1]: `octaves` layers of value noise, each at double frequency
+ * and `gain` amplitude. Doubling keeps the period an integer, so the sum stays tileable.
+ */
+export declare function fbm(x: number, y: number, period: number, seed: number, octaves?: number, gain?: number): number;

package/dist/material/paint/normal.d.ts

@@ -0,0 +1,8 @@
+import type { Canvas } from './canvas.js';
+/** Neighbour column indices, precomputed so the hot loop does no modulo. */
+export declare function neighbours(n: number, wrap: boolean): {
+    lo: Int32Array;
+    hi: Int32Array;
+};
+/** RGBA8 tangent-space normals for the canvas; `strength` scales the slope. */
+export declare function sobelNormals(c: Canvas, strength?: number): Uint8Array;

package/dist/material/paint/orm.d.ts

@@ -0,0 +1,8 @@
+import type { Canvas } from './canvas.js';
+/** Per-texel ambient occlusion in [1 - AO_STRENGTH, 1]. */
+export declare function cavityOcclusion(c: Canvas): Float32Array;
+export declare const SRGB: Uint8Array<ArrayBuffer>;
+/** RGBA8 ORM: R = occlusion, G = roughness, B = metalness, A = 255. */
+export declare function packOrm(c: Canvas, ao: Float32Array): Uint8Array;
+/** RGBA8 sRGB albedo: the stamped image if any, else grey tone × mild cavity. */
+export declare function packAlbedo(c: Canvas, ao: Float32Array): Uint8Array;

package/dist/material/paint/planks.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintPlanks(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/plates.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintPlates(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/shapes.d.ts

@@ -0,0 +1,8 @@
+/** Distance from (px, py) to the segment (ax, ay)–(bx, by). */
+export declare function segment(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+/** Signed distance to an axis-aligned rectangle (negative inside). */
+export declare function rect(px: number, py: number, x0: number, y0: number, x1: number, y1: number): number;
+/** Dome profile in [0, 1] for a round boss of radius `r` at distance `d`. */
+export declare const dome: (d: number, r: number) => number;
+/** Distance to the nearest of `n` points evenly spaced on a circle of radius `ring`. */
+export declare function boltRing(px: number, py: number, ring: number, n: number, phase?: number): number;

package/dist/material/paint/slate.d.ts

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintSlate(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/stamp.d.ts

@@ -0,0 +1,3 @@
+import type { Canvas } from './canvas.js';
+export declare const STAMP_ROUGHNESS = 0.6;
+export declare function stampImage(c: Canvas, png: Uint8Array): void;

package/dist/material/paint/strip.d.ts

@@ -0,0 +1,3 @@
+import type { Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintStrip(c: Canvas, r: StripRecipe, seed: number): void;

package/dist/material/paint/surface.d.ts

@@ -0,0 +1,5 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintFlat(c: Canvas, r: StripRecipe): void;
+export declare function paintNoise(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintGlass(c: Canvas, r: StripRecipe, seed: number): void;