@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.10

package/dist/gltf/lib/api/gltf-scenegraph.cjs

@@ -0,0 +1,615 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/api/gltf-scenegraph.ts
+var gltf_scenegraph_exports = {};
+__export(gltf_scenegraph_exports, {
+  GLTFScenegraph: () => GLTFScenegraph
+});
+module.exports = __toCommonJS(gltf_scenegraph_exports);
+var import_images = require("@loaders.gl/images");
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_assert = require("../utils/assert.cjs");
+var import_gltf_utils = require("../gltf-utils/gltf-utils.cjs");
+var import_get_typed_array = require("../gltf-utils/get-typed-array.cjs");
+function makeDefaultGLTFJson() {
+  return {
+    asset: {
+      version: "2.0",
+      generator: "loaders.gl"
+    },
+    buffers: [],
+    extensions: {},
+    extensionsRequired: [],
+    extensionsUsed: []
+  };
+}
+var GLTFScenegraph = class {
+  // internal
+  gltf;
+  sourceBuffers;
+  byteLength;
+  // TODO - why is this not GLTFWithBuffers - what happens to images?
+  constructor(gltf) {
+    this.gltf = {
+      json: gltf?.json || makeDefaultGLTFJson(),
+      buffers: gltf?.buffers || [],
+      images: gltf?.images || []
+    };
+    this.sourceBuffers = [];
+    this.byteLength = 0;
+    if (this.gltf.buffers && this.gltf.buffers[0]) {
+      this.byteLength = (0, import_loader_utils.padToNBytes)(this.gltf.buffers[0].byteLength, 4);
+      this.sourceBuffers = [this.gltf.buffers[0]];
+    }
+  }
+  // Accessors
+  get json() {
+    return this.gltf.json;
+  }
+  getApplicationData(key) {
+    const data = this.json[key];
+    return data;
+  }
+  getExtraData(key) {
+    const extras = this.json.extras || {};
+    return extras[key];
+  }
+  hasExtension(extensionName) {
+    const isUsedExtension = this.getUsedExtensions().find((name) => name === extensionName);
+    const isRequiredExtension = this.getRequiredExtensions().find((name) => name === extensionName);
+    return typeof isUsedExtension === "string" || typeof isRequiredExtension === "string";
+  }
+  getExtension(extensionName) {
+    const isExtension = this.getUsedExtensions().find((name) => name === extensionName);
+    const extensions = this.json.extensions || {};
+    return isExtension ? extensions[extensionName] : null;
+  }
+  getRequiredExtension(extensionName) {
+    const isRequired = this.getRequiredExtensions().find((name) => name === extensionName);
+    return isRequired ? this.getExtension(extensionName) : null;
+  }
+  getRequiredExtensions() {
+    return this.json.extensionsRequired || [];
+  }
+  getUsedExtensions() {
+    return this.json.extensionsUsed || [];
+  }
+  getRemovedExtensions() {
+    return this.json.extensionsRemoved || [];
+  }
+  getObjectExtension(object, extensionName) {
+    const extensions = object.extensions || {};
+    return extensions[extensionName];
+  }
+  getScene(index) {
+    return this.getObject("scenes", index);
+  }
+  getNode(index) {
+    return this.getObject("nodes", index);
+  }
+  getSkin(index) {
+    return this.getObject("skins", index);
+  }
+  getMesh(index) {
+    return this.getObject("meshes", index);
+  }
+  getMaterial(index) {
+    return this.getObject("materials", index);
+  }
+  getAccessor(index) {
+    return this.getObject("accessors", index);
+  }
+  // getCamera(index: number): object | null {
+  //   return null; // TODO: fix thi: object  as null;
+  // }
+  getTexture(index) {
+    return this.getObject("textures", index);
+  }
+  getSampler(index) {
+    return this.getObject("samplers", index);
+  }
+  getImage(index) {
+    return this.getObject("images", index);
+  }
+  getBufferView(index) {
+    return this.getObject("bufferViews", index);
+  }
+  getBuffer(index) {
+    return this.getObject("buffers", index);
+  }
+  getObject(array, index) {
+    if (typeof index === "object") {
+      return index;
+    }
+    const object = this.json[array] && this.json[array][index];
+    if (!object) {
+      throw new Error(`glTF file error: Could not find ${array}[${index}]`);
+    }
+    return object;
+  }
+  /**
+   * Accepts buffer view index or buffer view object
+   * @returns a `Uint8Array`
+   */
+  getTypedArrayForBufferView(bufferView) {
+    return (0, import_get_typed_array.getTypedArrayForBufferView)(this.gltf.json, this.gltf.buffers, bufferView);
+  }
+  /** Accepts accessor index or accessor object
+   * @returns a typed array with type that matches the types
+   */
+  getTypedArrayForAccessor(accessor) {
+    return (0, import_get_typed_array.getTypedArrayForAccessor)(this.gltf.json, this.gltf.buffers, accessor);
+  }
+  /** accepts accessor index or accessor object
+   * returns a `Uint8Array`
+   */
+  getTypedArrayForImageData(image) {
+    image = this.getAccessor(image);
+    const bufferView = this.getBufferView(image.bufferView);
+    const buffer = this.getBuffer(bufferView.buffer);
+    const arrayBuffer = buffer.data;
+    const byteOffset = bufferView.byteOffset || 0;
+    return new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+  }
+  // MODIFERS
+  /**
+   * Add an extra application-defined key to the top-level data structure
+   */
+  addApplicationData(key, data) {
+    this.json[key] = data;
+    return this;
+  }
+  /**
+   * `extras` - Standard GLTF field for storing application specific data
+   */
+  addExtraData(key, data) {
+    this.json.extras = this.json.extras || {};
+    this.json.extras[key] = data;
+    return this;
+  }
+  addObjectExtension(object, extensionName, data) {
+    object.extensions = object.extensions || {};
+    object.extensions[extensionName] = data;
+    this.registerUsedExtension(extensionName);
+    return this;
+  }
+  setObjectExtension(object, extensionName, data) {
+    const extensions = object.extensions || {};
+    extensions[extensionName] = data;
+  }
+  removeObjectExtension(object, extensionName) {
+    const extensions = object?.extensions || {};
+    if (extensions[extensionName]) {
+      this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+      const extensionsRemoved = this.json.extensionsRemoved;
+      if (!extensionsRemoved.includes(extensionName)) {
+        extensionsRemoved.push(extensionName);
+      }
+    }
+    delete extensions[extensionName];
+  }
+  /**
+   * Add to standard GLTF top level extension object, mark as used
+   */
+  addExtension(extensionName, extensionData = {}) {
+    (0, import_assert.assert)(extensionData);
+    this.json.extensions = this.json.extensions || {};
+    this.json.extensions[extensionName] = extensionData;
+    this.registerUsedExtension(extensionName);
+    return extensionData;
+  }
+  /**
+   * Standard GLTF top level extension object, mark as used and required
+   */
+  addRequiredExtension(extensionName, extensionData = {}) {
+    (0, import_assert.assert)(extensionData);
+    this.addExtension(extensionName, extensionData);
+    this.registerRequiredExtension(extensionName);
+    return extensionData;
+  }
+  /**
+   * Add extensionName to list of used extensions
+   */
+  registerUsedExtension(extensionName) {
+    this.json.extensionsUsed = this.json.extensionsUsed || [];
+    if (!this.json.extensionsUsed.find((ext) => ext === extensionName)) {
+      this.json.extensionsUsed.push(extensionName);
+    }
+  }
+  /**
+   * Add extensionName to list of required extensions
+   */
+  registerRequiredExtension(extensionName) {
+    this.registerUsedExtension(extensionName);
+    this.json.extensionsRequired = this.json.extensionsRequired || [];
+    if (!this.json.extensionsRequired.find((ext) => ext === extensionName)) {
+      this.json.extensionsRequired.push(extensionName);
+    }
+  }
+  /**
+   * Removes an extension from the top-level list
+   */
+  removeExtension(extensionName) {
+    if (this.json.extensions?.[extensionName]) {
+      this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+      const extensionsRemoved = this.json.extensionsRemoved;
+      if (!extensionsRemoved.includes(extensionName)) {
+        extensionsRemoved.push(extensionName);
+      }
+    }
+    if (this.json.extensions) {
+      delete this.json.extensions[extensionName];
+    }
+    if (this.json.extensionsRequired) {
+      this._removeStringFromArray(this.json.extensionsRequired, extensionName);
+    }
+    if (this.json.extensionsUsed) {
+      this._removeStringFromArray(this.json.extensionsUsed, extensionName);
+    }
+  }
+  /**
+   *  Set default scene which is to be displayed at load time
+   */
+  setDefaultScene(sceneIndex) {
+    this.json.scene = sceneIndex;
+  }
+  /**
+   * @todo: add more properties for scene initialization:
+   *   name`, `extensions`, `extras`
+   *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-scene
+   */
+  addScene(scene) {
+    const { nodeIndices } = scene;
+    this.json.scenes = this.json.scenes || [];
+    this.json.scenes.push({ nodes: nodeIndices });
+    return this.json.scenes.length - 1;
+  }
+  /**
+   * @todo: add more properties for node initialization:
+   *   `name`, `extensions`, `extras`, `camera`, `children`, `skin`, `rotation`, `scale`, `translation`, `weights`
+   *   https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#node
+   */
+  addNode(node) {
+    const { meshIndex, matrix } = node;
+    this.json.nodes = this.json.nodes || [];
+    const nodeData = { mesh: meshIndex };
+    if (matrix) {
+      nodeData.matrix = matrix;
+    }
+    this.json.nodes.push(nodeData);
+    return this.json.nodes.length - 1;
+  }
+  /** Adds a mesh to the json part */
+  addMesh(mesh) {
+    const { attributes, indices, material, mode = 4 } = mesh;
+    const accessors = this._addAttributes(attributes);
+    const glTFMesh = {
+      primitives: [
+        {
+          attributes: accessors,
+          mode
+        }
+      ]
+    };
+    if (indices) {
+      const indicesAccessor = this._addIndices(indices);
+      glTFMesh.primitives[0].indices = indicesAccessor;
+    }
+    if (Number.isFinite(material)) {
+      glTFMesh.primitives[0].material = material;
+    }
+    this.json.meshes = this.json.meshes || [];
+    this.json.meshes.push(glTFMesh);
+    return this.json.meshes.length - 1;
+  }
+  addPointCloud(attributes) {
+    const accessorIndices = this._addAttributes(attributes);
+    const glTFMesh = {
+      primitives: [
+        {
+          attributes: accessorIndices,
+          mode: 0
+          // GL.POINTS
+        }
+      ]
+    };
+    this.json.meshes = this.json.meshes || [];
+    this.json.meshes.push(glTFMesh);
+    return this.json.meshes.length - 1;
+  }
+  /**
+   * Adds a binary image. Builds glTF "JSON metadata" and saves buffer reference
+   * Buffer will be copied into BIN chunk during "pack"
+   * Currently encodes as glTF image
+   * @param imageData
+   * @param mimeType
+   */
+  addImage(imageData, mimeTypeOpt) {
+    const metadata = (0, import_images.getBinaryImageMetadata)(imageData);
+    const mimeType = mimeTypeOpt || metadata?.mimeType;
+    const bufferViewIndex = this.addBufferView(imageData);
+    const glTFImage = {
+      bufferView: bufferViewIndex,
+      mimeType
+    };
+    this.json.images = this.json.images || [];
+    this.json.images.push(glTFImage);
+    return this.json.images.length - 1;
+  }
+  /**
+   * Add one untyped source buffer, create a matching glTF `bufferView`, and return its index
+   * @param buffer
+   */
+  addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
+    const byteLength = buffer.byteLength;
+    (0, import_assert.assert)(Number.isFinite(byteLength));
+    this.sourceBuffers = this.sourceBuffers || [];
+    this.sourceBuffers.push(buffer);
+    const glTFBufferView = {
+      buffer: bufferIndex,
+      // Write offset from the start of the binary body
+      byteOffset,
+      byteLength
+    };
+    this.byteLength += (0, import_loader_utils.padToNBytes)(byteLength, 4);
+    this.json.bufferViews = this.json.bufferViews || [];
+    this.json.bufferViews.push(glTFBufferView);
+    return this.json.bufferViews.length - 1;
+  }
+  /**
+   * Adds an accessor to a bufferView, preserving explicitly supplied normalization.
+   * @param bufferViewIndex
+   * @param accessor
+   */
+  addAccessor(bufferViewIndex, accessor) {
+    const normalized = accessor.normalized;
+    const glTFAccessor = {
+      bufferView: bufferViewIndex,
+      ...normalized === void 0 ? {} : { normalized },
+      // @ts-ignore
+      type: (0, import_gltf_utils.getAccessorTypeFromSize)(accessor.size),
+      // @ts-ignore
+      componentType: accessor.componentType,
+      // @ts-ignore
+      count: accessor.count,
+      // @ts-ignore
+      max: accessor.max,
+      // @ts-ignore
+      min: accessor.min
+    };
+    this.json.accessors = this.json.accessors || [];
+    this.json.accessors.push(glTFAccessor);
+    return this.json.accessors.length - 1;
+  }
+  /**
+   * Add a binary buffer. Builds glTF "JSON metadata" and saves buffer reference
+   * Buffer will be copied into BIN chunk during "pack"
+   * Currently encodes buffers as glTF accessors, but this could be optimized
+   * @param sourceBuffer
+   * @param accessor
+   */
+  addBinaryBuffer(sourceBuffer, accessor = { size: 3 }) {
+    const bufferViewIndex = this.addBufferView(sourceBuffer);
+    let minMax = { min: accessor.min, max: accessor.max };
+    if (!minMax.min || !minMax.max) {
+      minMax = this._getAccessorMinMax(sourceBuffer, accessor.size);
+    }
+    const accessorDefaults = {
+      // @ts-ignore
+      size: accessor.size,
+      componentType: (0, import_gltf_utils.getComponentTypeFromArray)(sourceBuffer),
+      // @ts-ignore
+      count: Math.round(sourceBuffer.length / accessor.size),
+      min: minMax.min,
+      max: minMax.max
+    };
+    return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));
+  }
+  /**
+   * Adds a texture to the json part
+   * @todo: add more properties for texture initialization
+   * `name`, `extensions`, `extras`
+   * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texture
+   */
+  addTexture(texture) {
+    const { imageIndex, samplerIndex } = texture;
+    const glTFTexture = {
+      source: imageIndex,
+      ...samplerIndex === void 0 ? {} : { sampler: samplerIndex }
+    };
+    this.json.textures = this.json.textures || [];
+    this.json.textures.push(glTFTexture);
+    return this.json.textures.length - 1;
+  }
+  /** Adds a sampler to the JSON resources and returns its index; callers supply valid glTF properties. */
+  addSampler(sampler) {
+    this.json.samplers = this.json.samplers || [];
+    this.json.samplers.push({ ...sampler });
+    return this.json.samplers.length - 1;
+  }
+  /** Adds a material to the json part */
+  addMaterial(pbrMaterialInfo) {
+    this.json.materials = this.json.materials || [];
+    this.json.materials.push(pbrMaterialInfo);
+    return this.json.materials.length - 1;
+  }
+  /** Pack binary data, omitting the optional chunk when no buffer is declared or populated. */
+  createBinaryChunk() {
+    if (this.byteLength === 0 && !this.json.buffers?.length) {
+      delete this.json.buffers;
+      delete this.gltf.binary;
+      this.sourceBuffers = [];
+      this.gltf.buffers = [];
+      return;
+    }
+    const bufferOffsets = [0];
+    let totalByteLength = this.byteLength;
+    for (let bufferIndex = 1; bufferIndex < this.gltf.buffers.length; bufferIndex++) {
+      const buffer = this.gltf.buffers[bufferIndex];
+      if (!buffer) continue;
+      bufferOffsets[bufferIndex] = (0, import_loader_utils.padToNBytes)(totalByteLength, 8);
+      totalByteLength = bufferOffsets[bufferIndex] + (0, import_loader_utils.padToNBytes)(buffer.byteLength, 4);
+    }
+    const arrayBuffer = new ArrayBuffer(totalByteLength);
+    const targetArray = new Uint8Array(arrayBuffer);
+    let destinationByteOffset = 0;
+    for (const sourceBuffer of this.sourceBuffers || []) {
+      destinationByteOffset = (0, import_loader_utils.copyToArray)(sourceBuffer, targetArray, destinationByteOffset);
+    }
+    for (let bufferIndex = 1; bufferIndex < this.gltf.buffers.length; bufferIndex++) {
+      const buffer = this.gltf.buffers[bufferIndex];
+      if (buffer) (0, import_loader_utils.copyToArray)(buffer, targetArray, bufferOffsets[bufferIndex]);
+    }
+    for (const bufferView of this.json.bufferViews || []) {
+      const bufferOffset = bufferOffsets[bufferView.buffer];
+      (0, import_assert.assert)(bufferOffset !== void 0);
+      bufferView.byteOffset = bufferOffset + (bufferView.byteOffset || 0);
+      bufferView.buffer = 0;
+      for (const name of ["EXT_meshopt_compression", "KHR_meshopt_compression"]) {
+        const extension = bufferView.extensions?.[name];
+        if (extension) {
+          const extensionOffset = bufferOffsets[extension.buffer];
+          (0, import_assert.assert)(extensionOffset !== void 0);
+          extension.byteOffset = extensionOffset + (extension.byteOffset || 0);
+          extension.buffer = 0;
+        }
+      }
+    }
+    this.byteLength = totalByteLength;
+    this.json.buffers = [{ byteLength: totalByteLength }];
+    this.gltf.binary = arrayBuffer;
+    this.sourceBuffers = [arrayBuffer];
+    this.gltf.buffers = [{ arrayBuffer, byteOffset: 0, byteLength: arrayBuffer.byteLength }];
+  }
+  // PRIVATE
+  _removeStringFromArray(array, string) {
+    let found = true;
+    while (found) {
+      const index = array.indexOf(string);
+      if (index > -1) {
+        array.splice(index, 1);
+      } else {
+        found = false;
+      }
+    }
+  }
+  /**
+   * Add attributes to buffers with four-byte vertex alignment and create the mesh attribute map.
+   */
+  _addAttributes(attributes = {}) {
+    const result = {};
+    for (const attributeKey in attributes) {
+      const attributeData = attributes[attributeKey];
+      const attrName = this._getGltfAttributeName(attributeKey);
+      const values = attributeData.value;
+      const elementByteLength = values.BYTES_PER_ELEMENT * attributeData.size;
+      const byteStride = (0, import_loader_utils.padToNBytes)(elementByteLength, 4);
+      let accessor;
+      if (byteStride === elementByteLength) {
+        accessor = this.addBinaryBuffer(values, attributeData);
+      } else {
+        const count = values.length / attributeData.size;
+        const paddedBytes = new Uint8Array(count * byteStride);
+        const sourceBytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+        for (let index = 0; index < count; index++) {
+          paddedBytes.set(
+            sourceBytes.subarray(index * elementByteLength, (index + 1) * elementByteLength),
+            index * byteStride
+          );
+        }
+        const bufferView = this.addBufferView(paddedBytes);
+        this.json.bufferViews[bufferView].byteStride = byteStride;
+        accessor = this.addAccessor(bufferView, {
+          ...this._getAccessorMinMax(values, attributeData.size),
+          ...attributeData,
+          componentType: (0, import_gltf_utils.getComponentTypeFromArray)(values),
+          count
+        });
+      }
+      result[attrName] = accessor;
+    }
+    return result;
+  }
+  /**
+   * Add indices to buffers
+   */
+  _addIndices(indices) {
+    return this.addBinaryBuffer(indices, { size: 1 });
+  }
+  /**
+   * Deduce gltf specific attribue name from input attribute name
+   */
+  _getGltfAttributeName(attributeName) {
+    switch (attributeName.toLowerCase()) {
+      case "position":
+      case "positions":
+      case "vertices":
+        return "POSITION";
+      case "normal":
+      case "normals":
+        return "NORMAL";
+      case "color":
+      case "colors":
+        return "COLOR_0";
+      case "texcoord":
+      case "texcoords":
+        return "TEXCOORD_0";
+      default:
+        return attributeName;
+    }
+  }
+  /**
+   * Calculate `min` and `max` arrays of accessor according to spec:
+   * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-accessor
+   */
+  _getAccessorMinMax(buffer, size) {
+    const result = { min: null, max: null };
+    if (buffer.length < size) {
+      return result;
+    }
+    result.min = [];
+    result.max = [];
+    const initValues = buffer.subarray(0, size);
+    for (const value of initValues) {
+      result.min.push(value);
+      result.max.push(value);
+    }
+    for (let index = size; index < buffer.length; index += size) {
+      for (let componentIndex = 0; componentIndex < size; componentIndex++) {
+        result.min[0 + componentIndex] = Math.min(
+          // @ts-ignore
+          result.min[0 + componentIndex],
+          buffer[index + componentIndex]
+        );
+        result.max[0 + componentIndex] = Math.max(
+          // @ts-ignore
+          result.max[0 + componentIndex],
+          buffer[index + componentIndex]
+        );
+      }
+    }
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLTFScenegraph
+});
+//# sourceMappingURL=gltf-scenegraph.cjs.map