@adatechnology/game-interactables-three 0.1.5 → 0.1.7

package/dist/index.js

@@ -697,6 +697,10 @@ function createCord(THREE, points, radius, material, radialSegments = 5) {
   return mesh;
 }
 
+// src/mesh.ts
+import { createShapeRecorder } from "@adatechnology/game-props3d";
+import { colorChannels, generate } from "@adatechnology/game-shapes";
+
 // src/types.ts
 var MATERIAL_KEYS = ["plain", "metal", "wood", "glass", "fabric", "plant", "water", "emissive", "atlas_picture", "atlas_floor"];
 
@@ -1055,214 +1059,99 @@ function createDefaultMaterials(THREE, quality = "high") {
     atlas_floor: std({ roughness: 1 })
   };
 }
-var IDENT_UV = { u0: 0, v0: 0, u1: 1, v1: 1 };
+var colorSpaces = /* @__PURE__ */ new WeakMap();
+function colorSpaceOf(THREE) {
+  const known = colorSpaces.get(THREE.Color);
+  if (known) return known;
+  const space = detectColorSpace(THREE);
+  colorSpaces.set(THREE.Color, space);
+  return space;
+}
+function detectColorSpace(THREE) {
+  const color = new THREE.Color();
+  for (let c = 0; c < 256; c++) {
+    color.setHex(c * 65793);
+    if (color.r !== colorChannels(c * 65793, "linear")[0]) {
+      if (color.r !== c / 255) throw new Error("createMeshApi: this three.js stores colours in a space game-shapes does not know");
+      return "srgb";
+    }
+  }
+  return "linear";
+}
 function createMeshApi(THREE, options = {}) {
   const quality = options.quality ?? "high";
   const shadows = options.shadows !== false;
   const materials = { ...createDefaultMaterials(THREE, quality), ...stripUndefined(options.materials) };
   if (options.doubleSidedPlanes) for (const k of MATERIAL_KEYS) materials[k].side = THREE.DoubleSide;
-  const root = { id: null, pivot: [0, 0, 0], ry: 0, acc: /* @__PURE__ */ new Map(), lights: [] };
-  const partTargets = /* @__PURE__ */ new Map();
-  const stack = [];
-  let current = root;
   let finished = false;
-  const templates = /* @__PURE__ */ new Map();
-  const template = (key, make) => {
-    let t = templates.get(key);
-    if (!t) {
-      const g = make();
-      t = {
-        pos: g.getAttribute("position").array,
-        nor: g.getAttribute("normal").array,
-        uv: g.getAttribute("uv").array,
-        idx: g.index ? g.index.array : Array.from({ length: g.getAttribute("position").count }, (_, i) => i)
-      };
-      templates.set(key, t);
-    }
-    return t;
-  };
-  const segs = quality === "high" ? { cyl: 12, sphereW: 12, sphereH: 8 } : { cyl: 8, sphereW: 8, sphereH: 6 };
-  const tBox = () => template("box", () => new THREE.BoxGeometry(1, 1, 1));
-  const tCyl = (shape) => {
-    switch (shape) {
-      case "cyl6":
-        return template("cyl6", () => new THREE.CylinderGeometry(1, 1, 1, 6));
-      case "cone":
-        return template("cone", () => new THREE.CylinderGeometry(0, 1, 1, segs.cyl));
-      case "sphere":
-        return template("sphere", () => new THREE.SphereGeometry(1, segs.sphereW, segs.sphereH));
-      default:
-        return template("cyl", () => new THREE.CylinderGeometry(1, 1, 1, segs.cyl));
-    }
-  };
-  const tPlane = () => template("plane", () => new THREE.PlaneGeometry(1, 1));
-  const tLeaf = () => {
-    let t = templates.get("leaf");
-    if (!t) {
-      const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
-      const pos = [];
-      const nor = [];
-      const uv = [];
-      const idx = [];
-      for (const side of [1, -1]) {
-        const base = pos.length / 3;
-        for (let i = 0; i < 4; i++) {
-          pos.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
-          nor.push(0, 0, side);
-          uv.push(f[i * 3] + 0.5, f[i * 3 + 1]);
-        }
-        if (side === 1) idx.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
-        else idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
-      }
-      t = { pos: new Float32Array(pos), nor: new Float32Array(nor), uv: new Float32Array(uv), idx };
-      templates.set("leaf", t);
-    }
-    return t;
-  };
-  const m4 = new THREE.Matrix4();
-  const mItem = new THREE.Matrix4();
-  const mTotal = new THREE.Matrix4();
-  const n3 = new THREE.Matrix3();
-  const v = new THREE.Vector3();
-  const quat = new THREE.Quaternion();
-  const euler = new THREE.Euler();
-  const scl = new THREE.Vector3();
-  const color = new THREE.Color();
-  const canonical = /* @__PURE__ */ new Map();
+  const recorder = quality === "high" ? createShapeRecorder({ cylinderSegments: 12, sphereSegments: [12, 8] }) : createShapeRecorder({ cylinderSegments: 8, sphereSegments: [8, 6] });
+  const materialAlias = {};
   for (const k of MATERIAL_KEYS) {
     const first = MATERIAL_KEYS.find((o) => materials[o] === materials[k]) ?? k;
-    canonical.set(k, first);
+    if (first !== k) materialAlias[k] = first;
   }
-  const accOf = (requested) => {
-    const key = canonical.get(requested) ?? requested;
-    let a = current.acc.get(key);
-    if (!a) {
-      a = { pos: [], nor: [], col: [], uv: [], idx: [] };
-      current.acc.set(key, a);
-    }
-    return a;
-  };
-  const frame = (M) => {
-    mItem.makeRotationY(M?.ry ?? 0);
-    mItem.setPosition(M?.x ?? 0, 0, M?.z ?? 0);
-    return mItem;
-  };
-  const emit = (requested, M, local, t, hexColor, uv) => {
-    const key = requested in materials ? requested : "plain";
-    const a = accOf(key);
-    const total = mTotal.copy(frame(M)).multiply(local);
-    n3.getNormalMatrix(total);
-    const base = a.pos.length / 3;
-    color.setHex(hexColor);
-    const count = t.pos.length / 3;
-    const e = total.elements;
-    const nm = n3.elements;
-    const u = uv ?? IDENT_UV;
-    for (let i = 0; i < count; i++) {
-      const x = t.pos[i * 3];
-      const y = t.pos[i * 3 + 1];
-      const z = t.pos[i * 3 + 2];
-      a.pos.push(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
-      const nx = t.nor[i * 3];
-      const ny = t.nor[i * 3 + 1];
-      const nz = t.nor[i * 3 + 2];
-      v.set(nm[0] * nx + nm[3] * ny + nm[6] * nz, nm[1] * nx + nm[4] * ny + nm[7] * nz, nm[2] * nx + nm[5] * ny + nm[8] * nz).normalize();
-      a.nor.push(v.x, v.y, v.z);
-      a.col.push(color.r, color.g, color.b);
-      a.uv.push(u.u0 + t.uv[i * 2] * (u.u1 - u.u0), u.v0 + t.uv[i * 2 + 1] * (u.v1 - u.v0));
-    }
-    for (let i = 0; i < t.idx.length; i++) a.idx.push(base + t.idx[i]);
-  };
-  const compose = (x, y, z, rx, ry, rz, sx, sy, sz) => {
-    euler.set(rx, ry, rz, "YXZ");
-    quat.setFromEuler(euler);
-    return m4.compose(v.set(x, y, z), quat, scl.set(sx, sy, sz));
-  };
-  const api = {
-    box(M, material, x, y, z, w, h, d, col, ry, rx, rz) {
-      emit(material, M, compose(x, y + h / 2, z, rx, ry, rz, w, h, d), tBox(), col);
-    },
-    cylinder(M, material, x, y, z, r, h, col, rx, rz, shape) {
-      const tilted = rx !== 0 || rz !== 0;
-      const cy = shape === "sphere" ? y + h / 2 : tilted ? y : y + h / 2;
-      const sy = shape === "sphere" ? h / 2 : h;
-      emit(material, M, compose(x, cy, z, rx, 0, rz, r, sy, r), tCyl(shape), col);
-    },
-    leaf(M, x, y, z, w, h, col, ry, rx) {
-      emit("plant", M, compose(x, y, z, rx, ry, 0, w, h, 1), tLeaf(), col);
-    },
-    plane(M, material, x, y, z, w, h, col, ry, rx, rz, uv) {
-      emit(material, M, compose(x, y, z, rx, ry, rz, w, h, 1), tPlane(), col, uv);
-    },
-    light(M, x, y, z, col, range) {
-      const fr = frame(M);
-      v.set(x, y, z).applyMatrix4(fr);
-      current.lights.push({ x: v.x, y: v.y, z: v.z, color: col, range });
-    },
-    part(id, pivot, ry, draw) {
-      let target = partTargets.get(id);
-      if (!target) {
-        target = { id, pivot: [pivot[0], pivot[1], pivot[2]], ry, acc: /* @__PURE__ */ new Map(), lights: [] };
-        partTargets.set(id, target);
-      }
-      stack.push(current);
-      current = target;
-      try {
-        draw();
-      } finally {
-        current = stack.pop() ?? root;
-      }
-    }
-  };
-  const build = (target, into, materialFor) => {
-    for (const [key, a] of target.acc) {
-      if (!a.idx.length) continue;
+  const lightsOut = [];
+  const build = (batches, points, id, into, materialFor) => {
+    for (const batch of batches) {
       const g = new THREE.BufferGeometry();
-      g.setAttribute("position", new THREE.Float32BufferAttribute(a.pos, 3));
-      g.setAttribute("normal", new THREE.Float32BufferAttribute(a.nor, 3));
-      g.setAttribute("color", new THREE.Float32BufferAttribute(a.col, 3));
-      g.setAttribute("uv", new THREE.Float32BufferAttribute(a.uv, 2));
-      g.setIndex(a.pos.length / 3 > 65535 ? new THREE.Uint32BufferAttribute(a.idx, 1) : new THREE.Uint16BufferAttribute(a.idx, 1));
+      g.setAttribute("position", new THREE.BufferAttribute(batch.positions, 3));
+      g.setAttribute("normal", new THREE.BufferAttribute(batch.normals, 3));
+      g.setAttribute("color", new THREE.BufferAttribute(batch.colors, 3));
+      g.setAttribute("uv", new THREE.BufferAttribute(batch.uvs, 2));
+      g.setIndex(new THREE.BufferAttribute(batch.indices, 1));
       g.computeBoundingSphere();
       g.computeBoundingBox();
-      const mesh = new THREE.Mesh(g, materialFor?.(key, target.id) ?? materials[key]);
-      mesh.name = target.id === null ? `static:${key}` : `part:${target.id}`;
-      if (target.id !== null) mesh.userData.part = target.id;
+      const key = batch.material;
+      const mesh = new THREE.Mesh(g, materialFor?.(key, id) ?? materials[key]);
+      mesh.name = id === null ? `static:${key}` : `part:${id}`;
+      if (id !== null) mesh.userData.part = id;
       mesh.userData.material = key;
       mesh.castShadow = shadows;
       mesh.receiveShadow = shadows;
       into.add(mesh);
     }
-    for (const l of target.lights) {
+    for (const point of points) {
+      const l = point.data;
       const light = new THREE.PointLight(l.color, 1, l.range);
-      light.position.set(l.x, l.y, l.z);
+      light.position.set(point.position[0], point.position[1], point.position[2]);
       into.add(light);
       lightsOut.push(light);
     }
   };
-  const lightsOut = [];
   return {
-    api,
+    api: recorder.api,
     materials,
     finish(spec, finishOptions) {
       const materialFor = finishOptions?.materialFor ?? options.materialFor;
       if (finished) throw new Error("createMeshApi: finish() was already called");
       finished = true;
+      const buffers = generate(recorder.schema(), {
+        colors: colorSpaceOf(THREE),
+        materials: MATERIAL_KEYS,
+        fallbackMaterial: "plain",
+        materialAlias,
+        validate: false,
+        key: false
+      });
+      const batches = buffers.levels[0]?.batches ?? [];
+      const of = (id) => ({ batches: batches.filter((b) => b.part === id), points: buffers.points.filter((p) => p.part === id) });
       const group = new THREE.Group();
       group.name = "interactable";
       const parts = {};
-      build(root, group, materialFor);
-      for (const [id, target] of partTargets) {
+      const body = of(null);
+      build(body.batches, body.points, null, group, materialFor);
+      for (const part of recorder.parts) {
         const g = new THREE.Group();
-        g.name = `part:${id}`;
-        g.userData.part = id;
-        g.position.set(target.pivot[0], target.pivot[1], target.pivot[2]);
-        g.rotation.y = target.ry;
+        g.name = `part:${part.id}`;
+        g.userData.part = part.id;
+        g.position.set(part.pivot[0], part.pivot[1], part.pivot[2]);
+        g.rotation.y = part.ry;
         g.updateMatrix();
-        build(target, g, materialFor);
+        const drawn = of(part.id);
+        build(drawn.batches, drawn.points, part.id, g, materialFor);
         rememberRest(g);
         group.add(g);
-        parts[id] = g;
+        parts[part.id] = g;
       }
       if (spec && (options.mergeParts ?? quality === "game")) mergeParts(THREE, group, parts, spec, { swayAmplitude: options.swayAmplitude });
       if (spec) tagDestruction(group, parts, spec);