@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/loader/parser/RGBEParser.js

@@ -1,248 +0,0 @@
-import { Texture } from "../../gfx/graphics/webGpu/core/texture/Texture";
-import { GPUTextureFormat } from "../../gfx/graphics/webGpu/WebGPUConst";
-import { HDRTexture } from "../../textures/HDRTexture";
-import { HDRTextureCube } from "../../textures/HDRTextureCube";
-import { toHalfFloat } from "../../util/Convert";
-import { ParserBase } from "./ParserBase";
-/* eslint-disable */
-export var RGBEErrorCode;
-(function (RGBEErrorCode) {
-    RGBEErrorCode[RGBEErrorCode["RGBE_RETURN_FAILURE"] = -1] = "RGBE_RETURN_FAILURE";
-    RGBEErrorCode[RGBEErrorCode["rgbe_read_error"] = 1] = "rgbe_read_error";
-    RGBEErrorCode[RGBEErrorCode["rgbe_write_error"] = 2] = "rgbe_write_error";
-    RGBEErrorCode[RGBEErrorCode["rgbe_format_error"] = 3] = "rgbe_format_error";
-    RGBEErrorCode[RGBEErrorCode["rgbe_memory_error"] = 4] = "rgbe_memory_error";
-})(RGBEErrorCode || (RGBEErrorCode = {}));
-export class RGBEHeader {
-}
-export class RGBEParser extends ParserBase {
-    constructor() {
-        super(...arguments);
-        this._RGBE_RETURN_FAILURE = -1;
-        this._parserType = GPUTextureFormat.rgba8uint;
-    }
-    parseBuffer(buffer) {
-        let ret_texture;
-        let byteArray = new Uint8Array(buffer);
-        byteArray["pos"] = 0;
-        const rgbe_header_info = this.paserHeader(byteArray);
-        if (rgbe_header_info instanceof RGBEHeader) {
-            const w = (this._width = rgbe_header_info.width);
-            const h = (this._height = rgbe_header_info.height);
-            let image_rgba_data = this.parserPixel(byteArray.subarray(byteArray["pos"]), w, h);
-            if (image_rgba_data instanceof Uint8Array) {
-                this._rgbeArray = image_rgba_data;
-                let data;
-                let numElements;
-                switch (this._parserType) {
-                }
-                this.data = ret_texture;
-                return ret_texture;
-            }
-        }
-        return null;
-    }
-    verification() {
-        if (this.data && this.data instanceof Texture) {
-            return true;
-        }
-        else if (this._rgbeArray) {
-            return true;
-        }
-        throw new Error("Method not implemented.");
-    }
-    getTexture() {
-        return this.data;
-    }
-    getCubeTexture() {
-        let size = this._width / 4;
-        let cubeTexture = new HDRTextureCube().createFromHDRData(size, {
-            width: this._width,
-            height: this._height,
-            array: this._rgbeArray,
-        });
-        return cubeTexture;
-    }
-    getHDRTexture() {
-        let texture = new HDRTexture().create(this._width, this._height, this._rgbeArray.buffer instanceof ArrayBuffer ? this._rgbeArray.buffer : new Uint8Array(this._rgbeArray).buffer);
-        return texture;
-    }
-    parseError(rgbe_error_code, msg) {
-        switch (rgbe_error_code) {
-            case RGBEErrorCode.rgbe_read_error:
-                console.error("Read Error: " + (msg || ""));
-                break;
-            case RGBEErrorCode.rgbe_write_error:
-                console.error("Write Error: " + (msg || ""));
-                break;
-            case RGBEErrorCode.rgbe_format_error:
-                console.error("Bad File Format: " + (msg || ""));
-                break;
-            default:
-            case RGBEErrorCode.rgbe_memory_error:
-                console.error("Error: " + (msg || ""));
-        }
-        return RGBEErrorCode.RGBE_RETURN_FAILURE;
-    }
-    parserBlock(buffer, lineLimit, consume) {
-        const chunkSize = 128;
-        lineLimit = !lineLimit ? 1024 : lineLimit;
-        let p = buffer["pos"], i = -1, len = 0, s = "", chunk = String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
-        const next = "\n";
-        while (0 > (i = chunk.indexOf(next)) &&
-            len < lineLimit &&
-            p < buffer.byteLength) {
-            s += chunk;
-            len += chunk.length;
-            p += chunkSize;
-            chunk += String.fromCharCode.apply(null, new Uint16Array(buffer.subarray(p, p + chunkSize)));
-        }
-        if (-1 < i) {
-            if (false !== consume)
-                buffer["pos"] += len + i + 1;
-            return s + chunk.slice(0, i);
-        }
-        return false;
-    }
-    paserHeader(buffer) {
-        const magic_token_re = /^#\?(\S+)/, gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, format_re = /^\s*FORMAT=(\S+)\s*$/, dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, header = new RGBEHeader();
-        let line, match;
-        if (buffer["pos"] >= buffer.byteLength ||
-            !(line = this.parserBlock(buffer))) {
-            return this.parseError(RGBEErrorCode.rgbe_read_error, "no header found");
-        }
-        if (!(match = line.match(magic_token_re))) {
-            return this.parseError(RGBEErrorCode.rgbe_format_error, "bad initial token");
-        }
-        const RGBE_VALID_PROGRAMTYPE = 1;
-        const RGBE_VALID_FORMAT = 2;
-        const RGBE_VALID_DIMENSIONS = 4;
-        header.valid |= RGBE_VALID_PROGRAMTYPE;
-        header.programtype = match[1];
-        header.string += line + "\n";
-        while (true) {
-            line = this.parserBlock(buffer);
-            if (false === line)
-                break;
-            header.string += line + "\n";
-            if ("#" === line.charAt(0)) {
-                header.comments += line + "\n";
-                continue;
-            }
-            if ((match = line.match(gamma_re))) {
-                header.gamma = Math.floor(parseFloat(match[1]) * 10) / 10;
-            }
-            if ((match = line.match(exposure_re))) {
-                header.exposure = Math.floor(parseFloat(match[1]) * 10) / 10;
-            }
-            if ((match = line.match(format_re))) {
-                header.valid |= RGBE_VALID_FORMAT;
-                header.format = match[1];
-            }
-            if ((match = line.match(dimensions_re))) {
-                header.valid |= RGBE_VALID_DIMENSIONS;
-                header.height = parseInt(match[1], 10);
-                header.width = parseInt(match[2], 10);
-            }
-            if (header.valid & RGBE_VALID_FORMAT &&
-                header.valid & RGBE_VALID_DIMENSIONS)
-                break;
-        }
-        if (!(header.valid & RGBE_VALID_FORMAT)) {
-            this.parseError(RGBEErrorCode.rgbe_format_error, "missing format specifier");
-            return null;
-        }
-        if (!(header.valid & RGBE_VALID_DIMENSIONS)) {
-            this.parseError(RGBEErrorCode.rgbe_format_error, "missing image size specifier");
-            return null;
-        }
-        return header;
-    }
-    parserPixel(buffer, w, h) {
-        const scanline_width = w;
-        if (scanline_width < 8 ||
-            scanline_width > 0x7fff ||
-            2 !== buffer[0] ||
-            2 !== buffer[1] ||
-            buffer[2] & 0x80) {
-            return new Uint8Array(buffer);
-        }
-        if (scanline_width !== ((buffer[2] << 8) | buffer[3])) {
-            return this.parseError(RGBEErrorCode.rgbe_format_error, "wrong scanline width");
-        }
-        const data_rgba = new Uint8Array(4 * w * h);
-        if (!data_rgba.length) {
-            return this.parseError(RGBEErrorCode.rgbe_memory_error, "unable to allocate buffer space");
-        }
-        let offset = 0, pos = 0;
-        const ptr_end = 4 * scanline_width;
-        const rgbeStart = new Uint8Array(4);
-        const scanline_buffer = new Uint8Array(ptr_end);
-        let num_scanlines = h;
-        while (num_scanlines > 0 && pos < buffer.byteLength) {
-            if (pos + 4 > buffer.byteLength) {
-                return this.parseError(RGBEErrorCode.rgbe_read_error, "");
-            }
-            rgbeStart[0] = buffer[pos++];
-            rgbeStart[1] = buffer[pos++];
-            rgbeStart[2] = buffer[pos++];
-            rgbeStart[3] = buffer[pos++];
-            if (2 != rgbeStart[0] ||
-                2 != rgbeStart[1] ||
-                ((rgbeStart[2] << 8) | rgbeStart[3]) != scanline_width) {
-                return this.parseError(RGBEErrorCode.rgbe_format_error, "bad rgbe scanline format");
-            }
-            let ptr = 0, count;
-            while (ptr < ptr_end && pos < buffer.byteLength) {
-                count = buffer[pos++];
-                const isEncodedRun = count > 128;
-                if (isEncodedRun)
-                    count -= 128;
-                if (0 === count || ptr + count > ptr_end) {
-                    return this.parseError(RGBEErrorCode.rgbe_format_error, "bad scanline data");
-                }
-                if (isEncodedRun) {
-                    const byteValue = buffer[pos++];
-                    for (let i = 0; i < count; i++) {
-                        scanline_buffer[ptr++] = byteValue;
-                    }
-                }
-                else {
-                    scanline_buffer.set(buffer.subarray(pos, pos + count), ptr);
-                    ptr += count;
-                    pos += count;
-                }
-            }
-            const l = scanline_width;
-            for (let i = 0; i < l; i++) {
-                let off = 0;
-                data_rgba[offset] = scanline_buffer[i + off];
-                off += scanline_width;
-                data_rgba[offset + 1] = scanline_buffer[i + off];
-                off += scanline_width;
-                data_rgba[offset + 2] = scanline_buffer[i + off];
-                off += scanline_width;
-                data_rgba[offset + 3] = scanline_buffer[i + off];
-                offset += 4;
-            }
-            num_scanlines--;
-        }
-        return data_rgba;
-    }
-    rbgeToFloat(sourceArray, sourceOffset, destArray, destOffset) {
-        const e = sourceArray[sourceOffset + 3];
-        const scale = Math.pow(2.0, e - 128.0) / 255.0;
-        destArray[destOffset + 0] = sourceArray[sourceOffset + 0] * scale;
-        destArray[destOffset + 1] = sourceArray[sourceOffset + 1] * scale;
-        destArray[destOffset + 2] = sourceArray[sourceOffset + 2] * scale;
-        destArray[destOffset + 3] = 1.0;
-    }
-    rbgeToHalfFloat(sourceArray, sourceOffset, destArray, destOffset) {
-        const e = sourceArray[sourceOffset + 3];
-        const scale = Math.pow(2.0, e - 128.0) / 255.0;
-        destArray[destOffset + 0] = toHalfFloat(sourceArray[sourceOffset + 0] * scale);
-        destArray[destOffset + 1] = toHalfFloat(sourceArray[sourceOffset + 1] * scale);
-        destArray[destOffset + 2] = toHalfFloat(sourceArray[sourceOffset + 2] * scale);
-        destArray[destOffset + 3] = toHalfFloat(1.0);
-    }
-}

