@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/Vector3.js

@@ -0,0 +1,561 @@
+export class Vector3 {
+    static { this.MAX = new Vector3(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE); }
+    static { this.MIN = new Vector3(Number.MIN_VALUE, Number.MIN_VALUE, Number.MIN_VALUE); }
+    static { this.SAFE_MAX = new Vector3(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); }
+    static { this.SAFE_MIN = new Vector3(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER); }
+    static { this.X_AXIS = new Vector3(1, 0, 0); }
+    static { this.neg_X_AXIS = new Vector3(-1, 0, 0); }
+    static { this.Y_AXIS = new Vector3(0, 1, 0); }
+    static { this.Z_AXIS = new Vector3(0, 0, 1); }
+    static { this.HELP_0 = new Vector3(); }
+    static { this.HELP_1 = new Vector3(); }
+    static { this.HELP_2 = new Vector3(); }
+    static { this.EPSILON = 0.00001; }
+    static { this.HELP_3 = new Vector3(); }
+    static { this.HELP_4 = new Vector3(); }
+    static { this.HELP_5 = new Vector3(); }
+    static { this.HELP_6 = new Vector3(); }
+    static get ZERO() {
+        return new Vector3(0, 0, 0);
+    }
+    static get ONE() {
+        return new Vector3(1, 1, 1);
+    }
+    static get LEFT() {
+        return new Vector3(-1, 0, 0);
+    }
+    static get RIGHT() {
+        return new Vector3(1, 0, 0);
+    }
+    static get UP() {
+        return new Vector3(0, 1, 0);
+    }
+    static get DOWN() {
+        return new Vector3(0, -1, 0);
+    }
+    static get BACK() {
+        return new Vector3(0, 0, -1);
+    }
+    static get FORWARD() {
+        return new Vector3(0, 0, 1);
+    }
+    static { this._index = 0; }
+    constructor(x = 0, y = 0, z = 0, w = 0) {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.w = 1;
+        this.index = 0;
+        this.set(x, y, z, w);
+        this.index = Vector3._index++;
+    }
+    set a(value) {
+        this.w = value;
+    }
+    set r(value) {
+        this.x = value;
+    }
+    set g(value) {
+        this.y = value;
+    }
+    set b(value) {
+        this.z = value;
+    }
+    get a() {
+        return this.w;
+    }
+    get r() {
+        return this.x;
+    }
+    get g() {
+        return this.y;
+    }
+    get b() {
+        return this.z;
+    }
+    get length() {
+        return Math.sqrt(this.lengthSquared);
+    }
+    get lengthSquared() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+    }
+    get position() {
+        return this;
+    }
+    static getTowPointbyDir(dir, tp1, tp2, width, aix) {
+        if (aix == Vector3.Z_AXIS) {
+            tp1.x = dir.y;
+            tp1.y = -dir.x;
+            tp2.x = -dir.y;
+            tp2.y = dir.x;
+            tp1.scaleBy(width * 0.5);
+            tp2.scaleBy(width * 0.5);
+        }
+        else if (aix == Vector3.Y_AXIS) {
+            tp1.x = dir.z;
+            tp1.z = -dir.x;
+            tp2.x = -dir.z;
+            tp2.z = dir.x;
+            tp1.scaleBy(width * 0.5);
+            tp2.scaleBy(width * 0.5);
+        }
+    }
+    static pointToLine(point1, point2, position) {
+        let space = 0;
+        let a, b, c;
+        a = Vector3.distance(point1, point2);
+        b = Vector3.distance(point1, position);
+        c = Vector3.distance(point2, position);
+        if (c <= 0.000001 || b <= 0.000001) {
+            space = 0;
+            return space;
+        }
+        if (a <= 0.000001) {
+            space = b;
+            return space;
+        }
+        if (c * c >= a * a + b * b) {
+            space = b;
+            return space;
+        }
+        if (b * b >= a * a + c * c) {
+            space = c;
+            return space;
+        }
+        let p = (a + b + c) / 2;
+        let s = Math.sqrt(p * (p - a) * (p - b) * (p - c));
+        space = (2 * s) / a;
+        return space;
+    }
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y + a.z * b.z;
+    }
+    static getPoints(total, randSeed) {
+        let points = [];
+        for (let index = 0; index < total; index++) {
+            const element = new Vector3(Math.random() * randSeed - randSeed * 0.5, Math.random() * randSeed - randSeed * 0.5, Math.random() * randSeed - randSeed * 0.5);
+            points.push(element);
+        }
+        return points;
+    }
+    static getPointNumbers(total, randSeed) {
+        let points = [];
+        for (let index = 0; index < total; index++) {
+            points.push(Math.random() * randSeed - randSeed * 0.5, Math.random() * randSeed - randSeed * 0.5, Math.random() * randSeed - randSeed * 0.5);
+        }
+        return points;
+    }
+    static getAngle(from, to) {
+        let t = from.dotProduct(to) / (from.length * to.length);
+        return (Math.acos(t) * 180) / Math.PI;
+    }
+    static sqrMagnitude(arg0) {
+        return arg0.x * arg0.x + arg0.y * arg0.y + arg0.z * arg0.z;
+    }
+    static getZYAngle(zd, yd) {
+        return this.calAngle(zd.y, zd.z, yd.y, yd.z);
+    }
+    static sub(a, b, target = null) {
+        target = target || new Vector3();
+        target.x = a.x - b.x;
+        target.y = a.y - b.y;
+        target.z = a.z - b.z;
+        return target;
+    }
+    static add(a, b, target = null) {
+        target = target || new Vector3();
+        target.x = a.x + b.x;
+        target.y = a.y + b.y;
+        target.z = a.z + b.z;
+        return target;
+    }
+    static smoothDamp(current, target, currentVelocity, smoothTime, maxSpeed, deltaTime) {
+        return null;
+    }
+    static distance(pt1, pt2) {
+        let x = pt1.x - pt2.x;
+        let y = pt1.y - pt2.y;
+        let z = pt1.z - pt2.z;
+        return Math.sqrt(x * x + y * y + z * z);
+    }
+    static squareDistance(pt1, pt2) {
+        let x = pt1.x - pt2.x;
+        let y = pt1.y - pt2.y;
+        let z = pt1.z - pt2.z;
+        return x * x + y * y + z * z;
+    }
+    static distanceXZ(pt1, pt2) {
+        let x = pt1.x - pt2.x;
+        let y = 0;
+        let z = pt1.z - pt2.z;
+        return Math.sqrt(x * x + y * y + z * z);
+    }
+    set(x, y, z, w = 1) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+    add(a, target = null) {
+        target ||= new Vector3();
+        let a0x = this.x;
+        let a0y = this.y;
+        let a0z = this.z;
+        let a0w = this.w;
+        let a1x = a.x;
+        let a1y = a.y;
+        let a1z = a.z;
+        let a1w = a.w;
+        target.setTo(a0x + a1x, a0y + a1y, a0z + a1z, a0w + a1w);
+        return target;
+    }
+    subVectors(a, b) {
+        this.x = a.x - b.x;
+        this.y = a.y - b.y;
+        this.z = a.z - b.z;
+        return this;
+    }
+    addScalar(scalar) {
+        this.x += scalar;
+        this.y += scalar;
+        this.z += scalar;
+        return this;
+    }
+    subScalar(scalar) {
+        this.x -= scalar;
+        this.y -= scalar;
+        this.z -= scalar;
+        return this;
+    }
+    min(v, target = this) {
+        target.x = Math.min(this.x, v.x);
+        target.y = Math.min(this.y, v.y);
+        target.z = Math.min(this.z, v.z);
+        return target;
+    }
+    max(v, target = this) {
+        target.x = Math.max(this.x, v.x);
+        target.y = Math.max(this.y, v.y);
+        target.z = Math.max(this.z, v.z);
+        return target;
+    }
+    distanceToSquared(v) {
+        let dx = this.x - v.x;
+        let dy = this.y - v.y;
+        let dz = this.z - v.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    addXYZW(x, y, z, w, target = null) {
+        target ||= new Vector3();
+        let a0x = this.x;
+        let a0y = this.y;
+        let a0z = this.z;
+        let a0w = this.w;
+        let a1x = x;
+        let a1y = y;
+        let a1z = z;
+        let a1w = w;
+        target.setTo(a0x + a1x, a0y + a1y, a0z + a1z, a0w + a1w);
+        return target;
+    }
+    clone() {
+        return new Vector3(this.x, this.y, this.z, this.w);
+    }
+    copyFrom(src) {
+        let v = this;
+        v.x = src.x;
+        v.y = src.y;
+        v.z = src.z;
+        v.w = src.w;
+        return v;
+    }
+    decrementBy(a) {
+        this.x -= a.x;
+        this.y -= a.y;
+        this.z -= a.z;
+    }
+    dotProduct(a) {
+        return this.x * a.x + this.y * a.y + this.z * a.z;
+    }
+    equals(toCompare, allFour = false) {
+        return (this.x == toCompare.x &&
+            this.y == toCompare.y &&
+            this.z == toCompare.z &&
+            (!allFour || this.w == toCompare.w));
+    }
+    incrementBy(a) {
+        this.x += a.x;
+        this.y += a.y;
+        this.z += a.z;
+    }
+    divide(v) {
+        if (v instanceof Vector3)
+            return new Vector3(this.x / v.x, this.y / v.y, this.z / v.z);
+        else {
+            this.x = this.x / v;
+            this.y = this.y / v;
+            this.z = this.z / v;
+        }
+        return this;
+    }
+    negate() {
+        this.x = -this.x;
+        this.y = -this.y;
+        this.z = -this.z;
+        return this;
+    }
+    normalize(thickness = 1) {
+        let self = this;
+        if (this.length != 0) {
+            let invLength = thickness / this.length;
+            this.x *= invLength;
+            this.y *= invLength;
+            this.z *= invLength;
+            return self;
+        }
+        return self;
+    }
+    applyQuaternion(q) {
+        const x = this.x, y = this.y, z = this.z;
+        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
+        // calculate quat * vector
+        const ix = qw * x + qy * z - qz * y;
+        const iy = qw * y + qz * x - qx * z;
+        const iz = qw * z + qx * y - qy * x;
+        const iw = -qx * x - qy * y - qz * z;
+        // calculate result * inverse quat
+        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+        return this;
+    }
+    applyMatrix4(m) {
+        return m.transformPoint(this, this);
+    }
+    scaleBy(s) {
+        this.x *= s;
+        this.y *= s;
+        this.z *= s;
+        return this;
+    }
+    mul(s) {
+        let v = new Vector3();
+        v.x = this.x * s;
+        v.y = this.y * s;
+        v.z = this.z * s;
+        return v;
+    }
+    scale(s) {
+        this.x *= s.x;
+        this.y *= s.y;
+        this.z *= s.z;
+        return this;
+    }
+    scaleToRef(s, ref) {
+        if (!ref) {
+            ref = new Vector3();
+        }
+        ref.x = this.x * s;
+        ref.y = this.y * s;
+        ref.z = this.z * s;
+        return ref;
+    }
+    setTo(xa, ya, za, wa = 1) {
+        this.x = xa;
+        this.y = ya;
+        this.z = za;
+        this.w = wa;
+    }
+    copy(src) {
+        this.x = src.x;
+        this.y = src.y;
+        this.z = src.z;
+        this.w = src.w;
+        return this;
+    }
+    subtract(a, target = null) {
+        if (!target) {
+            target = new Vector3();
+        }
+        target.setTo(this.x - a.x, this.y - a.y, this.z - a.z);
+        return target;
+    }
+    multiply(other, target = null) {
+        if (!target) {
+            target = new Vector3();
+        }
+        let x0 = this.x;
+        let y0 = this.y;
+        let z0 = this.z;
+        let x1 = other.x;
+        let y1 = other.y;
+        let z1 = other.z;
+        target.setTo(x0 * x1, y0 * y1, z0 * z1);
+        return target;
+    }
+    divided(other, target = null) {
+        if (!target) {
+            target = new Vector3();
+        }
+        let x0 = this.x;
+        let y0 = this.y;
+        let z0 = this.z;
+        let x1 = other.x;
+        let y1 = other.y;
+        let z1 = other.z;
+        target.setTo(x0 / x1, y0 / y1, z0 / z1);
+        return target;
+    }
+    div(v, target) {
+        if (!target) {
+            target = new Vector3();
+        }
+        let x0 = this.x;
+        let y0 = this.y;
+        let z0 = this.z;
+        let w0 = this.w;
+        target.setTo(x0 / v, y0 / v, z0 / v, w0 / v);
+        return target;
+    }
+    lerp(v0, v1, t) {
+        let v0x = v0.x, v0y = v0.y, v0z = v0.z, v0w = v0.w;
+        let v1x = v1.x, v1y = v1.y, v1z = v1.z, v1w = v1.w;
+        this.x = (v1x - v0x) * t + v0x;
+        this.y = (v1y - v0y) * t + v0y;
+        this.z = (v1z - v0z) * t + v0z;
+        this.w = (v1w - v0w) * t + v0w;
+    }
+    clamp(min, max) {
+        this.x = Math.max(min.x, Math.min(max.x, this.x));
+        this.y = Math.max(min.y, Math.min(max.y, this.y));
+        this.z = Math.max(min.z, Math.min(max.z, this.z));
+        return this;
+    }
+    toString() {
+        return "<" + this.x + ", " + this.y + ", " + this.z + ">";
+    }
+    normalizeToWay2D_XY() {
+        let tx = Math.abs(this.x);
+        let ty = Math.abs(this.y);
+        if (tx > ty) {
+            if (this.x > 0) {
+                this.copyFrom(Vector3.RIGHT);
+            }
+            else {
+                this.copyFrom(Vector3.LEFT);
+            }
+        }
+        else {
+            if (this.y > 0) {
+                this.copyFrom(Vector3.DOWN);
+            }
+            else {
+                this.copyFrom(Vector3.UP);
+            }
+        }
+    }
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+    copyToBytes(byte) {
+        byte.setFloat32(0 * Float32Array.BYTES_PER_ELEMENT, this.x, true);
+        byte.setFloat32(1 * Float32Array.BYTES_PER_ELEMENT, this.y, true);
+        byte.setFloat32(2 * Float32Array.BYTES_PER_ELEMENT, this.z, true);
+    }
+    crossProduct(a, target = null) {
+        target = target || new Vector3();
+        target.x = this.y * a.z - this.z * a.y;
+        target.y = this.z * a.x - this.x * a.z;
+        target.z = this.x * a.y - this.y * a.x;
+        target.w = 1;
+        return target;
+    }
+    crossVectors(a, b) {
+        a.crossProduct(b, this);
+        return this;
+    }
+    multiplyScalar(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+    }
+    setFromArray(array, firstElementPos = 0) {
+        this.x = array[firstElementPos];
+        this.y = array[firstElementPos + 1];
+        this.z = array[firstElementPos + 2];
+    }
+    divideScalar(scalar) {
+        return this.multiplyScalar(1 / scalar);
+    }
+    clampLength(min, max) {
+        let length = this.length;
+        return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+    }
+    setScalar(value) {
+        this.x = value;
+        this.y = value;
+        this.z = value;
+        return this;
+    }
+    addScaledVector(v, scale) {
+        this.x += v.x * scale;
+        this.y += v.y * scale;
+        this.z += v.z * scale;
+        return this;
+    }
+    static calAngle(cx, cy, x, y) {
+        const radian = getCosBy2pt(x, y, cx, cy);
+        let angle = (Math.acos(radian) * 180) / Math.PI;
+        if (x < cx)
+            angle = -angle;
+        return angle;
+        // Calculate the vector formed by point 1 and point 2
+        function getCosBy2pt(x, y, cx, cy) {
+            // Dot product formula
+            let a = [x - cx, y - cy];
+            let b = [0, -1];
+            return calCos(a, b);
+        }
+        function calCos(a, b) {
+            let dotProduct = a[0] * b[0] + a[1] * b[1];
+            let d = Math.sqrt(a[0] * a[0] + a[1] * a[1]) *
+                Math.sqrt(b[0] * b[0] + b[1] * b[1]);
+            return dotProduct / d;
+        }
+    }
+    static pointInsideTriangle(pt, pt0, pt1, pt2) {
+        Vector3.HELP_0.setTo(pt.x, pt.z, 0);
+        Vector3.HELP_1.setTo(pt0.x, pt0.z, 0);
+        Vector3.HELP_2.setTo(pt1.x, pt1.z, 0);
+        Vector3.HELP_3.setTo(pt2.x, pt2.z, 0);
+        return Vector3.pointInsideTriangle2d();
+    }
+    static pointInsideTriangle2d() {
+        if (Vector3.productXY(Vector3.HELP_1, Vector3.HELP_2, Vector3.HELP_3) >= 0) {
+            return (Vector3.productXY(Vector3.HELP_1, Vector3.HELP_2, Vector3.HELP_0) >=
+                0 &&
+                Vector3.productXY(Vector3.HELP_2, Vector3.HELP_3, Vector3.HELP_0) >=
+                    0 &&
+                Vector3.productXY(Vector3.HELP_3, Vector3.HELP_1, Vector3.HELP_0) >= 0);
+        }
+        else {
+            return (Vector3.productXY(Vector3.HELP_1, Vector3.HELP_2, Vector3.HELP_0) <=
+                0 &&
+                Vector3.productXY(Vector3.HELP_2, Vector3.HELP_3, Vector3.HELP_0) <=
+                    0 &&
+                Vector3.productXY(Vector3.HELP_3, Vector3.HELP_1, Vector3.HELP_0) <= 0);
+        }
+    }
+    static productXY(p1, p2, p3) {
+        var val = (p1.x - p3.x) * (p2.y - p3.y) - (p1.y - p3.y) * (p2.x - p3.x);
+        if (val > -0.00001 && val < 0.00001)
+            val = 0;
+        return val;
+    }
+    static serialize(position) {
+        let v = new Vector3(position.x, position.y, position.z, position.w);
+        return v;
+    }
+}

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

