@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/loader/LoaderBase.js

@@ -1,156 +0,0 @@
-import { Engine3D } from "../Engine3D";
-import { BitmapTexture2D } from "../textures/BitmapTexture2D";
-import { StringUtil } from "../util/StringUtil";
-export class LoaderBase {
-    constructor() {
-        this.baseUrl = "";
-        this._progress = 0;
-    }
-    /**
-     * @private
-     */
-    async loadBinData(url, loaderFunctions) {
-        this.baseUrl = StringUtil.getPath(url);
-        this.initUrl = url;
-        return new Promise(async (succ, fail) => {
-            fetch(url, { headers: loaderFunctions?.headers })
-                .then(async (response) => {
-                if (response.ok) {
-                    let chunks = await LoaderBase.read(url, response, loaderFunctions);
-                    let buffer = chunks.buffer;
-                    chunks = null;
-                    succ(buffer);
-                }
-                else {
-                    throw Error("request rejected with status " + response.status);
-                }
-            })
-                .catch((e) => {
-                if (loaderFunctions.onError) {
-                    loaderFunctions.onError(e);
-                }
-                fail(e);
-            });
-        });
-    }
-    /**
-     *
-     * @private
-     */
-    async loadAsyncBitmapTexture(url, loaderFunctions) {
-        this.baseUrl = StringUtil.getPath(url);
-        this.initUrl = url;
-        let bitmapTexture = new BitmapTexture2D();
-        bitmapTexture.url = url;
-        bitmapTexture.name = StringUtil.getURLName(url);
-        await bitmapTexture.load(url, loaderFunctions);
-        Engine3D.res.addTexture(url, bitmapTexture);
-        return bitmapTexture;
-    }
-    /**
-     *
-     * @private
-     */
-    async loadJson(url, loaderFunctions) {
-        this.baseUrl = StringUtil.getPath(url);
-        this.initUrl = url;
-        return new Promise(async (succ, fail) => {
-            fetch(url, { headers: loaderFunctions?.headers })
-                .then(async (response) => {
-                if (response.ok) {
-                    let chunks = await LoaderBase.read(url, response, loaderFunctions);
-                    let utf8decoder = new TextDecoder("utf-8");
-                    const jsonString = utf8decoder.decode(chunks);
-                    chunks = null;
-                    succ(JSON.parse(jsonString));
-                }
-                else {
-                    throw Error("request rejected with status" + response.status);
-                }
-            })
-                .catch((e) => {
-                if (loaderFunctions.onError) {
-                    loaderFunctions.onError(e);
-                }
-                fail(e);
-            });
-        });
-    }
-    /**
-     * @private
-     */
-    async loadTxt(url, loaderFunctions) {
-        this.baseUrl = StringUtil.getPath(url);
-        return new Promise(async (succ, fail) => {
-            fetch(url)
-                .then(async (response) => {
-                if (response.ok) {
-                    let chunks = await LoaderBase.read(url, response, loaderFunctions);
-                    let utf8decoder = new TextDecoder("utf-8");
-                    const textString = utf8decoder.decode(chunks);
-                    chunks = null;
-                    succ({ data: textString });
-                }
-                else {
-                    throw Error("request rejected with status" + response.status);
-                }
-            })
-                .catch((e) => {
-                if (loaderFunctions.onError) {
-                    loaderFunctions.onError(e);
-                }
-                fail(e);
-            });
-        });
-    }
-    /**
-     * @private
-     */
-    static async read(url, response, loaderFunctions) {
-        const reader = response.body.getReader();
-        const contentLength = +response.headers.get("Content-Length");
-        let receivedLength = 0;
-        let chunks = [];
-        let receivedArr = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                if (contentLength > 0) {
-                    if (loaderFunctions && loaderFunctions.onComplete) {
-                        loaderFunctions.onComplete.call(this, url);
-                    }
-                }
-                break;
-            }
-            chunks.push(value);
-            receivedLength += value.length;
-            if (contentLength > 0) {
-                if (loaderFunctions && loaderFunctions.onProgress) {
-                    loaderFunctions.onProgress.call(this, receivedLength, contentLength, url);
-                }
-            }
-            else {
-                receivedArr.push(value.length);
-            }
-        }
-        if (receivedArr.length > 0) {
-            for (let i = 0; i < chunks.length; i++) {
-                if (loaderFunctions && loaderFunctions.onProgress) {
-                    loaderFunctions.onProgress.call(this, receivedArr[i], receivedLength, url);
-                }
-                if (receivedArr[i] == receivedLength) {
-                    if (loaderFunctions && loaderFunctions.onComplete) {
-                        loaderFunctions.onComplete.call(this, url);
-                    }
-                }
-            }
-        }
-        let chunksAll = new Uint8Array(receivedLength);
-        let position = 0;
-        for (let chunk of chunks) {
-            chunksAll.set(chunk, position);
-            position += chunk.length;
-        }
-        return chunksAll;
-    }
-}

