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

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.
+ */
+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
+  };
+});

package/IO/Geometry/GLTFImporter/Parser.js

@@ -0,0 +1,359 @@
+import { m as macro } from '../../../macros2.js';
+import { SEMANTIC_ATTRIBUTE_MAP, MODES, ALPHA_MODE, BYTES, COMPONENTS, DEFAULT_SAMPLER, GL_SAMPLER } from './Constants.js';
+import { getAccessorArrayTypeAndLength, resolveUrl, getGLEnumFromSamplerParameter } from './Utils.js';
+
+/* eslint-disable guard-for-in */
+const {
+  vtkDebugMacro,
+  vtkWarningMacro
+} = macro;
+class GLTFParser {
+  constructor(glTF) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      json,
+      baseUri = ''
+    } = glTF;
+    this.glTF = glTF;
+    this.options = options;
+    this.baseUri = baseUri;
+    this.json = json;
+    this.extensions = json.extensions || {};
+    this.extensionsUsed = json.extensionsUsed || [];
+  }
+  async parse() {
+    const buffers = this.json.buffers || [];
+    this.buffers = new Array(buffers.length).fill(null);
+    const images = this.json.images || [];
+    this.images = new Array(images.length).fill({});
+    await this.loadBuffers();
+    await this.loadImages();
+    this.resolveTree();
+    return this.glTF.json;
+  }
+  resolveTree() {
+    this.json.scenes = this.json.scenes?.map((scene, idx) => this.resolveScene(scene, idx));
+    this.json.cameras = this.json.cameras?.map((camera, idx) => this.resolveCamera(camera, idx));
+    this.json.bufferViews = this.json.bufferViews?.map((bufView, idx) => this.resolveBufferView(bufView, idx));
+    this.json.images = this.json.images?.map((image, idx) => this.resolveImage(image, idx));
+    this.json.samplers = this.json.samplers?.map((sampler, idx) => this.resolveSampler(sampler, idx));
+    this.json.textures = this.json.textures?.map((texture, idx) => this.resolveTexture(texture, idx));
+    this.json.accessors = this.json.accessors?.map((accessor, idx) => this.resolveAccessor(accessor, idx));
+    this.json.materials = this.json.materials?.map((material, idx) => this.resolveMaterial(material, idx));
+    this.json.meshes = this.json.meshes?.map((mesh, idx) => this.resolveMesh(mesh, idx));
+    this.json.nodes = this.json.nodes?.map((node, idx) => this.resolveNode(node, idx));
+    this.json.skins = this.json.skins?.map((skin, idx) => this.resolveSkin(skin, idx));
+    this.json.animations = this.json.animations?.map((animation, idx) => this.resolveAnimation(animation, idx));
+  }
+  get(array, index) {
+    // check if already resolved
+    if (typeof index === 'object') {
+      return index;
+    }
+    const object = this.json[array] && this.json[array][index];
+    if (!object) {
+      vtkWarningMacro(`glTF file error: Could not find ${array}[${index}]`);
+    }
+    return object;
+  }
+  resolveScene(scene, index) {
+    scene.id = scene.id || `scene-${index}`;
+    scene.nodes = (scene.nodes || []).map(node => this.get('nodes', node));
+    return scene;
+  }
+  resolveNode(node, index) {
+    node.id = node.id || `node-${index}`;
+    if (node.children) {
+      node.children = node.children.map(child => this.get('nodes', child));
+    }
+    if (node.mesh !== undefined) {
+      node.mesh = this.get('meshes', node.mesh);
+    } else if (node.meshes !== undefined && node.meshes.length) {
+      node.mesh = node.meshes.reduce((accum, meshIndex) => {
+        const mesh = this.get('meshes', meshIndex);
+        accum.id = mesh.id;
+        accum.primitives = accum.primitives.concat(mesh.primitives);
+        return accum;
+      }, {
+        primitives: []
+      });
+    }
+    if (node.camera !== undefined) {
+      node.camera = this.get('cameras', node.camera);
+    }
+    if (node.skin !== undefined) {
+      node.skin = this.get('skins', node.skin);
+    }
+
+    // Fill punctual lights objects
+    if (node.extensions?.KHR_lights_punctual) {
+      node.extensions.KHR_lights_punctual.light = this.extensions?.KHR_lights_punctual.lights[node.extensions.KHR_lights_punctual.light];
+    }
+    return node;
+  }
+  resolveSkin(skin, index) {
+    skin.id = skin.id || `skin-${index}`;
+    skin.inverseBindMatrices = this.get('accessors', skin.inverseBindMatrices);
+    return skin;
+  }
+  resolveMesh(mesh, index) {
+    mesh.id = mesh.id || `mesh-${index}`;
+    if (mesh.primitives) {
+      mesh.primitives = mesh.primitives.map((primitive, idx) => {
+        const attributes = primitive.attributes;
+        primitive.name = `primitive-${idx}`;
+        primitive.attributes = {};
+        for (const attribute in attributes) {
+          const attr = SEMANTIC_ATTRIBUTE_MAP[attribute];
+          primitive.attributes[attr] = this.get('accessors', attributes[attribute]);
+        }
+        if (primitive.indices !== undefined) {
+          primitive.indices = this.get('accessors', primitive.indices);
+        }
+        if (primitive.material !== undefined) {
+          primitive.material = this.get('materials', primitive.material);
+        }
+        if (primitive.mode === undefined) {
+          primitive.mode = MODES.GL_TRIANGLES; // Default one
+        }
+
+        if (primitive.extensions?.KHR_draco_mesh_compression) {
+          vtkDebugMacro('Using Draco mesh compression');
+          const bufferView = this.get('bufferViews', primitive.extensions.KHR_draco_mesh_compression.bufferView);
+          primitive.extensions.KHR_draco_mesh_compression.bufferView = bufferView.data;
+        }
+        return primitive;
+      });
+    }
+    return mesh;
+  }
+  resolveMaterial(material, index) {
+    material.id = material.id || `material-${index}`;
+    if (material.alphaMode === undefined) material.alphaMode = ALPHA_MODE.OPAQUE;
+    if (material.doubleSided === undefined) material.doubleSided = false;
+    if (material.alphaCutoff === undefined) material.alphaCutoff = 0.5;
+    if (material.normalTexture) {
+      material.normalTexture = {
+        ...material.normalTexture
+      };
+      material.normalTexture.texture = this.get('textures', material.normalTexture.index);
+    }
+    if (material.occlusionTexture) {
+      material.occlusionTexture = {
+        ...material.occlusionTexture
+      };
+      material.occlusionTexture.texture = this.get('textures', material.occlusionTexture.index);
+    }
+    if (material.emissiveTexture) {
+      material.emissiveTexture = {
+        ...material.emissiveTexture
+      };
+      material.emissiveTexture.texture = this.get('textures', material.emissiveTexture.index);
+    }
+    if (!material.emissiveFactor) {
+      material.emissiveFactor = material.emissiveTexture ? 1 : 0;
+    } else material.emissiveFactor = material.emissiveFactor[0];
+    if (material.pbrMetallicRoughness) {
+      material.pbrMetallicRoughness = {
+        ...material.pbrMetallicRoughness
+      };
+      const mr = material.pbrMetallicRoughness;
+      if (mr.baseColorTexture) {
+        mr.baseColorTexture = {
+          ...mr.baseColorTexture
+        };
+        mr.baseColorTexture.texture = this.get('textures', mr.baseColorTexture.index);
+      }
+      if (mr.metallicRoughnessTexture) {
+        mr.metallicRoughnessTexture = {
+          ...mr.metallicRoughnessTexture
+        };
+        mr.metallicRoughnessTexture.texture = this.get('textures', mr.metallicRoughnessTexture.index);
+      }
+    } else {
+      material.pbrMetallicRoughness = {
+        baseColorFactor: [1, 1, 1, 1],
+        metallicFactor: 1.0,
+        roughnessFactor: 1.0
+      };
+    }
+    return material;
+  }
+
+  /**
+   * Take values of particular accessor from interleaved buffer various parts of
+   * the buffer
+   */
+  getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
+    const result = new Uint8Array(count * bytesPerElement);
+    for (let i = 0; i < count; i++) {
+      const elementOffset = byteOffset + i * byteStride;
+      result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i * bytesPerElement);
+    }
+    return result.buffer;
+  }
+  resolveAccessor(accessor, index) {
+    accessor.id = accessor.id || `accessor-${index}`;
+    if (accessor.bufferView !== undefined) {
+      // Draco encoded meshes don't have bufferView
+      accessor.bufferView = this.get('bufferViews', accessor.bufferView);
+    }
+
+    // Look up enums
+    accessor.bytesPerComponent = BYTES[accessor.componentType];
+    accessor.components = COMPONENTS[accessor.type];
+    accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
+
+    // Create TypedArray for the accessor
+    // Note: The canonical way to instantiate is to ignore this array and create
+    // WebGLBuffer's using the bufferViews.
+    if (accessor.bufferView) {
+      const buffer = accessor.bufferView.buffer;
+      const {
+        ArrayType,
+        byteLength
+      } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
+      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
+      let slicedBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+      if (accessor.bufferView.byteStride) {
+        slicedBufffer = this.getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+      }
+      accessor.value = new ArrayType(slicedBufffer);
+    }
+    return accessor;
+  }
+  resolveTexture(texture, index) {
+    texture.id = texture.id || `texture-${index}`;
+    texture.sampler = 'sampler' in texture ? this.get('samplers', texture.sampler) : DEFAULT_SAMPLER;
+    texture.source = this.get('images', texture.source);
+
+    // Handle texture extensions sources
+    if (texture.extensions !== undefined) {
+      const extensionsNames = Object.keys(texture.extensions);
+      extensionsNames.forEach(extensionName => {
+        const extension = texture.extensions[extensionName];
+        switch (extensionName) {
+          case 'KHR_texture_basisu':
+          case 'EXT_texture_webp':
+          case 'EXT_texture_avif':
+            texture.source = this.get('images', extension.source);
+            break;
+          default:
+            vtkWarningMacro(`Unhandled extension: ${extensionName}`);
+        }
+      });
+    }
+    return texture;
+  }
+  resolveSampler(sampler, index) {
+    sampler.id = sampler.id || `sampler-${index}`;
+    if (!Object.hasOwn(sampler, 'wrapS')) sampler.wrapS = GL_SAMPLER.REPEAT;
+    if (!Object.hasOwn(sampler, 'wrapT')) sampler.wrapT = GL_SAMPLER.REPEAT;
+    if (!Object.hasOwn(sampler, 'minFilter')) sampler.minFilter = GL_SAMPLER.LINEAR_MIPMAP_LINEAR;
+    if (!Object.hasOwn(sampler, 'magFilter')) sampler.magFilter = GL_SAMPLER.NEAREST;
+
+    // Map textual parameters to GL parameter values
+    sampler.parameters = {};
+    for (const key in sampler) {
+      const glEnum = getGLEnumFromSamplerParameter(key);
+      if (glEnum !== undefined) {
+        sampler.parameters[glEnum] = sampler[key];
+      }
+    }
+    return sampler;
+  }
+  resolveImage(image, index) {
+    image.id = image.id || `image-${index}`;
+    if (image.bufferView !== undefined) {
+      image.bufferView = this.get('bufferViews', image.bufferView);
+    }
+    return image;
+  }
+  resolveBufferView(bufferView, index) {
+    bufferView.id = bufferView.id || `bufferView-${index}`;
+    const bufferIndex = bufferView.buffer;
+    bufferView.buffer = this.buffers[bufferIndex];
+    const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
+    let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
+    if ('byteOffset' in bufferView) {
+      byteOffset += bufferView.byteOffset;
+    }
+    bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+    return bufferView;
+  }
+  resolveCamera(camera, index) {
+    camera.id = camera.id || `camera-${index}`;
+    return camera;
+  }
+  resolveAnimation(animation, index) {
+    animation.id = animation.id || `animation-${index}`;
+    animation.samplers.map(sampler => {
+      sampler.input = this.get('accessors', sampler.input).value;
+      sampler.output = this.get('accessors', sampler.output).value;
+      return sampler;
+    });
+    return animation;
+  }
+  loadBuffers() {
+    const promises = this.json.buffers.map((buffer, idx) => this.loadBuffer(buffer, idx).then(() => {
+      delete buffer.uri;
+    }));
+    return Promise.all(promises);
+  }
+  async loadBuffer(buffer, index) {
+    let arrayBuffer = buffer;
+    if (buffer.uri) {
+      vtkDebugMacro('Loading uri', buffer.uri);
+      const uri = resolveUrl(buffer.uri, this.options.baseUri);
+      const response = await fetch(uri);
+      arrayBuffer = await response.arrayBuffer();
+    } else if (this.glTF.glbBuffers) {
+      arrayBuffer = this.glTF.glbBuffers[index];
+    }
+    this.buffers[index] = {
+      arrayBuffer,
+      byteOffset: 0,
+      byteLength: arrayBuffer.byteLength
+    };
+  }
+  loadImages() {
+    const images = this.json.images || [];
+    const promises = [];
+    return new Promise((resolve, reject) => {
+      for (let i = 0; i < images.length; ++i) {
+        promises.push(Promise.resolve(this.loadImage(images[i], i).then(() => {
+          vtkDebugMacro('Texture loaded ', images[i]);
+        })));
+      }
+      Promise.all(promises).then(() => resolve(this.images));
+    });
+  }
+  async loadImage(image, index) {
+    let arrayBuffer;
+    let buffer;
+    if (image.uri) {
+      vtkDebugMacro('Loading texture', image.uri);
+      const uri = resolveUrl(image.uri, this.options.baseUri);
+      const response = await fetch(uri);
+      arrayBuffer = await response.arrayBuffer();
+      image.uri = uri;
+      image.bufferView = {
+        data: arrayBuffer
+      };
+    } else if (image.bufferView) {
+      const bufferView = this.get('bufferViews', image.bufferView);
+      buffer = this.get('buffers', bufferView.buffer);
+
+      // GLB buffer
+      if (this.glTF.glbBuffers) {
+        buffer = this.glTF.glbBuffers[bufferView.buffer];
+        arrayBuffer = buffer.slice(bufferView.byteOffset, bufferView.byteOffset + bufferView.byteLength);
+      }
+      image.bufferView = {
+        data: arrayBuffer
+      };
+    }
+  }
+}
+
+export { GLTFParser as default };