@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/util/SerializeDecoration.js

@@ -0,0 +1,95 @@
+export function NonSerialize(cls, key) {
+    let dic = cls['__NonSerialize__'];
+    if (!dic) {
+        dic = cls['__NonSerialize__'] = {};
+        dic['__NonSerialize__'] = true;
+    }
+    dic[key] = true;
+}
+export function IsNonSerialize(instance, key) {
+    let noSerializeDic;
+    while (instance) {
+        instance = instance['__proto__'];
+        if (instance)
+            noSerializeDic = instance['__NonSerialize__'];
+        if (noSerializeDic)
+            break;
+    }
+    return noSerializeDic && noSerializeDic[key];
+}
+export function EditorInspector(cls, key, p1, p2, p3) {
+    let dic = cls['__EditorInspector__'];
+    if (!dic) {
+        dic = cls['__EditorInspector__'] = new Map();
+    }
+    let property = dic.get(cls.constructor.name);
+    if (!property) {
+        property = new Map();
+        dic.set(cls.constructor.name, property);
+    }
+    property.set(key, { p1, p2, p3 });
+}
+export function IsEditorInspector(instance) {
+    let propertyDic;
+    let ins = instance;
+    let list = [];
+    while (ins) {
+        if (list.indexOf(ins.constructor.name) != -1) {
+            ins = ins['__proto__'];
+            continue;
+        }
+        list.push(ins.constructor.name);
+        ins = ins['__proto__'];
+    }
+    list = list.reverse();
+    ins = instance;
+    while (ins) {
+        ins = ins['__proto__'];
+        if (ins) {
+            propertyDic = ins['__EditorInspector__'];
+        }
+        if (propertyDic)
+            break;
+    }
+    let final = new Map();
+    if (propertyDic) {
+        for (let i = 0; i < list.length; i++) {
+            const c_name = list[i];
+            let dic = propertyDic.get(c_name);
+            if (dic) {
+                dic.forEach((v, k) => {
+                    final.set(k, v);
+                });
+            }
+        }
+    }
+    return final;
+}
+export function RegisterComponent(cls, key, p1, p2, p3) {
+    let dic = window['__Component__'];
+    if (!dic) {
+        dic = window['__Component__'] = {};
+    }
+    dic[key] = cls;
+}
+export function GetComponentClass(name) {
+    let coms = window['__Component__'];
+    if (coms[name]) {
+        return coms[name];
+    }
+    return null;
+}
+export function RegisterShader(cls, key, p1, p2, p3) {
+    let dic = window['__shader__'];
+    if (!dic) {
+        dic = window['__shader__'] = {};
+    }
+    dic[key] = cls;
+}
+export function GetShader(name) {
+    let coms = window['__shader__'];
+    if (coms[name]) {
+        return coms[name];
+    }
+    return null;
+}

package/dist/src/util/StringUtil.d.ts

@@ -0,0 +1,23 @@
+export declare class StringUtil {
+    private static _filterChar;
+    static hasString(fields: Array<string>, str: string): number;
+    static getEllipsis(str: any, len?: number): string;
+    static getURLName(url: string): string;
+    static getFileFormat(url: string): string;
+    static readLineProperty(line: string, data: any): void;
+    static getPath(url: string): string;
+    static normalizePath(url: string): string;
+    static getStringList(str: string, char?: string): string[];
+    static formatTime(time: number): string[];
+    static trim(str: any): any;
+    static isEmpty(value: any): boolean;
+    static strCut(str: any, len: any): string;
+    static toQueryPair(key: any, value: any, isEncodeURI?: boolean): string;
+    static stringFormat(str: string, ...params: any[]): string;
+    static parseJson2String(json: any, options?: any): string;
+    static compareVersion(v1: any, v2: any): 1 | 0 | -1;
+    static buildRandomCode(): string;
+    static UUID(): string;
+    static stringToHash(str: any): number;
+    static parseUrl(base: string, url: string): string;
+}

package/dist/src/util/StringUtil.js

