@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/loader/parser/gltf/GLBParser.js

@@ -0,0 +1,133 @@
+import { BitmapTexture2D } from "../../../textures/BitmapTexture2D";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export class GLBHeader {
+}
+export class GLBChunk {
+}
+export class GLBParser extends ParserBase {
+    static { this.format = ParserFormat.BIN; }
+    async parseBuffer(buffer) {
+        let byteArray = new Uint8Array(buffer);
+        byteArray["pos"] = 0;
+        const fileHeader = this.parseHeader(byteArray);
+        if (fileHeader.magic != 0x46546c67) {
+            console.error(`invalid GLB file`);
+            return false;
+        }
+        if (fileHeader.version !== 2.0) {
+            console.error(`GLBParser only support glTF 2.0 for now! Received glTF version: ${fileHeader.version}`);
+            return false;
+        }
+        let chunks = [];
+        while (byteArray["pos"] < byteArray.length) {
+            let chunk = this.parseChunk(byteArray);
+            chunks.push(chunk);
+        }
+        if (chunks[0].chunkType != 0x4e4f534a) {
+            console.error(`invalid GLBChunk`);
+            return false;
+        }
+        let gltfJSON = "";
+        let maxCount = 65535;
+        let chunkJSONData = chunks[0].chunkData;
+        for (let i = 0; i < chunkJSONData.length; i += maxCount) {
+            let count = chunkJSONData.length - i;
+            count = Math.min(count, maxCount);
+            let newUint = chunkJSONData.subarray(i, i + count);
+            gltfJSON += String.fromCharCode(...newUint);
+        }
+        let obj = JSON.parse(gltfJSON);
+        this._gltf = new GLTF_Info();
+        this._gltf = { ...this._gltf, ...obj };
+        this._gltf.resources = {};
+        for (let i = 0; i < this._gltf.buffers.length; i++) {
+            let buffer = this._gltf.buffers[i];
+            buffer.isParsed = true;
+            buffer.dbuffer = chunks[i + 1].chunkData.buffer;
+        }
+        if (this._gltf.images) {
+            for (let i = 0; i < this._gltf.images.length; i++) {
+                let image = this._gltf.images[i];
+                image.name = image.name || "bufferView_" + image.bufferView.toString();
+                const bufferView = this._gltf.bufferViews[image.bufferView];
+                const buffer = this._gltf.buffers[bufferView.buffer];
+                let dataBuffer = new Uint8Array(buffer.dbuffer, bufferView.byteOffset, bufferView.byteLength);
+                let imgData = new Blob([dataBuffer], { type: image.mimeType });
+                let dtexture = new BitmapTexture2D();
+                await dtexture.loadFromBlob(imgData);
+                dtexture.name = image.name;
+                this._gltf.resources[image.name] = dtexture;
+            }
+        }
+        let subParser = new GLTFSubParser();
+        let nodes = await subParser.parse(this.initUrl, this._gltf, this._gltf.scene);
+        if (nodes) {
+            this.data = nodes.rootNode;
+            return nodes.rootNode;
+        }
+        return null;
+    }
+    async parseJsonAndBuffer(obj, bin) {
+        this._gltf = new GLTF_Info();
+        this._gltf = { ...this._gltf, ...obj };
+        this._gltf.resources = {};
+        let dbuffer = this._gltf.buffers[0];
+        dbuffer.isParsed = true;
+        dbuffer.dbuffer = bin;
+        if (this._gltf.images) {
+            for (let i = 0; i < this._gltf.images.length; i++) {
+                let image = this._gltf.images[i];
+                image.name = image.name || "bufferView_" + image.bufferView.toString();
+                const bufferView = this._gltf.bufferViews[image.bufferView];
+                const buffer = this._gltf.buffers[bufferView.buffer];
+                let dataBuffer = new Uint8Array(buffer.dbuffer, bufferView.byteOffset, bufferView.byteLength);
+                let imgData = new Blob([dataBuffer], { type: image.mimeType });
+                let dtexture = new BitmapTexture2D();
+                await dtexture.loadFromBlob(imgData);
+                dtexture.name = image.name;
+                this._gltf.resources[image.name] = dtexture;
+            }
+        }
+        let subParser = new GLTFSubParser();
+        let nodes = await subParser.parse(this.initUrl, this._gltf, this._gltf.scene);
+        if (nodes) {
+            this.data = nodes.rootNode;
+            return nodes.rootNode;
+        }
+        return null;
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("Method not implemented.");
+    }
+    parseHeader(buffer) {
+        let pos = buffer["pos"];
+        let result = new GLBHeader();
+        let data = new Uint32Array(buffer.buffer, pos, 3);
+        buffer["pos"] += data.byteLength;
+        result.magic = data[0];
+        result.version = data[1];
+        result.length = data[2];
+        return result;
+    }
+    parseChunk(buffer) {
+        let pos = buffer["pos"];
+        let result = new GLBChunk();
+        let data = new Uint32Array(buffer.buffer, pos, 2);
+        pos = buffer["pos"] += data.byteLength;
+        result.chunkLength = data[0];
+        result.chunkType = data[1];
+        result.chunkData = new Uint8Array(buffer.buffer, pos, result.chunkLength);
+        const bytes = new Uint8Array(result.chunkLength);
+        for (let i = 0; i < result.chunkLength; i++)
+            bytes[i] = result.chunkData[i];
+        result.chunkData = bytes;
+        buffer["pos"] += result.chunkLength;
+        return result;
+    }
+}

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

