@felbrasil/dreamy 0.1.1 → 0.2.0

package/dist/types/api/src/index.d.ts

@@ -28,4 +28,4 @@ export type { CreationApi, DispatchResult, PartVariantInfo, PremadeInfo } from "
 export type { Clock, IdGenerator } from "./ports/basic-ports.js";
 export type { GitProvider, GitSettings, LibraryEntry, LibrarySync, Persistence, PreferencesStore, SyncStatus, SyncSummary, ViewPreferences, } from "./ports/persistence.js";
 export type { Evaluator, MeshRequest, MeshResult, SkinRequest, SkinResult } from "./ports/evaluator.js";
-export type { BoneTool, DecalBrush, DecalCatalogEntry, FrameOptions, Selection, StampBrush, Tool, ViewSession, Viewport, ViewportCallbacks, } from "./ports/viewport.js";
+export type { BoneTool, DecalBrush, DecalCatalogEntry, CameraView, FrameOptions, Selection, SpriteBake, SpriteBakeOptions, StampBrush, Tool, ViewSession, Viewport, ViewportCallbacks, } from "./ports/viewport.js";

package/dist/types/api/src/ports/viewport.d.ts

@@ -98,6 +98,49 @@ export type FrameOptions = {
     readonly padding?: number;
     /** Where the camera looks from, as a direction from the objects (default: the current view direction). */
     readonly direction?: Vec3;
+    /** An exact angle around the first object's front; replaces `direction` when given. */
+    readonly view?: CameraView;
+};
+/**
+ * A camera angle around an object, in degrees, from its front (+z in its own space, turned by its transform):
+ * 0 / 0 looks straight at the front middle. Positive yaw swings the camera toward the object's left (+x), positive
+ * pitch raises it (90: from above). Yaw 180 looks at the back.
+ */
+export type CameraView = {
+    readonly yaw: number;
+    readonly pitch: number;
+};
+/** What `Viewport.bakeSprite` renders: the objects alone, in pixel art, in a square framed from `view`. */
+export type SpriteBakeOptions = {
+    readonly objectIds: readonly Id[];
+    /** Width and height in pixels (16–512). */
+    readonly size: number;
+    readonly view: CameraView;
+    /** The share of the square left empty around the silhouette, 0–0.5 (default 0.03). */
+    readonly padding?: number;
+    /** The camera's vertical field of view in degrees, 5–60 (default 25: flatter than the studio's 50, as sprites are). */
+    readonly fov?: number;
+};
+/**
+ * A baked sprite. Pixels hold palette roles, not colors, so the sprite can be recolored: 0 transparent, 1 ink
+ * (outlines and black), and `2 + slot × 3 + tone` for the slots primary, secondary, detail, highlight, eye, pupil,
+ * custom, tongue and teeth (in that order) with tone 0 base, 1 light, 2 shade (roles 2–28).
+ */
+export type SpriteBake = {
+    readonly width: number;
+    readonly height: number;
+    /** One role per pixel, rows from the top. */
+    readonly roles: Uint8Array;
+    /** The color of each role (index = role) for the creation's palette, as 0xRRGGBB; role 0 is unused. */
+    readonly colors: readonly number[];
+    /** Where the sprite stands: the lowest opaque row and the centre of the opaque pixels' box, in pixels. */
+    readonly anchor: {
+        readonly footY: number;
+        readonly centerX: number;
+        readonly centerY: number;
+    };
+    /** Opaque pixels whose color was only matched to the nearest role (decal art in colors outside the palette). */
+    readonly approximated: number;
 };
 /** The 3D view. Imperative so the port stays framework-agnostic. */
 export type Viewport = {
@@ -121,5 +164,10 @@ export type Viewport = {
     frame(objectIds: readonly Id[], options?: FrameOptions): void;
     /** Small preview for the library (data URL). */
     thumbnail(): string | undefined;
+    /**
+     * Bakes a sprite of objects (see `SpriteBake`): waits until they have meshed at the finest level, then renders them
+     * alone. The camera the view had is put back. Rejects when the viewport is not mounted or meshing does not settle.
+     */
+    bakeSprite(options: SpriteBakeOptions): Promise<SpriteBake>;
     dispose(): void;
 };

package/dist/types/dreamy/src/bake.d.ts

@@ -0,0 +1,5 @@
+/** Headless sprite baking: `createSpriteBaker()` renders creations as palette-role sprites; the role helpers recolor them. */
+export { createSpriteBaker } from "../../studio/src/sprite-baker.js";
+export type { SpriteBaker, SpriteBakerOptions, SpriteShot } from "../../studio/src/sprite-baker.js";
+export { ROLE_INK, ROLE_TRANSPARENT, roleSlot, SPRITE_ROLE_COUNT, SPRITE_SLOTS, spriteColors, spriteRole, type SpriteSlot, type SpriteTone, } from "../../viewport/src/index.js";
+export type { CameraView, SpriteBake, SpriteBakeOptions } from "../../api/src/index.js";

package/dist/types/studio/src/index.d.ts

@@ -13,3 +13,5 @@ export type { GitRemote } from "./git-remote.js";
 export { EMPTY_LOG, parseCreationLog, serializeCreationLog } from "./creation-file.js";
 export { createIds } from "./ids.js";
 export { clock } from "./clock.js";
+export { createSpriteBaker } from "./sprite-baker.js";
+export type { SpriteBaker, SpriteBakerOptions, SpriteShot } from "./sprite-baker.js";

package/dist/types/studio/src/sprite-baker.d.ts

@@ -0,0 +1,26 @@
+import type { CameraView, Creation, Evaluator, Id, SpriteBake } from "../../api/src/index.js";
+/** One picture of a bake: its angle around the creature's front and its size (see `SpriteBakeOptions`). */
+export type SpriteShot = {
+    readonly view: CameraView;
+    readonly size: number;
+    readonly padding?: number;
+    readonly fov?: number;
+};
+/** Bakes sprites of creations, one at a time, with no studio UI. */
+export type SpriteBaker = {
+    /** The shots of objects in a creation (default: every object), in order. */
+    bake(creation: Creation, shots: readonly SpriteShot[], objectIds?: readonly Id[]): Promise<SpriteBake[]>;
+    /** Releases the canvas, the GPU resources and (when the baker made it) the mesher. */
+    dispose(): void;
+};
+export type SpriteBakerOptions = {
+    /** The element the canvas goes into (default: one made off-screen, removed on dispose). */
+    readonly host?: HTMLElement;
+    /** The mesher (default: a new one, disposed with the baker). */
+    readonly evaluator?: Evaluator;
+};
+/**
+ * A headless sprite baker: the WASM mesher and the viewport on a canvas nobody sees. A page (or a headless browser
+ * on a server) builds creations with `@dreamy/core` and bakes their pictures here. Bakes run one after another.
+ */
+export declare function createSpriteBaker(options?: SpriteBakerOptions): SpriteBaker;

package/dist/types/viewport/src/index.d.ts

@@ -1 +1,2 @@
 export { createViewport, type ViewportOptions } from "./create-viewport.js";
+export { ROLE_INK, ROLE_TRANSPARENT, roleSlot, SPRITE_ROLE_COUNT, SPRITE_SLOTS, spriteColors, spriteRole, type SpriteSlot, type SpriteTone, } from "./math/sprite-roles.js";

package/dist/types/viewport/src/math/sprite-roles.d.ts

@@ -0,0 +1,32 @@
+import type { Palette, SpriteBake } from "../../../api/src/index.js";
+/** The slots a sprite role can name, in role order (the pixel-art palette list without black, which is ink). */
+export declare const SPRITE_SLOTS: readonly ["primary", "secondary", "detail", "highlight", "eye", "pupil", "custom", "tongue", "teeth"];
+export type SpriteSlot = (typeof SPRITE_SLOTS)[number];
+/** 0 base, 1 light, 2 shade (the pixel-art tones). */
+export type SpriteTone = 0 | 1 | 2;
+export declare const ROLE_TRANSPARENT = 0;
+export declare const ROLE_INK = 1;
+/** Roles in use: transparent, ink, and three tones per slot. */
+export declare const SPRITE_ROLE_COUNT: number;
+/** The role of a slot's tone. */
+export declare const spriteRole: (slot: SpriteSlot, tone: SpriteTone) => number;
+/** The slot and tone a role names (undefined for transparent and ink). */
+export declare function roleSlot(role: number): {
+    readonly slot: SpriteSlot;
+    readonly tone: SpriteTone;
+} | undefined;
+/**
+ * The color of every role for a palette (index = role), as the pixel-art render draws them: a slot's base is its
+ * swatch, light and shade its pixel-art variations. Recoloring a sprite is drawing its roles with another table.
+ */
+export declare function spriteColors(palette: Palette): number[];
+/**
+ * Reads the index pass back: `rgba` is the render target's bytes (rows from the bottom, as WebGL reads them), the role
+ * in red and an "approximated" flag in green. Returns rows from the top.
+ */
+export declare function decodeRoles(rgba: Uint8Array, width: number, height: number): {
+    roles: Uint8Array;
+    approximated: number;
+};
+/** Where a sprite stands: its lowest opaque row and the centre of its opaque pixels' box (0s when empty). */
+export declare function spriteAnchor(roles: Uint8Array, width: number, height: number): SpriteBake["anchor"];

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

@@ -1,6 +1,11 @@
-import type { FrameOptions } from "../../../api/src/index.js";
+import type { CameraView, FrameOptions, Quaternion } from "../../../api/src/index.js";
 import { Vector3, type Box3 } from "three";
 import type { Stage } from "./stage.js";
+/**
+ * The direction from an object toward the camera for a `CameraView`: around the object's front (+z in its space,
+ * turned by `rotation`, kept level), yaw toward its left (+x), pitch up from the ground plane.
+ */
+export declare function viewDirection(view: CameraView, rotation: Quaternion): Vector3;
 /**
  * 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

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

@@ -17,10 +17,21 @@ export declare class RenderPipeline {
     private readonly quadCam;
     private paletteKey;
     private readonly size;
+    /** Sprite bakes: the world pass and the role target, kept apart from the view's target. */
+    private bake;
     constructor(stage: Stage, globals: GlobalUniforms);
     render(prefs: ViewPreferences, palette: Palette, keep: readonly Object3D[] | null, isolated: boolean): void;
     private hideUnselected;
     private ensureTarget;
+    /** The offscreen world pass: linear, with "kind" in alpha, and a depth texture for pixel-art outlines. */
+    private worldTarget;
+    /**
+     * A sprite bake: `keep` alone (lights stay, ground and helpers go) in pixel art into a `size`-square target, resolved
+     * to sprite roles instead of colors, read back as RGBA bytes (rows from the bottom). The camera must already be
+     * square. Nothing reaches the canvas.
+     */
+    renderSprite(size: number, palette: Palette, keep: readonly Object3D[]): Uint8Array;
+    private disposeBake;
     private setPalette;
     dispose(): void;
 }

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

