xl-public-utils 1.0.22 → 1.0.23

package/index.d.ts

@@ -248,6 +248,12 @@ declare module "xl-public-utils" {
      * @param {vtkPolyData} data 需要应用变换的polydata
      */
     export function pointsApplyMat4(mt4: mat4, data: vtkPolyData): void;
+    /**
+     * 对一个polydata应用矩阵变化，直接改变点位置
+     * @param {mat4} mt4 变换矩阵
+     * @param {number[]} vertices 需要应用变换的polydata
+     */
+    export function verticesApplyMat4(mt4: mat4, vertices: number[]): Float32Array;
     /**
      * 将点应用矩阵变换
      * @param {vec3} point 三维点
@@ -470,6 +476,14 @@ declare module "xl-public-utils" {
      * @returns {vtkPolyData} 去重之后的vtkPolyData
      */
     export function deduplicatePolyData(data: vtkPolyData): vtkPolyData;
+    /**
+     * 顶点去重，用于 STL
+     * @param {Float32Array} vertices 输入顶点数组 [x,y,z, x,y,z, ...]
+     * @param {Int32Array} faces 输入面索引数组 [3,i1,i2,i3, 3,i4,i5,i6, ...]
+     * @param {number} [precision=1e-10] 精度，用于判断顶点相等（默认 1e-10）
+     * @returns {{ vertices: Float32Array, faces: Int32Array }} 去重后的网格数据
+     */
+    export function deduplicateVF(vertices: Float32Array | number[], faces: Int32Array | number[], precision = 1e-10): { vertices: Float32Array, faces: Int32Array };
     /**
      * 判断一个矩阵是否是正交矩阵
      * @param {mat4} matrix 矩阵
@@ -715,7 +729,7 @@ declare module "xl-public-utils" {
      * @param { vec3 } axisX 朝向 X 轴，默认 [1, 0, 0]
      * @param { vec3 } axisY 朝向 Y 轴，默认 [0, 1, 0]
      * @param { vec3 } axisZ 朝向 Z 轴，默认 [0, 0, 1]
-     * @returns { vtkPolyData } polydata 六边形网格
+     * @returns { vertices: Float32Array, faces: Int32Array } 点和面 六边形网格
      */
     export function createHexagonPolydata(
       rows:number,
@@ -727,7 +741,7 @@ declare module "xl-public-utils" {
       axisX?: vec3,
       axisY?: vec3,
       axisZ?: vec3
-    ): vtkPolyData
+    ): { vertices: Float32Array, faces: Int32Array }
   }
 
   export namespace utils {
@@ -1066,18 +1080,14 @@ declare module "xl-public-utils" {
       fontName?: string,
       scale?: vec3
     ): {
-      polyData: vtkPolyData;
-      indexData: IndexData;
+      vertices: number[],
+      faces: number[],
+      indexData: IndexData,
     };
 
     /**
      * 获取顶点索引映射
      */
-    getPointsMapData(polydata: vtkPolyData): IndexData;
-
-    /**
-     * 创建 vtkPolyData 对象
-     */
-    createPolyData(verts: any, faces: any): vtkPolyData;
+    getPointsMapData(polydata: ArrayLike<number>): IndexData;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xl-public-utils",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "",
   "main": "index.js",
   "module": "index.js",

package/src/drcUtils.js

@@ -1,6 +1,5 @@
 import { vec3 } from "gl-matrix";
 import { int8ArrayToBase64 } from './utils.js'
-import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData.js";
 import vtkDracoReader from "@kitware/vtk.js/IO/Geometry/DracoReader";
 /**
  * @typedef {Object} AttrOption

package/src/exportPLY.js

@@ -1,4 +1,3 @@
-import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData.js";
 var FormatTypes = {
   ASCII: 'ascii',
   BINARY: 'binary'

package/src/exportSTL.js

@@ -1,4 +1,3 @@
-import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData.js';
 import { vec3 } from 'gl-matrix';
 
 /**

package/src/meshUtils.js

@@ -1,8 +1,7 @@
 import { ExtrudeGeometry } from './threeFont/TextGeometry/ExtrudeGeometry.js';
 import { Shape } from './threeFont/Curve/Shape.js';
 import { vec3, mat4 } from 'gl-matrix';
-import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData.js';
-import { clonePolyData, createPolyData, getL2WMatrix, getPolydataCenterOffset, mergePolyData, pointsApplyMat4 } from './vtkUtils.js';
+import { getL2WMatrix, getPolydataCenterOffset, mergeMeshes, verticesApplyMat4 } from './vtkUtils.js';
 
 
 /**
@@ -60,7 +59,7 @@ export function createHexagonGeometry(radius, height, wallThickness) {
  * @param { vec3 } axisX 朝向 X 轴，默认 [1, 0, 0]
  * @param { vec3 } axisY 朝向 Y 轴，默认 [0, 1, 0]
  * @param { vec3 } axisZ 朝向 Z 轴，默认 [0, 0, 1]
- * @returns { vtkPolyData } polydata 六边形网格
+ * @returns { vertices: Float32Array, faces: Int32Array } 点和面 六边形网格
  */
 export function createHexagonPolydata(
 	rows,
@@ -81,30 +80,31 @@ export function createHexagonPolydata(
 	const b = (radius / 2) * z - _wall / 2 / z;
 
 	const geometry = createHexagonGeometry(radius, height, _wall);
-	const polyData = createPolyData(geometry.vertices, geometry.faces);
 
 	let polyDataArr = [];
 	// 生成网格
 	for (let i = 0; i < rows; i++) {
 		let q = i % 2; // 奇偶行偏移
 		for (let j = 1; j <= cols; j++) {
-			let _polyData = clonePolyData(polyData);
 
 			// 根据形状和OpenSCAD公式计算位置
 			let x = i * a;
 			let y = j * b * 2 + q * b - b;
 			let _trans = mat4.fromTranslation(mat4.create(), [x, y, 0]);
-			pointsApplyMat4(_trans, _polyData);
-			polyDataArr.push(_polyData);
+			const newVertices = verticesApplyMat4(_trans, geometry.vertices);
+			polyDataArr.push({
+        vertices: newVertices,
+        faces: geometry.faces
+      });
 		}
 	}
 
-	const resultPolyData = mergePolyData(polyDataArr);
-	const _offset = getPolydataCenterOffset(resultPolyData);
+	const resultPolyData = mergeMeshes(polyDataArr);
+	const _offset = getPolydataCenterOffset(resultPolyData.vertices);
 	const offsetM4 = mat4.translate(mat4.create(), mat4.create(), [_offset.x, _offset.y, 0]);
-	pointsApplyMat4(offsetM4, resultPolyData);
+	resultPolyData.vertices = verticesApplyMat4(offsetM4, resultPolyData.vertices);
 
 	const _matrix = getL2WMatrix(center, axisX, axisY, axisZ);
-	pointsApplyMat4(_matrix, resultPolyData);
+	resultPolyData.vertices = verticesApplyMat4(_matrix, resultPolyData.vertices);
 	return resultPolyData;
 }

package/src/threeFont/index.js

@@ -3,13 +3,11 @@ import { ExtrudeGeometry } from './TextGeometry/ExtrudeGeometry.js';
 import { mat4, vec3 } from 'gl-matrix';
 
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData.js';
-import vtkPoints from '@kitware/vtk.js/Common/Core/Points.js';
-import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray.js';
 
 import {
   clonePolyData,
-  deduplicatePolyData,
-  pointsApplyMat4
+  deduplicateVF,
+  verticesApplyMat4
 } from '../vtkUtils.js';
 
 /**
@@ -21,7 +19,7 @@ class FontManager {
   constructor() {
     if (FontManager.instance) return FontManager.instance;
 
-    /** @type {Object.<string, vtkPolyData>} */
+    /** @type {Object.<string, {vertices: ArrayLike<number>, faces: ArrayLike<number>}}>} */
     this.cacheFontMap = {};
     /** @type {Object.<string, { zeroIndexs: number[], oneIndexs: number[] }>} */
     this.cacheFontPointMap = {};
@@ -68,48 +66,44 @@ class FontManager {
    * @param {string} text 
    * @param {string} fontName 
    * @param {vec3} scale 
-   * @returns {{ polyData: vtkPolyData, indexData: { zeroIndexs: number[], oneIndexs: number[] } }}
+   * @returns {{ vertices: ArrayLike<number>, faces: ArrayLike<number>, indexData: { zeroIndexs: number[], oneIndexs: number[] } }}
    */
   generateShapes(text, fontName = 'defaultFont', scale = [0.018, 0.018, 0.018]) {
     const scaleM4 = mat4.scale(mat4.create(), mat4.create(), scale);
 
     if (this.cacheFontMap[text]) {
-      const newPolyData = clonePolyData(this.cacheFontMap[text]);
-      pointsApplyMat4(scaleM4, newPolyData);
+      const newVertices = verticesApplyMat4(scaleM4, this.cacheFontMap[text].vertices);
       return {
-        polyData: newPolyData,
+        vertices: newVertices,
+        faces:  this.cacheFontMap[text].faces,
         indexData: this.cacheFontPointMap[text]
       };
     }
 
     const shapes = this.parameters.font[fontName].generateShapes(text, this.parameters.size);
     const extrude = new ExtrudeGeometry(shapes, this.parameters);
-
-    let polyData = this.createPolyData(extrude.vertices, extrude.faces);
-    polyData = deduplicatePolyData(polyData);
-    polyData = this.reIndexPolyData(polyData);
-    const indexData = this.getPointsMapData(polyData);
+    let vfData = deduplicateVF(extrude.vertices, extrude.faces);
+    vfData = this.reIndexByVF(vfData.vertices, vfData.faces);
+    const indexData = this.getPointsMapData(vfData.vertices);
     // console.log(indexData);
-
-    const _polyData = clonePolyData(polyData);
-    pointsApplyMat4(scaleM4, _polyData);
-
-    this.cacheFontMap[text] = polyData;
+    const newVertices = verticesApplyMat4(scaleM4, vfData.vertices);
+    this.cacheFontMap[text] = vfData;
     this.cacheFontPointMap[text] = indexData;
 
     return {
-      polyData: _polyData,
+      vertices: newVertices,
+      faces:  vfData.faces,
       indexData
     };
   }
 
   /**
-   * 获取前后层顶点索引映射数据
-   * @param {vtkPolyData} polydata 
+   * 根据指定索引集合重新组织点和面
+   * @param {Float32Array} vertices 点数组 [x,y,z, x,y,z, ...]
    * @returns {{ zeroIndexs: number[], oneIndexs: number[] }}
    */
-  getPointsMapData(polydata) {
-    const points = polydata.getPoints().getData();
+  getPointsMapData(vertices) {
+    const points = vertices
     const zeroIndexs = [];
     const oneIndexs = [];
     const pointIndexMap = {};
@@ -137,65 +131,36 @@ class FontManager {
     };
   }
   /**
-   * 
-   * @param {vtkPolyData} polydata 
-   * @returns {vtkPolyData} 重组索引之后的polydata
+   * 根据指定索引集合重新组织点和面
+   * @param {Float32Array} vertices 点数组 [x,y,z, x,y,z, ...]
+   * @param {Int32Array} faces 面索引数组 (VTK风格: [3,i1,i2,i3, 3,i4,i5,i6,...])
    */
-  reIndexPolyData(polydata) {
-    const indexData = this.getPointsMapData(polydata);
+  reIndexByVF(vertices, faces) {
+    const indexData = this.getPointsMapData(vertices);
     const allIndexData = [...indexData.zeroIndexs, ...indexData.oneIndexs]
-    const nowPoints = polydata.getPoints().getData();
-    const nowFaces = polydata.getPolys().getData();
-    const newPoints = new Float32Array(nowPoints.length);
+    const newPoints = new Float32Array(vertices.length);
     const indexMap = {};
     for(let i = 0; i < allIndexData.length; i++) {
       const index = allIndexData[i];
-      const x = nowPoints[index * 3];
-      const y = nowPoints[index * 3 + 1];
-      const z = nowPoints[index * 3 + 2];
+      const x = vertices[index * 3];
+      const y = vertices[index * 3 + 1];
+      const z = vertices[index * 3 + 2];
       newPoints[i * 3] = x
       newPoints[i * 3 + 1] = y
       newPoints[i * 3 + 2] = z
       indexMap[index] = i;
     }
-    for(let i =0; i< nowFaces.length; i += 4) {
-      const p1 = nowFaces[i + 1];
-      const p2 = nowFaces[i + 2]
-      const p3 = nowFaces[i + 3]
-      nowFaces[i + 1] = indexMap[p1]
-      nowFaces[i + 2] = indexMap[p2]
-      nowFaces[i + 3] = indexMap[p3]
+    const newFaces = new Int32Array(faces.length);
+    for(let i =0; i< faces.length; i += 4) {
+      newFaces[i] = 3;
+      newFaces[i + 1] = indexMap[faces[i + 1]];
+      newFaces[i + 2] = indexMap[faces[i + 2]];
+      newFaces[i + 3] = indexMap[faces[i + 3]];
     }
-    polydata.getPoints().setData(newPoints);
-    polydata.getPolys().setData(nowFaces);
-    return polydata
-  }
-
-  /**
-   * 创建 vtkPolyData 对象
-   * @param {any} verts 
-   * @param {any} faces 
-   * @returns {vtkPolyData}
-   */
-  createPolyData(verts, faces) {
-    const values_v = Object.values(verts);
-    const values_f = Object.values(faces);
-
-    const _verts = values_v.map(v => parseFloat(v));
-    const _faces = values_f.map(f => parseInt(f));
-
-    const vpoints = vtkPoints.newInstance();
-    const cellArray = vtkCellArray.newInstance();
-
-    vpoints.setData(_verts, 3);
-    cellArray.setNumberOfComponents(4);
-    cellArray.setData(_faces);
-
-    const polyData = vtkPolyData.newInstance();
-    polyData.setPoints(vpoints);
-    polyData.setPolys(cellArray);
-
-    return polyData;
+    return {
+      vertices: newPoints,
+      faces: newFaces,
+    };
   }
 }
 

package/src/vtkUtils.js

@@ -1,8 +1,4 @@
 import vtkRenderer from "@kitware/vtk.js/Rendering/Core/Renderer.js";
-import vtkInteractorStyleManipulator from "@kitware/vtk.js/Interaction/Style/InteractorStyleManipulator.js"
-import vtkMouseCameraTrackballPanManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballPanManipulator.js";
-import vtkMouseCameraTrackballRotateManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js";
-import vtkMouseCameraTrackballZoomManipulator from "@kitware/vtk.js/Interaction/Manipulators/MouseCameraTrackballZoomManipulator.js";
 import vtkRenderWindowInteractor from "@kitware/vtk.js/Rendering/Core/RenderWindowInteractor.js";
 import vtkMatrixBuilder from "@kitware/vtk.js/Common/Core/MatrixBuilder.js";
 import vtkPolyData from "@kitware/vtk.js/Common/DataModel/PolyData.js";
@@ -18,7 +14,6 @@ import { exportBinarySTL } from './exportSTL.js';
 import { writePLY } from "./exportPLY.js";
 import { enCodeMesh } from './drcUtils.js';
 import { getFileExtension, int8ArrayToBase64 } from "./utils.js";
-
 /**
  * 计算屏幕坐标到三维坐标
  * @param {vtkRenderer} renderer vtkRenderer
@@ -153,42 +148,6 @@ export function getL2WMatrix(
  */
 export const getmatofl2w = getL2WMatrix;
 
-/**
- * 返回交互的interactorStyle
- * @returns {vtkInteractorStyleManipulator} 交互的interactorStyle
- */
-export function make3DInteractorStyle() {
-  const interactorStyle = vtkInteractorStyleManipulator.newInstance();
-  const cameraRotate = vtkMouseCameraTrackballRotateManipulator.newInstance({
-    button: 1,
-  });
-  const cameraPan = vtkMouseCameraTrackballPanManipulator.newInstance({
-    button: 3,
-  });
-  // const cameraPanControl = vtkMouseCameraTrackballPanManipulator.newInstance({
-  //   button: 1,
-  //   shift: true,
-  // });
-  // const cameraRoll = vtkMouseCameraTrackballRollManipulator.newInstance({
-  //   button: 3,
-  //   control: true,
-  // });
-  const cameraZoom = vtkMouseCameraTrackballZoomManipulator.newInstance({
-    button: 2,
-  });
-  const cameraZoomDrag = vtkMouseCameraTrackballZoomManipulator.newInstance({
-    scrollEnabled: true,
-    dragEnabled: false,
-  });
-
-  interactorStyle.addMouseManipulator(cameraRotate);
-  interactorStyle.addMouseManipulator(cameraPan);
-  // interactorStyle.addMouseManipulator(cameraPanControl);
-  // interactorStyle.addMouseManipulator(cameraRoll);
-  // interactorStyle.addMouseManipulator(cameraZoom);
-  interactorStyle.addMouseManipulator(cameraZoomDrag);
-  return interactorStyle;
-}
 
 /**
  * 移除并返回当前renderWindow的所有鼠标交互设定
@@ -402,6 +361,29 @@ export function pointsApplyMat4(mt4, data) {
     .apply(data.getPoints().getData());
 }
 
+/**
+ * 对点集合应用 4x4 变换矩阵
+ * @param {mat4} mt4 变换矩阵
+ * @param {number[]} points 点数组 [x1,y1,z1, x2,y2,z2, ...]
+ * @returns {Float32Array} 变换后的点数组（新的数组，不改变原数组）
+ */
+export function verticesApplyMat4(mt4, points) {
+  const result = new Float32Array(points.length);
+  const v = vec3.create();
+
+  for (let i = 0; i < points.length; i += 3) {
+    v[0] = points[i];
+    v[1] = points[i + 1];
+    v[2] = points[i + 2];
+    vec3.transformMat4(v, v, mt4); // v = mt4 * v
+    result[i] = v[0];
+    result[i + 1] = v[1];
+    result[i + 2] = v[2];
+  }
+
+  return result;
+}
+
 /**
  * 将点应用矩阵变换
  * @param {vec3} point 三维点
@@ -548,6 +530,58 @@ export function deduplicatePolyData(data) {
   return p;
 };
 
+/**
+ * 顶点去重，用于 STL
+ * @param {Float32Array} vertices 输入顶点数组 [x,y,z, x,y,z, ...]
+ * @param {Int32Array} faces 输入面索引数组 [3,i1,i2,i3, 3,i4,i5,i6, ...]
+ * @param {number} [precision=1e-10] 精度，用于判断顶点相等（默认 1e-10）
+ * @returns {{ vertices: Float32Array, faces: Int32Array }} 去重后的网格数据
+ */
+export function deduplicateVF(vertices, faces, precision = 1e-10) {
+  const OFFSET_BOUNDS = Math.log10(1 / precision); // 比如 precision=1e-10 => 10
+  const vMap = new Map();   // key -> newIndex
+  const vIndexMap = new Map(); // oldIndex -> newIndex
+  let vInc = 0;
+
+  // 建立映射
+  for (let i = 0; i < vertices.length; i += 3) {
+    const key = `${(vertices[i] * Math.pow(10, OFFSET_BOUNDS)).toFixed(0)},` +
+                `${(vertices[i + 1] * Math.pow(10, OFFSET_BOUNDS)).toFixed(0)},` +
+                `${(vertices[i + 2] * Math.pow(10, OFFSET_BOUNDS)).toFixed(0)}`;
+    if (vMap.has(key)) {
+      vIndexMap.set(i / 3, vMap.get(key));
+    } else {
+      vMap.set(key, vInc);
+      vIndexMap.set(i / 3, vInc);
+      vInc++;
+    }
+  }
+
+  // 重建顶点数组
+  const tVertices = new Float32Array(vMap.size * 3);
+  for (const [key, idx] of vMap.entries()) {
+    const j = idx * 3;
+    const [x, y, z] = key.split(",").map((e) => +e * Math.pow(10, -OFFSET_BOUNDS));
+    tVertices[j] = x;
+    tVertices[j + 1] = y;
+    tVertices[j + 2] = z;
+  }
+
+  // 重建面索引
+  const tFaces = new Int32Array(faces.length);
+  for (let i = 0; i < faces.length; i += 4) {
+    tFaces[i] = 3; // 三角面
+    tFaces[i + 1] = vIndexMap.get(faces[i + 1]);
+    tFaces[i + 2] = vIndexMap.get(faces[i + 2]);
+    tFaces[i + 3] = vIndexMap.get(faces[i + 3]);
+  }
+
+  return {
+    vertices: tVertices,
+    faces: tFaces
+  };
+}
+
 /**
  * 计算一组三维点的中心点
  * @param {vec3[]} points 三维点数组
@@ -1089,18 +1123,68 @@ export function mergePolyData(params) {
     return appendPolyData.getOutputData();
 }
 
+/**
+ * 合并多个 mesh
+ * @param {Array<{ vertices: Float32Array, faces: Uint32Array }>} meshes 
+ *   - vertices: Float32Array，长度 = 顶点数 * 3
+ *   - faces: Uint32Array 或 Int32Array，格式为 [n, i1, i2, i3, n, j1, j2, j3, ...] (和 vtkPolyData.getPolys().getData() 一样)
+ * @returns {{ vertices: Float32Array, faces: Uint32Array }}
+ */
+export function mergeMeshes(meshes) {
+  // 先算总点数和总面索引数
+  let totalPoints = 0;
+  let totalFaces = 0;
+  meshes.forEach(mesh => {
+    totalPoints += mesh.vertices.length;
+    totalFaces += mesh.faces.length;
+  });
+
+  // 合并数组
+  const mergedPoints = new Float32Array(totalPoints);
+  const mergedFaces = new Uint32Array(totalFaces);
+
+  let pointOffset = 0; // 顶点偏移量 (按点坐标数量, 即 *3 后的下标)
+  let faceOffset = 0;  // 面的写入位置
+  let indexOffset = 0; // 索引偏移量 (按顶点数量)
+
+  for (const mesh of meshes) {
+    // 复制点
+    mergedPoints.set(mesh.vertices, pointOffset);
+
+    // faces 要改索引
+    const faces = mesh.faces;
+    let i = 0;
+    while (i < faces.length) {
+      const n = faces[i]; // 面的顶点数量
+      mergedFaces[faceOffset++] = n;
+      for (let j = 1; j <= n; j++) {
+        mergedFaces[faceOffset++] = faces[i + j] + indexOffset;
+      }
+      i += n + 1;
+    }
+
+    pointOffset += mesh.vertices.length;
+    indexOffset += mesh.vertices.length / 3; // 每个顶点占 3 个数
+  }
+
+  return {
+    vertices: mergedPoints,
+    faces: mergedFaces,
+  };
+}
+
 /**
  * 计算网格的boundingBox
- * @param { vtkPolyData } polydata 网格数据
+ * @param { number[] | Float32Array } vertices 点数据
  * @returns 返回网格的boundingBox
  */
-export function computeBoundingBox(polydata) {
+export function computeBoundingBox(vertices) {
     // 初始化最小值和最大值
     const min = vec3.fromValues(Infinity, Infinity, Infinity);
     const max = vec3.fromValues(-Infinity, -Infinity, -Infinity);
 
     // 从 vtkPolyData 中提取顶点数据（假设是 Float32Array 格式）
-    const points = polydata.getPoints().getData();
+    const points = vertices;
     const numPoints = points.length / 3;
 
     // 遍历所有顶点
@@ -1124,11 +1208,11 @@ export function computeBoundingBox(polydata) {
 
 /**
  * 计算网格移动到相对自己中心位置的xyz偏移量
- * @param { vtkPolyData } _polydata 网格 
+ * @param { number[] | Float32Array } vertices 点数据
  * @returns {{x: number, y: number, z: number}} 网格自己居中所需要的xyz偏移量
  */
-export function getPolydataCenterOffset(_polydata) {
-    const _boundBox = computeBoundingBox(_polydata);
+export function getPolydataCenterOffset(vertices) {
+    const _boundBox = computeBoundingBox(vertices);
     const _width = Math.abs(_boundBox.min[0] - _boundBox.max[0]);
     const _height = Math.abs(_boundBox.min[1] - _boundBox.max[1]);
     const _surface =Math.abs(_boundBox.min[2] - _boundBox.max[2]);