@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/TimeInterpolator.js

@@ -0,0 +1,334 @@
+export class AccelerateInterpolator {
+    constructor() {
+        this._factor = 1.0;
+        this._doubleFactor = 2.0;
+    }
+    get accelerateInterpolator() {
+        return this._factor;
+    }
+    set accelerateInterpolator(factor) {
+        this._factor = factor;
+        this._doubleFactor = 2 * this._factor;
+    }
+    getInterpolation(input) {
+        if (this._factor == 1.0) {
+            return input * input;
+        }
+        else {
+            return Math.pow(input, this._doubleFactor);
+        }
+    }
+}
+export class DecelerateInterpolator {
+    constructor() {
+        this._factor = 1.0;
+    }
+    get decelerateInterpolator() {
+        return this._factor;
+    }
+    set decelerateInterpolator(factor) {
+        this._factor = factor;
+    }
+    getInterpolation(input) {
+        let result;
+        if (this._factor == 1.0) {
+            result = 1.0 - (1.0 - input) * (1.0 - input);
+        }
+        else {
+            result = 1.0 - Math.pow(1.0 - input, 2 * this._factor);
+        }
+        return result;
+    }
+}
+export class AccelerateDecelerateInterpolator {
+    constructor() {
+        this._factor = 1.0;
+    }
+    getInterpolation(input) {
+        return Math.cos((input + 1) * Math.PI) / 2.0 + 0.5;
+    }
+}
+export class LinearInterpolator {
+    getInterpolation(input) {
+        return input;
+    }
+}
+export class JumperInterpolator {
+    getInterpolation(t) {
+        return 4.9 * t + 4.9 * t;
+    }
+}
+export class BounceInterpolator {
+    constructor() { }
+    static bounce(t) {
+        return t * t * 9.8;
+    }
+    getInterpolation(t) {
+        t *= 1.1226;
+        if (t < 0.3535)
+            return BounceInterpolator.bounce(t);
+        else if (t < 0.7408)
+            return BounceInterpolator.bounce(t - 0.54719) + 0.7;
+        else if (t < 0.9644)
+            return BounceInterpolator.bounce(t - 0.8526) + 0.9;
+        else
+            return BounceInterpolator.bounce(t - 1.0435) + 0.95;
+    }
+    getBounceInterpolation(t) {
+        if (t < 0.5)
+            return BounceInterpolator.bounce(t);
+        else
+            return BounceInterpolator.bounce(t - 1.0);
+    }
+    geJumpUp(v0, t) {
+        if (t < 0.5) {
+            t = t / 0.5;
+            return v0 * t - BounceInterpolator.bounce(t);
+        }
+        else if (t < 0.8) {
+            t = (t - 0.5) / (0.8 - 0.5);
+            return (v0 * t - BounceInterpolator.bounce(t)) * 0.3;
+        }
+        else if (t < 1) {
+            t = (t - 0.8) / (1 - 0.8);
+            return (v0 * t - BounceInterpolator.bounce(t)) * 0.15;
+        }
+        else
+            return v0 * t - BounceInterpolator.bounce(t);
+    }
+}
+export class AnticipateInterpolator {
+    constructor() {
+        this._tension = 2.0;
+    }
+    get anticipateInterpolator() {
+        return this._tension;
+    }
+    set anticipateInterpolator(tension) {
+        this._tension = tension;
+    }
+    getInterpolation(t) {
+        return t * t * ((this._tension + 1) * t - this._tension);
+    }
+}
+export class AnticipateOvershootInterpolator {
+    constructor() {
+        this._tension = 1.0 * 1.5;
+    }
+    anticipateOvershootInterpolator(tension) {
+        this._tension = tension * 1.5;
+    }
+    anticipateOvershootInterpolator2(tension, extraTension) {
+        this._tension = tension * extraTension;
+    }
+    getInterpolation(t) {
+        if (t < 0.5)
+            return 0.5 * AnticipateOvershootInterpolator.a(t * 2.0, this._tension);
+        else
+            return (0.5 *
+                (AnticipateOvershootInterpolator.o(t * 2.0 - 2.0, this._tension) + 2.0));
+    }
+    static a(t, s) {
+        return t * t * ((s + 1) * t - s);
+    }
+    static o(t, s) {
+        return t * t * ((s + 1) * t + s);
+    }
+}
+export class CycleInterpolator {
+    constructor(cycles) {
+        this._cycles = cycles;
+    }
+    getInterpolation(t) {
+        return Math.sin(2 * this._cycles * Math.PI * t);
+    }
+}
+export class OvershootInterpolator {
+    constructor() {
+        this._tension = 2.0;
+    }
+    getInterpolation(t) {
+        t -= 1.0;
+        return t * t * ((this._tension + 1) * t + this._tension) + 1.0;
+    }
+}
+export var InterpolatorEnum;
+(function (InterpolatorEnum) {
+    /**
+     * Acceleration interpolator, animation acceleration runs to the end.
+     */
+    InterpolatorEnum[InterpolatorEnum["AccelerateInterpolator"] = 0] = "AccelerateInterpolator";
+    /**
+     * Slow down interpolator, animation slow down run to end.
+     */
+    InterpolatorEnum[InterpolatorEnum["DecelerateInterpolator"] = 1] = "DecelerateInterpolator";
+    /**
+     * Acceleration and deceleration interpolator, animation first speed up and then decelerate.
+     */
+    InterpolatorEnum[InterpolatorEnum["AccelerateDecelerateInterpolator"] = 2] = "AccelerateDecelerateInterpolator";
+    /**
+     * Linear interpolator, animation uniform motion.
+     */
+    InterpolatorEnum[InterpolatorEnum["LinearInterpolator"] = 3] = "LinearInterpolator";
+    /**
+     * Elastic interpolator, before the end of the animation will have an elastic animation effect.
+     */
+    InterpolatorEnum[InterpolatorEnum["BounceInterpolator"] = 4] = "BounceInterpolator";
+    /**
+     * Step back and then speed up to the end.
+     */
+    InterpolatorEnum[InterpolatorEnum["AnticipateInterpolator"] = 5] = "AnticipateInterpolator";
+    /**
+     * Take a small step back, then speed up, then go a little beyond the finish line and then come back.
+     */
+    InterpolatorEnum[InterpolatorEnum["AnticipateOvershootInterpolator"] = 6] = "AnticipateOvershootInterpolator";
+    /**
+     * Cyclic motion
+     */
+    InterpolatorEnum[InterpolatorEnum["CycleInterpolator"] = 7] = "CycleInterpolator";
+    /**
+     * Finish the animation quickly, go a little beyond the end point and then go back to the end point.
+     */
+    InterpolatorEnum[InterpolatorEnum["OvershootInterpolator"] = 8] = "OvershootInterpolator";
+    /**
+     * @internal
+     */
+    InterpolatorEnum[InterpolatorEnum["JumperInterpolator"] = 9] = "JumperInterpolator";
+})(InterpolatorEnum || (InterpolatorEnum = {}));
+export class Interpolator {
+    constructor() {
+        /**
+         * @internal
+         */
+        this.complete = false;
+        /**
+         * @internal
+         */
+        this.delayTime = 0;
+        this._ct = 0;
+        this._p = 0;
+    }
+    /**
+     * @internal
+     */
+    static { this.interpolators = []; }
+    /**
+     * Creates an animation from the current property to the specified target property.
+     * @param target Objects that need to be animated
+     * @param property Animation parameter
+     * @param durtion Animation duration, usually seconds
+     * @param interpolatorEnum Interpolator type
+     * @returns
+     */
+    static to(target, property, durtion, interpolatorEnum = InterpolatorEnum.AccelerateInterpolator) {
+        let pro;
+        var interpolator = new Interpolator();
+        interpolator.target = target;
+        interpolator.property = property;
+        interpolator.durtion = durtion;
+        interpolator.interpolatorEnum = interpolatorEnum;
+        interpolator.start();
+        interpolator.delayTime = property["delayTime"] ? property["delayTime"] : 0;
+        if (property["onComplete"])
+            interpolator.onComplete = property["onComplete"];
+        if (property["onProgress"])
+            interpolator.onProgress = property["onProgress"];
+        this.interpolators.push(interpolator);
+        return interpolator;
+    }
+    /**
+     * @internal
+     */
+    static tick(delta) {
+        let interpolators = Interpolator.interpolators;
+        for (let inter of interpolators) {
+            if (inter.complete) {
+                Interpolator.remove(inter, true);
+            }
+            else {
+                inter.tick(delta);
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    static remove(interpolator, dispose) {
+        let interpolators = Interpolator.interpolators;
+        let index = interpolators.indexOf(interpolator);
+        if (index != -1)
+            interpolators.splice(index, 1);
+        if (dispose)
+            interpolator.dispose();
+    }
+    static removeList(interpolators, dispose) {
+        interpolators.forEach((v) => {
+            this.remove(v, dispose);
+        });
+    }
+    /**
+     * @internal
+     */
+    start() {
+        window["AccelerateInterpolator"] = AccelerateInterpolator;
+        window["DecelerateInterpolator"] = DecelerateInterpolator;
+        window["AccelerateDecelerateInterpolator"] =
+            AccelerateDecelerateInterpolator;
+        window["LinearInterpolator"] = LinearInterpolator;
+        window["BounceInterpolator"] = BounceInterpolator;
+        window["AnticipateInterpolator"] = AnticipateInterpolator;
+        window["AnticipateOvershootInterpolator"] = AnticipateOvershootInterpolator;
+        window["CycleInterpolator"] = CycleInterpolator;
+        window["OvershootInterpolator"] = OvershootInterpolator;
+        window["JumperInterpolator"] = JumperInterpolator;
+        this._interpolator = new window[InterpolatorEnum[this.interpolatorEnum]]();
+        this.targetProperty = {};
+        for (let p in this.property) {
+            this.targetProperty[p] = this.target[p];
+        }
+    }
+    /**
+     * @internal
+     */
+    tick(delta) {
+        if (this.delayTime <= 0) {
+            this._p = Math.min(this._ct / this.durtion, 1.0);
+            let v = this._interpolator.getInterpolation(this._p);
+            let property = this.property;
+            let target = this.target;
+            let targetProperty = this.targetProperty;
+            let ct;
+            let tt;
+            for (let p in property) {
+                tt = property[p];
+                ct = targetProperty[p];
+                target[p] = ct + (tt - ct) * v;
+            }
+            if (this.onProgress != null)
+                this.onProgress(this._p);
+            if (this._ct >= this.durtion) {
+                this.complete = true;
+                if (this.onComplete != null) {
+                    this.onComplete(this.target);
+                }
+            }
+            this._ct += delta;
+        }
+        else {
+            this.delayTime -= delta;
+        }
+    }
+    /**
+     * @internal
+     */
+    dispose() {
+        this.onComplete = null;
+        this.onProgress = null;
+        this.target = null;
+        this.property = null;
+        this.targetProperty = null;
+        this.interpolatorEnum = null;
+        this._interpolator = null;
+        Interpolator.remove(this);
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Line } from "./Line";
+import { Vector2 } from "./Vector2";
+import { Vector3 } from "./Vector3";
+export declare class Triangle {
+    static ID: number;
+    v1: Vector3;
+    v2: Vector3;
+    v3: Vector3;
+    u1: Vector2;
+    u2: Vector2;
+    u3: Vector2;
+    n1: Vector3;
+    n2: Vector3;
+    n3: Vector3;
+    t0: number;
+    t: number;
+    u: number;
+    v: number;
+    min: Vector3;
+    max: Vector3;
+    id: number;
+    constructor(v1?: Vector3, v2?: Vector3, v3?: Vector3);
+    set(v1: Vector3, v2: Vector3, v3: Vector3): this;
+    getNormal(): Vector3;
+    turnBack(): void;
+    getLines(): Line[];
+    equals(t: Triangle): boolean;
+    getCenter(): Vector3;
+    intersects(other: Triangle): boolean;
+    sign2D(p1: Vector3, p2: Vector3, p3: Vector3): number;
+    pointInTriangle2D(pt: Vector3): boolean;
+    toArray(): number[];
+}

package/dist/src/math/Triangle.js

@@ -0,0 +1,113 @@
+import { Line } from "./Line";
+import { Vector3 } from "./Vector3";
+export class Triangle {
+    static { this.ID = -1; }
+    constructor(v1, v2, v3) {
+        this.min = new Vector3();
+        this.max = new Vector3();
+        this.id = 0;
+        this.id = Triangle.ID++ + 200;
+        v1 && v2 && v3 && this.set(v1, v2, v3);
+    }
+    set(v1, v2, v3) {
+        this.v1 = v1;
+        this.v2 = v2;
+        this.v3 = v3;
+        let min = this.min;
+        let max = this.max;
+        min.x = Math.min(this.v1.x, this.v2.x, this.v3.x);
+        min.y = Math.min(this.v1.y, this.v2.y, this.v3.y);
+        min.z = Math.min(this.v1.z, this.v2.z, this.v3.z);
+        max.x = Math.max(this.v1.x, this.v2.x, this.v3.x);
+        max.y = Math.max(this.v1.y, this.v2.y, this.v3.y);
+        max.z = Math.max(this.v1.z, this.v2.z, this.v3.z);
+        return this;
+    }
+    getNormal() {
+        let v1 = this.v1;
+        let v2 = this.v2;
+        let v3 = this.v3;
+        let edge1 = new Vector3(v2.x - v1.x, v2.y - v1.y, v2.z - v1.z);
+        let edge2 = new Vector3(v3.x - v1.x, v3.y - v1.y, v3.z - v1.z);
+        let normal = edge2.crossProduct(edge1);
+        normal.normalize();
+        return normal;
+    }
+    turnBack() {
+        let tmp = this.v3;
+        this.v3 = this.v1;
+        this.v1 = tmp;
+    }
+    getLines() {
+        let v1 = this.v1;
+        let v2 = this.v2;
+        let v3 = this.v3;
+        let l = [new Line(v1, v2), new Line(v2, v3), new Line(v3, v1)];
+        return l;
+    }
+    equals(t) {
+        let lines1 = this.getLines();
+        let lines2 = t.getLines();
+        let cnt = 0;
+        for (let i = 0; i < lines1.length; i++) {
+            for (let j = 0; j < lines2.length; j++) {
+                if (lines1[i].equals(lines2[j]))
+                    cnt++;
+            }
+        }
+        if (cnt == 3)
+            return true;
+        else
+            return false;
+    }
+    getCenter() {
+        let min = this.min;
+        let max = this.max;
+        let center = new Vector3();
+        center.x = (min.x + max.x) * 0.5;
+        center.y = (min.y + max.y) * 0.5;
+        center.z = (min.z + max.z) * 0.5;
+        return center;
+    }
+    intersects(other) {
+        var aMax = this.max;
+        var aMin = this.min;
+        var bMax = other.max;
+        var bMin = other.min;
+        return (aMin.x <= bMax.x &&
+            aMax.x >= bMin.x &&
+            aMin.y <= bMax.y &&
+            aMax.y >= bMin.y &&
+            aMin.z <= bMax.z &&
+            aMax.z >= bMin.z);
+    }
+    sign2D(p1, p2, p3) {
+        return (p1.x - p3.x) * (p2.z - p3.z) - (p2.x - p3.x) * (p1.z - p3.z);
+    }
+    pointInTriangle2D(pt) {
+        let v1 = this.v1;
+        let v2 = this.v2;
+        let v3 = this.v3;
+        let d1, d2, d3;
+        let has_neg, has_pos;
+        d1 = this.sign2D(pt, v1, v2);
+        d2 = this.sign2D(pt, v2, v3);
+        d3 = this.sign2D(pt, v3, v1);
+        has_neg = d1 < 0 || d2 < 0 || d3 < 0;
+        has_pos = d1 > 0 || d2 > 0 || d3 > 0;
+        return !(has_neg && has_pos);
+    }
+    toArray() {
+        return [
+            this.v1.x,
+            this.v1.y,
+            this.v1.z,
+            this.v2.x,
+            this.v2.y,
+            this.v2.z,
+            this.v3.x,
+            this.v3.y,
+            this.v3.z,
+        ];
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Vector4 } from "..";
+import { Vector2 } from "./Vector2";
+export declare class UV extends Vector2 {
+    static uv_0: UV;
+    u: number;
+    v: number;
+    constructor(x?: number, y?: number);
+    length(): number;
+    static getUVSheet(frame: number, countX: number, countY: number): Vector4;
+}

package/dist/src/math/UV.js

@@ -0,0 +1,21 @@
+import { Vector4 } from "..";
+import { Vector2 } from "./Vector2";
+export class UV extends Vector2 {
+    static { this.uv_0 = new UV(); }
+    constructor(x = 0, y = 0) {
+        super(x, y);
+        this.u = 0.0;
+        this.v = 0.0;
+        this.u = x;
+        this.v = y;
+    }
+    length() {
+        return 0;
+    }
+    static getUVSheet(frame, countX, countY) {
+        let f = Math.floor(frame % (countX * countY));
+        let fx = Math.floor(f / countX);
+        let fy = f % countX;
+        return new Vector4(fx / countX, fy / countY, 1 / countX, 1 / countY);
+    }
+}

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

@@ -0,0 +1,38 @@
+export declare class Vector2 {
+    static HELP_0: Vector2;
+    static HELP_1: Vector2;
+    static HELP_2: Vector2;
+    static readonly ZERO: Vector2;
+    static readonly SAFE_MAX: Vector2;
+    static readonly SAFE_MIN: Vector2;
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    static getAngle(a: Vector2, b: Vector2): number;
+    static slerp(from: Vector2, to: Vector2, t: number): Vector2;
+    static lerp(from: Vector2, to: Vector2, t: number): Vector2;
+    set(x?: number, y?: number): this;
+    distance(a: Vector2): number;
+    add(a: Vector2, target?: Vector2): Vector2;
+    sub(a: Vector2, target?: Vector2): Vector2;
+    scale(v: number): this;
+    multiply(a: number, target?: Vector2): Vector2;
+    multiplyScaler(a: number): this;
+    divide(v: number, target?: Vector2): Vector2;
+    neg(target?: Vector2): Vector2;
+    abs(): number;
+    length(): number;
+    getAngle(target: Vector2): number;
+    unt(target?: Vector2): Vector2;
+    angleTo(v: Vector2): number;
+    equals(a: Vector2): boolean;
+    pal(a: Vector2): number;
+    clone(): Vector2;
+    copyFrom(v: Vector2): Vector2;
+    addScaledVector(v: Vector2, size: number): Vector2;
+    dot(value: Vector2): number;
+    normalize(): this;
+    addInPlace(otherVector: Vector2): this;
+    addScalar(s: number): this;
+    clampScalar(minVal: number, maxVal: number): this;
+}