@adatechnology/game-items-three 0.0.0-stage → 0.1.1

package/LICENSE

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

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @adatechnology/game-items-three
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+three.js presentation for `@adatechnology/game-items`. Everything is drawn at the **real size** of the item (metres, y up, origin at the bottom centre).
+
+- **Models of the team:** the 24 builders of the Itens do Vale Cinzento showcase, ported as they are (their units, their materials by tag) and scaled to metres by the `scale` of its entry. A game adds or replaces one with `registerItemModel`.
+- **Simple shapes:** 25 shapes (`can`, `bottle`, `box`, `bag`, `tool`, `blade`, `long_tool`, `garment`, `backpack`, `jerrycan`, `tank`, `book`, `key`, `battery`, `plank`, `device`...) drawn inside the `size` of any item, chosen by its `shape` hint refined by category and proportions (`shapeOf`).
+- **Wear:** `setWear(object, 0 | 1 | 2)` takes the materials from new to used to spoiled, as the showcase does.
+- **Budgets:** `mergeItem` joins an item by material, `buildItemLod` gives three levels (model or shape, half-detail shape, nothing past 30 m for a small item and 60 m for a large one), `ITEM_BUDGETS` and `checkBudget` hold the page's 30 draw calls and 400 / 1200 triangles.
+
+```ts
+import * as THREE from 'three'
+import { createGoodsItems } from '@adatechnology/game-items-goods'
+import { buildItem, buildItemLod, setWear } from '@adatechnology/game-items-three'
+
+const items = createGoodsItems()
+const can = buildItem(THREE, items.get('canned_beans'))   // model or shape, real size
+scene.add(can.root)
+setWear(can.root, 2)                                      // spoiled
+scene.add(buildItemLod(THREE, items.get('hammer')).root)  // merged, with LOD and cull
+```
+
+three.js is a peer dependency (`^0.160`). The global of the IIFE build is `GameItemsThree`.

package/dist/index.d.ts

