@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/Plane3D.js

@@ -0,0 +1,191 @@
+import { PlaneClassification } from "./PlaneClassification";
+/**
+ * @language zh_CN
+ * @class Plane3D
+ * @classdesc
+ * Plane3D 类 3D空间中的平面表示数据
+ * 由a,b,c,d4个分量组成 在三维空间中定义了一个平面 Ax + By + Cz + D = 0
+ * @includeExample geom/Plane3D.ts
+ * @platform Web,Native
+ */
+export class Plane3D {
+    // indicates the alignment of the plane
+    /**
+     * @private
+     */
+    static { this.ALIGN_ANY = 0; }
+    /**
+     * @private
+     */
+    static { this.ALIGN_XY_AXIS = 1; }
+    /**
+     * @private
+     */
+    static { this.ALIGN_YZ_AXIS = 2; }
+    /**
+     * @private
+     */
+    static { this.ALIGN_XZ_AXIS = 3; }
+    /**
+     * @language en_US
+     * Create a Plane3D with ABCD coefficients
+     */
+    /**
+     * @language zh_CN
+     * 创建一个平面实例
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @platform Web,Native
+     */
+    constructor(a = 0, b = 0, c = 0, d = 0) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+    }
+    /**
+     * @language zh_CN
+     * 填充平面的各分量的值
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @platform Web,Native
+     */
+    setTo(a = 0, b = 0, c = 0, d = 0) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+    }
+    /**
+     * @language en_US
+     * Fills this Plane3D with the coefficients from 3 points in 3d space.
+     * @param p0 Vector3
+     * @param p1 Vector3
+     * @param p2 Vector3
+     */
+    /**
+     * @language zh_CN
+     * 由3个坐标来创建一个3d平面
+     * @param p0 Vector3
+     * @param p1 Vector3
+     * @param p2 Vector3
+     * @platform Web,Native
+     */
+    fromPoints(p0, p1, p2) {
+        var d1x = p1.x - p0.x;
+        var d1y = p1.y - p0.y;
+        var d1z = p1.z - p0.z;
+        var d2x = p2.x - p0.x;
+        var d2y = p2.y - p0.y;
+        var d2z = p2.z - p0.z;
+        this.a = d1y * d2z - d1z * d2y;
+        this.b = d1z * d2x - d1x * d2z;
+        this.c = d1x * d2y - d1y * d2x;
+        this.d = -(this.a * p0.x + this.b * p0.y + this.c * p0.z);
+    }
+    /**
+     * @language en_US
+     * Fills this Plane3D with the coefficients from the plane's normal and a point in 3d space.
+     * @param normal Vector3
+     * @param point  Vector3
+     */
+    /**
+     * @language zh_CN
+     * 由一条normal向量和一个坐标创建一个3d平面
+     * @param normal Vector3
+     * @param point  Vector3
+     * @platform Web,Native
+     */
+    fromNormalAndPoint(normal, point) {
+        this.a = normal.x;
+        this.b = normal.y;
+        this.c = normal.z;
+        this.d = -(this.a * point.x + this.b * point.y + this.c * point.z);
+    }
+    /**
+     * @language en_US
+     * Normalize this Plane3D
+     * @returns Plane3D This Plane3D.
+     */
+    /**
+     * @language zh_CN
+     * 单位化3d平面
+     * @returns number 返回平面长度
+     * @platform Web,Native
+     */
+    normalize() {
+        var len = Math.sqrt(this.a * this.a + this.b * this.b + this.c * this.c);
+        if (len > 0.0) {
+            var invLength = 1.0 / len;
+            this.a *= invLength;
+            this.b *= invLength;
+            this.c *= invLength;
+            this.d *= invLength;
+        }
+        return len;
+    }
+    /**
+     * @language en_US
+     * Returns the signed distance between this Plane3D and the point p.
+     * @param p Vector3
+     * @returns Number
+     */
+    /**
+     * @language zh_CN
+     * 计算3d平面到点p的距离
+     * @param p Vector3
+     * @returns number 返回计算后的距离
+     * @platform Web,Native
+     */
+    distance(p) {
+        return this.a * p.x + this.b * p.y + this.c * p.z + this.d;
+    }
+    /**
+     * @language en_US
+     * Classify a point against this Plane3D. (in front, back or intersecting)
+     * @param p Vector3
+     * @param epsilon
+     * @returns PlaneClassification.FRONT在平面正面
+     * PlaneClassification.BACK在平面背面面
+     * PlaneClassification.INTERSECT在平面上
+     */
+    /**
+     * @language zh_CN
+     * 计算3d平面和点p的空间关系
+     * @param p Vector3
+     * @param epsilon 相对偏移值
+     * @returns number int Plane3.FRONT or Plane3D.BACK or Plane3D.INTERSECT
+     * @platform Web,Native
+     */
+    classifyPoint(p, epsilon = 0.01) {
+        var dis = this.distance(p);
+        if (dis < -epsilon) {
+            return PlaneClassification.BACK;
+        }
+        else if (dis > epsilon) {
+            return PlaneClassification.FRONT;
+        }
+        return PlaneClassification.INTERSECT;
+    }
+    /**
+     * @language zh_CN
+     * 当前Plane3D以字符串形式返回
+     * @returns string
+     * @platform Web,Native
+     */
+    toString() {
+        return ("Plane3D [a:" +
+            this.a +
+            ", b:" +
+            this.b +
+            ", c:" +
+            this.c +
+            ", d:" +
+            this.d +
+            "]");
+    }
+}

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

