@loaders.gl/gltf 3.1.0-alpha.3 → 3.1.0-beta.2

package/dist/es5/lib/api/gltf-scenegraph.js

@@ -0,0 +1,529 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _images = require("@loaders.gl/images");
+
+var _loaderUtils = require("@loaders.gl/loader-utils");
+
+var _assert = require("../utils/assert");
+
+var _gltfUtils = require("../gltf-utils/gltf-utils");
+
+const DEFAULT_GLTF_JSON = {
+  asset: {
+    version: '2.0',
+    generator: 'loaders.gl'
+  },
+  buffers: []
+};
+
+class GLTFScenegraph {
+  constructor(gltf) {
+    (0, _defineProperty2.default)(this, "gltf", void 0);
+    (0, _defineProperty2.default)(this, "sourceBuffers", void 0);
+    (0, _defineProperty2.default)(this, "byteLength", void 0);
+    this.gltf = gltf || {
+      json: { ...DEFAULT_GLTF_JSON
+      },
+      buffers: []
+    };
+    this.sourceBuffers = [];
+    this.byteLength = 0;
+
+    if (this.gltf.buffers && this.gltf.buffers[0]) {
+      this.byteLength = this.gltf.buffers[0].byteLength;
+      this.sourceBuffers = [this.gltf.buffers[0]];
+    }
+  }
+
+  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];
+  }
+
+  getExtension(extensionName) {
+    const isExtension = this.getUsedExtensions().find(name => name === extensionName);
+    const extensions = this.json.extensions || {};
+    return isExtension ? extensions[extensionName] || true : 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 || [];
+  }
+
+  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);
+  }
+
+  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 ".concat(array, "[").concat(index, "]"));
+    }
+
+    return object;
+  }
+
+  getTypedArrayForBufferView(bufferView) {
+    bufferView = this.getBufferView(bufferView);
+    const bufferIndex = bufferView.buffer;
+    const binChunk = this.gltf.buffers[bufferIndex];
+    (0, _assert.assert)(binChunk);
+    const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+    return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+  }
+
+  getTypedArrayForAccessor(accessor) {
+    accessor = this.getAccessor(accessor);
+    const bufferView = this.getBufferView(accessor.bufferView);
+    const buffer = this.getBuffer(bufferView.buffer);
+    const arrayBuffer = buffer.data;
+    const {
+      ArrayType,
+      length
+    } = (0, _gltfUtils.getAccessorArrayTypeAndLength)(accessor, bufferView);
+    const byteOffset = bufferView.byteOffset + accessor.byteOffset;
+    return new ArrayType(arrayBuffer, byteOffset, length);
+  }
+
+  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);
+  }
+
+  addApplicationData(key, data) {
+    this.json[key] = data;
+    return this;
+  }
+
+  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 || {};
+    const extension = extensions[extensionName];
+    delete extensions[extensionName];
+    return extension;
+  }
+
+  addExtension(extensionName, extensionData = {}) {
+    (0, _assert.assert)(extensionData);
+    this.json.extensions = this.json.extensions || {};
+    this.json.extensions[extensionName] = extensionData;
+    this.registerUsedExtension(extensionName);
+    return extensionData;
+  }
+
+  addRequiredExtension(extensionName, extensionData = {}) {
+    (0, _assert.assert)(extensionData);
+    this.addExtension(extensionName, extensionData);
+    this.registerRequiredExtension(extensionName);
+    return extensionData;
+  }
+
+  registerUsedExtension(extensionName) {
+    this.json.extensionsUsed = this.json.extensionsUsed || [];
+
+    if (!this.json.extensionsUsed.find(ext => ext === extensionName)) {
+      this.json.extensionsUsed.push(extensionName);
+    }
+  }
+
+  registerRequiredExtension(extensionName) {
+    this.registerUsedExtension(extensionName);
+    this.json.extensionsRequired = this.json.extensionsRequired || [];
+
+    if (!this.json.extensionsRequired.find(ext => ext === extensionName)) {
+      this.json.extensionsRequired.push(extensionName);
+    }
+  }
+
+  removeExtension(extensionName) {
+    if (this.json.extensionsRequired) {
+      this._removeStringFromArray(this.json.extensionsRequired, extensionName);
+    }
+
+    if (this.json.extensionsUsed) {
+      this._removeStringFromArray(this.json.extensionsUsed, extensionName);
+    }
+
+    if (this.json.extensions) {
+      delete this.json.extensions[extensionName];
+    }
+  }
+
+  setDefaultScene(sceneIndex) {
+    this.json.scene = sceneIndex;
+  }
+
+  addScene(scene) {
+    const {
+      nodeIndices
+    } = scene;
+    this.json.scenes = this.json.scenes || [];
+    this.json.scenes.push({
+      nodes: nodeIndices
+    });
+    return this.json.scenes.length - 1;
+  }
+
+  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;
+  }
+
+  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
+      }]
+    };
+    this.json.meshes = this.json.meshes || [];
+    this.json.meshes.push(glTFMesh);
+    return this.json.meshes.length - 1;
+  }
+
+  addImage(imageData, mimeTypeOpt) {
+    const metadata = (0, _images.getBinaryImageMetadata)(imageData);
+    const mimeType = mimeTypeOpt || (metadata === null || metadata === void 0 ? void 0 : 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;
+  }
+
+  addBufferView(buffer) {
+    const byteLength = buffer.byteLength;
+    (0, _assert.assert)(Number.isFinite(byteLength));
+    this.sourceBuffers = this.sourceBuffers || [];
+    this.sourceBuffers.push(buffer);
+    const glTFBufferView = {
+      buffer: 0,
+      byteOffset: this.byteLength,
+      byteLength
+    };
+    this.byteLength += (0, _loaderUtils.padToNBytes)(byteLength, 4);
+    this.json.bufferViews = this.json.bufferViews || [];
+    this.json.bufferViews.push(glTFBufferView);
+    return this.json.bufferViews.length - 1;
+  }
+
+  addAccessor(bufferViewIndex, accessor) {
+    const glTFAccessor = {
+      bufferView: bufferViewIndex,
+      type: (0, _gltfUtils.getAccessorTypeFromSize)(accessor.size),
+      componentType: accessor.componentType,
+      count: accessor.count,
+      max: accessor.max,
+      min: accessor.min
+    };
+    this.json.accessors = this.json.accessors || [];
+    this.json.accessors.push(glTFAccessor);
+    return this.json.accessors.length - 1;
+  }
+
+  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 = {
+      size: accessor.size,
+      componentType: (0, _gltfUtils.getComponentTypeFromArray)(sourceBuffer),
+      count: Math.round(sourceBuffer.length / accessor.size),
+      min: minMax.min,
+      max: minMax.max
+    };
+    return this.addAccessor(bufferViewIndex, Object.assign(accessorDefaults, accessor));
+  }
+
+  addTexture(texture) {
+    const {
+      imageIndex
+    } = texture;
+    const glTFTexture = {
+      source: imageIndex
+    };
+    this.json.textures = this.json.textures || [];
+    this.json.textures.push(glTFTexture);
+    return this.json.textures.length - 1;
+  }
+
+  addMaterial(pbrMaterialInfo) {
+    this.json.materials = this.json.materials || [];
+    this.json.materials.push(pbrMaterialInfo);
+    return this.json.materials.length - 1;
+  }
+
+  createBinaryChunk() {
+    var _this$json, _this$json$buffers;
+
+    this.gltf.buffers = [];
+    const totalByteLength = this.byteLength;
+    const arrayBuffer = new ArrayBuffer(totalByteLength);
+    const targetArray = new Uint8Array(arrayBuffer);
+    let dstByteOffset = 0;
+
+    for (const sourceBuffer of this.sourceBuffers || []) {
+      dstByteOffset = (0, _loaderUtils.copyToArray)(sourceBuffer, targetArray, dstByteOffset);
+    }
+
+    if ((_this$json = this.json) !== null && _this$json !== void 0 && (_this$json$buffers = _this$json.buffers) !== null && _this$json$buffers !== void 0 && _this$json$buffers[0]) {
+      this.json.buffers[0].byteLength = totalByteLength;
+    } else {
+      this.json.buffers = [{
+        byteLength: totalByteLength
+      }];
+    }
+
+    this.gltf.binary = arrayBuffer;
+    this.sourceBuffers = [arrayBuffer];
+  }
+
+  _removeStringFromArray(array, string) {
+    let found = true;
+
+    while (found) {
+      const index = array.indexOf(string);
+
+      if (index > -1) {
+        array.splice(index, 1);
+      } else {
+        found = false;
+      }
+    }
+  }
+
+  _addAttributes(attributes = {}) {
+    const result = {};
+
+    for (const attributeKey in attributes) {
+      const attributeData = attributes[attributeKey];
+
+      const attrName = this._getGltfAttributeName(attributeKey);
+
+      const accessor = this.addBinaryBuffer(attributeData.value, attributeData);
+      result[attrName] = accessor;
+    }
+
+    return result;
+  }
+
+  _addIndices(indices) {
+    return this.addBinaryBuffer(indices, {
+      size: 1
+    });
+  }
+
+  _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;
+    }
+  }
+
+  _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(result.min[0 + componentIndex], buffer[index + componentIndex]);
+        result.max[0 + componentIndex] = Math.max(result.max[0 + componentIndex], buffer[index + componentIndex]);
+      }
+    }
+
+    return result;
+  }
+
+}
+
+exports.default = GLTFScenegraph;
+//# sourceMappingURL=gltf-scenegraph.js.map