@rednaxela101/cubing 0.63.8 → 0.63.9

package/dist/lib/cubing/chunks/{twisty-dynamic-3d-SLKSUJTE.js → twisty-dynamic-3d-MF76FSDA.js}

@@ -3,7 +3,7 @@ import {
   bulk3DCode,
   haveStartedSharingRenderers,
   hintFaceletStyles
-} from "./chunk-B2YKAP2I.js";
+} from "./chunk-F765ZFNM.js";
 import "./chunk-3ODTF4HE.js";
 import {
   cube3x3x3,
@@ -21,7 +21,7 @@ import { BufferGeometry as BufferGeometry2 } from "three/src/core/BufferGeometry
 import { Object3D } from "three/src/core/Object3D.js";
 import { BoxGeometry } from "three/src/geometries/BoxGeometry.js";
 import { TextureLoader } from "three/src/loaders/TextureLoader.js";
-import { MeshBasicMaterial } from "three/src/materials/MeshBasicMaterial.js";
+import { MeshBasicMaterial as MeshBasicMaterial2 } from "three/src/materials/MeshBasicMaterial.js";
 import { Color as Color2 } from "three/src/math/Color.js";
 import { Matrix4 } from "three/src/math/Matrix4.js";
 import { Quaternion } from "three/src/math/Quaternion.js";
@@ -87,7 +87,6 @@ function beveledCubieGeometry(faceNormals, outerFaceIndices, halfSize, outerAxis
   }
   const gridSize = samples.length;
   const positions = [];
-  const normals = [];
   const indices = [];
   const geometry = new BufferGeometry();
   const point = new Vector3();
@@ -140,9 +139,6 @@ function beveledCubieGeometry(faceNormals, outerFaceIndices, halfSize, outerAxis
           core.y + offset.y * radii.y,
           core.z + offset.z * radii.z
         );
-        normals.push(
-          ...offset.set(offset.x / radii.x, offset.y / radii.y, offset.z / radii.z).normalize().toArray()
-        );
       }
     }
     const indexStart = indices.length;
@@ -159,18 +155,12 @@ function beveledCubieGeometry(faceNormals, outerFaceIndices, halfSize, outerAxis
     "position",
     new BufferAttribute(new Float32Array(positions), 3)
   );
-  geometry.setAttribute(
-    "normal",
-    new BufferAttribute(new Float32Array(normals), 3)
-  );
   geometry.setIndex(indices);
   return geometry;
 }
 
 // src/cubing/twisty/views/3D/puzzles/CubieStyle.ts
-import { AmbientLight } from "three/src/lights/AmbientLight.js";
-import { DirectionalLight } from "three/src/lights/DirectionalLight.js";
-import { MeshPhongMaterial } from "three/src/materials/MeshPhongMaterial.js";
+import { MeshBasicMaterial } from "three/src/materials/MeshBasicMaterial.js";
 import { Color } from "three/src/math/Color.js";
 import { Euler } from "three/src/math/Euler.js";
 import { Vector3 as Vector32 } from "three/src/math/Vector3.js";
@@ -268,18 +258,14 @@ var cubieBodyDimensions = {
    * a thin line of the puzzle's interior showing between them.
    */
   pieceScale: 0.95,
-  roundingSegments: 7
+  roundingSegments: 3
 };
 function cubieBodyHalfExtent(layers) {
   return layers / 2 - 0.5 + cubieBodyDimensions.halfWidth * cubieBodyDimensions.pieceScale;
 }
