@kitware/vtk.js 33.0.0-beta.2 → 33.0.0-beta.3

package/IO/Geometry/DracoReader.js

@@ -1,8 +1,9 @@
-import DataAccessHelper from '../Core/DataAccessHelper.js';
 import { m as macro } from '../../macros2.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPolyDataNormals from '../../Filters/Core/PolyDataNormals.js';
 import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 
 // import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip
@@ -12,8 +13,7 @@ import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
 const {
   vtkErrorMacro
 } = macro;
-let decoderModule = {};
-
+let decoderModule = null;
 // ----------------------------------------------------------------------------
 // static methods
 // ----------------------------------------------------------------------------
@@ -46,8 +46,13 @@ function setWasmBinary(url, binaryName) {
     xhr.send(null);
   });
 }
-function setDracoDecoder(createDracoModule) {
-  decoderModule = createDracoModule({});
+
+/**
+ * Set the Draco decoder module
+ * @param {*} dracoDecoder
+ */
+async function setDracoDecoder(dracoDecoder) {
+  decoderModule = await dracoDecoder({});
 }
 function getDracoDecoder() {
   return decoderModule;
@@ -56,115 +61,141 @@ function getDracoDecoder() {
 // ----------------------------------------------------------------------------
 // vtkDracoReader methods
 // ----------------------------------------------------------------------------
-
-function decodeBuffer(buffer) {
-  const byteArray = new Int8Array(buffer);
-  const decoder = new decoderModule.Decoder();
-  const decoderBuffer = new decoderModule.DecoderBuffer();
-  decoderBuffer.Init(byteArray, byteArray.length);
-  const geometryType = decoder.GetEncodedGeometryType(decoderBuffer);
-  let dracoGeometry;
-  if (geometryType === decoderModule.TRIANGULAR_MESH) {
-    dracoGeometry = new decoderModule.Mesh();
-    const status = decoder.DecodeBufferToMesh(decoderBuffer, dracoGeometry);
-    if (!status.ok()) {
-      vtkErrorMacro(`Could not decode Draco file: ${status.error_msg()}`);
-    }
-  } else {
-    vtkErrorMacro('Wrong geometry type, expected mesh, got point cloud.');
+function getDracoDataType(attributeType) {
+  switch (attributeType) {
+    case Float32Array:
+      return decoderModule.DT_FLOAT32;
+    case Int8Array:
+      return decoderModule.DT_INT8;
+    case Int16Array:
+      return decoderModule.DT_INT16;
+    case Int32Array:
+      return decoderModule.DT_INT32;
+    case Uint8Array:
+      return decoderModule.DT_UINT8;
+    case Uint16Array:
+      return decoderModule.DT_UINT16;
+    case Uint32Array:
+      return decoderModule.DT_UINT32;
+    default:
+      return decoderModule.DT_FLOAT32;
   }
-  decoderModule.destroy(decoderBuffer);
-  decoderModule.destroy(decoder);
-  return dracoGeometry;
 }
-function getDracoAttributeAsFloat32Array(dracoGeometry, attributeId) {
-  const decoder = new decoderModule.Decoder();
-  const attribute = decoder.GetAttribute(dracoGeometry, attributeId);
-  const numberOfComponents = attribute.num_components();
-  const numberOfPoints = dracoGeometry.num_points();
-  const attributeData = new decoderModule.DracoFloat32Array();
-  decoder.GetAttributeFloatForAllPoints(dracoGeometry, attribute, attributeData);
-  let i = numberOfPoints * numberOfComponents;
-  const attributeArray = new Float32Array(i);
-  while (i--) {
-    attributeArray[i] = attributeData.GetValue(i);
-  }
-  return attributeArray;
+
+/**
+ * Decode a single attribute
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @param {*} attributeName The name of the attribute
+ * @param {*} attributeType The type of the attribute
+ * @param {*} attribute The attribute to decode
+ * @returns object with name, array, itemSize
+ */
+function decodeAttribute(decoder, dracoGeometry, attributeName, attributeType, attribute) {
+  const numComponents = attribute.num_components();
+  const numPoints = dracoGeometry.num_points();
+  const numValues = numPoints * numComponents;
+  const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
+  const dataType = getDracoDataType(attributeType);
+  const ptr = decoderModule._malloc(byteLength);
+  decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, attribute, dataType, byteLength, ptr);
+
+  // eslint-disable-next-line new-cap
+  const array = new attributeType(decoderModule.HEAPF32.buffer, ptr, numValues).slice();
+  decoderModule._free(ptr);
+  return {
+    name: attributeName,
+    array,
+    itemSize: numComponents
+  };
 }
-function getPolyDataFromDracoGeometry(dracoGeometry) {
-  const decoder = new decoderModule.Decoder();
 
-  // Get position attribute ID
-  const positionAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.POSITION);
-  if (positionAttributeId === -1) {
-    console.error('No position attribute found in the decoded model.');
-    decoderModule.destroy(decoder);
-    decoderModule.destroy(dracoGeometry);
-    return null;
-  }
-  const positionArray = getDracoAttributeAsFloat32Array(dracoGeometry, positionAttributeId);
+/**
+ * Decode the indices of the geometry
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @returns The indices array of the geometry
+ */
+function decodeIndices(decoder, dracoGeometry) {
+  const numFaces = dracoGeometry.num_faces();
+  const numIndices = numFaces * 3;
+  const byteLength = numIndices * 4;
+  const ptr = decoderModule._malloc(byteLength);
+  decoder.GetTrianglesUInt32Array(dracoGeometry, byteLength, ptr);
+  const indices = new Uint32Array(decoderModule.HEAPF32.buffer, ptr, numIndices).slice();
+  decoderModule._free(ptr);
+  return indices;
+}
 
-  // Read indices
-  let i = dracoGeometry.num_faces();
-  const indices = new Uint32Array(i * 4);
-  const indicesArray = new decoderModule.DracoInt32Array();
-  while (i--) {
-    decoder.GetFaceFromMesh(dracoGeometry, i, indicesArray);
-    const index = i * 4;
-    indices[index] = 3;
-    indices[index + 1] = indicesArray.GetValue(0);
-    indices[index + 2] = indicesArray.GetValue(1);
-    indices[index + 3] = indicesArray.GetValue(2);
+/**
+ * Get the polyData from the Draco geometry
+ * @param {*} decoder The Draco decoder
+ * @param {*} dracoGeometry The geometry to decode
+ * @returns {vtkPolyData} The polyData of the geometry
+ */
+function getPolyDataFromDracoGeometry(decoder, dracoGeometry) {
+  const indices = decodeIndices(decoder, dracoGeometry);
+  const nCells = indices.length - 2;
+  const cells = vtkCellArray.newInstance();
+  cells.resize(4 * indices.length / 3);
+  for (let cellId = 0; cellId < nCells; cellId += 3) {
+    const cell = indices.slice(cellId, cellId + 3);
+    cells.insertNextCell(cell);
   }
-
-  // Create polyData and add positions and indinces
-  const cellArray = vtkCellArray.newInstance({
-    values: indices
-  });
   const polyData = vtkPolyData.newInstance({
-    polys: cellArray
+    polys: cells
   });
-  polyData.getPoints().setData(positionArray);
-
-  // Look for other attributes
-  const pointData = polyData.getPointData();
 
-  // Normals
-  const normalAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.NORMAL);
-  if (normalAttributeId !== -1) {
-    const normalArray = getDracoAttributeAsFloat32Array(dracoGeometry, decoderModule.NORMAL);
-    const normals = vtkDataArray.newInstance({
-      numberOfComponents: 3,
-      values: normalArray,
-      name: 'Normals'
-    });
-    pointData.setNormals(normals);
-  }
-
-  // Texture coordinates
-  const texCoordAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.TEX_COORD);
-  if (texCoordAttributeId !== -1) {
-    const texCoordArray = getDracoAttributeAsFloat32Array(dracoGeometry, texCoordAttributeId);
-    const texCoords = vtkDataArray.newInstance({
-      numberOfComponents: 2,
-      values: texCoordArray,
-      name: 'TCoords'
-    });
-    pointData.setTCoords(texCoords);
-  }
+  // Look for attributes
+  const attributeIDs = {
+    points: 'POSITION',
+    normals: 'NORMAL',
+    scalars: 'COLOR',
+    tcoords: 'TEX_COORD'
+  };
+  Object.keys(attributeIDs).forEach(attributeName => {
+    const attributeType = Float32Array;
+    const attributeID = decoder.GetAttributeId(dracoGeometry, decoderModule[attributeIDs[attributeName]]);
+    if (attributeID === -1) return;
+    const attribute = decoder.GetAttribute(dracoGeometry, attributeID);
+    const attributeResult = decodeAttribute(decoder, dracoGeometry, attributeName, attributeType, attribute);
+    const pointData = polyData.getPointData();
+    switch (attributeName) {
+      case 'points':
+        polyData.getPoints().setData(attributeResult.array, attributeResult.itemSize);
+        break;
+      case 'normals':
+        pointData.setNormals(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'Normals'
+        }));
+        break;
+      case 'scalars':
+        pointData.setScalars(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'Scalars'
+        }));
+        break;
+      case 'tcoords':
+        pointData.setTCoords(vtkDataArray.newInstance({
+          numberOfComponents: attributeResult.itemSize,
+          values: attributeResult.array,
+          name: 'TCoords'
+        }));
+        break;
+    }
+  });
 
-  // Scalars
-  const colorAttributeId = decoder.GetAttributeId(dracoGeometry, decoderModule.COLOR);
-  if (colorAttributeId !== -1) {
-    const colorArray = getDracoAttributeAsFloat32Array(dracoGeometry, colorAttributeId);
-    const scalars = vtkDataArray.newInstance({
-      numberOfComponents: 3,
-      values: colorArray,
-      name: 'Scalars'
-    });
-    pointData.setScalars(scalars);
+  // we will generate normals if they're missing
+  const hasNormals = polyData.getPointData().getNormals();
+  if (!hasNormals) {
+    const pdn = vtkPolyDataNormals.newInstance();
+    pdn.setInputData(polyData);
+    pdn.setComputePointNormals(true);
+    return pdn.getOutputData();
   }
-  decoderModule.destroy(decoder);
   return polyData;
 }
 function vtkDracoReader(publicAPI, model) {
@@ -235,9 +266,27 @@ function vtkDracoReader(publicAPI, model) {
       return;
     }
     model.parseData = content;
-    const dracoGeometry = decodeBuffer(content);
-    const polyData = getPolyDataFromDracoGeometry(dracoGeometry);
+    const byteArray = new Int8Array(content);
+    const decoder = new decoderModule.Decoder();
+    const buffer = new decoderModule.DecoderBuffer();
+    buffer.Init(byteArray, byteArray.length);
+    const geometryType = decoder.GetEncodedGeometryType(buffer);
+    let dracoGeometry;
+    if (geometryType === decoderModule.TRIANGULAR_MESH) {
+      dracoGeometry = new decoderModule.Mesh();
+      const status = decoder.DecodeBufferToMesh(buffer, dracoGeometry);
+      if (!status.ok()) {
+        vtkErrorMacro(`Could not decode Draco file: ${status.error_msg()}`);
+        return;
+      }
+    } else {
+      vtkErrorMacro('Wrong geometry type, expected mesh, got point cloud.');
+      return;
+    }
+    const polyData = getPolyDataFromDracoGeometry(decoder, dracoGeometry);
     decoderModule.destroy(dracoGeometry);
+    decoderModule.destroy(buffer);
+    decoderModule.destroy(decoder);
     model.output[0] = polyData;
   };
   publicAPI.requestData = () => {

package/IO/Geometry/GLTFImporter/Animations.js

@@ -0,0 +1,239 @@
+import { m as macro } from '../../../macros2.js';
+import { A as degreesFromRadians } from '../../../Common/Core/Math/index.js';
+import { quat, vec3 } from 'gl-matrix';
+
+const {
+  vtkDebugMacro,
+  vtkWarningMacro
+} = macro;
+
+/**
+ * Create an animation channel
+ * @param {glTFChannel} glTFChannel
+ * @param {glTFChannel[]} glTFSamplers
+ * @returns
+ */
+function createAnimationChannel(glTFChannel, glTFSamplers) {
+  const path = glTFChannel.target.path;
+  const node = glTFChannel.target.node;
+  function applyAnimation(value) {
+    let axisAngle;
+    let w;
+    let nq;
+    switch (path) {
+      case 'translation':
+        node.setPosition(value[0], value[1], value[2]);
+        break;
+      case 'rotation':
+        // Convert quaternion to axis-angle representation
+        nq = quat.normalize(quat.create(), value);
+        axisAngle = new Float64Array(3);
+        w = quat.getAxisAngle(axisAngle, nq);
+        // Apply rotation using rotateWXYZ
+        node.rotateWXYZ(degreesFromRadians(w), axisAngle[0], axisAngle[1], axisAngle[2]);
+        break;
+      case 'scale':
+        node.setScale(value[0], value[1], value[2]);
+        break;
+      default:
+        vtkWarningMacro(`Unsupported animation path: ${path}`);
+    }
+  }
+  function animate(currentTime) {
+    const sampler = glTFSamplers[glTFChannel.sampler];
+    const value = sampler.evaluate(currentTime, path);
+    applyAnimation(value);
+  }
+  return {
+    ...glTFChannel,
+    animate
+  };
+}
+
+/**
+ * Create an animation sampler
+ * @param {glTFSampler} glTFSampler
+ * @returns
+ */
+function createAnimationSampler(glTFSampler) {
+  let lastKeyframeIndex = 0;
+  function findKeyframes(time) {
+    let i1 = lastKeyframeIndex;
+    while (i1 < glTFSampler.input.length - 1 && glTFSampler.input[i1] <= time) {
+      i1++;
+    }
+    const i0 = Math.max(0, i1 - 1);
+    lastKeyframeIndex = i0;
+    return [glTFSampler.input[i0], glTFSampler.input[i1], i0, i1];
+  }
+  function stepInterpolate(path, i0) {
+    const startIndex = i0 * 3;
+    const v0 = new Array(3);
+    for (let i = 0; i < 3; ++i) {
+      v0[i] = glTFSampler.output[startIndex + i];
+    }
+    return v0;
+  }
+  function linearInterpolate(path, t0, t1, i0, i1, t) {
+    const ratio = (t - t0) / (t1 - t0);
+    const startIndex = i0 * 4;
+    const endIndex = i1 * 4;
+    const v0 = new Array(4);
+    const v1 = new Array(4);
+    for (let i = 0; i < 4; ++i) {
+      v0[i] = glTFSampler.output[startIndex + i];
+      v1[i] = glTFSampler.output[endIndex + i];
+    }
+    switch (path) {
+      case 'translation':
+      case 'scale':
+        return vec3.lerp(vec3.create(), v0, v1, ratio);
+      case 'rotation':
+        return quat.slerp(quat.create(), v0, v1, ratio);
+      default:
+        vtkWarningMacro(`Unsupported animation path: ${path}`);
+        return null;
+    }
+  }
+  function cubicSplineInterpolate(path, t0, t1, i0, i1, time) {
+    const dt = t1 - t0;
+    const t = (time - t0) / dt;
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const p0 = glTFSampler.output[i0 * 3 + 1];
+    const m0 = dt * glTFSampler.output[i0 * 3 + 2];
+    const p1 = glTFSampler.output[i1 * 3 + 1];
+    const m1 = dt * glTFSampler.output[i1 * 3];
+    if (Array.isArray(p0)) {
+      return p0.map((v, j) => {
+        const a = 2 * t3 - 3 * t2 + 1;
+        const b = t3 - 2 * t2 + t;
+        const c = -2 * t3 + 3 * t2;
+        const d = t3 - t2;
+        return a * v + b * m0[j] + c * p1[j] + d * m1[j];
+      });
+    }
+    const a = 2 * t3 - 3 * t2 + 1;
+    const b = t3 - 2 * t2 + t;
+    const c = -2 * t3 + 3 * t2;
+    const d = t3 - t2;
+    return a * p0 + b * m0 + c * p1 + d * m1;
+  }
+  function evaluate(time, path) {
+    const [t0, t1, i0, i1] = findKeyframes(time);
+    let result;
+    switch (glTFSampler.interpolation) {
+      case 'STEP':
+        result = stepInterpolate(path, i0);
+        break;
+      case 'LINEAR':
+        result = linearInterpolate(path, t0, t1, i0, i1, time);
+        break;
+      case 'CUBICSPLINE':
+        result = cubicSplineInterpolate(path, t0, t1, i0, i1, time);
+        break;
+      default:
+        vtkWarningMacro(`Unknown interpolation method: ${glTFSampler.interpolation}`);
+    }
+    return result;
+  }
+  return {
+    ...glTFSampler,
+    evaluate
+  };
+}
+
+/**
+ * Create an animation
+ * @param {glTFAnimation} glTFAnimation
+ * @param {Map} nodes
+ * @returns
+ */
+function createAnimation(glTFAnimation, nodes) {
+  glTFAnimation.samplers = glTFAnimation.samplers.map(sampler => createAnimationSampler(sampler));
+  glTFAnimation.channels = glTFAnimation.channels.map(channel => {
+    channel.target.node = nodes.get(`node-${channel.target.node}`);
+    return createAnimationChannel(channel, glTFAnimation.samplers);
+  });
+  function update(currentTime) {
+    glTFAnimation.channels.forEach(channel => channel.animate(currentTime));
+  }
+  return {
+    ...glTFAnimation,
+    update
+  };
+}
+
+/**
+ * Create an animation mixer
+ * @param {Map} nodes
+ * @param {*} accessors
+ * @returns
+ */
+function createAnimationMixer(nodes, accessors) {
+  const animations = new Map();
+  const activeAnimations = new Map();
+  function addAnimation(glTFAnimation) {
+    const annimation = createAnimation(glTFAnimation, nodes);
+    animations.set(glTFAnimation.id, annimation);
+    vtkDebugMacro(`Animation "${glTFAnimation.id}" added to mixer`);
+  }
+  function play(name) {
+    let weight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    if (!animations.has(name)) {
+      vtkWarningMacro(`Animation "${name}" not found in mixer`);
+      return;
+    }
+    activeAnimations.set(name, {
+      animation: animations.get(name),
+      weight,
+      time: 0
+    });
+    vtkDebugMacro(`Playing animation "${name}" with weight ${weight}`);
+  }
+  function stop(name) {
+    if (activeAnimations.delete(name)) {
+      vtkWarningMacro(`Stopped animation "${name}"`);
+    } else {
+      vtkWarningMacro(`Animation "${name}" was not playing`);
+    }
+  }
+  function stopAll() {
+    activeAnimations.clear();
+    vtkWarningMacro('Stopped all animations');
+  }
+  function update(deltaTime) {
+    // Normalize weights
+    const totalWeight = Array.from(activeAnimations.values()).reduce((sum, _ref) => {
+      let {
+        weight
+      } = _ref;
+      return sum + weight;
+    }, 0);
+    activeAnimations.forEach((_ref2, name) => {
+      let {
+        animation,
+        weight,
+        time
+      } = _ref2;
+      const normalizedWeight = totalWeight > 0 ? weight / totalWeight : 0;
+      const newTime = time + deltaTime;
+      activeAnimations.set(name, {
+        animation,
+        weight,
+        time: newTime
+      });
+      vtkDebugMacro(`Updating animation "${name}" at time ${newTime.toFixed(3)} with normalized weight ${normalizedWeight.toFixed(3)}`);
+      animation.update(newTime, normalizedWeight);
+    });
+  }
+  return {
+    addAnimation,
+    play,
+    stop,
+    stopAll,
+    update
+  };
+}
+
+export { createAnimation, createAnimationChannel, createAnimationMixer, createAnimationSampler };

package/IO/Geometry/GLTFImporter/Constants.js

@@ -0,0 +1,87 @@
+const BINARY_HEADER_MAGIC = 'glTF';
+const BINARY_HEADER_LENGTH = 12;
+const BINARY_CHUNK_TYPES = {
+  JSON: 0x4e4f534a,
+  BIN: 0x004e4942
+};
+const BINARY_HEADER_INTS = 3;
+const BINARY_CHUNK_HEADER_INTS = 2;
+const MIN_LIGHT_ATTENUATION = 0.01;
+const COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+const BYTES = {
+  5120: 1,
+  // BYTE
+  5121: 1,
+  // UNSIGNED_BYTE
+  5122: 2,
+  // SHORT
+  5123: 2,
+  // UNSIGNED_SHORT
+  5125: 4,
+  // UNSIGNED_INT
+  5126: 4 // FLOAT
+};
+
+const MODES = {
+  GL_POINTS: 0,
+  GL_LINES: 1,
+  GL_LINE_LOOP: 2,
+  GL_LINE_STRIP: 3,
+  GL_TRIANGLES: 4,
+  GL_TRIANGLE_STRIP: 5,
+  GL_TRIANGLE_FAN: 6
+};
+const ARRAY_TYPES = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+};
+const GL_SAMPLER = {
+  NEAREST: 9728,
+  LINEAR: 9729,
+  NEAREST_MIPMAP_NEAREST: 9984,
+  LINEAR_MIPMAP_NEAREST: 9985,
+  NEAREST_MIPMAP_LINEAR: 9986,
+  LINEAR_MIPMAP_LINEAR: 9987,
+  REPEAT: 10497,
+  CLAMP_TO_EDGE: 33071,
+  MIRRORED_REPEAT: 33648,
+  TEXTURE_MAG_FILTER: 10240,
+  TEXTURE_MIN_FILTER: 10241,
+  TEXTURE_WRAP_S: 10242,
+  TEXTURE_WRAP_T: 10243
+};
+const DEFAULT_SAMPLER = {
+  magFilter: GL_SAMPLER.NEAREST,
+  minFilter: GL_SAMPLER.LINEAR_MIPMAP_LINEAR,
+  wrapS: GL_SAMPLER.REPEAT,
+  wrapT: GL_SAMPLER.REPEAT
+};
+const SEMANTIC_ATTRIBUTE_MAP = {
+  NORMAL: 'normal',
+  POSITION: 'position',
+  TEXCOORD_0: 'texcoord0',
+  TEXCOORD_1: 'texcoord1',
+  WEIGHTS_0: 'weight',
+  JOINTS_0: 'joint',
+  COLOR_0: 'color',
+  TANGENT: 'tangent'
+};
+const ALPHA_MODE = {
+  OPAQUE: 'OPAQUE',
+  MASK: 'MASK',
+  BLEND: 'BLEND'
+};
+
+export { ALPHA_MODE, ARRAY_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_CHUNK_TYPES, BINARY_HEADER_INTS, BINARY_HEADER_LENGTH, BINARY_HEADER_MAGIC, BYTES, COMPONENTS, DEFAULT_SAMPLER, GL_SAMPLER, MIN_LIGHT_ATTENUATION, MODES, SEMANTIC_ATTRIBUTE_MAP };