@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/Color.js

@@ -0,0 +1,381 @@
+export class Color {
+    /**
+     * red color
+     */
+    static { this.COLOR_RED = new Color(1, 0, 0, 1); }
+    /**
+     * green color
+     */
+    static { this.COLOR_GREEN = new Color(0, 1, 0, 1); }
+    /**
+     * blue color
+     */
+    static { this.COLOR_BLUE = new Color(0, 0, 1, 1); }
+    /**
+     * white color
+     */
+    static { this.COLOR_WHITE = new Color(1, 1, 1, 1); }
+    /**
+     * cache
+     * @internal
+     */
+    static { this.COLOR_0 = new Color(); }
+    /**
+     * cache
+     * @internal
+     */
+    static { this.COLOR_1 = new Color(); }
+    /**
+     * cache
+     * @internal
+     */
+    static { this.COLOR_2 = new Color(); }
+    /**
+     * @internal
+     */
+    static { this.HEX_CHARACTERS = "a-f\\d"; }
+    /**
+     * @internal
+     */
+    static { this.MATCH_3OR4_HEX = `#?[${Color.HEX_CHARACTERS}]{3}[${Color.HEX_CHARACTERS}]?`; }
+    /**
+     * @internal
+     */
+    static { this.MATCH_6OR8_HEX = `#?[${Color.HEX_CHARACTERS}]{6}([${Color.HEX_CHARACTERS}]{2})?`; }
+    /**
+     * @internal
+     */
+    static { this.NON_HEX_CHARS = new RegExp(`[^#${Color.HEX_CHARACTERS}]`, "gi"); }
+    /**
+     * @internal
+     */
+    static { this.VALID_HEX_SIZE = new RegExp(`^${Color.MATCH_3OR4_HEX}$|^${Color.MATCH_6OR8_HEX}$`, "i"); }
+    constructor(r = 1.0, g = 1.0, b = 1.0, a = 1.0) {
+        /**
+         * red channel
+         */
+        this.r = 0;
+        /**
+         * green channel
+         */
+        this.g = 0;
+        /**
+         * blue channel
+         */
+        this.b = 0;
+        /**
+         * alpha channel
+         */
+        this.a = 0;
+        this.setTo(r, g, b, a);
+    }
+    convertToHDRRGB() {
+        this.r = this.r * Math.pow(2.4, this.a);
+        this.g = this.g * Math.pow(2.4, this.a);
+        this.b = this.b * Math.pow(2.4, this.a);
+        return this;
+    }
+    unSerialized(data) {
+        this.r = data["r"];
+        this.g = data["g"];
+        this.b = data["b"];
+        this.a = data["a"];
+        return this;
+    }
+    hexToRGB(value) {
+        this.r = ((value >> 16) & 0xff) / 255;
+        this.g = ((value >> 8) & 0xff) / 255;
+        this.b = (value & 0xff) / 255;
+        return this;
+    }
+    hexToRGBA(value) {
+        this.a = ((value >> 24) & 0xff) / 255;
+        this.r = ((value >> 16) & 0xff) / 255;
+        this.g = ((value >> 8) & 0xff) / 255;
+        this.b = (value & 0xff) / 255;
+        return this;
+    }
+    static random(base = 1.0) {
+        let color = new Color();
+        color.a = base;
+        color.r = base * Math.random();
+        color.g = base * Math.random();
+        color.b = base * Math.random();
+        return color;
+    }
+    static randomRGB(seedR = 0.5, seedG = 0.5, seedB = 0.5, baseR = 0.5, baseG = 0.5, baseB = 0.5) {
+        let color = new Color();
+        color.a = 1.0;
+        color.r = baseR + seedR * Math.random();
+        color.g = baseG + seedG * Math.random();
+        color.b = baseB + seedB * Math.random();
+        return color;
+    }
+    static randomGray(base = 0.5, random = 0.5) {
+        let seed = Math.random() * random + base;
+        let color = new Color();
+        color.a = 1.0;
+        color.r = seed;
+        color.g = seed;
+        color.b = seed;
+        return color;
+    }
+    setTo(r, g, b, a) {
+        this.r = Math.max(r, 0.0);
+        this.g = Math.max(g, 0.0);
+        this.b = Math.max(b, 0.0);
+        this.a = Math.max(a, 0.0);
+    }
+    setHex(hex) {
+        if (typeof hex !== "string" ||
+            Color.NON_HEX_CHARS.test(hex) ||
+            !Color.VALID_HEX_SIZE.test(hex)) {
+            throw new TypeError("Expected a valid hex string");
+        }
+        hex = hex.replace(/^#/, "");
+        let alphaFromHex = 1;
+        if (hex.length === 8) {
+            alphaFromHex = Number.parseInt(hex.slice(6, 8), 16) / 255;
+            hex = hex.slice(0, 6);
+        }
+        if (hex.length === 4) {
+            alphaFromHex = Number.parseInt(hex.slice(3, 4).repeat(2), 16) / 255;
+            hex = hex.slice(0, 3);
+        }
+        if (hex.length === 3) {
+            hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+        }
+        const number = Number.parseInt(hex, 16);
+        const red = number >> 16;
+        const green = (number >> 8) & 255;
+        const blue = number & 255;
+        const alpha = alphaFromHex;
+        this.a = alpha;
+        this.r = red / 255;
+        this.g = green / 255;
+        this.b = blue / 255;
+    }
+    getHex() {
+        let getHexStr = (n) => {
+            n *= 255.0;
+            let str = n.toString(16);
+            if (str.length === 1) {
+                str = "0" + str;
+            }
+            return str;
+        };
+        let hex = getHexStr(this.r) +
+            getHexStr(this.g) +
+            getHexStr(this.b) +
+            getHexStr(this.a);
+        return hex;
+    }
+    /**
+     * get rgb to array
+     */
+    get rgb() {
+        return [(this.r * 255) >>> 0, (this.g * 255) >>> 0, (this.b * 255) >>> 0];
+    }
+    /**
+     * set rgb by array
+     */
+    set rgb(c) {
+        this.setTo(c[0] / 255, c[1] / 255, c[2] / 255, this.a);
+    }
+    /**
+     * get rgba to array
+     */
+    get rgba() {
+        return [
+            (this.r * 255) >>> 0,
+            (this.g * 255) >>> 0,
+            (this.b * 255) >>> 0,
+            (this.a * 255) >>> 0,
+        ];
+    }
+    /**
+     * set rgb by array
+     */
+    set rgba(c) {
+        this.setTo(c[0] / 255, c[1] / 255, c[2] / 255, c[3] / 255);
+    }
+    clone() {
+        return new Color().copyFrom(this);
+    }
+    copyFrom(src) {
+        this.r = src.r;
+        this.g = src.g;
+        this.b = src.b;
+        this.a = src.a;
+        return this;
+    }
+    copyFromArray(arr, scalar = 255) {
+        this.r = arr[0] / scalar;
+        this.g = arr[1] / scalar;
+        this.b = arr[2] / scalar;
+        this.a = arr[3] / scalar;
+        return this;
+    }
+    copyFromVector(value) {
+        this.r = value.x;
+        this.g = value.y;
+        this.b = value.z;
+        this.a = value.w || 1;
+        return this;
+    }
+    static hexRGBColor(hexColor, dst = null) {
+        dst = dst || new Color();
+        dst.hexToRGB(hexColor);
+        return dst;
+    }
+    static lerp(v, c1, c2, target) {
+        let ret = target ? target : new Color();
+        ret.r = (c2.r - c1.r) * v + c1.r;
+        ret.g = (c2.g - c1.g) * v + c1.g;
+        ret.b = (c2.b - c1.b) * v + c1.b;
+        ret.a = (c2.a - c1.a) * v + c1.a;
+        return ret;
+    }
+    static { this.PRIMARY = 0x3f51b5; } //
+    static { this.PRIMARYDARK = 0x303f9f; } //
+    static { this.ACCENT = 0xff4081; } //
+    static { this.WHITE = 0xffffff; }
+    static { this.IVORY = 0xfffff0; }
+    static { this.LIGHTYELLOW = 0xffffe0; }
+    static { this.YELLOW = 0xffff00; }
+    static { this.SNOW = 0xfffafa; }
+    static { this.FLORALWHITE = 0xfffaf0; }
+    static { this.LEMONCHIFFON = 0xfffacd; }
+    static { this.CORNSILK = 0xfff8dc; }
+    static { this.SEASHELL = 0xfff5ee; }
+    static { this.LAVENDERBLUSH = 0xfff0f5; }
+    static { this.PAPAYAWHIP = 0xffefd5; }
+    static { this.BLANCHEDALMOND = 0xffebcd; }
+    static { this.MISTYROSE = 0xffe4e1; }
+    static { this.BISQUE = 0xffe4c4; }
+    static { this.MOCCASIN = 0xffe4b5; }
+    static { this.NAVAJOWHITE = 0xffdead; }
+    static { this.PEACHPUFF = 0xffdab9; }
+    static { this.GOLD = 0xffd700; }
+    static { this.PINK = 0xffc0cb; }
+    static { this.LIGHTPINK = 0xffb6c1; }
+    static { this.ORANGE = 0xffa500; }
+    static { this.LIGHTSALMON = 0xffa07a; }
+    static { this.DARKORANGE = 0xff8c00; }
+    static { this.CORAL = 0xff7f50; }
+    static { this.HOTPINK = 0xff69b4; }
+    static { this.TOMATO = 0xff6347; }
+    static { this.ORANGERED = 0xff4500; }
+    static { this.DEEPPINK = 0xff1493; }
+    static { this.FUCHSIA = 0xff00ff; }
+    static { this.MAGENTA = 0xff00ff; }
+    static { this.RED = 0xff0000; }
+    static { this.OLDLACE = 0xfdf5e6; }
+    static { this.LIGHTGOLDENRODYELLOW = 0xfafad2; }
+    static { this.LINEN = 0xfaf0e6; }
+    static { this.ANTIQUEWHITE = 0xfaebd7; }
+    static { this.SALMON = 0xfa8072; }
+    static { this.GHOSTWHITE = 0xf8f8ff; }
+    static { this.MINTCREAM = 0xf5fffa; }
+    static { this.WHITESMOKE = 0xf5f5f5; }
+    static { this.BEIGE = 0xf5f5dc; }
+    static { this.WHEAT = 0xf5deb3; }
+    static { this.SANDYBROWN = 0xf4a460; }
+    static { this.AZURE = 0xf0ffff; }
+    static { this.HONEYDEW = 0xf0fff0; }
+    static { this.ALICEBLUE = 0xf0f8ff; }
+    static { this.KHAKI = 0xf0e68c; }
+    static { this.LIGHTCORAL = 0xf08080; }
+    static { this.PALEGOLDENROD = 0xeee8aa; }
+    static { this.VIOLET = 0xee82ee; }
+    static { this.DARKSALMON = 0xe9967a; }
+    static { this.LAVENDER = 0xe6e6fa; }
+    static { this.LIGHTCYAN = 0xe0ffff; }
+    static { this.BURLYWOOD = 0xdeb887; }
+    static { this.PLUM = 0xdda0dd; }
+    static { this.GAINSBORO = 0xdcdcdc; }
+    static { this.CRIMSON = 0xdc143c; }
+    static { this.PALEVIOLETRED = 0xdb7093; }
+    static { this.GOLDENROD = 0xdaa520; }
+    static { this.ORCHID = 0xda70d6; }
+    static { this.THISTLE = 0xd8bfd8; }
+    static { this.LIGHTGREY = 0xd3d3d3; }
+    static { this.TAN = 0xd2b48c; }
+    static { this.CHOCOLATE = 0xd2691e; }
+    static { this.PERU = 0xcd853f; }
+    static { this.INDIANRED = 0xcd5c5c; }
+    static { this.MEDIUMVIOLETRED = 0xc71585; }
+    static { this.SILVER = 0xc0c0c0; }
+    static { this.DARKKHAKI = 0xbdb76b; }
+    static { this.ROSYBROWN = 0xbc8f8f; }
+    static { this.MEDIUMORCHID = 0xba55d3; }
+    static { this.DARKGOLDENROD = 0xb8860b; }
+    static { this.FIREBRICK = 0xb22222; }
+    static { this.POWDERBLUE = 0xb0e0e6; }
+    static { this.LIGHTSTEELBLUE = 0xb0c4de; }
+    static { this.PALETURQUOISE = 0xafeeee; }
+    static { this.GREENYELLOW = 0xadff2f; }
+    static { this.LIGHTBLUE = 0xadd8e6; }
+    static { this.DARKGRAY = 0xa9a9a9; }
+    static { this.BROWN = 0xa52a2a; }
+    static { this.SIENNA = 0xa0522d; }
+    static { this.DARKORCHID = 0x9932cc; }
+    static { this.PALEGREEN = 0x98fb98; }
+    static { this.DARKVIOLET = 0x9400d3; }
+    static { this.MEDIUMPURPLE = 0x9370db; }
+    static { this.LIGHTGREEN = 0x90ee90; }
+    static { this.DARKSEAGREEN = 0x8fbc8f; }
+    static { this.SADDLEBROWN = 0x8b4513; }
+    static { this.DARKMAGENTA = 0x8b008b; }
+    static { this.DARKRED = 0x8b0000; }
+    static { this.BLUEVIOLET = 0x8a2be2; }
+    static { this.LIGHTSKYBLUE = 0x87cefa; }
+    static { this.SKYBLUE = 0x87ceeb; }
+    static { this.GRAY = 0x808080; }
+    static { this.OLIVE = 0x808000; }
+    static { this.PURPLE = 0x800080; }
+    static { this.MAROON = 0x800000; }
+    static { this.AQUAMARINE = 0x7fffd4; }
+    static { this.CHARTREUSE = 0x7fff00; }
+    static { this.LAWNGREEN = 0x7cfc00; }
+    static { this.MEDIUMSLATEBLUE = 0x7b68ee; }
+    static { this.LIGHTSLATEGRAY = 0x778899; }
+    static { this.SLATEGRAY = 0x708090; }
+    static { this.OLIVEDRAB = 0x6b8e23; }
+    static { this.SLATEBLUE = 0x6a5acd; }
+    static { this.DIMGRAY = 0x696969; }
+    static { this.MEDIUMAQUAMARINE = 0x66cdaa; }
+    static { this.CORNFLOWERBLUE = 0x6495ed; }
+    static { this.CADETBLUE = 0x5f9ea0; }
+    static { this.DARKOLIVEGREEN = 0x556b2f; }
+    static { this.INDIGO = 0x4b0082; }
+    static { this.MEDIUMTURQUOISE = 0x48d1cc; }
+    static { this.DARKSLATEBLUE = 0x483d8b; }
+    static { this.STEELBLUE = 0x4682b4; }
+    static { this.ROYALBLUE = 0x4169e1; }
+    static { this.TURQUOISE = 0x40e0d0; }
+    static { this.MEDIUMSEAGREEN = 0x3cb371; }
+    static { this.LIMEGREEN = 0x32cd32; }
+    static { this.DARKSLATEGRAY = 0x2f4f4f; }
+    static { this.SEAGREEN = 0x2e8b57; }
+    static { this.FORESTGREEN = 0x228b22; }
+    static { this.LIGHTSEAGREEN = 0x20b2aa; }
+    static { this.DODGERBLUE = 0x1e90ff; }
+    static { this.MIDNIGHTBLUE = 0x191970; }
+    static { this.AQUA = 0x00ffff; }
+    static { this.CYAN = 0x00ffff; }
+    static { this.SPRINGGREEN = 0x00ff7f; }
+    static { this.LIME = 0x00ff00; }
+    static { this.MEDIUMSPRINGGREEN = 0x00fa9a; }
+    static { this.DARKTURQUOISE = 0x00ced1; }
+    static { this.DEEPSKYBLUE = 0x00bfff; }
+    static { this.DARKCYAN = 0x008b8b; }
+    static { this.TEAL = 0x008080; }
+    static { this.GREEN = 0x008000; }
+    static { this.DARKGREEN = 0x006400; }
+    static { this.BLUE = 0x0000ff; }
+    static { this.MEDIUMBLUE = 0x0000cd; }
+    static { this.DARKBLUE = 0x00008b; }
+    static { this.NAVY = 0x000080; }
+    static { this.BLACK = 0x000000; }
+}

package/dist/src/math/ColorGradient.d.ts

@@ -0,0 +1,6 @@
+import { Color } from "./Color";
+export declare class ColorGradient {
+    private colorArray;
+    constructor(array: Color[]);
+    getColor(p: number): Color;
+}

package/dist/src/math/ColorGradient.js

@@ -0,0 +1,14 @@
+import { Color } from "./Color";
+export class ColorGradient {
+    constructor(array) {
+        this.colorArray = array;
+    }
+    getColor(p) {
+        let s = p * this.colorArray.length;
+        let i = Math.floor(s);
+        let k = Math.min(i + 1, this.colorArray.length - 1);
+        let c1 = this.colorArray[i];
+        let c2 = this.colorArray[k];
+        return Color.lerp(s - i, c1, c2);
+    }
+}

package/dist/src/math/CubicBezierCurve.d.ts

@@ -0,0 +1,47 @@
+import { Vector3 } from "./Vector3";
+/**
+ * 三次贝塞尔曲线
+ * @group Math
+ */
+export declare class CubicBezierCurve {
+    private controlVertices;
+    /**
+     * @constructor
+     * @param cvs 更新控制点
+     */
+    constructor(cvs: Vector3[]);
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    setControlVertices(cvs: Vector3[]): void;
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    getPoint(t: number): Vector3;
+    /**
+     * 计算曲线上参数t处的切线方向
+     * @param t 参数值，范围[0-1]
+     * @returns 切线方向向量
+     */
+    getTangent(t: number): Vector3;
+    /**
+     * 获取曲线上最接近给定点的参数t值
+     * @param pos 给定的点位置
+     * @param paramThreshold 阈值
+     * @returns 参数t值，范围[0-1]
+     */
+    getClosestParam(pos: Vector3, paramThreshold?: number): number;
+    /**
+     * 递归计算给定范围内最接近点的参数t值
+     * @param pos 给定的点位置
+     * @param beginT 起始参数
+     * @param endT 结束参数
+     * @param thresholdT 阈值
+     * @returns 参数t值
+     */
+    getClosestParamRec(pos: Vector3, beginT: number, endT: number, thresholdT: number): number;
+}

package/dist/src/math/CubicBezierCurve.js

@@ -0,0 +1,100 @@
+import { Vector3 } from "./Vector3";
+/**
+ * 三次贝塞尔曲线
+ * @group Math
+ */
+export class CubicBezierCurve {
+    /**
+     * @constructor
+     * @param cvs 更新控制点
+     */
+    constructor(cvs) {
+        this.setControlVertices(cvs);
+    }
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    setControlVertices(cvs) {
+        // Cubic Bezier curves require 4 cvs.
+        if (cvs.length == 4) {
+            this.controlVertices = cvs.concat();
+        }
+    }
+    /**
+     * 根据参数t计算曲线上点的位置
+     * @param t 参数值，范围[0-1]
+     * @returns 曲线上的点坐标(Vector3)
+     */
+    getPoint(t) {
+        if (!(t >= 0.0 && t <= 1.0)) {
+            return Vector3.ZERO;
+        }
+        let c = 1.0 - t;
+        let bb0 = c * c * c;
+        let bb1 = 3 * t * c * c;
+        let bb2 = 3 * t * t * c;
+        let bb3 = t * t * t;
+        let point = this.controlVertices[0]
+            .mul(bb0)
+            .add(this.controlVertices[1].mul(bb1))
+            .add(this.controlVertices[2].mul(bb2))
+            .add(this.controlVertices[3].mul(bb3));
+        return point;
+    }
+    /**
+     * 计算曲线上参数t处的切线方向
+     * @param t 参数值，范围[0-1]
+     * @returns 切线方向向量
+     */
+    getTangent(t) {
+        if (!(t >= 0.0 && t <= 1.0)) {
+            return Vector3.ZERO;
+        }
+        let controlVerts = this.controlVertices;
+        let q0 = controlVerts[0].add(controlVerts[1].add(controlVerts[0]).mul(t));
+        let q1 = controlVerts[1].add(controlVerts[2].add(controlVerts[1]).mul(t));
+        let q2 = controlVerts[2].add(controlVerts[3].add(controlVerts[2]).mul(t));
+        let r0 = q0.add(q1.subtract(q0).mul(t));
+        let r1 = q1.add(q2.subtract(q1).mul(t));
+        let tangent = r1.subtract(r0);
+        return tangent;
+    }
+    /**
+     * 获取曲线上最接近给定点的参数t值
+     * @param pos 给定的点位置
+     * @param paramThreshold 阈值
+     * @returns 参数t值，范围[0-1]
+     */
+    getClosestParam(pos, paramThreshold = 0.000001) {
+        return this.getClosestParamRec(pos, 0.0, 1.0, paramThreshold);
+    }
+    /**
+     * 递归计算给定范围内最接近点的参数t值
+     * @param pos 给定的点位置
+     * @param beginT 起始参数
+     * @param endT 结束参数
+     * @param thresholdT 阈值
+     * @returns 参数t值
+     */
+    getClosestParamRec(pos, beginT, endT, thresholdT) {
+        let mid = (beginT + endT) / 2.0;
+        if (endT - beginT < thresholdT) {
+            return mid;
+        }
+        let paramA = (beginT + mid) / 2.0;
+        let paramB = (mid + endT) / 2.0;
+        let posA = this.getPoint(paramA);
+        let posB = this.getPoint(paramB);
+        let distASq = posA.subtract(pos).lengthSquared;
+        let distBSq = posB.subtract(pos).lengthSquared;
+        if (distASq < distBSq) {
+            endT = mid;
+        }
+        else {
+            beginT = mid;
+        }
+        return this.getClosestParamRec(pos, beginT, endT, thresholdT);
+    }
+}

package/dist/src/math/CubicBezierPath.d.ts

@@ -0,0 +1,37 @@
+import { Vector3 } from "./Vector3";
+/**
+ * 三次贝塞尔曲线类型
+ * @group Math
+ */
+export declare enum CubicBezierType {
+    Open = 0,
+    Closed = 1
+}
+/**
+ * @group Math
+ */
+export declare class CubicBezierPath {
+    private type;
+    private numCurveSegments;
+    private numControlVertices;
+    private controlVertices;
+    constructor(controlVertices: Vector3[], t?: CubicBezierType);
+    getPathType(): CubicBezierType;
+    isClosed(): boolean;
+    /**
+     * @returns
+     */
+    isValid(): boolean;
+    clear(): void;
+    computeApproxLength(): number;
+    computeApproxParamPerUnitLength(): number;
+    computeApproxNormParamPerUnitLength(): number;
+    interpolatePoints(knots: Vector3[], t: CubicBezierType): void;
+    setControlVertices(cvs: Vector3[], t: CubicBezierType): void;
+    getPoint(t: number): Vector3;
+    getPointNorm(t: number): Vector3;
+    getTangent(t: number): Vector3;
+    getTangentNorm(t: number): Vector3;
+    computeClosestParam(pos: Vector3, paramThreshold: number): number;
+    computeClosestNormParam(pos: Vector3, paramThreshold: number): number;
+}