@adatechnology/game-shapes 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as ShapeSchema, G as GenerateOptions, a as ShapeBuffers, b as ShapeNode, P as PrimitiveNode, c as PrimitiveBuffers, d as ShapeOutline, B as BevelSpec, V as Vec3, H as HoleSpec, e as ShapeGenerator, C as Color, T as Transform, R as RotationOrder } from './worker-W5A14FiP.js';
-export { f as Bounds, g as BoxNode, h as CircleNode, i as ConeNode, j as CustomNode, k as CylinderNode, D as DifferenceNode, E as ExtrudeNode, l as GeneratorContext, m as GeometryGroup, n as GroupNode, I as InstanceSpec, o as InstancedBatch, L as LatheNode, p as LodLevel, M as Mat4, q as MaterialHint, r as MeshNode, N as NamedRange, s as NodeCommon, t as PlaneNode, u as PointNode, v as RingNode, w as ShapeBatch, x as ShapeJob, y as ShapeKind, z as ShapeLevel, A as ShapePart, F as ShapePoint, J as ShapeReply, K as ShapeStats, O as ShapeWorkerOptions, Q as SphereNode, U as TorusNode, W as UvRect, X as Vec2, Y as WorkerScopeLike, Z as installShapeWorker } from './worker-W5A14FiP.js';
+import { S as ShapeSchema, G as GenerateOptions, a as ShapeBuffers, b as ShapeNode, P as PrimitiveNode, c as PrimitiveBuffers, d as ShapeOutline, B as BevelSpec, V as Vec3, H as HoleSpec, e as ShapeGenerator, C as Color, T as Transform, R as RotationOrder } from './worker-DUZKXhCw.js';
+export { f as Bounds, g as BoxNode, h as CircleNode, i as ConeNode, j as CustomNode, k as CylinderNode, D as DifferenceNode, E as ExtrudeNode, l as GeneratorContext, m as GeometryGroup, n as GroupNode, I as InstanceSpec, o as InstancedBatch, L as LatheNode, p as LodLevel, M as Mat4, q as MaterialHint, r as MeshNode, N as NamedRange, s as NodeCommon, t as PlaneNode, u as PointNode, v as RingNode, w as ShapeBatch, x as ShapeJob, y as ShapeKind, z as ShapeLevel, A as ShapePart, F as ShapePoint, J as ShapeReply, K as ShapeStats, O as ShapeWorkerOptions, Q as SphereNode, U as TorusNode, W as UvRect, X as Vec2, Y as WorkerScopeLike, Z as installShapeWorker } from './worker-DUZKXhCw.js';
 
 declare const isPrimitiveNode: (node: ShapeNode) => node is PrimitiveNode;
 /** The options that change the output, as they enter the cache key. */
@@ -93,15 +93,45 @@ declare function validateShape(schema: unknown): string[];
 /** Throws with every problem when the schema is not valid. */
 declare function assertValidShape(schema: unknown): asserts schema is ShapeSchema;
 
-/**
- * Registers a generator for `{ kind: 'custom', generator: name, params }` nodes: a pure function of its params and a seeded stream that returns a
- * node. A worker that generates shapes with custom nodes must register the same generators (import the same module in the worker script).
- */
-declare function registerGenerator(name: string, generator: ShapeGenerator): void;
+/** The generators of one set: what `{ kind: 'custom', generator: name, params }` nodes look up. */
+interface ShapeGenerators {
+    /**
+     * Registers a generator: a pure function of its params and a seeded stream that returns a node. A worker that generates shapes with custom nodes must
+     * register the same generators (import the same module in the worker script).
+     */
+    register(name: string, generator: ShapeGenerator): void;
+    unregister(name: string): boolean;
+    get(name: string): ShapeGenerator | undefined;
+    list(): string[];
+    /** The generators by name, as `GenerateOptions.generators` takes them. */
+    record(): Readonly<Record<string, ShapeGenerator>>;
+}
+/** The set behind `registerGenerator`, `getGenerator` and the rest of the global functions, created on first use. */
+declare const defaultShapeGenerators: () => ShapeGenerators;
+/** @deprecated use `createShapes(...).register`. */
+declare const registerGenerator: (name: string, generator: ShapeGenerator) => void;
+/** @deprecated use `createShapes(...).unregister`. */
 declare const unregisterGenerator: (name: string) => boolean;
+/** @deprecated use `createShapes(...).get`. */
 declare const getGenerator: (name: string) => ShapeGenerator | undefined;
+/** @deprecated use `createShapes(...).list`. */
 declare const listGenerators: () => string[];
 
