@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/gltf-utils/gltf-attribute-utils.js

@@ -1,73 +1,73 @@
-import { getAccessorTypeFromSize, getComponentTypeFromArray } from './gltf-utils';
-export function getGLTFAccessors(attributes) {
-  const accessors = {};
-
-  for (const name in attributes) {
-    const attribute = attributes[name];
-
-    if (name !== 'indices') {
-      const glTFAccessor = getGLTFAccessor(attribute);
-      accessors[name] = glTFAccessor;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGLTFAccessor = exports.getGLTFAccessors = void 0;
+// TODO - remove
+const gltf_utils_1 = require("./gltf-utils");
+// Returns a fresh attributes object with glTF-standardized attributes names
+// Attributes that cannot be identified will not be included
+// Removes `indices` if present, as it should be stored separately from the attributes
+function getGLTFAccessors(attributes) {
+    const accessors = {};
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        if (name !== 'indices') {
+            const glTFAccessor = getGLTFAccessor(attribute);
+            accessors[name] = glTFAccessor;
+        }
     }
-  }
-
-  return accessors;
+    return accessors;
 }
-export function getGLTFAccessor(attribute) {
-  const {
-    buffer,
-    size,
-    count
-  } = getAccessorData(attribute);
-  const glTFAccessor = {
-    value: buffer,
-    size,
-    byteOffset: 0,
-    count,
-    type: getAccessorTypeFromSize(size),
-    componentType: getComponentTypeFromArray(buffer)
-  };
-  return glTFAccessor;
+exports.getGLTFAccessors = getGLTFAccessors;
+// Fix up a single accessor.
+// Input: typed array or a partial accessor object
+// Return: accessor object
+function getGLTFAccessor(attribute) {
+    const { buffer, size, count } = getAccessorData(attribute);
+    const glTFAccessor = {
+        // glTF Accessor values
+        // TODO: Instead of a bufferView index we could have an actual buffer (typed array)
+        // bufferView: null,
+        // TODO: Deprecate `value` in favor of bufferView?
+        // @ts-ignore
+        value: buffer,
+        size,
+        byteOffset: 0,
+        count,
+        type: (0, gltf_utils_1.getAccessorTypeFromSize)(size),
+        componentType: (0, gltf_utils_1.getComponentTypeFromArray)(buffer)
+    };
+    return glTFAccessor;
 }
-
+exports.getGLTFAccessor = getGLTFAccessor;
+// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {
+//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];
+// }
 function getAccessorData(attribute) {
-  let buffer = attribute;
-  let size = 1;
-  let count = 0;
-
-  if (attribute && attribute.value) {
-    buffer = attribute.value;
-    size = attribute.size || 1;
-  }
-
-  if (buffer) {
-    if (!ArrayBuffer.isView(buffer)) {
-      buffer = toTypedArray(buffer, Float32Array);
+    let buffer = attribute;
+    let size = 1;
+    let count = 0;
+    if (attribute && attribute.value) {
+        buffer = attribute.value;
+        size = attribute.size || 1;
     }
-
-    count = buffer.length / size;
-  }
-
-  return {
-    buffer,
-    size,
-    count
-  };
+    if (buffer) {
+        if (!ArrayBuffer.isView(buffer)) {
+            buffer = toTypedArray(buffer, Float32Array);
+        }
+        count = buffer.length / size;
+    }
+    return { buffer, size, count };
 }
-
+// Convert non-typed arrays to arrays of specified format
 function toTypedArray(array, ArrayType, convertTypedArrays = false) {
-  if (!array) {
-    return null;
-  }
-
-  if (Array.isArray(array)) {
-    return new ArrayType(array);
-  }
-
-  if (convertTypedArrays && !(array instanceof ArrayType)) {
-    return new ArrayType(array);
-  }
-
-  return array;
+    if (!array) {
+        return null;
+    }
+    if (Array.isArray(array)) {
+        return new ArrayType(array);
+    }
+    if (convertTypedArrays && !(array instanceof ArrayType)) {
+        return new ArrayType(array);
+    }
+    return array;
 }
-//# sourceMappingURL=gltf-attribute-utils.js.map

package/dist/lib/gltf-utils/gltf-constants.d.ts

@@ -1,3 +1,20 @@
+export declare const COMPONENTS: {
+    SCALAR: number;
+    VEC2: number;
+    VEC3: number;
+    VEC4: number;
+    MAT2: number;
+    MAT3: number;
+    MAT4: number;
+};
+export declare const BYTES: {
+    5120: number;
+    5121: number;
+    5122: number;
+    5123: number;
+    5125: number;
+    5126: number;
+};
 export declare function getBytesFromComponentType(componentType: any): any;
 export declare function getSizeFromAccessorType(type: any): any;
 export declare function getGLEnumFromSamplerParameter(parameter: any): any;

package/dist/lib/gltf-utils/gltf-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-constants.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"names":[],"mappings":"AAqBA,wBAAgB,yBAAyB,CAAC,aAAa,KAAA,OAEtD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAE3C;AAED,wBAAgB,6BAA6B,CAAC,SAAS,KAAA,OActD"}
+{"version":3,"file":"gltf-constants.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;CAQtB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;CAOjB,CAAC;AAIF,wBAAgB,yBAAyB,CAAC,aAAa,KAAA,OAEtD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAE3C;AAED,wBAAgB,6BAA6B,CAAC,SAAS,KAAA,OActD"}

package/dist/lib/gltf-utils/gltf-constants.js

@@ -1,37 +1,43 @@
-const COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGLEnumFromSamplerParameter = exports.getSizeFromAccessorType = exports.getBytesFromComponentType = exports.BYTES = exports.COMPONENTS = void 0;
+exports.COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
 };
-const BYTES = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
+exports.BYTES = {
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4 // FLOAT
 };
-export function getBytesFromComponentType(componentType) {
-  return BYTES[componentType];
+// ENUM LOOKUP
+function getBytesFromComponentType(componentType) {
+    return exports.BYTES[componentType];
 }
-export function getSizeFromAccessorType(type) {
-  return COMPONENTS[type];
+exports.getBytesFromComponentType = getBytesFromComponentType;
+function getSizeFromAccessorType(type) {
+    return exports.COMPONENTS[type];
 }
-export function getGLEnumFromSamplerParameter(parameter) {
-  const GL_TEXTURE_MAG_FILTER = 0x2800;
-  const GL_TEXTURE_MIN_FILTER = 0x2801;
-  const GL_TEXTURE_WRAP_S = 0x2802;
-  const GL_TEXTURE_WRAP_T = 0x2803;
-  const PARAMETER_MAP = {
-    magFilter: GL_TEXTURE_MAG_FILTER,
-    minFilter: GL_TEXTURE_MIN_FILTER,
-    wrapS: GL_TEXTURE_WRAP_S,
-    wrapT: GL_TEXTURE_WRAP_T
-  };
-  return PARAMETER_MAP[parameter];
+exports.getSizeFromAccessorType = getSizeFromAccessorType;
+function getGLEnumFromSamplerParameter(parameter) {
+    const GL_TEXTURE_MAG_FILTER = 0x2800;
+    const GL_TEXTURE_MIN_FILTER = 0x2801;
+    const GL_TEXTURE_WRAP_S = 0x2802;
+    const GL_TEXTURE_WRAP_T = 0x2803;
+    const PARAMETER_MAP = {
+        magFilter: GL_TEXTURE_MAG_FILTER,
+        minFilter: GL_TEXTURE_MIN_FILTER,
+        wrapS: GL_TEXTURE_WRAP_S,
+        wrapT: GL_TEXTURE_WRAP_T
+    };
+    return PARAMETER_MAP[parameter];
 }
-//# sourceMappingURL=gltf-constants.js.map
+exports.getGLEnumFromSamplerParameter = getGLEnumFromSamplerParameter;

package/dist/lib/gltf-utils/gltf-utils.d.ts

@@ -1,3 +1,4 @@
+import type { GLTFPostprocessed } from '../types/gltf-postprocessed-schema';
 export declare function getAccessorTypeFromSize(size: any): string;
 export declare function getComponentTypeFromArray(typedArray: any): number;
 export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView: any): {
@@ -5,4 +6,10 @@ export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView:
     length: number;
     byteLength: number;
 };
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+export declare function getMemoryUsageGLTF(gltf: GLTFPostprocessed): number;
 //# sourceMappingURL=gltf-utils.d.ts.map

package/dist/lib/gltf-utils/gltf-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAyDA,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;EAQjE"}
+{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oCAAoC,CAAC;AA+D1E,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;EAQjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiBlE"}

package/dist/lib/gltf-utils/gltf-utils.js

@@ -1,56 +1,90 @@
-import { assert } from '../utils/assert';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemoryUsageGLTF = exports.getAccessorArrayTypeAndLength = exports.getComponentTypeFromArray = exports.getAccessorTypeFromSize = void 0;
+const assert_1 = require("../utils/assert");
+/**
+ * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...
+ * Minimum 1.33, but due to GPU layout may be 1.5
+ */
+const MIPMAP_FACTOR = 1.33;
 const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
-const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+    [Int8Array, 5120],
+    [Uint8Array, 5121],
+    [Int16Array, 5122],
+    [Uint16Array, 5123],
+    [Uint32Array, 5125],
+    [Float32Array, 5126],
+    [Float64Array, 5130]
+];
 const ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
 };
 const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5125: 4,
+    5126: 4
 };
 const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-  5120: Int8Array,
-  5121: Uint8Array,
-  5122: Int16Array,
-  5123: Uint16Array,
-  5125: Uint32Array,
-  5126: Float32Array
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
 };
