@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/MathUtil.js

@@ -0,0 +1,480 @@
+import { Color } from "./Color";
+import { Matrix4 } from "./Matrix4";
+import { Quaternion } from "./Quaternion";
+import { Rand } from "./Rand";
+import { Vector2 } from "./Vector2";
+import { Vector3 } from "./Vector3";
+export let RADIANS_TO_DEGREES = 180 / Math.PI;
+export let DEGREES_TO_RADIANS = Math.PI / 180;
+export let MAX_VALUE = 0x7fffffff;
+export let MIN_VALUE = -0x7fffffff;
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export class MathUtil {
+    static gaussFunction(value, amplitude, center, rmsWidth) {
+        let numerator = Math.pow(value - center, 2);
+        let denominator = 2 * Math.pow(rmsWidth, 2);
+        let exp = -1 * (numerator / denominator);
+        let curve = Math.pow(Math.E, exp);
+        return Math.round(curve * amplitude);
+    }
+    static computeGaussian(n, theta) {
+        return ((1.0 / Math.sqrt(2 * Math.PI * theta)) *
+            Math.exp(-(n * n) / (2 * theta * theta)));
+    }
+    static gaussCoef(sigma) {
+        if (sigma < 0.5) {
+            sigma = 0.5;
+        }
+        let a = Math.exp(0.726 * 0.726) / sigma;
+        let g1 = Math.exp(-a);
+        let g2 = Math.exp(-2 * a);
+        let k = ((1 - g1) * (1 - g1)) / (1 + 2 * a * g1 - g2);
+        let a0 = k;
+        let a1 = k * (a - 1) * g1;
+        let a2 = k * (a + 1) * g1;
+        let a3 = -k * g2;
+        let b1 = 2 * g1;
+        let b2 = -g2;
+        let left_corner = (a0 + a1) / (1 - b1 - b2);
+        let right_corner = (a2 + a3) / (1 - b1 - b2);
+        // Attempt to force type to FP32.
+        return new Float32Array([
+            a0,
+            a1,
+            a2,
+            a3,
+            b1,
+            b2,
+            left_corner,
+            right_corner,
+        ]);
+    }
+    static clampf(value, min_inclusive, max_inclusive) {
+        if (min_inclusive > max_inclusive) {
+            let temp = min_inclusive;
+            min_inclusive = max_inclusive;
+            max_inclusive = temp;
+        }
+        return value < min_inclusive
+            ? min_inclusive
+            : value < max_inclusive
+                ? value
+                : max_inclusive;
+    }
+    static normalizeAngle(a) {
+        while (a > 180) {
+            a -= 360;
+        }
+        while (a < -180) {
+            a += 360;
+        }
+        return a;
+    }
+    static fract(v) {
+        return v - Math.floor(v);
+    }
+    static getRandDirXZ(r) {
+        let rr = r * Math.random();
+        let ra = 360 * Math.random() * DEGREES_TO_RADIANS;
+        let x = Math.cos(ra) * rr;
+        let z = Math.sin(ra) * rr;
+        return { x: x, z: z };
+    }
+    static getRandDirXYZ(r) {
+        let rr = r * Math.random();
+        let ra = 360 * Math.random() * DEGREES_TO_RADIANS;
+        let x = Math.cos(ra) * rr;
+        let y = Math.tan(ra) * rr;
+        let z = Math.sin(ra) * rr;
+        return new Vector3(x, y, z);
+    }
+    static getCycleXYZ(r) {
+        let rr = r * Math.random();
+        let ra = 360 * Math.random() * DEGREES_TO_RADIANS;
+        let x = Math.cos(ra) * rr;
+        let y = r * Math.random() - r * 0.5;
+        let z = Math.sin(ra) * rr;
+        return new Vector3(x, y, z);
+    }
+    static angle(p1, p2) {
+        let v1 = Vector2.HELP_0;
+        let v2 = Vector2.HELP_1;
+        v1.set(p1.x, p1.z);
+        v2.set(p2.x, p2.z);
+        return Math.acos((v1.x * v2.x + v1.y * v2.y) / (v1.abs() * v2.abs()));
+    }
+    static angle_360(from, to) {
+        let v3 = Vector3.HELP_0;
+        from.crossProduct(to, v3);
+        if (v3.z > 0) {
+            return MathUtil.angle(from, to);
+        }
+        else {
+            return 360 - MathUtil.angle(from, to);
+        }
+    }
+    getRotationY(v) {
+        let rot = MathUtil.normalizeAngle(Math.atan2(v.z, v.x) * RADIANS_TO_DEGREES); //- 90;
+        return rot;
+    }
+    static fromToRotation(fromDirection, toDirection, target = null) {
+        target ||= new Quaternion();
+        let mat = Matrix4.help_matrix_2;
+        Matrix4.fromToRotation(fromDirection, toDirection, mat);
+        target.fromMatrix(mat);
+        return target;
+    }
+    static getEularDir_yUp(v) {
+        let q = Quaternion.HELP_0;
+        q.fromEulerAngles(0, v, 0);
+        q.transformVector(Vector3.Z_AXIS, Vector3.HELP_5);
+        return Vector3.HELP_5;
+    }
+    static transformVector(matrix, vector, result = null) {
+        result ||= new Vector3();
+        let raw = matrix.rawData;
+        let a = raw[0];
+        let e = raw[1];
+        let i = raw[2];
+        let m = raw[3];
+        let b = raw[4];
+        let f = raw[5];
+        let j = raw[6];
+        let n = raw[7];
+        let c = raw[8];
+        let g = raw[9];
+        let k = raw[10];
+        let o = raw[11];
+        let d = raw[12];
+        let h = raw[13];
+        let l = raw[14];
+        let p = raw[15];
+        let x = vector.x;
+        let y = vector.y;
+        let z = vector.z;
+        result.x = a * x + b * y + c * z + d;
+        result.y = e * x + f * y + g * z + h;
+        result.z = i * x + j * y + k * z + l;
+        result.w = m * x + n * y + o * z + p;
+        return result;
+    }
+}
+export let lerp = function (v0, v1, t) {
+    //return v0 * t + v1 * (1-t) ;
+    return v0 * (1 - t) + v1 * t;
+};
+export function lerpVector3(v0, v1, t) {
+    let newV = new Vector3();
+    let v0x = v0.x;
+    let v0y = v0.y;
+    let v0z = v0.z;
+    let v0w = v0.w;
+    let v1x = v1.x;
+    let v1y = v1.y;
+    let v1z = v1.z;
+    let v1w = v1.w;
+    newV.x = (v1x - v0x) * t + v0x;
+    newV.y = (v1y - v0y) * t + v0y;
+    newV.z = (v1z - v0z) * t + v0z;
+    newV.w = (v1w - v0w) * t + v0w;
+    return newV;
+}
+export function lerpColor(c0, c1, t) {
+    let newColor = new Color();
+    newColor.r = (1.0 - t) * c0.r + t * c1.r;
+    newColor.g = (1.0 - t) * c0.g + t * c1.g;
+    newColor.b = (1.0 - t) * c0.b + t * c1.b;
+    newColor.a = (1.0 - t) * c0.a + t * c1.a;
+    return newColor;
+}
+export function lerpByte(u0, u1, scale) {
+    return (u0 + (((u1 - u0) * scale) >> 8)) & 0xff;
+}
+export let PingPong = function (t, start, end) {
+    let len = end - start;
+    let tt = Math.floor(t / len);
+    let sd = tt % 2;
+    if (sd == 0) {
+        return (t % len) + start;
+    }
+    else {
+        return end - (t % len) + start;
+    }
+};
+export let RepeatSE = function (t, start, end) {
+    let len = end - start;
+    return (t % len) + start;
+};
+export let GetRepeat = function (datas, element) {
+    let count = 0;
+    for (let i in datas) {
+        if (i == element) {
+            count++;
+        }
+    }
+    return count;
+};
+export class RandomSeed {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.w = 0;
+        this.randSeedList = [];
+    }
+    reset() {
+        this.x = Math.random() * 1;
+        this.y = Math.random() * 1;
+        this.z = Math.random() * 1;
+        this.w = Math.random() * 1;
+        this.randSeedList.length = 0;
+        for (let i = 0; i < 20; i++) {
+            this.randSeedList.push(Math.random() * 1);
+        }
+    }
+}
+export function dot(lhs, rhs) {
+    if (lhs instanceof Vector3 && rhs instanceof Vector3) {
+        return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+    }
+    else if (lhs instanceof Quaternion && rhs instanceof Quaternion) {
+        return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+    }
+    else {
+        return lhs.x * rhs.x + lhs.y * rhs.y;
+    }
+}
+export function scale(lhs, rhs) {
+    return new Vector3(lhs.x * rhs.x, lhs.y * rhs.y, lhs.z * rhs.z);
+}
+export function sqrtImpl(f) {
+    return Math.sqrt(f);
+}
+export function magnitude(inV) {
+    return sqrtImpl(dot(inV, inV));
+}
+export function normalizeSafe(inV, defaultV) {
+    let mag = magnitude(inV);
+    if (mag > Vector3.EPSILON) {
+        return inV.divide(magnitude(inV));
+    }
+    else {
+        if (inV instanceof Vector2) {
+            return new Vector2();
+        }
+        if (inV instanceof Vector3) {
+            return new Vector3();
+        }
+        if (inV instanceof Quaternion) {
+            return new Quaternion();
+        }
+    }
+}
+export function getFloatFromInt(value) {
+    // take 23 bits of integer, and divide by 2^23-1
+    let v = value & 0x007fffff;
+    return v * (1.0 / 8388607.0);
+}
+export function random01(value) {
+    // take 23 bits of integer, and divide by 2^23-1
+    return value.getFloat();
+}
+export function rangedRandomFloat(r, min, max) {
+    let t = r.getFloat();
+    t = min * t + (1.0 - t) * max;
+    return t;
+}
+export function rangedRandomInt(r, min, max) {
+    let dif;
+    if (min < max) {
+        dif = max - min;
+        // let t = r.Get () % dif;
+        let t = r.get() % dif;
+        t += min;
+        return t;
+    }
+    else if (min > max) {
+        dif = min - max;
+        // let t = r.Get () % dif;
+        let t = r.get() % dif;
+        t = min - t;
+        return t;
+    }
+    else {
+        return min;
+    }
+}
+export function randomUnitVector(rand) {
+    let z = rangedRandomFloat(rand, -1.0, 1.0);
+    let a = rangedRandomFloat(rand, 0.0, 2.0 * Math.PI);
+    let r = Math.sqrt(1.0 - z * z);
+    let x = r * Math.cos(a);
+    let y = r * Math.sin(a);
+    return new Vector3(x, y, z);
+}
+export function randomUnitVector2(rand) {
+    let a = rangedRandomFloat(rand, 0.0, 2.0 * Math.PI);
+    let x = Math.cos(a);
+    let y = Math.sin(a);
+    return new Vector2(x, y);
+}
+export function randomQuaternion(rand) {
+    let q = new Quaternion();
+    q.x = rangedRandomFloat(rand, -1.0, 1.0);
+    q.y = rangedRandomFloat(rand, -1.0, 1.0);
+    q.z = rangedRandomFloat(rand, -1.0, 1.0);
+    q.w = rangedRandomFloat(rand, -1.0, 1.0);
+    q = normalizeSafe(q);
+    if (dot(q, Quaternion.identity()) < 0.0) {
+        return -q;
+    }
+    else {
+        return q;
+    }
+}
+export function randomQuaternionUniformDistribution(rand) {
+    const two_pi = 2.0 * Math.PI;
+    // Employs Hopf fibration to uniformly distribute quaternions
+    let u1 = rangedRandomFloat(rand, 0.0, 1.0);
+    let theta = rangedRandomFloat(rand, 0.0, two_pi);
+    let rho = rangedRandomFloat(rand, 0.0, two_pi);
+    let i = Math.sqrt(1.0 - u1);
+    let j = Math.sqrt(u1);
+    // We do not need to normalize the generated quaternion, because the probability density corresponds to the Haar measure.
+    // This means that a random rotation is obtained by picking a point at random on S^3, and forming the unit quaternion.
+    let q = new Quaternion(i * Math.sin(theta), i * Math.cos(theta), j * Math.sin(rho), j * Math.cos(rho));
+    if (dot(q, Quaternion.identity()) < 0.0) {
+        return -q;
+    }
+    else {
+        return q;
+    }
+}
+export function randomPointInsideCube(r, extents) {
+    return new Vector3(rangedRandomFloat(r, -extents.x, extents.x), rangedRandomFloat(r, -extents.y, extents.y), rangedRandomFloat(r, -extents.z, extents.z));
+}
+export function randomPointInsideUnitSphere(r) {
+    let v = randomUnitVector(r);
+    v.scaleBy(Math.pow(random01(r), 1.0 / 3.0)); // *= Math.pow (Random01 (r), 1.0 / 3.0);
+    return v;
+}
+export function randomPointInsideEllipsoid(r, extents) {
+    return scale(randomPointInsideUnitSphere(r), extents);
+}
+export function randomPointBetweenSphere(r, minRadius, maxRadius) {
+    let v = randomUnitVector(r);
+    // As the volume of the sphere increases (x^3) over an interval we have to increase range as well with x^(1/3)
+    let range = Math.pow(rangedRandomFloat(r, 0.0, 1.0), 1.0 / 3.0);
+    v.scaleBy(minRadius + (maxRadius - minRadius) * range);
+    return v;
+}
+export function randomPointInsideUnitCircle(r) {
+    let v = randomUnitVector2(r);
+    // As the volume of the sphere increases (x^3) over an interval we have to increase range as well with x^(1/3)
+    v.multiply(Math.pow(rangedRandomFloat(r, 0.0, 1.0), 1.0 / 2.0), v);
+    return v;
+}
+export function randomPointBetweenEllipsoid(r, maxExtents, minRange) {
+    let v = scale(randomUnitVector(r), maxExtents);
+    // As the volume of the sphere increases (x^3) over an interval we have to increase range as well with x^(1/3)
+    let range = Math.pow(rangedRandomFloat(r, minRange, 1.0), 1.0 / 3.0);
+    v.scaleBy(range);
+    return v;
+}
+export function randomBarycentricCoord(rand) {
+    let u = rand.getFloat();
+    let v = rand.getFloat();
+    if (u + v > 1.0) {
+        u = 1.0 - u;
+        v = 1.0 - v;
+    }
+    let w = 1.0 - u - v;
+    return new Vector3(u, v, w);
+}
+export function deg2Rad(deg) {
+    // TODO : should be deg * kDeg2Rad, but can't be changed,
+    // because it changes the order of operations and that affects a replay in some RegressionTests
+    return (deg / 360.0) * 2.0 * Math.PI;
+}
+export function rad2Deg(deg) {
+    // TODO : should be deg * kDeg2Rad, but can't be changed,
+    // because it changes the order of operations and that affects a replay in some RegressionTests
+    return (180 * deg) / Math.PI;
+}
+export function sin(v) {
+    return Math.sin(v);
+}
+export function cos(v) {
+    return Math.cos(v);
+}
+export let randomSeed = 0x1337;
+export function getGlobalRandomSeed() {
+    return ++randomSeed;
+}
+export function swap(values, i1, i2) {
+    let v1 = values[i1];
+    let v2 = values[i2];
+    values[i1] = v2;
+    values[i2] = v1;
+}
+export function floorfToIntPos(f) {
+    return Math.floor(f);
+}
+export function roundfToIntPos(f) {
+    return floorfToIntPos(f + 0.5);
+}
+export function normalizedToWord(f) {
+    f = Math.max(f, 0.0);
+    f = Math.min(f, 1.0);
+    return roundfToIntPos(f * 65535.0);
+}
+export function normalizedToByte(f) {
+    f = Math.max(f, 0.0);
+    f = Math.min(f, 1.0);
+    return roundfToIntPos(f * 255.0);
+}
+export function fastInvSqrt(f) {
+    // The Newton iteration trick used in FastestInvSqrt is a bit faster on
+    // Pentium4 / Windows, but lower precision. Doing two iterations is precise enough,
+    // but actually a bit slower.
+    if (Math.abs(f) == 0.0) {
+        return f;
+    }
+    return 1.0 / Math.sqrt(f);
+}
+export function normalizeFast(inV) {
+    let m = sqrMagnitude(inV);
+    return inV.scaleBy(fastInvSqrt(m));
+}
+export function crossProduct(lhs, rhs) {
+    return lhs.crossProduct(rhs);
+}
+export function sqrMagnitude(inV) {
+    return dot(inV, inV);
+}
+export function generateRandom(randomIn) {
+    let rand = new Rand(randomIn);
+    return random01(rand);
+}
+export function generateRandom3(randomOut, randomIn) {
+    let rand = new Rand(randomIn);
+    randomOut.x = random01(rand);
+    randomOut.y = random01(rand);
+    randomOut.z = random01(rand);
+}
+export function clampRepeat(t, t0, t1) {
+    if (t < t0) {
+        return t1;
+    }
+    else if (t > t1) {
+        return t0;
+    }
+    else {
+        return t;
+    }
+}
+export function repeat(t, length) {
+    return t - Math.floor(t / length) * length;
+}

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

