@felbrasil/dreamy 0.0.0-stage → 0.1.0

package/dist/types/viewport/src/math/skeleton-math.d.ts

@@ -0,0 +1,32 @@
+import type { Bone, Id, Vec3 } from "../../../api/src/index.js";
+import { Matrix4, Vector3 } from "three";
+/** 64 mat4 per array (uBones, uSeg): the shader's uniform budget. */
+export declare const MAX_BONES = 64;
+export type RigMatrices = {
+    /** Bone id → slot in the GPU arrays (rig order, at most 64). */
+    readonly index: ReadonlyMap<Id, number>;
+    readonly bindGlobal: readonly Matrix4[];
+    /** The displayed pose (the bind pose itself in rig mode or while a part is sculpted). */
+    readonly shownGlobal: readonly Matrix4[];
+    readonly heads: readonly Vector3[];
+};
+export declare const identityArray: <T extends Float32Array<ArrayBufferLike>>(out: T) => T;
+export declare function rigMatrices(allBones: readonly Bone[], showPose: boolean): RigMatrices;
+/** Children of each bone (slots), in rig order. */
+export declare function childSlots(bones: readonly Bone[], index: ReadonlyMap<Id, number>): number[][];
+/** Skinned body: FinalMatrix = shown global × inverse bind, per slot. */
+export declare function writeSkinMatrices(m: RigMatrices, out: Float32Array): void;
+/**
+ * Rigid body parts (the POC's Skeleton.updateSegments): one matrix per bone that aims the part at its primary
+ * child (longest bind segment), stretches it along the bone and scales its thickness across. No blending, so
+ * nothing twists or shears. Identity when shown = bind and the bone has no size; a bone's size (length, thickness)
+ * scales its part on top: its child joints already sit `length` times farther, so the part stretches to meet them.
+ */
+export declare function writeSegmentMatrices(bones: readonly Bone[], m: RigMatrices, out: Float32Array): void;
+/** Auto-weight input (evaluator.skinWeights): per bone its bind head and each child's head. */
+export declare function skinBones(bones: readonly Bone[], m: RigMatrices): {
+    head: Vec3;
+    childHeads: Vec3[];
+}[];
+/** World-free local transform of a bone from a target global (gizmo drags): parentGlobal⁻¹ × target. */
+export declare function localFromGlobal(parentGlobal: Matrix4 | undefined, target: Matrix4): Matrix4;

package/dist/types/viewport/src/math/smear.d.ts

@@ -0,0 +1,20 @@
+/** Smear stroke spacing (the POC's input.js): dabs every 0.4 × stamp size, at most 24 per pointer move. */
+export declare const SMEAR_SPACING_FACTOR = 0.4;
+export declare const SMEAR_MAX_DABS_PER_MOVE = 24;
+export type P3 = {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+};
+export declare const smearSpacing: (size: number) => number;
+/**
+ * Dab points for one pointer move from the last dab to the cursor: evenly spaced on the segment, ending on the
+ * cursor. Empty while the cursor is closer than one spacing (the stroke waits).
+ */
+export declare function smearDabs(last: P3, target: P3, size: number): P3[];
+/** A small brush gets a proportionally small blend so dabs don't melt into one blob (local size × 0.5). */
+export declare const smearBlend: (sculptBlend: number, localSize: {
+    x: number;
+    y: number;
+    z: number;
+}) => number;

package/dist/types/viewport/src/math/symmetry.d.ts

@@ -0,0 +1,21 @@
+import type { Pivot, Symmetry, SymmetryAxis } from "../../../api/src/index.js";
+import { Matrix4, Quaternion, Vector3 } from "three";
+/**
+ * Kaleidoscope instances (the POC's symmetry.js). The viewport only previews copies (ghost brush, selected
+ * shape wires); the evaluator bakes them. Copy k is the source rotated k · 360 / N about each axis
+ * (composed X, Y, Z); N = 2 on an axis mirrors across that axis' plane.
+ */
+export declare const SYM_MAX_N = 12;
+export declare const SYM_MAX_INSTANCES = 128;
+export declare const symAxesOf: (axes: readonly SymmetryAxis[] | undefined) => SymmetryAxis[];
+/** N clamped to 1–12 and to N^(#axes) ≤ 128. */
+export declare function symClampN(n: number, axes: readonly SymmetryAxis[] | undefined): number;
+/** Every non-identity linear part of the symmetry group (read-only, cached). */
+export declare function symInstanceMatrices(n: number, axes: readonly SymmetryAxis[] | undefined): readonly Matrix4[];
+export type Placement = {
+    position: Vector3;
+    quaternion: Quaternion;
+    scale: Vector3;
+};
+/** Instance placements of one shape about the sculpt-local pivot (identity excluded). */
+export declare function symInstances(src: Placement, pivot: Pivot, sym: Symmetry | undefined): Placement[];