-export function getAccessorTypeFromSize(size) {
-  const type = TYPES[size - 1];
-  return type || TYPES[0];
+function getAccessorTypeFromSize(size) {
+    const type = TYPES[size - 1];
+    return type || TYPES[0];
 }
-export function getComponentTypeFromArray(typedArray) {
-  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
-
-  if (!componentType) {
-    throw new Error('Illegal typed array');
-  }
-
-  return componentType;
+exports.getAccessorTypeFromSize = getAccessorTypeFromSize;
+function getComponentTypeFromArray(typedArray) {
+    const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+    if (!componentType) {
+        throw new Error('Illegal typed array');
+    }
+    return componentType;
 }
-export function getAccessorArrayTypeAndLength(accessor, bufferView) {
-  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
-  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
-  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
-  const length = accessor.count * components;
-  const byteLength = accessor.count * components * bytesPerComponent;
-  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
-  return {
-    ArrayType,
-    length,
-    byteLength
-  };
+exports.getComponentTypeFromArray = getComponentTypeFromArray;
+function getAccessorArrayTypeAndLength(accessor, bufferView) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+    const length = accessor.count * components;
+    const byteLength = accessor.count * components * bytesPerComponent;
+    (0, assert_1.assert)(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    return { ArrayType, length, byteLength };
 }
-//# sourceMappingURL=gltf-utils.js.map
+exports.getAccessorArrayTypeAndLength = getAccessorArrayTypeAndLength;
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+function getMemoryUsageGLTF(gltf) {
+    let { images, bufferViews } = gltf;
+    images = images || [];
+    bufferViews = bufferViews || [];
+    const imageBufferViews = images.map((i) => i.bufferView);
+    bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
+    const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+    // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)
+    // TODO correctly handle compressed textures
+    const pixelCount = images.reduce((acc, image) => {
+        // @ts-ignore
+        const { width, height } = image.image;
+        return acc + width * height;
+    }, 0);
+    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+}
+exports.getMemoryUsageGLTF = getMemoryUsageGLTF;

package/dist/lib/gltf-utils/resolve-url.js

@@ -1,16 +1,18 @@
-export function resolveUrl(url, options) {
-  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
-
-  if (absolute) {
-    return url;
-  }
-
-  const baseUrl = options.baseUri || options.uri;
-
-  if (!baseUrl) {
-    throw new Error("'baseUri' must be provided to resolve relative url ".concat(url));
-  }
-
-  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrl = void 0;
+// Resolves a relative url against a baseUrl
+// If url is absolute, return it unchanged
+function resolveUrl(url, options) {
+    // TODO: Use better logic to handle all protocols plus not delay on data
+    const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
+    if (absolute) {
+        return url;
+    }
+    const baseUrl = options.baseUri || options.uri;
+    if (!baseUrl) {
+        throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    }
+    return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
 }
-//# sourceMappingURL=resolve-url.js.map
+exports.resolveUrl = resolveUrl;

package/dist/lib/parsers/parse-glb.d.ts

@@ -1,8 +1,20 @@
 import type { GLB } from '../types/glb-types';
-export declare type GLBParseOptions = {
+/** Options for parsing a GLB */
+export type ParseGLBOptions = {
+    /** @deprecated This option was used by XVIZ protocol to define a non-standard magic number */
     magic?: number;
+    /** @deprecated This option was used by XVIZ protocol to embed non-standard chunks */
     strict?: boolean;
 };
-export declare function isGLB(arrayBuffer: ArrayBuffer, byteOffset?: number, options?: GLBParseOptions): boolean;
-export default function parseGLBSync(glb: GLB, arrayBuffer: ArrayBuffer, byteOffset?: number, options?: GLBParseOptions): number;
+/** Check if the contents of an array buffer contains GLB byte markers */
+export declare function isGLB(arrayBuffer: ArrayBuffer, byteOffset?: number, options?: ParseGLBOptions): boolean;
+/**
+ * Synchronously parse a GLB
+ * @param glb - Target, Output is stored there
+ * @param arrayBuffer - Input data
+ * @param byteOffset - Offset into arrayBuffer to start parsing from (for "embedded" GLBs, e.g. in 3D tiles)
+ * @param options
+ * @returns
+ */
+export declare function parseGLBSync(glb: GLB, arrayBuffer: ArrayBuffer, byteOffset?: number, options?: ParseGLBOptions): number;
 //# sourceMappingURL=parse-glb.d.ts.map

package/dist/lib/parsers/parse-glb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-glb.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oBAAoB,CAAC;AAG5C,oBAAY,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAyBF,wBAAgB,KAAK,CACnB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAMT;AAED,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,UAqC9B"}
+{"version":3,"file":"parse-glb.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-glb.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,oBAAoB,CAAC;AAG5C,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG;IAC5B,8FAA8F;IAC9F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA0BF,yEAAyE;AACzE,wBAAgB,KAAK,CACnB,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAMT;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,WAAW,EACxB,UAAU,GAAE,MAAU,EACtB,OAAO,GAAE,eAAoB,UAmC9B"}