@operato/scene-storage 10.0.0-beta.43 → 10.0.0-beta.44

package/package.json

@@ -2,7 +2,7 @@
   "name": "@operato/scene-storage",
   "description": "Storage-domain components for things-scene (smart factory / logistics) — pallet, box, parcel; AS/RS and shelves planned.",
   "author": "heartyoh",
-  "version": "10.0.0-beta.43",
+  "version": "10.0.0-beta.44",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -45,5 +45,5 @@
     "typescript": "^5.0.4"
   },
   "prettier": "@hatiolab/prettier-config",
-  "gitHead": "6e92206ada64b1b0d4e6a4f73ee34ee99e87bd57"
+  "gitHead": "c9abb002847f21c028102ba5eb489fb57b2dd95e"
 }

package/src/box-3d.ts

@@ -16,6 +16,55 @@ import * as THREE from 'three'
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js'
 import { RealObjectGroup } from '@hatiolab/things-scene'
 
+// ── Material cache by bodyColor (shared across all Box3D instances) ──
+const woodBodyMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const woodPostMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const plasticToteMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const plasticLipMaterials = new Map<string, THREE.MeshStandardMaterial>()
+
+function getWoodBodyMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = woodBodyMaterials.get(bodyColor)
+  if (!m) {
+    m = new THREE.MeshStandardMaterial({ color: bodyColor, metalness: 0, roughness: 0.85 })
+    woodBodyMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getWoodPostMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = woodPostMaterials.get(bodyColor)
+  if (!m) {
+    const tint = new THREE.Color(bodyColor).multiplyScalar(0.8)
+    m = new THREE.MeshStandardMaterial({ color: tint, metalness: 0, roughness: 0.9 })
+    woodPostMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getPlasticToteMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = plasticToteMaterials.get(bodyColor)
+  if (!m) {
+    m = new THREE.MeshStandardMaterial({ color: bodyColor, metalness: 0.05, roughness: 0.55 })
+    plasticToteMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getPlasticLipMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = plasticLipMaterials.get(bodyColor)
+  if (!m) {
+    const tint = new THREE.Color(bodyColor).multiplyScalar(0.85)
+    m = new THREE.MeshStandardMaterial({ color: tint, metalness: 0.05, roughness: 0.55 })
+    plasticLipMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+// ── Geometry cache by size (shared across all Box3D instances) ──
+// Floor geo는 local 좌표 + mesh position 으로 두어 mesh 별 position 만 다름.
+const woodGeoCache = new Map<string, { posts: THREE.BufferGeometry; slats: THREE.BufferGeometry; floor: THREE.BufferGeometry; floorY: number }>()
+const plasticGeoCache = new Map<string, { walls: THREE.BufferGeometry; lip: THREE.BufferGeometry; floor: THREE.BufferGeometry; floorY: number }>()
+
 export class Box3D extends RealObjectGroup {
   build() {
     super.build()
@@ -33,6 +82,31 @@ export class Box3D extends RealObjectGroup {
 
   /** Wood crate — visible slats, 4 corner posts, open top. */
   private buildWoodCrate(width: number, height: number, depth: number, bodyColor: string) {
+    const { posts, slats, floor, floorY } = this.getWoodGeometries(width, height, depth)
+
+    const woodMaterial = getWoodBodyMaterial(bodyColor)
+    const postMaterial = getWoodPostMaterial(bodyColor)
+
+    const postMesh = new THREE.Mesh(posts, postMaterial)
+    postMesh.castShadow = true
+    this.object3d.add(postMesh)
+
+    const slatMesh = new THREE.Mesh(slats, woodMaterial)
+    slatMesh.castShadow = true
+    slatMesh.receiveShadow = true
+    this.object3d.add(slatMesh)
+
+    const floorMesh = new THREE.Mesh(floor, woodMaterial)
+    floorMesh.position.set(0, floorY, 0)
+    floorMesh.receiveShadow = true
+    this.object3d.add(floorMesh)
+  }
+
+  private getWoodGeometries(width: number, height: number, depth: number) {
+    const key = `${width}|${height}|${depth}`
+    let cached = woodGeoCache.get(key)
+    if (cached) return cached
+
     const baseY = -depth / 2
     const wallThickness = Math.min(width, height) * 0.04
     const postW = wallThickness * 1.6
@@ -40,19 +114,6 @@ export class Box3D extends RealObjectGroup {
     const slatGap = slatH * 0.6
     const floorH = depth * 0.05
 
-    const woodMaterial = new THREE.MeshStandardMaterial({
-      color: bodyColor,
-      metalness: 0,
-      roughness: 0.85
-    })
-    const postColor = new THREE.Color(bodyColor).multiplyScalar(0.8)
-    const postMaterial = new THREE.MeshStandardMaterial({
-      color: postColor,
-      metalness: 0,
-      roughness: 0.9
-    })
-
-    // ── 4 corner posts ───────────────────────────────────────────────
     const postGeos: THREE.BufferGeometry[] = []
     for (const xSign of [-1, 1]) {
       for (const zSign of [-1, 1]) {
@@ -65,108 +126,100 @@ export class Box3D extends RealObjectGroup {
         postGeos.push(post)
       }
     }
-    const postMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(postGeos), postMaterial)
-    postMesh.castShadow = true
-    this.object3d.add(postMesh)
+    const posts = BufferGeometryUtils.mergeGeometries(postGeos)
 
-    // ── Slatted walls (horizontal slats with gaps) ───────────────────
     const slatRowCount = Math.max(2, Math.floor((depth - floorH) / (slatH + slatGap)))
     const slatGeos: THREE.BufferGeometry[] = []
-
     for (let row = 0; row < slatRowCount; row++) {
       const y = baseY + floorH + slatGap + row * (slatH + slatGap) + slatH / 2
-      // Long walls (front / back)
       for (const zSign of [-1, 1]) {
         const slat = new THREE.BoxGeometry(width - postW * 2, slatH, wallThickness)
         slat.translate(0, y, zSign * (height / 2 - wallThickness / 2))
         slatGeos.push(slat)
       }
-      // Short walls (left / right)
       for (const xSign of [-1, 1]) {
         const slat = new THREE.BoxGeometry(wallThickness, slatH, height - postW * 2)
         slat.translate(xSign * (width / 2 - wallThickness / 2), y, 0)
         slatGeos.push(slat)
       }
     }
-    const slatMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(slatGeos), woodMaterial)
-    slatMesh.castShadow = true
-    slatMesh.receiveShadow = true
-    this.object3d.add(slatMesh)
+    const slats = BufferGeometryUtils.mergeGeometries(slatGeos)
 
-    // ── Floor (bottom panel) ─────────────────────────────────────────
-    const floorGeo = new THREE.BoxGeometry(width - postW * 2, floorH, height - postW * 2)
-    const floorMesh = new THREE.Mesh(floorGeo, woodMaterial)
-    floorMesh.position.set(0, baseY + floorH / 2, 0)
-    floorMesh.receiveShadow = true
-    this.object3d.add(floorMesh)
+    const floor = new THREE.BoxGeometry(width - postW * 2, floorH, height - postW * 2)
+    const floorY = baseY + floorH / 2
+
+    cached = { posts, slats, floor, floorY }
+    woodGeoCache.set(key, cached)
+    return cached
   }
 
   /** Plastic tote — solid molded walls + top stackable lip. */
   private buildPlasticTote(width: number, height: number, depth: number, bodyColor: string) {
+    const { walls, lip, floor, floorY } = this.getPlasticGeometries(width, height, depth)
+
+    const totMaterial = getPlasticToteMaterial(bodyColor)
+    const lipMaterial = getPlasticLipMaterial(bodyColor)
+
+    const wallMesh = new THREE.Mesh(walls, totMaterial)
+    wallMesh.castShadow = true
+    wallMesh.receiveShadow = true
+    this.object3d.add(wallMesh)
+
+    const lipMesh = new THREE.Mesh(lip, lipMaterial)
+    lipMesh.castShadow = true
+    this.object3d.add(lipMesh)
+
+    const floorMesh = new THREE.Mesh(floor, totMaterial)
+    floorMesh.position.set(0, floorY, 0)
+    floorMesh.receiveShadow = true
+    this.object3d.add(floorMesh)
+  }
+
+  private getPlasticGeometries(width: number, height: number, depth: number) {
+    const key = `${width}|${height}|${depth}`
+    let cached = plasticGeoCache.get(key)
+    if (cached) return cached
+
     const baseY = -depth / 2
     const wallThickness = Math.min(width, height) * 0.05
     const lipH = depth * 0.06
     const floorH = depth * 0.06
 
-    const totMaterial = new THREE.MeshStandardMaterial({
-      color: bodyColor,
-      metalness: 0.05,
-      roughness: 0.55
-    })
-    const lipColor = new THREE.Color(bodyColor).multiplyScalar(0.85)
-    const lipMaterial = new THREE.MeshStandardMaterial({
-      color: lipColor,
-      metalness: 0.05,
-      roughness: 0.55
-    })
-
-    // ── 4 solid walls ────────────────────────────────────────────────
     const wallGeos: THREE.BufferGeometry[] = []
     const wallH = depth - lipH - floorH
     const wallY = baseY + floorH + wallH / 2
-
-    // Long walls
     for (const zSign of [-1, 1]) {
       const wall = new THREE.BoxGeometry(width, wallH, wallThickness)
       wall.translate(0, wallY, zSign * (height / 2 - wallThickness / 2))
       wallGeos.push(wall)
     }
-    // Short walls
     for (const xSign of [-1, 1]) {
       const wall = new THREE.BoxGeometry(wallThickness, wallH, height - 2 * wallThickness)
       wall.translate(xSign * (width / 2 - wallThickness / 2), wallY, 0)
       wallGeos.push(wall)
     }
-    const wallMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(wallGeos), totMaterial)
-    wallMesh.castShadow = true
-    wallMesh.receiveShadow = true
-    this.object3d.add(wallMesh)
+    const walls = BufferGeometryUtils.mergeGeometries(wallGeos)
 
-    // ── Top lip (stackable rim — slightly wider than walls) ──────────
     const lipGeos: THREE.BufferGeometry[] = []
     const lipY = baseY + depth - lipH / 2
-    // Long sides
     for (const zSign of [-1, 1]) {
-      const lip = new THREE.BoxGeometry(width * 1.02, lipH, wallThickness * 1.5)
-      lip.translate(0, lipY, zSign * (height / 2 - wallThickness * 0.75))
-      lipGeos.push(lip)
+      const lipG = new THREE.BoxGeometry(width * 1.02, lipH, wallThickness * 1.5)
+      lipG.translate(0, lipY, zSign * (height / 2 - wallThickness * 0.75))
+      lipGeos.push(lipG)
     }
-    // Short sides
     for (const xSign of [-1, 1]) {
-      const lip = new THREE.BoxGeometry(wallThickness * 1.5, lipH, height * 1.02 - 2 * wallThickness * 1.5)
-      lip.translate(xSign * (width / 2 - wallThickness * 0.75), lipY, 0)
-      lipGeos.push(lip)
+      const lipG = new THREE.BoxGeometry(wallThickness * 1.5, lipH, height * 1.02 - 2 * wallThickness * 1.5)
+      lipG.translate(xSign * (width / 2 - wallThickness * 0.75), lipY, 0)
+      lipGeos.push(lipG)
     }
-    const lipMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(lipGeos), lipMaterial)
-    lipMesh.castShadow = true
-    this.object3d.add(lipMesh)
+    const lip = BufferGeometryUtils.mergeGeometries(lipGeos)
 
-    // ── Floor (solid bottom) ─────────────────────────────────────────
-    const floorGeo = new THREE.BoxGeometry(width, floorH, height)
-    const floorMesh = new THREE.Mesh(floorGeo, totMaterial)
-    floorMesh.position.set(0, baseY + floorH / 2, 0)
-    floorMesh.receiveShadow = true
-    this.object3d.add(floorMesh)
+    const floor = new THREE.BoxGeometry(width, floorH, height)
+    const floorY = baseY + floorH / 2
+
+    cached = { walls, lip, floor, floorY }
+    plasticGeoCache.set(key, cached)
+    return cached
   }
 
   updateDimension() {}

package/src/pallet-3d.ts

@@ -21,6 +21,57 @@ import * as THREE from 'three'
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js'
 import { RealObjectGroup } from '@hatiolab/things-scene'
 
+// ── Material cache by bodyColor (shared across all Pallet3D instances) ──
+// 동일 bodyColor 의 pallet 수십~수백 개 → GPU material 인스턴스 *1개로 통합*.
+const woodBodyMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const woodStringerMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const plasticDeckMaterials = new Map<string, THREE.MeshStandardMaterial>()
+const plasticFootMaterials = new Map<string, THREE.MeshStandardMaterial>()
+
+function getWoodBodyMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = woodBodyMaterials.get(bodyColor)
+  if (!m) {
+    m = new THREE.MeshStandardMaterial({ color: bodyColor, metalness: 0.0, roughness: 0.85 })
+    woodBodyMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getWoodStringerMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = woodStringerMaterials.get(bodyColor)
+  if (!m) {
+    const tint = new THREE.Color(bodyColor).multiplyScalar(0.85)
+    m = new THREE.MeshStandardMaterial({ color: tint, metalness: 0.0, roughness: 0.9 })
+    woodStringerMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getPlasticDeckMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = plasticDeckMaterials.get(bodyColor)
+  if (!m) {
+    m = new THREE.MeshStandardMaterial({ color: bodyColor, metalness: 0.1, roughness: 0.55 })
+    plasticDeckMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+function getPlasticFootMaterial(bodyColor: string): THREE.MeshStandardMaterial {
+  let m = plasticFootMaterials.get(bodyColor)
+  if (!m) {
+    const tint = new THREE.Color(bodyColor).multiplyScalar(0.85)
+    m = new THREE.MeshStandardMaterial({ color: tint, metalness: 0.1, roughness: 0.65 })
+    plasticFootMaterials.set(bodyColor, m)
+  }
+  return m
+}
+
+// ── Geometry cache by size (shared across all Pallet3D instances) ──
+// 동일 width × height × depth 의 pallet → merged geometry *1세트*만 GPU 에 업로드.
+// Translation / merge 비용도 동일 size pallet 끼리 *1회*만 발생.
+const woodGeoCache = new Map<string, { top: THREE.BufferGeometry; stringer: THREE.BufferGeometry; bottom: THREE.BufferGeometry }>()
+const plasticGeoCache = new Map<string, { deck: THREE.BufferGeometry; feet: THREE.BufferGeometry; brace: THREE.BufferGeometry }>()
+
 export class Pallet3D extends RealObjectGroup {
   build() {
     super.build()
@@ -38,28 +89,36 @@ export class Pallet3D extends RealObjectGroup {
 
   /** Wood EUR-style: 7 top slats + 3 stringers + 5 bottom slats. */
   private buildWood(width: number, height: number, depth: number, bodyColor: string) {
+    const { top, stringer, bottom } = this.getWoodGeometries(width, height, depth)
+
+    const woodMaterial = getWoodBodyMaterial(bodyColor)
+    const stringerMaterial = getWoodStringerMaterial(bodyColor)
+
+    const topSlatMesh = new THREE.Mesh(top, woodMaterial)
+    topSlatMesh.castShadow = true
+    topSlatMesh.receiveShadow = true
+    this.object3d.add(topSlatMesh)
+
+    const stringerMesh = new THREE.Mesh(stringer, stringerMaterial)
+    stringerMesh.castShadow = true
+    this.object3d.add(stringerMesh)
+
+    const botSlatMesh = new THREE.Mesh(bottom, woodMaterial)
+    botSlatMesh.receiveShadow = true
+    this.object3d.add(botSlatMesh)
+  }
+
+  private getWoodGeometries(width: number, height: number, depth: number) {
+    const key = `${width}|${height}|${depth}`
+    let cached = woodGeoCache.get(key)
+    if (cached) return cached
+
     const baseY = -depth / 2
     const slatThickness = depth * 0.15
     const stringerThickness = depth * 0.45
     const bottomSlatThickness = depth * 0.13
 
-    const woodMaterial = new THREE.MeshStandardMaterial({
-      color: bodyColor,
-      metalness: 0.0,
-      roughness: 0.85
-    })
-    const stringerColor = new THREE.Color(bodyColor).multiplyScalar(0.85)
-    const stringerMaterial = new THREE.MeshStandardMaterial({
-      color: stringerColor,
-      metalness: 0.0,
-      roughness: 0.9
-    })
-
-    // ── Top + bottom slats — same count, same z-positions, paired vertically ─
-    // EUR-pallet style: 5 boards on top, 5 below (under the same z ranges so
-    // they read as a single skeleton rather than two unrelated grids).
     const slatCount = 5
-    const slatW = width
     const slatD = (height * 0.92) / (slatCount + (slatCount - 1) * 0.4)
     const gapD = slatD * 0.4
     const totalSpan = slatCount * slatD + (slatCount - 1) * gapD
@@ -72,16 +131,12 @@ export class Pallet3D extends RealObjectGroup {
 
     const topSlatGeos: THREE.BufferGeometry[] = []
     for (const z of slatPositions) {
-      const slat = new THREE.BoxGeometry(slatW, slatThickness, slatD)
+      const slat = new THREE.BoxGeometry(width, slatThickness, slatD)
       slat.translate(0, baseY + depth - slatThickness / 2, z)
       topSlatGeos.push(slat)
     }
-    const topSlatMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(topSlatGeos), woodMaterial)
-    topSlatMesh.castShadow = true
-    topSlatMesh.receiveShadow = true
-    this.object3d.add(topSlatMesh)
+    const top = BufferGeometryUtils.mergeGeometries(topSlatGeos)
 
-    // ── Stringers (3 perpendicular blocks between top and bottom decks) ─
     const stringerCount = 3
     const stringerW = width * 0.07
     const stringerY = baseY + bottomSlatThickness + stringerThickness / 2
@@ -93,50 +148,59 @@ export class Pallet3D extends RealObjectGroup {
       stringer.translate(x, stringerY, 0)
       stringerGeos.push(stringer)
     }
-    const stringerMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(stringerGeos), stringerMaterial)
-    stringerMesh.castShadow = true
-    this.object3d.add(stringerMesh)
+    const stringer = BufferGeometryUtils.mergeGeometries(stringerGeos)
 
-    // ── Bottom slats — same z-positions as top so the deck reads as paired ─
     const botSlatGeos: THREE.BufferGeometry[] = []
     for (const z of slatPositions) {
       const slat = new THREE.BoxGeometry(width, bottomSlatThickness, slatD)
       slat.translate(0, baseY + bottomSlatThickness / 2, z)
       botSlatGeos.push(slat)
     }
-    const botSlatMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(botSlatGeos), woodMaterial)
-    botSlatMesh.receiveShadow = true
-    this.object3d.add(botSlatMesh)
+    const bottom = BufferGeometryUtils.mergeGeometries(botSlatGeos)
+
+    cached = { top, stringer, bottom }
+    woodGeoCache.set(key, cached)
+    return cached
   }
 
   /** Plastic molded: solid top deck + ribbed underside / feet. */
   private buildPlastic(width: number, height: number, depth: number, bodyColor: string) {
+    const { deck, feet, brace } = this.getPlasticGeometries(width, height, depth)
+
+    const deckMaterial = getPlasticDeckMaterial(bodyColor)
+    const footMaterial = getPlasticFootMaterial(bodyColor)
+
     const baseY = -depth / 2
     const deckThickness = depth * 0.30
-    const footH = depth * 0.55
-    const footW = width * 0.12
 
-    const deckMaterial = new THREE.MeshStandardMaterial({
-      color: bodyColor,
-      metalness: 0.1,
-      roughness: 0.55
-    })
-    const footColor = new THREE.Color(bodyColor).multiplyScalar(0.85)
-    const footMaterial = new THREE.MeshStandardMaterial({
-      color: footColor,
-      metalness: 0.1,
-      roughness: 0.65
-    })
-
-    // ── Solid top deck ───────────────────────────────────────────────
-    const deckGeo = new THREE.BoxGeometry(width * 0.98, deckThickness, height * 0.98)
-    const deckMesh = new THREE.Mesh(deckGeo, deckMaterial)
+    const deckMesh = new THREE.Mesh(deck, deckMaterial)
     deckMesh.position.set(0, baseY + depth - deckThickness / 2, 0)
     deckMesh.castShadow = true
     deckMesh.receiveShadow = true
     this.object3d.add(deckMesh)
 
-    // ── 9 feet (3×3 grid — typical plastic pallet underside) ─────────
+    const footMesh = new THREE.Mesh(feet, footMaterial)
+    footMesh.castShadow = true
+    this.object3d.add(footMesh)
+
+    const braceMesh = new THREE.Mesh(brace, footMaterial)
+    this.object3d.add(braceMesh)
+  }
+
+  private getPlasticGeometries(width: number, height: number, depth: number) {
+    const key = `${width}|${height}|${depth}`
+    let cached = plasticGeoCache.get(key)
+    if (cached) return cached
+
+    const baseY = -depth / 2
+    const deckThickness = depth * 0.30
+    const footH = depth * 0.55
+    const footW = width * 0.12
+
+    // Deck geo — local space; mesh position applied at instantiation.
+    const deck = new THREE.BoxGeometry(width * 0.98, deckThickness, height * 0.98)
+
+    // 9 feet (3×3 grid) → merged geometry with translations baked in.
     const footGeos: THREE.BufferGeometry[] = []
     for (let i = -1; i <= 1; i++) {
       for (let j = -1; j <= 1; j++) {
@@ -147,18 +211,21 @@ export class Pallet3D extends RealObjectGroup {
         footGeos.push(foot)
       }
     }
-    const footMesh = new THREE.Mesh(BufferGeometryUtils.mergeGeometries(footGeos), footMaterial)
-    footMesh.castShadow = true
-    this.object3d.add(footMesh)
+    const feet = BufferGeometryUtils.mergeGeometries(footGeos)
 
-    // ── Cross-bracing along underside (suggests molded reinforcement) ─
+    // 3 braces → merged into single mesh (이전에 mesh 3개 분리 = drawcall 3개).
     const braceH = depth * 0.10
-    const braceGeo = new THREE.BoxGeometry(width * 0.95, braceH, height * 0.04)
+    const braceGeos: THREE.BufferGeometry[] = []
     for (const zSign of [-1, 0, 1]) {
-      const brace = new THREE.Mesh(braceGeo.clone(), footMaterial)
-      brace.position.set(0, baseY + footH - braceH / 2, zSign * height * 0.4)
-      this.object3d.add(brace)
+      const b = new THREE.BoxGeometry(width * 0.95, braceH, height * 0.04)
+      b.translate(0, baseY + footH - braceH / 2, zSign * height * 0.4)
+      braceGeos.push(b)
     }
+    const brace = BufferGeometryUtils.mergeGeometries(braceGeos)
+
+    cached = { deck, feet, brace }
+    plasticGeoCache.set(key, cached)
+    return cached
   }
 
   updateDimension() {}