package/dist/src/loader/LoaderFunctions.d.ts

@@ -1,7 +0,0 @@
-export type LoaderFunctions = {
-    onProgress?: Function;
-    onComplete?: Function;
-    onError?: Function;
-    onUrl?: Function;
-    headers?: {};
-};

package/dist/src/loader/LoaderFunctions.js

@@ -1 +0,0 @@
-export {};

package/dist/src/loader/LoaderManager.d.ts

@@ -1,36 +0,0 @@
-import { CEventDispatcher } from "../event/CEventDispatcher";
-import { ParserBase } from "./parser/ParserBase";
-/**
- * @internal
- * 加载管理
- * @group Loader
- */
-export declare class LoaderManager extends CEventDispatcher {
-    private static _instance;
-    private _maxRetry;
-    /**
-     * 同时加载多个同类型资源
-     * @param urls 资源URL列表
-     * @param c 资源解析器类型
-     * @returns 返回解析器数组的Promise
-     */
-    loadAll<T extends ParserBase>(urls: string[], c: {
-        new (): T;
-    }): Promise<T[]>;
-    constructor();
-    static getInstance(): LoaderManager;
-    /**
-     * 加载多个URL资源
-     * @param urls 资源URL列表
-     * @param c 资源解析器类型
-     * @returns 返回解析器数组的Promise
-     */
-    loadUrls(urls: string[], c: {
-        new (): ParserBase;
-    }): Promise<ParserBase[]>;
-    get maxRetry(): number;
-    set maxRetry(value: number);
-    load<T extends ParserBase>(url: string, c: {
-        new (): T;
-    }): Promise<T>;
-}

package/dist/src/loader/LoaderManager.js

@@ -1,83 +0,0 @@
-import { CEventDispatcher } from "../event/CEventDispatcher";
-/**
- * @internal
- * 加载管理
- * @group Loader
- */
-export class LoaderManager extends CEventDispatcher {
-    /**
-     * 同时加载多个同类型资源
-     * @param urls 资源URL列表
-     * @param c 资源解析器类型
-     * @returns 返回解析器数组的Promise
-     */
-    loadAll(urls, c) {
-        return new Promise((succ, fail) => {
-            let count = urls.length;
-            let ret = [];
-            urls.forEach((url, index) => {
-                let parser = new c();
-                this.load(url, c).then((data) => {
-                    parser.parse(data);
-                    ret.push(parser);
-                    count--;
-                    if (count === 0) {
-                        succ(ret);
-                    }
-                });
-            });
-        });
-    }
-    constructor() {
-        super();
-        this._maxRetry = 3;
-        if (LoaderManager._instance) {
-            throw new Error("LoadManager is singleton class...");
-        }
-    }
-    static getInstance() {
-        return this._instance || (this._instance = new LoaderManager());
-    }
-    /**
-     * 加载多个URL资源
-     * @param urls 资源URL列表
-     * @param c 资源解析器类型
-     * @returns 返回解析器数组的Promise
-     */
-    loadUrls(urls, c) {
-        return new Promise((succ, fail) => {
-            let count = urls.length;
-            let ret = [];
-            urls.forEach((url, index) => {
-                this.load(url, c).then((data) => {
-                    ret.push(data);
-                    count--;
-                    if (count === 0) {
-                        succ(ret);
-                    }
-                    if (count < 0) {
-                        console.error(`loadUrls ${urls} error`);
-                    }
-                });
-            });
-        });
-    }
-    get maxRetry() {
-        return this._maxRetry;
-    }
-    set maxRetry(value) {
-        this._maxRetry = value;
-    }
-    load(url, c) {
-        return new Promise((succ, fail) => {
-            switch (c[`format`]) {
-                case `bin`:
-                    break;
-                case `json`:
-                    break;
-                default:
-                    break;
-            }
-        });
-    }
-}

package/dist/src/loader/parser/AtlasParser.d.ts

