@genex-ai/multiplayer 0.17.6 → 0.17.9

package/dist/world-fit/three.d.ts

@@ -0,0 +1,77 @@
+import { a as LevelHull, L as LevelScene } from '../level-build-CbRqrYJq.js';
+export { b as LEVEL_LIMITS, e as LevelRefusal, f as LevelRefusalCode, R as RawWorldScene } from '../level-build-CbRqrYJq.js';
+
+/** What this reads of `THREE.BufferAttribute`. */
+interface ThreeAttribute {
+    readonly count: number;
+    getX(i: number): number;
+    getY(i: number): number;
+    getZ(i: number): number;
+}
+/** What this reads of `THREE.BufferGeometry`. */
+interface ThreeGeometry {
+    readonly attributes: {
+        readonly position?: ThreeAttribute;
+    };
+    readonly index: {
+        readonly count: number;
+        getX(i: number): number;
+    } | null;
+    readonly drawRange?: {
+        readonly start: number;
+        readonly count: number;
+    };
+}
+/** What this reads of `THREE.Object3D`. Real three.js objects fit; nothing else is touched. */
+interface ThreeObject {
+    readonly name: string;
+    readonly userData: Record<string, unknown>;
+    readonly children: readonly ThreeObject[];
+    readonly matrixWorld: {
+        readonly elements: ArrayLike<number>;
+    };
+    updateWorldMatrix?(updateParents: boolean, updateChildren: boolean): void;
+    readonly isMesh?: boolean;
+    readonly isSkinnedMesh?: boolean;
+    readonly isInstancedMesh?: boolean;
+    readonly isBatchedMesh?: boolean;
+    readonly isLOD?: boolean;
+    readonly levels?: readonly {
+        readonly object: ThreeObject;
+    }[];
+    readonly geometry?: ThreeGeometry;
+    readonly morphTargetInfluences?: readonly number[];
+    readonly count?: number;
+    readonly instanceMatrix?: {
+        readonly array: ArrayLike<number>;
+    };
+}
+/** What a `GLTFLoader` hands back, enough of it: animations say which nodes move. */
+interface ThreeModel {
+    readonly scene: ThreeObject;
+    readonly animations?: readonly {
+        readonly tracks: readonly {
+            readonly name: string;
+        }[];
+    }[];
+}
+interface SceneFromThreeOptions {
+    /** Room units in one three.js unit. Default 1: a game that draws the server's numbers directly, as `(x, z, -y)`. */
+    readonly scale?: number;
+    /** What a report's areas are in, and how a missing hull is sized. */
+    readonly unitsPerMeter?: number;
+    readonly hull?: LevelHull;
+    /** The level's name in the fit's report. */
+    readonly level?: string;
+    /** Spawns not marked in the scene, in the room's axes and units. */
+    readonly spawns?: readonly {
+        readonly at: readonly [number, number, number];
+        readonly name?: string;
+        readonly tags?: readonly string[];
+    }[];
+}
+/** Turns a three.js level into the scene format. Throws {@link LevelRefusal}, as the glTF reader does. World matrices are
+ *  brought up to date and nothing else in the scene changes. */
+declare function sceneFromThree(input: ThreeObject | ThreeModel, options?: SceneFromThreeOptions): LevelScene;
+
+export { LevelScene, type SceneFromThreeOptions, type ThreeAttribute, type ThreeGeometry, type ThreeModel, type ThreeObject, sceneFromThree };

package/dist/world-fit/three.js