@@ -0,0 +1,32 @@
+export declare class PlaneClassification {
+    /**
+     * @language zh_CN
+     * 背面
+     * @platform Web,Native
+     */
+    static BACK: number;
+    /**
+     * @language zh_CN
+     * 正面
+     * @platform Web,Native
+     */
+    static FRONT: number;
+    /**
+     * @language zh_CN
+     * 在法线朝上的一面
+     * @platform Web,Native
+     */
+    static IN: number;
+    /**
+     * @language zh_CN
+     * 在法线朝下的一面
+     * @platform Web,Native
+     */
+    static OUT: number;
+    /**
+     * @language zh_CN
+     * 相交
+     * @platform Web,Native
+     */
+    static INTERSECT: number;
+}

package/dist/src/math/PlaneClassification.js

@@ -0,0 +1,32 @@
+export class PlaneClassification {
+    /**
+     * @language zh_CN
+     * 背面
+     * @platform Web,Native
+     */
+    static { this.BACK = 0; }
+    /**
+     * @language zh_CN
+     * 正面
+     * @platform Web,Native
+     */
+    static { this.FRONT = 1; }
+    /**
+     * @language zh_CN
+     * 在法线朝上的一面
+     * @platform Web,Native
+     */
+    static { this.IN = 0; }
+    /**
+     * @language zh_CN
+     * 在法线朝下的一面
+     * @platform Web,Native
+     */
+    static { this.OUT = 1; }
+    /**
+     * @language zh_CN
+     * 相交
+     * @platform Web,Native
+     */
+    static { this.INTERSECT = 2; }
+}

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