@@ -1,10 +0,0 @@
-import { ParserBase } from "../../loader/parser/ParserBase";
-import { ParserFormat } from "./ParserFormat";
-export declare class AtlasParser extends ParserBase {
-    static format: ParserFormat;
-    private _json;
-    private _texture;
-    parseString(data: string): Promise<void>;
-    verification(): boolean;
-    private parseAtlas;
-}

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

@@ -1,31 +0,0 @@
-import { GUIAtlasTexture } from "../../components/gui/core/GUIAtlasTexture";
-import { GUITexture } from "../../components/gui/core/GUITexture";
-import { Engine3D } from "../../Engine3D";
-import { ParserBase } from "../../loader/parser/ParserBase";
-import { ParserFormat } from "./ParserFormat";
-export class AtlasParser extends ParserBase {
-    static { this.format = ParserFormat.TEXT; }
-    async parseString(data) {
-        this._json = JSON.parse(data);
-        let textureUrl = this.userData.replace(".json", ".png");
-        this._texture = await Engine3D.res.loadTexture(textureUrl, null, true);
-        this.data = { json: this._json, texture: this._texture };
-        this.parseAtlas();
-    }
-    verification() {
-        if (this.data) {
-            return true;
-        }
-        throw new Error("verify failed.");
-    }
-    parseAtlas() {
-        let atlas = new GUIAtlasTexture(this._json.size);
-        let texture = new GUITexture(this._texture);
-        let atlasInfo = this._json.atlas;
-        for (const key in atlasInfo) {
-            atlas.setTexture(texture, key, atlasInfo[key]);
-        }
-        Engine3D.res.addAtlas(this.baseUrl, atlas);
-        this.data = atlas;
-    }
-}

package/dist/src/loader/parser/B3DMParser.d.ts

@@ -1,24 +0,0 @@
-import { Object3D } from "../../core/entities/Object3D";
-import { ParserBase } from "./ParserBase";
-import { ParserFormat } from "./ParserFormat";
-export declare class B3DMParser extends ParserBase {
-    static format: ParserFormat;
-    parseBuffer(buffer: ArrayBuffer): Promise<void>;
-    verification(): boolean;
-}
-export declare class GLTFBinaryExtension {
-    name: string;
-    content: string;
-    body: ArrayBuffer;
-    header: {
-        magic: string;
-        length: number;
-        version: number;
-    };
-    constructor(data: ArrayBuffer);
-}
-export declare class B3DMParseUtil {
-    private _binary;
-    parseBinary(bytes: ArrayBuffer): Promise<Object3D>;
-    private parseGLB;
-}

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

@@ -1,108 +0,0 @@
-import { ParserBase } from "./ParserBase";
-import { ParserFormat } from "./ParserFormat";
-import { B3DMLoader } from "./b3dm/B3DMLoader";
-import { GLBParser } from "./gltf/GLBParser";
-export class B3DMParser extends ParserBase {
-    static { this.format = ParserFormat.JSON; }
-    async parseBuffer(buffer) {
-        let loader = new B3DMLoader();
-        loader.adjustmentTransform = this.userData;
-        this.data = await loader.parse(buffer);
-    }
-    verification() {
-        if (this.data) {
-            return true;
-        }
-        throw new Error("Method not implemented.");
-    }
-}
-const BINARY_EXTENSION_HEADER_MAGIC = "glTF";
-const BINARY_EXTENSION_HEADER_LENGTH = 12;
-const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4e4f534a, BIN: 0x004e4942 };
-const EXTENSIONS = {
-    KHR_BINARY_GLTF: "KHR_binary_glTF",
-    KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
-    KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
-    KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
-    KHR_MATERIALS_IOR: "KHR_materials_ior",
-    KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: "KHR_materials_pbrSpecularGlossiness",
-    KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
-    KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
-    KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
-    KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
-    KHR_MATERIALS_VOLUME: "KHR_materials_volume",
-    KHR_TEXTURE_BASISU: "KHR_texture_basisu",
-    KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
-    KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
-    EXT_TEXTURE_WEBP: "EXT_texture_webp",
-    EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
-};
-export class GLTFBinaryExtension {
-    constructor(data) {
-        this.name = EXTENSIONS.KHR_BINARY_GLTF;
-        this.content = null;
-        this.body = null;
-        const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
-        this.header = {
-            magic: B3DMLoader.decodeText(new Uint8Array(data.slice(0, 4))),
-            version: headerView.getUint32(4, true),
-            length: headerView.getUint32(8, true),
-        };
-        if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
-            throw new Error("GLTFLoader: Unsupported glTF-Binary header.");
-        }
-        else if (this.header.version < 2.0) {
-            throw new Error("GLTFLoader: Legacy binary file detected.");
-        }
-        const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
-        const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
-        let chunkIndex = 0;
-        while (chunkIndex < chunkContentsLength) {
-            const chunkLength = chunkView.getUint32(chunkIndex, true);
-            chunkIndex += 4;
-            const chunkType = chunkView.getUint32(chunkIndex, true);
-            chunkIndex += 4;
-            if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
-                const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
-                this.content = B3DMLoader.decodeText(contentArray);
-            }
-            else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
-                const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
-                this.body = data.slice(byteOffset, byteOffset + chunkLength);
-            }
-            chunkIndex += chunkLength;
-        }
-        if (this.content === null) {
-            throw new Error("GLTFLoader: JSON content not found.");
-        }
-    }
-}
-export class B3DMParseUtil {
-    async parseBinary(bytes) {
-        this._binary = bytes;
-        const magic = B3DMLoader.decodeText(new Uint8Array(this._binary, 0, 4));
-        const extensions = {};
-        let content;
-        let info;
-        if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
-            try {
-                info = extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(this._binary);
-            }
-            catch (error) {
-                return;
-            }
-            content = extensions[EXTENSIONS.KHR_BINARY_GLTF].content;
-        }
-        else {
-            content = B3DMLoader.decodeText(new Uint8Array(this._binary));
-        }
-        const json = JSON.parse(content);
-        let obj3d = await this.parseGLB(json, info.body);
-        return obj3d;
-    }
-    async parseGLB(json, bin) {
-        let loader = new GLBParser();
-        let obj3d = await loader.parseJsonAndBuffer(json, bin);
-        return obj3d;
-    }
-}