-var BODY_SHININESS = 30;
-var BODY_SPECULAR = 657930;
 function newBodyMaterial(color) {
-  return new MeshPhongMaterial({
-    color: typeof color === "number" ? new Color(color).convertLinearToSRGB() : color,
-    shininess: BODY_SHININESS,
-    specular: new Color(BODY_SPECULAR).convertLinearToSRGB()
+  return new MeshBasicMaterial({
+    color: typeof color === "number" ? new Color(color).convertLinearToSRGB() : color
   });
 }
 function newVertexColorBodyMaterial() {
@@ -301,51 +287,35 @@ var hintMaskStyles = {
   experimentalOriented2: { color: 16775545, opacity: 0.5 },
   mystery: { color: 15911883, opacity: 0.5 }
 };
-var AMBIENT_LIGHT_INTENSITY = 2.04;
-var KEY_LIGHT_INTENSITY = 1.55;
-var FILL_LIGHT_INTENSITY = 0.3;
-var RIM_LIGHT_INTENSITY = 0.3;
-function addCubieBodyLighting(target) {
-  target.add(new AmbientLight(16777215, AMBIENT_LIGHT_INTENSITY));
-  const keyLight = new DirectionalLight(16777215, KEY_LIGHT_INTENSITY);
-  keyLight.position.set(3, 5, 4);
-  target.add(keyLight);
-  const fillLight = new DirectionalLight(16777215, FILL_LIGHT_INTENSITY);
-  fillLight.position.set(-5, 2, 3);
-  target.add(fillLight);
-  const rimLight = new DirectionalLight(16777215, RIM_LIGHT_INTENSITY);
-  rimLight.position.set(-3, -2, -4);
-  target.add(rimLight);
-}
 
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
 var svgLoader = new TextureLoader();
 function newHintMaterial(style) {
-  return new MeshBasicMaterial({
+  return new MeshBasicMaterial2({
     color: new Color2(style.color).convertLinearToSRGB(),
     side: BackSide,
     transparent: true,
     opacity: style.opacity
   });
 }
-var ignoredMaterial = new MeshBasicMaterial({
+var ignoredMaterial = new MeshBasicMaterial2({
   color: new Color2(bodyMaskColors.ignored).convertLinearToSRGB()
 });
 var ignoredMaterialHint = newHintMaterial(hintMaskStyles.ignored);
-var invisibleMaterial = new MeshBasicMaterial({
+var invisibleMaterial = new MeshBasicMaterial2({
   visible: false
 });
-var orientedMaterial = new MeshBasicMaterial({
+var orientedMaterial = new MeshBasicMaterial2({
   color: bodyMaskColors.oriented
 });
 var orientedMaterialHint = newHintMaterial(hintMaskStyles.oriented);
-var experimentalOriented2Material = new MeshBasicMaterial({
+var experimentalOriented2Material = new MeshBasicMaterial2({
   color: bodyMaskColors.experimentalOriented2
 });
 var experimentalOriented2MaterialHint = newHintMaterial(
   hintMaskStyles.experimentalOriented2
 );
-var mysteryMaterial = new MeshBasicMaterial({
+var mysteryMaterial = new MeshBasicMaterial2({
   color: bodyMaskColors.mystery
 });
 var mysterMaterialHint = newHintMaterial(hintMaskStyles.mystery);
@@ -369,12 +339,12 @@ var AxisInfo = class {
     const colorLinearSRGB = new Color2(color).convertLinearToSRGB();
     const dimColorLinearSRGB = new Color2(dimColor).convertLinearToSRGB();
     this.stickerMaterial = {
-      regular: new MeshBasicMaterial({
+      regular: new MeshBasicMaterial2({
         color: colorLinearSRGB,
         side: FrontSide
         // TODO: set to `DoubleSide` when hint facelets are disabled.
       }),
-      dim: new MeshBasicMaterial({
+      dim: new MeshBasicMaterial2({
         color: dimColorLinearSRGB,
         side: FrontSide
         // TODO: set to `DoubleSide` when hint facelets are disabled.
@@ -487,12 +457,12 @@ function getFaceletScale(options) {
   }
   return options.faceletScale;
 }
-var blackMesh = new MeshBasicMaterial({
+var blackMesh = new MeshBasicMaterial2({
   color: 0,
   opacity: 1,
   transparent: true
 });
-var blackTranslucentMesh = new MeshBasicMaterial({
+var blackTranslucentMesh = new MeshBasicMaterial2({
   color: 0,
   opacity: 0.3,
   transparent: true
@@ -810,9 +780,6 @@ var Cube3D = class extends Object3D {
         this.createCubie.bind(this, orbit, orbitFaceletInfo)
       );
     }
-    if (this.#stickerless()) {
-      addCubieBodyLighting(this);
-    }
     const scale = cubeScale(this.#stickerless());
     this.scale.set(scale, scale, scale);
     if (this.options.experimentalStickeringMask) {
@@ -1097,7 +1064,7 @@ var Cube3D = class extends Object3D {
               axesInfo[piece.stickerFaces[i]],
               hint
             );
-            mesh.material = new MeshBasicMaterial({
+            mesh.material = new MeshBasicMaterial2({
               map: texture,
               side: hint ? BackSide : DoubleSide,
               transparent: true
@@ -1246,8 +1213,6 @@ import { Vector3 as Vector34 } from "three/src/math/Vector3.js";
 // src/cubing/twisty/views/3D/puzzles/StickerlessPlan.ts
 var HINT_FACELET_ELEVATION = 0.5;
 var HINT_FACELET_SCALE = 0.85;
-var BODY_MATERIAL_INDEX = 0;
-var HINT_MATERIAL_INDEX = 1;
 var faceletMeshStickeringMasks = [
   "regular",
   "dim",
@@ -1470,7 +1435,6 @@ function newCubieShape(outwardFaces, slotWidth) {
     cubieBodyDimensions.roundingSegments
   );
   const bodyPositions = body.getAttribute("position").array;
-  const bodyNormals = body.getAttribute("normal").array;
   const bodyIndices = Array.from(body.getIndex().array);
   const faceVertexRanges = [];
   for (const group of body.groups) {
@@ -1482,9 +1446,8 @@ function newCubieShape(outwardFaces, slotWidth) {
     }
     faceVertexRanges[group.materialIndex] = { start, count: end - start };
   }
-  const positions = Array.from(bodyPositions);
-  const normals = Array.from(bodyNormals);
-  const indices = bodyIndices.slice();
+  const hintPositions = [];
+  const hintIndices = [];
   const hintVertexRanges = /* @__PURE__ */ new Map();
   const hintHalfWidth = HINT_FACELET_SCALE * slotWidth / 2;
   const hintDistance = slotWidth / 2 + HINT_FACELET_ELEVATION;
@@ -1495,7 +1458,7 @@ function newCubieShape(outwardFaces, slotWidth) {
     const normal2 = cubeFaceStyles[faceIdx].vector;
     u.set(normal2.y, normal2.z, normal2.x);
     v.crossVectors(normal2, u);
-    const start = positions.length / 3;
+    const start = hintPositions.length / 3;
     for (const [su, sv] of [
       [-1, -1],
       [1, -1],
@@ -1503,44 +1466,39 @@ function newCubieShape(outwardFaces, slotWidth) {
       [-1, 1]
     ]) {
       corner.copy(normal2).multiplyScalar(hintDistance).addScaledVector(u, su * hintHalfWidth).addScaledVector(v, sv * hintHalfWidth);
-      positions.push(corner.x, corner.y, corner.z);
-      normals.push(normal2.x, normal2.y, normal2.z);
+      hintPositions.push(corner.x, corner.y, corner.z);
     }
-    indices.push(start, start + 1, start + 2, start, start + 2, start + 3);
+    hintIndices.push(start, start + 1, start + 2, start, start + 2, start + 3);
     hintVertexRanges.set(faceIdx, { start, count: 4 });
   }
   body.dispose();
   return {
-    position: new BufferAttribute3(new Float32Array(positions), 3),
-    normal: new BufferAttribute3(new Float32Array(normals), 3),
-    index: new BufferAttribute3(new Uint16Array(indices), 1),
-    vertexCount: positions.length / 3,
-    bodyIndexCount: bodyIndices.length,
-    hintIndexCount: indices.length - bodyIndices.length,
+    bodyPosition: new BufferAttribute3(bodyPositions.slice(), 3),
+    bodyIndex: new BufferAttribute3(new Uint16Array(bodyIndices), 1),
+    bodyVertexCount: bodyPositions.length / 3,
+    hintPosition: new BufferAttribute3(new Float32Array(hintPositions), 3),
+    hintIndex: new BufferAttribute3(new Uint16Array(hintIndices), 1),
+    hintVertexCount: hintPositions.length / 3,
     faceVertexRanges,
     hintVertexRanges
   };
 }
-function newCubiePiece(cubie, shape) {
+function newPieceMesh(position, index, vertexCount) {
   const geometry = new BufferGeometry3();
-  geometry.setAttribute("position", shape.position);
-  geometry.setAttribute("normal", shape.normal);
-  geometry.setIndex(shape.index);
-  const colors = new BufferAttribute3(
-    new Uint8Array(4 * shape.vertexCount),
-    4,
-    true
-  );
+  geometry.setAttribute("position", position);
+  geometry.setIndex(index);
+  const colors = new BufferAttribute3(new Uint8Array(4 * vertexCount), 4, true);
   geometry.setAttribute("color", colors);
-  geometry.addGroup(0, shape.bodyIndexCount, BODY_MATERIAL_INDEX);
-  if (shape.hintIndexCount > 0) {
-    geometry.addGroup(
-      shape.bodyIndexCount,
-      shape.hintIndexCount,
-      HINT_MATERIAL_INDEX
-    );
-  }
-  paintInternal(colors, shape.faceVertexRanges);
+  return { geometry, colors };
+}
+function newCubiePiece(cubie, shape) {
+  const body = newPieceMesh(
+    shape.bodyPosition,
+    shape.bodyIndex,
+    shape.bodyVertexCount
+  );
+  const hint = shape.hintVertexCount > 0 ? newPieceMesh(shape.hintPosition, shape.hintIndex, shape.hintVertexCount) : null;
+  paintInternal(body.colors, shape.faceVertexRanges);
   const facelets = cubie.stickers.map((sticker) => ({
     ori: sticker.ori,
     faceStyle: sticker.faceIdx,
@@ -1553,8 +1511,8 @@ function newCubiePiece(cubie, shape) {
     orbit: cubie.orbit,
     ord: cubie.ord,
     home: new Matrix42().setPosition(cubie.center),
-    geometry,
-    colors,
+    body,
+    hint,
     facelets
   };
 }
@@ -1588,19 +1546,19 @@ import { DoubleSide as DoubleSide2, FrontSide as FrontSide2 } from "three/src/co
 import { BufferAttribute as BufferAttribute4 } from "three/src/core/BufferAttribute.js";
 import { BufferGeometry as BufferGeometry4 } from "three/src/core/BufferGeometry.js";
 import { Object3D as Object3D2 } from "three/src/core/Object3D.js";
-import { MeshBasicMaterial as MeshBasicMaterial2 } from "three/src/materials/MeshBasicMaterial.js";
+import { MeshBasicMaterial as MeshBasicMaterial3 } from "three/src/materials/MeshBasicMaterial.js";
 import { Color as Color3 } from "three/src/math/Color.js";
 import { Vector3 as Vector35 } from "three/src/math/Vector3.js";
 import { Group as Group2 } from "three/src/objects/Group.js";
 import { Mesh as Mesh2 } from "three/src/objects/Mesh.js";
-var foundationMaterial = new MeshBasicMaterial2({
+var foundationMaterial = new MeshBasicMaterial3({
   side: DoubleSide2,
   color: 0
 });
-var invisMaterial = new MeshBasicMaterial2({
+var invisMaterial = new MeshBasicMaterial3({
   visible: false
 });
-var basicStickerMaterial = new MeshBasicMaterial2({
+var basicStickerMaterial = new MeshBasicMaterial3({
   vertexColors: true
 });
 function dist(coords, a, b) {
@@ -1995,7 +1953,7 @@ var PG3D = class extends Object3D2 {
     if (stickerDat.stickers.length === 0) {
       throw Error("Reuse of stickerdat from pg; please don't do that.");
     }
-    this.hintMaterial = new MeshBasicMaterial2({
+    this.hintMaterial = new MeshBasicMaterial3({
       vertexColors: true,
       transparent: true,
       opacity: 0.5
@@ -2414,7 +2372,7 @@ var PG3D = class extends Object3D2 {
     } else if (v === 1) {
       this.hintMaterial = this.stickerMaterial;
     } else {
-      this.hintMaterial = new MeshBasicMaterial2({
+      this.hintMaterial = new MeshBasicMaterial3({
         vertexColors: true,
         transparent: true,
         opacity: v
@@ -2477,7 +2435,7 @@ var PG3D = class extends Object3D2 {
       this.stickerMaterialDisposable = false;
     }
     if (enabled) {
-      this.stickerMaterial = new MeshBasicMaterial2({
+      this.stickerMaterial = new MeshBasicMaterial3({
         map: stickerTexture,
         side: FrontSide2,
         transparent: false
@@ -2491,7 +2449,7 @@ var PG3D = class extends Object3D2 {
       this.hintMaterialDisposable = false;
     }
     if (enabled) {
-      this.hintMaterial = new MeshBasicMaterial2({
+      this.hintMaterial = new MeshBasicMaterial3({
         map: hintTexture,
         side: FrontSide2,
         transparent: true
@@ -2690,11 +2648,9 @@ function solidPieceGeometry(planes, options) {
   const withChamfers = options.chamfer > 0 ? working.concat(chamferPlanes(plain, working, options.chamfer, epsilon)) : working;
   const facets = (options.chamfer > 0 ? buildFacets(withChamfers, options.radius, epsilon) : plain) ?? plain;
   const positions = [];
-  const normals = [];
   const ranges = planes.map(() => []);
   const internalRanges = [];
   for (const facet of facets) {
-    const plane = withChamfers[facet.plane];
     const start = positions.length / 3;
     for (let i = 1; i < facet.vertices.length - 1; i++) {
       for (const vertex of [
@@ -2703,22 +2659,20 @@ function solidPieceGeometry(planes, options) {
         facet.vertices[i + 1]
       ]) {
         positions.push(vertex.x, vertex.y, vertex.z);
-        normals.push(plane.normal.x, plane.normal.y, plane.normal.z);
       }
     }
     const range = { start, count: positions.length / 3 - start };
     if (range.count === 0) {
       continue;
     }
-    if (plane.source === -1) {
+    if (withChamfers[facet.plane].source === -1) {
       internalRanges.push(range);
     } else {
-      ranges[plane.source].push(range);
+      ranges[withChamfers[facet.plane].source].push(range);
     }
   }
   return {
     positions: new Float32Array(positions),
-    normals: new Float32Array(normals),
     vertexCount: positions.length / 3,
     ranges,
     internalRanges
@@ -2805,6 +2759,8 @@ function solidPuzzlePlan(stickerDat) {
     return null;
   }
   let radius = 0;
+  let faceletArea = 0;
+  let faceletCount = 0;
   for (const sticker of stickers) {
     if (sticker.coords.length < 9 || sticker.coords.length % 3 !== 0) {
       return null;
@@ -2867,6 +2823,10 @@ function solidPuzzlePlan(stickerDat) {
     if (faceColors[sticker.face] !== sticker.color) {
       return null;
     }
+    faceletCount++;
+    for (let i = 1; i < polygon.length - 1; i++) {
+      faceletArea += new Vector37().subVectors(polygon[i], polygon[0]).cross(new Vector37().subVectors(polygon[i + 1], polygon[0])).length() / 2;
+    }
     piece.stickers.push({ sticker, polygon });
     for (let i = 0; i < polygon.length; i++) {
       const edgeKey = [
@@ -2885,16 +2845,30 @@ function solidPuzzlePlan(stickerDat) {
   if (!styles) {
     return null;
   }
-  const axes = stickerDat.axis.map(
-    (axis) => new Vector37(...axis.coordinates).normalize()
+  const featureScale = Math.min(
+    faceDistance,
+    1.5 * Math.sqrt(faceletArea / faceletCount)
   );
+  const cuts = cutPlanes(
+    order,
+    edges,
+    stickerDat.axis.map((axis) => new Vector37(...axis.coordinates).normalize()),
+    quantum
+  );
+  if (!cuts) {
+    return null;
+  }
   const plans = [];
   for (const piece of order) {
-    const plan = newSolidPiece(piece, edges, axes, {
-      quantum,
-      radius,
-      faceDistance
-    });
+    const plan = newSolidPiece(
+      piece,
+      { planes: cuts, edges },
+      {
+        quantum,
+        radius,
+        featureScale
+      }
+    );
     if (!plan) {
       return null;
     }
@@ -2902,11 +2876,74 @@ function solidPuzzlePlan(stickerDat) {
   }
   return { faceStyles: styles, pieces: plans, scale: PG_SCALE3 };
 }
-function newSolidPiece(piece, edges, axes, sizes) {
+function cutPlanes(pieces, edges, axes, quantum) {
+  const candidates = /* @__PURE__ */ new Map();
+  const boundaryEdges = [];
+  for (const piece of pieces) {
+    const pieceKey = `${piece.orbit}/${piece.ord}`;
+    for (const { polygon } of piece.stickers) {
+      for (let i = 0; i < polygon.length; i++) {
+        const a = polygon[i];
+        const b = polygon[(i + 1) % polygon.length];
+        const sharing = edges.get(
+          [keyOf(a, quantum), keyOf(b, quantum)].sort().join("|")
+        );
+        if (!sharing || ![...sharing].some((key) => key !== pieceKey)) {
+          continue;
+        }
+        boundaryEdges.push([a, b]);
+        for (const axis of axes) {
+          if (Math.abs(a.dot(axis) - b.dot(axis)) > quantum) {
+            continue;
+          }
+          const offset = a.dot(axis);
+          const key = `${keyOf(axis, 1e-4)}|${Math.round(offset / quantum)}`;
+          const candidate = candidates.get(key);
+          if (candidate) {
+            candidate.uses++;
+          } else {
+            candidates.set(key, { normal: axis, offset, uses: 1 });
+          }
+        }
+      }
+    }
+  }
+  const cuts = [...candidates.values()].sort((a, b) => b.uses - a.uses);
+  const kept = cuts.filter(({ normal: normal2, offset }) => {
+    for (const piece of pieces) {
+      let above = false;
+      let below = false;
+      for (const { polygon } of piece.stickers) {
+        let onIt = true;
+        for (const vertex of polygon) {
+          above ||= vertex.dot(normal2) > offset + quantum;
+          below ||= vertex.dot(normal2) < offset - quantum;
+          onIt &&= Math.abs(vertex.dot(normal2) - offset) <= quantum;
+        }
+        if (onIt) {
+          return false;
+        }
+      }
+      if (above && below) {
+        return false;
+      }
+    }
+    return true;
+  });
+  for (const [a, b] of boundaryEdges) {
+    const covered = kept.some(
+      ({ normal: normal2, offset }) => Math.abs(a.dot(normal2) - offset) < quantum && Math.abs(b.dot(normal2) - offset) < quantum
+    );
+    if (!covered) {
+      return null;
+    }
+  }
+  return kept;
+}
+function newSolidPiece(piece, cuts, sizes) {
   if (piece.stickers.length === 0) {
     return null;
   }
-  const pieceKey = `${piece.orbit}/${piece.ord}`;
   const planes = [];
   const planeOfSticker = /* @__PURE__ */ new Map();
   const interior = new Vector37();
@@ -2914,7 +2951,7 @@ function newSolidPiece(piece, edges, axes, sizes) {
     for (const vertex of polygon) {
       interior.addScaledVector(
         vertex,
-        0.5 / polygon.length / piece.stickers.length
+        1 / polygon.length / piece.stickers.length
       );
     }
   }
@@ -2927,88 +2964,88 @@ function newSolidPiece(piece, edges, axes, sizes) {
       color: sticker.face
     });
   }
+  const pieceKey = `${piece.orbit}/${piece.ord}`;
   for (const { polygon } of piece.stickers) {
     for (let i = 0; i < polygon.length; i++) {
       const a = polygon[i];
       const b = polygon[(i + 1) % polygon.length];
-      const edgeKey = [keyOf(a, sizes.quantum), keyOf(b, sizes.quantum)].sort().join("|");
-      const sharing = edges.get(edgeKey);
-      if (sharing && sharing.size === 1 && sharing.has(pieceKey)) {
+      const sharing = cuts.edges.get(
+        [keyOf(a, sizes.quantum), keyOf(b, sizes.quantum)].sort().join("|")
+      );
+      if (!sharing || ![...sharing].some((key) => key !== pieceKey)) {
         continue;
       }
-      const normal2 = new Vector37().crossVectors(a, b);
-      if (normal2.length() < sizes.quantum) {
-        return null;
-      }
-      normal2.normalize();
-      if (normal2.dot(interior) > 0) {
-        normal2.negate();
-      }
-      if (!axes.some((axis) => Math.abs(axis.dot(normal2)) > 0.9999)) {
+      const cut = cuts.planes.find(
+        ({ normal: normal3, offset: offset2 }) => Math.abs(a.dot(normal3) - offset2) < sizes.quantum && Math.abs(b.dot(normal3) - offset2) < sizes.quantum
+      );
+      if (!cut) {
         return null;
       }
-      for (const other of piece.stickers) {
-        for (const vertex of other.polygon) {
-          if (vertex.dot(normal2) > sizes.quantum) {
-            return null;
-          }
-        }
-      }
+      const outward = interior.dot(cut.normal) < cut.offset;
+      const normal2 = outward ? cut.normal.clone() : cut.normal.clone().negate();
+      const offset = outward ? cut.offset : -cut.offset;
       if (planes.some(
-        (plane) => plane.color === null && plane.normal.dot(normal2) > 0.9999 && Math.abs(plane.offset) < sizes.quantum
+        (plane) => plane.color === null && plane.normal.dot(normal2) > 0.9999 && Math.abs(plane.offset - offset) < sizes.quantum
       )) {
         continue;
       }
-      planes.push({ normal: normal2, offset: 0, color: null });
+      planes.push({ normal: normal2, offset, color: null });
+    }
+  }
+  for (const cut of cuts.planes) {
+    let touches = false;
+    let above = false;
+    let below = false;
+    for (const { polygon } of piece.stickers) {
+      for (const vertex of polygon) {
+        const side = vertex.dot(cut.normal) - cut.offset;
+        if (Math.abs(side) <= sizes.quantum) {
+          touches = true;
+        } else if (side > 0) {
+          above = true;
+        } else {
+          below = true;
+        }
+      }
+    }
+    if (touches || above === below) {
+      continue;
     }
+    planes.push(
+      above ? {
+        normal: cut.normal.clone().negate(),
+        offset: -cut.offset,
+        color: null
+      } : { normal: cut.normal.clone(), offset: cut.offset, color: null }
+    );
   }
   const solid = solidPieceGeometry(planes, {
-    groove: SOLID_PIECE_GROOVE * sizes.faceDistance,
-    chamfer: SOLID_PIECE_CHAMFER * sizes.faceDistance,
+    groove: SOLID_PIECE_GROOVE * sizes.featureScale,
+    chamfer: SOLID_PIECE_CHAMFER * sizes.featureScale,
     radius: sizes.radius
   });
   if (!solid) {
     return null;
   }
-  const positions = Array.from(solid.positions);
-  const normals = Array.from(solid.normals);
+  const hintPositions = [];
   const hintRanges = /* @__PURE__ */ new Map();
   for (const { sticker, polygon } of piece.stickers) {
     const normal2 = outwardNormal(polygon);
-    const hint = hintPolygon(polygon, normal2);
-    const start = positions.length / 3;
-    for (let i = 1; i < hint.length - 1; i++) {
-      for (const vertex of [hint[0], hint[i], hint[i + 1]]) {
-        positions.push(vertex.x, vertex.y, vertex.z);
-        normals.push(normal2.x, normal2.y, normal2.z);
+    const hint2 = hintPolygon(polygon, normal2);
+    const start = hintPositions.length / 3;
+    for (let i = 1; i < hint2.length - 1; i++) {
+      for (const vertex of [hint2[0], hint2[i], hint2[i + 1]]) {
+        hintPositions.push(vertex.x, vertex.y, vertex.z);
       }
     }
     hintRanges.set(sticker, {
       start,
-      count: positions.length / 3 - start
+      count: hintPositions.length / 3 - start
     });
   }
-  const vertexCount = positions.length / 3;
-  const geometry = new BufferGeometry5();
-  geometry.setAttribute(
-    "position",
-    new BufferAttribute5(new Float32Array(positions), 3)
-  );
-  geometry.setAttribute(
-    "normal",
-    new BufferAttribute5(new Float32Array(normals), 3)
-  );
-  const colors = new BufferAttribute5(new Uint8Array(4 * vertexCount), 4, true);
-  geometry.setAttribute("color", colors);
-  geometry.addGroup(0, solid.vertexCount, BODY_MATERIAL_INDEX);
-  if (vertexCount > solid.vertexCount) {
-    geometry.addGroup(
-      solid.vertexCount,
-      vertexCount - solid.vertexCount,
-      HINT_MATERIAL_INDEX
-    );
-  }
-  paintInternal(colors, solid.internalRanges);
+  const body = newPieceMesh2(solid.positions);
+  const hint = hintPositions.length > 0 ? newPieceMesh2(new Float32Array(hintPositions)) : null;
+  paintInternal(body.colors, solid.internalRanges);
   const facelets = piece.stickers.map(({ sticker }) => ({
     ori: sticker.ori,
     faceStyle: sticker.face,
@@ -3028,18 +3065,29 @@ function newSolidPiece(piece, edges, axes, sizes) {
     ord: piece.ord,
     // The geometry is already where the piece belongs.
     home: new Matrix43(),
-    geometry,
-    colors,
+    body,
+    hint,
     facelets
   };
 }
+function newPieceMesh2(positions) {
+  const geometry = new BufferGeometry5();
+  geometry.setAttribute("position", new BufferAttribute5(positions, 3));
+  const colors = new BufferAttribute5(
+    new Uint8Array(4 * positions.length / 3),
+    4,
+    true
+  );
+  geometry.setAttribute("color", colors);
+  return { geometry, colors };
+}
 
 // src/cubing/twisty/views/3D/puzzles/Square1_3D.ts
 import { DoubleSide as DoubleSide3 } from "three/src/constants.js";
 import { BufferAttribute as BufferAttribute6 } from "three/src/core/BufferAttribute.js";
 import { BufferGeometry as BufferGeometry6 } from "three/src/core/BufferGeometry.js";
 import { Object3D as Object3D3 } from "three/src/core/Object3D.js";
-import { MeshBasicMaterial as MeshBasicMaterial3 } from "three/src/materials/MeshBasicMaterial.js";
+import { MeshBasicMaterial as MeshBasicMaterial4 } from "three/src/materials/MeshBasicMaterial.js";
 import { Color as Color5 } from "three/src/math/Color.js";
 import { Quaternion as Quaternion2 } from "three/src/math/Quaternion.js";
 import { Vector3 as Vector38 } from "three/src/math/Vector3.js";
@@ -3297,11 +3345,10 @@ function stickerlessPieceGeometry(spec) {
   }
   const geometry = new BufferGeometry6();
   geometry.setAttribute("position", new BufferAttribute6(piece.positions, 3));
-  geometry.setAttribute("normal", new BufferAttribute6(piece.normals, 3));
   geometry.setAttribute("color", new BufferAttribute6(colors, 4, true));
   return geometry;
 }
-var bodyMaterial = new MeshBasicMaterial3({
+var bodyMaterial = new MeshBasicMaterial4({
   color: new Color5(BODY_COLOR).convertLinearToSRGB(),
   side: DoubleSide3
 });
@@ -3313,7 +3360,7 @@ var stickerMaterialCache = /* @__PURE__ */ new Map();
 function stickerMaterial(color) {
   let material = stickerMaterialCache.get(color);
   if (!material) {
-    material = new MeshBasicMaterial3({
+    material = new MeshBasicMaterial4({
       color: new Color5(color).convertLinearToSRGB(),
       side: DoubleSide3
     });
@@ -3468,9 +3515,6 @@ var Square1_3D = class extends Object3D3 {
       this.#equatorPieces.push(equator);
       this.add(equator);
     }
-    if (this.#stickerless) {
-      addCubieBodyLighting(this);
-    }
     this.scale.set(PUZZLE_SCALE, PUZZLE_SCALE, PUZZLE_SCALE);
   }
   scheduleRenderCallback;
@@ -3610,11 +3654,29 @@ import { BackSide as BackSide2 } from "three/src/constants.js";
 import { BufferAttribute as BufferAttribute7 } from "three/src/core/BufferAttribute.js";
 import { BufferGeometry as BufferGeometry7 } from "three/src/core/BufferGeometry.js";
 import { Object3D as Object3D4 } from "three/src/core/Object3D.js";
-import { MeshBasicMaterial as MeshBasicMaterial4 } from "three/src/materials/MeshBasicMaterial.js";
+import { MeshBasicMaterial as MeshBasicMaterial5 } from "three/src/materials/MeshBasicMaterial.js";
 import { Matrix4 as Matrix44 } from "three/src/math/Matrix4.js";
 import { Vector3 as Vector39 } from "three/src/math/Vector3.js";
+import { BatchedMesh } from "three/src/objects/BatchedMesh.js";
 import { Mesh as Mesh4 } from "three/src/objects/Mesh.js";
-var invisibleMaterial2 = new MeshBasicMaterial4({ visible: false });
+var invisibleMaterial2 = new MeshBasicMaterial5({ visible: false });
+function newBatch(meshes, material) {
+  let vertices = 0;
+  let indices = 0;
+  for (const { geometry } of meshes) {
+    vertices += geometry.getAttribute("position").count;
+    indices += geometry.getIndex()?.count ?? 0;
+  }
+  return new BatchedMesh(meshes.length, vertices, indices, material);
+}
+function addToBatch(batch, mesh, home) {
+  const geometryId = batch.addGeometry(mesh.geometry);
+  const instance = batch.addInstance(geometryId);
+  batch.setMatrixAt(instance, home);
+  mesh.geometry.dispose();
+  const range = batch.getGeometryRangeAt(geometryId);
+  return { instance, vertexStart: range.vertexStart };
+}
 var Stickerless3D = class extends Object3D4 {
   constructor(scheduleRenderCallback, kpuzzle, stickerDat, plan, options = {}) {
     super();
@@ -3622,7 +3684,7 @@ var Stickerless3D = class extends Object3D4 {
     this.kpuzzle = kpuzzle;
     this.stickerDat = stickerDat;
     this.plan = plan;
-    this.#hintMaterial = new MeshBasicMaterial4({
+    this.#hintMaterial = new MeshBasicMaterial5({
       vertexColors: true,
       transparent: true,
       // Hint facelets show the faces turned away from the camera, so they are
@@ -3630,20 +3692,35 @@ var Stickerless3D = class extends Object3D4 {
       side: BackSide2
     });
     this.#bodyMaterial = newVertexColorBodyMaterial();
-    this.#materials = [this.#bodyMaterial, this.#hintMaterial];
-    this.experimentalUpdateOptions({
-      hintFacelets: options.hintFacelets ?? "floating"
-    });
     for (const axis of stickerDat.axis) {
       this.#axesInfo[axis.quantumMove.family] = {
         axis: new Vector39(...axis.coordinates),
         order: axis.order
       };
     }
+    this.#bodyBatch = newBatch(
+      plan.pieces.map((piecePlan) => piecePlan.body),
+      this.#bodyMaterial
+    );
+    this.#bodyBatch.sortObjects = false;
+    this.#bodyBatch.perObjectFrustumCulled = false;
+    this.add(this.#bodyBatch);
+    const hints = plan.pieces.map((piecePlan) => piecePlan.hint).filter((hint) => hint !== null);
+    if (hints.length > 0) {
+      this.#hintBatch = newBatch(hints, this.#hintMaterial);
+      this.#hintBatch.perObjectFrustumCulled = false;
+      this.add(this.#hintBatch);
+    }
     for (const piecePlan of plan.pieces) {
       this.#addPiece(piecePlan);
     }
-    addCubieBodyLighting(this);
+    this.#bodyColors = this.#bodyBatch.geometry.getAttribute(
+      "color"
+    );
+    this.#hintColors = this.#hintBatch?.geometry.getAttribute("color") ?? null;
+    this.experimentalUpdateOptions({
+      hintFacelets: options.hintFacelets ?? "floating"
+    });
     for (const face2 of stickerDat.faces) {
       this.#addControlTarget(face2);
     }
@@ -3657,11 +3734,19 @@ var Stickerless3D = class extends Object3D4 {
   stickerDat;
   plan;
   #pieces = [];
+  /**
+   * One draw call for every piece of the puzzle, and one for every hint
+   * facelet. A batch keeps a matrix per instance, so a move still moves the
+   * pieces it sweeps and nothing else.
+   */
+  #bodyBatch;
+  #hintBatch = null;
+  #bodyColors;
+  #hintColors = null;
   /** Indexed `[orbit][ori][ord]`, like the orbits of the `KPuzzle`. */
   #facelets = {};
   #axesInfo = {};
   #controlTargets = [];
-  #materials;
   #bodyMaterial;
   #hintMaterial;
   #appearances = /* @__PURE__ */ new Map();
@@ -3669,29 +3754,44 @@ var Stickerless3D = class extends Object3D4 {
   #turningPieces = [];
   /** Which pieces each quantum move sweeps, by the move's notation. */
   #turnedPieces = /* @__PURE__ */ new Map();
-  #dirtyColors = /* @__PURE__ */ new Set();
+  /** The span of each color attribute that changed, so only it is uploaded. */
+  #dirtyColors = /* @__PURE__ */ new Map();
   #lastPosition = null;
   #pendingStickeringUpdate = false;
   #addPiece(plan) {
-    const mesh = new Mesh4(plan.geometry, this.#materials);
-    mesh.matrixAutoUpdate = false;
-    mesh.matrix.copy(plan.home);
-    this.add(mesh);
-    const piece = { mesh, colors: plan.colors, home: plan.home };
+    const bodyInstance = addToBatch(this.#bodyBatch, plan.body, plan.home);
+    const hintInstance = plan.hint && this.#hintBatch ? addToBatch(this.#hintBatch, plan.hint, plan.home) : -1;
+    const piece = {
+      bodyInstance: bodyInstance.instance,
+      hintInstance: hintInstance === -1 ? -1 : hintInstance.instance,
+      home: plan.home,
+      matrix: plan.home.clone(),
+      turning: false
+    };
     this.#pieces.push(piece);
+    const shift = (ranges, offset) => ranges.map((range) => ({
+      start: range.start + offset,
+      count: range.count
+    }));
     const orbitFacelets = this.#facelets[plan.orbit] ??= [];
     for (const facelet of plan.facelets) {
       (orbitFacelets[facelet.ori] ??= [])[plan.ord] = {
         piece,
         faceStyle: facelet.faceStyle,
-        body: facelet.body,
-        hint: facelet.hint,
+        body: shift(facelet.body, bodyInstance.vertexStart),
+        hint: hintInstance === -1 ? [] : shift(facelet.hint, hintInstance.vertexStart),
         appearanceKey: -1,
         mask: "regular",
         hintMask: "regular"
       };
     }
   }
+  #setMatrix(piece) {
+    this.#bodyBatch.setMatrixAt(piece.bodyInstance, piece.matrix);
+    if (piece.hintInstance !== -1) {
+      this.#hintBatch.setMatrixAt(piece.hintInstance, piece.matrix);
+    }
+  }
   #addControlTarget(face2) {
     const { coords } = face2;
     const triangles = coords.length / 3 - 2;
@@ -3716,9 +3816,10 @@ var Stickerless3D = class extends Object3D4 {
     this.#controlTargets.push(mesh);
   }
   dispose() {
-    for (const piece of this.#pieces) {
-      piece.mesh.geometry.dispose();
-    }
+    this.#bodyBatch.dispose();
+    this.#bodyBatch.geometry.dispose();
+    this.#hintBatch?.dispose();
+    this.#hintBatch?.geometry.dispose();
     this.#bodyMaterial.dispose();
     this.#hintMaterial.dispose();
   }
@@ -3809,8 +3910,8 @@ var Stickerless3D = class extends Object3D4 {
   }
   /** @deprecated */
   experimentalUpdateOptions(options) {
-    if (options.hintFacelets !== void 0) {
-      this.#materials[HINT_MATERIAL_INDEX] = options.hintFacelets === "none" ? invisibleMaterial2 : this.#hintMaterial;
+    if (options.hintFacelets !== void 0 && this.#hintBatch) {
+      this.#hintBatch.visible = options.hintFacelets !== "none";
       this.scheduleRenderCallback();
     }
   }
@@ -3829,10 +3930,11 @@ var Stickerless3D = class extends Object3D4 {
       this.#lastPosition = position;
       this.#pendingStickeringUpdate = false;
     }
-    for (const piece of this.#turningPieces) {
-      piece.mesh.matrix.copy(piece.home);
+    const wereTurning = this.#turningPieces;
+    for (const piece of wereTurning) {
+      piece.turning = false;
     }
-    this.#turningPieces.length = 0;
+    this.#turningPieces = [];
     const turnMatrix = new Matrix44();
     for (const moveProgress of position.movesInProgress) {
       const move = moveProgress.move;
@@ -3849,10 +3951,23 @@ var Stickerless3D = class extends Object3D4 {
         -smootherStep(moveProgress.fraction) * moveProgress.direction * unswizzled.amount * TAU / axisInfo.order
       );
       for (const piece of this.#piecesTurnedBy(move)) {
-        piece.mesh.matrix.premultiply(turnMatrix);
-        this.#turningPieces.push(piece);
+        if (!piece.turning) {
+          piece.turning = true;
+          piece.matrix.copy(piece.home);
+          this.#turningPieces.push(piece);
+        }
+        piece.matrix.premultiply(turnMatrix);
       }
     }
+    for (const piece of wereTurning) {
+      if (!piece.turning) {
+        piece.matrix.copy(piece.home);
+        this.#setMatrix(piece);
+      }
+    }
+    for (const piece of this.#turningPieces) {
+      this.#setMatrix(piece);
+    }
     this.scheduleRenderCallback();
   }
   /**
@@ -3935,17 +4050,34 @@ var Stickerless3D = class extends Object3D4 {
             source.mask,
             source.hintMask
           );
-          writeColor(slot.piece.colors, slot.body, appearance);
-          writeColor(slot.piece.colors, slot.hint, appearance, 4);
-          this.#dirtyColors.add(slot.piece.colors);
+          this.#paint(this.#bodyColors, slot.body, appearance, 0);
+          if (this.#hintColors) {
+            this.#paint(this.#hintColors, slot.hint, appearance, 4);
+          }
         }
       }
     }
-    for (const colors of this.#dirtyColors) {
+    for (const [colors, span] of this.#dirtyColors) {
+      colors.addUpdateRange(4 * span.first, 4 * (span.last - span.first + 1));
       colors.needsUpdate = true;
     }
     this.#dirtyColors.clear();
   }
+  #paint(colors, ranges, appearance, offset) {
+    if (ranges.length === 0) {
+      return;
+    }
+    writeColor(colors, ranges, appearance, offset);
+    let span = this.#dirtyColors.get(colors);
+    if (!span) {
+      span = { first: Number.POSITIVE_INFINITY, last: 0 };
+      this.#dirtyColors.set(colors, span);
+    }
+    for (const range of ranges) {
+      span.first = Math.min(span.first, range.start);
+      span.last = Math.max(span.last, range.start + range.count - 1);
+    }
+  }
 };
 
 // src/cubing/twisty/heavy-code-imports/dynamic-entries/twisty-dynamic-3d.ts
@@ -4033,4 +4165,4 @@ export {
   pg3dShim,
   square1_3DShim
 };
-//# sourceMappingURL=twisty-dynamic-3d-SLKSUJTE.js.map
+//# sourceMappingURL=twisty-dynamic-3d-MF76FSDA.js.map