@@ -1,3 +1,5 @@
+/** The teeth color's place in the pixel-art palette list (the palette slots, then tongue, teeth, black). */
+export declare const TEETH_INDEX = 8;
 /** 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";
+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;\nuniform float uIndexOut;\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\n// The pixel-art choice for a lit pixel, as a sprite role: 1 ink, or 2 + palette index \u00D7 3 + tone (0 base, 1 light,\n// 2 shade); a shiny surface's light tone is teeth-white (the teeth base role).\nfloat celRole(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 1.0;\n\n    vec3 base = vec3(0.0);\n    float bestScore = 1e9;\n    float bestS = 1.0;\n    float bestI = 0.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; bestI = float(i);\n            base = uPalBase[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 1.0;\n\n    float tau = log2(bestS) + (bayer4(p) - 0.47) * uDither;\n    if (tau > uTone2) return (gloss > uGlossWhite) ? 26.0 : 2.0 + bestI * 3.0 + 1.0;   // only shiny materials catch teeth-white light\n    if (tau > uTone1) return 2.0 + bestI * 3.0;\n    return 2.0 + bestI * 3.0 + 2.0;\n}\n\nvec3 roleColor(float role) {\n    if (role < 1.5) return uInk;\n    float k = role - 2.0;\n    float slot = floor(k / 3.0 + 0.001);\n    float tone = k - slot * 3.0;\n    vec3 col = uInk;\n    for (int i = 0; i < 12; i++) {\n        if (float(i) == slot) col = (tone < 0.5) ? uPalBase[i] : ((tone < 1.5) ? uPalLight[i] : uPalShade[i]);\n    }\n    return col;\n}\n\nvec3 celShade(vec3 c, float gloss, vec2 p) { return roleColor(celRole(c, gloss, p)); }\n\n// A flat (decal) color as the nearest role: x the role, y 1 when the match is not close (art outside the palette)\nvec2 nearestRole(vec3 c) {\n    if (max(c.r, max(c.g, c.b)) < 0.05) return vec2(1.0, 0.0);\n    float best = length(c - uInk), role = 1.0;\n    for (int i = 0; i < 12; i++) {\n        if (i >= uPalCount) break;\n        if (length(uPalBase[i] - uInk) < 0.05) continue;\n        float d0 = length(c - uPalBase[i]), d1 = length(c - uPalLight[i]), d2 = length(c - uPalShade[i]);\n        if (d0 < best) { best = d0; role = 2.0 + float(i) * 3.0; }\n        if (d1 < best) { best = d1; role = 2.0 + float(i) * 3.0 + 1.0; }\n        if (d2 < best) { best = d2; role = 2.0 + float(i) * 3.0 + 2.0; }\n    }\n    return vec2(role, best > 0.08 ? 1.0 : 0.0);\n}\n\nvoid main() {\n    vec2 p = floor(vUv * uSize);\n    vec4 s = texture2D(tColor, (uPixel > 0.5) ? (p + 0.5) / uSize : vUv);\n    // Sprite bake: the role of each pixel in red (/ 255), \"approximated\" in green\n    if (uIndexOut > 0.5) {\n        vec2 r = vec2(0.0);\n        if (s.a > 0.05) {\n            if (s.a >= 0.45 && s.a <= 0.50) r = nearestRole(s.rgb);\n            else r = vec2(celRole(s.rgb, (s.a < 0.4) ? 0.0 : clamp((1.0 - s.a) * 2.0, 0.0, 1.0), p), 0.0);\n        }\n        if (outlineAt(p)) r = vec2(1.0, 0.0);\n        gl_FragColor = vec4(r.x / 255.0, r.y, 0.0, 1.0);\n        return;\n    }\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/viewport.js

@@ -1,8 +1,22 @@
 "use client";
 import {
-  createViewport
-} from "./chunks/chunk-VZMBE5MV.js";
+  ROLE_INK,
+  ROLE_TRANSPARENT,
+  SPRITE_ROLE_COUNT,
+  SPRITE_SLOTS,
+  createViewport,
+  roleSlot,
+  spriteColors,
+  spriteRole
+} from "./chunks/chunk-5KZP6X65.js";
 export {
-  createViewport
+  ROLE_INK,
+  ROLE_TRANSPARENT,
+  SPRITE_ROLE_COUNT,
+  SPRITE_SLOTS,
+  createViewport,
+  roleSlot,
+  spriteColors,
+  spriteRole
 };
 //# sourceMappingURL=viewport.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felbrasil/dreamy",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Dreamy: a voxel creature sculpting studio for React (WASM mesher, Three.js viewport, git-backed saves).",
   "license": "MIT",
   "author": "Felipe Bravo",
@@ -48,6 +48,10 @@
       "types": "./dist/api.d.ts",
       "default": "./dist/api.js"
     },
+    "./bake": {
+      "types": "./dist/bake.d.ts",
+      "default": "./dist/bake.js"
+    },
     "./styles.css": "./dist/styles.css",
     "./dreamy_evaluator.wasm": "./dist/dreamy_evaluator.wasm",
     "./package.json": "./package.json"