@adatechnology/game-items-three 0.3.1 → 0.4.0

package/dist/index.js

@@ -365,14 +365,19 @@ var destruction_default = {
         },
         tessellate: {
           cylinder: {
-            heightSegments: 6,
-            radialSegments: 20
+            heightSegments: 24,
+            radialSegments: 40,
+            capRings: 6
           },
           box: {
             widthSegments: 6,
             heightSegments: 1,
             depthSegments: 4
           }
+        },
+        wall: {
+          body: 1e-4,
+          ends: 25e-5
         }
       }
     },
@@ -396,14 +401,19 @@ var destruction_default = {
         },
         tessellate: {
           cylinder: {
-            heightSegments: 6,
-            radialSegments: 20
+            heightSegments: 24,
+            radialSegments: 40,
+            capRings: 6
           },
           box: {
             widthSegments: 6,
             heightSegments: 1,
             depthSegments: 4
           }
+        },
+        wall: {
+          body: 18e-5,
+          ends: 22e-5
         }
       }
     }
@@ -497,12 +507,53 @@ function volumeOf(mesh) {
   if (!box2) return 0;
   return (box2.max.x - box2.min.x) * (box2.max.y - box2.min.y) * (box2.max.z - box2.min.z);
 }
-function tessellated(geometry, rule) {
+function ringedCylinder(T, p, radial, maxRows, rings) {
+  const half = p.height / 2;
+  const column = 2 * Math.PI * Math.max(p.radiusTop, p.radiusBottom, 1e-6) / radial;
+  const rows = Math.max(1, Math.min(maxRows, Math.round(p.height / column)));
+  const points = [];
+  if (!p.openEnded) for (let i = 0; i <= rings; i++) points.push(new T.Vector2(p.radiusBottom * i / rings, -half));
+  for (let j = 0; j <= rows; j++) points.push(new T.Vector2(p.radiusBottom + (p.radiusTop - p.radiusBottom) * j / rows, -half + p.height * j / rows));
+  if (!p.openEnded) for (let i = rings; i >= 0; i--) points.push(new T.Vector2(p.radiusTop * i / rings, half));
+  return lathed(T, points, radial, p.thetaStart, p.thetaLength);
+}
+function lathed(T, points, radial, phiStart, phiLength) {
+  const geometry = new T.LatheGeometry([...points], radial, phiStart, phiLength);
+  geometry.computeVertexNormals();
+  const position = geometry.getAttribute("position");
+  const normal = geometry.getAttribute("normal");
+  const middle = (Math.min(...points.map((point) => point.y)) + Math.max(...points.map((point) => point.y))) / 2;
+  for (let i = 0; i < normal.count; i++) {
+    if (Math.hypot(normal.getX(i), normal.getY(i), normal.getZ(i)) > 0.5) continue;
+    normal.setXYZ(i, 0, position.getY(i) >= middle ? 1 : -1, 0);
+  }
+  return geometry;
+}
+function finerProfile(T, points, step) {
+  const out = [];
+  points.forEach((point, index) => {
+    const next = points[index + 1];
+    out.push(point.clone());
+    if (!next) return;
+    const pieces = Math.max(1, Math.round(point.distanceTo(next) / step));
+    for (let k = 1; k < pieces; k++) out.push(point.clone().lerp(next, k / pieces));
+  });
+  return out;
+}
+function tessellated(geometry, rule, T) {
   const Shape = geometry.constructor;
   if (geometry.type === "CylinderGeometry" && rule.cylinder) {
-    const { radiusTop, radiusBottom, height, openEnded, thetaStart, thetaLength } = geometry.parameters;
+    const parameters = geometry.parameters;
+    const { radiusTop, radiusBottom, height, openEnded, thetaStart, thetaLength } = parameters;
+    if (T && rule.cylinder.capRings !== void 0) return ringedCylinder(T, parameters, rule.cylinder.radialSegments, rule.cylinder.heightSegments, rule.cylinder.capRings);
     return new Shape(radiusTop, radiusBottom, height, rule.cylinder.radialSegments, rule.cylinder.heightSegments, openEnded, thetaStart, thetaLength);
   }
+  if (geometry.type === "LatheGeometry" && rule.cylinder && T && rule.cylinder.capRings !== void 0) {
+    const { points, segments, phiStart, phiLength } = geometry.parameters;
+    if (segments >= rule.cylinder.radialSegments) return void 0;
+    const widest = Math.max(...points.map((point) => point.x), 1e-6);
+    return lathed(T, finerProfile(T, points, 2 * Math.PI * widest / rule.cylinder.radialSegments), rule.cylinder.radialSegments, phiStart, phiLength);
+  }
   if (geometry.type === "BoxGeometry" && rule.box) {
     const { width, height, depth } = geometry.parameters;
     return new Shape(width, height, depth, rule.box.widthSegments, rule.box.heightSegments, rule.box.depthSegments);
@@ -510,14 +561,14 @@ function tessellated(geometry, rule) {
   return void 0;
 }
 var triangleCount = (geometry) => (geometry.index ? geometry.index.count : geometry.getAttribute("position").count) / 3;
-function tessellateShapes(root, rule) {
+function tessellateShapes(root, rule, T) {
   const rebuilt = /* @__PURE__ */ new Map();
   root.traverse((object) => {
     const mesh = object;
     if (!mesh.isMesh) return;
     let fresh = rebuilt.get(mesh.geometry);
     if (!fresh) {
-      fresh = tessellated(mesh.geometry, rule);
+      fresh = tessellated(mesh.geometry, rule, T);
       if (!fresh) return;
       rebuilt.set(mesh.geometry, fresh);
     }
@@ -531,10 +582,10 @@ function tessellateShapes(root, rule) {
   root.userData.tessellationTriangles = added;
 }
 function tagForDestruction(root, options = {}) {
-  const { modelId, weight, size } = options;
+  const { modelId, weight, size, three } = options;
   if (weight !== void 0 && weight > 0) root.userData.destructionMass = weight;
   const rule = modelId === void 0 ? void 0 : itemDestruction(modelId);
-  if (rule?.tessellate) tessellateShapes(root, rule.tessellate);
+  if (rule?.tessellate) tessellateShapes(root, rule.tessellate, three);
   const solid = [];
   root.traverse((object) => {
     const mesh = object;
@@ -554,6 +605,7 @@ function tagForDestruction(root, options = {}) {
   const anchor = solid.reduce((largest, mesh) => volumeOf(mesh) > volumeOf(largest) ? mesh : largest);
   solid.forEach((mesh, index) => {
     mesh.userData.destructionPart = mesh === anchor ? { id: SHELL_PART_ID } : { id: `shell_${index}`, parent: SHELL_PART_ID, kind: "weld" };
+    if (rule.wall) mesh.userData.destructionThickness = mesh === anchor ? rule.wall.body : rule.wall.ends;
   });
   const contents = size === void 0 ? void 0 : itemContents({ ...modelId === void 0 ? {} : { model: modelId }, size, ...weight === void 0 ? {} : { weight } });
   if (contents) anchor.userData.destructionContains = { fluid: contents.liquid, liters: contents.liters };
@@ -6674,7 +6726,7 @@ function buildItem(T, item, options = {}) {
   const materials = kit.materials.slice(first);
   if (options.wear) setWear(materials, options.wear);
   root.userData.wear = options.wear ?? 0;
-  if (options.destructible) tagForDestruction(root, { ...kind === "model" && item.model !== void 0 ? { modelId: item.model } : {}, ...item.weight === void 0 ? {} : { weight: item.weight }, size: item.size });
+  if (options.destructible) tagForDestruction(root, { ...kind === "model" && item.model !== void 0 ? { modelId: item.model } : {}, ...item.weight === void 0 ? {} : { weight: item.weight }, size: item.size, three: T });
   markKitOrigin(root, { owner: "game-items-three", kind: "item", id: item.id, ...kind === "shape" ? { standIn: true } : {} });
   return { root, kind, ...shape ? { shape } : {}, size: item.size, materials };
 }
@@ -7417,6 +7469,7 @@ function createItemsTestModule(options) {
   const module = {
     id: "items_area",
     name: text.name,
+    ground: { surface: "tile_floor" },
     group: text.group,
     state,
     placed: () => entries2.map((entry) => ({ id: entry.id, itemId: entry.itemId, group: entry.group, kind: entry.kind, size: entry.size, root: entry.root })),