package/dist/types/viewport/src/objects/default-look.d.ts

@@ -0,0 +1,3 @@
+import type { ColorRef, SculptLook } from "../../../api/src/index.js";
+/** The POC's new-sculpt defaults (createNewSculptObject), for view-only sculpts (stress test). */
+export declare const defaultLook: (color: ColorRef) => SculptLook;

package/dist/types/viewport/src/objects/mesh-driver.d.ts

@@ -0,0 +1,26 @@
+import type { Evaluator, MeshRequest, MeshResult, Palette, Sculpt, SkinRequest, SkinResult } from "../../../api/src/index.js";
+/**
+ * Talks to the evaluator: one request per key (object, part or rig body), newest wins (results of older
+ * requests are dropped), identical requests are skipped. The view keeps its last mesh until the new one lands.
+ */
+export declare class MeshDriver {
+    private readonly evaluator;
+    private readonly last;
+    private seq;
+    private inFlight;
+    lastMs: number;
+    private disposed;
+    constructor(evaluator: Evaluator);
+    get busy(): number;
+    /** Requests a mesh unless the same content at the same resolution was already requested for this key. */
+    mesh(key: string, sculpt: Sculpt, palette: Palette, resolution: number, content: string, done: (r: MeshResult) => void, view?: MeshRequest["view"], viewSig?: string): void;
+    /** Auto weights for a skinned body, newest wins like meshes. */
+    skin(req: SkinRequest, done: (r: SkinResult) => void): void;
+    /** Forget a key (the object is gone): pending work is dropped. */
+    forget(key: string): void;
+    /** Force the next request of a key through (e.g. after a resolution change). */
+    invalidate(key: string): void;
+    dispose(): void;
+    /** Drop pending results but stay usable (the viewport can be mounted again after dispose). */
+    reset(): void;
+}

package/dist/types/viewport/src/objects/mesh-key.d.ts

@@ -0,0 +1,8 @@
+import type { ColorRef, Palette, Sculpt } from "../../../api/src/index.js";
+/** Palette refs a sculpt's mesh colors depend on (stamps, smear groups, the look's color and foundation). */
+export declare function meshColorRefs(s: Sculpt): ColorRef[];
+/**
+ * Everything the mesh depends on, as a string: stamps, smear groups, pivot (symmetry copies), the look's colors /
+ * material / blend, and the palette colors it uses. Decals, flecks and patterns are shader-only: no remesh.
+ */
+export declare function meshContentKey(s: Sculpt, palette: Palette): string;

package/dist/types/viewport/src/objects/rig-view.d.ts

@@ -0,0 +1,31 @@
+import type { Id, Rig } from "../../../api/src/index.js";
+import { Group } from "three";
+import { type RigMatrices } from "../math/skeleton-math.js";
+import { type SkinUniforms } from "../materials/skin.js";
+import { SculptView } from "./sculpt-view.js";
+import type { ViewContext } from "./view-context.js";
+import { WingView } from "./wing-view.js";
+export declare const partKey: (objectId: Id, boneId: Id) => string;
+export declare const bodyKey: (objectId: Id) => string;
+/**
+ * A rig on screen: its skeleton's GPU matrices (uBones for the skinned body, uSeg for rigid parts), its body
+ * parts (sculpts or flat wings, in the rig's bind space) and its own skinned body. The group is rig space.
+ */
+export declare class RigView {
+    readonly id: Id;
+    private readonly ctx;
+    readonly group: Group<import("three").Object3DEventMap>;
+    readonly skin: SkinUniforms;
+    readonly parts: Map<string, SculptView | WingView>;
+    body: SculptView | null;
+    rig: Rig | null;
+    matrices: RigMatrices | null;
+    private bonesKey;
+    constructor(id: Id, ctx: ViewContext);
+    /** `showPose`: pose mode and not held at bind (a part of this rig is being sculpted). */
+    set(rig: Rig, showPose: boolean): void;
+    private autoSkinning;
+    /** Every sculpt view of the rig (body first, then sculpt parts). */
+    sculptViews(): SculptView[];
+    dispose(): void;
+}

package/dist/types/viewport/src/objects/scene-views.d.ts

