@rednaxela101/cubing 0.63.7 → 0.63.8

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

@@ -3,7 +3,7 @@ import {
   bulk3DCode,
   haveStartedSharingRenderers,
   hintFaceletStyles
-} from "./chunk-GP66KY36.js";
+} from "./chunk-B2YKAP2I.js";
 import "./chunk-3ODTF4HE.js";
 import {
   cube3x3x3,
@@ -16,18 +16,17 @@ import {
 
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
 import { BackSide, DoubleSide, FrontSide } from "three/src/constants.js";
-import { BufferAttribute } from "three/src/core/BufferAttribute.js";
-import { BufferGeometry } from "three/src/core/BufferGeometry.js";
+import { BufferAttribute as BufferAttribute2 } from "three/src/core/BufferAttribute.js";
+import { BufferGeometry as BufferGeometry2 } from "three/src/core/BufferGeometry.js";
 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 { Color } from "three/src/math/Color.js";
-import { Euler } from "three/src/math/Euler.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";
 import { Vector2 } from "three/src/math/Vector2.js";
-import { Vector3 } from "three/src/math/Vector3.js";
+import { Vector3 as Vector33 } from "three/src/math/Vector3.js";
 import { Group } from "three/src/objects/Group.js";
 import { Mesh } from "three/src/objects/Mesh.js";
 
@@ -36,56 +35,339 @@ function smootherStep(x) {
   return x * x * x * (10 - x * (15 - 6 * x));
 }
 
+// src/cubing/twisty/views/3D/puzzles/BeveledCubieGeometry.ts
+import { BufferAttribute } from "three/src/core/BufferAttribute.js";
+import { BufferGeometry } from "three/src/core/BufferGeometry.js";
+import { Vector3 } from "three/src/math/Vector3.js";
+function clamp(value, bound) {
+  return Math.min(Math.max(value, -bound), bound);
+}
+function component(vector, axis) {
+  return axis === 0 ? vector.x : axis === 1 ? vector.y : vector.z;
+}
+function setComponent(vector, axis, value) {
+  if (axis === 0) {
+    vector.x = value;
+  } else if (axis === 1) {
+    vector.y = value;
+  } else {
+    vector.z = value;
+  }
+}
+function beveledCubieGeometry(faceNormals, outerFaceIndices, halfSize, outerAxisRadius, innerEdgeRadius, innerCornerRadius, cornerSharpness, segments) {
+  const allRadii = [outerAxisRadius, innerEdgeRadius, innerCornerRadius];
+  const maxRadius = Math.max(...allRadii);
+  if (!(Math.min(...allRadii) > 0 && maxRadius < halfSize)) {
+    throw new Error(
+      "Every radius must be positive and smaller than the half-size."
+    );
+  }
+  if (cornerSharpness <= 0 || segments < 1) {
+    throw new Error(
+      "The corner sharpness must be positive, with at least one segment."
+    );
+  }
+  const outward = [
+    [0, 0],
+    [0, 0],
+    [0, 0]
+  ];
+  for (let faceIdx = 0; faceIdx < faceNormals.length; faceIdx++) {
+    const normal2 = faceNormals[faceIdx];
+    const axis = Math.abs(normal2.x) > 0.5 ? 0 : Math.abs(normal2.y) > 0.5 ? 1 : 2;
+    outward[axis][component(normal2, axis) > 0 ? 1 : 0] = outerFaceIndices.includes(faceIdx) ? 1 : 0;
+  }
+  const inner = halfSize - maxRadius;
+  const samples = [];
+  for (let i = 0; i <= segments; i++) {
+    samples.push(-halfSize + maxRadius * i / segments);
+  }
+  for (let i = 0; i <= segments; i++) {
+    samples.push(inner + maxRadius * i / segments);
+  }
+  const gridSize = samples.length;
+  const positions = [];
+  const normals = [];
+  const indices = [];
+  const geometry = new BufferGeometry();
+  const point = new Vector3();
+  const core = new Vector3();
+  const offset = new Vector3();
+  const u = new Vector3();
+  const v = new Vector3();
+  const radii = new Vector3();
+  const outerness = [0, 0, 0];
+  const radiiAt = (p, out) => {
+    const towardCorner = (Math.abs(p.x) * Math.abs(p.y) * Math.abs(p.z) / (halfSize * halfSize * halfSize)) ** cornerSharpness;
+    let outwardFaceCount = 0;
+    for (let axis = 0; axis < 3; axis++) {
+      const towardPositive = (component(p, axis) / halfSize + 1) / 2;
+      outerness[axis] = towardPositive * outward[axis][1] + (1 - towardPositive) * outward[axis][0];
+      outwardFaceCount += outerness[axis];
+    }
+    const interiorCorner = Math.min(Math.max(2 - outwardFaceCount, 0), 1);
+    for (let axis = 0; axis < 3; axis++) {
+      const alongEdge = innerEdgeRadius + (outerAxisRadius - innerEdgeRadius) * outerness[axis];
+      const atCorner = innerCornerRadius + (outerAxisRadius - innerCornerRadius) * outerness[axis];
+      setComponent(
+        out,
+        axis,
+        alongEdge + (atCorner - alongEdge) * towardCorner * interiorCorner
+      );
+    }
+  };
+  for (let faceIdx = 0; faceIdx < faceNormals.length; faceIdx++) {
+    const normal2 = faceNormals[faceIdx];
+    u.set(normal2.y, normal2.z, normal2.x);
+    v.crossVectors(normal2, u);
+    const vertexStart = positions.length / 3;
+    for (let i = 0; i < gridSize; i++) {
+      for (let j = 0; j < gridSize; j++) {
+        point.copy(u).multiplyScalar(samples[i]).addScaledVector(v, samples[j]).addScaledVector(normal2, halfSize);
+        radiiAt(point, radii);
+        core.set(
+          clamp(point.x, halfSize - radii.x),
+          clamp(point.y, halfSize - radii.y),
+          clamp(point.z, halfSize - radii.z)
+        );
+        offset.set(
+          (point.x - core.x) / radii.x,
+          (point.y - core.y) / radii.y,
+          (point.z - core.z) / radii.z
+        ).normalize();
+        positions.push(
+          core.x + offset.x * radii.x,
+          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;
+    for (let i = 0; i < gridSize - 1; i++) {
+      for (let j = 0; j < gridSize - 1; j++) {
+        const a = vertexStart + i * gridSize + j;
+        const b = a + gridSize;
+        indices.push(a, b, b + 1, a, b + 1, a + 1);
+      }
+    }
+    geometry.addGroup(indexStart, indices.length - indexStart, faceIdx);
+  }
+  geometry.setAttribute(
+    "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 { 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";
+var cubeFaceStyles = [
+  {
+    vector: new Vector32(0, 1, 0),
+    fromZ: new Euler(-TAU / 4, 0, 0),
+    color: 16777215,
+    dimColor: 14540253,
+    hintColor: 16777215,
+    hintDimColor: 14540253,
+    hintOpacityScale: 1.25
+  },
+  {
+    vector: new Vector32(-1, 0, 0),
+    fromZ: new Euler(0, -TAU / 4, 0),
+    color: 16750848,
+    dimColor: 8934656,
+    hintColor: 16750848,
+    hintDimColor: 8930304,
+    hintOpacityScale: 1
+  },
+  {
+    vector: new Vector32(0, 0, 1),
+    fromZ: new Euler(0, 0, 0),
+    color: 65280,
+    dimColor: 34816,
+    hintColor: 65280,
+    hintDimColor: 39168,
+    hintOpacityScale: 1
+  },
+  {
+    vector: new Vector32(1, 0, 0),
+    fromZ: new Euler(0, TAU / 4, 0),
+    color: 16711680,
+    dimColor: 6684672,
+    hintColor: 16711680,
+    hintDimColor: 6684672,
+    hintOpacityScale: 1
+  },
+  {
+    vector: new Vector32(0, 0, -1),
+    fromZ: new Euler(0, TAU / 2, 0),
+    color: 2254591,
+    dimColor: 1127304,
+    hintColor: 2254591,
+    hintDimColor: 6246,
+    hintOpacityScale: 0.75
+  },
+  {
+    vector: new Vector32(0, -1, 0),
+    fromZ: new Euler(TAU / 4, 0, 0),
+    color: 16776960,
+    dimColor: 8947712,
+    hintColor: 16776960,
+    hintDimColor: 14540032,
+    hintOpacityScale: 1.25
+  }
+];
+var cubieBodyDimensions = {
+  /**
+   * Half-width of a `stickerless` cubie body. Deliberately more than the 0.5
+   * that would make pieces exactly fill their slot: oversized pieces press into
+   * each other, which buries most of each rounded edge inside its neighbor and
+   * keeps the dividing lines thin.
+   */
+  halfWidth: 0.54,
+  /**
+   * Roll at the rim of a facelet, along the axis the facelet faces — so also
+   * the rounding of the puzzle's own outer edges and corners. Effectively zero,
+   * which leaves those edges sharp and the plates dead flat.
+   *
+   * Not exactly zero: the construction lifts each face off the core box along
+   * this axis, so a true zero leaves nothing to normalize in the middle of a
+   * face. A few thousandths is below a pixel at any sane size.
+   */
+  outerAxisRadius: 4e-3,
+  /**
+   * Rounding along an axis pointing at a neighboring piece, in the middle of an
+   * edge. Sets how wide the dividing line between two pieces reads.
+   */
+  innerEdgeRadius: 0.07,
+  /**
+   * The same axis at a corner. This one rounds a facelet's corners within its
+   * own plane, so it is what turns a center into a disc, and it costs no
+   * thickness because the roll stays `outerAxisRadius` deep.
+   */
+  innerCornerRadius: 0.34,
+  /** How tightly the corner rounding is pulled in toward the corners. */
+  cornerSharpness: 1.3,
+  /**
+   * Everything above, shrunk about each piece's own center. Scaling rather than
+   * trimming the half-width leaves every proportion of the piece untouched and
+   * only opens a gap against its neighbors, so the pieces read as separate with
+   * a thin line of the puzzle's interior showing between them.
+   */
+  pieceScale: 0.95,
+  roundingSegments: 7
+};
+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()
+  });
+}
+function newVertexColorBodyMaterial() {
+  const material = newBodyMaterial(16777215);
+  material.vertexColors = true;
+  return material;
+}
+var bodyMaskColors = {
+  /** The plastic that shows through the grooves between pieces. */
+  internal: 921102,
+  ignored: 6710886,
+  oriented: 4513228,
+  experimentalOriented2: 16776618,
+  mystery: 15911883
+};
+var hintMaskStyles = {
+  ignored: { color: 13421772, opacity: 0.75 },
+  oriented: { color: 4513228, opacity: 0.5 },
+  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({
+    color: new Color2(style.color).convertLinearToSRGB(),
+    side: BackSide,
+    transparent: true,
+    opacity: style.opacity
+  });
+}
 var ignoredMaterial = new MeshBasicMaterial({
-  color: new Color(6710886).convertLinearToSRGB()
-});
-var ignoredMaterialHint = new MeshBasicMaterial({
-  color: new Color(13421772).convertLinearToSRGB(),
-  side: BackSide,
-  transparent: true,
-  opacity: 0.75
+  color: new Color2(bodyMaskColors.ignored).convertLinearToSRGB()
 });
+var ignoredMaterialHint = newHintMaterial(hintMaskStyles.ignored);
 var invisibleMaterial = new MeshBasicMaterial({
   visible: false
 });
 var orientedMaterial = new MeshBasicMaterial({
-  color: 4513228
-});
-var orientedMaterialHint = new MeshBasicMaterial({
-  color: 4513228,
-  side: BackSide,
-  transparent: true,
-  opacity: 0.5
+  color: bodyMaskColors.oriented
 });
+var orientedMaterialHint = newHintMaterial(hintMaskStyles.oriented);
 var experimentalOriented2Material = new MeshBasicMaterial({
-  color: 16776618
-});
-var experimentalOriented2MaterialHint = new MeshBasicMaterial({
-  color: 16775545,
-  side: BackSide,
-  transparent: true,
-  opacity: 0.5
+  color: bodyMaskColors.experimentalOriented2
 });
+var experimentalOriented2MaterialHint = newHintMaterial(
+  hintMaskStyles.experimentalOriented2
+);
 var mysteryMaterial = new MeshBasicMaterial({
-  color: 15911883
-});
-var mysterMaterialHint = new MeshBasicMaterial({
-  color: 15911883,
-  side: BackSide,
-  transparent: true,
-  opacity: 0.5
+  color: bodyMaskColors.mystery
 });
+var mysterMaterialHint = newHintMaterial(hintMaskStyles.mystery);
+var internalBodyMaterial = newBodyMaterial(bodyMaskColors.internal);
+var ignoredBodyMaterial = newBodyMaterial(bodyMaskColors.ignored);
+var orientedBodyMaterial = newBodyMaterial(bodyMaskColors.oriented);
+var experimentalOriented2BodyMaterial = newBodyMaterial(
+  bodyMaskColors.experimentalOriented2
+);
+var mysteryBodyMaterial = newBodyMaterial(bodyMaskColors.mystery);
 var AxisInfo = class {
-  constructor(vector, fromZ, color, dimColor, hintOpacityScale, options) {
-    this.vector = vector;
-    this.fromZ = fromZ;
-    this.color = color;
-    this.dimColor = dimColor;
-    this.hintOpacityScale = hintOpacityScale;
-    const colorLinearSRGB = new Color(color).convertLinearToSRGB();
-    const dimColorLinearSRGB = new Color(dimColor).convertLinearToSRGB();
+  vector;
+  fromZ;
+  stickerMaterial;
+  hintStickerMaterial;
+  bodyMaterial;
+  constructor(style) {
+    const { color, dimColor, hintOpacityScale } = style;
+    this.vector = style.vector;
+    this.fromZ = style.fromZ;
+    const colorLinearSRGB = new Color2(color).convertLinearToSRGB();
+    const dimColorLinearSRGB = new Color2(dimColor).convertLinearToSRGB();
     this.stickerMaterial = {
       regular: new MeshBasicMaterial({
         color: colorLinearSRGB,
@@ -104,18 +386,12 @@ var AxisInfo = class {
       mystery: mysteryMaterial
     };
     this.hintStickerMaterial = {
-      regular: new MeshBasicMaterial({
-        color: new Color(options?.hintColor ?? color).convertLinearToSRGB(),
-        side: BackSide,
-        transparent: true,
+      regular: newHintMaterial({
+        color: style.hintColor,
         opacity: 0.5 * hintOpacityScale
       }),
-      dim: new MeshBasicMaterial({
-        color: new Color(
-          options?.hintDimColor ?? dimColor
-        ).convertLinearToSRGB(),
-        side: BackSide,
-        transparent: true,
+      dim: newHintMaterial({
+        color: style.hintDimColor,
         opacity: 0.5 * hintOpacityScale
       }),
       oriented: orientedMaterialHint,
@@ -124,64 +400,20 @@ var AxisInfo = class {
       invisible: invisibleMaterial,
       mystery: mysterMaterialHint
     };
+    this.bodyMaterial = {
+      regular: newBodyMaterial(colorLinearSRGB),
+      dim: newBodyMaterial(dimColorLinearSRGB),
+      oriented: orientedBodyMaterial,
+      experimentalOriented2: experimentalOriented2BodyMaterial,
+      ignored: ignoredBodyMaterial,
+      // A solid piece of plastic can't have a hole punched in it, so an
+      // invisible facelet falls back to the internal plastic color.
+      invisible: internalBodyMaterial,
+      mystery: mysteryBodyMaterial
+    };
   }
-  vector;
-  fromZ;
-  color;
-  dimColor;
-  hintOpacityScale;
-  stickerMaterial;
-  hintStickerMaterial;
 };
-var axesInfo = [
-  new AxisInfo(
-    new Vector3(0, 1, 0),
-    new Euler(-TAU / 4, 0, 0),
-    16777215,
-    14540253,
-    1.25
-  ),
-  new AxisInfo(
-    new Vector3(-1, 0, 0),
-    new Euler(0, -TAU / 4, 0),
-    16750848,
-    8934656,
-    1,
-    { hintDimColor: 8930304 }
-  ),
-  new AxisInfo(
-    new Vector3(0, 0, 1),
-    new Euler(0, 0, 0),
-    65280,
-    34816,
-    1,
-    { hintDimColor: 39168 }
-  ),
-  new AxisInfo(
-    new Vector3(1, 0, 0),
-    new Euler(0, TAU / 4, 0),
-    16711680,
-    6684672,
-    1,
-    { hintDimColor: 6684672 }
-  ),
-  new AxisInfo(
-    new Vector3(0, 0, -1),
-    new Euler(0, TAU / 2, 0),
-    2254591,
-    1127304,
-    0.75,
-    { hintDimColor: 6246 }
-  ),
-  new AxisInfo(
-    new Vector3(0, -1, 0),
-    new Euler(TAU / 4, 0, 0),
-    16776960,
-    8947712,
-    1.25,
-    { hintDimColor: 14540032 }
-  )
-];
+var axesInfo = cubeFaceStyles.map((style) => new AxisInfo(style));
 var face = {
   U: 0,
   L: 1,
@@ -226,11 +458,19 @@ var cubieDimensions = {
   // stickerWidth: 0.85, // Now `faceletScale` in options.
   stickerElevation: 0.503,
   foundationWidth: 1,
-  defaultHintStickerElevation: 1.45
+  defaultHintStickerElevation: 1.45,
+  /**
+   * How far back the eight corners of a `stickerless` cubie are shaved, from 0
+   * (not at all) to 1 (all the way back to the edges). This is the only knob
+   * that widens the notch where four pieces meet without also widening the
+   * straight dividing lines.
+   */
+  bodyVertexCut: 0.45
 };
 var EXPERIMENTAL_PICTURE_CUBE_HINT_ELEVATION = 2;
 var cube3DOptionsDefaults = {
   showMainStickers: true,
+  experimentalCubieStyle: "stickerless",
   hintFacelets: "floating",
   showFoundation: true,
   experimentalStickeringMask: void 0,
@@ -275,18 +515,18 @@ function t(v, t4) {
   return new Quaternion().setFromAxisAngle(v, TAU * t4 / 4);
 }
 var r = {
-  O: new Vector3(0, 0, 0),
-  U: new Vector3(0, -1, 0),
-  L: new Vector3(1, 0, 0),
-  F: new Vector3(0, 0, -1),
-  R: new Vector3(-1, 0, 0),
-  B: new Vector3(0, 0, 1),
-  D: new Vector3(0, 1, 0)
+  O: new Vector33(0, 0, 0),
+  U: new Vector33(0, -1, 0),
+  L: new Vector33(1, 0, 0),
+  F: new Vector33(0, 0, -1),
+  R: new Vector33(-1, 0, 0),
+  B: new Vector33(0, 0, 1),
+  D: new Vector33(0, 1, 0)
 };
 var firstPiecePosition = {
-  EDGES: new Vector3(0, 1, 1),
-  CORNERS: new Vector3(1, 1, 1),
-  CENTERS: new Vector3(0, 1, 0)
+  EDGES: new Vector33(0, 1, 1),
+  CORNERS: new Vector33(1, 1, 1),
+  CENTERS: new Vector33(0, 1, 0)
 };
 var orientationRotation = {
   EDGES: [0, 1].map(
@@ -344,6 +584,9 @@ var pieceDefs = {
   ]
 };
 var CUBE_SCALE = 1 / 3;
+function cubeScale(stickerless) {
+  return stickerless ? 0.5 / cubieBodyHalfExtent(3) : CUBE_SCALE;
+}
 var pictureStickerCoords = {
   EDGES: [
     [
@@ -455,11 +698,11 @@ function sharedCubieFoundationGeometry() {
   ));
 }
 function newStickerGeometry() {
-  const r2 = new BufferGeometry();
+  const r2 = new BufferGeometry2();
   const half = 0.5;
   r2.setAttribute(
     "position",
-    new BufferAttribute(
+    new BufferAttribute2(
       new Float32Array([
         half,
         half,
@@ -485,7 +728,7 @@ function newStickerGeometry() {
   );
   r2.setAttribute(
     "uv",
-    new BufferAttribute(
+    new BufferAttribute2(
       new Float32Array([
         1,
         1,
@@ -517,6 +760,26 @@ function newStickerGeometry() {
   );
   return r2;
 }
+var cubieBodyGeometryCache = /* @__PURE__ */ new Map();
+function cubieBodyGeometry(orbit, outerAxes) {
+  const cached = cubieBodyGeometryCache.get(orbit);
+  if (cached) {
+    return cached;
+  }
+  const scale = cubieBodyDimensions.pieceScale;
+  const geometry = beveledCubieGeometry(
+    axesInfo.map((axisInfo) => axisInfo.vector),
+    outerAxes,
+    cubieBodyDimensions.halfWidth * scale,
+    cubieBodyDimensions.outerAxisRadius * scale,
+    cubieBodyDimensions.innerEdgeRadius * scale,
+    cubieBodyDimensions.innerCornerRadius * scale,
+    cubieBodyDimensions.cornerSharpness,
+    cubieBodyDimensions.roundingSegments
+  );
+  cubieBodyGeometryCache.set(orbit, geometry);
+  return geometry;
+}
 var sharedStickerGeometryCache;
 function sharedStickerGeometry() {
   return sharedStickerGeometryCache ??= newStickerGeometry();
@@ -547,7 +810,11 @@ var Cube3D = class extends Object3D {
         this.createCubie.bind(this, orbit, orbitFaceletInfo)
       );
     }
-    this.scale.set(CUBE_SCALE, CUBE_SCALE, CUBE_SCALE);
+    if (this.#stickerless()) {
+      addCubieBodyLighting(this);
+    }
+    const scale = cubeScale(this.#stickerless());
+    this.scale.set(scale, scale, scale);
     if (this.options.experimentalStickeringMask) {
       this.setStickeringMask(this.options.experimentalStickeringMask);
     }
@@ -654,12 +921,24 @@ var Cube3D = class extends Object3D {
   experimentalSetHintStickerSpriteURL(hintStickerSpriteURL) {
     this.#setHintSpriteURL?.(hintStickerSpriteURL);
   }
+  #stickerless() {
+    return this.options.experimentalCubieStyle === "stickerless";
+  }
+  #setFaceletMaterial(faceletInfo, mask) {
+    const axisInfo = axesInfo[faceletInfo.faceIdx];
+    const { bodyMaterialIndex } = faceletInfo;
+    if (bodyMaterialIndex === void 0) {
+      faceletInfo.facelet.material = axisInfo.stickerMaterial[mask];
+    } else {
+      faceletInfo.facelet.material[bodyMaterialIndex] = axisInfo.bodyMaterial[mask];
+    }
+  }
   setStickeringMask(stickeringMask) {
     if (stickeringMask.specialBehaviour === "picture") {
       for (const pieceInfos of Object.values(this.kpuzzleFaceletInfo)) {
         for (const faceletInfos of pieceInfos) {
           for (const faceletInfo of faceletInfos) {
-            faceletInfo.facelet.material = invisibleMaterial;
+            this.#setFaceletMaterial(faceletInfo, "invisible");
             const { hintFacelet } = faceletInfo;
             if (hintFacelet) {
               hintFacelet.material = invisibleMaterial;
@@ -682,7 +961,7 @@ var Cube3D = class extends Object3D {
             if (faceletStickeringMask) {
               const faceletInfo = pieceInfo[faceletIdx];
               const stickeringMask2 = typeof faceletStickeringMask === "string" ? faceletStickeringMask : faceletStickeringMask?.mask;
-              faceletInfo.facelet.material = axesInfo[faceletInfo.faceIdx].stickerMaterial[stickeringMask2];
+              this.#setFaceletMaterial(faceletInfo, stickeringMask2);
               const hintStickeringMask = typeof faceletStickeringMask === "string" ? stickeringMask2 : faceletStickeringMask.hintMask ?? stickeringMask2;
               if (faceletInfo.hintFacelet) {
                 faceletInfo.hintFacelet.material = axesInfo[faceletInfo.faceIdx].hintStickerMaterial[hintStickeringMask];
@@ -769,26 +1048,39 @@ var Cube3D = class extends Object3D {
     const cubieFaceletInfo = [];
     orbitFacelets.push(cubieFaceletInfo);
     const cubie = new Group();
-    if (this.options.showFoundation) {
+    const body = this.#stickerless() ? new Mesh(
+      cubieBodyGeometry(
+        orbit,
+        cubieStickerOrder.slice(0, piece.stickerFaces.length)
+      ),
+      axesInfo.map(() => internalBodyMaterial)
+    ) : null;
+    if (body) {
+      cubie.add(body);
+    } else if (this.options.showFoundation) {
       const foundation = this.createCubieFoundation();
       cubie.add(foundation);
       this.experimentalFoundationMeshes.push(foundation);
     }
     for (let i = 0; i < piece.stickerFaces.length; i++) {
-      const sticker = this.createSticker(
-        axesInfo[cubieStickerOrder[i]],
-        axesInfo[piece.stickerFaces[i]],
-        false
-      );
-      const faceletInfo = {
-        faceIdx: piece.stickerFaces[i],
-        facelet: sticker
+      const faceIdx = piece.stickerFaces[i];
+      const faceletInfo = body ? { faceIdx, facelet: body, bodyMaterialIndex: cubieStickerOrder[i] } : {
+        faceIdx,
+        facelet: this.createSticker(
+          axesInfo[cubieStickerOrder[i]],
+          axesInfo[faceIdx],
+          false
+        )
       };
-      cubie.add(sticker);
+      if (body) {
+        body.material[cubieStickerOrder[i]] = axesInfo[faceIdx].bodyMaterial.regular;
+      } else {
+        cubie.add(faceletInfo.facelet);
+      }
       if (this.options.hintFacelets === "floating") {
         const hintSticker = this.createSticker(
           axesInfo[cubieStickerOrder[i]],
-          axesInfo[piece.stickerFaces[i]],
+          axesInfo[faceIdx],
           true
         );
         cubie.add(hintSticker);
@@ -834,7 +1126,7 @@ var Cube3D = class extends Object3D {
             }
             mesh.geometry.setAttribute(
               "uv",
-              new BufferAttribute(
+              new BufferAttribute2(
                 new Float32Array([
                   v3.x,
                   v3.y,
@@ -904,6 +1196,9 @@ var Cube3D = class extends Object3D {
   }
   /** @deprecated */
   experimentalSetFoundationOpacity(opacity) {
+    if (this.experimentalFoundationMeshes.length === 0) {
+      return;
+    }
     this.experimentalFoundationMeshes[0].material.opacity = opacity;
   }
   /** @deprecated */
@@ -913,8 +1208,10 @@ var Cube3D = class extends Object3D {
       for (const pieceInfo of orbitInfo) {
         for (const faceletInfo of pieceInfo) {
           const scale = getFaceletScale(this.options);
-          faceletInfo.facelet.scale.setX(scale);
-          faceletInfo.facelet.scale.setY(scale);
+          if (faceletInfo.bodyMaterialIndex === void 0) {
+            faceletInfo.facelet.scale.setX(scale);
+            faceletInfo.facelet.scale.setY(scale);
+          }
           faceletInfo.hintFacelet?.scale.setX(scale);
           faceletInfo.hintFacelet?.scale.setY(scale);
         }
@@ -940,14 +1237,360 @@ var Cube3D = class extends Object3D {
   }
 };
 
+// src/cubing/twisty/views/3D/puzzles/CubePieces.ts
+import { BufferAttribute as BufferAttribute3 } from "three/src/core/BufferAttribute.js";
+import { BufferGeometry as BufferGeometry3 } from "three/src/core/BufferGeometry.js";
+import { Matrix4 as Matrix42 } from "three/src/math/Matrix4.js";
+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",
+  "oriented",
+  "experimentalOriented2",
+  "ignored",
+  "invisible",
+  "mystery"
+];
+function bodyColor(style, mask) {
+  switch (mask) {
+    case "regular":
+      return style.color;
+    case "dim":
+      return style.dimColor;
+    // A solid piece of plastic can't have a hole punched in it, so an invisible
+    // facelet falls back to the internal plastic color.
+    case "invisible":
+      return bodyMaskColors.internal;
+    default:
+      return bodyMaskColors[mask];
+  }
+}
+function hintColor(style, mask) {
+  switch (mask) {
+    case "regular":
+      return { color: style.hintColor, opacity: 0.5 * style.hintOpacityScale };
+    case "dim":
+      return {
+        color: style.hintDimColor,
+        opacity: 0.5 * style.hintOpacityScale
+      };
+    case "invisible":
+      return { color: 0, opacity: 0 };
+    default:
+      return hintMaskStyles[mask];
+  }
+}
+function faceletAppearanceKey(faceStyle, mask, hintMask) {
+  return (faceStyle * faceletMeshStickeringMasks.length + faceletMeshStickeringMasks.indexOf(mask)) * faceletMeshStickeringMasks.length + faceletMeshStickeringMasks.indexOf(hintMask);
+}
+function faceletAppearance(cache, styles, faceStyle, mask, hintMask) {
+  const key = faceletAppearanceKey(faceStyle, mask, hintMask);
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const style = styles[faceStyle];
+  const body = bodyColor(style, mask);
+  const hint = hintColor(style, hintMask);
+  const appearance = new Uint8Array([
+    body >> 16 & 255,
+    body >> 8 & 255,
+    body & 255,
+    255,
+    hint.color >> 16 & 255,
+    hint.color >> 8 & 255,
+    hint.color & 255,
+    Math.round(hint.opacity * 255)
+  ]);
+  cache.set(key, appearance);
+  return appearance;
+}
+function writeColor(colors, ranges, appearance, offset = 0) {
+  const array = colors.array;
+  const red = appearance[offset];
+  const green = appearance[offset + 1];
+  const blue = appearance[offset + 2];
+  const alpha = appearance[offset + 3];
+  for (const range of ranges) {
+    for (let vertex = range.start; vertex < range.start + range.count; vertex++) {
+      array[4 * vertex] = red;
+      array[4 * vertex + 1] = green;
+      array[4 * vertex + 2] = blue;
+      array[4 * vertex + 3] = alpha;
+    }
+  }
+}
+function paintInternal(colors, ranges) {
+  const internal = bodyMaskColors.internal;
+  writeColor(
+    colors,
+    ranges,
+    new Uint8Array([
+      internal >> 16 & 255,
+      internal >> 8 & 255,
+      internal & 255,
+      255
+    ])
+  );
+}
+
+// src/cubing/twisty/views/3D/puzzles/CubePieces.ts
+var PG_SCALE = 0.5;
+var FACE_COUNT = 6;
+function faceIdxForNormal(x, y, z) {
+  for (let faceIdx = 0; faceIdx < FACE_COUNT; faceIdx++) {
+    const { vector } = cubeFaceStyles[faceIdx];
+    if (vector.x * x + vector.y * y + vector.z * z > 0.5) {
+      return faceIdx;
+    }
+  }
+  return -1;
+}
+function cubeLayout(stickerDat) {
+  const { stickers } = stickerDat;
+  if (stickerDat.faces.length !== FACE_COUNT || stickers.length === 0) {
+    return null;
+  }
+  let faceletCount = 0;
+  let halfExtent = 0;
+  for (const sticker of stickers) {
+    if (sticker.coords.length !== 12) {
+      return null;
+    }
+    if (!sticker.isDup) {
+      faceletCount++;
+    }
+    for (const coord of sticker.coords) {
+      halfExtent = Math.max(halfExtent, Math.abs(coord));
+    }
+  }
+  const layers = Math.round(Math.sqrt(faceletCount / FACE_COUNT));
+  if (FACE_COUNT * layers * layers !== faceletCount || layers < 2) {
+    return null;
+  }
+  const slotWidth = 2 * halfExtent / layers;
+  const epsilon = slotWidth / 1e3;
+  const faceColors = new Array(FACE_COUNT);
+  const cubiesByPiece = /* @__PURE__ */ new Map();
+  const cubies = [];
+  const centroid = [0, 0, 0];
+  for (const sticker of stickers) {
+    const { coords } = sticker;
+    for (let axis = 0; axis < 3; axis++) {
+      centroid[axis] = (coords[axis] + coords[axis + 3] + coords[axis + 6] + coords[axis + 9]) / 4;
+    }
+    let normalAxis = 0;
+    for (let axis = 1; axis < 3; axis++) {
+      if (Math.abs(centroid[axis]) > Math.abs(centroid[normalAxis])) {
+        normalAxis = axis;
+      }
+    }
+    const outward = Math.sign(centroid[normalAxis]);
+    const center = new Vector34();
+    for (let axis = 0; axis < 3; axis++) {
+      let expected;
+      if (axis === normalAxis) {
+        expected = outward * halfExtent;
+        center.setComponent(axis, outward * (halfExtent - slotWidth / 2));
+      } else {
+        const slot = Math.round(
+          (centroid[axis] + halfExtent) / slotWidth - 0.5
+        );
+        if (slot < 0 || slot >= layers) {
+          return null;
+        }
+        expected = -halfExtent + (slot + 0.5) * slotWidth;
+        center.setComponent(axis, expected);
+      }
+      if (Math.abs(centroid[axis] - expected) > epsilon) {
+        return null;
+      }
+      const halfSpan = axis === normalAxis ? 0 : slotWidth / 2;
+      for (let vertex = 0; vertex < 4; vertex++) {
+        const offset = Math.abs(coords[3 * vertex + axis] - expected);
+        if (Math.abs(offset - halfSpan) > epsilon) {
+          return null;
+        }
+      }
+    }
+    const faceIdx = faceIdxForNormal(
+      normalAxis === 0 ? outward : 0,
+      normalAxis === 1 ? outward : 0,
+      normalAxis === 2 ? outward : 0
+    );
+    if (faceIdx === -1) {
+      return null;
+    }
+    faceColors[faceIdx] ??= sticker.color;
+    if (faceColors[faceIdx] !== sticker.color) {
+      return null;
+    }
+    const pieceKey = `${sticker.orbit}/${sticker.ord}`;
+    let cubie = cubiesByPiece.get(pieceKey);
+    if (!cubie) {
+      cubie = {
+        orbit: sticker.orbit,
+        ord: sticker.ord,
+        center,
+        outwardFaces: [],
+        stickers: []
+      };
+      cubiesByPiece.set(pieceKey, cubie);
+      cubies.push(cubie);
+    } else if (cubie.center.distanceTo(center) > epsilon) {
+      return null;
+    }
+    if (!cubie.outwardFaces.includes(faceIdx)) {
+      cubie.outwardFaces.push(faceIdx);
+      cubie.outwardFaces.sort((a, b) => a - b);
+    }
+    cubie.stickers.push({ faceIdx, ori: sticker.ori, isDup: !!sticker.isDup });
+  }
+  if (new Set(faceColors).size !== FACE_COUNT) {
+    return null;
+  }
+  return { layers, halfExtent, cubies };
+}
+function newCubieShape(outwardFaces, slotWidth) {
+  const scale = cubieBodyDimensions.pieceScale * slotWidth;
+  const body = beveledCubieGeometry(
+    cubeFaceStyles.map((style) => style.vector),
+    outwardFaces,
+    cubieBodyDimensions.halfWidth * scale,
+    cubieBodyDimensions.outerAxisRadius * scale,
+    cubieBodyDimensions.innerEdgeRadius * scale,
+    cubieBodyDimensions.innerCornerRadius * scale,
+    cubieBodyDimensions.cornerSharpness,
+    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) {
+    let start = Number.POSITIVE_INFINITY;
+    let end = 0;
+    for (let i = group.start; i < group.start + group.count; i++) {
+      start = Math.min(start, bodyIndices[i]);
+      end = Math.max(end, bodyIndices[i] + 1);
+    }
+    faceVertexRanges[group.materialIndex] = { start, count: end - start };
+  }
+  const positions = Array.from(bodyPositions);
+  const normals = Array.from(bodyNormals);
+  const indices = bodyIndices.slice();
+  const hintVertexRanges = /* @__PURE__ */ new Map();
+  const hintHalfWidth = HINT_FACELET_SCALE * slotWidth / 2;
+  const hintDistance = slotWidth / 2 + HINT_FACELET_ELEVATION;
+  const u = new Vector34();
+  const v = new Vector34();
+  const corner = new Vector34();
+  for (const faceIdx of outwardFaces) {
+    const normal2 = cubeFaceStyles[faceIdx].vector;
+    u.set(normal2.y, normal2.z, normal2.x);
+    v.crossVectors(normal2, u);
+    const start = positions.length / 3;
+    for (const [su, sv] of [
+      [-1, -1],
+      [1, -1],
+      [1, 1],
+      [-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);
+    }
+    indices.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,
+    faceVertexRanges,
+    hintVertexRanges
+  };
+}
+function newCubiePiece(cubie, shape) {
+  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("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);
+  const facelets = cubie.stickers.map((sticker) => ({
+    ori: sticker.ori,
+    faceStyle: sticker.faceIdx,
+    // A duplicate shares its square with the real facelet, which is the one
+    // that gets painted.
+    body: sticker.isDup ? [] : [shape.faceVertexRanges[sticker.faceIdx]],
+    hint: sticker.isDup ? [] : [shape.hintVertexRanges.get(sticker.faceIdx)].filter(Boolean)
+  }));
+  return {
+    orbit: cubie.orbit,
+    ord: cubie.ord,
+    home: new Matrix42().setPosition(cubie.center),
+    geometry,
+    colors,
+    facelets
+  };
+}
+function cubePuzzlePlan(stickerDat) {
+  const layout = cubeLayout(stickerDat);
+  if (!layout) {
+    return null;
+  }
+  const slotWidth = 2 * layout.halfExtent / layout.layers;
+  const shapes = /* @__PURE__ */ new Map();
+  const pieces = layout.cubies.map((cubie) => {
+    const shapeKey = cubie.outwardFaces.join(",");
+    let shape = shapes.get(shapeKey);
+    if (!shape) {
+      shape = newCubieShape(cubie.outwardFaces, slotWidth);
+      shapes.set(shapeKey, shape);
+    }
+    return newCubiePiece(cubie, shape);
+  });
+  return {
+    faceStyles: cubeFaceStyles,
+    pieces,
+    // Oversized pieces push the puzzle past the half-extent the camera framing
+    // assumes, so scale it back to the size `PG3D` would have drawn.
+    scale: PG_SCALE * layout.halfExtent / (cubieBodyHalfExtent(layout.layers) * slotWidth)
+  };
+}
+
 // src/cubing/twisty/views/3D/puzzles/PG3D.ts
 import { DoubleSide as DoubleSide2, FrontSide as FrontSide2 } from "three/src/constants.js";
-import { BufferAttribute as BufferAttribute2 } from "three/src/core/BufferAttribute.js";
-import { BufferGeometry as BufferGeometry2 } from "three/src/core/BufferGeometry.js";
+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 { Color as Color2 } from "three/src/math/Color.js";
-import { Vector3 as Vector32 } from "three/src/math/Vector3.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({
@@ -1092,9 +1735,9 @@ var Filler = class {
     }
   }
   setAttributes(geo) {
-    geo.setAttribute("position", new BufferAttribute2(this.vertices, 3));
+    geo.setAttribute("position", new BufferAttribute4(this.vertices, 3));
     const sa2 = this.colors.subarray(0, 9 * this.sz);
-    geo.setAttribute("color", new BufferAttribute2(sa2, 3, true));
+    geo.setAttribute("color", new BufferAttribute4(sa2, 3, true));
   }
   makeGroups(geo) {
     geo.clearGroups();
@@ -1129,7 +1772,7 @@ var StickerDef = class {
     this.isDup = !!stickerDat.isDup;
     this.faceNum = stickerDat.face;
     this.stickerStart = filler.ipos;
-    const sdColor = new Color2(stickerDat.color).getHex();
+    const sdColor = new Color3(stickerDat.color).getHex();
     this.origColor = sdColor;
     this.origColorStickeringMask = sdColor;
     if (options?.stickeringMask) {
@@ -1203,7 +1846,7 @@ var StickerDef = class {
         if (this.origColor === 16777215) {
           c = 14540253;
         } else {
-          c = new Color2(this.origColor).multiplyScalar(0.5).getHex();
+          c = new Color3(this.origColor).multiplyScalar(0.5).getHex();
         }
         break;
       }
@@ -1320,7 +1963,7 @@ var HitPlaneDef = class {
       filler.addUncolored(coords, g);
       filler.addUncolored(coords, g + 1);
     }
-    this.geo = new BufferGeometry2();
+    this.geo = new BufferGeometry4();
     filler.setAttributes(this.geo);
     const obj = new Mesh2(this.geo, invisMaterial);
     obj.userData["quantumMove"] = stickerDat.notationMapper.notationToExternal(
@@ -1335,12 +1978,12 @@ var AxisInfo2 = class {
   order;
   constructor(axisDat) {
     const vec = axisDat.coordinates;
-    this.axis = new Vector32(vec[0], vec[1], vec[2]);
+    this.axis = new Vector35(vec[0], vec[1], vec[2]);
     this.order = axisDat.order;
   }
 };
 var DEFAULT_COLOR_FRACTION = 0.71;
-var PG_SCALE = 0.5;
+var PG_SCALE2 = 0.5;
 var PG3D = class extends Object3D2 {
   constructor(scheduleRenderCallback, kpuzzle, stickerDat, enableFoundationOpt = false, enableHintStickersOpt = false, hintStickerHeightScale = 1, faceletScale = 1, params = {}) {
     super();
@@ -1440,14 +2083,14 @@ var PG3D = class extends Object3D2 {
         this.stickers[orbit][ori][ord].addFoundation(filler, sticker, black);
       }
     }
-    const fixedGeo = new BufferGeometry2();
+    const fixedGeo = new BufferGeometry4();
     filler.setAttributes(fixedGeo);
     filler.makeGroups(fixedGeo);
     const obj = new Mesh2(fixedGeo, this.materialArray1);
-    obj.scale.set(PG_SCALE, PG_SCALE, PG_SCALE);
+    obj.scale.set(PG_SCALE2, PG_SCALE2, PG_SCALE2);
     this.add(obj);
     const obj2 = new Mesh2(fixedGeo, this.materialArray2);
-    obj2.scale.set(PG_SCALE, PG_SCALE, PG_SCALE);
+    obj2.scale.set(PG_SCALE2, PG_SCALE2, PG_SCALE2);
     this.add(obj2);
     const hitfaces = this.stickerDat.faces;
     this.movingObj = obj2;
@@ -1459,7 +2102,7 @@ var PG3D = class extends Object3D2 {
         stickerDat.textureMapper,
         this.stickerDat
       );
-      facedef.cubie.scale.set(PG_SCALE, PG_SCALE, PG_SCALE);
+      facedef.cubie.scale.set(PG_SCALE2, PG_SCALE2, PG_SCALE2);
       this.add(facedef.cubie);
       this.controlTargets.push(facedef.cubie.children[0]);
     }
@@ -1537,7 +2180,7 @@ var PG3D = class extends Object3D2 {
       }
     }
     for (const axis of this.stickerDat.axis) {
-      const product = point.dot(new Vector32(...axis.coordinates));
+      const product = point.dot(new Vector35(...axis.coordinates));
       if (product > closestMoveDotProduct) {
         const modified = this.stickerDat.notationMapper.notationToExternal(
           modify(axis.quantumMove)
@@ -1819,7 +2462,7 @@ var PG3D = class extends Object3D2 {
     }
     filler.uvs.copyWithin(6 * filler.sz, 0, 6 * filler.sz);
     const sa1 = filler.uvs.subarray(0, 6 * filler.sz);
-    this.fixedGeo.setAttribute("uv", new BufferAttribute2(sa1, 2, true));
+    this.fixedGeo.setAttribute("uv", new BufferAttribute4(sa1, 2, true));
   }
   experimentalUpdateTexture(enabled, stickerTexture, hintTexture) {
     if (!stickerTexture) {
@@ -1869,15 +2512,537 @@ var PG3D = class extends Object3D2 {
   }
 };
 
+// src/cubing/twisty/views/3D/puzzles/SolidPieces.ts
+import { BufferAttribute as BufferAttribute5 } from "three/src/core/BufferAttribute.js";
+import { BufferGeometry as BufferGeometry5 } from "three/src/core/BufferGeometry.js";
+import { Color as Color4 } from "three/src/math/Color.js";
+import { Matrix4 as Matrix43 } from "three/src/math/Matrix4.js";
+import { Vector3 as Vector37 } from "three/src/math/Vector3.js";
+
+// src/cubing/twisty/views/3D/puzzles/SolidPieceGeometry.ts
+import { Vector3 as Vector36 } from "three/src/math/Vector3.js";
+var SOLID_PIECE_GROOVE = 0.018;
+var SOLID_PIECE_CHAMFER = 5e-3;
+var BOX_PLANE = -1;
+function boxFacet(planeIdx, normal2, size) {
+  const reference = Math.abs(normal2.y) > 0.5 ? new Vector36(0, 0, 1) : new Vector36(0, 1, 0);
+  const u = new Vector36().crossVectors(reference, normal2).normalize();
+  const v = new Vector36().crossVectors(normal2, u);
+  const center = normal2.clone().multiplyScalar(size);
+  return {
+    plane: planeIdx,
+    vertices: [
+      [-1, -1],
+      [1, -1],
+      [1, 1],
+      [-1, 1]
+    ].map(
+      ([su, sv]) => center.clone().addScaledVector(u, su * size).addScaledVector(v, sv * size)
+    )
+  };
+}
+var BOX_NORMALS = [
+  new Vector36(1, 0, 0),
+  new Vector36(-1, 0, 0),
+  new Vector36(0, 1, 0),
+  new Vector36(0, -1, 0),
+  new Vector36(0, 0, 1),
+  new Vector36(0, 0, -1)
+];
+function orderInPlane(points, normal2) {
+  const centroid = new Vector36();
+  for (const point of points) {
+    centroid.addScaledVector(point, 1 / points.length);
+  }
+  const reference = new Vector36().subVectors(points[0], centroid).normalize();
+  const other = new Vector36().crossVectors(normal2, reference);
+  const offset = new Vector36();
+  return points.map((point) => {
+    offset.subVectors(point, centroid);
+    return {
+      point,
+      angle: Math.atan2(offset.dot(other), offset.dot(reference))
+    };
+  }).sort((a, b) => a.angle - b.angle).map(({ point }) => point);
+}
+function vertexKey(vertex, quantum) {
+  return `${Math.round(vertex.x / quantum)},${Math.round(vertex.y / quantum)},${Math.round(vertex.z / quantum)}`;
+}
+function clipByPlane(facets, plane, planeIdx, epsilon) {
+  const clipped = [];
+  const capPoints = [];
+  const capKeys = /* @__PURE__ */ new Set();
+  const quantum = epsilon * 10;
+  for (const facet of facets) {
+    const kept = [];
+    const count = facet.vertices.length;
+    for (let i = 0; i < count; i++) {
+      const current = facet.vertices[i];
+      const next = facet.vertices[(i + 1) % count];
+      const currentSide = current.dot(plane.normal) - plane.offset;
+      const nextSide = next.dot(plane.normal) - plane.offset;
+      if (currentSide <= epsilon) {
+        kept.push(current);
+      }
+      if (currentSide > epsilon && nextSide < -epsilon || currentSide < -epsilon && nextSide > epsilon) {
+        kept.push(
+          current.clone().lerp(next, currentSide / (currentSide - nextSide))
+        );
+      }
+    }
+    if (kept.length < 3) {
+      continue;
+    }
+    clipped.push({ plane: facet.plane, vertices: kept });
+    for (const vertex of kept) {
+      if (Math.abs(vertex.dot(plane.normal) - plane.offset) > epsilon) {
+        continue;
+      }
+      const key = vertexKey(vertex, quantum);
+      if (!capKeys.has(key)) {
+        capKeys.add(key);
+        capPoints.push(vertex);
+      }
+    }
+  }
+  if (capPoints.length >= 3) {
+    clipped.push({
+      plane: planeIdx,
+      vertices: orderInPlane(capPoints, plane.normal)
+    });
+  }
+  return clipped;
+}
+function buildFacets(planes, radius, epsilon) {
+  let facets = BOX_NORMALS.map(
+    (normal2) => boxFacet(BOX_PLANE, normal2, radius * 4)
+  );
+  for (let planeIdx = 0; planeIdx < planes.length; planeIdx++) {
+    facets = clipByPlane(facets, planes[planeIdx], planeIdx, epsilon);
+  }
+  if (facets.some((facet) => facet.plane === BOX_PLANE) || facets.length < 4) {
+    return null;
+  }
+  return facets;
+}
+function chamferPlanes(facets, planes, chamfer, epsilon) {
+  const quantum = epsilon * 10;
+  const edges = /* @__PURE__ */ new Map();
+  for (const facet of facets) {
+    const { vertices } = facet;
+    for (let i = 0; i < vertices.length; i++) {
+      const edgeKey = [
+        vertexKey(vertices[i], quantum),
+        vertexKey(vertices[(i + 1) % vertices.length], quantum)
+      ].sort().join("|");
+      const sharing = edges.get(edgeKey);
+      if (sharing) {
+        sharing.push(facet.plane);
+      } else {
+        edges.set(edgeKey, [facet.plane]);
+      }
+    }
+  }
+  const added = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sharing of edges.values()) {
+    if (sharing.length !== 2) {
+      continue;
+    }
+    const [a, b] = sharing;
+    const colored = planes[a].source !== -1 ? a : b;
+    const internal = planes[a].source !== -1 ? b : a;
+    if (planes[colored].source === -1 || planes[internal].source !== -1) {
+      continue;
+    }
+    const pairKey = `${colored}|${internal}`;
+    if (seen.has(pairKey)) {
+      continue;
+    }
+    seen.add(pairKey);
+    const sum = new Vector36().addVectors(
+      planes[colored].normal,
+      planes[internal].normal
+    );
+    if (sum.length() < 1e-6) {
+      continue;
+    }
+    added.push({
+      normal: sum.clone().normalize(),
+      // Where the two faces meet, measured along the bevel's own direction.
+      offset: (planes[colored].offset + planes[internal].offset) / sum.length() - chamfer,
+      source: planes[colored].source
+    });
+  }
+  return added;
+}
+function solidPieceGeometry(planes, options) {
+  const epsilon = options.radius * 1e-6;
+  const working = planes.map((plane, index) => ({
+    normal: plane.normal,
+    offset: plane.offset - (plane.color === null ? options.groove : 0),
+    source: plane.color === null ? -1 : index
+  }));
+  const plain = buildFacets(working, options.radius, epsilon);
+  if (!plain) {
+    return null;
+  }
+  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 [
+        facet.vertices[0],
+        facet.vertices[i],
+        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) {
+      internalRanges.push(range);
+    } else {
+      ranges[plane.source].push(range);
+    }
+  }
+  return {
+    positions: new Float32Array(positions),
+    normals: new Float32Array(normals),
+    vertexCount: positions.length / 3,
+    ranges,
+    internalRanges
+  };
+}
+
+// src/cubing/twisty/views/3D/puzzles/SolidPieces.ts
+var PG_SCALE3 = 0.5;
+var EPSILON = 1e-6;
+function vertexAt(sticker, index) {
+  return new Vector37(
+    sticker.coords[3 * index],
+    sticker.coords[3 * index + 1],
+    sticker.coords[3 * index + 2]
+  );
+}
+function polygonOf(sticker) {
+  const vertices = [];
+  for (let i = 0; i < sticker.coords.length / 3; i++) {
+    vertices.push(vertexAt(sticker, i));
+  }
+  return vertices;
+}
+function outwardNormal(polygon) {
+  const normal2 = new Vector37().crossVectors(
+    new Vector37().subVectors(polygon[1], polygon[0]),
+    new Vector37().subVectors(polygon[2], polygon[0])
+  );
+  if (normal2.length() < EPSILON) {
+    return null;
+  }
+  normal2.normalize();
+  return normal2.dot(polygon[0]) < 0 ? normal2.negate() : normal2;
+}
+function keyOf(vertex, quantum) {
+  return `${Math.round(vertex.x / quantum)},${Math.round(vertex.y / quantum)},${Math.round(vertex.z / quantum)}`;
+}
+function faceStyles(faceNormals, faceColors) {
+  const styles = [];
+  const cubeFaces = [];
+  for (let face2 = 0; face2 < faceNormals.length; face2++) {
+    const normal2 = faceNormals[face2];
+    const color = faceColors[face2];
+    if (!normal2 || color === void 0) {
+      return null;
+    }
+    cubeFaces.push(
+      cubeFaceStyles.findIndex((style) => style.vector.dot(normal2) > 0.999)
+    );
+  }
+  const isCube = faceNormals.length === cubeFaceStyles.length && new Set(cubeFaces).size === cubeFaceStyles.length && !cubeFaces.includes(-1) && new Set(faceColors).size === faceColors.length;
+  for (let face2 = 0; face2 < faceNormals.length; face2++) {
+    if (isCube) {
+      styles.push(cubeFaceStyles[cubeFaces[face2]]);
+      continue;
+    }
+    const color = new Color4(faceColors[face2]).getHex();
+    const dimColor = new Color4(color).multiplyScalar(0.5).getHex();
+    styles.push({
+      color,
+      dimColor,
+      hintColor: color,
+      hintDimColor: dimColor,
+      hintOpacityScale: 1
+    });
+  }
+  return styles;
+}
+function hintPolygon(polygon, normal2) {
+  const centroid = new Vector37();
+  for (const vertex of polygon) {
+    centroid.addScaledVector(vertex, 1 / polygon.length);
+  }
+  return polygon.map(
+    (vertex) => centroid.clone().addScaledVector(
+      new Vector37().subVectors(vertex, centroid),
+      HINT_FACELET_SCALE
+    ).addScaledVector(normal2, HINT_FACELET_ELEVATION)
+  );
+}
+function solidPuzzlePlan(stickerDat) {
+  const { stickers } = stickerDat;
+  if (stickers.length === 0 || stickerDat.faces.length === 0) {
+    return null;
+  }
+  let radius = 0;
+  for (const sticker of stickers) {
+    if (sticker.coords.length < 9 || sticker.coords.length % 3 !== 0) {
+      return null;
+    }
+    for (let i = 0; i < sticker.coords.length; i += 3) {
+      radius = Math.max(
+        radius,
+        Math.hypot(
+          sticker.coords[i],
+          sticker.coords[i + 1],
+          sticker.coords[i + 2]
+        )
+      );
+    }
+  }
+  const quantum = radius * 1e-5;
+  const faceNormals = new Array(stickerDat.faces.length);
+  const faceColors = new Array(stickerDat.faces.length);
+  const pieces = /* @__PURE__ */ new Map();
+  const order = [];
+  const edges = /* @__PURE__ */ new Map();
+  let faceDistance = 0;
+  for (const sticker of stickers) {
+    const pieceKey = `${sticker.orbit}/${sticker.ord}`;
+    let piece = pieces.get(pieceKey);
+    if (!piece) {
+      piece = {
+        orbit: sticker.orbit,
+        ord: sticker.ord,
+        stickers: [],
+        duplicates: []
+      };
+      pieces.set(pieceKey, piece);
+      order.push(piece);
+    }
+    if (sticker.isDup) {
+      piece.duplicates.push(sticker);
+      continue;
+    }
+    const polygon = polygonOf(sticker);
+    const normal2 = outwardNormal(polygon);
+    if (!normal2) {
+      return null;
+    }
+    for (const vertex of polygon) {
+      if (Math.abs(vertex.dot(normal2) - polygon[0].dot(normal2)) > quantum) {
+        return null;
+      }
+    }
+    const distance = polygon[0].dot(normal2);
+    faceDistance = faceDistance || distance;
+    if (faceNormals[sticker.face]) {
+      if (faceNormals[sticker.face].dot(normal2) < 0.999) {
+        return null;
+      }
+    } else {
+      faceNormals[sticker.face] = normal2;
+    }
+    faceColors[sticker.face] ??= sticker.color;
+    if (faceColors[sticker.face] !== sticker.color) {
+      return null;
+    }
+    piece.stickers.push({ sticker, polygon });
+    for (let i = 0; i < polygon.length; i++) {
+      const edgeKey = [
+        keyOf(polygon[i], quantum),
+        keyOf(polygon[(i + 1) % polygon.length], quantum)
+      ].sort().join("|");
+      const sharing = edges.get(edgeKey);
+      if (sharing) {
+        sharing.add(pieceKey);
+      } else {
+        edges.set(edgeKey, /* @__PURE__ */ new Set([pieceKey]));
+      }
+    }
+  }
+  const styles = faceStyles(faceNormals, faceColors);
+  if (!styles) {
+    return null;
+  }
+  const axes = stickerDat.axis.map(
+    (axis) => new Vector37(...axis.coordinates).normalize()
+  );
+  const plans = [];
+  for (const piece of order) {
+    const plan = newSolidPiece(piece, edges, axes, {
+      quantum,
+      radius,
+      faceDistance
+    });
+    if (!plan) {
+      return null;
+    }
+    plans.push(plan);
+  }
+  return { faceStyles: styles, pieces: plans, scale: PG_SCALE3 };
+}
+function newSolidPiece(piece, edges, axes, 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();
+  for (const { polygon } of piece.stickers) {
+    for (const vertex of polygon) {
+      interior.addScaledVector(
+        vertex,
+        0.5 / polygon.length / piece.stickers.length
+      );
+    }
+  }
+  for (const { sticker, polygon } of piece.stickers) {
+    const normal2 = outwardNormal(polygon);
+    planeOfSticker.set(sticker, planes.length);
+    planes.push({
+      normal: normal2,
+      offset: polygon[0].dot(normal2),
+      color: sticker.face
+    });
+  }
+  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)) {
+        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)) {
+        return null;
+      }
+      for (const other of piece.stickers) {
+        for (const vertex of other.polygon) {
+          if (vertex.dot(normal2) > sizes.quantum) {
+            return null;
+          }
+        }
+      }
+      if (planes.some(
+        (plane) => plane.color === null && plane.normal.dot(normal2) > 0.9999 && Math.abs(plane.offset) < sizes.quantum
+      )) {
+        continue;
+      }
+      planes.push({ normal: normal2, offset: 0, color: null });
+    }
+  }
+  const solid = solidPieceGeometry(planes, {
+    groove: SOLID_PIECE_GROOVE * sizes.faceDistance,
+    chamfer: SOLID_PIECE_CHAMFER * sizes.faceDistance,
+    radius: sizes.radius
+  });
+  if (!solid) {
+    return null;
+  }
+  const positions = Array.from(solid.positions);
+  const normals = Array.from(solid.normals);
+  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);
+      }
+    }
+    hintRanges.set(sticker, {
+      start,
+      count: positions.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 facelets = piece.stickers.map(({ sticker }) => ({
+    ori: sticker.ori,
+    faceStyle: sticker.face,
+    body: solid.ranges[planeOfSticker.get(sticker)],
+    hint: [hintRanges.get(sticker)]
+  }));
+  for (const sticker of piece.duplicates) {
+    facelets.push({
+      ori: sticker.ori,
+      faceStyle: sticker.face,
+      body: [],
+      hint: []
+    });
+  }
+  return {
+    orbit: piece.orbit,
+    ord: piece.ord,
+    // The geometry is already where the piece belongs.
+    home: new Matrix43(),
+    geometry,
+    colors,
+    facelets
+  };
+}
+
 // src/cubing/twisty/views/3D/puzzles/Square1_3D.ts
 import { DoubleSide as DoubleSide3 } from "three/src/constants.js";
-import { BufferAttribute as BufferAttribute3 } from "three/src/core/BufferAttribute.js";
-import { BufferGeometry as BufferGeometry3 } from "three/src/core/BufferGeometry.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 { Color as Color3 } from "three/src/math/Color.js";
+import { Color as Color5 } from "three/src/math/Color.js";
 import { Quaternion as Quaternion2 } from "three/src/math/Quaternion.js";
-import { Vector3 as Vector33 } from "three/src/math/Vector3.js";
+import { Vector3 as Vector38 } from "three/src/math/Vector3.js";
 import { Group as Group3 } from "three/src/objects/Group.js";
 import { Mesh as Mesh3 } from "three/src/objects/Mesh.js";
 var DEGREE = TAU / 360;
@@ -1894,8 +3059,8 @@ var RING_COLORS = [2254591, 16750848, 65280, 16711680];
 var FRAME_OFFSET_DEGREES = 180;
 var BODY_COLOR = 1118481;
 var MIRROR = -1;
-var Y_AXIS = new Vector33(0, 1, 0);
-var SLICE_AXIS = new Vector33(
+var Y_AXIS = new Vector38(0, 1, 0);
+var SLICE_AXIS = new Vector38(
   MIRROR * Math.sin(15 * DEGREE),
   0,
   Math.cos(15 * DEGREE)
@@ -1912,7 +3077,7 @@ function slotQuaternion(slot) {
   );
   if (slot >= WEDGES_PER_LAYER) {
     quaternion.multiply(
-      new Quaternion2().setFromAxisAngle(new Vector33(0, 0, 1), TAU / 2)
+      new Quaternion2().setFromAxisAngle(new Vector38(0, 0, 1), TAU / 2)
     );
   }
   return quaternion;
@@ -2001,15 +3166,15 @@ function prismStickerSpecs(spec) {
   const specs = [];
   if (topColor !== null) {
     specs.push({
-      corners: polygon.map(([x, z]) => new Vector33(x, yTop, z)),
-      normal: new Vector33(0, 1, 0),
+      corners: polygon.map(([x, z]) => new Vector38(x, yTop, z)),
+      normal: new Vector38(0, 1, 0),
       color: topColor
     });
   }
   if (bottomColor !== null) {
     specs.push({
-      corners: polygon.map(([x, z]) => new Vector33(x, yBottom, z)),
-      normal: new Vector33(0, -1, 0),
+      corners: polygon.map(([x, z]) => new Vector38(x, yBottom, z)),
+      normal: new Vector38(0, -1, 0),
       color: bottomColor
     });
   }
@@ -2026,17 +3191,17 @@ function prismStickerSpecs(spec) {
     }
     const [x0, z0] = polygon[i];
     const [x1, z1] = polygon[(i + 1) % polygon.length];
-    const normal2 = new Vector33(z1 - z0, 0, -(x1 - x0)).normalize();
+    const normal2 = new Vector38(z1 - z0, 0, -(x1 - x0)).normalize();
     const outward = normal2.x * ((x0 + x1) / 2 - centroidX) + normal2.z * ((z0 + z1) / 2 - centroidZ);
     if (outward < 0) {
       normal2.negate();
     }
     specs.push({
       corners: [
-        new Vector33(x0, yBottom, z0),
-        new Vector33(x1, yBottom, z1),
-        new Vector33(x1, yTop, z1),
-        new Vector33(x0, yTop, z0)
+        new Vector38(x0, yBottom, z0),
+        new Vector38(x1, yBottom, z1),
+        new Vector38(x1, yTop, z1),
+        new Vector38(x0, yTop, z0)
       ],
       normal: normal2,
       color
@@ -2045,7 +3210,7 @@ function prismStickerSpecs(spec) {
   return specs;
 }
 function stickerPositions(spec, faceletScale) {
-  const center = new Vector33();
+  const center = new Vector38();
   for (const corner of spec.corners) {
     center.addScaledVector(corner, 1 / spec.corners.length);
   }
@@ -2068,16 +3233,88 @@ function stickerPositions(spec, faceletScale) {
   }
   return new Float32Array(out);
 }
+var PIECE_GROOVE_HALF_WIDTH = 0.018;
+var PIECE_CHAMFER = 5e-3;
+var PUZZLE_RADIUS = CUBE_HALF_EDGE * Math.SQRT2;
+function prismPlanes(spec) {
+  const { polygon, sideColors } = spec;
+  const planes = [
+    { normal: new Vector38(0, 1, 0), offset: spec.yTop, color: spec.topColor },
+    {
+      normal: new Vector38(0, -1, 0),
+      offset: -spec.yBottom,
+      color: spec.bottomColor
+    }
+  ];
+  let centroidX = 0;
+  let centroidZ = 0;
+  for (const [x, z] of polygon) {
+    centroidX += x / polygon.length;
+    centroidZ += z / polygon.length;
+  }
+  for (let i = 0; i < polygon.length; i++) {
+    const [x0, z0] = polygon[i];
+    const [x1, z1] = polygon[(i + 1) % polygon.length];
+    const normal2 = new Vector38(z1 - z0, 0, -(x1 - x0)).normalize();
+    if (normal2.x * (x0 - centroidX) + normal2.z * (z0 - centroidZ) < 0) {
+      normal2.negate();
+    }
+    planes.push({
+      normal: normal2,
+      offset: normal2.x * x0 + normal2.z * z0,
+      color: sideColors[i] ?? null
+    });
+  }
+  return planes;
+}
+function stickerlessPieceGeometry(spec) {
+  const planes = prismPlanes(spec);
+  const piece = solidPieceGeometry(planes, {
+    groove: PIECE_GROOVE_HALF_WIDTH,
+    chamfer: PIECE_CHAMFER,
+    radius: PUZZLE_RADIUS
+  });
+  if (!piece) {
+    throw new Error("Could not build a Square-1 piece out of its planes.");
+  }
+  const colors = new Uint8Array(4 * piece.vertexCount);
+  const paint = (ranges, color) => {
+    for (const range of ranges) {
+      for (let i = range.start; i < range.start + range.count; i++) {
+        colors[4 * i] = color >> 16 & 255;
+        colors[4 * i + 1] = color >> 8 & 255;
+        colors[4 * i + 2] = color & 255;
+        colors[4 * i + 3] = 255;
+      }
+    }
+  };
+  paint(piece.internalRanges, bodyMaskColors.internal);
+  for (let i = 0; i < planes.length; i++) {
+    const color = planes[i].color;
+    if (color !== null) {
+      paint(piece.ranges[i], color);
+    }
+  }
+  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({
-  color: new Color3(BODY_COLOR).convertLinearToSRGB(),
+  color: new Color5(BODY_COLOR).convertLinearToSRGB(),
   side: DoubleSide3
 });
+var stickerlessMaterialCache;
+function stickerlessMaterial() {
+  return stickerlessMaterialCache ??= newVertexColorBodyMaterial();
+}
 var stickerMaterialCache = /* @__PURE__ */ new Map();
 function stickerMaterial(color) {
   let material = stickerMaterialCache.get(color);
   if (!material) {
     material = new MeshBasicMaterial3({
-      color: new Color3(color).convertLinearToSRGB(),
+      color: new Color5(color).convertLinearToSRGB(),
       side: DoubleSide3
     });
     stickerMaterialCache.set(color, material);
@@ -2086,23 +3323,31 @@ function stickerMaterial(color) {
 }
 var Square1Piece = class extends Group3 {
   body;
-  #stickerSpecs;
+  #stickerSpecs = [];
   #stickerMeshes = [];
-  constructor(spec, faceletScale) {
+  constructor(spec, faceletScale, stickerless) {
     super();
-    const bodyGeometry = new BufferGeometry3();
+    if (stickerless) {
+      this.body = new Mesh3(
+        stickerlessPieceGeometry(spec),
+        stickerlessMaterial()
+      );
+      this.add(this.body);
+      return;
+    }
+    const bodyGeometry = new BufferGeometry6();
     bodyGeometry.setAttribute(
       "position",
-      new BufferAttribute3(prismBodyPositions(spec), 3)
+      new BufferAttribute6(prismBodyPositions(spec), 3)
     );
     this.body = new Mesh3(bodyGeometry, bodyMaterial);
     this.add(this.body);
     this.#stickerSpecs = prismStickerSpecs(spec);
     for (const stickerSpec of this.#stickerSpecs) {
-      const geometry = new BufferGeometry3();
+      const geometry = new BufferGeometry6();
       geometry.setAttribute(
         "position",
-        new BufferAttribute3(stickerPositions(stickerSpec, faceletScale), 3)
+        new BufferAttribute6(stickerPositions(stickerSpec, faceletScale), 3)
       );
       const mesh = new Mesh3(geometry, stickerMaterial(stickerSpec.color));
       this.#stickerMeshes.push(mesh);
@@ -2114,7 +3359,7 @@ var Square1Piece = class extends Group3 {
       const geometry = this.#stickerMeshes[i].geometry;
       geometry.setAttribute(
         "position",
-        new BufferAttribute3(
+        new BufferAttribute6(
           stickerPositions(this.#stickerSpecs[i], faceletScale),
           3
         )
@@ -2122,7 +3367,9 @@ var Square1Piece = class extends Group3 {
     }
   }
   setFoundationVisible(visible) {
-    this.body.visible = visible;
+    if (this.#stickerMeshes.length > 0) {
+      this.body.visible = visible;
+    }
   }
 };
 function wedgePrismSpec(homeSlot) {
@@ -2186,8 +3433,15 @@ var Square1_3D = class extends Object3D3 {
     if (typeof options.showFoundation === "boolean") {
       this.#showFoundation = options.showFoundation;
     }
+    if (options.experimentalWedgeStyle) {
+      this.#stickerless = options.experimentalWedgeStyle === "stickerless";
+    }
     for (let piece = 0; piece < 2 * WEDGES_PER_LAYER; piece++) {
-      const wedge = new Square1Piece(wedgePrismSpec(piece), this.#faceletScale);
+      const wedge = new Square1Piece(
+        wedgePrismSpec(piece),
+        this.#faceletScale,
+        this.#stickerless
+      );
       wedge.setFoundationVisible(this.#showFoundation);
       wedge.quaternion.copy(SLOT_QUATERNIONS[piece]);
       this.#wedgePieces.push(wedge);
@@ -2196,7 +3450,8 @@ var Square1_3D = class extends Object3D3 {
     for (const pair of CORNER_PAIRS) {
       const corner = new Square1Piece(
         cornerPrismSpec(pair),
-        this.#faceletScale
+        this.#faceletScale,
+        this.#stickerless
       );
       corner.setFoundationVisible(this.#showFoundation);
       corner.visible = false;
@@ -2206,12 +3461,16 @@ var Square1_3D = class extends Object3D3 {
     for (let piece = 0; piece < 2; piece++) {
       const equator = new Square1Piece(
         equatorPrismSpec(piece),
-        this.#faceletScale
+        this.#faceletScale,
+        this.#stickerless
       );
       equator.setFoundationVisible(this.#showFoundation);
       this.#equatorPieces.push(equator);
       this.add(equator);
     }
+    if (this.#stickerless) {
+      addCubieBodyLighting(this);
+    }
     this.scale.set(PUZZLE_SCALE, PUZZLE_SCALE, PUZZLE_SCALE);
   }
   scheduleRenderCallback;
@@ -2220,6 +3479,7 @@ var Square1_3D = class extends Object3D3 {
   #equatorPieces = [];
   #faceletScale = DEFAULT_FACELET_SCALE;
   #showFoundation = true;
+  #stickerless = true;
   #slotOfPiece = new Int8Array(2 * WEDGES_PER_LAYER);
   #slotMoveMask = new Uint8Array(2 * WEDGES_PER_LAYER);
   #slotRotation = new Array(2 * WEDGES_PER_LAYER).fill(
@@ -2345,13 +3605,356 @@ var Square1_3D = class extends Object3D3 {
   }
 };
 
+// src/cubing/twisty/views/3D/puzzles/Stickerless3D.ts
+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 { Matrix4 as Matrix44 } from "three/src/math/Matrix4.js";
+import { Vector3 as Vector39 } from "three/src/math/Vector3.js";
+import { Mesh as Mesh4 } from "three/src/objects/Mesh.js";
+var invisibleMaterial2 = new MeshBasicMaterial4({ visible: false });
+var Stickerless3D = class extends Object3D4 {
+  constructor(scheduleRenderCallback, kpuzzle, stickerDat, plan, options = {}) {
+    super();
+    this.scheduleRenderCallback = scheduleRenderCallback;
+    this.kpuzzle = kpuzzle;
+    this.stickerDat = stickerDat;
+    this.plan = plan;
+    this.#hintMaterial = new MeshBasicMaterial4({
+      vertexColors: true,
+      transparent: true,
+      // Hint facelets show the faces turned away from the camera, so they are
+      // drawn from the inside out.
+      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
+      };
+    }
+    for (const piecePlan of plan.pieces) {
+      this.#addPiece(piecePlan);
+    }
+    addCubieBodyLighting(this);
+    for (const face2 of stickerDat.faces) {
+      this.#addControlTarget(face2);
+    }
+    this.scale.setScalar(plan.scale);
+    if (options.stickeringMask) {
+      this.setStickeringMask(options.stickeringMask);
+    }
+  }
+  scheduleRenderCallback;
+  kpuzzle;
+  stickerDat;
+  plan;
+  #pieces = [];
+  /** Indexed `[orbit][ori][ord]`, like the orbits of the `KPuzzle`. */
+  #facelets = {};
+  #axesInfo = {};
+  #controlTargets = [];
+  #materials;
+  #bodyMaterial;
+  #hintMaterial;
+  #appearances = /* @__PURE__ */ new Map();
+  /** Pieces rotated away from their home position by the last frame. */
+  #turningPieces = [];
+  /** Which pieces each quantum move sweeps, by the move's notation. */
+  #turnedPieces = /* @__PURE__ */ new Map();
+  #dirtyColors = /* @__PURE__ */ new Set();
+  #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 };
+    this.#pieces.push(piece);
+    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,
+        appearanceKey: -1,
+        mask: "regular",
+        hintMask: "regular"
+      };
+    }
+  }
+  #addControlTarget(face2) {
+    const { coords } = face2;
+    const triangles = coords.length / 3 - 2;
+    const positions = new Float32Array(9 * triangles);
+    for (let triangle = 0; triangle < triangles; triangle++) {
+      for (const [vertex, source] of [
+        0,
+        triangle + 1,
+        triangle + 2
+      ].entries()) {
+        for (let axis = 0; axis < 3; axis++) {
+          positions[9 * triangle + 3 * vertex + axis] = coords[3 * source + axis];
+        }
+      }
+    }
+    const geometry = new BufferGeometry7();
+    geometry.setAttribute("position", new BufferAttribute7(positions, 3));
+    const mesh = new Mesh4(geometry, invisibleMaterial2);
+    mesh.userData["quantumMove"] = this.stickerDat.notationMapper.notationToExternal(new Move(face2.name));
+    mesh.scale.setScalar(0.99);
+    this.add(mesh);
+    this.#controlTargets.push(mesh);
+  }
+  dispose() {
+    for (const piece of this.#pieces) {
+      piece.mesh.geometry.dispose();
+    }
+    this.#bodyMaterial.dispose();
+    this.#hintMaterial.dispose();
+  }
+  experimentalGetStickerTargets() {
+    return [];
+  }
+  experimentalGetControlTargets() {
+    return this.#controlTargets;
+  }
+  #isValidMove(move) {
+    try {
+      this.kpuzzle.moveToTransformation(move);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getClosestMoveToAxis(point, transformations) {
+    let closestMove = null;
+    let closestMoveDotProduct = 0;
+    let modify = (m) => m;
+    switch (transformations.depth) {
+      case "secondSlice": {
+        modify = (m) => m.modified({ innerLayer: 2 });
+        break;
+      }
+      case "rotation": {
+        modify = (m) => m.modified({ family: `${m.family}v` });
+        break;
+      }
+    }
+    for (const axis of this.stickerDat.axis) {
+      const product = point.dot(new Vector39(...axis.coordinates));
+      if (product > closestMoveDotProduct) {
+        const modified = this.stickerDat.notationMapper.notationToExternal(
+          modify(axis.quantumMove)
+        );
+        if (!modified || !this.#isValidMove(modified)) {
+          continue;
+        }
+        closestMoveDotProduct = product;
+        closestMove = modified;
+      }
+    }
+    if (!closestMove) {
+      return null;
+    }
+    if (transformations.invert) {
+      closestMove = closestMove.invert();
+    }
+    const order = this.kpuzzle.moveToTransformation(closestMove).repetitionOrder();
+    return { move: closestMove, order };
+  }
+  setStickeringMask(stickeringMask) {
+    for (const orbitDefinition of stickeringMask.specialBehaviour === "picture" ? [] : this.kpuzzle.definition.orbits) {
+      const { orbitName, numPieces, numOrientations } = orbitDefinition;
+      const orbitFacelets = this.#facelets[orbitName];
+      if (!orbitFacelets) {
+        continue;
+      }
+      for (let ori = 0; ori < numOrientations; ori++) {
+        for (let ord = 0; ord < numPieces; ord++) {
+          const facelet = orbitFacelets[ori]?.[ord];
+          if (!facelet) {
+            continue;
+          }
+          facelet.mask = getFaceletStickeringMask(
+            stickeringMask,
+            orbitName,
+            ord,
+            ori,
+            false
+          );
+          facelet.hintMask = getFaceletStickeringMask(
+            stickeringMask,
+            orbitName,
+            ord,
+            ori,
+            true
+          );
+        }
+      }
+    }
+    this.#pendingStickeringUpdate = true;
+    if (this.#lastPosition) {
+      this.onPositionChange(this.#lastPosition);
+    }
+  }
+  /** @deprecated */
+  experimentalUpdateOptions(options) {
+    if (options.hintFacelets !== void 0) {
+      this.#materials[HINT_MATERIAL_INDEX] = options.hintFacelets === "none" ? invisibleMaterial2 : this.#hintMaterial;
+      this.scheduleRenderCallback();
+    }
+  }
+  /** @deprecated */
+  experimentalUpdateTexture(enabled, stickerTexture, _hintTexture) {
+    if (enabled && stickerTexture) {
+      console.warn(
+        "Sprites are not supported for stickerless pieces. For now, set the sprite before creating the TwistyPlayer."
+      );
+    }
+  }
+  onPositionChange(position) {
+    const { pattern } = position;
+    if (this.#pendingStickeringUpdate || !this.#lastPosition || !this.#lastPosition.pattern.isIdentical(pattern)) {
+      this.#updateColors(position);
+      this.#lastPosition = position;
+      this.#pendingStickeringUpdate = false;
+    }
+    for (const piece of this.#turningPieces) {
+      piece.mesh.matrix.copy(piece.home);
+    }
+    this.#turningPieces.length = 0;
+    const turnMatrix = new Matrix44();
+    for (const moveProgress of position.movesInProgress) {
+      const move = moveProgress.move;
+      const unswizzled = this.stickerDat.unswizzle(move);
+      if (!unswizzled) {
+        continue;
+      }
+      const axisInfo = this.#axesInfo[unswizzled.family];
+      if (!axisInfo) {
+        continue;
+      }
+      turnMatrix.makeRotationAxis(
+        axisInfo.axis,
+        -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);
+      }
+    }
+    this.scheduleRenderCallback();
+  }
+  /**
+   * The pieces a single quantum of `move` sweeps: the ones whose slot does not
+   * map to itself.
+   */
+  #piecesTurnedBy(move) {
+    const quantum = move.modified({ amount: 1 });
+    const key = quantum.toString();
+    const cached = this.#turnedPieces.get(key);
+    if (cached) {
+      return cached;
+    }
+    const pieces = [];
+    const { transformationData } = this.#quantumTransformation(quantum);
+    for (const orbitName in this.#facelets) {
+      const orbitTransformation = transformationData[orbitName];
+      if (!orbitTransformation) {
+        continue;
+      }
+      const { permutation, orientationDelta } = orbitTransformation;
+      const slots = this.#facelets[orbitName][0];
+      for (let ord = 0; ord < permutation.length; ord++) {
+        if (permutation[ord] !== ord || orientationDelta[ord] !== 0) {
+          const slot = slots[ord];
+          if (slot) {
+            pieces.push(slot.piece);
+          }
+        }
+      }
+    }
+    this.#turnedPieces.set(key, pieces);
+    return pieces;
+  }
+  #quantumTransformation(quantum) {
+    try {
+      return this.kpuzzle.moveToTransformation(quantum);
+    } catch (e) {
+      const internal = this.stickerDat.notationMapper.notationToInternal(quantum);
+      const external = internal && this.stickerDat.notationMapper.notationToExternal(
+        internal.modified({ amount: 1 })
+      );
+      if (!external) {
+        throw e;
+      }
+      return this.kpuzzle.moveToTransformation(external);
+    }
+  }
+  /** Repaints every slot with the colors of whatever piece is now in it. */
+  #updateColors(position) {
+    for (const orbitName in this.#facelets) {
+      const orbitFacelets = this.#facelets[orbitName];
+      const orbitPattern = position.pattern.patternData[orbitName];
+      const numOrientations = orbitFacelets.length;
+      for (let ori = 0; ori < numOrientations; ori++) {
+        const slots = orbitFacelets[ori];
+        for (let ord = 0; ord < slots.length; ord++) {
+          const slot = slots[ord];
+          if (!slot) {
+            continue;
+          }
+          const sourceOri = numOrientations === 1 ? 0 : (ori + numOrientations - orbitPattern.orientation[ord]) % numOrientations;
+          const source = orbitFacelets[sourceOri][orbitPattern.pieces[ord]];
+          const key = faceletAppearanceKey(
+            source.faceStyle,
+            source.mask,
+            source.hintMask
+          );
+          if (key === slot.appearanceKey) {
+            continue;
+          }
+          slot.appearanceKey = key;
+          if (slot.body.length === 0 && slot.hint.length === 0) {
+            continue;
+          }
+          const appearance = faceletAppearance(
+            this.#appearances,
+            this.plan.faceStyles,
+            source.faceStyle,
+            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);
+        }
+      }
+    }
+    for (const colors of this.#dirtyColors) {
+      colors.needsUpdate = true;
+    }
+    this.#dirtyColors.clear();
+  }
+};
+
 // src/cubing/twisty/heavy-code-imports/dynamic-entries/twisty-dynamic-3d.ts
 import { PerspectiveCamera } from "three/src/cameras/PerspectiveCamera.js";
 import { Raycaster } from "three/src/core/Raycaster.js";
 import { TextureLoader as TextureLoader2 } from "three/src/loaders/TextureLoader.js";
 import { Spherical } from "three/src/math/Spherical.js";
 import { Vector2 as Vector22 } from "three/src/math/Vector2.js";
-import { Vector3 as Vector34 } from "three/src/math/Vector3.js";
+import { Vector3 as Vector310 } from "three/src/math/Vector3.js";
 import { WebGLRenderer } from "three/src/renderers/WebGLRenderer.js";
 import { Scene } from "three/src/scenes/Scene.js";
 
@@ -2393,11 +3996,19 @@ async function square1_3DShim(renderCallback, puzzleLoader, faceletScale) {
     faceletScale
   });
 }
-async function pg3dShim(renderCallback, puzzleLoader, hintFacelets, faceletScale, darkIgnoredOrbits) {
+async function pg3dShim(renderCallback, puzzleLoader, hintFacelets, faceletScale, darkIgnoredOrbits, pictureCube = false) {
+  const kpuzzle = await puzzleLoader.kpuzzle();
+  const stickerDat = (await puzzleLoader.pg()).get3d({ darkIgnoredOrbits });
+  const plan = darkIgnoredOrbits || pictureCube ? null : cubePuzzlePlan(stickerDat) ?? solidPuzzlePlan(stickerDat);
+  if (plan) {
+    return new Stickerless3D(renderCallback, kpuzzle, stickerDat, plan, {
+      hintFacelets
+    });
+  }
   return new PG3D(
     renderCallback,
-    await puzzleLoader.kpuzzle(),
-    (await puzzleLoader.pg()).get3d({ darkIgnoredOrbits }),
+    kpuzzle,
+    stickerDat,
     true,
     hintFacelets === "floating",
     void 0,
@@ -2408,17 +4019,18 @@ export {
   Cube3D,
   PG3D,
   Square1_3D,
+  Stickerless3D,
   PerspectiveCamera as ThreePerspectiveCamera,
   Raycaster as ThreeRaycaster,
   Scene as ThreeScene,
   Spherical as ThreeSpherical,
   TextureLoader2 as ThreeTextureLoader,
   Vector22 as ThreeVector2,
-  Vector34 as ThreeVector3,
+  Vector310 as ThreeVector3,
   WebGLRenderer as ThreeWebGLRenderer,
   Twisty3DScene,
   cube3DShim,
   pg3dShim,
   square1_3DShim
 };
-//# sourceMappingURL=twisty-dynamic-3d-XQOH6E2O.js.map
+//# sourceMappingURL=twisty-dynamic-3d-SLKSUJTE.js.map