@@ -0,0 +1,137 @@
+export declare class GLTF_Info {
+    asset: {
+        generator: string;
+        version: string;
+        minVersion: string;
+    };
+    accessors: GLTF_Accessors[];
+    buffers: {
+        isParsed: boolean;
+        dbuffer: any;
+        byteLength: number;
+        uri: string;
+    }[];
+    bufferViews: {
+        isParsed: boolean;
+        buffer: number;
+        byteOffset: number;
+        dbufferView: any;
+        byteStride: number;
+        byteLength: number;
+    }[];
+    materials: {
+        name: string;
+        alphaModel: string;
+        alphaCutoff: number;
+    }[];
+    meshes: GLTF_Mesh[];
+    nodes: GLTF_Node[];
+    scene: number;
+    scenes: GLTF_Scene;
+    textures: {
+        isParsed: boolean;
+        sampler: number;
+        source: number;
+        name: string;
+        dtexture: any;
+    }[];
+    cameras: any;
+    skins: any;
+    resources: {
+        [uri: string]: any;
+    };
+    images: {
+        uri: string;
+        name: string;
+        isParsed: any;
+        dsampler: any;
+        dimage: any;
+        mimeType: string;
+        bufferView: number;
+    }[];
+    samplers: {
+        minFilter: number;
+        magFilter: number;
+        wrapS: number;
+        wrapT: number;
+    }[];
+    animations: any;
+    extensions: {
+        KHR_lights_punctual: {
+            lights: GLTF_Light[];
+        };
+    };
+}
+export declare class GLTF_Scene {
+    nodes: number[];
+}
+export declare class GLTF_Light {
+    name: string;
+    type: string;
+    color: number[];
+    intensity: number;
+    range: number;
+    spot: {
+        outerConeAngle: number;
+    };
+    isParsed: boolean;
+}
+export declare class GLTF_Node {
+    name: string;
+    rotation: number[];
+    scale: number[];
+    translation: number[];
+    children: number[];
+    matrix: number[];
+    mesh: number;
+    isParsed: any;
+    dnode: any;
+    camera: any;
+    skin: any;
+    nodeId: any;
+    primitives: any;
+    extensions: any;
+    light: GLTF_Light;
+}
+export declare class GLTF_Primitives {
+    attributes: {
+        POSITION: number;
+        NORMAL: number;
+        TANGENT: number;
+        TEXCOORD_0: number;
+        TEXCOORD_1: number;
+    };
+    indices: number;
+    material: number;
+    mode: any;
+    name: any;
+    targets: any;
+    extensions: any;
+    morphTargetsRelative: boolean;
+}
+export declare class GLTF_Mesh {
+    name: string;
+    primitives: GLTF_Primitives[];
+    isParsed: any;
+    dprimitives: any;
+    weights: any;
+    extras: any;
+}
+export declare class GLTF_Accessors {
+    bufferView: number;
+    componentType: number;
+    count: number;
+    type: string;
+    max: number[];
+    min: number[];
+    isParsed: any;
+    daccessor: any;
+    normalized: any;
+    sparse: any;
+    byteOffset: number;
+    computeResult: {
+        typedArray: any;
+        arrayType: any;
+        numComponents: number;
+    };
+}

package/dist/src/loader/parser/gltf/GLTFInfo.js

@@ -0,0 +1,20 @@
+export class GLTF_Info {
+    constructor() {
+        this.scene = 0;
+    }
+}
+export class GLTF_Scene {
+}
+export class GLTF_Light {
+}
+export class GLTF_Node {
+    constructor() {
+        this.mesh = -1;
+    }
+}
+export class GLTF_Primitives {
+}
+export class GLTF_Mesh {
+}
+export class GLTF_Accessors {
+}

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