@@ -0,0 +1,53 @@
+import type { Creation, Id, SceneObject, SculptTarget, Vec3 as Vec3Like } from "../../../api/src/index.js";
+import { Box3, Vector3, type Group, type Object3D } from "three";
+import { RigView } from "./rig-view.js";
+import { SculptView } from "./sculpt-view.js";
+import type { ViewContext } from "./view-context.js";
+import { WingView } from "./wing-view.js";
+export type ObjectView = {
+    readonly object: SceneObject;
+    readonly view: SculptView | RigView;
+};
+/** What a picked mesh belongs to. */
+export type MeshOwner = {
+    readonly objectId: Id;
+    readonly boneId?: Id;
+    readonly view: SculptView | WingView;
+};
+export declare const targetKey: (t: SculptTarget) => string;
+/**
+ * Keeps one view per scene object in step with the creation (plus view-only objects: the stress test). Objects nest
+ * like the creation's tree; rig parts and bodies live in their rig's group.
+ */
+export declare class SceneViews {
+    private readonly root;
+    private readonly ctx;
+    readonly views: Map<string, ObjectView>;
+    constructor(root: Group, ctx: ViewContext);
+    /** `heldRigId`: the rig whose part / body is being sculpted shows its bind pose. */
+    sync(creation: Creation, extra: readonly SceneObject[], heldRigId: Id | undefined): void;
+    /** Refresh everything against a new palette (looks, decals, meshes). */
+    refreshPalette(): void;
+    sculptView(t: SculptTarget): SculptView | undefined;
+    group(id: Id): Group | undefined;
+    /** Union of an object's meshed sculpt bounds (its own sculpt, or a rig's body and sculpt parts), in object space. */
+    contentBounds(id: Id): {
+        center: Vec3Like;
+        halfSize: Vec3Like;
+    } | undefined;
+    /**
+     * Objects' bounds in world space as drawn: sculpts by their meshes, a rig's rigid parts and wings through their
+     * bones' segment matrices (so a pose moves them), its skinned body by its bind bounds. Empty until something has
+     * meshed.
+     */
+    worldBounds(ids: readonly Id[]): Box3;
+    /** Up to `max` points of objects' drawn surfaces in world space (mesh vertices, posed as the bounds are). */
+    worldPoints(ids: readonly Id[], max?: number): Vector3[];
+    allSculptViews(): SculptView[];
+    allWingViews(): WingView[];
+    /** Meshes that can be clicked (optionally only those of some objects). */
+    pickables(only?: ReadonlySet<Id>): Object3D[];
+    ownerOf(mesh: Object3D): MeshOwner | undefined;
+    triangles(): number;
+    dispose(): void;
+}

package/dist/types/viewport/src/objects/sculpt-view.d.ts

@@ -0,0 +1,66 @@
+import type { Decal, MeshRequest, Sculpt } from "../../../api/src/index.js";
+import { Box3, BufferGeometry, Group, Mesh, type MeshStandardMaterial, Vector3 } from "three";
+import { type DecalUniforms } from "../decals/decal-uniforms.js";
+import { type FleckUniforms } from "../materials/fleck-material.js";
+import { type SkinUniforms } from "../materials/skin.js";
+import type { ViewContext } from "./view-context.js";
+/** How a sculpt's vertices follow a rig: not at all, rigidly with one bone (a part), or by auto weights (a body). */
+export type Skinning = {
+    readonly kind: "none";
+} | {
+    readonly kind: "rigid";
+    readonly slot: number;
+} | {
+    readonly kind: "auto";
+    readonly version: string;
+    readonly weights: (positions: Float32Array, done: (idx: Float32Array, wt: Float32Array) => void) => void;
+};
+/**
+ * One sculpt on screen (a sculpt object, a rig's body or a sculpt body part): the mesh from the evaluator with the
+ * fleck material, its decals and its LOD. The group is the sculpt's local (bind) space.
+ */
+export declare class SculptView {
+    readonly key: string;
+    private readonly ctx;
+    private readonly skin;
+    private skinning;
+    readonly group: Group<import("three").Object3DEventMap>;
+    readonly mesh: Mesh<BufferGeometry, MeshStandardMaterial>;
+    readonly fleck: FleckUniforms;
+    readonly decal: DecalUniforms;
+    sculpt: Sculpt | null;
+    /** Shown instead of `sculpt` while a drag previews (gizmo, smear). */
+    private preview;
+    private dropPreview;
+    bounds: Box3 | null;
+    private view;
+    private viewSig;
+    resolution: number;
+    private decalKey;
+    private lookKey;
+    /** The bone slot a rigid part follows (its segment matrix), if it's one. */
+    get rigidSlot(): number | undefined;
+    constructor(key: string, ctx: ViewContext, skin: SkinUniforms, skinning: Skinning);
+    /** The sculpt shown now (the drag preview while there is one). */
+    get shown(): Sculpt | null;
+    setSkinning(s: Skinning): void;
+    set(sculpt: Sculpt): void;
+    /** A committed drag: keep showing the preview until the creation that includes it arrives (no flicker). */
+    clearPreviewOnNextSet(): void;
+    setPreview(sculpt: Sculpt | null): void;
+    /** Re-applies look, decals and (if needed) the mesh against the current palette. */
+    refresh(): void;
+    /** Chunked LOD view for a large standalone sculpt (camera in sculpt space, quantized signature). */
+    setView(view: MeshRequest["view"] | undefined, sig: string): void;
+    setResolution(res: number): void;
+    private remesh;
+    private install;
+    private applyLook;
+    /** Decals never remesh: they are uniforms over the mesh. */
+    applyDecals(decals: readonly Decal[], force?: boolean): void;
+    setGrayscale(v: number): void;
+    /** Interior rooms need the camera in this sculpt's space. */
+    updateLocalCamera(cameraWorld: Vector3): void;
+    triangles(): number;
+    dispose(): void;
+}

