@rings-webgpu/core 1.0.1 → 1.0.2

package/dist/src/math/Vector2.js

@@ -0,0 +1,166 @@
+export class Vector2 {
+    static { this.HELP_0 = new Vector2(); }
+    static { this.HELP_1 = new Vector2(); }
+    static { this.HELP_2 = new Vector2(); }
+    static { this.ZERO = new Vector2(0, 0); }
+    static { this.SAFE_MAX = new Vector2(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); }
+    static { this.SAFE_MIN = new Vector2(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER); }
+    constructor(x = 0, y = 0) {
+        this.x = 0.0;
+        this.y = 0.0;
+        this.x = x;
+        this.y = y;
+    }
+    static getAngle(a, b) {
+        return Math.atan2(b.y - a.y, b.x - a.x);
+    }
+    static slerp(from, to, t) {
+        let v = new Vector2();
+        let dot = from.dot(to);
+        if (dot < 0) {
+            to.x = -to.x;
+            to.y = -to.y;
+            dot = -dot;
+        }
+        if (dot > 0.9995) {
+            v.x = from.x + t * (to.x - from.x);
+            v.y = from.y + t * (to.y - from.y);
+            return v;
+        }
+        let theta = Math.acos(dot);
+        let sinTheta = Math.sin(theta);
+        let scale0 = Math.sin((1 - t) * theta) / sinTheta;
+        let scale1 = Math.sin(t * theta) / sinTheta;
+        v.x = scale0 * from.x + scale1 * to.x;
+        v.y = scale0 * from.y + scale1 * to.y;
+        return v;
+    }
+    static lerp(from, to, t) {
+        Vector2.HELP_0.copyFrom(from);
+        Vector2.HELP_1.copyFrom(to);
+        Vector2.HELP_0.scale(t);
+        Vector2.HELP_1.scale(1.0 - t);
+        return new Vector2(Vector2.HELP_0.x + Vector2.HELP_1.x, Vector2.HELP_0.y + Vector2.HELP_1.y);
+    }
+    set(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    distance(a) {
+        return Math.sqrt(Math.pow(this.x - a.x, 2) + Math.pow(this.y - a.y, 2));
+    }
+    add(a, target) {
+        target = target || new Vector2();
+        target.x = this.x + a.x;
+        target.y = this.y + a.y;
+        return target;
+    }
+    sub(a, target) {
+        target = target || new Vector2();
+        target.x = this.x - a.x;
+        target.y = this.y - a.y;
+        return target;
+    }
+    scale(v) {
+        this.x = this.x * v;
+        this.y = this.y * v;
+        return this;
+    }
+    multiply(a, target) {
+        target = target || new Vector2();
+        target.x = this.x * a;
+        target.y = this.y * a;
+        return target;
+    }
+    multiplyScaler(a) {
+        this.x *= a;
+        this.y *= a;
+        return this;
+    }
+    divide(v, target) {
+        target = target || new Vector2();
+        target.x = this.x / v;
+        target.y = this.y / v;
+        return target;
+    }
+    neg(target) {
+        if (!target)
+            target = new Vector2();
+        target.x = -target.x;
+        target.y = -target.y;
+        return target;
+    }
+    abs() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    getAngle(target) {
+        return Math.atan2(target.y - this.y, target.x - this.x);
+    }
+    unt(target) {
+        target = target || new Vector2();
+        let d = this.abs();
+        target.x = this.x / d;
+        target.y = this.y / d;
+        return target;
+    }
+    angleTo(v) {
+        let dx = v.x - this.x;
+        let dy = v.y - this.y;
+        return Math.atan2(dy, dx);
+    }
+    equals(a) {
+        if (Math.abs(this.x - a.x) < 1e-6 && Math.abs(this.y - a.y) < 1e-6)
+            return true;
+        return false;
+    }
+    pal(a) {
+        let u1 = this.unt();
+        let u2 = a.unt();
+        if (u1.equals(u2))
+            return 1;
+        if (u1.equals(u2.neg()))
+            return -1;
+        return 0;
+    }
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+    copyFrom(v) {
+        this.x = v.x;
+        this.y = v.y;
+        return this;
+    }
+    addScaledVector(v, size) {
+        this.x += v.x * size;
+        this.y += v.y * size;
+        return this;
+    }
+    dot(value) {
+        return this.x * value.x + this.y * value.y;
+    }
+    normalize() {
+        let d = this.abs();
+        this.x = this.x / d;
+        this.y = this.y / d;
+        return this;
+    }
+    addInPlace(otherVector) {
+        this.x += otherVector.x;
+        this.y += otherVector.y;
+        return this;
+    }
+    addScalar(s) {
+        this.x += s;
+        this.y += s;
+        return this;
+    }
+    clampScalar(minVal, maxVal) {
+        this.x = Math.max(minVal, Math.min(maxVal, this.x));
+        this.y = Math.max(minVal, Math.min(maxVal, this.y));
+        return this;
+    }
+}

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

@@ -0,0 +1,107 @@
+export declare class Vector3 {
+    static readonly MAX: Vector3;
+    static readonly MIN: Vector3;
+    static readonly SAFE_MAX: Vector3;
+    static readonly SAFE_MIN: Vector3;
+    static readonly X_AXIS: Vector3;
+    static readonly neg_X_AXIS: Vector3;
+    static readonly Y_AXIS: Vector3;
+    static readonly Z_AXIS: Vector3;
+    static HELP_0: Vector3;
+    static HELP_1: Vector3;
+    static HELP_2: Vector3;
+    static readonly EPSILON: number;
+    static HELP_3: Vector3;
+    static HELP_4: Vector3;
+    static HELP_5: Vector3;
+    static HELP_6: Vector3;
+    static get ZERO(): Vector3;
+    static get ONE(): Vector3;
+    static get LEFT(): Vector3;
+    static get RIGHT(): Vector3;
+    static get UP(): Vector3;
+    static get DOWN(): Vector3;
+    static get BACK(): Vector3;
+    static get FORWARD(): Vector3;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    index: number;
+    private static _index;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    set a(value: number);
+    set r(value: number);
+    set g(value: number);
+    set b(value: number);
+    get a(): number;
+    get r(): number;
+    get g(): number;
+    get b(): number;
+    get length(): number;
+    get lengthSquared(): number;
+    get position(): this;
+    static getTowPointbyDir(dir: Vector3, tp1: Vector3, tp2: Vector3, width: number, aix: Vector3): void;
+    static pointToLine(point1: Vector3, point2: Vector3, position: Vector3): number;
+    static dot(a: Vector3, b: Vector3): number;
+    static getPoints(total: number, randSeed: number): any[];
+    static getPointNumbers(total: number, randSeed: number): any[];
+    static getAngle(from: Vector3, to: Vector3): number;
+    static sqrMagnitude(arg0: Vector3): number;
+    static getZYAngle(zd: Vector3, yd: Vector3): number;
+    static sub(a: Vector3, b: Vector3, target?: Vector3): Vector3;
+    static add(a: Vector3, b: Vector3, target?: Vector3): Vector3;
+    static smoothDamp(current: Vector3, target: Vector3, currentVelocity: Vector3, smoothTime: number, maxSpeed: number, deltaTime: number): any;
+    static distance(pt1: Vector3, pt2: Vector3): number;
+    static squareDistance(pt1: Vector3, pt2: Vector3): number;
+    static distanceXZ(pt1: Vector3, pt2: Vector3): number;
+    set(x: number, y: number, z: number, w?: number): this;
+    add(a: Vector3, target?: Vector3): Vector3;
+    subVectors(a: Vector3, b: Vector3): this;
+    addScalar(scalar: number): Vector3;
+    subScalar(scalar: number): Vector3;
+    min(v: Vector3, target?: Vector3): Vector3;
+    max(v: Vector3, target?: Vector3): Vector3;
+    distanceToSquared(v: Vector3): number;
+    addXYZW(x: number, y: number, z: number, w: number, target?: Vector3): Vector3;
+    clone(): Vector3;
+    copyFrom(src: Vector3): Vector3;
+    decrementBy(a: Vector3): void;
+    dotProduct(a: Vector3): number;
+    equals(toCompare: Vector3, allFour?: boolean): boolean;
+    incrementBy(a: Vector3): void;
+    divide(v: any): Vector3;
+    negate(): this;
+    normalize(thickness?: number): Vector3;
+    applyQuaternion(q: any): this;
+    applyMatrix4(m: any): Vector3;
+    scaleBy(s: number): Vector3;
+    mul(s: number): Vector3;
+    scale(s: Vector3): Vector3;
+    scaleToRef(s: number, ref: Vector3): Vector3;
+    setTo(xa: number, ya: number, za: number, wa?: number): void;
+    copy(src: Vector3): this;
+    subtract(a: Vector3, target?: Vector3): Vector3;
+    multiply(other: Vector3, target?: Vector3): Vector3;
+    divided(other: Vector3, target?: Vector3): Vector3;
+    div(v: number, target?: Vector3): Vector3;
+    lerp(v0: Vector3, v1: Vector3, t: number): void;
+    clamp(min: Vector3, max: Vector3): Vector3;
+    toString(): string;
+    normalizeToWay2D_XY(): void;
+    toArray(): number[];
+    copyToBytes(byte: DataView): void;
+    crossProduct(a: Vector3, target?: Vector3): Vector3;
+    crossVectors(a: Vector3, b: Vector3): this;
+    multiplyScalar(scalar: number): this;
+    setFromArray(array: number[], firstElementPos?: number): void;
+    divideScalar(scalar: any): this;
+    clampLength(min: number, max: number): this;
+    setScalar(value: number): this;
+    addScaledVector(v: Vector3, scale: number): Vector3;
+    private static calAngle;
+    static pointInsideTriangle(pt: Vector3, pt0: Vector3, pt1: Vector3, pt2: Vector3): boolean;
+    private static pointInsideTriangle2d;
+    private static productXY;
+    static serialize(position: Vector3): Vector3;
+}