package/dist/src/loader/parser/b3dm/B3DMLoader.d.ts

@@ -1,10 +0,0 @@
-import { B3DMLoaderBase } from "./B3DMLoaderBase";
-import { Matrix4 } from "../../../math/Matrix4";
-export declare class B3DMLoader extends B3DMLoaderBase {
-    adjustmentTransform: Matrix4;
-    private gltfBuffer;
-    private static tempMatrix;
-    constructor();
-    parse(buffer: ArrayBuffer): Promise<any>;
-    static decodeText(array: any): string;
-}

package/dist/src/loader/parser/b3dm/B3DMLoader.js

@@ -1,56 +0,0 @@
-import { B3DMLoaderBase } from "./B3DMLoaderBase";
-import { B3DMParseUtil } from "../B3DMParser";
-import { Transform } from "../../../components/Transform";
-import { Matrix4 } from "../../../math/Matrix4";
-import { Orientation3D } from "../../../math/Orientation3D";
-export class B3DMLoader extends B3DMLoaderBase {
-    constructor() {
-        super();
-        this.adjustmentTransform = new Matrix4().identity();
-        B3DMLoader.tempMatrix ||= new Matrix4().identity();
-    }
-    async parse(buffer) {
-        const b3dm = await super.parse(buffer);
-        this.gltfBuffer = b3dm.glbBytes.slice().buffer;
-        let glbLoader = new B3DMParseUtil();
-        let model = await glbLoader.parseBinary(this.gltfBuffer);
-        let { batchTable, featureTable } = b3dm;
-        const rtcCenter = featureTable.getData("RTC_CENTER");
-        if (rtcCenter) {
-            model.x += rtcCenter[0];
-            model.y += rtcCenter[1];
-            model.z += rtcCenter[2];
-        }
-        let transform = model.getComponent(Transform);
-        transform.updateWorldMatrix();
-        let tempMatrix = B3DMLoader.tempMatrix;
-        tempMatrix.compose(transform.localPosition, transform.localRotQuat, transform.localScale);
-        tempMatrix.multiply(this.adjustmentTransform);
-        let prs = tempMatrix.decompose(Orientation3D.QUATERNION);
-        transform.localRotQuat.copyFrom(prs[1]);
-        transform.localRotQuat = transform.localRotQuat;
-        transform.localPosition.copyFrom(prs[0]);
-        transform.localPosition = transform.localPosition;
-        transform.localScale.copyFrom(prs[2]);
-        transform.localScale = transform.localScale;
-        transform.updateWorldMatrix();
-        model["batchTable"] = batchTable;
-        model["featureTable"] = featureTable;
-        return model;
-    }
-    static decodeText(array) {
-        if (typeof TextDecoder !== "undefined") {
-            return new TextDecoder().decode(array);
-        }
-        let s = "";
-        for (let i = 0, il = array.length; i < il; i++) {
-            s += String.fromCharCode(array[i]);
-        }
-        try {
-            return decodeURIComponent(escape(s));
-        }
-        catch (e) {
-            return s;
-        }
-    }
-}

