@oeave/bakery3 0.0.0-stage → 0.1.0

package/dist/presets/index.d.ts

@@ -0,0 +1,526 @@
+import { P as PedestalPresetName, M as MaterialPresetName, a as PresetTextureSize, H as HdriPresetName } from '../catalog.gen-BM-aNf7n.js';
+export { b as HDRI_PRESETS, c as HdriPresetInfo, d as MATERIAL_PRESETS, e as MaterialPresetInfo, f as PEDESTAL_PRESETS, g as PedestalPresetInfo, h as PresetMapName } from '../catalog.gen-BM-aNf7n.js';
+import { Group, ColorRepresentation, MeshStandardMaterial, DataTexture, Texture, Object3D, Vector3, PerspectiveCamera } from 'three';
+import { a as RoomPresetLighting, R as RoomPresetName } from '../rooms.gen-vhj6sFW5.js';
+
+/**
+ * Where the preset library is served from.
+ *
+ * A leaf on purpose: the bake session needs the base URL to fetch a preset
+ * room's lightmaps, and importing it from the presets entry would drag the
+ * room loader (GLTFLoader, GroundedSkybox) into every bundle that bakes.
+ */
+/**
+ * Point the SDK at another copy of the preset library, for self-hosting or a
+ * local mirror. The host must send CORS headers: the SDK reads texture pixels
+ * back when it builds a manifest.
+ */
+declare function setPresetBaseUrl(url: string): void;
+declare function presetBaseUrl(): string;
+
+/**
+ * The implementation behind `@oeave/bakery3/presets`: materials, HDR
+ * environments, the parametric room and pedestals. `index.ts` lists what is
+ * public.
+ */
+
+type PresetEnvironmentOptions = {
+    /** Override the preset CDN, primarily for a local development server. */
+    baseUrl?: string;
+};
+/**
+ * Load the lightweight HDR preview while registering the EXR render master
+ * with the core SDK. Assign the returned texture to `scene.environment` (and
+ * optionally `scene.background`); render with
+ * `background: { type: 'environment' }` when the rendered output should show it.
+ * captureScene sends only the master URL, so the browser never downloads or
+ * uploads the EXR.
+ */
+declare function loadPresetEnvironment(name: HdriPresetName, options?: PresetEnvironmentOptions): Promise<Texture>;
+type SkyEnvironmentOptions = {
+    /** Straight overhead. Default a deep clear-day blue. */
+    zenith?: ColorRepresentation;
+    /**
+     * At the horizon, where most of the light that comes through a window
+     * comes from. Default a saturated sky blue: a paler, more physical horizon
+     * vanishes against a room's sun.
+     */
+    horizon?: ColorRepresentation;
+    /** Below the horizon: the ground's bounce. Default a warm gray. */
+    ground?: ColorRepresentation;
+    /**
+     * Multiplies the whole dome. 1 is a clear sky at exposure 0 seen through
+     * the window; a room that is also lit by a sun of 3 to 4 wants 4 to 6
+     * here before its shade turns cool, because the physical ratio between
+     * sun and sky is far larger than a single exposure can hold.
+     */
+    intensity?: number;
+    /** Equirect width in pixels; height is half. A gradient needs no more than the default 128. */
+    width?: number;
+};
+/**
+ * A sky to put outside the windows.
+ *
+ * A room with windows lit by a studio probe is lit by a studio through its
+ * windows, and it shows: the light that comes in is neutral, and the cool
+ * cast a real window throws (the blue of the sky against the warmth of the
+ * sun) is missing. This is a generated equirectangular gradient (blue
+ * overhead, paling to the horizon, a warm ground below) as an ordinary
+ * `DataTexture`, so `scene.environment = createSkyEnvironment()` lights the
+ * preview through PMREM like any HDRI, and the SDK ships the same pixels to
+ * the render as a small Radiance file: no download, no CDN.
+ *
+ * It is a sky, not a sun: pair it with `createRoom({ sun })`, which carries
+ * the crisp shadows. A room with a closed ceiling only ever sees this
+ * through its openings, which is the point.
+ */
+declare function createSkyEnvironment(options?: SkyEnvironmentOptions): DataTexture;
+type PresetMaterialOptions = {
+    /** Texture resolution to load. 2k is the web default; 4k for close-ups. */
+    size?: PresetTextureSize;
+    /** Override the CDN base for this material only. */
+    baseUrl?: string;
+    /** Extra multiplier on the physical repeat (2 = pattern twice as dense). */
+    repeat?: number;
+    /** Skip the AO map (it needs a second render bounce to matter less). */
+    ao?: boolean;
+    anisotropy?: number;
+};
+/**
+ * A MeshStandardMaterial wired to a preset's baked maps. Returns
+ * synchronously; textures stream in and the material fills out as they
+ * arrive (use loadPresetMaterial to await them). Tint `matte_paint`, or
+ * any preset, with `material.color`.
+ */
+declare function createPresetMaterial(name: MaterialPresetName, options?: PresetMaterialOptions): MeshStandardMaterial;
+/** createPresetMaterial, resolved once every map has actually loaded. */
+declare function loadPresetMaterial(name: MaterialPresetName, options?: PresetMaterialOptions): Promise<MeshStandardMaterial>;
+type WindowSpec = {
+    /**
+     * Meters along the wall from its center; positive is to your right as you
+     * face the wall from inside the room. Default 0 (centered).
+     */
+    offset?: number;
+    /** Opening width in meters. Default 1.2. */
+    width?: number;
+    /** Opening height in meters. Default 1.4. */
+    height?: number;
+    /** Meters from the floor to the bottom of the opening. Default 0.9. */
+    sill?: number;
+    /** Painted frame in the opening. Default true. */
+    frame?: boolean;
+    /** Glass pane (MeshPhysicalMaterial, transmission 1). Default false. */
+    glass?: boolean;
+    /**
+     * Leaves outside the opening, so sun through it arrives dappled rather
+     * than as one hard rectangle, the way a window with something outside it
+     * does. Default true. Ordinary leaf geometry: it shows through the glass
+     * and traces like any other mesh.
+     */
+    foliage?: boolean;
+};
+type RoomWallName = 'north' | 'south' | 'west' | 'east';
+type SunOptions = {
+    /** Degrees above the horizon. Default 32. */
+    elevation?: number;
+    /**
+     * Degrees clockwise from north (the −z wall) as seen from above. Default
+     * 0: straight through a north-wall window.
+     */
+    azimuth?: number;
+    /** Light intensity. Default 3.5. */
+    intensity?: number;
+    color?: ColorRepresentation;
+    /**
+     * Angular diameter in degrees: how crisp the shadows trace. Default 0.53,
+     * the real sun: a leaf two meters outside still draws a leaf on the floor.
+     * Without it the renderer's default is a studio-soft 12°, which turns sun
+     * through a window into a glow and a canopy into mottling.
+     */
+    angleDeg?: number;
+};
+type RoomOptions = {
+    /** Meters. Defaults: 4 × 4 × 2.7. */
+    width?: number;
+    depth?: number;
+    height?: number;
+    floor?: MaterialPresetName;
+    walls?: MaterialPresetName;
+    /** Pass null for an open ceiling (studio lighting from above). */
+    ceiling?: MaterialPresetName | null;
+    /** Wall thickness in meters: the depth of window reveals. Default 0.15. */
+    wallThickness?: number;
+    /**
+     * Window openings per wall. north is the −z wall; offsets are measured to
+     * your right as you face each wall from inside.
+     */
+    windows?: Partial<Record<RoomWallName, WindowSpec | readonly WindowSpec[]>>;
+    /**
+     * Add a shadow-casting sun outside the room. Aim it through a window
+     * (azimuth 0 = through the north wall) and the render traces real daylight
+     * falling in; the WebGL preview shows the same shafts, because every
+     * room surface casts shadows.
+     */
+    sun?: SunOptions | true;
+    materialOptions?: PresetMaterialOptions;
+};
+/**
+ * An interior shell: floor at y = 0, centered on the origin, every surface
+ * facing inward (from outside the walls are backface-culled, which makes
+ * orbiting and debugging pleasant, but they still block light: traced
+ * geometry is two-sided, and the preview shadow pass renders both sides).
+ *
+ * Structure, all by name so surfaces can be restyled or removed:
+ *   floor, ceiling: meshes
+ *   wall-north (−z), wall-south, wall-west, wall-east: groups holding a
+ *     'face' mesh plus 'window-N' groups (reveal-*, frame and glass
+ *     meshes, and a 'foliage' group, the canopy outside, on by default)
+ *   sun: when requested, a group holding 'sun-light' and its aim target
+ */
+declare function createRoom(options?: RoomOptions): Group;
+type PedestalOptions = {
+    /** Which pedestal. Default `pedestal_block`; or pass the name first. */
+    type?: PedestalPresetName;
+    material?: MaterialPresetName;
+    materialOptions?: PresetMaterialOptions;
+    baseUrl?: string;
+};
+/**
+ * A pedestal from `createPedestal()`: a plain three.js `Group`, with what a
+ * page needs from it typed on `userData`. Anything else on `userData` is
+ * yours, as on any object.
+ */
+interface PresetPedestal extends Group {
+    userData: {
+        /**
+         * The resting height for what it displays, in meters:
+         * `product.position.y = pedestal.userData.topY`.
+         */
+        topY: number;
+        /**
+         * Resolves with the pedestal once its model is in. Await it before a
+         * render: one started earlier gets an empty group.
+         */
+        ready: Promise<PresetPedestal>;
+        [key: string]: any;
+    };
+}
+/**
+ * A pedestal with a preset material, base at y = 0. Returns a Group
+ * immediately; the mesh streams in (await `userData.ready` to know when).
+ * `userData.topY` is the resting height for whatever it displays:
+ * `product.position.y = pedestal.userData.topY` and the product sits on it.
+ *
+ *     createPedestal('pedestal_column', { material: 'carrara_marble' });
+ *     createPedestal({ type: 'pedestal_column', material: 'carrara_marble' });
+ */
+declare function createPedestal(type: PedestalPresetName, options?: Omit<PedestalOptions, 'type'>): PresetPedestal;
+declare function createPedestal(options?: PedestalOptions): PresetPedestal;
+
+/**
+ * A preset room lit by its own library lightmaps, the moment it is added.
+ *
+ * A room that has been prebaked under a lighting mode (`ROOM_PRESETS[name]
+ * .prebaked`) has its light on the preset CDN already: the same bundle a
+ * product bake in `room: 'preset'` mode stands on. `createPresetRoom` applies
+ * it to the stand-in through a bake session of the room's own, so the
+ * viewport shows traced bounce and contact shadows before anyone bakes
+ * anything, and costs nothing but the download.
+ *
+ * Two sessions, one set of materials. A developer's own bake session covers
+ * the whole scene, room included, and a bundle that stands its product in a
+ * preset room lays the same room lightmaps down again under its own. Two
+ * patches on one material would each record the other's edit as the thing to
+ * restore. So the room's patch is registered here, and a session about to
+ * light any of the room's objects suspends it first and resumes it after its
+ * own patch is gone: always nested, never interleaved.
+ *
+ * Only an unmodified room is lit this way, by the same rule the bake uses
+ * (`roomPrebakeChanges`): the library's light is a photograph of one
+ * arrangement, and another floor or another view outside is another light.
+ */
+
+/** What `createPresetRoom` resolves `userData.prebaked` to. */
+type PresetRoomPrebake = {
+    /** Room surfaces that took their lightmap. */
+    applied: number;
+    /** Surfaces the library lit that found no mesh here: a stand-in that
+     *  changed since the prebake. */
+    unmatched: number;
+};
+/**
+ * Show or hide a preset room's library lightmaps. Off, the room is lit by its
+ * stand-in lights alone, exactly as it was created; on puts them back. A room
+ * that was never prebaked is left as it is.
+ */
+declare function setPresetRoomPrebaked(room: Object3D, on: boolean): void;
+
+/**
+ * Room presets: a staged interior around the product, in one call.
+ *
+ *     import { createPresetRoom, applyPresetRoomCamera } from '@oeave/bakery3/presets';
+ *
+ *     const room = createPresetRoom('loft_golden', {
+ *       walls: { material: 'white_plaster', color: '#e9dfd0' },
+ *       pedestal: 'pedestal_column',
+ *     });
+ *     scene.add(room);
+ *     product.position.copy(room.userData.stand);   // on the pedestal
+ *     applyPresetRoomCamera(camera, room);          // the published framing
+ *     renderer.toneMappingExposure = room.userData.exposure; // as bright as designed
+ *
+ * What the browser gets is a stand-in: one compressed GLB from the preset
+ * CDN (a few MB: furniture with 1k textures, the shell wearing the same
+ * preset materials `createPresetMaterial` serves, a sun and a hemisphere
+ * fill). It is there so the product can be framed inside the room. None of
+ * it is captured. The manifest carries a small record instead (which room,
+ * which build, which lighting, which surfaces, which stand, the group's
+ * matrix) and the render worker rebuilds the whole set from its own
+ * full-resolution copy: 4k maps, the full geometry, the foliage outside the
+ * glass that dapples the sun, the light fixtures, the portals, the haze. A
+ * product in a room therefore uploads exactly what a bare product uploads.
+ *
+ * Two things follow. The foliage and the light rig are never in the
+ * preview, so the traced image is meant to be richer than the viewport, not
+ * identical to it, and the compatibility report says so once, as an info
+ * item, at capture. And a room's lights and sky replace the scene's
+ * environment for the render: the room owns its daylight.
+ */
+
+/** A preset material, optionally tinted (plaster and paint take a tint well). */
+type RoomSurfaceOption = MaterialPresetName | {
+    material: MaterialPresetName;
+    color?: string;
+};
+type PresetRoomOptions = {
+    /** Day, golden, overcast or night. Defaults to the mode the room was designed under. */
+    lighting?: RoomPresetLighting;
+    floor?: RoomSurfaceOption;
+    walls?: RoomSurfaceOption;
+    ceiling?: RoomSurfaceOption;
+    /** Window sills: stone or timber. Never tinted. */
+    sill?: MaterialPresetName;
+    /**
+     * What the product stands on: a pedestal preset, or `null` for the floor.
+     * Defaults to the room's own stand.
+     */
+    pedestal?: PedestalPresetName | null;
+    /** The pedestal's material. A room whose own stand is a table keeps the
+     *  table's finish. */
+    pedestalMaterial?: MaterialPresetName;
+    /**
+     * Preview lights: the room's sun through its windows, a hemisphere fill,
+     * whatever fixtures the published rig had. Default true. Off, the group is
+     * geometry only, for an app that lights its own viewport.
+     */
+    lights?: boolean;
+    /**
+     * Make the room bakeable. The stand-in's surfaces (floor, walls, ceiling,
+     * sills, the stand, the furniture) then ship in the capture like any mesh,
+     * so `bake()` lists them and the bake lightmaps the room itself:
+     * contact shadows under the product, bounce on the walls. The renderer
+     * still owns the light (sky, sun, portals, foliage, fixtures) and builds no
+     * shell of its own around the shipped one. Off by default: a plain render
+     * of a room uploads only the product.
+     */
+    bake?: boolean;
+    /**
+     * What is outside the windows. By default the map the room was published
+     * with for its mode: its 1k preview on a dome projected onto the ground,
+     * so the view through the glass has a horizon and a floor, turned so the
+     * map's sun sits where the room's sun is. Name another `HDRI_PRESETS`
+     * entry to put that one there instead (the render turns it to the room's
+     * sun the same way), or `false` for nothing outside: the mode's plain sky,
+     * in the viewport and in the render alike.
+     * The dome never ships; the render builds its own from the 4k master.
+     *
+     * The dome is 60 m out, so the camera's `far` must reach past it (100 is
+     * plenty) or the sky is clipped to black. The console says so once.
+     * The render also lays aerial perspective over the distance when the room
+     * was published with air; the stand-in shows the map as shot.
+     */
+    hdri?: HdriPresetName | false;
+    /**
+     * Let the room ask a bake to stand in for its own heavy pieces: a box
+     * where a shelf of books is, a low-poly planter and a flat card where a
+     * plant is. Default true, and it only ever applies to a bake that is
+     * covering the room's own surfaces.
+     *
+     * It is the room's geometry, so the room says how it would like to be
+     * stood in for. `false` bakes every piece as it is, which is what a bundle
+     * shared between pages wants: a card is drawn from one side, and a bundle
+     * everybody downloads has to hold up from all of them.
+     */
+    simplify?: boolean;
+    /**
+     * Your own images in the room's frames, one per picture it hangs, in the
+     * order it hangs them (`ROOM_PRESETS[name].pictures` lists them). A URL
+     * the page can fetch, or a `Blob` you already have; `null` leaves that
+     * frame as published, and a short list leaves the rest.
+     *
+     * The frame stays where it is and the image is cropped to fill it, the
+     * way `object-fit: cover` fills a box, so a portrait photograph in a
+     * landscape frame is centred and cropped rather than letterboxed.
+     */
+    pictures?: ReadonlyArray<PresetRoomPicture | null>;
+    /**
+     * Light the room with its prebaked lightmaps, when the library has them
+     * for this lighting mode (`ROOM_PRESETS[name].prebaked`). Default true.
+     * They arrive after `userData.ready`, and `userData.prebaked` resolves
+     * when they are on (or `null` when there are none). The room must be
+     * unmodified: another floor, walls, ceiling, sill, map outside or stand is
+     * other light, so the room keeps its preview lights. `false` never
+     * downloads them; `setPresetRoomPrebaked(room, false)` turns them off.
+     */
+    prebaked?: boolean;
+    baseUrl?: string;
+    materialOptions?: PresetMaterialOptions;
+};
+/**
+ * A room from `createPresetRoom()`: a plain three.js `Group`, with what a
+ * page needs from it typed on `userData`. Anything else on `userData` is
+ * yours, as on any object.
+ */
+interface PresetRoom extends Group {
+    userData: {
+        /**
+         * Where the product goes: the top of the stand, in the room's own
+         * frame. `product.position.copy(room.userData.stand)`.
+         */
+        stand: Vector3;
+        /** The height of `stand`, in meters. */
+        topY: number;
+        /**
+         * The `toneMappingExposure` the room was designed under. Set the
+         * renderer to it and the room is as bright as its published pictures.
+         */
+        exposure: number;
+        /**
+         * Resolves with the room once its stand-in is in. Await it before a
+         * render: one started earlier gets an empty room.
+         */
+        ready: Promise<PresetRoom>;
+        /**
+         * Resolves when the room's own traced light is on (see the `prebaked`
+         * option), or with `null` when there is none for this room as it is.
+         */
+        prebaked: Promise<PresetRoomPrebake | null>;
+        [key: string]: any;
+    };
+}
+
+/** An image to hang: a URL the page can fetch, or bytes you already have. */
+type PresetRoomPicture = string | Blob;
+/**
+ * A staged room around the origin: floor at y = 0, north wall at −z. Returns
+ * a Group immediately; the stand-in streams in (`userData.ready` resolves
+ * when it has). `userData.stand` is where the product goes (the top of the
+ * pedestal, in the room's own frame) and `userData.topY` is its height.
+ * `userData.exposure` is the `toneMappingExposure` the room was designed
+ * under: the render honors whatever the renderer is set to, so a scene that
+ * adopts it gets the room as bright as its published pictures, and one that
+ * keeps exposure 1 gets a faithful picture about a stop darker.
+ *
+ * Every choice is remembered on `userData.bakery3Preset.roomPreset`, which is
+ * what the capture reads; move or rotate the group freely, the render
+ * rebuilds the room at its world matrix.
+ */
+declare function createPresetRoom(name: RoomPresetName, options?: PresetRoomOptions): PresetRoom;
+/**
+ * Put `camera` where the room was published from (its own framing, aimed at
+ * the stand), in world space, wherever the group sits.
+ */
+declare function applyPresetRoomCamera(camera: PerspectiveCamera, room: Object3D): void;
+
+/**
+ * The public face of the room catalog: `ROOM_PRESETS` as a developer reads
+ * it.
+ *
+ * The generated record (`rooms.gen.ts`) carries everything the SDK and the
+ * renderer agree on: the published build hash, the stand-in's file, the
+ * preview's brightness and colour per mode, the sky's irradiance, the scene
+ * complexity the estimator prices. None of that is anything a page decides
+ * with, and all of it changes whenever a room is published again, so the
+ * public type names only what a developer chooses or places by. The object
+ * is the same one; the SDK's own code reads the full record from
+ * `rooms.gen.ts`.
+ */
+
+/** A preset surface: a preset material and its tint. */
+type RoomPresetSurface = {
+    readonly material: string;
+    readonly color: string;
+};
+/** What a preset room is, as `ROOM_PRESETS[name]` lists it. */
+type RoomPresetInfo = {
+    /** Its name for people, for a picker. */
+    readonly label: string;
+    /** A sentence about it, for a picker. */
+    readonly description: string;
+    /** Meters. Floor at y = 0, centered on the origin; north is −z. */
+    readonly size: {
+        readonly width: number;
+        readonly height: number;
+        readonly depth: number;
+    };
+    /** The lighting mode the room was designed under; any of the four can be asked for. */
+    readonly lighting: RoomPresetLighting;
+    /** The surfaces it comes with, which `createPresetRoom()` options replace. */
+    readonly surfaces: {
+        readonly floor: RoomPresetSurface;
+        readonly walls: RoomPresetSurface;
+        readonly ceiling: RoomPresetSurface;
+        readonly sill: {
+            readonly material: string;
+        };
+    };
+    /** What the product stands on, where, and how high its top is. */
+    readonly stand: {
+        readonly type: string | null;
+        readonly material: string | null;
+        readonly x: number;
+        readonly z: number;
+        readonly rotationDeg: number;
+        readonly top: number;
+        /** three.js axes, meters. `null` when the room has no stand. */
+        readonly size: {
+            readonly x: number;
+            readonly y: number;
+            readonly z: number;
+        } | null;
+    };
+    /** The framing the room was designed with, in its own frame (`applyPresetRoomCamera`). */
+    readonly camera: {
+        readonly position: readonly [number, number, number];
+        readonly target: readonly [number, number, number];
+        readonly lensMm: number;
+        readonly fstop: number | null;
+    };
+    /**
+     * The pictures the room hangs, in the order it hangs them: which wall, and
+     * how long the image's longest side is in meters. `createPresetRoom({
+     * pictures })` fills them in this order.
+     */
+    readonly pictures: readonly {
+        readonly wall: string;
+        readonly size: number;
+    }[];
+    /**
+     * The `toneMappingExposure` the room is designed for, per lighting mode;
+     * `createPresetRoom()` leaves the current mode's on `userData.exposure`.
+     */
+    readonly exposure: Readonly<Record<RoomPresetLighting, number>>;
+    /**
+     * The lighting modes this room's own traced light is published for. In
+     * those, `createPresetRoom()` shows it in the viewport, and a bake of a
+     * product in the unmodified room covers only the product, its stand and
+     * its shadow. In the others a bake lights the whole room.
+     */
+    readonly prebaked: readonly RoomPresetLighting[];
+};
+/** Every preset room, by name. */
+declare const ROOM_PRESETS: {
+    readonly [Name in RoomPresetName]: RoomPresetInfo;
+};
+
+export { HdriPresetName, MaterialPresetName, type PedestalOptions, PedestalPresetName, type PresetEnvironmentOptions, type PresetMaterialOptions, type PresetPedestal, type PresetRoom, type PresetRoomOptions, type PresetRoomPicture, type PresetRoomPrebake, PresetTextureSize, ROOM_PRESETS, type RoomOptions, type RoomPresetInfo, RoomPresetLighting, RoomPresetName, type RoomSurfaceOption, type RoomWallName, type SkyEnvironmentOptions, type SunOptions, type WindowSpec, applyPresetRoomCamera, createPedestal, createPresetMaterial, createPresetRoom, createRoom, createSkyEnvironment, loadPresetEnvironment, loadPresetMaterial, presetBaseUrl, setPresetBaseUrl, setPresetRoomPrebaked };

