@loaders.gl/draco 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/draco-builder.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Native Draco attribute names to GLTF attribute names.
+const GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
+    POSITION: 'POSITION',
+    NORMAL: 'NORMAL',
+    COLOR_0: 'COLOR',
+    TEXCOORD_0: 'TEX_COORD'
+};
+const noop = () => { };
+class DracoBuilder {
+    // draco - the draco decoder, either import `draco3d` or load dynamically
+    constructor(draco) {
+        this.draco = draco;
+        this.dracoEncoder = new this.draco.Encoder();
+        this.dracoMeshBuilder = new this.draco.MeshBuilder();
+        this.dracoMetadataBuilder = new this.draco.MetadataBuilder();
+    }
+    destroy() {
+        this.destroyEncodedObject(this.dracoMeshBuilder);
+        this.destroyEncodedObject(this.dracoEncoder);
+        this.destroyEncodedObject(this.dracoMetadataBuilder);
+        // @ts-ignore
+        this.dracoMeshBuilder = null;
+        // @ts-ignore
+        this.dracoEncoder = null;
+        // @ts-ignore
+        this.draco = null;
+    }
+    // TBD - when does this need to be called?
+    destroyEncodedObject(object) {
+        if (object) {
+            this.draco.destroy(object);
+        }
+    }
+    /**
+     * Encode mesh or point cloud
+     * @param mesh =({})
+     * @param options
+     */
+    encodeSync(mesh, options = {}) {
+        this.log = noop; // TODO
+        this._setOptions(options);
+        return options.pointcloud
+            ? this._encodePointCloud(mesh, options)
+            : this._encodeMesh(mesh, options);
+    }
+    // PRIVATE
+    _getAttributesFromMesh(mesh) {
+        // TODO - Change the encodePointCloud interface instead?
+        const attributes = { ...mesh, ...mesh.attributes };
+        // Fold indices into the attributes
+        if (mesh.indices) {
+            attributes.indices = mesh.indices;
+        }
+        return attributes;
+    }
+    _encodePointCloud(pointcloud, options) {
+        const dracoPointCloud = new this.draco.PointCloud();
+        if (options.metadata) {
+            this._addGeometryMetadata(dracoPointCloud, options.metadata);
+        }
+        const attributes = this._getAttributesFromMesh(pointcloud);
+        // Build a `DracoPointCloud` from the input data
+        this._createDracoPointCloud(dracoPointCloud, attributes, options);
+        const dracoData = new this.draco.DracoInt8Array();
+        try {
+            const encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(dracoPointCloud, false, dracoData);
+            if (!(encodedLen > 0)) {
+                throw new Error('Draco encoding failed.');
+            }
+            this.log(`DRACO encoded ${dracoPointCloud.num_points()} points
+        with ${dracoPointCloud.num_attributes()} attributes into ${encodedLen} bytes`);
+            return dracoInt8ArrayToArrayBuffer(dracoData);
+        }
+        finally {
+            this.destroyEncodedObject(dracoData);
+            this.destroyEncodedObject(dracoPointCloud);
+        }
+    }
+    _encodeMesh(mesh, options) {
+        const dracoMesh = new this.draco.Mesh();
+        if (options.metadata) {
+            this._addGeometryMetadata(dracoMesh, options.metadata);
+        }
+        const attributes = this._getAttributesFromMesh(mesh);
+        // Build a `DracoMesh` from the input data
+        this._createDracoMesh(dracoMesh, attributes, options);
+        const dracoData = new this.draco.DracoInt8Array();
+        try {
+            const encodedLen = this.dracoEncoder.EncodeMeshToDracoBuffer(dracoMesh, dracoData);
+            if (encodedLen <= 0) {
+                throw new Error('Draco encoding failed.');
+            }
+            this.log(`DRACO encoded ${dracoMesh.num_points()} points
+        with ${dracoMesh.num_attributes()} attributes into ${encodedLen} bytes`);
+            return dracoInt8ArrayToArrayBuffer(dracoData);
+        }
+        finally {
+            this.destroyEncodedObject(dracoData);
+            this.destroyEncodedObject(dracoMesh);
+        }
+    }
+    /**
+     * Set encoding options.
+     * @param {{speed?: any; method?: any; quantization?: any;}} options
+     */
+    _setOptions(options) {
+        if ('speed' in options) {
+            // @ts-ignore
+            this.dracoEncoder.SetSpeedOptions(...options.speed);
+        }
+        if ('method' in options) {
+            const dracoMethod = this.draco[options.method || 'MESH_SEQUENTIAL_ENCODING'];
+            // assert(dracoMethod)
+            this.dracoEncoder.SetEncodingMethod(dracoMethod);
+        }
+        if ('quantization' in options) {
+            for (const attribute in options.quantization) {
+                const bits = options.quantization[attribute];
+                const dracoPosition = this.draco[attribute];
+                this.dracoEncoder.SetAttributeQuantization(dracoPosition, bits);
+            }
+        }
+    }
+    /**
+     * @param {Mesh} dracoMesh
+     * @param {object} attributes
+     * @returns {Mesh}
+     */
+    _createDracoMesh(dracoMesh, attributes, options) {
+        const optionalMetadata = options.attributesMetadata || {};
+        try {
+            const positions = this._getPositionAttribute(attributes);
+            if (!positions) {
+                throw new Error('positions');
+            }
+            const vertexCount = positions.length / 3;
+            for (let attributeName in attributes) {
+                const attribute = attributes[attributeName];
+                attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
+                const uniqueId = this._addAttributeToMesh(dracoMesh, attributeName, attribute, vertexCount);
+                if (uniqueId !== -1) {
+                    this._addAttributeMetadata(dracoMesh, uniqueId, {
+                        name: attributeName,
+                        ...(optionalMetadata[attributeName] || {})
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.destroyEncodedObject(dracoMesh);
+            throw error;
+        }
+        return dracoMesh;
+    }
+    /**
+     * @param {} dracoPointCloud
+     * @param {object} attributes
+     */
+    _createDracoPointCloud(dracoPointCloud, attributes, options) {
+        const optionalMetadata = options.attributesMetadata || {};
+        try {
+            const positions = this._getPositionAttribute(attributes);
+            if (!positions) {
+                throw new Error('positions');
+            }
+            const vertexCount = positions.length / 3;
+            for (let attributeName in attributes) {
+                const attribute = attributes[attributeName];
+                attributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName] || attributeName;
+                const uniqueId = this._addAttributeToMesh(dracoPointCloud, attributeName, attribute, vertexCount);
+                if (uniqueId !== -1) {
+                    this._addAttributeMetadata(dracoPointCloud, uniqueId, {
+                        name: attributeName,
+                        ...(optionalMetadata[attributeName] || {})
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.destroyEncodedObject(dracoPointCloud);
+            throw error;
+        }
+        return dracoPointCloud;
+    }
+    /**
+     * @param mesh
+     * @param attributeName
+     * @param attribute
+     * @param vertexCount
+     */
+    _addAttributeToMesh(mesh, attributeName, attribute, vertexCount) {
+        if (!ArrayBuffer.isView(attribute)) {
+            return -1;
+        }
+        const type = this._getDracoAttributeType(attributeName);
+        // @ts-ignore TODO/fix types
+        const size = attribute.length / vertexCount;
+        if (type === 'indices') {
+            // @ts-ignore TODO/fix types
+            const numFaces = attribute.length / 3;
+            this.log(`Adding attribute ${attributeName}, size ${numFaces}`);
+            // @ts-ignore assumes mesh is a Mesh, not a point cloud
+            this.dracoMeshBuilder.AddFacesToMesh(mesh, numFaces, attribute);
+            return -1;
+        }
+        this.log(`Adding attribute ${attributeName}, size ${size}`);
+        const builder = this.dracoMeshBuilder;
+        const { buffer } = attribute;
+        switch (attribute.constructor) {
+            case Int8Array:
+                return builder.AddInt8Attribute(mesh, type, vertexCount, size, new Int8Array(buffer));
+            case Int16Array:
+                return builder.AddInt16Attribute(mesh, type, vertexCount, size, new Int16Array(buffer));
+            case Int32Array:
+                return builder.AddInt32Attribute(mesh, type, vertexCount, size, new Int32Array(buffer));
+            case Uint8Array:
+            case Uint8ClampedArray:
+                return builder.AddUInt8Attribute(mesh, type, vertexCount, size, new Uint8Array(buffer));
+            case Uint16Array:
+                return builder.AddUInt16Attribute(mesh, type, vertexCount, size, new Uint16Array(buffer));
+            case Uint32Array:
+                return builder.AddUInt32Attribute(mesh, type, vertexCount, size, new Uint32Array(buffer));
+            case Float32Array:
+            default:
+                return builder.AddFloatAttribute(mesh, type, vertexCount, size, new Float32Array(buffer));
+        }
+    }
+    /**
+     * DRACO can compress attributes of know type better
+     * TODO - expose an attribute type map?
+     * @param attributeName
+     */
+    _getDracoAttributeType(attributeName) {
+        switch (attributeName.toLowerCase()) {
+            case 'indices':
+                return 'indices';
+            case 'position':
+            case 'positions':
+            case 'vertices':
+                return this.draco.POSITION;
+            case 'normal':
+            case 'normals':
+                return this.draco.NORMAL;
+            case 'color':
+            case 'colors':
+                return this.draco.COLOR;
+            case 'texcoord':
+            case 'texcoords':
+                return this.draco.TEX_COORD;
+            default:
+                return this.draco.GENERIC;
+        }
+    }
+    _getPositionAttribute(attributes) {
+        for (const attributeName in attributes) {
+            const attribute = attributes[attributeName];
+            const dracoType = this._getDracoAttributeType(attributeName);
+            if (dracoType === this.draco.POSITION) {
+                return attribute;
+            }
+        }
+        return null;
+    }
+    /**
+     * Add metadata for the geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param metadata
+     */
+    _addGeometryMetadata(dracoGeometry, metadata) {
+        const dracoMetadata = new this.draco.Metadata();
+        this._populateDracoMetadata(dracoMetadata, metadata);
+        this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
+    }
+    /**
+     * Add metadata for an attribute to geometry.
+     * @param dracoGeometry - WASM Draco Object
+     * @param uniqueAttributeId
+     * @param metadata
+     */
+    _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
+        // Note: Draco JS IDL doesn't seem to expose draco.AttributeMetadata, however it seems to
+        // create such objects automatically from draco.Metadata object.
+        const dracoAttributeMetadata = new this.draco.Metadata();
+        this._populateDracoMetadata(dracoAttributeMetadata, metadata);
+        // Draco3d doc note: Directly add attribute metadata to geometry.
+        // You can do this without explicitly adding |GeometryMetadata| to mesh.
+        this.dracoMeshBuilder.SetMetadataForAttribute(dracoGeometry, uniqueAttributeId, dracoAttributeMetadata);
+    }
+    /**
+     * Add contents of object or map to a WASM Draco Metadata Object
+     * @param dracoMetadata - WASM Draco Object
+     * @param metadata
+     */
+    _populateDracoMetadata(dracoMetadata, metadata) {
+        for (const [key, value] of getEntries(metadata)) {
+            switch (typeof value) {
+                case 'number':
+                    if (Math.trunc(value) === value) {
+                        this.dracoMetadataBuilder.AddIntEntry(dracoMetadata, key, value);
+                    }
+                    else {
+                        this.dracoMetadataBuilder.AddDoubleEntry(dracoMetadata, key, value);
+                    }
+                    break;
+                case 'object':
+                    if (value instanceof Int32Array) {
+                        this.dracoMetadataBuilder.AddIntEntryArray(dracoMetadata, key, value, value.length);
+                    }
+                    break;
+                case 'string':
+                default:
+                    this.dracoMetadataBuilder.AddStringEntry(dracoMetadata, key, value);
+            }
+        }
+    }
+}
+exports.default = DracoBuilder;
+// HELPER FUNCTIONS
+/**
+ * Copy encoded data to buffer
+ * @param dracoData
+ */
+function dracoInt8ArrayToArrayBuffer(dracoData) {
+    const byteLength = dracoData.size();
+    const outputBuffer = new ArrayBuffer(byteLength);
+    const outputData = new Int8Array(outputBuffer);
+    for (let i = 0; i < byteLength; ++i) {
+        outputData[i] = dracoData.GetValue(i);
+    }
+    return outputBuffer;
+}
+/** Enable iteration over either an object or a map */
+function getEntries(container) {
+    const hasEntriesFunc = container.entries && !container.hasOwnProperty('entries');
+    return hasEntriesFunc ? container.entries() : Object.entries(container);
+}

package/dist/lib/draco-module-loader.d.ts

@@ -0,0 +1,3 @@
+export declare function loadDracoDecoderModule(options: any): Promise<any>;
+export declare function loadDracoEncoderModule(options: any): Promise<any>;
+//# sourceMappingURL=draco-module-loader.d.ts.map

package/dist/lib/draco-module-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draco-module-loader.d.ts","sourceRoot":"","sources":["../../src/lib/draco-module-loader.ts"],"names":[],"mappings":"AAgBA,wBAAsB,sBAAsB,CAAC,OAAO,KAAA,gBAenD;AAED,wBAAsB,sBAAsB,CAAC,OAAO,KAAA,gBAenD"}

package/dist/lib/draco-module-loader.js

@@ -0,0 +1,91 @@
+"use strict";
+// Dynamic DRACO module loading inspired by THREE.DRACOLoader
+// https://github.com/mrdoob/three.js/blob/398c4f39ebdb8b23eefd4a7a5ec49ec0c96c7462/examples/jsm/loaders/DRACOLoader.js
+// by Don McCurdy / https://www.donmccurdy.com / MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDracoEncoderModule = exports.loadDracoDecoderModule = void 0;
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const DRACO_VERSION = '1.4.1';
+const DRACO_JS_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.js`;
+const DRACO_WASM_WRAPPER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_wasm_wrapper.js`;
+const DRACO_WASM_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.wasm`;
+const DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_VERSION}/javascript/draco_encoder.js`;
+let loadDecoderPromise;
+let loadEncoderPromise;
+async function loadDracoDecoderModule(options) {
+    const modules = options.modules || {};
+    // Check if a bundled draco3d library has been supplied by application
+    if (modules.draco3d) {
+        loadDecoderPromise =
+            loadDecoderPromise ||
+                modules.draco3d.createDecoderModule({}).then((draco) => {
+                    return { draco };
+                });
+    }
+    else {
+        // If not, dynamically load the WASM script from our CDN
+        loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);
+    }
+    return await loadDecoderPromise;
+}
+exports.loadDracoDecoderModule = loadDracoDecoderModule;
+async function loadDracoEncoderModule(options) {
+    const modules = options.modules || {};
+    // Check if a bundled draco3d library has been supplied by application
+    if (modules.draco3d) {
+        loadEncoderPromise =
+            loadEncoderPromise ||
+                modules.draco3d.createEncoderModule({}).then((draco) => {
+                    return { draco };
+                });
+    }
+    else {
+        // If not, dynamically load the WASM script from our CDN
+        loadEncoderPromise = loadEncoderPromise || loadDracoEncoder(options);
+    }
+    return await loadEncoderPromise;
+}
+exports.loadDracoEncoderModule = loadDracoEncoderModule;
+// DRACO DECODER LOADING
+async function loadDracoDecoder(options) {
+    let DracoDecoderModule;
+    let wasmBinary;
+    switch (options.draco && options.draco.decoderType) {
+        case 'js':
+            DracoDecoderModule = await (0, worker_utils_1.loadLibrary)(DRACO_JS_DECODER_URL, 'draco', options);
+            break;
+        case 'wasm':
+        default:
+            [DracoDecoderModule, wasmBinary] = await Promise.all([
+                await (0, worker_utils_1.loadLibrary)(DRACO_WASM_WRAPPER_URL, 'draco', options),
+                await (0, worker_utils_1.loadLibrary)(DRACO_WASM_DECODER_URL, 'draco', options)
+            ]);
+    }
+    // Depends on how import happened...
+    // @ts-ignore
+    DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
+}
+function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+        options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+        DracoDecoderModule({
+            ...options,
+            onModuleLoaded: (draco) => resolve({ draco }) // Module is Promise-like. Wrap in object to avoid loop.
+        });
+    });
+}
+// ENCODER
+async function loadDracoEncoder(options) {
+    let DracoEncoderModule = await (0, worker_utils_1.loadLibrary)(DRACO_ENCODER_URL, 'draco', options);
+    // @ts-ignore
+    DracoEncoderModule = DracoEncoderModule || globalThis.DracoEncoderModule;
+    return new Promise((resolve) => {
+        DracoEncoderModule({
+            onModuleLoaded: (draco) => resolve({ draco }) // Module is Promise-like. Wrap in object to avoid loop.
+        });
+    });
+}

package/dist/lib/draco-parser.d.ts

@@ -0,0 +1,137 @@
+import type { TypedArray, MeshAttribute, MeshGeometry } from '@loaders.gl/schema';
+import type { Draco3D, Decoder, Mesh, PointCloud, PointAttribute, Metadata, MetadataQuerier } from '../draco3d/draco3d-types';
+import type { DracoMesh, DracoLoaderData, DracoAttribute, DracoMetadataEntry, DracoQuantizationTransform, DracoOctahedronTransform } from './draco-types';
+/**
+ * @param topology - How triangle indices should be generated (mesh only)
+ * @param attributeNameEntry
+ * @param extraAttributes
+ * @param quantizedAttributes
+ * @param octahedronAttributes
+ */
+export declare type DracoParseOptions = {
+    topology?: 'triangle-list' | 'triangle-strip';
+    attributeNameEntry?: string;
+    extraAttributes?: {
+        [uniqueId: string]: number;
+    };
+    quantizedAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];
+    octahedronAttributes?: ('POSITION' | 'NORMAL' | 'COLOR' | 'TEX_COORD' | 'GENERIC')[];
+};
+export default class DracoParser {
+    draco: Draco3D;
+    decoder: Decoder;
+    metadataQuerier: MetadataQuerier;
+    constructor(draco: Draco3D);
+    /**
+     * Destroy draco resources
+     */
+    destroy(): void;
+    /**
+     * NOTE: caller must call `destroyGeometry` on the return value after using it
+     * @param arrayBuffer
+     * @param options
+     */
+    parseSync(arrayBuffer: ArrayBuffer, options?: DracoParseOptions): DracoMesh;
+    /**
+     * Extract
+     * @param dracoGeometry
+     * @param geometry_type
+     * @param options
+     * @returns
+     */
+    _getDracoLoaderData(dracoGeometry: Mesh | PointCloud, geometry_type: any, options: DracoParseOptions): DracoLoaderData;
+    /**
+     * Extract all draco provided information and metadata for each attribute
+     * @param dracoGeometry
+     * @param options
+     * @returns
+     */
+    _getDracoAttributes(dracoGeometry: Mesh | PointCloud, options: DracoParseOptions): {
+        [unique_id: number]: DracoAttribute;
+    };
+    /**
+     * Get standard loaders.gl mesh category data
+     * Extracts the geometry from draco
+     * @param dracoGeometry
+     * @param options
+     */
+    _getMeshData(dracoGeometry: Mesh | PointCloud, loaderData: DracoLoaderData, options: DracoParseOptions): MeshGeometry;
+    _getMeshAttributes(loaderData: DracoLoaderData, dracoGeometry: Mesh | PointCloud, options: DracoParseOptions): {
+        [attributeName: string]: MeshAttribute;
+    };
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
+    _getTriangleListIndices(dracoGeometry: Mesh): Uint32Array;
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
+    _getTriangleStripIndices(dracoGeometry: Mesh): Int32Array;
+    /**
+     *
+     * @param dracoGeometry
+     * @param dracoAttribute
+     * @param attributeName
+     */
+    _getAttributeValues(dracoGeometry: Mesh | PointCloud, attribute: DracoAttribute): {
+        value: TypedArray;
+        size: number;
+    };
+    /**
+     * DRACO does not store attribute names - We need to deduce an attribute name
+     * for each attribute
+    _getAttributeNames(
+      dracoGeometry: Mesh | PointCloud,
+      options: DracoParseOptions
+    ): {[unique_id: number]: string} {
+      const attributeNames: {[unique_id: number]: string} = {};
+      for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+        const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+        const attributeName = this._deduceAttributeName(dracoAttribute, options);
+        attributeNames[attributeName] = attributeName;
+      }
+      return attributeNames;
+    }
+     */
+    /**
+     * Deduce an attribute name.
+     * @note DRACO does not save attribute names, just general type (POSITION, COLOR)
+     * to help optimize compression. We generate GLTF compatible names for the Draco-recognized
+     * types
+     * @param attributeData
+     */
+    _deduceAttributeName(attribute: DracoAttribute, options: DracoParseOptions): string;
+    /** Get top level metadata */
+    _getTopLevelMetadata(dracoGeometry: Mesh | PointCloud): {
+        [entry: string]: DracoMetadataEntry;
+    };
+    /** Get per attribute metadata */
+    _getAttributeMetadata(dracoGeometry: Mesh | PointCloud, attributeId: number): {
+        [entry: string]: DracoMetadataEntry;
+    };
+    /**
+     * Extract metadata field values
+     * @param dracoMetadata
+     * @returns
+     */
+    _getDracoMetadata(dracoMetadata: Metadata): {
+        [entry: string]: DracoMetadataEntry;
+    };
+    /**
+     * Extracts possible values for one metadata entry by name
+     * @param dracoMetadata
+     * @param entryName
+     */
+    _getDracoMetadataField(dracoMetadata: Metadata, entryName: string): DracoMetadataEntry;
+    /** Skip transforms for specific attribute types */
+    _disableAttributeTransforms(options: DracoParseOptions): void;
+    /**
+     * Extract (and apply?) Position Transform
+     * @todo not used
+     */
+    _getQuantizationTransform(dracoAttribute: PointAttribute, options: DracoParseOptions): DracoQuantizationTransform | null;
+    _getOctahedronTransform(dracoAttribute: PointAttribute, options: DracoParseOptions): DracoOctahedronTransform | null;
+}
+//# sourceMappingURL=draco-parser.d.ts.map

package/dist/lib/draco-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draco-parser.d.ts","sourceRoot":"","sources":["../../src/lib/draco-parser.ts"],"names":[],"mappings":"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"}