package/dist/src/loader/parser/b3dm/B3DMLoaderBase.d.ts

@@ -1,9 +0,0 @@
-import { FeatureTable, BatchTable } from "./FeatureTable";
-export declare class B3DMLoaderBase {
-    parse(buffer: ArrayBuffer): Promise<{
-        version: number;
-        featureTable: FeatureTable;
-        batchTable: BatchTable;
-        glbBytes: Uint8Array<ArrayBuffer>;
-    }>;
-}

package/dist/src/loader/parser/b3dm/B3DMLoaderBase.js

@@ -1,31 +0,0 @@
-import { FeatureTable, BatchTable } from "./FeatureTable";
-import { readMagicBytes } from "./readMagicBytes";
-export class B3DMLoaderBase {
-    async parse(buffer) {
-        const dataView = new DataView(buffer);
-        const magic = readMagicBytes(dataView);
-        console.assert(magic === "b3dm");
-        const version = dataView.getUint32(4, true);
-        console.assert(version === 1);
-        const byteLength = dataView.getUint32(8, true);
-        console.assert(byteLength === buffer.byteLength);
-        const featureTableJSONByteLength = dataView.getUint32(12, true);
-        const featureTableBinaryByteLength = dataView.getUint32(16, true);
-        const batchTableJSONByteLength = dataView.getUint32(20, true);
-        const batchTableBinaryByteLength = dataView.getUint32(24, true);
-        const featureTableStart = 28;
-        const featureTable = new FeatureTable(buffer, featureTableStart, featureTableJSONByteLength, featureTableBinaryByteLength);
-        const batchTableStart = featureTableStart +
-            featureTableJSONByteLength +
-            featureTableBinaryByteLength;
-        const batchTable = new BatchTable(buffer, featureTable.getData("BATCH_LENGTH"), batchTableStart, batchTableJSONByteLength, batchTableBinaryByteLength);
-        const glbStart = batchTableStart + batchTableJSONByteLength + batchTableBinaryByteLength;
-        const glbBytes = new Uint8Array(buffer, glbStart, byteLength - glbStart);
-        return {
-            version,
-            featureTable,
-            batchTable,
-            glbBytes,
-        };
-    }
-}