@@ -0,0 +1,381 @@
+import * as THREE_NS from 'three';
+import { Thumbnail, Vec3, AreaPlacement, TestableModule } from '@adatechnology/game-contracts';
+import { FindStack, ItemsCatalog, FindsProvider } from '@adatechnology/game-items';
+
+type Three = typeof THREE_NS;
+/** The material tags the team's showcase wears: what `setWear` turns toward its spoiled colour. */
+declare const WEAR_TAGS: readonly ["metal", "wood", "cloth", "plastic", "paper", "food", "glass"];
+type WearTag = (typeof WEAR_TAGS)[number];
+/** What a material of the kit remembers so that `setWear` can go back to new: the colour it was made with (as three read it, and as sRGB floats), its tag and its roughness. */
+interface ItemMaterialData {
+    base: THREE_NS.Color;
+    baseRgb: readonly [number, number, number];
+    tag: string;
+    rough: number;
+}
+type Vec3Tuple = readonly [number, number, number];
+/**
+ * The helpers the showcase page defines before its models (`M`, `mesh`, `cyl`, `bx`, `lathe`, `torus`, `extrude`, `G` and the seven material makers), so that the
+ * builders ported from the page read the same as the originals. `T` is the three.js the kit was made with; `materials` lists every material it made, in order.
+ */
+interface ItemKit {
+    readonly T: Three;
+    readonly materials: THREE_NS.MeshStandardMaterial[];
+    M(color: number, tag: string, options?: THREE_NS.MeshStandardMaterialParameters): THREE_NS.MeshStandardMaterial;
+    mesh(geometry: THREE_NS.BufferGeometry, material: THREE_NS.Material, position?: Vec3Tuple, rotation?: Vec3Tuple, scale?: Vec3Tuple): THREE_NS.Mesh;
+    cyl(radiusTop: number, radiusBottom: number, height: number, segments?: number): THREE_NS.CylinderGeometry;
+    bx(width: number, height: number, depth: number): THREE_NS.BoxGeometry;
+    lathe(points: ReadonlyArray<readonly [number, number]>, segments?: number): THREE_NS.LatheGeometry;
+    torus(radius: number, tube: number, arc?: number): THREE_NS.TorusGeometry;
+    extrude(points: ReadonlyArray<readonly [number, number]>, depth: number, bevel?: number): THREE_NS.ExtrudeGeometry;
+    G(...children: THREE_NS.Object3D[]): THREE_NS.Group;
+    metal(color: number): THREE_NS.MeshStandardMaterial;
+    wood(color: number): THREE_NS.MeshStandardMaterial;
+    cloth(color: number): THREE_NS.MeshStandardMaterial;
+    plastic(color: number): THREE_NS.MeshStandardMaterial;
+    paper(color: number): THREE_NS.MeshStandardMaterial;
+    food(color: number): THREE_NS.MeshStandardMaterial;
+    glass(color: number, opacity: number): THREE_NS.MeshStandardMaterial;
+}
+/** The helpers of the showcase page on a given three.js; every kit has its own list of materials. */
+declare function createItemKit(T: Three): ItemKit;
+
+/** 0 new, 1 used, 2 spoiled (the three stages of the showcase). */
+type WearStage = 0 | 1 | 2;
+/** The colour each material tag turns toward as it wears (`STAGE_TARGET` of the showcase). */
+declare const WEAR_TARGET: Readonly<Record<string, number>>;
+/** How far toward the target colour each stage goes (`AMT`). */
+declare const WEAR_AMOUNT: readonly [number, number, number];
+/** Every material under `root` that the kit made (with a tag), once each. */
+declare function wearableMaterials(root: THREE_NS.Object3D): THREE_NS.MeshStandardMaterial[];
+/**
+ * Sets the wear of an item (`setStage` of the showcase): each material goes from its own colour toward the target of its tag by `WEAR_AMOUNT[stage]`, gets rougher, and
+ * metal loses its shine. The colours are mixed in sRGB, as the page mixes them (three r128 had no colour management), so stage 0 is exactly the colour the material was made with.
+ * Takes the object or the list of materials of a kit.
+ */
+declare function setWear(target: THREE_NS.Object3D | readonly THREE_NS.MeshStandardMaterial[], stage: WearStage): void;
+
+/** The simple shapes the kit draws at the real size of an item, by the `shape` hint of its definition. */
+declare const SHAPES: readonly ["can", "bag", "box", "bottle", "tool", "roll", "dish", "cloth", "shoe", "jar", "paper", "fruit", "cup", "tube", "blade", "long_tool", "garment", "backpack", "jerrycan", "tank", "book", "key", "battery", "plank", "device"];
+type ShapeId = (typeof SHAPES)[number];
+/** What a shape drawer is given: the kit, the size in metres, the colour of the item and the level of detail (1 full, 0.5 half the segments). */
+interface ShapeContext {
+    k: ItemKit;
+    w: number;
+    h: number;
+    d: number;
+    color: number;
+    detail: number;
+}
+/** The colour `factor` times lighter (above 1) or darker (below 1), per channel. */
+declare function shade(color: number, factor: number): number;
+/** The long axis of a size and the three sides in the frame where that axis is x: `L` long, `a` the next, `b` the shortest of the other two in their own order. */
+declare function canonicalFrame(size: Vec3Tuple): {
+    axis: 0 | 1 | 2;
+    L: number;
+    a: number;
+    b: number;
+};
+declare const isShape: (value: string | undefined) => value is ShapeId;
+/** The item fields the shape choice reads. */
+interface ShapeSubject {
+    category: string;
+    size: Vec3Tuple;
+    shape?: string;
+    color?: number;
+}
+/**
+ * The shape an item is drawn with: its own `shape` when it names one of the 25, else a box. The hints the household catalog uses (`tool`, `cloth`, `bag`, `box`, `paper`) are
+ * refined by the category and the proportions, so that a rake is a long tool, a jacket a garment, a rucksack a backpack, a phone a device and a diary a book.
+ */
+declare function shapeOf(subject: ShapeSubject): ShapeId;
+/** Draws the simple shape of an item at its real size, centred on the origin (the long side of long shapes lies on the long axis of `size`). */
+declare function drawShape(k: ItemKit, shape: ShapeId, size: Vec3Tuple, options?: {
+    color?: number;
+    detail?: number;
+}): THREE_NS.Group;
+
+/** The fields of an item the drawing reads (an `ItemDef` of `game-items` has them all). */
+interface DrawableItem extends ShapeSubject {
+    id: string;
+    size: Vec3Tuple;
+    /** Key of a showcase model; without one (or when the model is not registered) the simple shape is drawn. */
+    model?: string;
+}
+interface BuildItemOptions {
+    /** Wear of the materials, 0 new (default), 1 used, 2 spoiled. */
+    wear?: WearStage;
+    /** Draw the simple shape even when the item has a model (the second level of detail). */
+    simple?: boolean;
+    /** Level of detail of the simple shape, 1 (default) or 0.5 for half the segments. */
+    detail?: number;
+    /** A kit to draw with (and to collect the materials in); default a new one. */
+    kit?: ItemKit;
+}
+/** What `buildItem` returns. */
+interface ItemModel {
+    /** The object to add to a scene: origin at the bottom centre of the item, y up, in metres. */
+    readonly root: THREE_NS.Group;
+    /** `model` when the showcase builder drew it, `shape` otherwise. */
+    readonly kind: 'model' | 'shape';
+    readonly shape?: ShapeId;
+    /** Size in metres the drawing was fitted to (the item's `size`). */
+    readonly size: Vec3Tuple;
+    /** The materials made for this item. */
+    readonly materials: readonly THREE_NS.MeshStandardMaterial[];
+}
+/**
+ * Draws an item at its real size. An item whose `model` is registered gets the showcase builder, ported as it is (page units, scaled to metres by the scale of
+ * `models.json` on the root, so that the group inside is still the team's); every other item gets the simple shape of its `shape` hint (refined by category and
+ * proportions) at its `size`. Either way the origin is the bottom centre and y is up.
+ */
+declare function buildItem(T: typeof THREE_NS, item: DrawableItem, options?: BuildItemOptions): ItemModel;
+
+/**
+ * The same item with its meshes joined by material: one mesh and one draw call per material instead of one per part (the "one material for all the items" of the page's
+ * budget, as far as the materials of the kit allow). The materials are the same objects, so `setWear` still reaches them. The model's scale stays on the root.
+ */
+declare function mergeItem(T: typeof THREE_NS, model: ItemModel): ItemModel;
+
+type Vec3Like = readonly [number, number, number];
+/** The draw budgets of the Itens do Vale Cinzento page (section "Desempenho com hordas"). */
+interface ItemBudgets {
+    /** Draw calls of all the items in a frame. */
+    drawCalls: number;
+    /** A small item: at most this many triangles, and it disappears at `cullDistance`. */
+    small: {
+        triangles: number;
+        cullDistance: number;
+    };
+    /** A large item. */
+    large: {
+        triangles: number;
+        cullDistance: number;
+    };
+    /** The second level of detail has this share of the triangles of the first. */
+    lod1Ratio: number;
+    /** Longest side (m) from which an item counts as large: the page does not say where small ends, so this is the kit's reading and a game can change it. */
+    largeFrom: number;
+}
+declare const ITEM_BUDGETS: ItemBudgets;
+type ItemSizeClass = 'small' | 'large';
+declare const sizeClassOf: (size: Vec3Like, budgets?: ItemBudgets) => ItemSizeClass;
+declare const triangleBudgetOf: (size: Vec3Like, budgets?: ItemBudgets) => number;
+declare const cullDistanceOf: (size: Vec3Like, budgets?: ItemBudgets) => number;
+/** Triangles under `root`: visible meshes only, indexed or not. */
+declare function countTriangles(root: THREE_NS.Object3D): number;
+/** Draw calls under `root`: one per visible mesh (a mesh with a material list counts once per group). */
+declare function countDrawCalls(root: THREE_NS.Object3D): number;
+interface BudgetReport {
+    triangles: number;
+    limit: number;
+    drawCalls: number;
+    sizeClass: ItemSizeClass;
+    ok: boolean;
+}
+/** How an item's model measures against its triangle budget (a model of the team above it is a known deviation, not an error). */
+declare function checkBudget(root: THREE_NS.Object3D, size: Vec3Like, budgets?: ItemBudgets): BudgetReport;
+
+interface ItemLodOptions extends Omit<BuildItemOptions, 'simple' | 'detail' | 'kit'> {
+    budgets?: ItemBudgets;
+    /** Join the meshes of each level by material (default true). */
+    merge?: boolean;
+    /** Distance of the second level in metres; default a third of the distance at which the item disappears. */
+    lod1Distance?: number;
+}
+interface ItemLod {
+    /** Add this to the scene and call `update(camera)` (or let the renderer do it). */
+    readonly root: THREE_NS.LOD;
+    /** Full detail: the showcase model, or the shape at full segments. */
+    readonly near: ItemModel;
+    /** The simple shape at half the segments. */
+    readonly far: ItemModel;
+    /** Metres from the camera at which the item is no longer drawn. */
+    readonly cullDistance: number;
+    readonly lod1Distance: number;
+}
+/**
+ * Three levels of an item: the model (or the shape) up close, the simple shape at half the segments from `lod1Distance`, and nothing from the distance of its class
+ * (a small item goes at 30 m, a large one at 60 m).
+ */
+declare function buildItemLod(T: typeof THREE_NS, item: DrawableItem, options?: ItemLodOptions): ItemLod;
+
+/** One model of the showcase as `data/models.json` keeps it: the item it draws, the id the team gave it, the box it has in the units of the page and the scale to metres. */
+interface ItemModelEntry {
+    /** Catalog id of the item (`canned_beans`). */
+    readonly id: string;
+    /** The id in the team's `MODELS` (`feijao_lata`). */
+    readonly teamId: string;
+    /** Box of the builder's group in the page's units (`Box3.setFromObject`), x y z. */
+    readonly teamBox: readonly [number, number, number];
+    /** Metres per unit of the page, from one real measure of the object. */
+    readonly scale: number;
+}
+/** A builder of the showcase, ported as it is: it draws in the page's units and returns the group. */
+type ItemModelBuilder = (kit: ItemKit) => THREE_NS.Group;
+/** Adds (or replaces) the model of an item: `entry.id` is the catalog id the item's `model` field names. */
+declare function registerItemModel(entry: ItemModelEntry, builder: ItemModelBuilder): void;
+/** Takes a model out (a game that wants the simple shape instead). */
+declare function unregisterItemModel(id: string): void;
+declare const itemModelEntry: (id: string) => ItemModelEntry | undefined;
+declare const itemModelBuilder: (id: string) => ItemModelBuilder | undefined;
+declare const hasItemModel: (id: string) => boolean;
+/** The ids of the models registered, in the order of registration (the order of the showcase for the ones the kit ships). */
+declare const listItemModels: () => string[];
+
+/** The 24 models of the showcase in the page's order: the entry of `data/models.json` (generated by `tools/items-catalog`) and the builder ported from the page. */
+declare const SHIPPED_MODELS: ReadonlyArray<{
+    readonly entry: ItemModelEntry;
+    readonly builder: ItemModelBuilder;
+}>;
+
+/**
+ * Models of the showcase that go over the triangle budget of their class (400 for a small item, 1200 for a large one) as the team drew them, with the count they have.
+ * The page set the budget for the game and drew the models for a showcase; the models stay as delivered (the builder is the team's) and a scene at a distance wears the
+ * simple shape of the second level of detail (`buildItemLod`), which is inside the budget. A model that changes its count is a drawing that changed: the test flags it.
+ */
+declare const MODEL_BUDGET_DEVIATIONS: Readonly<Record<string, number>>;
+
+/** The SVG picture of a shape in the colour of an item: a 64 x 64 board with plain shapes, no script and no reference. */
+declare function shapeThumbnailSvg(shape: ShapeId, color?: number): string;
+/**
+ * The picture of an item for catalogues and inventories: an item that has a 3D model asks the host to draw it (`render: true`), every other gets the SVG of its shape in
+ * its colour.
+ */
+declare function itemThumbnail(item: DrawableItem): Thumbnail;
+/** The SVG of an item whatever it has: its shape in its colour (what a host with no renderer shows for a modeled item). */
+declare const itemThumbnailSvg: (item: DrawableItem) => string;
+/** `{ id: { thumbnail } }` for `createItems({ patch })`, so that a catalog carries its pictures. */
+declare function thumbnailPatch(items: Iterable<DrawableItem>): Record<string, {
+    thumbnail: Thumbnail;
+}>;
+interface ThumbnailRenderOptions {
+    /** Side of the picture in pixels (default 128). */
+    size?: number;
+    /** Turn of the item around y and the lift of the camera, radians (default a three-quarter view from above). */
+    yaw?: number;
+    pitch?: number;
+    /** Multiplies the distance that just fits the item (default 1). */
+    distance?: number;
+    wear?: WearStage;
+}
+interface ThumbnailScene {
+    scene: THREE_NS.Scene;
+    camera: THREE_NS.PerspectiveCamera;
+}
+/** The scene and camera that frame an item for its picture: the item at the origin, lit like the showcase (hemisphere, sun, rim), the camera far enough to fit all of it. */
+declare function composeThumbnailScene(T: typeof THREE_NS, item: DrawableItem, options?: ThumbnailRenderOptions): ThumbnailScene;
+/** What `renderItemThumbnail` needs of a renderer (a `WebGLRenderer`, or anything that draws a scene to a canvas). */
+interface ThumbnailRenderer {
+    setSize(width: number, height: number): void;
+    setClearColor?(color: number, alpha?: number): void;
+    render(scene: THREE_NS.Scene, camera: THREE_NS.Camera): void;
+    domElement: {
+        toDataURL(type?: string): string;
+    };
+}
+/** Draws the item with the host's renderer and returns the PNG as a data URL (transparent background). */
+declare function renderItemThumbnail(T: typeof THREE_NS, renderer: ThumbnailRenderer, item: DrawableItem, options?: ThumbnailRenderOptions): string;
+
+/** What the layout needs of an item: its id, category and real size [width, height, depth] in metres. */
+interface LayoutItem {
+    readonly id: string;
+    readonly category: string;
+    readonly size: readonly [number, number, number];
+}
+/** Height of the top of a shelf, metres. */
+declare const SHELF_HEIGHT = 0.9;
+/** Longest row of items on a shelf, metres. */
+declare const ROW_LIMIT = 5;
+/** One shelf: a category's items laid out in rows at real size, the shelf's footprint and where its items sit on its top. */
+interface ShelfPlan {
+    category: string;
+    /** Item id of the shelf in the module (`shelf_<category>`). */
+    id: string;
+    /** Footprint on the floor: length along x, depth along z. */
+    length: number;
+    depth: number;
+    position: Vec3;
+    /** Where each item sits, in world coordinates. */
+    items: AreaPlacement[];
+}
+declare const SHELF_PREFIX = "shelf_";
+declare const ITEM_PREFIX = "item_";
+declare const SHOWCASE_PREFIX = "showcase_";
+/**
+ * The shelves of the area: one per category, in the order the categories come, with every item of the category side by side at real size, wrapped in rows of at most
+ * `ROW_LIMIT` metres. Shelves stand in a grid of four columns; an item that is longer than the row limit gets a row to itself. Pure: the same items always land in the same spots.
+ */
+declare function shelvesLayout(items: readonly LayoutItem[], categories: readonly string[]): ShelfPlan[];
+
+interface ItemsTestModuleOptions {
+    /** The catalog to lay out (for example `createGoodsItems()` of `game-items-goods`). The module knows no content of its own. */
+    catalog: ItemsCatalog;
+    /** `en` or `pt-BR` (default). */
+    locale?: string;
+    /** Text of a key such as `item.canned_beans`, `place.house`, `category.food`, `container.fridge`, `recipe.stew` (the goods package has them in `goodsText`); without it the module falls back to the id. */
+    translate?: (key: string, locale: string) => string | undefined;
+    /** Seed of the finds roll (default 1). */
+    seed?: number;
+    /** Wear the items start with: `new` (default), `used` or `spoiled`. */
+    wear?: string;
+    /** The finds provider; default the one of `game-items` over `catalog`. A game gives its own (floorplan bindings, pools). */
+    provider?: FindsProvider;
+}
+declare const SHOWCASE_STAND_ID = "stand_models";
+declare const RULER_ID = "ruler_155";
+declare const HUMAN_ID = "human_180";
+declare const FINDS_TABLE_ID = "finds_table";
+declare const RULER_HEIGHT = 1.55;
+declare const HUMAN_HEIGHT = 1.8;
+/** What the scenarios of the area ask of the module (and what a host or a test may read). */
+interface ItemsAreaState {
+    readonly category: string;
+    readonly wear: string;
+    readonly ageDays: number;
+    readonly storage: string;
+    readonly powered: boolean;
+    readonly place: string;
+    readonly container: string;
+    readonly state: string;
+    readonly day: number;
+    readonly seed: number;
+    readonly recipe: string;
+}
+interface ItemsTestModule extends TestableModule {
+    /** Everything the module has put in the scene so far, with what was measured when it was drawn. */
+    placed(): ReadonlyArray<{
+        id: string;
+        itemId: string;
+        group: 'shelf' | 'showcase';
+        kind: 'model' | 'shape';
+        size: readonly [number, number, number];
+        root: THREE_NS.Object3D;
+    }>;
+    /** The stacks now on the finds table. */
+    finds(): readonly FindStack[];
+    /** The shelves of the layout. */
+    shelves(): readonly ShelfPlan[];
+    readonly state: ItemsAreaState;
+    /** The bench actions, callable without a host (what the buttons do). */
+    rollFinds(): readonly FindStack[];
+    craftSelected(): {
+        ok: boolean;
+        missing: readonly string[];
+    };
+    selectRecipe(id: string): void;
+    /** The box of a drawn object, metres [x, y, z] (needs the host's three.js namespace: null before the module is attached or an item built). */
+    measure(root: THREE_NS.Object3D): [number, number, number] | null;
+}
+/**
+ * The items test area as a `TestableModule` of @adatechnology/game-contracts: every item of a catalog on shelves by category at real size (the real model of the team where there is
+ * one, the simple shape of its category elsewhere), a stand where the 24 models turn, a ruler and a human figure to judge the scale, and a table where the finds of a container
+ * and the result of a recipe are laid. The bench sets wear, age and storage, the place, container, state, outbreak day and seed of the finds, and the recipe.
+ */
+declare function createItemsTestModule(options: ItemsTestModuleOptions): ItemsTestModule;
+/** What the scenarios use of the context the test room passes (`ScenarioContext`). */
+interface ScenarioLike {
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+
+export { type BudgetReport, type BuildItemOptions, type DrawableItem, FINDS_TABLE_ID, HUMAN_HEIGHT, HUMAN_ID, ITEM_BUDGETS, ITEM_PREFIX, type ItemBudgets, type ItemKit, type ItemLod, type ItemLodOptions, type ItemMaterialData, type ItemModel, type ItemModelBuilder, type ItemModelEntry, type ItemSizeClass, type ItemsAreaState, type ItemsTestModule, type ItemsTestModuleOptions, type LayoutItem, MODEL_BUDGET_DEVIATIONS, ROW_LIMIT, RULER_HEIGHT, RULER_ID, SHAPES, SHELF_HEIGHT, SHELF_PREFIX, SHIPPED_MODELS, SHOWCASE_PREFIX, SHOWCASE_STAND_ID, type ScenarioLike, type ShapeContext, type ShapeId, type ShapeSubject, type ShelfPlan, type ThumbnailRenderOptions, type ThumbnailRenderer, type ThumbnailScene, type Vec3Like, type Vec3Tuple, WEAR_AMOUNT, WEAR_TAGS, WEAR_TARGET, type WearStage, type WearTag, buildItem, buildItemLod, canonicalFrame, checkBudget, composeThumbnailScene, countDrawCalls, countTriangles, createItemKit, createItemsTestModule, cullDistanceOf, drawShape, hasItemModel, isShape, itemModelBuilder, itemModelEntry, itemThumbnail, itemThumbnailSvg, listItemModels, mergeItem, registerItemModel, renderItemThumbnail, setWear, shade, shapeOf, shapeThumbnailSvg, shelvesLayout, sizeClassOf, thumbnailPatch, triangleBudgetOf, unregisterItemModel, wearableMaterials };