+interface ShapesOptions {
+    /** Generators by name, added to the set; later packs replace earlier ones with the same name. */
+    readonly packs?: readonly Readonly<Record<string, ShapeGenerator>>[];
+    /** A generator replaced by name (a function is replaced as a whole). */
+    readonly patch?: Readonly<Record<string, ShapeGenerator>>;
+    /** Names taken out. */
+    readonly remove?: readonly string[];
+}
+interface Shapes extends ShapeGenerators {
+    /** `generate` that looks custom nodes up in this set only (a name only the global registry has throws). */
+    generate(schema: ShapeSchema, options?: Omit<GenerateOptions, 'isolatedGenerators'>): ShapeBuffers;
+}
+/** A set of shape generators of its own. Nothing is shared with any other set or with the global registry. */
+declare function createShapes(options?: ShapesOptions): Shapes;
+
 /**
  * Canonical JSON (keys sorted, `undefined` left out, `-0` kept as `-0`, typed arrays as plain lists) and a 64-bit FNV-1a of it in two 32-bit
  * lanes: the key a shape is cached and shared by.
@@ -190,6 +220,8 @@ interface ShapePoolOptions {
     readonly cache?: ShapeCache;
     /** Generators of the `custom` nodes for the jobs made in the calling thread (the workers register their own). */
     readonly generators?: Readonly<Record<string, ShapeGenerator>>;