@@ -0,0 +1,43 @@
+import { AnimationCurve } from "./AnimationCurve";
+import { Vector2 } from "./Vector2";
+/**
+ * @internal
+ * @group Math
+ */
+export declare class Polynomial {
+    coeff: number[];
+    static EvalSegment(t: number, coeff: number[]): number;
+}
+/**
+ * @internal
+ * @group Math
+ */
+export declare class PolynomialCurve {
+    private static kMaxNumSegments;
+    segments: Polynomial[];
+    integrationCache: number[];
+    doubleIntegrationCache: number[];
+    times: number[];
+    segmentCount: number;
+    constructor();
+    calculateMinMax(minmax: Vector2, value: any): void;
+    findMinMaxDoubleIntegrated(): Vector2;
+    findMinMaxIntegrated(): Vector2;
+    generateIntegrationCache(curve: PolynomialCurve): void;
+    generateDoubleIntegrationCache(curve: PolynomialCurve): void;
+    integrate(): void;
+    doubleIntegrate(): void;
+    static isValidCurve(editorCurve: AnimationCurve): boolean;
+    evaluateDoubleIntegrated(t: any): number;
+    evaluateIntegrated(t: any): number;
+    evaluate(t: any): number;
+    buildCurve(editorCurve: AnimationCurve, scale: number): boolean;
+}
+/**
+ * @internal
+ */
+export declare function doubleIntegrateSegment(coeff: any): void;
+/**
+ * @internal
+ */
+export declare function integrateSegment(coeff: any): void;

package/dist/src/math/PolynomialCurve.js