package/dist/presets/index.js

@@ -0,0 +1,14 @@
+export { applyPresetRoomCamera, createPedestal, createPresetMaterial, createPresetRoom, createRoom, createSkyEnvironment, loadPresetEnvironment, loadPresetMaterial } from '../chunk-6YVQANMW.js';
+import '../chunk-AF5BIELI.js';
+export { presetBaseUrl, setPresetBaseUrl } from '../chunk-4E5VV4QY.js';
+export { setPresetRoomPrebaked } from '../chunk-W6WQ5UP7.js';
+export { HDRI_PRESETS, MATERIAL_PRESETS, PEDESTAL_PRESETS } from '../chunk-6NYR73Y7.js';
+import { ROOM_PRESETS } from '../chunk-MD2U6S4N.js';
+import '../chunk-3G5QL4F4.js';
+
+// src/presets/roomCatalog.ts
+var ROOM_PRESETS2 = ROOM_PRESETS;
+
+export { ROOM_PRESETS2 as ROOM_PRESETS };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/presets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/presets/roomCatalog.ts"],"names":["ROOM_PRESETS"],"mappings":";;;;;;;;;AA6FO,IAAMA,aAAAA,GAET","file":"index.js","sourcesContent":["/**\n * The public face of the room catalog: `ROOM_PRESETS` as a developer reads\n * it.\n *\n * The generated record (`rooms.gen.ts`) carries everything the SDK and the\n * renderer agree on: the published build hash, the stand-in's file, the\n * preview's brightness and colour per mode, the sky's irradiance, the scene\n * complexity the estimator prices. None of that is anything a page decides\n * with, and all of it changes whenever a room is published again, so the\n * public type names only what a developer chooses or places by. The object\n * is the same one; the SDK's own code reads the full record from\n * `rooms.gen.ts`.\n */\n\nimport {\n  ROOM_PRESETS as ROOM_RECORDS,\n  type RoomPresetLighting,\n  type RoomPresetName,\n} from './rooms.gen.js';\n\n/** A preset surface: a preset material and its tint. */\nexport type RoomPresetSurface = {\n  readonly material: string;\n  readonly color: string;\n};\n\n/** What a preset room is, as `ROOM_PRESETS[name]` lists it. */\nexport type RoomPresetInfo = {\n  /** Its name for people, for a picker. */\n  readonly label: string;\n  /** A sentence about it, for a picker. */\n  readonly description: string;\n  /** Meters. Floor at y = 0, centered on the origin; north is −z. */\n  readonly size: {\n    readonly width: number;\n    readonly height: number;\n    readonly depth: number;\n  };\n  /** The lighting mode the room was designed under; any of the four can be asked for. */\n  readonly lighting: RoomPresetLighting;\n  /** The surfaces it comes with, which `createPresetRoom()` options replace. */\n  readonly surfaces: {\n    readonly floor: RoomPresetSurface;\n    readonly walls: RoomPresetSurface;\n    readonly ceiling: RoomPresetSurface;\n    readonly sill: { readonly material: string };\n  };\n  /** What the product stands on, where, and how high its top is. */\n  readonly stand: {\n    readonly type: string | null;\n    readonly material: string | null;\n    readonly x: number;\n    readonly z: number;\n    readonly rotationDeg: number;\n    readonly top: number;\n    /** three.js axes, meters. `null` when the room has no stand. */\n    readonly size: {\n      readonly x: number;\n      readonly y: number;\n      readonly z: number;\n    } | null;\n  };\n  /** The framing the room was designed with, in its own frame (`applyPresetRoomCamera`). */\n  readonly camera: {\n    readonly position: readonly [number, number, number];\n    readonly target: readonly [number, number, number];\n    readonly lensMm: number;\n    readonly fstop: number | null;\n  };\n  /**\n   * The pictures the room hangs, in the order it hangs them: which wall, and\n   * how long the image's longest side is in meters. `createPresetRoom({\n   * pictures })` fills them in this order.\n   */\n  readonly pictures: readonly {\n    readonly wall: string;\n    readonly size: number;\n  }[];\n  /**\n   * The `toneMappingExposure` the room is designed for, per lighting mode;\n   * `createPresetRoom()` leaves the current mode's on `userData.exposure`.\n   */\n  readonly exposure: Readonly<Record<RoomPresetLighting, number>>;\n  /**\n   * The lighting modes this room's own traced light is published for. In\n   * those, `createPresetRoom()` shows it in the viewport, and a bake of a\n   * product in the unmodified room covers only the product, its stand and\n   * its shadow. In the others a bake lights the whole room.\n   */\n  readonly prebaked: readonly RoomPresetLighting[];\n};\n\n/** Every preset room, by name. */\nexport const ROOM_PRESETS: {\n  readonly [Name in RoomPresetName]: RoomPresetInfo;\n} = ROOM_RECORDS;\n"]}