@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,366 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { StringUtil } from "../../../util/StringUtil";
+import { getTypedArrayTypeFromGLType } from "./TypeArray";
+import { KHR_draco_mesh_compression } from "./extends/KHR_draco_mesh_compression";
+import { BitmapTexture2D } from "../../../textures/BitmapTexture2D";
+import { GLTFSubParserCamera } from "./GLTFSubParserCamera";
+import { GLTFSubParserMesh } from "./GLTFSubParserMesh";
+import { GLTFSubParserMaterial } from "./GLTFSubParserMaterial";
+import { GLTFSubParserSkin } from "./GLTFSubParserSkin";
+import { GLTFSubParserSkeleton } from "./GLTFSubParserSkeleton";
+import { GLTFSubParserConverter } from "./GLTFSubParserConverter";
+export class GLTFSubParser {
+    constructor() {
+        this._BASE64_MARKER = ";base64,";
+        this._cameraParser = null;
+        this._meshParser = null;
+        this._materialParser = null;
+        this._skinParser = null;
+        this._skeletonParser = null;
+        this._converter = null;
+    }
+    get version() {
+        if (this.version)
+            return this.version;
+        else if (this.gltf) {
+            if (!this.gltf.asset)
+                return this.errorMiss("asset");
+            this._version = this.gltf.asset.version;
+            if (this.gltf.asset.minVersion)
+                this._version += `\r minVersion${this.gltf.asset.minVersion}`;
+            return this.version;
+        }
+        console.warn("glTF not loaded.");
+        return null;
+    }
+    async parse(initUrl, gltf, sceneId) {
+        this.gltf = gltf;
+        this.initUrl = initUrl;
+        const { version, generator } = this.gltf.asset;
+        this._generator = generator;
+        if (version !== "2.0") {
+            console.error(`GLTFParser only support glTF 2.0 for now! Received glTF version: ${this.version}`);
+            return false;
+        }
+        const result = {
+            nodes: await this.parseScene(sceneId),
+            animations: this.parseAnimations(),
+            name: this.currentSceneName,
+        };
+        return await this.convertToNode(result);
+    }
+    destroy() {
+        KHR_draco_mesh_compression.unload(this.gltf);
+        this.gltf = null;
+    }
+    async parseScene(sceneId) {
+        const loadScene = sceneId || this.gltf.scene || 0;
+        const scene = this.gltf.scenes[loadScene];
+        if (typeof scene === "undefined")
+            return this.errorMiss("scene", loadScene);
+        this.currentSceneName = scene.name || "GLTF_NO_NAME_SCENE";
+        const result = [];
+        const nodes = scene.nodes;
+        for (let i = 0; i < nodes.length; i++) {
+            const node = await this.parseNode(nodes[i]);
+            if (node)
+                result.push(node);
+        }
+        return result;
+    }
+    async parseNode(nodeId) {
+        const node = this.gltf.nodes[nodeId];
+        if (!node)
+            return this.errorMiss("node", nodeId);
+        if (node.isParsed)
+            return node.dnode;
+        const { name, matrix, translation, rotation, scale } = node;
+        const dnode = {
+            name,
+            matrix,
+            translation,
+            rotation,
+            scale,
+            nodeId,
+            camera: null,
+            primitives: null,
+            skin: null,
+            children: null,
+            light: null,
+        };
+        if (node.camera !== undefined)
+            dnode.camera = this.parseCamera(node.camera);
+        if (node.mesh !== undefined)
+            dnode.primitives = await this.parseMesh(node.mesh);
+        if (node.extensions !== undefined)
+            this.applyNodeExtensions(node, dnode);
+        if (node.skin !== undefined) {
+            const skin = this.parseSkin(node.skin);
+            if (skin)
+                dnode.skin = skin;
+        }
+        dnode.children = [];
+        if (node.children)
+            for (let i = 0; i < node.children.length; i++) {
+                dnode.children.push(await this.parseNode(node.children[i]));
+            }
+        node.dnode = dnode;
+        node.isParsed = true;
+        return node.dnode;
+    }
+    errorMiss(e, info) {
+        throw new Error(e + info);
+    }
+    parseCamera(cameraId) {
+        if (!this._cameraParser) {
+            this._cameraParser = new GLTFSubParserCamera(this.gltf);
+        }
+        return this._cameraParser.parse(cameraId);
+    }
+    async parseMesh(meshId) {
+        if (!this._meshParser) {
+            this._meshParser = new GLTFSubParserMesh(this);
+        }
+        return this._meshParser.parse(meshId);
+    }
+    async parseTexture(index) {
+        let textureInfo = this.gltf.textures[index];
+        if (textureInfo && !textureInfo.dtexture) {
+            if (textureInfo && textureInfo.source != null) {
+                let image = this.gltf.images[textureInfo.source];
+                if (image.uri) {
+                    let name = image.uri;
+                    name = StringUtil.getURLName(name);
+                    textureInfo.dtexture = this.gltf.resources[name];
+                }
+                else if (image.bufferView) {
+                    let buffer = this.parseBufferView(image.bufferView);
+                    let bitmapTexture = new BitmapTexture2D();
+                    let img = new Blob([buffer], { type: image.mimeType });
+                    await bitmapTexture.loadFromBlob(img);
+                    textureInfo.dtexture = bitmapTexture;
+                }
+                else {
+                    textureInfo.dtexture = this.gltf.resources[image.name];
+                }
+            }
+            else if (textureInfo.name) {
+                let name = StringUtil.getURLName(textureInfo.name);
+                textureInfo.dtexture = this.gltf.resources[name];
+            }
+        }
+        if (!textureInfo.dtexture) {
+            console.log("miss texture , please check texture!", index, textureInfo);
+        }
+        return textureInfo.dtexture;
+    }
+    async parseMaterial(materialId) {
+        if (!this._materialParser) {
+            this._materialParser = new GLTFSubParserMaterial(this);
+        }
+        return this._materialParser.parse(materialId);
+    }
+    parseAnimations() {
+        const result = [];
+        return result;
+    }
+    async parseObject3D(nodeInfo, parentNode) {
+        if (!this._converter) {
+            this._converter = new GLTFSubParserConverter(this);
+        }
+        return this._converter.convertNodeToObject3D(nodeInfo, parentNode);
+    }
+    parseSkeleton(skeletonID) {
+        if (!this._skeletonParser) {
+            this._skeletonParser = new GLTFSubParserSkeleton(this);
+        }
+        return this._skeletonParser.parse(skeletonID);
+    }
+    parseSkeletonAnimation(avatarData, animation) {
+        if (!this._skeletonParser) {
+            this._skeletonParser = new GLTFSubParserSkeleton(this);
+        }
+        return this._skeletonParser.parseSkeletonAnimation(avatarData, animation);
+    }
+    async traverse(parentNode, nodeInfos) {
+        for (let i = 0; i < nodeInfos.length; i++) {
+            const node = await this.parseObject3D(nodeInfos[i], parentNode);
+            await this.traverse(node, nodeInfos[i].children);
+        }
+    }
+    async convertToNode(infos) {
+        const rootNode = new Object3D();
+        rootNode.name = infos.name;
+        const nodes = infos.nodes;
+        const animations = infos.animations;
+        const textures = [];
+        const skins = [];
+        const cameras = [];
+        await this.traverse(rootNode, nodes);
+        let animas;
+        return {
+            rootNode,
+            textures,
+            animations: animas,
+            cameras,
+        };
+    }
+    parseSkin(skinId) {
+        if (!this._skinParser) {
+            this._skinParser = new GLTFSubParserSkin(this);
+        }
+        return this._skinParser.parse(skinId);
+    }
+    parseAccessor(accessorId) {
+        const accessor = this.gltf.accessors[accessorId];
+        if (!accessor)
+            return this.errorMiss("accessor", accessorId);
+        if (accessor.isParsed)
+            return accessor.daccessor;
+        accessor.isParsed = true;
+        accessor.daccessor = false;
+        const normalize = !!accessor.normalized;
+        // accessor.bufferView = accessor.bufferView ? accessor.bufferView : accessorId;
+        const bufferView = this.gltf.bufferViews[accessor.bufferView];
+        const byteStride = bufferView && bufferView.byteStride;
+        const arrayType = getTypedArrayTypeFromGLType(accessor.componentType);
+        let numComponents = 1;
+        switch (accessor.type) {
+            case "SCALAR":
+                numComponents = 1;
+                break;
+            case "VEC2":
+                numComponents = 2;
+                break;
+            case "VEC3":
+                numComponents = 3;
+                break;
+            case "VEC4":
+            case "MAT2":
+                numComponents = 4;
+                break;
+            case "MAT3":
+                numComponents = 9;
+                break;
+            case "MAT4":
+                numComponents = 16;
+                break;
+            default:
+                numComponents = 0;
+                break;
+        }
+        if (numComponents === 0) {
+            console.error(`glTF has unknown data type in accessor: ${accessor.type}`);
+            return false;
+        }
+        const componentsBytes = numComponents * arrayType.BYTES_PER_ELEMENT;
+        let buffer;
+        if (bufferView !== undefined) {
+            buffer = this.parseBufferView(accessor.bufferView);
+            if (!buffer)
+                return accessor.daccessor;
+        }
+        else
+            buffer = new Uint8Array(componentsBytes * accessor.count).buffer;
+        let typedArray = this.getTypedArrayFromArrayBuffer(buffer, byteStride, accessor.byteOffset || 0, arrayType, numComponents, accessor.count);
+        if (accessor.sparse) {
+            const { count, indices, values } = accessor.sparse;
+            typedArray = new arrayType(typedArray); // eslint-disable-line
+            const indicesByteOffset = indices.byteOffset || 0;
+            const indicesBufferView = this.gltf.bufferViews[indices.bufferView];
+            const indicesArrayType = getTypedArrayTypeFromGLType(indices.componentType);
+            const indicesBuffer = this.parseBufferView(indices.bufferView);
+            const indicesArray = this.getTypedArrayFromArrayBuffer(indicesBuffer, indicesBufferView.byteStride, indicesByteOffset, indicesArrayType, 1, count);
+            const valuesByteOffset = values.byteOffset || 0;
+            const valuesBufferView = this.gltf.bufferViews[values.bufferView];
+            const valuesBuffer = this.parseBufferView(values.bufferView);
+            const valuesArray = this.getTypedArrayFromArrayBuffer(valuesBuffer, valuesBufferView.byteStride, valuesByteOffset, arrayType, numComponents, count);
+            for (let i = 0; i < indicesArray.length; i++)
+                typedArray.set(valuesArray.slice(i * numComponents, i * numComponents + numComponents), indicesArray[i] * numComponents);
+        }
+        accessor.computeResult = {
+            typedArray,
+            arrayType,
+            numComponents,
+        };
+        accessor.daccessor = {
+            data: typedArray,
+            numComponents,
+            normalize,
+        };
+        return accessor.daccessor;
+    }
+    getTypedArrayFromArrayBuffer(buffer, byteStride, byteOffset, arrayType, numComponents, count) {
+        let typedArray;
+        const componentsBytes = numComponents * arrayType.BYTES_PER_ELEMENT;
+        if (byteStride && componentsBytes !== byteStride) {
+            const arrayLength = numComponents * count;
+            typedArray = new arrayType(arrayLength); // eslint-disable-line
+            for (let i = 0; i < count; i++) {
+                const componentVals = new arrayType(buffer, byteOffset + i * byteStride, numComponents); // eslint-disable-line
+                for (let j = 0; j < numComponents; j++)
+                    typedArray[i * numComponents + j] = componentVals[j];
+            }
+        }
+        else
+            typedArray = new arrayType(buffer, byteOffset, count * numComponents); // eslint-disable-line
+        return typedArray;
+    }
+    parseBufferView(bufferViewId) {
+        const bufferView = this.gltf.bufferViews[bufferViewId];
+        if (!bufferView)
+            return this.errorMiss("bufferView", bufferViewId);
+        if (bufferView.isParsed)
+            return bufferView.dbufferView;
+        bufferView.isParsed = true;
+        bufferView.dbufferView = false;
+        const buffer = this.parseBuffer(bufferView.buffer);
+        if (buffer) {
+            const { byteOffset, byteLength } = bufferView;
+            const bufferArray = new Uint8Array(buffer, byteOffset || 0, byteLength);
+            bufferView.dbufferView = new Uint8Array(bufferArray).buffer;
+        }
+        return bufferView.dbufferView;
+    }
+    parseBuffer(bufferId) {
+        const buffer = this.gltf.buffers[bufferId];
+        if (!buffer)
+            return this.errorMiss("buffer", bufferId);
+        if (buffer.isParsed)
+            return buffer.dbuffer;
+        buffer.isParsed = true;
+        buffer.dbuffer = false;
+        if (buffer.uri.substring(0, 5) !== "data:") {
+            const uri = buffer.uri;
+            const arrayBuffer = this.gltf.resources[uri];
+            if (arrayBuffer)
+                if (arrayBuffer.byteLength === buffer.byteLength) {
+                    buffer.dbuffer = this.gltf.resources[uri];
+                }
+                else
+                    console.error(`load gltf resource "${uri}" at buffers[${bufferId} failed, ArrayBuffer.byteLength not equals buffer's byteLength]`);
+            else
+                console.error(`load gltf resource "${uri}" at buffers[${bufferId}] failed`);
+        }
+        else {
+            const base64Idx = buffer.uri.indexOf(this._BASE64_MARKER) + this._BASE64_MARKER.length;
+            const blob = window.atob(buffer.uri.substring(base64Idx));
+            const bytes = new Uint8Array(blob.length);
+            for (let i = 0; i < blob.length; i++)
+                bytes[i] = blob.charCodeAt(i);
+            buffer.dbuffer = bytes.buffer;
+        }
+        return buffer.dbuffer;
+    }
+    getLight(lightID) {
+        let info = this.gltf.extensions.KHR_lights_punctual.lights[lightID];
+        return info;
+    }
+    applyNodeExtensions(node, dNode) {
+        let extensions = node.extensions;
+        if (extensions[`KHR_lights_punctual`] &&
+            this.gltf.extensions.KHR_lights_punctual) {
+            dNode.light = this.getLight(extensions[`KHR_lights_punctual`].light);
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { GLTF_Info } from "./GLTFInfo";
+export declare class GLTFSubParserCamera {
+    protected gltf: GLTF_Info;
+    constructor(gltf: GLTF_Info);
+    parse(cameraId: any): any;
+    protected errorMiss(e: any, info?: any): void;
+}

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

@@ -0,0 +1,41 @@
+export class GLTFSubParserCamera {
+    constructor(gltf) {
+        this.gltf = gltf;
+    }
+    parse(cameraId) {
+        const camera = this.gltf.cameras[cameraId];
+        if (!camera)
+            return this.errorMiss("camera", cameraId);
+        if (camera.isParsed)
+            return camera.dcamera;
+        camera.isParsed = true;
+        camera.dcamera = false;
+        const { name, type, perspective, orthographic } = camera;
+        if (type === "perspective" && perspective) {
+            const { aspectRatio, yfov, zfar, znear } = perspective;
+            camera.dcamera = Object.assign({}, {
+                name,
+                type,
+                yfov,
+                znear,
+                aspectRatio,
+                zfar,
+            });
+        }
+        else if (type === "orthographic" && orthographic) {
+            const { xmag, ymag, zfar, znear } = orthographic;
+            camera.dcamera = Object.assign({}, {
+                name,
+                type,
+                xmag,
+                ymag,
+                zfar,
+                znear,
+            });
+        }
+        return camera.dcamera;
+    }
+    errorMiss(e, info) {
+        throw new Error(e + info);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Object3D } from "../../../core/entities/Object3D";
+import { GLTF_Info, GLTF_Node } from "./GLTFInfo";
+import { GLTFSubParser } from "./GLTFSubParser";
+export declare class GLTFSubParserConverter {
+    protected gltf: GLTF_Info;
+    protected subParser: GLTFSubParser;
+    private _testCount;
+    private _hasCastShadow;
+    constructor(subParser: GLTFSubParser);
+    convertNodeToObject3D(nodeInfo: GLTF_Node, parentNode: any): Promise<Object3D>;
+    private convertSkeletonAnim;
+    private convertLight;
+    private convertprimitives;
+    private createGeometryBase;
+    private applyMaterialExtensions;
+    private parseSkinJoints;
+}