@rings-webgpu/core 1.0.6 → 1.0.7

package/dist/types/math/Plane3D.d.ts

@@ -0,0 +1,173 @@
+import { Vector3 } from "..";
+/**
+ * @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 declare class Plane3D {
+    /**
+     * @language en_US
+     * The A coefficient of this plane. (Also the x dimension of the plane normal)
+     */
+    /**
+     * @language zh_CN
+     * 平面中的a分量
+     * @platform Web,Native
+     */
+    a: number;
+    /**
+     * @language en_US
+     * The B coefficient of this plane. (Also the y dimension of the plane normal)
+     */
+    /**
+     * @language zh_CN
+     * 平面中的b分量
+     * @platform Web,Native
+     */
+    b: number;
+    /**
+     * @language en_US
+     * The C coefficient of this plane. (Also the z dimension of the plane normal)
+     */
+    /**
+     * @language zh_CN
+     * 平面中的c分量
+     * @platform Web,Native
+     */
+    c: number;
+    /**
+     * @language en_US
+     * The D coefficient of this plane. (Also the inverse dot product between normal and point)
+     */
+    /**
+     * @language zh_CN
+     * 平面中的d分量
+     * @platform Web,Native
+     */
+    d: number;
+    /**
+     * @private
+     */
+    static ALIGN_ANY: number;
+    /**
+     * @private
+     */
+    static ALIGN_XY_AXIS: number;
+    /**
+     * @private
+     */
+    static ALIGN_YZ_AXIS: number;
+    /**
+     * @private
+     */
+    static ALIGN_XZ_AXIS: number;
+    /**
+     * @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?: number, b?: number, c?: number, d?: number);
+    /**
+     * @language zh_CN
+     * 填充平面的各分量的值
+     * @param a
+     * @param b
+     * @param c
+     * @param d
+     * @platform Web,Native
+     */
+    setTo(a?: number, b?: number, c?: number, d?: number): void;
+    /**
+     * @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: Vector3, p1: Vector3, p2: Vector3): void;
+    /**
+     * @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: Vector3, point: Vector3): void;
+    /**
+     * @language en_US
+     * Normalize this Plane3D
+     * @returns Plane3D This Plane3D.
+     */
+    /**
+     * @language zh_CN
+     * 单位化3d平面
+     * @returns number 返回平面长度
+     * @platform Web,Native
+     */
+    normalize(): number;
+    /**
+     * @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: Vector3): number;
+    /**
+     * @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: Vector3, epsilon?: number): number;
+    /**
+     * @language zh_CN
+     * 当前Plane3D以字符串形式返回
+     * @returns string
+     * @platform Web,Native
+     */
+    toString(): string;
+}

package/dist/types/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/types/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/types/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/types/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;

package/dist/types/math/Rand.d.ts

@@ -0,0 +1,15 @@
+export declare class Rand {
+    private _x;
+    private _y;
+    private _z;
+    private _w;
+    constructor(seed?: number);
+    get seed(): number;
+    set seed(value: number);
+    static getFloatFromInt(value: any): number;
+    static getByteFromInt(value: any): number;
+    clone(): Rand;
+    get(): number;
+    getFloat(): number;
+    getSignedFloat(): number;
+}

package/dist/types/math/Random.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @internal
+ * 均匀实数分布函数
+ * @param min 最小值
+ * @param max 最大值
+ * @returns 区间[min,max]内的随机数
+ */
+export declare function uniform_real_distribution(min: any, max: any): number;
+/**
+ * @internal
+ * 带随机数生成器的均匀实数分布
+ * @param min 最小值
+ * @param max 最大值
+ * @param rng 随机数生成器
+ * @returns 区间[min,max]内的随机数
+ */
+export declare function uniform_real_distribution2(min: any, max: any, rng: any): number;
+/**
+ * @internal
+ * 正态(高斯)分布函数
+ * @param min 最小值
+ * @param max 最大值
+ * @param skew 偏度系数
+ * @returns 符合正态分布的随机数
+ */
+export declare function normal_distribution(min: any, max: any, skew: any): number;
+export declare function FASTFLOOR(x: any): number;
+/**
+ * @internal
+ */
+export declare let perm: number[];
+/**
+ * @internal
+ */
+export declare function grad1(hash: any, x: any): number;
+/**
+ * @internal
+ */
+export declare function grad2(hash: any, x: any, y: any): any;
+/**
+ * @internal
+ */
+export declare function grad3(hash: any, x: any, y: any, z: any): any;
+/**
+ * @internal
+ */
+export declare function grad4(hash: any, x: any, y: any, z: any, t: any): any;
+/**
+ * @internal
+ */
+export declare let simplex: number[][];
+/**
+ * @internal
+ */
+export declare function snoise1(x: any): number;
+/**
+ * @internal
+ */
+export declare function snoise2(x: any, y: any): number;
+/**
+ * @internal
+ */
+export declare function snoise3(x: any, y: any, z: any): number;
+/**
+ * @internal
+ */
+export declare function snoise4(x: any, y: any, z: any, w: any): number;