@@ -0,0 +1,183 @@
+import { Vector3 } from "./Vector3";
+export declare class Matrix3 {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    tx: number;
+    ty: number;
+    /**
+     * Create a Matrix3
+     * @param a The width of x
+     * @param b The slope of y
+     * @param c The slope of x
+     * @param d The height of y
+     * @param tx The position of the x coordinate
+     * @param ty The position of the y coordinate
+     */
+    constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);
+    /**
+     * 克隆当前矩阵 - 返回一个新矩阵对象
+     * @returns New Matrix3 object
+     */
+    clone(): Matrix3;
+    /**
+     * 合并矩阵 - 将当前矩阵与目标矩阵相乘(后乘)
+     * @param matrix target matrix
+     */
+    concat(matrix: Matrix3): void;
+    /**
+     * 复制矩阵值 - 从另一个矩阵复制值到当前矩阵
+     * @param other  target matrix value
+     * @returns current matrix
+     */
+    copyFrom(other: Matrix3): Matrix3;
+    /**
+     * 重置为单位矩阵 - 将矩阵重置为无变换状态
+     */
+    identity(): this;
+    /**
+     * 矩阵求逆 - 将当前矩阵变为它的逆矩阵
+     */
+    invert(): void;
+    /**
+     * 旋转矩阵 - 按指定角度旋转(角度制)
+     * @param angle rotation angle
+     */
+    rotate(angle: number): void;
+    /**
+     * 缩放矩阵 - 按指定比例缩放
+     * @param sx x axis scaling
+     * @param sy y axis scaling
+     */
+    scale(sx: number, sy: number): void;
+    /**
+     * 设置矩阵值 - 直接设置矩阵各元素值
+     * @param a Matrix element a
+     * @param b Matrix element b
+     * @param c Matrix element c
+     * @param d Matrix element d
+     * @param tx Matrix element tx
+     * @param ty Matrix element ty
+     * @returns The modified matrix
+     */
+    setTo(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix3;
+    /**
+     * 坐标变换 - 将点坐标应用当前矩阵变换
+     * @param pointX x coordinate
+     * @param pointY y coordinate
+     * @param resultPoint Vector of results
+     * @returns Vector of results
+     */
+    transformPoint(pointX: number, pointY: number, resultPoint?: Vector3): Vector3;
+    /**
+     * 设置平移量 - 直接设置tx/ty值
+     * @param x x coordinate
+     * @param y y coordinate
+     */
+    setTranslate(x: number, y: number): void;
+    /**
+     * 平移矩阵 - 增加平移偏移量
+     * @param dx The x-coordinate offset
+     * @param dy The y-coordinate offset
+     */
+    translate(dx: number, dy: number): void;
+    /**
+     * 矩阵乘法 - 当前矩阵乘以目标矩阵(后乘)
+     * @param t target matrix
+     */
+    mul(t: Matrix3): void;
+    /**
+     * 矩阵相等判断 - 判断与另一矩阵是否相等
+     * @param other matrix
+     * @returns
+     */
+    equals(other: Matrix3): boolean;
+    /**
+     * 前乘矩阵 - 用指定参数创建一个矩阵并前乘当前矩阵
+     * @param a Multiply by a
+     * @param b Multiply by b
+     * @param c Multiply by c
+     * @param d Multiply by d
+     * @param tx Multiply by tx
+     * @param ty Multiply by ty
+     * @returns prematrix
+     */
+    prepend(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix3;
+    /**
+     * 后乘矩阵 - 用目标矩阵后乘当前矩阵
+     * @param mat Matrix
+     * @returns result
+     */
+    append(mat: Matrix3): Matrix3;
+    /**
+     * 忽略平移的坐标变换 - 只应用缩放/旋转变换
+     * @param point A given point
+     * @returns
+     */
+    deltaTransformPoint(point: Vector3): Vector3;
+    /**
+     * 转换为字符串 - 返回矩阵的字符串表示
+     * @returns
+     */
+    toString(): string;
+    /**
+     * 创建变换矩阵 - 设置缩放、旋转和平移参数
+     * @param scaleX x axis scaling
+     * @param scaleY y axis scaling
+     * @param rotation rotation
+     * @param tx x-coordinate
+     * @param ty y-coordinate
+     */
+    createBox(scaleX: number, scaleY: number, rotation?: number, tx?: number, ty?: number): void;
+    /**
+     * 创建渐变框矩阵 - 特殊用途的矩阵创建方法
+     * @param width width
+     * @param height height
+     * @param rotation rotation
+     * @param tx x-coordinate
+     * @param ty y-coordinate
+     */
+    createGradientBox(width: number, height: number, rotation?: number, tx?: number, ty?: number): void;
+    /**
+     * 内部方法 - 将矩阵求逆结果存入目标矩阵
+     * @param target matrix
+     * @returns
+     */
+    private _invertInto;
+    /**
+     * @private
+     */
+    getScaleX(): number;
+    /**
+     * @private
+     */
+    getScaleY(): number;
+    /**
+     * @private
+     */
+    getSkewX(): number;
+    /**
+     * @private
+     */
+    getSkewY(): number;
+    /**
+     * @private
+     */
+    updateScaleAndRotation(scaleX: number, scaleY: number, skewX: number, skewY: number): void;
+    /**
+     * 前乘到目标矩阵 - 计算 other * this 存入target
+     * @private
+     * target = other * this
+     */
+    preMultiplyInto(other: Matrix3, target: Matrix3): void;
+    /**
+     * 变换矩形边界 - 对矩形应用矩阵变换
+     * @private
+     */
+    private $transformBounds;
+    /**
+     * @private
+     */
+    private getDeterminant;
+}