+    /** Look custom nodes up in `generators` only (for example `shapes.record()` of `createShapes`), never in the global registry; the jobs then run in the calling thread, since a worker cannot receive functions. */
+    readonly isolatedGenerators?: boolean;
 }
 interface ShapeRequest {
     readonly schema: ShapeSchema;
@@ -218,4 +250,4 @@ interface ShapePool {
  */
 declare function createShapePool(options?: ShapePoolOptions): ShapePool;
 
-export { BevelSpec, Color, type DetailOptions, GenerateOptions, HoleSpec, type Matrix3, type Matrix4, type MergedArrays, PrimitiveBuffers, PrimitiveNode, RotationOrder, SHAPE_SCHEMA, ShapeBuffers, type ShapeCache, type ShapeCacheOptions, type ShapeCacheStats, ShapeGenerator, ShapeNode, ShapeOutline, type ShapePool, type ShapePoolOptions, type ShapePoolStats, type ShapeRequest, ShapeSchema, Transform, type TransformedPiece, Vec3, type WorkerLike, assertValidShape, box, buildPrimitive, byteSizeOf, canonicalJson, circle, clearTemplateCache, cloneBuffers, clonePrimitive, colorChannels, colorHex, compose, computeVertexNormals, cone, createShapeCache, createShapePool, cylinder, difference, extrude, generate, getGenerator, hash64, hashValue, headingMatrix, identity4, isAffine, isPrimitiveNode, keyOptions, lathe, listGenerators, matrixOf, mergeTransformed, mulberry32, multiply, normalMatrix, plane, primitiveParameters, quaternionFromEuler, registerGenerator, ring, setTemplateCacheSize, shapeKey, sphere, srgbToLinear, streamFor, templateCacheStats, torus, transferablesOf, transformPoint, unregisterGenerator, validateShape };
+export { BevelSpec, Color, type DetailOptions, GenerateOptions, HoleSpec, type Matrix3, type Matrix4, type MergedArrays, PrimitiveBuffers, PrimitiveNode, RotationOrder, SHAPE_SCHEMA, ShapeBuffers, type ShapeCache, type ShapeCacheOptions, type ShapeCacheStats, ShapeGenerator, type ShapeGenerators, ShapeNode, ShapeOutline, type ShapePool, type ShapePoolOptions, type ShapePoolStats, type ShapeRequest, ShapeSchema, type Shapes, type ShapesOptions, Transform, type TransformedPiece, Vec3, type WorkerLike, assertValidShape, box, buildPrimitive, byteSizeOf, canonicalJson, circle, clearTemplateCache, cloneBuffers, clonePrimitive, colorChannels, colorHex, compose, computeVertexNormals, cone, createShapeCache, createShapePool, createShapes, cylinder, defaultShapeGenerators, difference, extrude, generate, getGenerator, hash64, hashValue, headingMatrix, identity4, isAffine, isPrimitiveNode, keyOptions, lathe, listGenerators, matrixOf, mergeTransformed, mulberry32, multiply, normalMatrix, plane, primitiveParameters, quaternionFromEuler, registerGenerator, ring, setTemplateCacheSize, shapeKey, sphere, srgbToLinear, streamFor, templateCacheStats, torus, transferablesOf, transformPoint, unregisterGenerator, validateShape };

package/dist/index.global.js

@@ -40,7 +40,9 @@ var GameShapes = (() => {
     cone: () => cone,
     createShapeCache: () => createShapeCache,
     createShapePool: () => createShapePool,
+    createShapes: () => createShapes,
     cylinder: () => cylinder,
+    defaultShapeGenerators: () => defaultShapeGenerators,
     difference: () => difference,
     extrude: () => extrude,
     generate: () => generate,
@@ -1507,8 +1509,8 @@ var GameShapes = (() => {
       groups: []
     };
   }
-  function make(kind, p) {
-    switch (kind) {
+  function make(p) {
+    switch (p.kind) {
       case "box": {
         const size = p.size ?? [1, 1, 1];
         const segments = p.segments ?? [1, 1, 1];
@@ -1537,7 +1539,7 @@ var GameShapes = (() => {
       case "mesh":
         return mesh(p);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -1555,7 +1557,7 @@ var GameShapes = (() => {
   var templateCacheStats = () => ({ size: templates.size, ...stats });
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -1565,7 +1567,7 @@ var GameShapes = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
+    const built = make({ ...node, ...parameters });
     templates.set(key, built);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
     return built;
@@ -1596,14 +1598,23 @@ var GameShapes = (() => {
   var streamFor = (seed, generator, path) => mulberry32(parseInt(hash64(`${String(seed)}\0${generator}\0${path}`).slice(0, 8), 16));
 
   // src/registry.ts
-  var generators = /* @__PURE__ */ new Map();
-  function registerGenerator(name, generator) {
-    if (!/^[a-zA-Z][\w.:-]*$/.test(name)) throw new Error(`game-shapes: generator name "${name}" must start with a letter and use letters, digits, ".", ":", "-" or "_"`);
-    generators.set(name, generator);
-  }
-  var unregisterGenerator = (name) => generators.delete(name);
-  var getGenerator = (name) => generators.get(name);
-  var listGenerators = () => [...generators.keys()].sort();
+  var GENERATOR_NAME = /^[a-zA-Z][\w.:-]*$/;
+  var generatorsOver = (generators) => ({
+    register(name, generator) {
+      if (!GENERATOR_NAME.test(name)) throw new Error(`game-shapes: generator name "${name}" must start with a letter and use letters, digits, ".", ":", "-" or "_"`);
+      generators.set(name, generator);
+    },
+    unregister: (name) => generators.delete(name),
+    get: (name) => generators.get(name),
+    list: () => [...generators.keys()].sort(),
+    record: () => Object.fromEntries(generators)
+  });
+  var defaultGenerators;
+  var defaultShapeGenerators = () => defaultGenerators ?? (defaultGenerators = generatorsOver(/* @__PURE__ */ new Map()));
+  var registerGenerator = (name, generator) => defaultShapeGenerators().register(name, generator);
+  var unregisterGenerator = (name) => defaultShapeGenerators().unregister(name);
+  var getGenerator = (name) => defaultShapeGenerators().get(name);
+  var listGenerators = () => defaultShapeGenerators().list();
 
   // schema/shape.schema.json
   var shape_schema_default = {
@@ -2649,7 +2660,7 @@ var GameShapes = (() => {
     return r * Math.max(sx, sy, sz);
   };
   function expandCustom(node, settings, detail, path) {
-    const generator = settings.generators?.[node.generator] ?? getGenerator(node.generator);
+    const generator = settings.generators?.[node.generator] ?? (settings.isolatedGenerators ? void 0 : getGenerator(node.generator));
     if (!generator) throw new Error(`game-shapes: no generator "${node.generator}" (register it with registerGenerator, in the worker too) at ${path}`);
     const generated = generator(node.params, { random: streamFor(settings.seed, node.generator, path), seed: settings.seed, detail, path });
     const { kind: _kind, generator: _generator, params: _params, ...common } = node;
@@ -2857,6 +2868,7 @@ var GameShapes = (() => {
       ...options.materialAlias ? { alias: options.materialAlias } : {},
       seed: options.seed ?? 0,
       ...options.generators ? { generators: options.generators } : {},
+      ...options.isolatedGenerators ? { isolatedGenerators: true } : {},
       ...options.instancing ? { autoMin: Math.max(2, options.instancing.minCount) } : {}
     };
     const specs = [{ distance: 0, detail: 1, index: 0 }, ...(schema.lod ?? []).map((rule, index) => ({ ...rule, index: index + 1 }))];
@@ -2976,6 +2988,118 @@ var GameShapes = (() => {
     return transferablesOf(buffers).reduce((sum, buffer) => sum + buffer.byteLength, 0);
   }
 
+  // ../game-contracts/dist/index.js
+  var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
+  var DEFERRED_QUEUE_ID = {
+    DESTRUCTION_EVENTS: "destruction.events",
+    BREACH_PAINT: "floorplan.breach-paint",
+    AUDIO_VOICES: "audio.voices",
+    VEHICLE_CREASE: "vehicles.crease"
+  };
+  var DEFERRED_PRIORITY = {
+    [DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS]: { priority: 300, phase: "present" },
+    [DEFERRED_QUEUE_ID.BREACH_PAINT]: { priority: 250, phase: "present" },
+    [DEFERRED_QUEUE_ID.AUDIO_VOICES]: { priority: 200, phase: "idle", reserveMs: 1 },
+    [DEFERRED_QUEUE_ID.VEHICLE_CREASE]: { priority: 100, phase: "idle" }
+  };
+  var WARNED_KEY = /* @__PURE__ */ Symbol.for("@adatechnology/game-contracts.warned");
+  var warnedKeys = () => {
+    const holder = globalThis;
+    return holder[WARNED_KEY] ?? (holder[WARNED_KEY] = /* @__PURE__ */ new Set());
+  };
+  var isProduction = () => {
+    try {
+      return process.env.NODE_ENV === "production";
+    } catch {
+      return false;
+    }
+  };
+  var isQuiet = () => globalThis.__GAME_KIT_QUIET__ === true;
+  var warnOnce = (key, message) => {
+    if (isQuiet() || isProduction()) return;
+    const seen = warnedKeys();
+    if (seen.has(key)) return;
+    seen.add(key);
+    console.warn(`[game-kit] ${message}`);
+  };
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+      else warnOnce(`registry.patch.${id}`, `patch for "${id}" ignored: no entry has that id`);
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) {
+      if (!entries.delete(id)) warnOnce(`registry.remove.${id}`, `remove of "${id}" ignored: no entry has that id`);
+    }
+  };
+  var SURFACE_IDS = ["concrete", "asphalt", "wood", "tile", "dirt", "grass", "gravel", "sand", "metal", "water", "glass", "carpet"];
+  var GAIT_IDS = ["walk", "run"];
+  var LANDING_IDS = ["light", "heavy"];
+  var BODY_SOUND_IDS = [
+    "jump",
+    "cloth_rustle",
+    "body_fall",
+    "fall_damage",
+    "player_hurt",
+    "player_breath_run",
+    "player_death",
+    "bite",
+    "grab",
+    "punch_swing",
+    "punch_hit_body",
+    "punch_hit_face",
+    "punch_hit_object",
+    "kick_swing",
+    "kick_hit",
+    "kick_hit_object",
+    "shove_two_hands",
+    "knife_swing",
+    "knife_stab",
+    "knife_slash",
+    "knife_hit_object",
+    "blunt_swing",
+    "blunt_hit",
+    "blunt_hit_object",
+    "axe_swing",
+    "axe_chop",
+    "axe_hit_object"
+  ];
+  var footstepSoundId = (surface, gait) => `footstep_${surface}_${gait}`;
+  var FOOTSTEP_SOUND_IDS = SURFACE_IDS.flatMap((surface) => GAIT_IDS.map((gait) => footstepSoundId(surface, gait)));
+  var LAND_SOUND_IDS = SURFACE_IDS.flatMap((surface) => LANDING_IDS.map((landing) => `land_${surface}_${landing}`));
+  var BODY_FOLEY_IDS = [...FOOTSTEP_SOUND_IDS, ...LAND_SOUND_IDS, ...BODY_SOUND_IDS];
+
+  // src/instance.ts
+  function createShapes(options = {}) {
+    const entryOf = ([id, generator]) => ({ id, generator });
+    const entries = mergeById([], (options.packs ?? []).flatMap((pack2) => Object.entries(pack2).map(entryOf)));
+    const patches = {};
+    for (const [id, generator] of Object.entries(options.patch ?? {})) patches[id] = { generator };
+    applyPatches(entries, patches);
+    removeIds(entries, options.remove);
+    const generators = generatorsOver(new Map([...entries].map(([id, entry]) => [id, entry.generator])));
+    return { ...generators, generate: (schema, generateOptions = {}) => generate(schema, { ...generateOptions, generators: { ...generators.record(), ...generateOptions.generators }, isolatedGenerators: true }) };
+  }
+
   // src/cache.ts
   function createShapeCache(options = {}) {
     const maxEntries = options.maxEntries ?? 256;
@@ -3063,11 +3187,11 @@ var GameShapes = (() => {
     };
     for (let i = 0; i < size; i++) slots.push(spawnSlot());
     const run = (schema, generateOptions) => {
-      if (slots.length === 0 || generateOptions.generators) {
+      if (slots.length === 0 || generateOptions.generators || options.isolatedGenerators) {
         inThread++;
         try {
-          const generators2 = { ...options.generators ?? {}, ...generateOptions.generators ?? {} };
-          return Promise.resolve(generate(schema, { ...generateOptions, ...Object.keys(generators2).length ? { generators: generators2 } : {} }));
+          const generators = { ...options.generators ?? {}, ...generateOptions.generators ?? {} };
+          return Promise.resolve(generate(schema, { ...generateOptions, ...Object.keys(generators).length ? { generators } : {}, ...options.isolatedGenerators ? { isolatedGenerators: true } : {} }));
         } catch (error) {
           return Promise.reject(error);
         }