@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,248 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,104 @@
+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

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,15 @@
+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

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

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,21 @@
+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;
+}