@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/math/TimeInterpolator.js

@@ -1,334 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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;
-}