package/dist/types/viewport/src/objects/view-context.d.ts

@@ -0,0 +1,19 @@
+import type { Palette } from "../../../api/src/index.js";
+import type { Texture } from "three";
+import type { DecalAtlas } from "../decals/decal-atlas.js";
+import type { GlobalUniforms } from "../materials/global-uniforms.js";
+import type { MeshDriver } from "./mesh-driver.js";
+/** What every object view shares within one viewport. */
+export type ViewContext = {
+    readonly globals: GlobalUniforms;
+    readonly atlas: DecalAtlas;
+    readonly driver: MeshDriver;
+    readonly env: Texture | null;
+    palette: Palette;
+    /** LOD levels from the base voxel resolution, finest first. */
+    levels: readonly number[];
+    /** Mesh arrived / geometry changed (triangle count, picking caches). */
+    changed(): void;
+    /** A user-facing warning (e.g. the kaleidoscope cap dropped copies). */
+    warn(message: string): void;
+};

package/dist/types/viewport/src/objects/wing-view.d.ts

@@ -0,0 +1,27 @@
+import type { FlatWing, Material } from "../../../api/src/index.js";
+import { BufferGeometry, Group, Mesh, type MeshStandardMaterial } from "three";
+import { type SkinUniforms } from "../materials/skin.js";
+import { type WingUniforms } from "../materials/wing-material.js";
+import type { ViewContext } from "./view-context.js";
+/** A flat wing body part: outline triangulated in its frame, pattern painted on a canvas, rigid to its bone. */
+export declare class WingView {
+    readonly key: string;
+    private readonly ctx;
+    private slot;
+    readonly group: Group<import("three").Object3DEventMap>;
+    readonly mesh: Mesh<BufferGeometry, MeshStandardMaterial>;
+    /** Contour line, pixel art only: keeps a wing seen edge-on a continuous stroke instead of scattered pixels. */
+    private readonly edge;
+    readonly uniforms: WingUniforms;
+    private readonly canvas;
+    private readonly texture;
+    private texKey;
+    private geoKey;
+    /** The bone slot the wing follows (its segment matrix). */
+    get segmentSlot(): number;
+    constructor(key: string, ctx: ViewContext, skin: SkinUniforms, slot: number);
+    set(wing: FlatWing, material: Material, slot: number): void;
+    setGrayscale(v: number): void;
+    triangles(): number;
+    dispose(): void;
+}

package/dist/types/viewport/src/rig/bone-viz.d.ts

@@ -0,0 +1,13 @@
+import type { Id } from "../../../api/src/index.js";
+import { Group, type Matrix4 } from "three";
+import { type RigMatrices } from "../math/skeleton-math.js";
+import type { Bone } from "../../../api/src/index.js";
+/** Bone overlay of one rig (the POC's skeleton viz): segments parent → child and a dot per joint, drawn on top. */
+export declare class BoneViz {
+    readonly root: Group<import("three").Object3DEventMap>;
+    private readonly line;
+    private readonly points;
+    constructor();
+    update(rigWorld: Matrix4, bones: readonly Bone[], m: RigMatrices, rigMode: boolean, selected: Id | undefined): void;
+    dispose(): void;
+}

package/dist/types/viewport/src/scene/camera-motion.d.ts

@@ -0,0 +1,10 @@
+import { Vector3 } from "three";
+import type { Stage } from "./stage.js";
+/** WASD / arrow keys slide the camera and its orbit target over the floor plane (12 units / s). */
+export declare function moveCameraOnFloor(stage: Stage, keys: ReadonlySet<string>, delta: number): void;
+/** Double-click focus: eases the orbit target to a point in 280 ms, keeping the view direction and distance. */
+export declare class CameraTween {
+    private tween;
+    focus(stage: Stage, to: Vector3): void;
+    update(stage: Stage): void;
+}