@@ -0,0 +1,24 @@
+import { Texture, Vector4 } from "../../..";
+export declare class GLTFMaterial {
+    name: string;
+    defines: string[];
+    doubleSided: boolean;
+    baseColorFactor: [1, 1, 1, 1];
+    emissiveFactor: number;
+    metallicFactor: number;
+    roughnessFactor: number;
+    alphaCutoff: number;
+    enableBlend: boolean;
+    baseColorTexture: Texture;
+    metallicRoughnessTexture: Texture;
+    normalTexture: Texture;
+    occlusionTexture: Texture;
+    emissiveTexture: Texture;
+    extensions: any;
+    baseMapOffsetSize: Vector4;
+    normalMapOffsetSize: Vector4;
+    emissiveMapOffsetSize: Vector4;
+    roughnessMapOffsetSize: Vector4;
+    metallicMapOffsetSize: Vector4;
+    aoMapOffsetSize: Vector4;
+}

package/dist/src/loader/parser/gltf/GLTFMaterial.js

@@ -0,0 +1,2 @@
+export class GLTFMaterial {
+}

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

@@ -0,0 +1,45 @@
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+export declare class GLTFParser extends ParserBase {
+    static format: ParserFormat;
+    private _gltf;
+    parseJson(obj: object): Promise<import("../../..").Object3D>;
+    verification(): boolean;
+    private static _counter;
+    static getMeshNameCounter(): () => string;
+    static getModelNameCounter(): () => string;
+    static getTexCoordDefine(texNum: any): string;
+    static getVertexColorDefine(num: any): string;
+    static getBaseColorTextureDefine(): string;
+    static getMetalRoughnessDefine(): string;
+    static getNormalMapDefine(): string;
+    static getEmissiveMapDefine(): string;
+    static getOcclusionMapDefine(): string;
+    static getMorphTargetsDefine(targetNum: any): string;
+    static getMorphtargetPositionDefine(): string;
+    static getMorphtargetNormalDefine(): string;
+    static getMorphtargetTangentDefine(): string;
+    static getJointsNumDefine(num: any): string;
+    static getJointVec8Define(): string;
+    static getHasNormalDefine(): string;
+    static getHasTangentDefine(): string;
+    static getHasNormalMapDefine(): string;
+    static getAlphaMaskDefine(): string;
+    static getAlphaBlendDefine(): string;
+    static readonly defaultMaterial: {
+        name: string;
+        alphaCutoff: number;
+        alphaMode: string;
+        pbrMetallicRoughness: {
+            name: string;
+            defines: any[];
+            doubleSided: boolean;
+            baseColorFactor: number[];
+            metallicFactor: number;
+            roughnessFactor: number;
+            emissiveFactor: number[];
+        };
+    };
+    private load_gltf_bin;
+    private load_gltf_textures;
+}

package/dist/src/loader/parser/gltf/GLTFParser.js