@@ -0,0 +1,236 @@
+import { cubicPolynomialRootsGeneric } from "./Polynomials";
+import { Vector2 } from "./Vector2";
+/**
+ * @internal
+ * @group Math
+ */
+export class Polynomial {
+    constructor() {
+        this.coeff = [];
+    }
+    static EvalSegment(t, coeff) {
+        return t * (t * (t * coeff[0] + coeff[1]) + coeff[2]) + coeff[3];
+    }
+}
+/**
+ * @internal
+ * @group Math
+ */
+export class PolynomialCurve {
+    static { this.kMaxNumSegments = 8; }
+    constructor() {
+        this.segments = [];
+        this.integrationCache = [];
+        this.doubleIntegrationCache = [];
+        this.times = [];
+        this.segments[PolynomialCurve.kMaxNumSegments] = new Polynomial();
+        this.integrationCache[PolynomialCurve.kMaxNumSegments] = 0;
+        this.doubleIntegrationCache[PolynomialCurve.kMaxNumSegments] = 0;
+        this.times[PolynomialCurve.kMaxNumSegments] = 0;
+    }
+    calculateMinMax(minmax, value) {
+        minmax.x = Math.min(minmax.x, value);
+        minmax.y = Math.max(minmax.y, value);
+    }
+    findMinMaxDoubleIntegrated() {
+        let result = Vector2.ZERO.clone();
+        let numSteps = 20;
+        let delta = 1.0 / numSteps;
+        let acc = delta;
+        for (let i = 0; i < numSteps; i++) {
+            this.calculateMinMax(result, this.evaluateDoubleIntegrated(acc));
+            acc += delta;
+        }
+        return result;
+    }
+    // Find the maximum of the integrated curve (x: min, y: max)
+    findMinMaxIntegrated() {
+        let result = Vector2.ZERO.clone();
+        let prevTimeValue = 0.0;
+        let start = [];
+        let end = [];
+        for (let i = 0; i < this.segmentCount; i++) {
+            // Differentiate coefficients
+            let a = 4.0 * this.segments[i].coeff[0];
+            let b = 3.0 * this.segments[i].coeff[1];
+            let c = 2.0 * this.segments[i].coeff[2];
+            let d = 1.0 * this.segments[i].coeff[3];
+            let roots = [];
+            let numRoots = cubicPolynomialRootsGeneric(roots, a, b, c, d);
+            for (let r = 0; r < numRoots; r++) {
+                let root = roots[r] + start[i];
+                if (root >= start[i] && root < end[i]) {
+                    this.calculateMinMax(result, this.evaluateIntegrated(root));
+                }
+            }
+            // TODO: Don't use eval integrated, use eval segment (and integrate in loop)
+            this.calculateMinMax(result, this.evaluateIntegrated(end[i]));
+            prevTimeValue = this.times[i];
+        }
+        return result;
+    }
+    generateIntegrationCache(curve) {
+        curve.integrationCache[0] = 0.0;
+        let prevTimeValue0 = curve.times[0];
+        let prevTimeValue1 = 0.0;
+        for (let i = 1; i < curve.segmentCount; i++) {
+            let coeff = curve.segments[i - 1].coeff;
+            integrateSegment(coeff);
+            let time = prevTimeValue0 - prevTimeValue1;
+            curve.integrationCache[i] =
+                curve.integrationCache[i - 1] +
+                    Polynomial.EvalSegment(time, coeff) * time;
+            prevTimeValue1 = prevTimeValue0;
+            prevTimeValue0 = curve.times[i];
+        }
+    }
+    generateDoubleIntegrationCache(curve) {
+        let sum = 0.0;
+        let prevTimeValue = 0.0;
+        for (let i = 0; i < curve.segmentCount; i++) {
+            curve.doubleIntegrationCache[i] = sum;
+            let time = curve.times[i] - prevTimeValue;
+            time = Math.max(time, 0.0);
+            sum +=
+                Polynomial.EvalSegment(time, curve.segments[i].coeff) * time * time +
+                    curve.integrationCache[i] * time;
+            prevTimeValue = curve.times[i];
+        }
+    }
+    // Integrates a velocity curve to be a position curve.
+    // You have to call EvaluateIntegrated to evaluate the curve
+    integrate() {
+        this.generateIntegrationCache(this);
+        for (let i = 0; i < this.segmentCount; i++) {
+            integrateSegment(this.segments[i].coeff);
+        }
+    }
+    // Integrates a velocity curve to be a position curve.
+    // You have to call EvaluateDoubleIntegrated to evaluate the curve
+    doubleIntegrate() {
+        this.generateIntegrationCache(this);
+        for (let i = 0; i < this.segmentCount; i++) {
+            doubleIntegrateSegment(this.segments[i].coeff);
+        }
+        this.generateDoubleIntegrationCache(this);
+    }
+    // Evaluates if it is possible to represent animation curve as PolynomialCurve
+    static isValidCurve(editorCurve) {
+        let keyCount = editorCurve.getKeyCount();
+        let segmentCount = keyCount - 1;
+        if (editorCurve.getKey(0).time != 0.0) {
+            segmentCount++;
+        }
+        if (editorCurve.getKey(keyCount - 1).time != 1.0) {
+            segmentCount++;
+        }
+        return segmentCount <= PolynomialCurve.kMaxNumSegments;
+    }
+    evaluateDoubleIntegrated(t) {
+        let prevTimeValue = 0.0;
+        for (let i = 0; i < this.segmentCount; i++) {
+            if (t <= this.times[i]) {
+                let time = t - prevTimeValue;
+                return (this.doubleIntegrationCache[i] +
+                    this.integrationCache[i] * time +
+                    Polynomial.EvalSegment(time, this.segments[i].coeff) * time * time);
+            }
+            prevTimeValue = this.times[i];
+        }
+        return 1.0;
+    }
+    // Evaluate integrated Polynomial curve.
+    // Example: position = EvaluateIntegrated (normalizedTime) * startEnergy
+    // Use Integrate function to for example turn a velocity curve into a position curve.
+    // Expects that t is in the 0...1 range.
+    evaluateIntegrated(t) {
+        let prevTimeValue = 0.0;
+        for (let i = 0; i < this.segmentCount; i++) {
+            if (t <= this.times[i]) {
+                let time = t - prevTimeValue;
+                return (this.integrationCache[i] +
+                    Polynomial.EvalSegment(time, this.segments[i].coeff) * time);
+            }
+            prevTimeValue = this.times[i];
+        }
+        return 1.0;
+    }
+    // Evaluate the curve
+    // extects that t is in the 0...1 range
+    evaluate(t) {
+        let prevTimeValue = 0.0;
+        for (let i = 0; i < this.segmentCount; i++) {
+            if (t <= this.times[i]) {
+                return Polynomial.EvalSegment(t - prevTimeValue, this.segments[i].coeff);
+            }
+            prevTimeValue = this.times[i];
+        }
+        return 1.0;
+    }
+    buildCurve(editorCurve, scale) {
+        let keyCount = editorCurve.getKeyCount();
+        this.segmentCount = 1;
+        let kMaxTime = 1.01;
+        this.segments.length = 0;
+        this.integrationCache.length = 0;
+        this.doubleIntegrationCache.length = 0;
+        this.times.length = 0;
+        this.times[0] = kMaxTime;
+        // Handle corner case 1 & 0 keyframes
+        if (keyCount == 0) {
+        }
+        else if (keyCount == 1) {
+            this.segments[0] = new Polynomial();
+            this.segments[0].coeff[3] = editorCurve.getKey(0).value * scale;
+        }
+        else {
+            this.segmentCount = keyCount - 1;
+            let segmentOffset = 0;
+            // Add extra key to start if it doesn't match up
+            if (editorCurve.getKey(0).time != 0.0) {
+                this.segments[0].coeff[3] = editorCurve.getKey(0).value;
+                this.times[0] = editorCurve.getKey(0).time;
+                segmentOffset = 1;
+            }
+            for (let i = 0; i < this.segmentCount; i++) {
+                let cache;
+                editorCurve.calculateCacheData(cache, i, i + 1, 0.0);
+                this.segments[i + segmentOffset].coeff = cache.coeff.concat();
+                this.times[i + segmentOffset] = editorCurve.getKey(i + 1).time;
+            }
+            this.segmentCount += segmentOffset;
+            // Add extra key to start if it doesn't match up
+            if (editorCurve.getKey(keyCount - 1).time != 1.0) {
+                this.segments[this.segmentCount].coeff[3] = editorCurve.getKey(keyCount - 1).value;
+                this.segmentCount++;
+            }
+            // Fixup last key time value
+            this.times[this.segmentCount - 1] = kMaxTime;
+            for (let i = 0; i < this.segmentCount; i++) {
+                this.segments[i].coeff[0] *= scale;
+                this.segments[i].coeff[1] *= scale;
+                this.segments[i].coeff[2] *= scale;
+                this.segments[i].coeff[3] *= scale;
+            }
+        }
+        return true;
+    }
+}
+/**
+ * @internal
+ */
+export function doubleIntegrateSegment(coeff) {
+    coeff[0] /= 20.0;
+    coeff[1] /= 12.0;
+    coeff[2] /= 6.0;
+    coeff[3] /= 2.0;
+}
+/**
+ * @internal
+ */
+export function integrateSegment(coeff) {
+    coeff[0] /= 4.0;
+    coeff[1] /= 3.0;
+    coeff[2] /= 2.0;
+    coeff[3] /= 1.0;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @internal
+ * @group Math
+ */
+export declare class Polynomials {
+}
+export declare function cubicPolynomialRoot(p: number, q: number, r: number): number;
+export declare function quadraticPolynomialRootsGeneric(a: any, b: any, c: any, out: {
+    r0: any;
+    r1: any;
+}): 1 | 0 | 2;
+export declare function cubicPolynomialRootsGeneric(roots: number[], a: number, b: number, c: number, d: number): number;

package/dist/src/math/Polynomials.js

@@ -0,0 +1,73 @@
+/**
+ * @internal
+ * @group Math
+ */
+export class Polynomials {
+}
+export function cubicPolynomialRoot(p, q, r) {
+    let rcp3 = 1.0 / 3.0;
+    let half = 0.5;
+    let po3 = p * rcp3;
+    let po3_2 = po3 * po3;
+    let po3_3 = po3_2 * po3;
+    let b = po3_3 - po3 * q * half + r * half;
+    let a = -po3_2 + q * rcp3;
+    let a3 = a * a * a;
+    let det = a3 + b * b;
+    if (det >= 0) {
+        let r0 = Math.sqrt(det) - b;
+        r0 = r0 > 0 ? Math.pow(r0, rcp3) : -Math.pow(-r0, rcp3);
+        return -po3 - a / r0 + r0;
+    }
+    let abs = Math.sqrt(-a3);
+    let arg = Math.acos(-b / abs);
+    abs = Math.pow(abs, rcp3);
+    abs = abs - a / abs;
+    arg = -po3 + abs * Math.cos(arg * rcp3);
+    return arg;
+}
+export function quadraticPolynomialRootsGeneric(a, b, c, out) {
+    let eps = 0.00001;
+    if (Math.abs(a) < eps) {
+        if (Math.abs(b) > eps) {
+            out.r0 = -c / b;
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    let disc = b * b - 4 * a * c;
+    if (disc < 0.0) {
+        return 0;
+    }
+    let halfRcpA = 0.5 / a;
+    let sqrtDisc = Math.sqrt(disc);
+    out.r0 = (sqrtDisc - b) * halfRcpA;
+    out.r1 = (-sqrtDisc - b) * halfRcpA;
+    return 2;
+}
+export function cubicPolynomialRootsGeneric(roots, a, b, c, d) {
+    let numRoots = 0;
+    if (Math.abs(a) >= 0.0001) {
+        let p = b / a;
+        let q = c / a;
+        let r = d / a;
+        roots[0] = cubicPolynomialRoot(p, q, r);
+        numRoots++;
+        let la = a;
+        let lb = b + a * roots[0];
+        let lc = c + b * roots[0] + a * roots[0] * roots[0];
+        numRoots += quadraticPolynomialRootsGeneric(la, lb, lc, {
+            r0: roots[1],
+            r1: roots[2],
+        });
+    }
+    else {
+        numRoots += quadraticPolynomialRootsGeneric(b, c, d, {
+            r0: roots[1],
+            r1: roots[2],
+        });
+    }
+    return numRoots;
+}

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

@@ -0,0 +1,42 @@
+import { FloatArray } from "@rings/wasm-matrix/WasmMatrix";
+import { Vector3 } from "./Vector3";
+export declare class Quaternion {
+    static HELP_0: Quaternion;
+    static HELP_1: Quaternion;
+    static HELP_2: Quaternion;
+    static _zero: Quaternion;
+    static CALCULATION_QUATERNION: Quaternion;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    static identity(): Quaternion;
+    static quaternionToMatrix(q: Quaternion, m: any): void;
+    get magnitude(): number;
+    set(x?: number, y?: number, z?: number, w?: number): Quaternion;
+    divide(v: any): Quaternion;
+    setFromArray(d: Float32Array | number[]): this;
+    multiply(qa: Quaternion, qb: Quaternion): void;
+    multiplyVector(vector: Vector3, target?: Quaternion): Quaternion;
+    fromAxisAngle(axis: Vector3, angle: number): void;
+    toAxisAngle(axis: Vector3): number;
+    slerp(qa: Quaternion, qb: Quaternion, t: number): void;
+    lerp(qa: Quaternion, qb: Quaternion, t: number): void;
+    fromEulerAngles(ax: number, ay: number, az: number): Quaternion;
+    setFromRotationMatrix(m: {
+        rawData: FloatArray;
+    }): this;
+    getEulerAngles(eulers?: Vector3): Vector3;
+    normalize(val?: number): void;
+    toString(): string;
+    fromMatrix(matrix: any): void;
+    inverse(target?: Quaternion): Quaternion;
+    clone(): Quaternion;
+    transformVector(vector: Vector3, target?: Vector3): Vector3;
+    copyFrom(q: Quaternion | Vector3): this;
+    mul(lhs: Quaternion, rhs: Quaternion, target?: Quaternion): Quaternion;
+    private clampf;
+    static serialize(value: Quaternion): Quaternion;
+}
+export declare function rotateVectorByQuat(lhs: Quaternion, rhs: Vector3, target: Vector3): Vector3;