package/dist/types/math/Ray.d.ts

@@ -0,0 +1,41 @@
+import { IBound } from "../core/bound/IBound";
+import { Triangle } from "./Triangle";
+import { Matrix4 } from "./Matrix4";
+import { Vector3 } from "./Vector3";
+export declare class Ray {
+    origin: Vector3;
+    length: number;
+    private static _rayl;
+    private static _smallnum;
+    private _vector;
+    private _dir;
+    constructor(origin?: Vector3, dir?: Vector3);
+    get direction(): Vector3;
+    set direction(dir: Vector3);
+    clone(): Ray;
+    intersectBox(box: IBound, target?: Vector3): Vector3;
+    pointAt(t: number, target?: Vector3): Vector3;
+    copy(src: Ray): this;
+    setApproxDirection(dir: Vector3): void;
+    setOrigin(origin: Vector3): void;
+    getOrigin(): Vector3;
+    getPoint(t: number): Vector3;
+    sqrDistToPoint(P: Vector3): number;
+    applyMatrix(mat4: Matrix4): void;
+    private _v0;
+    private _v1;
+    private _v2;
+    pointInTriangle(P: Vector3, A: Vector3, B: Vector3, C: Vector3): boolean;
+    private _E1;
+    private _E2;
+    private _P;
+    private _T;
+    private _Q;
+    intersectTriangle(orig: Vector3, dir: Vector3, face: Triangle): Vector3;
+    intersectSphere(o: Vector3, dir: Vector3, center: Vector3, radius: number): Vector3;
+    intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): {
+        out: Vector3;
+        length: number;
+    };
+    private get_vec;
+}

package/dist/types/math/Rect.d.ts

@@ -0,0 +1,21 @@
+export declare class Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    get width(): number;
+    set width(v: number);
+    get height(): number;
+    set height(v: number);
+    static pointInRect(x: number, y: number, lt_x: number, lt_y: number, rb_x: number, rb_y: number): boolean;
+    clone(): Rect;
+    copyFrom(rect: Rect): void;
+    copyTo(rect: Rect): void;
+    inner(x: number, y: number): boolean;
+    equal(rectangle: Rect): boolean;
+    equalArea(x: number, y: number, width: number, height: number): boolean;
+    equalInnerArea(source: Rect): boolean;
+    innerArea(source: Rect, target: Rect): Rect;
+    setTo(x: number, y: number, width: number, height: number): void;
+}

package/dist/types/math/TimeInterpolator.d.ts