@@ -0,0 +1,153 @@
+import { StringUtil } from "../../../util/StringUtil";
+import { FileLoader } from "../../FileLoader";
+import { ParserBase } from "../ParserBase";
+import { ParserFormat } from "../ParserFormat";
+import { GLTF_Info } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export class GLTFParser extends ParserBase {
+    static { this.format = ParserFormat.JSON; }
+    async parseJson(obj) {
+        this._gltf = new GLTF_Info();
+        this._gltf = { ...this._gltf, ...obj };
+        this._gltf.resources = {};
+        await Promise.all([this.load_gltf_bin(), this.load_gltf_textures()]);
+        let subParser = new GLTFSubParser();
+        let nodes = await subParser.parse(this.initUrl, this._gltf, this._gltf.scene);
+        subParser.destroy();
+        subParser = null;
+        if (nodes) {
+            this.data = nodes.rootNode;
+            return nodes.rootNode;
+        }
+        this._gltf = null;
+        return null;
+    }
+    verification() {
+        if (this.data) {
+            return true;
+        }
+        throw new Error("Method not implemented.");
+    }
+    static { this._counter = 0; }
+    static getMeshNameCounter() {
+        return function getMeshNameCounter() {
+            return `GLTF_NO_NAME_PRIMITIVE_${GLTFParser._counter++}`;
+        };
+    }
+    static getModelNameCounter() {
+        let counter = 0;
+        return function getModelNameCounter() {
+            return `GLTF_NO_NAME_MESH_${counter++}`;
+        };
+    }
+    static getTexCoordDefine(texNum) {
+        return `UV_NUM ${texNum}`;
+    }
+    static getVertexColorDefine(num) {
+        return `HAS_VERTEXCOLOR ${num}`;
+    }
+    static getBaseColorTextureDefine() {
+        return "HAS_BASECOLORMAP";
+    }
+    static getMetalRoughnessDefine() {
+        return "HAS_METALROUGHNESSMAP";
+    }
+    static getNormalMapDefine() {
+        return "HAS_NORMALMAP";
+    }
+    static getEmissiveMapDefine() {
+        return "HAS_EMISSIVEMAP";
+    }
+    static getOcclusionMapDefine() {
+        return "HAS_OCCLUSIONMAP";
+    }
+    static getMorphTargetsDefine(targetNum) {
+        return `MORPH_TARGET_NUM ${targetNum}`;
+    }
+    static getMorphtargetPositionDefine() {
+        return "HAS_MORPH_POSITION";
+    }
+    static getMorphtargetNormalDefine() {
+        return "HAS_MORPH_NORMAL";
+    }
+    static getMorphtargetTangentDefine() {
+        return "HAS_MORPH_TANGENT";
+    }
+    static getJointsNumDefine(num) {
+        return `JOINTS_NUM ${num}`;
+    }
+    static getJointVec8Define() {
+        return "JOINT_VEC8";
+    }
+    static getHasNormalDefine() {
+        return "HAS_NORMAL";
+    }
+    static getHasTangentDefine() {
+        return "HAS_TANGENT";
+    }
+    static getHasNormalMapDefine() {
+        return "HAS_NORMAL_MAP";
+    }
+    static getAlphaMaskDefine() {
+        return "ALPHA_MASK";
+    }
+    static getAlphaBlendDefine() {
+        return "ALPHA_BLEND";
+    }
+    static { this.defaultMaterial = {
+        name: "GLTF_DEFAULT_MATERIAL",
+        alphaCutoff: 0.33,
+        alphaMode: "MASK",
+        pbrMetallicRoughness: {
+            name: "GLTF_DEFAULT_MATERIAL",
+            defines: [],
+            doubleSided: false,
+            baseColorFactor: [1, 1, 1, 1],
+            metallicFactor: 1,
+            roughnessFactor: 1,
+            emissiveFactor: [0, 0, 0],
+        },
+    }; }
+    async load_gltf_bin() {
+        if (this._gltf.buffers && this._gltf.buffers.length > 0) {
+            let binArray = [];
+            for (let i = 0; i < this._gltf.buffers.length; i++) {
+                const element = this._gltf.buffers[i];
+                if (element.uri.substring(0, 5) !== "data:") {
+                    let url = StringUtil.parseUrl(this.baseUrl, element.uri);
+                    if (this.loaderFunctions?.onUrl)
+                        url = await this.loaderFunctions.onUrl(url);
+                    let promise = new FileLoader()
+                        .loadBinData(url, this.loaderFunctions)
+                        .then((loader) => {
+                        this._gltf.resources[element.uri] = loader;
+                    });
+                    binArray.push(promise);
+                }
+            }
+            await Promise.all(binArray);
+        }
+    }
+    async load_gltf_textures() {
+        let gltf = this._gltf;
+        if (this._gltf.images) {
+            let textureArray = [];
+            for (let i = 0; i < this._gltf.images.length; i++) {
+                const element = this._gltf.images[i];
+                if (element.uri) {
+                    let url = StringUtil.parseUrl(this.baseUrl, element.uri);
+                    if (this.loaderFunctions?.onUrl)
+                        url = await this.loaderFunctions.onUrl(url);
+                    let promise = new FileLoader()
+                        .loadAsyncBitmapTexture(url, this.loaderFunctions)
+                        .then((texture) => {
+                        texture.name = StringUtil.getURLName(element.uri);
+                        this._gltf.resources[texture.name] = texture;
+                    });
+                    textureArray.push(promise);
+                }
+            }
+            await Promise.all(textureArray);
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { GLTF_Info } from "./GLTFInfo";
+import { PrefabAvatarData } from "../prefab/prefabData/PrefabAvatarData";
+import { PropertyAnimationClip } from "../../../math/AnimationCurveClip";
+export declare class GLTFSubParser {
+    currentSceneName: any;
+    gltf: GLTF_Info;
+    initUrl: string;
+    private _generator;
+    private _version;
+    private _BASE64_MARKER;
+    private _cameraParser;
+    private _meshParser;
+    private _materialParser;
+    private _skinParser;
+    private _skeletonParser;
+    private _converter;
+    constructor();
+    get version(): any;
+    parse(initUrl: string, gltf: any, sceneId: any): Promise<false | {
+        rootNode: Object3D;
+        textures: any[];
+        animations: any;
+        cameras: any[];
+    }>;
+    destroy(): void;
+    private parseScene;
+    private parseNode;
+    private errorMiss;
+    private parseCamera;
+    private parseMesh;
+    parseTexture(index: number): Promise<any>;
+    parseMaterial(materialId: any): Promise<any>;
+    private parseAnimations;
+    private parseObject3D;
+    parseSkeleton(skeletonID: number): PrefabAvatarData;
+    parseSkeletonAnimation(avatarData: PrefabAvatarData, animation: any): PropertyAnimationClip;
+    private traverse;
+    private convertToNode;
+    private parseSkin;
+    parseAccessor(accessorId: any): any;
+    private getTypedArrayFromArrayBuffer;
+    parseBufferView(bufferViewId: any): any;
+    private parseBuffer;
+    private getLight;
+    private applyNodeExtensions;
+}