@@ -0,0 +1,140 @@
+import {
+  LEVEL_LIMITS,
+  LevelCollide,
+  LevelRefusal,
+  LevelRefusalCode,
+  buildLevelScene,
+  inheritMark,
+  levelMarkOf,
+  levelSettingsOf,
+  multiplyMatrix,
+  namesInRefusal,
+  spawnNameOf
+} from "../chunk-TVTVIMIH.js";
+
+// src/world-fit/three.ts
+var DEFAULT_UNITS_PER_METER = 39.37;
+var MATRIX_ELEMENTS = 16;
+var isModel = (v) => "scene" in v && !("children" in v);
+function animatedNames(model) {
+  const out = /* @__PURE__ */ new Set();
+  for (const clip of model.animations ?? []) {
+    for (const track of clip.tracks) {
+      const dot = track.name.lastIndexOf(".");
+      if (dot > 0 && /\.(position|quaternion|scale)$/.test(track.name)) out.add(track.name.slice(0, dot));
+    }
+  }
+  return out;
+}
+function primitiveOf(geometry, cache) {
+  const seen = cache.get(geometry);
+  if (seen !== void 0) return seen;
+  const position = geometry.attributes.position;
+  if (position === void 0 || position.count === 0) {
+    cache.set(geometry, null);
+    return null;
+  }
+  const positions = new Float64Array(position.count * 3);
+  for (let i = 0; i < position.count; i++) {
+    positions[i * 3] = position.getX(i);
+    positions[i * 3 + 1] = position.getY(i);
+    positions[i * 3 + 2] = position.getZ(i);
+  }
+  const full = geometry.index === null ? position.count : geometry.index.count;
+  const start = Math.max(0, geometry.drawRange?.start ?? 0);
+  const end = Math.min(full, start + (geometry.drawRange?.count ?? Number.POSITIVE_INFINITY));
+  const usable = Math.floor(Math.max(0, end - start) / 3) * 3;
+  const indices = new Uint32Array(usable);
+  for (let i = 0; i < usable; i++) indices[i] = geometry.index === null ? start + i : geometry.index.getX(start + i);
+  const primitive = { positions, indices };
+  cache.set(geometry, primitive);
+  return primitive;
+}
+function instancesOf(object) {
+  const world = object.matrixWorld.elements;
+  if (object.isInstancedMesh !== true) return [world];
+  const out = [];
+  const array = object.instanceMatrix?.array ?? [];
+  const count = object.count ?? 0;
+  for (let i = 0; i < count; i++) {
+    const own = new Float64Array(MATRIX_ELEMENTS);
+    for (let k = 0; k < MATRIX_ELEMENTS; k++) own[k] = array[i * MATRIX_ELEMENTS + k];
+    out.push(multiplyMatrix(world, own));
+  }
+  return out;
+}
+function sceneFromThree(input, options = {}) {
+  const root = isModel(input) ? input.scene : input;
+  const animated = isModel(input) ? animatedNames(input) : /* @__PURE__ */ new Set();
+  root.updateWorldMatrix?.(true, true);
+  const settings = levelSettingsOf(root.userData.genex, "the root");
+  const meshes = [];
+  const spawns = [];
+  const notes = [];
+  const skinned = [];
+  const morphed = [];
+  const geometries = /* @__PURE__ */ new Map();
+  let triangles = 0;
+  let visited = 0;
+  const rootMark = levelMarkOf(root.name, root.userData.genex, root.name === "" ? "the root" : root.name, true);
+  const stack = [];
+  const pushChildren = (object, mark, path) => {
+    if (object.isLOD === true && object.levels !== void 0) {
+      const near = object.levels[0]?.object;
+      if (near !== void 0) stack.push({ object: near, mark, path });
+      if (object.levels.length > 1) notes.push(`${path === "" ? "an LOD" : path}: only its nearest level collides`);
+      return;
+    }
+    for (let i = object.children.length - 1; i >= 0; i--) stack.push({ object: object.children[i], mark, path });
+  };
+  if (root.isMesh === true) stack.push({ object: root, mark: {}, path: "" });
+  else pushChildren(root, rootMark, "");
+  for (let frame = stack.pop(); frame !== void 0; frame = stack.pop()) {
+    const { object } = frame;
+    visited++;
+    if (visited > LEVEL_LIMITS.maxNodes) throw new LevelRefusal(LevelRefusalCode.TooLarge, `the level holds over ${LEVEL_LIMITS.maxNodes} objects`);
+    const name = object.name === "" ? `object_${visited}` : object.name;
+    const own = levelMarkOf(name, object.userData.genex, name);
+    const mark = inheritMark(frame.mark, animated.has(object.name) ? { ...own, movable: true } : own);
+    const path = frame.path === "" ? name : `${frame.path}/${name}`;
+    pushChildren(object, mark, path);
+    if (own.spawn === true) {
+      const world = object.matrixWorld.elements;
+      spawns.push({ name: spawnNameOf(name), at: [world[12], world[13], world[14]], tags: own.tags ?? [] });
+      continue;
+    }
+    if (object.isMesh !== true || mark.collide === LevelCollide.None) continue;
+    if (mark.movable !== true) {
+      if (object.isSkinnedMesh === true) {
+        skinned.push(name);
+        continue;
+      }
+      if ((object.morphTargetInfluences ?? []).some((w) => w !== 0)) {
+        morphed.push(name);
+        continue;
+      }
+    }
+    if (object.isBatchedMesh === true) throw new LevelRefusal(LevelRefusalCode.Unsupported, `${name} is a BatchedMesh, which this cannot read: use plain or instanced meshes for what collides, or mark it nocol_`);
+    if (object.geometry === void 0) continue;
+    const primitive = primitiveOf(object.geometry, geometries);
+    if (primitive === null) continue;
+    const instances = instancesOf(object);
+    triangles += primitive.indices.length / 3 * instances.length;
+    if (triangles > LEVEL_LIMITS.maxTriangles) throw new LevelRefusal(LevelRefusalCode.TooLarge, `the level holds over ${LEVEL_LIMITS.maxTriangles} triangles (${name} is where it passes); give what no one walks on a nocol_ mark or a collision proxy`);
+    meshes.push({ name, path, mark, instances, primitives: [primitive] });
+  }
+  if (skinned.length > 0) throw new LevelRefusal(LevelRefusalCode.Skinned, `a room's world is static and these are skinned: ${namesInRefusal(skinned)}. Mark them nocol_ and collide with a static proxy, or movable_`);
+  if (morphed.length > 0) throw new LevelRefusal(LevelRefusalCode.Morphed, `a room's world is static and these are posed by morph targets: ${namesInRefusal(morphed)}. Mark them nocol_ and collide with a static proxy, or movable_`);
+  const unitsPerMeter = options.unitsPerMeter ?? settings.unitsPerMeter ?? DEFAULT_UNITS_PER_METER;
+  const hull = options.hull ?? settings.hull;
+  return buildLevelScene(
+    { meshes, spawns, notes },
+    { scale: options.scale ?? 1, unitsPerMeter, ...hull === void 0 ? {} : { hull }, ...options.spawns === void 0 ? {} : { spawns: options.spawns }, source: { engine: "three.js", ...options.level === void 0 ? {} : { level: options.level }, tool: "sceneFromThree" } }
+  );
+}
+export {
+  LEVEL_LIMITS,
+  LevelRefusal,
+  LevelRefusalCode,
+  sceneFromThree
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/multiplayer",
-  "version": "0.17.6",
+  "version": "0.17.9",
   "description": "The multiplayer client wrapper + shared room schema for genex.",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,12 +51,24 @@
       "types": "./dist/authority/fast-webtransport.d.ts",
       "import": "./dist/authority/fast-webtransport.js"
     },