package/dist/src/loader/parser/FontParser.d.ts

@@ -1,54 +0,0 @@
-import { GUITexture } from "../../components/gui/core/GUITexture";
-import { ParserBase } from "./ParserBase";
-import { ParserFormat } from "./ParserFormat";
-export declare class FontInfo {
-    face: string;
-    size: number;
-    bold: boolean;
-    italic: boolean;
-    stretchH: number;
-    spacing: string;
-    outline: number;
-    lineHeight: number;
-    base: number;
-    scaleW: number;
-    scaleH: number;
-    pages: number;
-    packed: number;
-    alphaChnl: number;
-    redChnl: number;
-    greenChnl: number;
-    blueChnl: number;
-    count: number;
-    fontPage: FontPage[];
-    fontChar: {
-        [key: string]: FontChar;
-    };
-    constructor();
-}
-export declare class FontPage {
-    id: number;
-    file: string;
-}
-export declare class FontChar {
-    id: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    xoffset: number;
-    yoffset: number;
-    xadvance: number;
-    page: number;
-    chnl: number;
-}
-export declare class FontParser extends ParserBase {
-    static format: ParserFormat;
-    static parseSprite(guiTexture: GUITexture[], fontData: FontInfo): void;
-    verification(): boolean;
-    parseString(data: string): Promise<void>;
-    private getNewLine;
-    private loadFontTextures;
-    private static insertSpaceChar;
-    private static readLineProperty;
-}

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

