obj2gltf/lib/ArrayStorage.js

'use strict';
const Cesium = require('cesium');

const ComponentDatatype = Cesium.ComponentDatatype;

module.exports = ArrayStorage;

const initialLength = 1024; // 2^10
const doublingThreshold = 33554432; // 2^25 (~134 MB for a Float32Array)
const fixedExpansionLength = 33554432; // 2^25 (~134 MB for a Float32Array)

/**
 * Provides expandable typed array storage for geometry data. This is preferable to JS arrays which are
 * stored with double precision. The resizing mechanism is similar to std::vector.
 *
 * @param {ComponentDatatype} componentDatatype The data type.
 *
 * @private
 */
function ArrayStorage(componentDatatype) {
    this.componentDatatype = componentDatatype;
    this.typedArray = ComponentDatatype.createTypedArray(componentDatatype, 0);
    this.length = 0;
}

function resize(storage, length) {
    const typedArray = ComponentDatatype.createTypedArray(storage.componentDatatype, length);
    typedArray.set(storage.typedArray);
    storage.typedArray = typedArray;
}

ArrayStorage.prototype.push = function(value) {
    const length = this.length;
    const typedArrayLength = this.typedArray.length;

    if (length === 0) {
        resize(this, initialLength);
    } else if (length === typedArrayLength) {
        if (length < doublingThreshold) {
            resize(this, typedArrayLength * 2);
        } else {
            resize(this, typedArrayLength + fixedExpansionLength);
        }
    }

    this.typedArray[this.length++] = value;
};

ArrayStorage.prototype.get = function(index) {
    return this.typedArray[index];
};

const sizeOfUint16 = 2;
const sizeOfUint32 = 4;
const sizeOfFloat = 4;

ArrayStorage.prototype.toUint16Buffer = function() {
    const length = this.length;
    const typedArray = this.typedArray;
    const paddedLength = length + ((length % 2 === 0) ? 0 : 1); // Round to next multiple of 2
    const buffer = Buffer.alloc(paddedLength * sizeOfUint16);
    for (let i = 0; i < length; ++i) {
        buffer.writeUInt16LE(typedArray[i], i * sizeOfUint16);
    }
    return buffer;
};

ArrayStorage.prototype.toUint32Buffer = function() {
    const length = this.length;
    const typedArray = this.typedArray;
    const buffer = Buffer.alloc(length * sizeOfUint32);
    for (let i = 0; i < length; ++i) {
        buffer.writeUInt32LE(typedArray[i], i * sizeOfUint32);
    }
    return buffer;
};

ArrayStorage.prototype.toFloatBuffer = function() {
    const length = this.length;
    const typedArray = this.typedArray;
    const buffer = Buffer.alloc(length * sizeOfFloat);
    for (let i = 0; i < length; ++i) {
        buffer.writeFloatLE(typedArray[i], i * sizeOfFloat);
    }
    return buffer;
};

ArrayStorage.prototype.getMinMax = function(components) {
    const length = this.length;
    const typedArray = this.typedArray;
    const count = length / components;
    const min = new Array(components).fill(Number.POSITIVE_INFINITY);
    const max = new Array(components).fill(Number.NEGATIVE_INFINITY);
    for (let i = 0; i < count; ++i) {
        for (let j = 0; j < components; ++j) {
            const index = i * components + j;
            const value = typedArray[index];
            min[j] = Math.min(min[j], value);
            max[j] = Math.max(max[j], value);
        }
    }
    return {
        min : min,
        max : max
    };
};