@rings-webgpu/core 1.0.2 → 1.0.3

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

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

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

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

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