package/dist/types/viewport/src/scene/camera-sun.d.ts

@@ -0,0 +1,3 @@
+import { type Stage } from "./stage.js";
+/** Camera sun: the sun sits top-front-left of the view and aims at the orbit target; off = the fixed world sun. */
+export declare function updateCameraSun(stage: Stage, on: boolean): void;

package/dist/types/viewport/src/scene/environment.d.ts

@@ -0,0 +1,3 @@
+import { type Texture, type WebGLRenderer } from "three";
+/** One-off PMREM environment for the sculpt materials: gradient sky over a green ground (the POC's scene.js). */
+export declare function createSculptEnvironment(renderer: WebGLRenderer): Texture;

package/dist/types/viewport/src/scene/frame-camera.d.ts

@@ -0,0 +1,10 @@
+import type { FrameOptions } from "../../../api/src/index.js";
+import { Vector3, type Box3 } from "three";
+import type { Stage } from "./stage.js";
+/**
+ * Fits objects in the view like CSS `object-fit: contain`, in 3D. The camera keeps its angle (or takes `direction`)
+ * and moves so the silhouette of `points` exactly fills, on its limiting side, a centred area of `aspect` (as large as
+ * the view allows, less the padding), centred in it. Starts from the bounding box and refines on the points' actual
+ * projection (perspective makes the box loose), a few rounds.
+ */
+export declare function frameContain(stage: Stage, box: Box3, points: readonly Vector3[], options?: FrameOptions): void;

package/dist/types/viewport/src/scene/play-mode.d.ts

@@ -0,0 +1,9 @@
+import type { Stage } from "./stage.js";
+/** Play mode: a ball the player rolls with WASD and Space over the floor; the camera follows. Writes nothing. */
+export declare class PlayMode {
+    private ball;
+    private readonly velocity;
+    get active(): boolean;
+    set(stage: Stage, on: boolean): void;
+    update(stage: Stage, keys: ReadonlySet<string>): void;
+}

package/dist/types/viewport/src/scene/render-pipeline.d.ts

@@ -0,0 +1,26 @@
+import type { Palette, ViewPreferences } from "../../../api/src/index.js";
+import { Object3D } from "three";
+import type { GlobalUniforms } from "../materials/global-uniforms.js";
+import { type Stage } from "./stage.js";
+/**
+ * Normal rendering at screen resolution with nothing special on is a plain render. Anything else (the POC's
+ * renderPost): the world into an offscreen target of the chosen size (linear, with depth and a "kind" in alpha),
+ * a full-screen resolve to the canvas, then the editor helpers on top at screen resolution.
+ */
+export declare class RenderPipeline {
+    private readonly stage;
+    private readonly globals;
+    private target;
+    private targetKey;
+    private readonly quadMat;
+    private readonly quadScene;
+    private readonly quadCam;
+    private paletteKey;
+    private readonly size;
+    constructor(stage: Stage, globals: GlobalUniforms);
+    render(prefs: ViewPreferences, palette: Palette, keep: readonly Object3D[] | null, isolated: boolean): void;
+    private hideUnselected;
+    private ensureTarget;
+    private setPalette;
+    dispose(): void;
+}

package/dist/types/viewport/src/scene/render-settings.d.ts

@@ -0,0 +1,18 @@
+import type { ViewPreferences } from "../../../api/src/index.js";
+/** Nominal size each preset fits into; the render keeps the view's aspect ratio inside it. */
+export declare const RENDER_RES: Record<ViewPreferences["renderResolution"], readonly [number, number] | null>;
+/** Filtered; HD and below are nearest neighbour. */
+export declare const RENDER_SMOOTH_RES: readonly ViewPreferences["renderResolution"][];
+export declare const PIXEL_SHADE_BELOW: number;
+/** Only well-lit faces reach the light tone (was 1.55, which lit most of a creature's upper half). */
+export declare const PIXEL_LIGHT_ABOVE: number;
+/** Gloss (1 − roughness) above which the light tone turns teeth-white: only truly shiny surfaces, not every
+ *  roughness ≤ 0.5 part (the fleck shader clamps roughness to ≥ 0.4, so flecked sculpts keep their palette light). */
+export declare const PIXEL_GLOSS_WHITE = 0.8;
+export declare const PIXEL_DITHER = 0.45;
+export declare const PIXEL_EDGE = 0.02;
+export declare const PIXEL_MAX_PALETTE = 12;
+/** Largest size with the canvas' aspect ratio that fits inside the preset's nominal size. */
+export declare function renderFitSize(res: ViewPreferences["renderResolution"], w: number, h: number): [number, number];
+/** Pixel art has no translucency: coverage (texture alpha × opacity) at or above this draws solid, below it is dropped. */
+export declare const PIXEL_ALPHA_CUT = 0.2;