package/dist/src/loader/parser/b3dm/FeatureTable.d.ts

@@ -1,14 +0,0 @@
-export declare class FeatureTable {
-    private buffer;
-    private binOffset;
-    private binLength;
-    private header;
-    constructor(buffer: any, start: any, headerLength: any, binLength: any);
-    getKeys(): string[];
-    getData(key: any, count?: any, defaultComponentType?: any, defaultType?: any): any;
-}
-export declare class BatchTable extends FeatureTable {
-    private batchSize;
-    constructor(buffer: any, batchSize: any, start: any, headerLength: any, binLength: any);
-    getData(key: any, componentType?: any, type?: any): any;
-}

package/dist/src/loader/parser/b3dm/FeatureTable.js

@@ -1,104 +0,0 @@
-import { arrayToString } from "./arrayToString";
-export class FeatureTable {
-    constructor(buffer, start, headerLength, binLength) {
-        this.buffer = buffer;
-        this.binOffset = start + headerLength;
-        this.binLength = binLength;
-        let header = null;
-        if (headerLength !== 0) {
-            const headerData = new Uint8Array(buffer, start, headerLength);
-            header = JSON.parse(arrayToString(headerData));
-        }
-        else {
-            header = {};
-        }
-        this.header = header;
-    }
-    getKeys() {
-        return Object.keys(this.header);
-    }
-    getData(key, count, defaultComponentType = null, defaultType = null) {
-        const header = this.header;
-        if (!(key in header)) {
-            return null;
-        }
-        const feature = header[key];
-        if (!(feature instanceof Object)) {
-            return feature;
-        }
-        else if (Array.isArray(feature)) {
-            return feature;
-        }
-        else {
-            const { buffer, binOffset, binLength } = this;
-            const byteOffset = feature.byteOffset || 0;
-            const featureType = feature.type || defaultType;
-            const featureComponentType = feature.componentType || defaultComponentType;
-            if ("type" in feature && defaultType && feature.type !== defaultType) {
-                throw new Error("FeatureTable: Specified type does not match expected type.");
-            }
-            let stride;
-            switch (featureType) {
-                case "SCALAR":
-                    stride = 1;
-                    break;
-                case "VEC2":
-                    stride = 2;
-                    break;
-                case "VEC3":
-                    stride = 3;
-                    break;
-                case "VEC4":
-                    stride = 4;
-                    break;
-                default:
-                    throw new Error(`FeatureTable : Feature type not provided for "${key}".`);
-            }
-            let data;
-            const arrayStart = binOffset + byteOffset;
-            const arrayLength = count * stride;
-            switch (featureComponentType) {
-                case "BYTE":
-                    data = new Int8Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "UNSIGNED_BYTE":
-                    data = new Uint8Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "SHORT":
-                    data = new Int16Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "UNSIGNED_SHORT":
-                    data = new Uint16Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "INT":
-                    data = new Int32Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "UNSIGNED_INT":
-                    data = new Uint32Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "FLOAT":
-                    data = new Float32Array(buffer, arrayStart, arrayLength);
-                    break;
-                case "DOUBLE":
-                    data = new Float64Array(buffer, arrayStart, arrayLength);
-                    break;
-                default:
-                    throw new Error(`FeatureTable : Feature component type not provided for "${key}".`);
-            }
-            const dataEnd = arrayStart + arrayLength * data.BYTES_PER_ELEMENT;
-            if (dataEnd > binOffset + binLength) {
-                throw new Error("FeatureTable: Feature data read outside binary body length.");
-            }
-            return data;
-        }
-    }
-}
-export class BatchTable extends FeatureTable {
-    constructor(buffer, batchSize, start, headerLength, binLength) {
-        super(buffer, start, headerLength, binLength);
-        this.batchSize = batchSize;
-    }
-    getData(key, componentType = null, type = null) {
-        return super.getData(key, this.batchSize, componentType, type);
-    }
-}

