partforge 0.39.0 → 0.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",

package/src/framework/cutaway-gizmo.js

@@ -2,6 +2,7 @@ import * as THREE from "three";
 import {
   axisParameterFromRay,
   signedAngleAroundAxis,
+  snapQuaternionToAxis,
 } from "./cutaway-math.js";
 import { CUTAWAY_OVERLAY_RENDER_ORDER } from "./cutaway-render.js";
 
@@ -46,6 +47,7 @@ export function createCutawayGizmo({
   onPoseChange = () => {},
   onActivity = () => {},
   onHandleHoverChange = () => {},
+  onDragChange = () => {},
   pickHandle,
 }) {
   const group = new THREE.Group();
@@ -261,6 +263,7 @@ export function createCutawayGizmo({
   let activeAppearance = true;
   let themeMode = "dark";
   const raycaster = new THREE.Raycaster();
+  const _snapped = new THREE.Quaternion();
   const hitProxies = Object.values(handles);
 
   function rayFromEvent(event) {
@@ -326,6 +329,7 @@ export function createCutawayGizmo({
     drag = null;
     if (orbitControls) orbitControls.enabled = ending.orbitEnabled;
     safeRelease(ending.pointerId);
+    onDragChange(false);
   }
 
   function updateAppearance() {
@@ -361,6 +365,15 @@ export function createCutawayGizmo({
     onHandleHoverChange(normalized);
   }
 
+  // Rotation lands on a canonical axis when it gets close to one. Shift is read
+  // per move rather than latched at pointer-down, so it can be pressed and
+  // released mid-drag; it is unbound during a gizmo drag because orbit controls
+  // are already disabled.
+  function snapRotation(candidate, event) {
+    candidate.normalize();
+    return event.shiftKey ? candidate : snapQuaternionToAxis(candidate, undefined, _snapped);
+  }
+
   function notifyPose() {
     onPoseChange({
       position: group.position.clone(),
@@ -468,6 +481,7 @@ export function createCutawayGizmo({
     setHoveredHandle(handle);
     onActivity();
     drag = nextDrag;
+    onDragChange(true);
     if (orbitControls) orbitControls.enabled = false;
     safeCapture(event.pointerId);
     event.preventDefault();
@@ -512,7 +526,7 @@ export function createCutawayGizmo({
         * SCREEN_ROTATION_RADIANS_PER_PIXEL;
       if (!Number.isFinite(angle)) return;
       const delta = new THREE.Quaternion().setFromAxisAngle(drag.axis, angle);
-      group.quaternion.copy(delta.multiply(drag.startQuaternion)).normalize();
+      group.quaternion.copy(snapRotation(delta.multiply(drag.startQuaternion), event));
       group.position.copy(drag.startPosition);
       syncHandleTransform();
       notifyPose();
@@ -527,7 +541,7 @@ export function createCutawayGizmo({
     const angle = signedAngleAroundAxis(drag.startRadial, radial, drag.axis);
     if (!Number.isFinite(angle)) return;
     const delta = new THREE.Quaternion().setFromAxisAngle(drag.axis, angle);
-    group.quaternion.copy(delta.multiply(drag.startQuaternion)).normalize();
+    group.quaternion.copy(snapRotation(delta.multiply(drag.startQuaternion), event));
     group.position.copy(drag.startPosition);
     syncHandleTransform();
     notifyPose();

package/src/framework/cutaway-math.js

@@ -4,10 +4,38 @@ const PLANE_LOCAL_NORMAL = new THREE.Vector3(0, 0, 1);
 const POINT_EPSILON = 1e-6;
 const PARALLEL_EPSILON = 1e-6;
 
+// Nearest signed canonical axis (+/-X, +/-Y, +/-Z) to `direction`. Axes are
+// scanned X, Y, Z and replaced only on a strictly larger |component|, so a tie
+// resolves to the earlier axis — the default isometric framing is an exact tie
+// between -X and -Z and lands on -X. Degenerate input falls back to +Z.
+export function nearestCanonicalAxis(direction, target = new THREE.Vector3()) {
+  const components = [direction.x, direction.y, direction.z];
+  if (!components.every(Number.isFinite)) return target.set(0, 0, 1);
+
+  let bestIndex = -1;
+  let bestScore = 0;
+  for (let i = 0; i < 3; i++) {
+    const score = Math.abs(components[i]);
+    if (score > bestScore) {
+      bestScore = score;
+      bestIndex = i;
+    }
+  }
+  if (bestIndex < 0) return target.set(0, 0, 1);
+
+  // Built by setComponent rather than negating a unit axis: multiplying a zero
+  // component by -1 yields -0, and toEqual([0, -1, 0]) does not accept -0.
+  return target.set(0, 0, 0).setComponent(bestIndex, components[bestIndex] < 0 ? -1 : 1);
+}
+
 export function initialCutawayPose(box, camera) {
   const position = box.getCenter(new THREE.Vector3());
   const diagonal = Math.max(box.getSize(new THREE.Vector3()).length(), 1);
-  const normal = camera.getWorldDirection(new THREE.Vector3()).normalize();
+  // Square the cut plane up with the part rather than the camera: the axis
+  // nearest the view direction, so the near half is still what gets cut away.
+  const normal = nearestCanonicalAxis(
+    camera.getWorldDirection(new THREE.Vector3()).normalize(),
+  );
   const quaternion = new THREE.Quaternion().setFromUnitVectors(
     PLANE_LOCAL_NORMAL,
     normal,
@@ -20,6 +48,27 @@ export function initialCutawayPose(box, camera) {
   };
 }
 
+export const AXIS_SNAP_RADIANS = (7 * Math.PI) / 180;
+
+// Pull a plane pose onto the nearest canonical axis once its normal is within
+// `maxAngle` of one. The correction is the minimal rotation carrying the normal
+// onto the axis, not a rebuilt quaternion, so the plane's in-plane roll survives
+// and the gizmo rings do not visibly spin at the moment of snapping. Roll does
+// not affect the clip either way.
+export function snapQuaternionToAxis(
+  quaternion,
+  maxAngle = AXIS_SNAP_RADIANS,
+  target = new THREE.Quaternion(),
+) {
+  const normal = PLANE_LOCAL_NORMAL.clone().applyQuaternion(quaternion).normalize();
+  const axis = nearestCanonicalAxis(normal);
+  if (normal.angleTo(axis) > maxAngle) return target.copy(quaternion);
+  return target
+    .setFromUnitVectors(normal, axis)
+    .multiply(quaternion)
+    .normalize();
+}
+
 export function planeFromPose(plane, normalTarget, position, quaternion, flipped) {
   normalTarget.copy(PLANE_LOCAL_NORMAL).applyQuaternion(quaternion).normalize();
   if (flipped) normalTarget.negate();

package/src/framework/cutaway-outline.js

@@ -0,0 +1,233 @@
+import * as THREE from "three";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+
+// Matches POINT_EPSILON in cutaway-math.js: a vertex this close to the plane
+// counts as lying on it, so a grazing plane produces neither duplicate nor
+// zero-length segments.
+const ON_PLANE_EPSILON = 1e-6;
+
+const _vertices = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+const _distances = [0, 0, 0];
+const _signs = [0, 0, 0];
+const _crossing = new THREE.Vector3();
+
+// Plane/triangle intersection over a BufferGeometry, in the geometry's own
+// frame. Emits one segment per crossing triangle. Handles indexed (OCCT) and
+// non-indexed (Manifold) geometry alike.
+//
+// Degenerate contact is resolved so each boundary edge is emitted exactly once:
+//   - a triangle lying in the plane emits nothing; its neighbours bound it;
+//   - a triangle touching the plane at one vertex only emits nothing;
+//   - a triangle with an edge in the plane emits that edge only when its third
+//     vertex is on the clipped side, so the two triangles sharing that edge do
+//     not both emit it.
+//
+// Known limitation: that last rule reads only its own triangle, so it cannot
+// tell "the neighbour is on the other side" (a real crossing, one emission)
+// from "the neighbour is also clipped" (a ridge merely tangent to the plane,
+// two emissions of the same edge). Telling them apart needs per-slice edge
+// bookkeeping on a path that runs every frame of a gizmo drag, and the payoff
+// is small: the duplicates are coincident, so they are invisible on opaque
+// parts and only slightly darken a translucent one, in the measure-zero case
+// where a plane lands exactly on a crease.
+export function sectionSegments(geometry, plane) {
+  const position = geometry?.getAttribute?.("position");
+  if (!position) return new Float32Array(0);
+
+  const index = geometry.getIndex?.() ?? null;
+  const count = index ? index.count : position.count;
+  const out = [];
+
+  for (let i = 0; i + 2 < count; i += 3) {
+    for (let k = 0; k < 3; k++) {
+      _vertices[k].fromBufferAttribute(position, index ? index.getX(i + k) : i + k);
+      const distance = plane.distanceToPoint(_vertices[k]);
+      _distances[k] = distance;
+      _signs[k] = distance > ON_PLANE_EPSILON
+        ? 1
+        : distance < -ON_PLANE_EPSILON ? -1 : 0;
+    }
+
+    const onPlane = (_signs[0] === 0 ? 1 : 0)
+      + (_signs[1] === 0 ? 1 : 0)
+      + (_signs[2] === 0 ? 1 : 0);
+
+    if (onPlane === 3) continue;
+
+    if (onPlane === 2) {
+      const solo = _signs[0] !== 0 ? 0 : _signs[1] !== 0 ? 1 : 2;
+      if (_signs[solo] !== -1) continue;
+      pushPoint(out, _vertices[(solo + 1) % 3]);
+      pushPoint(out, _vertices[(solo + 2) % 3]);
+      continue;
+    }
+
+    if (onPlane === 1) {
+      const zero = _signs[0] === 0 ? 0 : _signs[1] === 0 ? 1 : 2;
+      const a = (zero + 1) % 3;
+      const b = (zero + 2) % 3;
+      if (_signs[a] === _signs[b]) continue;
+      pushPoint(out, _vertices[zero]);
+      pushPoint(out, crossingPoint(a, b));
+      continue;
+    }
+
+    if (_signs[0] === _signs[1] && _signs[1] === _signs[2]) continue;
+    for (let k = 0; k < 3; k++) {
+      const a = k;
+      const b = (k + 1) % 3;
+      if (_signs[a] === _signs[b]) continue;
+      pushPoint(out, crossingPoint(a, b));
+    }
+  }
+
+  return new Float32Array(out);
+}
+
+function crossingPoint(a, b) {
+  const t = _distances[a] / (_distances[a] - _distances[b]);
+  return _crossing.copy(_vertices[a]).lerp(_vertices[b], t);
+}
+
+function pushPoint(out, point) {
+  out.push(point.x, point.y, point.z);
+}
+
+const defaultNow = () => (typeof performance !== "undefined" ? performance.now() : 0);
+
+// One cut-face outline for one subpart. The object is parented to the mesh, the
+// same trick the stencil helpers use, so it inherits every present and future
+// transform including the pose fast path — and it always slices whatever
+// `mesh.geometry` currently draws, so the outline cannot disagree with the
+// surface it bounds.
+//
+// The section moves for four unrelated reasons (plane pose, geometry swap,
+// frameTo recentring the assembly under a world-fixed plane, and setSubPose),
+// and only the first two notify the cutaway. Rather than thread invalidation
+// through all four, refresh() compares a signature and re-slices when it
+// differs — roughly 21 float compares per frame.
+export function createSectionOutline({ mesh, plane, inkColor, now = defaultNow }) {
+  const material = new LineMaterial({
+    color: inkColor,
+    linewidth: 1,
+    // The outline lies exactly in the cap plane; pull it toward the viewer so
+    // the coincident-depth line wins against the cap it sits in.
+    polygonOffset: true,
+    polygonOffsetFactor: -1,
+    polygonOffsetUnits: -1,
+  });
+  material.resolution.set(1, 1);
+  // Deliberately no clippingPlanes: the outline sits at distance ~0 from its
+  // own plane, and clipping it would speckle.
+
+  const object = new LineSegments2(new LineSegmentsGeometry(), material);
+  object.frustumCulled = false;
+  object.visible = false;
+  mesh.add(object);
+
+  const localPlane = new THREE.Plane();
+  const inverse = new THREE.Matrix4();
+  const lastNormal = new THREE.Vector3(NaN, NaN, NaN);
+  const lastMatrix = new THREE.Matrix4();
+  let lastConstant = NaN;
+  let lastGeometry = null;
+  let lastCost = 0;
+  let hasSegments = false;
+  let visible = false;
+  let suppressed = false;
+  let disposed = false;
+  // A show transition (setVisible(true) / setSuppressed(false)) must not put
+  // the last slice on screen if the plane or mesh moved while hidden - that
+  // slice belongs to a pose nobody asked to see. Cleared once slice() has
+  // caught up; markShown() below leaves it alone when nothing moved, so an
+  // ordinary show doesn't wait on a needless re-slice.
+  let needsSlice = true;
+
+  function applyVisibility() {
+    object.visible = visible && hasSegments && !suppressed && !disposed && !needsSlice;
+  }
+
+  // Same signature the plane/mesh state is judged by in refresh(), reused so
+  // a show transition can tell "still matches the last slice" from "moved
+  // while hidden" without duplicating that comparison.
+  function signatureMatches(geometry, matrixWorld) {
+    return geometry === lastGeometry
+      && plane.constant === lastConstant
+      && plane.normal.equals(lastNormal)
+      && matrixWorld.equals(lastMatrix);
+  }
+
+  function markShown() {
+    mesh.updateWorldMatrix(true, false);
+    if (!signatureMatches(mesh.geometry, mesh.matrixWorld)) needsSlice = true;
+  }
+
+  function slice(geometry, matrixWorld) {
+    const start = now();
+    localPlane.copy(plane).applyMatrix4(inverse.copy(matrixWorld).invert());
+    const segments = geometry
+      ? sectionSegments(geometry, localPlane)
+      : new Float32Array(0);
+    hasSegments = segments.length > 0;
+    const previous = object.geometry;
+    const next = new LineSegmentsGeometry();
+    if (hasSegments) next.setPositions(segments);
+    object.geometry = next;
+    previous?.dispose();
+    lastCost = now() - start;
+    needsSlice = false;
+    applyVisibility();
+  }
+
+  function refresh() {
+    if (disposed || !visible || suppressed) return false;
+    mesh.updateWorldMatrix(true, false);
+    const geometry = mesh.geometry;
+    if (signatureMatches(geometry, mesh.matrixWorld)) return false;
+    lastGeometry = geometry;
+    lastConstant = plane.constant;
+    lastNormal.copy(plane.normal);
+    lastMatrix.copy(mesh.matrixWorld);
+    slice(geometry, mesh.matrixWorld);
+    return true;
+  }
+
+  return {
+    object,
+    refresh,
+    sliceCost: () => lastCost,
+    setVisible(on) {
+      if (disposed) return;
+      visible = Boolean(on);
+      if (visible) markShown();
+      applyVisibility();
+    },
+    setSuppressed(on) {
+      if (disposed) return;
+      suppressed = Boolean(on);
+      if (!suppressed) markShown();
+      applyVisibility();
+    },
+    setInk(color) {
+      if (!disposed) material.color.set(color);
+    },
+    setTransparent(on) {
+      if (disposed || material.transparent === Boolean(on)) return;
+      material.transparent = Boolean(on);
+      material.needsUpdate = true;
+    },
+    setViewportSize(width, height) {
+      if (!disposed) material.resolution.set(width, height);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      object.visible = false;
+      mesh.remove(object);
+      object.geometry?.dispose();
+      material.dispose();
+    },
+  };
+}

package/src/framework/cutaway-render.js

@@ -1,5 +1,7 @@
 import * as THREE from "three";
 
+import { createSectionOutline } from "./cutaway-outline.js";
+
 export const HATCH_PERIOD_CSS_PX = 5;
 export const HATCH_LINE_CSS_PX = 1;
 
@@ -9,6 +11,7 @@ export const HATCH_LINE_CSS_PX = 1;
 const SURFACE_ORDER_BASE = 1_000_000;
 const EDGE_ORDER_BASE = 2_000_000;
 const SECTION_ORDER_STRIDE = 2;
+export const OUTLINE_ORDER_BASE = 2_500_000;
 export const CUTAWAY_OVERLAY_RENDER_ORDER = 3_000_000;
 
 export function createHatchMaterial({ color, opacity, inkColor }) {
@@ -122,6 +125,7 @@ export function createSectionRenderSet({
   capGeometry,
   order,
   inkColor,
+  now,
 }) {
   let originalMeshMaterial = mesh.material;
   let originalEdgeMaterial = edgeLines?.material;
@@ -187,6 +191,13 @@ export function createSectionRenderSet({
   front.renderOrder = stencilOrder;
   cap.renderOrder = stencilOrder + 1;
 
+  // Cut-face outline: real 3D segments sliced from the mesh, drawn with the
+  // same fat-line renderer as the viewer's feature edges. Ordered above the
+  // clipped edges so it wins the coincident depth against its own cap.
+  const outline = createSectionOutline({ mesh, plane, inkColor, now });
+  outline.object.renderOrder = OUTLINE_ORDER_BASE + order;
+  outline.setTransparent(capMaterial.transparent);
+
   let enabled = false;
   let visible = mesh.visible;
   let disposed = false;
@@ -196,6 +207,7 @@ export function createSectionRenderSet({
     back.visible = on;
     front.visible = on;
     cap.visible = on;
+    outline.setVisible(on);
   }
 
   back.visible = false;
@@ -245,12 +257,14 @@ export function createSectionRenderSet({
   function setHatchInk(color) {
     if (disposed) return;
     capMaterial.userData.setInkColor(color);
+    outline.setInk(color);
   }
 
   function setViewportSize(width, height, pixelRatio = 1) {
     if (disposed) return;
     viewportSize = { width, height, pixelRatio };
     setLineResolution(clippedEdgeMaterial, width, height);
+    outline.setViewportSize(width, height);
     capMaterial.userData.setScreenScale(pixelRatio);
   }
 
@@ -302,6 +316,7 @@ export function createSectionRenderSet({
     backMaterial.transparent = capMaterial.transparent;
     frontMaterial.transparent = capMaterial.transparent;
     if (clippedEdgeMaterial && capMaterial.transparent) makeTransparent(clippedEdgeMaterial);
+    outline.setTransparent(capMaterial.transparent);
 
     if (enabled) {
       mesh.material = clippedMeshMaterial;
@@ -319,6 +334,7 @@ export function createSectionRenderSet({
     disposed = true;
     mesh.remove(back, front);
     scene.remove(cap);
+    outline.dispose();
     for (const material of ownedMaterials) material.dispose();
   }
 
@@ -326,6 +342,7 @@ export function createSectionRenderSet({
     back,
     front,
     cap,
+    outline,
     setEnabled,
     setVisible,
     setGeometry,
@@ -333,6 +350,9 @@ export function createSectionRenderSet({
     setHatchInk,
     setViewportSize,
     refreshSourceMaterial,
+    refreshOutline: outline.refresh,
+    outlineSliceCost: outline.sliceCost,
+    setOutlineSuppressed: outline.setSuppressed,
     dispose,
   };
 }

package/src/framework/cutaway.js

@@ -10,6 +10,11 @@ import { createSectionRenderSet } from "./cutaway-render.js";
 
 const IDLE_DELAY_MS = 800;
 
+// Slicing rides on top of everything else in the frame, so the whole visible
+// assembly gets about an eighth of a 60 fps frame before outlines step aside
+// for the duration of a drag.
+export const OUTLINE_SLICE_BUDGET_MS = 2;
+
 function defaultSchedule(callback, delay) {
   const timer = setTimeout(callback, delay);
   return () => clearTimeout(timer);
@@ -33,6 +38,7 @@ export function createCutaway({
   getBounds,
   edgeColor,
   schedule = defaultSchedule,
+  now,
 }) {
   let supported = false;
   try {
@@ -61,6 +67,7 @@ export function createCutaway({
   let previousLocalClippingEnabled;
   let disposed = false;
   let disabling = false;
+  let outlinesSuppressed = false;
   let hoveredHandle = null;
   const handleHoverSubscribers = new Set();
   const pendingHandlePublications = [];
@@ -218,6 +225,7 @@ export function createCutaway({
     onPoseChange,
     onActivity: showActive,
     onHandleHoverChange: publishHandleHover,
+    onDragChange: setDragging,
   });
   gizmo.setVisible(false);
   gizmo.setTheme(theme);
@@ -236,6 +244,7 @@ export function createCutaway({
       capGeometry,
       order,
       inkColor: hatchInk,
+      now,
     });
     renderSets.set(name, { renderSet, mesh, edgeLines, order });
     if (viewportSize) {
@@ -248,6 +257,7 @@ export function createCutaway({
     applyCapPose(renderSet);
     renderSet.setVisible(enabled && selected(name));
     renderSet.setEnabled(enabled);
+    renderSet.setOutlineSuppressed(outlinesSuppressed);
     return true;
   }
 
@@ -402,8 +412,42 @@ export function createCutaway({
     };
   }
 
+  // Per-frame maintenance while the cutaway is on: the gizmo rescales for the
+  // camera, and every visible section re-slices its outline if anything it
+  // depends on moved. Both are cheap no-ops when nothing changed.
+  function refreshSections() {
+    for (const { renderSet } of renderSets.values()) renderSet.refreshOutline();
+  }
+
+  // Outlines re-slice on every frame of a gizmo drag. On heavy assemblies that
+  // is the one place the cost could show, so decide once at drag start — from
+  // costs already measured, so the drag never pays a spike to discover it is
+  // too expensive — and hide all of them or none. Half-outlined assemblies read
+  // as broken. Only sections that are actually showing count toward the budget:
+  // a hidden section's refresh() early-returns without slicing, so its cost
+  // entry is whatever was last measured while it *was* visible — stale, and
+  // irrelevant to what the drag will actually spend time on.
+  function setDragging(active) {
+    if (disposed) return;
+    if (active) {
+      let total = 0;
+      for (const [name, { renderSet }] of renderSets) {
+        if (enabled && selected(name)) total += renderSet.outlineSliceCost();
+      }
+      outlinesSuppressed = total > OUTLINE_SLICE_BUDGET_MS;
+    } else {
+      outlinesSuppressed = false;
+    }
+    for (const { renderSet } of renderSets.values()) {
+      renderSet.setOutlineSuppressed(outlinesSuppressed);
+    }
+    if (!active) refreshSections();
+  }
+
   function updateForCamera() {
-    if (enabled && !disposed) gizmo.updateForCamera();
+    if (!enabled || disposed) return;
+    gizmo.updateForCamera();
+    refreshSections();
   }
 
   function renderOverlay(targetRenderer, targetCamera) {
@@ -465,5 +509,7 @@ export function createCutaway({
     renderOverlay,
     onHandleHoverChange,
     dispose,
+    _renderSetFor: (name) => renderSets.get(name)?.renderSet ?? null,
+    _setDragging: setDragging,
   };
 }

package/src/framework/viewer.js

@@ -175,14 +175,24 @@ export function createViewer(container, part) {
   }
 
   // The cutaway plane lives in world space, so its initial/reset bounds must
-  // include the pivot rotation and the per-view recentering transform.
+  // include the pivot rotation and the per-view recentering transform —
+  // mesh.matrixWorld carries both. Union each visible mesh's own
+  // geometry.boundingBox rather than `Box3.expandByObject`, which recurses into
+  // children: the two stencil-pass meshes share `mesh.geometry` so that
+  // recursion is harmless for them, but the cut-face outline child carries its
+  // own independent geometry that only re-slices while the cutaway is enabled
+  // and visible — while hidden it can keep segments from an older, larger part
+  // and inflate these bounds. A subpart's initial placeholder BufferGeometry
+  // has no boundingBox computed (only buildGeometry computes one), so skip it.
   const _worldBounds = new THREE.Box3();
+  const _meshBounds = new THREE.Box3();
   function getVisibleWorldBounds() {
     _worldBounds.makeEmpty();
     for (const mesh of Object.values(subMesh)) {
-      if (!mesh.visible || !mesh.geometry) continue;
+      if (!mesh.visible || !mesh.geometry?.boundingBox) continue;
       mesh.updateWorldMatrix(true, false);
-      _worldBounds.expandByObject(mesh);
+      _meshBounds.copy(mesh.geometry.boundingBox).applyMatrix4(mesh.matrixWorld);
+      _worldBounds.union(_meshBounds);
     }
     return _worldBounds;
   }