+    "./world-fit": {
+      "@genex-ai/source": "./src/world-fit/index.ts",
+      "types": "./dist/world-fit/index.d.ts",
+      "import": "./dist/world-fit/index.js"
+    },
+    "./world-fit/three": {
+      "@genex-ai/source": "./src/world-fit/three.ts",
+      "types": "./dist/world-fit/three.d.ts",
+      "import": "./dist/world-fit/three.js"
+    },
     "./bridge.global.js": "./dist/bridge.global.js",
     "./bridge-authority.global.js": "./dist/bridge-authority.global.js"
   },
   "files": [
     "dist",
-    "PROTOCOL.md"
+    "PROTOCOL.md",
+    "WORLD-SCENE.md",
+    "WORLD-GLTF.md"
   ],
   "scripts": {
     "build": "tsup",
@@ -90,7 +102,7 @@
     "@colyseus/uwebsockets-transport": "^0.18.4",
     "@colyseus/ws-transport": "^0.18.4",
     "@genex-ai/embed-sdk": "workspace:*",
-    "@genex-ai/physics": "file:../authority-host/vendor/genex-ai-physics-0.1.0.tgz",
+    "@genex-ai/physics": "file:../authority-host/vendor/genex-ai-physics-0.1.1.tgz",
     "publint": "^0.3.0",
     "tsup": "^8.0.0",
     "typescript": "^5.8.0"