@@ -0,0 +1,179 @@
+export interface TimeInterpolator {
+    getInterpolation(input: number): number;
+}
+export declare class AccelerateInterpolator implements TimeInterpolator {
+    private _factor;
+    private _doubleFactor;
+    constructor();
+    get accelerateInterpolator(): number;
+    set accelerateInterpolator(factor: number);
+    getInterpolation(input: number): number;
+}
+export declare class DecelerateInterpolator implements TimeInterpolator {
+    private _factor;
+    constructor();
+    get decelerateInterpolator(): number;
+    set decelerateInterpolator(factor: number);
+    getInterpolation(input: number): number;
+}
+export declare class AccelerateDecelerateInterpolator implements TimeInterpolator {
+    private _factor;
+    constructor();
+    getInterpolation(input: number): number;
+}
+export declare class LinearInterpolator implements TimeInterpolator {
+    getInterpolation(input: number): number;
+}
+export declare class JumperInterpolator implements TimeInterpolator {
+    getInterpolation(t: number): number;
+}
+export declare class BounceInterpolator implements TimeInterpolator {
+    constructor();
+    private static bounce;
+    getInterpolation(t: number): number;
+    getBounceInterpolation(t: number): number;
+    geJumpUp(v0: number, t: number): number;
+}
+export declare class AnticipateInterpolator implements TimeInterpolator {
+    private _tension;
+    constructor();
+    get anticipateInterpolator(): number;
+    set anticipateInterpolator(tension: number);
+    getInterpolation(t: number): number;
+}
+export declare class AnticipateOvershootInterpolator implements TimeInterpolator {
+    private _tension;
+    constructor();
+    anticipateOvershootInterpolator(tension: number): void;
+    anticipateOvershootInterpolator2(tension: number, extraTension: number): void;
+    getInterpolation(t: any): number;
+    private static a;
+    private static o;
+}
+export declare class CycleInterpolator implements TimeInterpolator {
+    private _cycles;
+    constructor(cycles: any);
+    getInterpolation(t: any): number;
+}
+export declare class OvershootInterpolator implements TimeInterpolator {
+    private _tension;
+    constructor();
+    getInterpolation(t: any): number;
+}
+export declare enum InterpolatorEnum {
+    /**
+     * Acceleration interpolator, animation acceleration runs to the end.
+     */
+    AccelerateInterpolator = 0,
+    /**
+     * Slow down interpolator, animation slow down run to end.
+     */
+    DecelerateInterpolator = 1,
+    /**
+     * Acceleration and deceleration interpolator, animation first speed up and then decelerate.
+     */
+    AccelerateDecelerateInterpolator = 2,
+    /**
+     * Linear interpolator, animation uniform motion.
+     */
+    LinearInterpolator = 3,
+    /**
+     * Elastic interpolator, before the end of the animation will have an elastic animation effect.
+     */
+    BounceInterpolator = 4,
+    /**
+     * Step back and then speed up to the end.
+     */
+    AnticipateInterpolator = 5,
+    /**
+     * Take a small step back, then speed up, then go a little beyond the finish line and then come back.
+     */
+    AnticipateOvershootInterpolator = 6,
+    /**
+     * Cyclic motion
+     */
+    CycleInterpolator = 7,
+    /**
+     * Finish the animation quickly, go a little beyond the end point and then go back to the end point.
+     */
+    OvershootInterpolator = 8,
+    /**
+     * @internal
+     */
+    JumperInterpolator = 9
+}
+export declare class Interpolator {
+    /**
+     * @internal
+     */
+    static interpolators: Interpolator[];
+    /**
+     * @internal
+     */
+    complete: boolean;
+    /**
+     * @internal
+     */
+    onComplete: Function;
+    /**
+     * @internal
+     */
+    onProgress: Function;
+    /**
+     * @internal
+     */
+    target: any;
+    /**
+     * @internal
+     */
+    property: any;
+    /**
+     * @internal
+     */
+    targetProperty: any;
+    /**
+     * @internal
+     */
+    durtion: number;
+    /**
+     * @internal
+     */
+    interpolatorEnum: InterpolatorEnum;
+    /**
+     * @internal
+     */
+    delayTime: number;
+    private _interpolator;
+    private _ct;
+    private _p;
+    /**
+     * 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: any, property: any, durtion: number, interpolatorEnum?: InterpolatorEnum): Interpolator;
+    /**
+     * @internal
+     */
+    static tick(delta: number): void;
+    /**
+     * @internal
+     */
+    static remove(interpolator: Interpolator, dispose?: boolean): void;
+    static removeList(interpolators: Interpolator[], dispose?: boolean): void;
+    /**
+     * @internal
+     */
+    start(): void;
+    /**
+     * @internal
+     */
+    tick(delta: number): void;
+    /**
+     * @internal
+     */
+    dispose(): void;
+}

package/dist/types/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/types/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;
+}