@@ -0,0 +1,34 @@
+export declare class Vector4 {
+    static X_AXIS: Vector4;
+    static Y_AXIS: Vector4;
+    static Z_AXIS: Vector4;
+    static HELP_0: Vector4;
+    static HELP_1: Vector4;
+    static HELP_2: Vector4;
+    static EPSILON: number;
+    static HELP_3: Vector4;
+    static HELP_4: Vector4;
+    static HELP_5: Vector4;
+    static HELP_6: Vector4;
+    static ZERO: Vector4;
+    static ONE: Vector4;
+    static LEFT: Vector4;
+    static RIGHT: Vector4;
+    static UP: Vector4;
+    static DOWN: Vector4;
+    static BACK: Vector4;
+    static FORWARD: Vector4;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    get width(): number;
+    get height(): number;
+    static crossVectors(a: Vector4, b: Vector4, target?: Vector4): Vector4;
+    static distance(pt1: Vector4, pt2: Vector4): number;
+    set(x: number, y: number, z: number, w: number): this;
+    multiplyScalar(scalar: number): this;
+    copyFrom(v: Vector4): this;
+    clone(): Vector4;
+}

package/dist/src/math/Vector4.js

@@ -0,0 +1,77 @@
+export class Vector4 {
+    static { this.X_AXIS = new Vector4(1, 0, 0); }
+    static { this.Y_AXIS = new Vector4(0, 1, 0); }
+    static { this.Z_AXIS = new Vector4(0, 0, 1); }
+    static { this.HELP_0 = new Vector4(); }
+    static { this.HELP_1 = new Vector4(); }
+    static { this.HELP_2 = new Vector4(); }
+    static { this.EPSILON = 0.00001; }
+    static { this.HELP_3 = new Vector4(); }
+    static { this.HELP_4 = new Vector4(); }
+    static { this.HELP_5 = new Vector4(); }
+    static { this.HELP_6 = new Vector4(); }
+    static { this.ZERO = new Vector4(); }
+    static { this.ONE = new Vector4(1, 1, 1, 1); }
+    static { this.LEFT = new Vector4(-1, 0, 0); }
+    static { this.RIGHT = new Vector4(1, 0, 0); }
+    static { this.UP = new Vector4(0, -1, 0); }
+    static { this.DOWN = new Vector4(0, 1, 0); }
+    static { this.BACK = new Vector4(0, 0, -1); }
+    static { this.FORWARD = new Vector4(0, 0, 1); }
+    constructor(x = 0, y = 0, z = 0, w = 0) {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.w = 1;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    get width() {
+        return this.z;
+    }
+    get height() {
+        return this.w;
+    }
+    static crossVectors(a, b, target) {
+        target = target || new Vector4();
+        var ax = a.x, ay = a.y, az = a.z;
+        var bx = b.x, by = b.y, bz = b.z;
+        target.x = ay * bz - az * by;
+        target.y = az * bx - ax * bz;
+        target.z = ax * by - ay * bx;
+        return target;
+    }
+    static distance(pt1, pt2) {
+        let x = pt1.x - pt2.x;
+        let y = pt1.y - pt2.y;
+        let z = pt1.z - pt2.z;
+        let w = pt1.w - pt2.w;
+        return Math.sqrt(x * x + y * y + z * z + w * w);
+    }
+    set(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+    multiplyScalar(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        this.w *= scalar;
+        return this;
+    }
+    copyFrom(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        this.w = v.w;
+        return this;
+    }
+    clone() {
+        return new Vector4(this.x, this.y, this.z, this.w);
+    }
+}

package/dist/src/math/enum/FrameCache.d.ts

@@ -0,0 +1,6 @@
+export declare class FrameCache {
+    index: number;
+    time: number;
+    timeEnd: number;
+    coeff: number[];
+}

package/dist/src/math/enum/FrameCache.js

@@ -0,0 +1,5 @@
+export class FrameCache {
+    constructor() {
+        this.coeff = []; //= lhsIndex;
+    }
+}

package/dist/src/math/enum/Keyframe.d.ts

@@ -0,0 +1,14 @@
+export declare class Keyframe {
+    serializedVersion: string;
+    time: number;
+    value: number;
+    inSlope: number;
+    outSlope: number;
+    tangentMode: number;
+    weightedMode: number;
+    inWeight: number;
+    outWeight: number;
+    constructor(time?: number, value?: number);
+    unSerialized(data: any): void;
+    unSerialized2(data: any): void;
+}