package/dist/types/viewport/src/scene/resolve-frag.d.ts

@@ -0,0 +1,3 @@
+/** Full-screen resolve of the offscreen world pass (the POC's rendering.js): tone mapping + sRGB, or pixel-art
+   palette cel shading, dithering and depth outlines; background or a checkerboard behind transparent pixels. */
+export declare const RESOLVE_FRAG = "\nuniform sampler2D tColor;\nuniform sampler2D tDepth;\nuniform vec2 uSize;\nuniform float uNear;\nuniform float uFar;\nuniform float uExposure;\nuniform float uDpr;\nuniform float uPixel;\nuniform float uChecker;\nuniform vec3 uBg;\nuniform int uPalCount;\nuniform vec3 uPalRaw[12];\nuniform vec3 uPalBase[12];\nuniform vec3 uPalLight[12];\nuniform vec3 uPalShade[12];\nuniform vec3 uTeeth;\nuniform vec3 uInk;\nuniform float uEdge;\nuniform float uTone1;\nuniform float uTone2;\nuniform float uDither;\nuniform float uGlossWhite;\nvarying vec2 vUv;\n\n// same curves three.js applies to a material's output on screen\nvec3 RRTAndODTFit(vec3 v) {\n    vec3 a = v * (v + 0.0245786) - 0.000090537;\n    vec3 b = v * (0.983729 * v + 0.4329510) + 0.238081;\n    return a / b;\n}\nvec3 acesFilmic(vec3 color) {\n    const mat3 inMat = mat3(vec3(0.59719, 0.07600, 0.02840), vec3(0.35458, 0.90834, 0.13383), vec3(0.04823, 0.01566, 0.83777));\n    const mat3 outMat = mat3(vec3(1.60475, -0.10208, -0.00327), vec3(-0.53108, 1.10813, -0.07276), vec3(-0.07367, -0.00605, 1.07602));\n    color *= uExposure / 0.6;\n    color = inMat * color;\n    color = RRTAndODTFit(color);\n    color = outMat * color;\n    return clamp(color, 0.0, 1.0);\n}\nvec3 toSRGB(vec3 c) {\n    return mix(pow(c, vec3(0.41666)) * 1.055 - vec3(0.055), c * 12.92, vec3(lessThanEqual(c, vec3(0.0031308))));\n}\n\nfloat bayer2(vec2 a) { a = floor(a); return fract(a.x / 2.0 + a.y * a.y * 0.75); }\nfloat bayer4(vec2 a) { return bayer2(0.5 * a) * 0.25 + bayer2(a); }\n\nvec2 pixUv(vec2 p) { return (clamp(p, vec2(0.0), uSize - 1.0) + 0.5) / uSize; }\n\n// 1 / view-space depth: planes are linear in it across the screen, so a flat floor seen at a glancing\n// angle gives no edge while a real depth step does\nfloat invZ(vec2 p) {\n    float d = texture2D(tDepth, pixUv(p)).r;\n    float z = 2.0 * uNear * uFar / (uFar + uNear - (2.0 * d - 1.0) * (uFar - uNear));\n    return 1.0 / z;\n}\nfloat kindAt(vec2 p) { return texture2D(tColor, pixUv(p)).a; }\n\n// A pixel is outline when a neighbour (4-connected) is clearly nearer than the surface around it and\n// that nearer neighbour is an object (not the ground): the line sits on the far side, outside the shape.\nbool outlineAt(vec2 p) {\n    float w0 = invZ(p);\n    for (int i = 0; i < 4; i++) {\n        vec2 dir = (i == 0) ? vec2(1.0, 0.0) : ((i == 1) ? vec2(0.0, 1.0) : ((i == 2) ? vec2(-1.0, 0.0) : vec2(0.0, -1.0)));\n        float wq = invZ(p + dir);\n        float wq2 = invZ(p - dir);\n        if (wq + wq2 - 2.0 * w0 > uEdge * max(wq, wq2)) {\n            float nearer = (wq >= wq2) ? kindAt(p + dir) : kindAt(p - dir);\n            if (nearer > 0.4) return true;\n        }\n    }\n    return false;\n}\n\nvec3 celShade(vec3 c, float gloss, vec2 p) {\n    // Pixels from black decals or unlit black surfaces render directly as solid ink\n    if (max(c.r, max(c.g, c.b)) < 0.05) return uInk;\n\n    vec3 base = vec3(0.0), light = vec3(0.0), shade = vec3(0.0);\n    float bestScore = 1e9;\n    float bestS = 1.0;\n    float cl = length(c) + 0.02;\n    for (int i = 0; i < 12; i++) {\n        if (i >= uPalCount) break;\n        vec3 P = uPalRaw[i];\n        float s = clamp(dot(c, P) / max(dot(P, P), 0.0001), 0.2, 4.0);\n        float score = length(c - s * P) / cl + 0.12 * abs(log2(s / 1.25));\n        if (score < bestScore) {\n            bestScore = score; bestS = s;\n            base = uPalBase[i]; light = uPalLight[i]; shade = uPalShade[i];\n        }\n    }\n\n    // Black from the palette stays flat: no teeth-white specular, no dithering, no stepping\n    if (length(base - uInk) < 0.05 || length(base) < 0.10) return uInk;\n\n    if (gloss > uGlossWhite) light = uTeeth;   // only shiny materials catch teeth-white light\n    float tau = log2(bestS) + (bayer4(p) - 0.47) * uDither;\n    if (tau > uTone2) return light;\n    if (tau > uTone1) return base;\n    return shade;\n}\n\nvoid main() {\n    vec2 p = floor(vUv * uSize);\n    vec4 s = texture2D(tColor, (uPixel > 0.5) ? (p + 0.5) / uSize : vUv);\n    vec3 bg = uBg;\n    if (uChecker > 0.5) {\n        vec2 g = floor(gl_FragCoord.xy / (9.0 * uDpr));\n        bg = (mod(g.x + g.y, 2.0) < 0.5) ? vec3(0.96) : vec3(0.78);\n    }\n    vec3 col = bg;\n    if (uPixel < 0.5) {\n        if (s.a > 0.05) col = toSRGB(acesFilmic(s.rgb));\n    } else {\n        if (s.a > 0.05) {\n            // Decal pixel: render flat and clean (no scene light, no shadows, no glossiness)\n            // We use a broader threshold to catch blended light/shadow modifier pixels\n            if (s.a >= 0.45 && s.a <= 0.50) {\n                // Ensure pure black decals stay flat black, others render their flat color\n                if (max(s.r, max(s.g, s.b)) < 0.05) col = uInk;\n                else col = s.rgb;\n            } else {\n                float gloss = (s.a < 0.4) ? 0.0 : clamp((1.0 - s.a) * 2.0, 0.0, 1.0);\n                col = celShade(s.rgb, gloss, p);\n            }\n        }\n        if (outlineAt(p)) col = uInk;\n    }\n    gl_FragColor = vec4(col, 1.0);\n}\n";