package/dist/src/loader/parser/b3dm/arrayToString.d.ts

@@ -1 +0,0 @@
-export declare function arrayToString(array: any): string;

package/dist/src/loader/parser/b3dm/arrayToString.js

@@ -1,4 +0,0 @@
-export function arrayToString(array) {
-    const utf8decoder = new TextDecoder();
-    return utf8decoder.decode(array);
-}

package/dist/src/loader/parser/b3dm/readMagicBytes.d.ts

@@ -1 +0,0 @@
-export declare function readMagicBytes(bufferOrDataView: any): string;

package/dist/src/loader/parser/b3dm/readMagicBytes.js

@@ -1,17 +0,0 @@
-export function readMagicBytes(bufferOrDataView) {
-    let view;
-    if (bufferOrDataView instanceof DataView) {
-        view = bufferOrDataView;
-    }
-    else {
-        view = new DataView(bufferOrDataView);
-    }
-    if (String.fromCharCode(view.getUint8(0)) === "{") {
-        return null;
-    }
-    let magicBytes = "";
-    for (let i = 0; i < 4; i++) {
-        magicBytes += String.fromCharCode(view.getUint8(i));
-    }
-    return magicBytes;
-}

package/dist/src/loader/parser/gis/GeoJsonParser.d.ts

@@ -1,29 +0,0 @@
-import { ParserBase } from "../ParserBase";
-import { ParserFormat } from "../ParserFormat";
-export declare enum GeoType {
-    Point = "Point",
-    LineString = "LineString",
-    MultiPolygon = "MultiPolygon"
-}
-export interface GeoJsonGeometryStruct {
-    type: GeoType;
-    coordinates: any;
-}
-export interface GeoJsonPropertiesStruct {
-    prop0: string;
-    prop1: any;
-}
-export interface GeoJsonNodeStruct {
-    type: string;
-    geometry: GeoJsonGeometryStruct;
-    properties: GeoJsonPropertiesStruct;
-}
-export interface GeoJsonStruct {
-    type: string;
-    features: GeoJsonNodeStruct[];
-}
-export declare class GeoJsonParser extends ParserBase {
-    static format: ParserFormat;
-    json: string;
-    parseString(data: any): Promise<void>;
-}

