@loaders.gl/draco 4.0.0-alpha.9 → 4.0.0-beta.1

package/dist/lib/draco-builder.js

@@ -1,338 +0,0 @@
-"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.js

@@ -1,93 +0,0 @@
-"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_DECODER_VERSION = '1.5.5';
-const DRACO_ENCODER_VERSION = '1.4.1';
-const STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-const DRACO_JS_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.js`;
-const DRACO_WASM_WRAPPER_URL = `${STATIC_DECODER_URL}/draco_wasm_wrapper.js`;
-const DRACO_WASM_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.wasm`;
-const DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_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.
-        });
-    });
-}