@@ -1,171 +0,0 @@
-import { Engine3D } from "../../Engine3D";
-import { fonts } from "../../assets/Fonts";
-import { GUISprite } from "../../components/gui/core/GUISprite";
-import { GUITexture } from "../../components/gui/core/GUITexture";
-import { ParserBase } from "./ParserBase";
-import { ParserFormat } from "./ParserFormat";
-export class FontInfo {
-    constructor() {
-        this.face = "";
-        this.size = 0;
-        this.bold = false;
-        this.italic = false;
-        this.stretchH = 0;
-        this.spacing = "";
-        this.outline = 0;
-        this.lineHeight = 0;
-        this.base = 0;
-        this.scaleW = 0;
-        this.scaleH = 0;
-        this.pages = 0;
-        this.packed = 0;
-        this.alphaChnl = 0;
-        this.redChnl = 0;
-        this.greenChnl = 0;
-        this.blueChnl = 0;
-        this.count = 0;
-        this.fontPage = [];
-        this.fontChar = {};
-    }
-}
-export class FontPage {
-    constructor() {
-        this.id = 0;
-        this.file = "";
-    }
-}
-export class FontChar {
-    constructor() {
-        this.id = -1;
-        this.x = 0;
-        this.y = 0;
-        this.width = 0;
-        this.height = 0;
-        this.xoffset = 0;
-        this.yoffset = 0;
-        this.xadvance = 0;
-        this.page = 0;
-        this.chnl = 0;
-    }
-}
-export class FontParser extends ParserBase {
-    static { this.format = ParserFormat.TEXT; }
-    static parseSprite(guiTexture, fontData) {
-        for (const key in fontData.fontChar) {
-            if (Object.prototype.hasOwnProperty.call(fontData.fontChar, key)) {
-                const charInfo = fontData.fontChar[key];
-                let sprite = new GUISprite();
-                sprite.id = charInfo.id.toString();
-                sprite.offsetSize.set(0, 0, charInfo.width, charInfo.height);
-                sprite.trimSize.set(charInfo.width, charInfo.height);
-                sprite.width = charInfo.width;
-                sprite.height = charInfo.height;
-                sprite.xadvance = charInfo.xadvance;
-                sprite.xoffset = charInfo.xoffset;
-                sprite.yoffset = charInfo.yoffset;
-                sprite.guiTexture = guiTexture[charInfo.page];
-                sprite.uvRec.set(charInfo.x / fontData.scaleW, (fontData.scaleH - (charInfo.y + charInfo.height)) / fontData.scaleH, charInfo.width / fontData.scaleW, charInfo.height / fontData.scaleH);
-                fonts.addFnt(fontData.face, fontData.size, sprite.id, sprite);
-            }
-        }
-    }
-    verification() {
-        if (this.data) {
-            return true;
-        }
-        throw new Error("Method not implemented.");
-    }
-    async parseString(data) {
-        let newLine = this.getNewLine(data);
-        let fnt = data;
-        let fontData = new FontInfo();
-        fnt
-            .trim()
-            .split(newLine)
-            .forEach((v, i) => {
-            if (i < 2) {
-                FontParser.readLineProperty(v, fontData);
-            }
-            else {
-                if (i < fontData.pages + 2) {
-                    let page = new FontPage();
-                    FontParser.readLineProperty(v, page);
-                    fontData.fontPage.push(page);
-                }
-                else if (i < fontData.pages + 3) {
-                    FontParser.readLineProperty(v, fontData);
-                }
-                else {
-                    if (fontData.count > 0) {
-                        let char = new FontChar();
-                        FontParser.readLineProperty(v, char);
-                        fontData.fontChar[char.id] = char;
-                        fontData.count--;
-                    }
-                }
-            }
-        });
-        fnt = "";
-        this.data = fontData;
-        await this.loadFontTextures();
-    }
-    getNewLine(value) {
-        if (value.indexOf("\r\n") != -1)
-            return "\r\n";
-        else if (value.indexOf("\r") != -1)
-            return "\r";
-        else
-            return "\n";
-    }
-    async loadFontTextures() {
-        let images = [];
-        let fontData = this.data;
-        for (const fontPage of fontData.fontPage) {
-            let texturePath = this.baseUrl + fontPage.file;
-            await Engine3D.res.loadTexture(texturePath, null, true);
-            let texture = Engine3D.res.getTexture(texturePath);
-            let source = new GUITexture(texture);
-            images.push(source);
-        }
-        FontParser.parseSprite(images, fontData);
-        if (!fontData.fontChar[" "]) {
-            FontParser.insertSpaceChar(fontData, images[0]);
-        }
-    }
-    static insertSpaceChar(fontData, texture) {
-        let sprite = new GUISprite();
-        let width = fontData.size * 0.5;
-        let height = fontData.lineHeight * 0.5;
-        sprite.id = " ";
-        sprite.offsetSize.set(0, 0, fontData.size, fontData.size);
-        sprite.trimSize.set(width, height);
-        sprite.width = width;
-        sprite.height = height;
-        sprite.xadvance = 0;
-        sprite.xoffset = 0;
-        sprite.yoffset = 0;
-        sprite.guiTexture = texture;
-        sprite.uvRec.set(0, 0, 0.000001, 0.000001);
-        fonts.addFnt(fontData.face, fontData.size, sprite.id, sprite);
-    }
-    static readLineProperty(line, data) {
-        line
-            .trim()
-            .split(" ")
-            .forEach((v, i) => {
-            let strArr = v.split("=");
-            if (strArr.length > 1) {
-                let key = strArr[0];
-                let value = strArr[1];
-                if (Object.prototype.hasOwnProperty.call(data, key)) {
-                    if (value.indexOf('"') == -1) {
-                        data[key] = parseFloat(strArr[1]);
-                    }
-                    else {
-                        data[key] = value.replace('"', "").replace('"', "");
-                    }
-                }
-            }
-        });
-    }
-}