package/dist/types/viewport/src/scene/stage.d.ts

@@ -0,0 +1,38 @@
+import { DirectionalLight, Group, Mesh, MeshStandardMaterial, PerspectiveCamera, Scene, SphereGeometry, Vector3, WebGLRenderer, type Texture } from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import type { GlobalUniforms } from "../materials/global-uniforms.js";
+export declare const SKY = 11455479;
+export declare const SKY_ISOLATED = 8950950;
+export declare const GROUND = 8832893;
+export declare const GROUND_ISOLATED = 7041664;
+export declare const DEFAULT_SUN_POS: Vector3;
+export declare const LIGHT: {
+    readonly ambient: 0.3;
+    readonly hemisphere: 0.25;
+    readonly sun: 0.8;
+    readonly exposure: 1;
+};
+export declare const DEFAULT_CAMERA: Vector3;
+export declare const DEFAULT_TARGET: Vector3;
+/**
+ * The POC's scene.js init. three r186 lights are physically based, so the POC's (legacy) intensities are
+ * multiplied by π; light / ground / fog colors are raw hex / 255 like the POC; the background is the exact hex.
+ */
+export type Stage = {
+    readonly renderer: WebGLRenderer;
+    readonly scene: Scene;
+    readonly camera: PerspectiveCamera;
+    readonly orbit: OrbitControls;
+    /** What the picture is made of: objects, ground, lights, the play ball. */
+    readonly world: Group;
+    /** Objects of the creation (the views' roots). */
+    readonly objects: Group;
+    /** Editor helpers drawn on top: gizmos, ghosts, wires, bone dots. */
+    readonly ui: Group;
+    readonly sun: DirectionalLight;
+    readonly ground: Mesh<SphereGeometry, MeshStandardMaterial>;
+    readonly env: Texture;
+    setIsolation(on: boolean): void;
+    dispose(): void;
+};
+export declare function createStage(host: HTMLElement, globals: GlobalUniforms): Stage;

