@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/loader/LoaderBase.js

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

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

package/dist/src/loader/LoaderFunctions.js

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,171 @@
+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('"', "");
+                    }
+                }
+            }
+        });
+    }
+}