package/dist/src/loader/parser/gis/GeoJsonParser.js

@@ -1,15 +0,0 @@
-import { ParserBase } from "../ParserBase";
-import { ParserFormat } from "../ParserFormat";
-export var GeoType;
-(function (GeoType) {
-    GeoType["Point"] = "Point";
-    GeoType["LineString"] = "LineString";
-    GeoType["MultiPolygon"] = "MultiPolygon";
-})(GeoType || (GeoType = {}));
-export class GeoJsonParser extends ParserBase {
-    static { this.format = ParserFormat.JSON; }
-    async parseString(data) {
-        this.json = data;
-        this.data = JSON.parse(data);
-    }
-}

package/dist/src/loader/parser/gis/GeoJsonUtil.d.ts

@@ -1,5 +0,0 @@
-import { Vector3 } from "../../..";
-import { GeoJsonStruct } from "./GeoJsonParser";
-export declare class GeoJsonUtil {
-    static getPath(data: GeoJsonStruct): Vector3[][];
-}

package/dist/src/loader/parser/gis/GeoJsonUtil.js

@@ -1,30 +0,0 @@
-import { Vector3 } from "../../..";
-import { GeoType } from "./GeoJsonParser";
-export class GeoJsonUtil {
-    static getPath(data) {
-        let lineArray = [];
-        for (let i = 0; i < data.features.length; i++) {
-            const element = data.features[i];
-            switch (element.geometry.type) {
-                case GeoType.LineString:
-                    break;
-                case GeoType.MultiPolygon:
-                    let point3s = [];
-                    for (let i = 0; i < element.geometry.coordinates.length; i++) {
-                        const pointArray = element.geometry.coordinates[i];
-                        for (const list of pointArray) {
-                            for (const iterator of list) {
-                                let point3 = new Vector3(iterator[0], 0, iterator[1]);
-                                point3s.push(point3);
-                            }
-                        }
-                    }
-                    lineArray.push(point3s);
-                    break;
-                default:
-                    break;
-            }
-        }
-        return lineArray;
-    }
-}

package/dist/src/loader/parser/gltf/GLBParser.d.ts

@@ -1,21 +0,0 @@
-import { ParserBase } from "../ParserBase";
-import { ParserFormat } from "../ParserFormat";
-export declare class GLBHeader {
-    magic: number;
-    version: number;
-    length: number;
-}
-export declare class GLBChunk {
-    chunkLength: number;
-    chunkType: number;
-    chunkData: Uint8Array;
-}
-export declare class GLBParser extends ParserBase {
-    static format: ParserFormat;
-    private _gltf;
-    parseBuffer(buffer: ArrayBuffer): Promise<false | import("../../..").Object3D>;
-    parseJsonAndBuffer(obj: object, bin: ArrayBuffer): Promise<import("../../..").Object3D>;
-    verification(): boolean;
-    private parseHeader;
-    private parseChunk;
-}