package/dist/types/viewport/src/scene/stress-test.d.ts

@@ -0,0 +1,6 @@
+import type { SculptObject } from "../../../api/src/index.js";
+/**
+ * Stress test (the POC's modes.js): 24 compound sculpts on a 5 × 5 grid around the origin. View-only objects:
+ * meshed and drawn like the creation's, never written to it, never selectable.
+ */
+export declare function stressTestObjects(rnd?: () => number): SculptObject[];

package/dist/types/viewport/src/wings/wing-mesh.d.ts

@@ -0,0 +1,19 @@
+import type { WingFrame } from "../../../api/src/index.js";
+import { BufferGeometry } from "three";
+/** Triangulates a wing outline in its frame (rig bind space): origin + x · span axis + y · chord axis. */
+export declare function buildWingGeometry(pts: readonly (readonly [number, number])[], frame: WingFrame, box: {
+    x0: number;
+    y0: number;
+    side: number;
+}): BufferGeometry;
+/**
+ * The wing's contour as a line loop for pixel art. A wing seen nearly edge-on is thinner than one offscreen pixel,
+ * so its triangles hit only scattered pixel centers; a line always rasterizes at least one pixel wide, and the
+ * contour's projection covers the whole edge-on wing. Texture coordinates are pulled slightly inward so the
+ * line takes the membrane's color, not the antialiased transparent rim.
+ */
+export declare function buildWingEdgeGeometry(pts: readonly (readonly [number, number])[], frame: WingFrame, box: {
+    x0: number;
+    y0: number;
+    side: number;
+}): BufferGeometry;

package/dist/types/viewport/src/wings/wing-outlines.d.ts

@@ -0,0 +1,32 @@
+import type { FlatWing, WingOutline } from "../../../api/src/index.js";
+type Seg = readonly number[];
+type Pt = readonly [number, number];
+/** A preset: fore and hind outlines; a membrane wing (bat) also has a wrist and finger tips the veins follow. */
+export type WingPreset = {
+    readonly name: string;
+    readonly fore: readonly Seg[];
+    readonly hind: readonly Seg[];
+    readonly wrist?: Pt;
+    readonly fingers?: readonly Pt[];
+};
+/**
+ * Outline presets in wing units (the POC's wings.js): x from the root (0) along the span to the tip (~1), y
+ * across the chord, positive = backwards. [moveTo, ...bezier triples]; fore and hind shapes per preset.
+ */
+export declare const WING_OUTLINES: Record<WingOutline, WingPreset>;
+export type WingShapeParams = Pick<FlatWing, "outline" | "part" | "span" | "chord" | "tail">;
+/** The outline as 2D points in wing units, after span / chord / tail (hindwing tails spike out of the back margin). */
+export declare function wingOutlinePoints(w: WingShapeParams): [number, number][];
+/** The square the pattern texture covers: the outline's bounds, centered in a square of its longest side. */
+export declare function wingTextureBox(pts: readonly (readonly [number, number])[]): {
+    x0: number;
+    y0: number;
+    side: number;
+};
+/** Seeded PRNG (mulberry32) so a wing's pattern is the same on every repaint. */
+export declare function wingRng(seed: number): () => number;
+/** The seed a wing's pattern draws from: fore and hind wings of one seed differ. */
+export declare const wingPatternSeed: (w: Pick<FlatWing, "seed" | "part">) => number;
+/** Repaint key: the texture is only repainted when the pattern, outline or the colors it uses change. */
+export declare function wingPatternKey(w: FlatWing, hex: (ref: FlatWing["base"]) => number): string;
+export {};

package/dist/types/viewport/src/wings/wing-pattern.d.ts

@@ -0,0 +1,7 @@
+import type { FlatWing } from "../../../api/src/index.js";
+/** Paints the wing's procedural pattern in wing units (the root is the focal point, so fore and hind agree). */
+export declare function paintWingPattern(canvas: HTMLCanvasElement, w: FlatWing, pts: readonly (readonly [number, number])[], box: {
+    x0: number;
+    y0: number;
+    side: number;
+}, css: (ref: FlatWing["base"]) => string): void;

package/dist/viewport.d.ts

@@ -0,0 +1 @@
+export * from "./types/viewport/src/index.js";

package/dist/viewport.js

@@ -0,0 +1,8 @@
+"use client";
+import {
+  createViewport
+} from "./chunks/chunk-VZMBE5MV.js";
+export {
+  createViewport
+};
+//# sourceMappingURL=viewport.js.map

package/dist/viewport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}