@@ -0,0 +1,250 @@
+export class StringUtil {
+    static { this._filterChar = [
+        " ",
+        "  ",
+        ";",
+        "\n",
+        "\r",
+        "\t",
+        "\n",
+        "\r",
+        "\t",
+    ]; }
+    static hasString(fields, str) {
+        for (var i = 0; i < fields.length; ++i) {
+            if (fields[i] == str) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    static getEllipsis(str, len = 4) {
+        let name = str;
+        if (name.length > len)
+            name = name.slice(0, len) + "...";
+        return name;
+    }
+    static getURLName(url) {
+        var urlArray;
+        urlArray = url.split("/");
+        let name = urlArray[urlArray.length - 1];
+        name = name.split(".")[0];
+        return name;
+    }
+    static getFileFormat(url) {
+        var startPos = url.lastIndexOf(".");
+        startPos++;
+        var endPos = url.length;
+        if (url.indexOf("?", startPos) !== -1) {
+            endPos = url.indexOf("?", startPos);
+        }
+        var fileFormat = url.substr(startPos, endPos - startPos);
+        fileFormat = fileFormat.toLowerCase();
+        return fileFormat;
+    }
+    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('"', "");
+                    }
+                }
+            }
+        });
+    }
+    static getPath(url) {
+        var s_pos = url.lastIndexOf("/");
+        s_pos++;
+        return url.substring(0, s_pos);
+    }
+    static normalizePath(url) {
+        var tmp = url.replaceAll(`//`, `\/`);
+        tmp = tmp.replaceAll(`\\`, `\/`);
+        return tmp;
+    }
+    static getStringList(str, char = ";") {
+        return str.split(char);
+    }
+    static formatTime(time) {
+        let t = time / 1000;
+        let temp = t / 60;
+        let m = Math.floor(temp);
+        let s = Math.floor(temp - m);
+        return [m.toString(), s.toString()];
+    }
+    static trim(str) {
+        return str.replace(/^\s+/g, "").replace(/\s+$/g, "");
+    }
+    static isEmpty(value) {
+        return (!value ||
+            typeof value == "undefined" ||
+            value == null ||
+            (typeof value === "string" && this.trim(value) === "") ||
+            value === "null");
+    }
+    static strCut(str, len) {
+        if (str.length * 2 <= len) {
+            return str;
+        }
+        var strlen = 0;
+        var s = "";
+        for (var i = 0; i < str.length; i++) {
+            s = s + str.charAt(i);
+            if (str.charCodeAt(i) > 128) {
+                strlen = strlen + 2;
+                if (strlen >= len) {
+                    return s.substring(0, s.length - 1) + "...";
+                }
+            }
+            else {
+                strlen = strlen + 1;
+                if (strlen >= len) {
+                    return s.substring(0, s.length - 2) + "...";
+                }
+            }
+        }
+        return s;
+    }
+    static toQueryPair(key, value, isEncodeURI = false) {
+        return key + "=" + (isEncodeURI ? encodeURIComponent(value) : value);
+    }
+    static stringFormat(str, ...params) {
+        if (arguments.length === 0)
+            throw new Error("please give arg at least one !");
+        if (arguments.length === 2 && typeof arguments[1] === "object") {
+            for (let key in arguments[1]) {
+                let reg = new RegExp("({" + key + "})", "g");
+                str = str.replace(reg, arguments[1][key]);
+            }
+        }
+        else {
+            for (let i = 0; i < params.length; i++) {
+                if (params[i] == undefined) {
+                    return str;
+                }
+                else {
+                    let reg = new RegExp("({[" + i + "]})", "g");
+                    str = str.replace(reg, params[i]);
+                }
+            }
+        }
+        return str;
+    }
+    static parseJson2String(json, options) {
+        let reg = null, formatted = "", pad = 0, PADDING = "    ";
+        options = options || {};
+        options.newlineAfterColonIfBeforeBraceOrBracket =
+            options.newlineAfterColonIfBeforeBraceOrBracket === true ? true : false;
+        options.spaceAfterColon = options.spaceAfterColon === false ? false : true;
+        if (typeof json !== "string") {
+            json = JSON.stringify(json);
+        }
+        else {
+            json = JSON.parse(json);
+            json = JSON.stringify(json);
+        }
+        reg = /([\{\}])/g;
+        json = json.replace(reg, "\r\n$1\r\n");
+        reg = /([\[\]])/g;
+        json = json.replace(reg, "\r\n$1\r\n");
+        reg = /(\,)/g;
+        json = json.replace(reg, "$1\r\n");
+        reg = /(\r\n\r\n)/g;
+        json = json.replace(reg, "\r\n");
+        reg = /\r\n\,/g;
+        json = json.replace(reg, ",");
+        if (!options.newlineAfterColonIfBeforeBraceOrBracket) {
+            reg = /\:\r\n\{/g;
+            json = json.replace(reg, ":{");
+            reg = /\:\r\n\[/g;
+            json = json.replace(reg, ":[");
+        }
+        if (options.spaceAfterColon) {
+            reg = /\:/g;
+            json = json.replace(reg, ":");
+        }
+        json.split("\r\n").forEach(function (node, index) {
+            let i = 0, indent = 0, padding = "";
+            if (node.match(/\{$/) || node.match(/\[$/)) {
+                indent = 1;
+            }
+            else if (node.match(/\}/) || node.match(/\]/)) {
+                if (pad !== 0) {
+                    pad -= 1;
+                }
+            }
+            else {
+                indent = 0;
+            }
+            for (i = 0; i < pad; i++) {
+                padding += PADDING;
+            }
+            formatted += padding + node + "\r\n";
+            pad += indent;
+        });
+        return formatted;
+    }
+    static compareVersion(v1, v2) {
+        v1 = v1.split(".");
+        v2 = v2.split(".");
+        let len = Math.max(v1.length, v2.length);
+        while (v1.length < len) {
+            v1.push("0");
+        }
+        while (v2.length < len) {
+            v2.push("0");
+        }
+        for (let i = 0; i < len; i++) {
+            let num1 = parseInt(v1[i]);
+            let num2 = parseInt(v2[i]);
+            if (num1 > num2) {
+                return 1;
+            }
+            else if (num1 < num2) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+    static buildRandomCode() {
+        let words = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        let len = words.length;
+        let str = "";
+        for (let i = 0; i < 26; i++) {
+            let rand = Math.floor(Math.random() * len);
+            str += words.charAt(rand);
+        }
+        let millisecond = new Date().getTime();
+        return `${millisecond}-${str}`;
+    }
+    static UUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static stringToHash(str) {
+        let hash = 0;
+        if (str.length == 0)
+            return hash;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    }
+    static parseUrl(base, url) {
+        return url.match(/^(blob|http|https):/) ? url : base + url;
+    }
+}

package/dist/src/util/Time.d.ts

@@ -0,0 +1,9 @@
+export declare class Time {
+    static time: number;
+    static frame: number;
+    static delta: number;
+    private static _startTime;
+    private static _timeLabel;
+    static start(label: string): void;
+    static end(): void;
+}

package/dist/src/util/Time.js

@@ -0,0 +1,14 @@
+export class Time {
+    static { this.time = 0; }
+    static { this.frame = 0; }
+    static { this.delta = 0; }
+    static { this._startTime = 0; }
+    static { this._timeLabel = ``; }
+    static start(label) {
+        this._startTime = performance.now();
+        this._timeLabel = label;
+    }
+    static end() {
+        console.log(this._timeLabel, performance.now() - this._startTime);
+    }
+}

package/dist/src/util/Vector3Ex.d.ts

@@ -0,0 +1,16 @@
+import { Vector3 } from "../math/Vector3";
+export declare class Vector3Ex {
+    static add(v1: Vector3, v2: Vector3, target?: Vector3): Vector3;
+    static sub(v1: Vector3, v2: Vector3, target?: Vector3): Vector3;
+    static mul(v1: Vector3, v2: Vector3, target?: Vector3): Vector3;
+    static mulScale(v1: Vector3, v: number, target?: Vector3): Vector3;
+    static div(v1: Vector3, v2: Vector3, target?: Vector3): Vector3;
+    static normalize(v1: Vector3): Vector3;
+    static dot(v1: Vector3, v2: Vector3): number;
+    static calculateVectorAngle_xz(v1: Vector3, v2: Vector3): number;
+    static distance(v1: Vector3, v2: Vector3): number;
+    static getRandomXYZ(min?: number, max?: number): Vector3;
+    static getRandomV3(min: number, max: number, yMin: number, yMax: number): Vector3;
+    static sphere(radius: number): Vector3;
+    static sphereXYZ(radiusMin: number, radiusMax: number, x?: number, y?: number, z?: number): Vector3;
+}

package/dist/src/util/Vector3Ex.js

@@ -0,0 +1,84 @@
+import { Vector3 } from "../math/Vector3";
+export class Vector3Ex {
+    static add(v1, v2, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.x = v1.x + v2.x;
+        target.y = v1.y + v2.y;
+        target.z = v1.z + v2.z;
+        return target;
+    }
+    static sub(v1, v2, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.x = v1.x - v2.x;
+        target.y = v1.y - v2.y;
+        target.z = v1.z - v2.z;
+        return target;
+    }
+    static mul(v1, v2, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.x = v1.x * v2.x;
+        target.y = v1.y * v2.y;
+        target.z = v1.z * v2.z;
+        return target;
+    }
+    static mulScale(v1, v, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.x = v1.x * v;
+        target.y = v1.y * v;
+        target.z = v1.z * v;
+        return target;
+    }
+    static div(v1, v2, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.x = v1.x / v2.x;
+        target.y = v1.y / v2.y;
+        target.z = v1.z / v2.z;
+        return target;
+    }
+    static normalize(v1) {
+        let t = v1.clone();
+        return t.normalize();
+    }
+    static dot(v1, v2) {
+        let v = Vector3.HELP_0;
+        v.copyFrom(v1);
+        return v.dotProduct(v2);
+    }
+    static calculateVectorAngle_xz(v1, v2) {
+        return Math.acos((v1.x * v2.x + v1.y * v2.y) /
+            Math.sqrt((v1.x * v1.x + v1.y * v1.y) * (v2.x * v2.x + v2.y * v2.y)));
+    }
+    static distance(v1, v2) {
+        return Vector3.distance(v1, v2);
+    }
+    static getRandomXYZ(min = -100, max = 100) {
+        return new Vector3(Math.random() * (max - min) + min, Math.random() * (max - min) + min, Math.random() * (max - min) + min);
+    }
+    static getRandomV3(min = -100, max = 100, yMin, yMax) {
+        return new Vector3(Math.random() * max + min, Math.random() * yMax + yMin, Math.random() * max + min);
+    }
+    static sphere(radius) {
+        let r = radius * Math.random();
+        let randomDir = new Vector3(Math.random() * 1 - 0.5, Math.random() * 1 - 0.5, Math.random() * 1 - 0.5);
+        randomDir.normalize();
+        randomDir.scaleBy(r);
+        return randomDir;
+    }
+    static sphereXYZ(radiusMin, radiusMax, x = 1, y = 1, z = 1) {
+        let r = radiusMin + (radiusMax - radiusMin) * Math.random();
+        let randomDir = new Vector3(Math.random() * x - x * 0.5, Math.random() * y - y * 0.5, Math.random() * z - z * 0.5);
+        randomDir.normalize();
+        randomDir.scaleBy(r);
+        return randomDir;
+    }
+}

package/dist/src/util/ZSorterUtil.d.ts

@@ -0,0 +1,13 @@
+import { Camera3D } from "../core/Camera3D";
+import { Object3D } from "../core/entities/Object3D";
+export declare class ZSorterUtil {
+    private _pool;
+    private _worldPosition;
+    private _viewPosition;
+    private _zSortList;
+    private pop;
+    private recycle;
+    sort(camera3D: Camera3D, userDataList: any[], getObject3D: (userData: any) => Object3D, result?: any[]): any[];
+    worldToCameraDepth(obj3d: Object3D, camera?: Camera3D): number;
+}
+export declare let zSorterUtil: ZSorterUtil;

package/dist/src/util/ZSorterUtil.js

@@ -0,0 +1,51 @@
+import { Vector3 } from "../math/Vector3";
+export class ZSorterUtil {
+    constructor() {
+        this._pool = [];
+        this._worldPosition = new Vector3();
+        this._viewPosition = new Vector3();
+        this._zSortList = [];
+    }
+    pop() {
+        return this._pool.pop() || {};
+    }
+    recycle() {
+        for (let item of this._zSortList) {
+            item.z = 0;
+            item.userData = null;
+            item.obj3d = null;
+            this._pool.push(item);
+        }
+        this._zSortList.length = 0;
+    }
+    sort(camera3D, userDataList, getObject3D, result) {
+        this._zSortList = [];
+        for (let userData of userDataList) {
+            let zSortItemObject3D = this.pop();
+            zSortItemObject3D.userData = userData;
+            zSortItemObject3D.obj3d = getObject3D(userData);
+            zSortItemObject3D.z = this.worldToCameraDepth(zSortItemObject3D.obj3d, camera3D);
+            this._zSortList.push(zSortItemObject3D);
+        }
+        this._zSortList.sort((a, b) => {
+            return a.z - b.z > 0 ? 1 : -1;
+        });
+        result ||= [];
+        for (let item of this._zSortList) {
+            result.push(item.userData);
+        }
+        this.recycle();
+        return result;
+    }
+    worldToCameraDepth(obj3d, camera) {
+        camera ||= obj3d.transform.view3D.camera;
+        let z = 0;
+        if (camera) {
+            this._worldPosition.copyFrom(obj3d.transform.worldPosition);
+            camera.worldToScreenPoint(this._worldPosition, this._viewPosition);
+            z = this._viewPosition.z;
+        }
+        return z;
+    }
+}
+export let zSorterUtil = new ZSorterUtil();

package/dist/src/util/struct/Struct.d.ts

@@ -0,0 +1,17 @@
+import { Ctor } from "../Global";
+export declare class Struct {
+    private __refection;
+    private __size;
+    getValueType(): {
+        name: string;
+        type: string;
+    }[];
+    static getValueSize(value: any): any;
+    private static __cacheStruct;
+    static Ref<T extends Struct>(c: Ctor<T>): {
+        name: string;
+        type: string;
+    }[];
+    static Get<T extends Struct>(c: Ctor<T>): Struct;
+    static GetSize<T extends Struct>(c: Ctor<T>): number;
+}

package/dist/src/util/struct/Struct.js

@@ -0,0 +1,101 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsNonSerialize, NonSerialize } from "../SerializeDecoration";
+export class Struct {
+    constructor() {
+        this.__size = 0;
+    }
+    getValueType() {
+        if (!this.__refection) {
+            let self = this;
+            this.__refection = [];
+            for (const key in self) {
+                if (!IsNonSerialize(this, key)) {
+                    const element = self[key];
+                    let att = {
+                        name: key,
+                        type: element.constructor.name,
+                    };
+                    this.__refection.push(att);
+                }
+            }
+        }
+        return this.__refection;
+    }
+    static getValueSize(value) {
+        let type = value.constructor.name;
+        switch (type) {
+            case `Boolean`:
+                return 1 * 4;
+            case `Number`:
+                return 1 * 4;
+            case `f32`:
+                return 1 * 4;
+            case `i32`:
+                return 1 * 4;
+            case `u32`:
+                return 1 * 4;
+            case `Float32Array`:
+                return value.byteLength;
+            case `Vector2`:
+                return 2 * 4;
+            case `Vector3`:
+                return 3 * 4;
+            case `Vector4`:
+                return 4 * 4;
+            case `Color`:
+                return 4 * 4;
+            case `Array`:
+                let singleSize = 0;
+                for (let i = 0, c = value.length; i < c; i++) {
+                    singleSize += Struct.getValueSize(value[i]);
+                }
+                return singleSize;
+        }
+        return 0;
+    }
+    static { this.__cacheStruct = new Map(); }
+    static Ref(c) {
+        let struct = this.Get(c);
+        let ref = struct.getValueType();
+        return ref;
+    }
+    static Get(c) {
+        let struct = Struct.__cacheStruct.get(c.prototype);
+        if (!struct) {
+            struct = new c();
+            Struct.__cacheStruct.set(c.prototype, struct);
+        }
+        return struct;
+    }
+    static GetSize(c) {
+        let struct = this.Get(c);
+        if (struct.__size == 0) {
+            for (const key in struct) {
+                if (!IsNonSerialize(struct, key)) {
+                    const element = struct[key];
+                    struct.__size += Struct.getValueSize(element);
+                }
+            }
+            if (struct.__size > 4) {
+                struct.__size = Math.ceil(struct.__size / 4) * 4;
+            }
+        }
+        return struct.__size;
+    }
+}
+__decorate([
+    NonSerialize,
+    __metadata("design:type", Array)
+], Struct.prototype, "__refection", void 0);
+__decorate([
+    NonSerialize,
+    __metadata("design:type", Number)
+], Struct.prototype, "__size", void 0);