@kitware/vtk.js 32.6.2 → 32.7.1

package/Common/Core/Math/index.js

@@ -2256,4 +2256,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { min as $, ldexp as A, xyz2rgb as B, degreesFromRadians as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { min as $, degreesFromRadians as A, ldexp as B, xyz2rgb as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, C as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, A as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, B as xyz2rgb } from './Math/index.js';
+export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, B as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, C as xyz2rgb } from './Math/index.js';

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:
+        throw new Error(`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 };

package/IO/Geometry/GLTFImporter/Decoder.js

@@ -0,0 +1,69 @@
+import BinaryHelper from '../../Core/BinaryHelper.js';
+import { BINARY_HEADER_MAGIC, BINARY_CHUNK_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_HEADER_LENGTH, BINARY_HEADER_INTS } from './Constants.js';
+
+function getChunkInfo(headerStart, data) {
+  const header = new Uint32Array(data, headerStart, BINARY_CHUNK_HEADER_INTS);
+  const chunkStart = headerStart + BINARY_CHUNK_HEADER_INTS * 4;
+  const chunkLength = header[0];
+  const chunkType = header[1];
+  return {
+    start: chunkStart,
+    length: chunkLength,
+    type: chunkType
+  };
+}
+function getAllChunkInfos(data) {
+  const infos = [];
+  let chunkStart = BINARY_HEADER_INTS * 4;
+  while (chunkStart < data.byteLength) {
+    const chunkInfo = getChunkInfo(chunkStart, data);
+    infos.push(chunkInfo);
+    chunkStart += chunkInfo.length + BINARY_CHUNK_HEADER_INTS * 4;
+  }
+  return infos;
+}
+function getJsonFromChunk(chunkInfo, data) {
+  const chunkLength = chunkInfo.length;
+  const jsonStart = (BINARY_HEADER_INTS + BINARY_CHUNK_HEADER_INTS) * 4;
+  const jsonSlice = new Uint8Array(data, jsonStart, chunkLength);
+  const stringBuffer = BinaryHelper.arrayBufferToString(jsonSlice);
+  return JSON.parse(stringBuffer);
+}
+function getBufferFromChunk(chunkInfo, data) {
+  return data.slice(chunkInfo.start, chunkInfo.start + chunkInfo.length);
+}
+function parseGLB(data) {
+  let json;
+  const buffers = [];
+  const headerView = new DataView(data, 0, BINARY_HEADER_LENGTH);
+  const header = {
+    magic: BinaryHelper.arrayBufferToString(new Uint8Array(data, 0, 4)),
+    version: headerView.getUint32(4, true),
+    length: headerView.getUint32(8, true)
+  };
+  if (header.magic !== BINARY_HEADER_MAGIC) {
+    throw new Error('Unsupported glTF-Binary header.');
+  } else if (header.version < 2.0) {
+    throw new Error('Unsupported legacy binary file detected.');
+  }
+  const chunkInfos = getAllChunkInfos(data);
+  chunkInfos.forEach(chunkInfo => {
+    if (chunkInfo.type === BINARY_CHUNK_TYPES.JSON && !json) {
+      json = getJsonFromChunk(chunkInfo, data);
+    } else if (chunkInfo.type === BINARY_CHUNK_TYPES.BIN) {
+      buffers.push(getBufferFromChunk(chunkInfo, data));
+    }
+  });
+  if (!json) {
+    throw new Error('glTF-Binary: JSON content not found.');
+  }
+  if (!buffers) {
+    throw new Error('glTF-Binary: Binary chunk not found.');
+  }
+  return {
+    json,
+    buffers
+  };
+}
+
+export { parseGLB as default };

package/IO/Geometry/GLTFImporter/Extensions.js

@@ -0,0 +1,110 @@
+import { m as macro } from '../../../macros2.js';
+import { r as radiansFromDegrees } from '../../../Common/Core/Math/index.js';
+import vtkDracoReader from '../DracoReader.js';
+import vtkLight from '../../../Rendering/Core/Light.js';
+import { MIN_LIGHT_ATTENUATION } from './Constants.js';
+
+const {
+  vtkWarningMacro
+} = macro;
+
+/**
+ * Handles the KHR_materials_unlit extension.
+ *
+ * @param {object} extension - The KHR_materials_unlit extension object.
+ * @param {vtkProperty} property - The vtkProperty instance to update.
+ */
+function handleKHRMaterialsUnlit(extension, property) {
+  property.setLighting(true);
+}
+
+/**
+ * Handles the KHR_materials_ior extension.
+ *
+ * @param {object} extension - The KHR_materials_unlit extension object.
+ * @param {vtkProperty} property - The vtkProperty instance to update.
+ */
+function handleKHRMaterialsIor(extension, property) {
+  property.setBaseIOR(extension.ior);
+}
+
+/**
+ * Handles the KHR_materials_specular extension.
+ * @param {object} extension - The KHR_materials_specular extension object.
+ * @param {vtkProperty} property - The vtkProperty instance to update.
+ */
+function handleKHRMaterialsSpecular(extension, property) {
+  property.setSpecular(extension.specularFactor);
+  property.setSpecularColor(extension.specularColorFactor);
+}
+
+/**
+ * Handles the KHR_lights_punctual extension.
+ *
+ * @param {object} extension - The KHR_lights_punctual extension object.
+ * @param {vtkRenderer} renderer - The vtkRenderer instance to add the light to.
+ */
+function handleKHRLightsPunctual(extension, transformMatrix, model) {
+  const {
+    light
+  } = extension;
+  const {
+    color,
+    intensity,
+    range,
+    spot,
+    type
+  } = light;
+  const l = vtkLight.newInstance({
+    color: color || [1, 1, 1],
+    intensity: intensity || 1.0
+  });
+
+  // Apply the global transform to the light
+  l.setTransformMatrix(transformMatrix);
+
+  // Handle range
+  if (range > 0) {
+    // Set quadratic values to get attenuation(range) ~= MIN_LIGHT_ATTENUATION
+    l.setAttenuationValues(1, 0, 1.0 / (range * range * MIN_LIGHT_ATTENUATION));
+  }
+  switch (type) {
+    case 'directional':
+      l.setPositional(false);
+      break;
+    case 'point':
+      l.setPositional(true);
+      l.setConeAngle(90);
+      break;
+    case 'spot':
+      l.setPositional(true);
+      l.setConeAngle(radiansFromDegrees(spot.outerConeAngle));
+      break;
+    default:
+      vtkWarningMacro(`Unsupported light type: ${type}`);
+  }
+  model.lights.set(light.name, l);
+}
+
+/**
+ * Handles the KHR_draco_mesh_compression extension.
+ *
+ * @param {object} extension - The KHR_draco_mesh_compression extension object.
+ */
+async function handleKHRDracoMeshCompression(extension) {
+  const reader = vtkDracoReader.newInstance();
+  reader.parse(extension.bufferView);
+  return reader.getOutputData();
+}
+
+/**
+ * Handles the KHR_materials_variants extension.
+ *
+ * @param {object} extension - The KHR_materials_variants extension object.
+ * @param {object} model - The model object to update with variant information.
+ */
+function handleKHRMaterialsVariants(extension, model) {
+  model.variants = extension.variants.map(v => v.name);
+}
+
+export { handleKHRDracoMeshCompression, handleKHRLightsPunctual, handleKHRMaterialsIor, handleKHRMaterialsSpecular, handleKHRMaterialsUnlit, handleKHRMaterialsVariants };

package/IO/Geometry/GLTFImporter/ORMTexture.worker.js

@@ -0,0 +1,42 @@
+import registerWebworker from 'webworker-promise/lib/register';
+
+/**
+ *
+ * @param {ArrayBuffer} imageBuffer
+ * @param {string} mimeType
+ * @param {string} channel
+ * @returns {Promise<ImageData>}
+ */
+registerWebworker(async _ref => {
+  let {
+    imageBuffer,
+    mimeType,
+    channel
+  } = _ref;
+  const channelsMap = {
+    r: 0,
+    g: 1,
+    b: 2
+  };
+  const blob = new Blob([imageBuffer], {
+    type: mimeType
+  });
+  const img = await createImageBitmap(blob);
+  const canvas = new OffscreenCanvas(img.width, img.height);
+  const ctx = canvas.getContext('2d');
+  ctx.drawImage(img, 0, 0, img.width, img.height);
+  const bitmap = ctx.getImageData(0, 0, img.width, img.height);
+  if (channel) {
+    const idx = channelsMap[channel];
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      const channelValue = bitmap.data[i + idx];
+      bitmap.data[i] = channelValue; // red channel
+      bitmap.data[i + 1] = channelValue; // green channel
+      bitmap.data[i + 2] = channelValue; // blue channel
+    }
+  }
+
+  return {
+    bitmap
+  };
+});