@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/CubicBezierPath.js

@@ -0,0 +1,234 @@
+import { CubicBezierCurve } from "./CubicBezierCurve";
+import { MathUtil } from "./MathUtil";
+/**
+ * 三次贝塞尔曲线类型
+ * @group Math
+ */
+export var CubicBezierType;
+(function (CubicBezierType) {
+    CubicBezierType[CubicBezierType["Open"] = 0] = "Open";
+    CubicBezierType[CubicBezierType["Closed"] = 1] = "Closed";
+})(CubicBezierType || (CubicBezierType = {}));
+/**
+ * @group Math
+ */
+export class CubicBezierPath {
+    constructor(controlVertices, t = CubicBezierType.Open) {
+        this.type = CubicBezierType.Open;
+        this.numCurveSegments = 0;
+        this.numControlVertices = 0;
+        this.controlVertices = [];
+        this.setControlVertices(controlVertices, t);
+    }
+    getPathType() {
+        return this.type;
+    }
+    isClosed() {
+        return this.type == CubicBezierType.Closed ? true : false;
+    }
+    /**
+     * @returns
+     */
+    isValid() {
+        return this.numCurveSegments > 0 ? true : false;
+    }
+    clear() {
+        this.controlVertices.length = 0;
+        this.type = CubicBezierType.Open;
+        this.numCurveSegments = 0;
+        this.numControlVertices = 0;
+    }
+    computeApproxLength() {
+        if (!this.isValid())
+            return 0.0;
+        let numInterpolatedPoints = this.numCurveSegments + 1;
+        if (numInterpolatedPoints < 2)
+            return 0.0;
+        let totalDist = 0.0;
+        let controlVertices = this.controlVertices;
+        for (let n = 1; n < numInterpolatedPoints; n++) {
+            let a = controlVertices[(n - 1) * 3];
+            let b = controlVertices[n * 3];
+            totalDist += a.subtract(b).lengthSquared;
+        }
+        if (totalDist == 0.0)
+            return 0.0;
+        return totalDist;
+    }
+    computeApproxParamPerUnitLength() {
+        let length = this.computeApproxLength();
+        return this.numCurveSegments / length;
+    }
+    computeApproxNormParamPerUnitLength() {
+        let length = this.computeApproxLength();
+        return 1.0 / length;
+    }
+    interpolatePoints(knots, t) {
+        let numKnots = knots.length;
+        if (numKnots < 2)
+            console.error("point count must great 1");
+        this.clear();
+        this.type = t;
+        let controlVertices = this.controlVertices;
+        switch (t) {
+            case CubicBezierType.Open: {
+                this.numCurveSegments = numKnots - 1;
+                this.numControlVertices = 3 * numKnots - 2;
+                controlVertices.length = this.numControlVertices;
+                for (let n = 0; n < numKnots; n++)
+                    controlVertices[n * 3] = knots[n];
+                let initialPoint = knots[1].subtract(knots[0]).mul(0.25);
+                controlVertices[1] = knots[0].add(initialPoint);
+                let finalPoint = knots[numKnots - 2]
+                    .subtract(knots[numKnots - 1])
+                    .mul(0.25);
+                controlVertices[this.numControlVertices - 2] =
+                    knots[numKnots - 1].add(finalPoint);
+                for (let k = 1; k < this.numCurveSegments; k++) {
+                    let a = knots[k - 1].subtract(knots[k]);
+                    let b = knots[k + 1].subtract(knots[k]);
+                    let aLen = a.lengthSquared;
+                    let bLen = b.lengthSquared;
+                    if (aLen > 0.0 && bLen > 0.0) {
+                        let abLen = (aLen + bLen) / 8.0;
+                        let ab = b.div(bLen).subtract(a.div(aLen));
+                        ab.normalize();
+                        ab = ab.mul(abLen);
+                        controlVertices[k * 3 - 1] = knots[k].subtract(ab);
+                        controlVertices[k * 3 + 1] = knots[k].add(ab);
+                    }
+                    else {
+                        controlVertices[k * 3 - 1] = knots[k];
+                        controlVertices[k * 3 + 1] = knots[k];
+                    }
+                }
+                break;
+            }
+            case CubicBezierType.Closed: {
+                this.numCurveSegments = numKnots;
+                this.numControlVertices = 3 * numKnots + 1;
+                controlVertices.length = this.numControlVertices;
+                for (let n = 0; n < numKnots; n++)
+                    controlVertices[n * 3] = knots[n];
+                controlVertices[this.numControlVertices - 1] = knots[0];
+                for (let k = 1; k <= this.numCurveSegments; k++) {
+                    let modkm1 = k - 1;
+                    let modkp1 = (k + 1) % this.numCurveSegments;
+                    let modk = k % this.numCurveSegments;
+                    let a = knots[modkm1].subtract(knots[modk]);
+                    let b = knots[modkp1].subtract(knots[modk]);
+                    let aLen = a.lengthSquared;
+                    let bLen = b.lengthSquared;
+                    let mod3km1 = 3 * k - 1;
+                    let mod3kp1 = (3 * k + 1) % (this.numControlVertices - 1);
+                    if (aLen > 0.0 && bLen > 0.0) {
+                        let abLen = (aLen + bLen) / 8.0;
+                        let ab = b.div(bLen).subtract(a.div(aLen));
+                        ab.normalize();
+                        ab = ab.mul(abLen);
+                        controlVertices[mod3km1] = knots[modk].subtract(ab);
+                        controlVertices[mod3kp1] = knots[modk].add(ab);
+                    }
+                    else {
+                        controlVertices[mod3km1] = knots[modk];
+                        controlVertices[mod3kp1] = knots[modk];
+                    }
+                }
+                break;
+            }
+        }
+    }
+    setControlVertices(cvs, t) {
+        let numCVs = cvs.length;
+        if (numCVs <= 0)
+            return;
+        if (t == CubicBezierType.Open && numCVs < 4)
+            return;
+        if (t == CubicBezierType.Closed && numCVs < 7)
+            return;
+        if (!((numCVs - 1) % 3 == 0))
+            return;
+        this.clear();
+        this.type = t;
+        this.numControlVertices = numCVs;
+        this.numCurveSegments = (numCVs - 1) / 3;
+        this.controlVertices = cvs;
+    }
+    getPoint(t) {
+        if (this.type == CubicBezierType.Closed) {
+            while (t < 0.0)
+                t += this.numCurveSegments;
+            while (t > this.numCurveSegments)
+                t -= this.numCurveSegments;
+        }
+        else {
+            t = MathUtil.clampf(t, 0.0, this.numCurveSegments);
+        }
+        if (!(t >= 0) && t <= this.numCurveSegments)
+            return;
+        let segment = Math.floor(t);
+        if (segment >= this.numCurveSegments)
+            segment = this.numCurveSegments - 1;
+        let curveCVs = [];
+        let controlVerts = this.controlVertices;
+        curveCVs[0] = controlVerts[3 * segment + 0];
+        curveCVs[1] = controlVerts[3 * segment + 1];
+        curveCVs[2] = controlVerts[3 * segment + 2];
+        curveCVs[3] = controlVerts[3 * segment + 3];
+        let bc = new CubicBezierCurve(curveCVs);
+        return bc.getPoint(t - segment);
+    }
+    getPointNorm(t) {
+        return this.getPoint(t * this.numCurveSegments);
+    }
+    getTangent(t) {
+        if (this.type == CubicBezierType.Closed) {
+            while (t < 0.0)
+                t += this.numCurveSegments;
+            while (t > this.numCurveSegments)
+                t -= this.numCurveSegments;
+        }
+        else {
+            t = MathUtil.clampf(t, 0.0, this.numCurveSegments);
+        }
+        if (!(t >= 0) && t <= this.numCurveSegments)
+            return;
+        let segment = Math.floor(t);
+        if (segment >= this.numCurveSegments)
+            segment = this.numCurveSegments - 1;
+        let controlVerts = this.controlVertices;
+        let curveCVs = [];
+        curveCVs[0] = controlVerts[3 * segment + 0];
+        curveCVs[1] = controlVerts[3 * segment + 1];
+        curveCVs[2] = controlVerts[3 * segment + 2];
+        curveCVs[3] = controlVerts[3 * segment + 3];
+        let bc = new CubicBezierCurve(curveCVs);
+        return bc.getTangent(t - segment);
+    }
+    getTangentNorm(t) {
+        return this.getTangent(t * this.numCurveSegments);
+    }
+    computeClosestParam(pos, paramThreshold) {
+        let minDistSq = Number.MAX_SAFE_INTEGER;
+        let closestParam = 0.0;
+        let curveCVs = [];
+        let curve = new CubicBezierCurve(curveCVs);
+        for (let startIndex = 0; startIndex < this.controlVertices.length - 1; startIndex += 3) {
+            for (let i = 0; i < 4; i++)
+                curveCVs[i] = this.controlVertices[startIndex + i];
+            curve.setControlVertices(curveCVs);
+            let curveClosestParam = curve.getClosestParam(pos, paramThreshold);
+            let curvePos = curve.getPoint(curveClosestParam);
+            let distSq = curvePos.subtract(pos).lengthSquared;
+            if (distSq < minDistSq) {
+                minDistSq = distSq;
+                let startParam = startIndex / 3.0;
+                closestParam = startParam + curveClosestParam;
+            }
+        }
+        return closestParam;
+    }
+    computeClosestNormParam(pos, paramThreshold) {
+        return this.computeClosestParam(pos, paramThreshold * this.numCurveSegments);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * https://en.wikipedia.org/wiki/Halton_sequence
+ * https://baike.baidu.com/item/Halton%20sequence/16697800
+ * Class for generating the Halton low-discrepancy series for Quasi Monte Carlo integration.
+ */
+export declare class HaltonSeq {
+    private value;
+    private inv_base;
+    static get(index: number, radix: number): number;
+    getBase(index: number, base: number): void;
+    next(): void;
+    get(): number;
+}

package/dist/src/math/HaltonSeq.js

@@ -0,0 +1,45 @@
+/**
+ * https://en.wikipedia.org/wiki/Halton_sequence
+ * https://baike.baidu.com/item/Halton%20sequence/16697800
+ * Class for generating the Halton low-discrepancy series for Quasi Monte Carlo integration.
+ */
+export class HaltonSeq {
+    constructor() {
+        this.value = 0;
+        this.inv_base = 0;
+    }
+    static get(index, radix) {
+        let result = 0;
+        let fraction = 1 / radix;
+        while (index > 0) {
+            result += (index % radix) * fraction;
+            index /= radix;
+            fraction /= radix;
+        }
+        return result;
+    }
+    getBase(index, base) {
+        let f = (this.inv_base = 1.0 / base);
+        while (index > 0) {
+            this.value += f * (index % base);
+            index /= base;
+            f *= this.inv_base;
+        }
+    }
+    next() {
+        let r = 1.0 - this.value - 0.0000001;
+        if (this.inv_base < r)
+            this.value += this.inv_base;
+        else {
+            let h = this.inv_base, hh;
+            do {
+                hh = h;
+                h *= this.inv_base;
+            } while (h >= r);
+            this.value += hh + h - 1.0;
+        }
+    }
+    get() {
+        return this.value;
+    }
+}

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

@@ -0,0 +1,39 @@
+import { Color } from "./Color";
+import { Matrix4 } from "./Matrix4";
+import { Ray } from "./Ray";
+import { Vector3 } from "./Vector3";
+export declare enum LineClassification {
+    COLLINEAR = 0,
+    LINES_INTERSECT = 1,
+    SEGMENTS_INTERSECT = 2,
+    A_BISECTS_B = 3,
+    B_BISECTS_A = 4,
+    PARALELL = 5
+}
+export declare enum PointClassification {
+    ON_LINE = 0,
+    LEFT_SIDE = 1,
+    RIGHT_SIDE = 2
+}
+export declare class Line {
+    static cacluteLine0: Line;
+    static cacluteLine1: Line;
+    start: Vector3;
+    end: Vector3;
+    color: Color;
+    private _normal;
+    private _normalCalculated;
+    constructor(start?: Vector3, end?: Vector3);
+    set(start: Vector3, end: Vector3): void;
+    getCenter(): Vector3;
+    inverse(): void;
+    equals(l: Line): boolean;
+    toArray(): number[];
+    static getLines(ps: Vector3[]): Line[];
+    intersection(other: Line, pIntersectPoint?: Vector3): LineClassification;
+    getDirection(): Vector3;
+    copyFrom(line: Line): void;
+    static IsEqual(d1: any, d2: any): boolean;
+    static squreDistanceSegmentToSegment(lineA: Line, lineB: Line, mat?: Matrix4): number;
+    isNear(ray: Ray, maxDistance?: number, mat?: Matrix4): boolean;
+}

package/dist/src/math/Line.js

@@ -0,0 +1,240 @@
+import { Color } from "./Color";
+import { Vector3 } from "./Vector3";
+import { repeat } from "./MathUtil";
+export var LineClassification;
+(function (LineClassification) {
+    LineClassification[LineClassification["COLLINEAR"] = 0] = "COLLINEAR";
+    LineClassification[LineClassification["LINES_INTERSECT"] = 1] = "LINES_INTERSECT";
+    LineClassification[LineClassification["SEGMENTS_INTERSECT"] = 2] = "SEGMENTS_INTERSECT";
+    LineClassification[LineClassification["A_BISECTS_B"] = 3] = "A_BISECTS_B";
+    LineClassification[LineClassification["B_BISECTS_A"] = 4] = "B_BISECTS_A";
+    LineClassification[LineClassification["PARALELL"] = 5] = "PARALELL";
+})(LineClassification || (LineClassification = {}));
+export var PointClassification;
+(function (PointClassification) {
+    PointClassification[PointClassification["ON_LINE"] = 0] = "ON_LINE";
+    PointClassification[PointClassification["LEFT_SIDE"] = 1] = "LEFT_SIDE";
+    PointClassification[PointClassification["RIGHT_SIDE"] = 2] = "RIGHT_SIDE";
+})(PointClassification || (PointClassification = {}));
+export class Line {
+    static { this.cacluteLine0 = new Line(null, null); }
+    static { this.cacluteLine1 = new Line(null, null); }
+    constructor(start, end) {
+        this.color = new Color(1, 1, 1, 1);
+        this._normalCalculated = false;
+        this.start = start;
+        this.end = end;
+    }
+    set(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    getCenter() {
+        let help = Vector3.HELP_0;
+        this.start.subtract(this.end, help);
+        help.scaleBy(0.5);
+        help.add(this.end);
+        return help;
+    }
+    inverse() {
+        let tmp = this.start;
+        this.start = this.end;
+        this.end = tmp;
+    }
+    equals(l) {
+        if ((this.start == l.start && this.end == l.end) ||
+            (this.start == l.end && this.end == l.start))
+            return true;
+        return false;
+    }
+    toArray() {
+        return [
+            this.start.x,
+            this.start.y,
+            this.start.z,
+            this.end.x,
+            this.end.y,
+            this.end.z,
+        ];
+    }
+    static getLines(ps) {
+        let arr = [];
+        for (let index = 0; index < ps.length; index++) {
+            let i0 = index;
+            let i1 = repeat(index + 1, ps.length);
+            let p0 = ps[i0];
+            let p1 = ps[i1];
+            arr.push(new Line(p0, p1));
+        }
+        return arr;
+    }
+    intersection(other, pIntersectPoint = null) {
+        var denom = (other.end.z - other.start.z) * (this.end.x - this.start.x) -
+            (other.end.x - other.start.x) * (this.end.z - this.start.z);
+        var u0 = (other.end.x - other.start.x) * (this.start.z - other.start.z) -
+            (other.end.z - other.start.z) * (this.start.x - other.start.x);
+        var u1 = (other.start.x - this.start.x) * (this.end.z - this.start.z) -
+            (other.start.z - this.start.z) * (this.end.x - this.start.x);
+        //if parallel
+        if (denom == 0.0) {
+            if (u0 == 0.0 && u1 == 0.0)
+                return LineClassification.COLLINEAR;
+            else
+                return LineClassification.PARALELL;
+        }
+        else {
+            u0 = u0 / denom;
+            u1 = u1 / denom;
+            var x = this.start.x + u0 * (this.end.x - this.start.x);
+            var z = this.start.z + u0 * (this.end.z - this.start.z);
+            if (pIntersectPoint != null) {
+                pIntersectPoint.x = x;
+                pIntersectPoint.y = 0;
+                pIntersectPoint.z = z;
+            }
+            if (u0 >= 0.0 && u0 <= 1.0 && u1 >= 0.0 && u1 <= 1.0) {
+                return LineClassification.SEGMENTS_INTERSECT;
+            }
+            else if (u1 >= 0.0 && u1 <= 1.0) {
+                return LineClassification.A_BISECTS_B;
+            }
+            else if (u0 >= 0.0 && u0 <= 1.0) {
+                return LineClassification.B_BISECTS_A;
+            }
+            return LineClassification.LINES_INTERSECT;
+        }
+    }
+    getDirection() {
+        var pt = this.end.subtract(this.start);
+        var direction = new Vector3(pt.x, pt.y);
+        return direction.normalize();
+    }
+    copyFrom(line) {
+        if (!this.start)
+            this.start = new Vector3();
+        if (!this.end)
+            this.end = new Vector3();
+        this.start.copyFrom(line.start);
+        this.end.copyFrom(line.end);
+    }
+    static IsEqual(d1, d2) {
+        if (Math.abs(d1 - d2) < 1e-7)
+            return true;
+        return false;
+    }
+    static squreDistanceSegmentToSegment(lineA, lineB, mat) {
+        let a_po = lineA.start;
+        let a_p1 = lineA.end;
+        let b_po = lineB.start;
+        let b_p1 = lineB.end;
+        let x1 = a_po.x;
+        let y1 = a_po.y;
+        let z1 = a_po.z;
+        let x2 = a_p1.x;
+        let y2 = a_p1.y;
+        let z2 = a_p1.z;
+        let x3 = b_po.x;
+        let y3 = b_po.y;
+        let z3 = b_po.z;
+        let x4 = b_p1.x;
+        let y4 = b_p1.y;
+        let z4 = b_p1.z;
+        let ux = x2 - x1;
+        let uy = y2 - y1;
+        let uz = z2 - z1;
+        let vx = x4 - x3;
+        let vy = y4 - y3;
+        let vz = z4 - z3;
+        let wx = x1 - x3;
+        let wy = y1 - y3;
+        let wz = z1 - z3;
+        let a = ux * ux + uy * uy + uz * uz;
+        let b = ux * vx + uy * vy + uz * vz;
+        let c = vx * vx + vy * vy + vz * vz;
+        let d = ux * wx + uy * wy + uz * wz;
+        let e = vx * wx + vy * wy + vz * wz;
+        let dt = a * c - b * b;
+        let sd = dt;
+        let td = dt;
+        let sn = 0.0;
+        let tn = 0.0;
+        if (this.IsEqual(dt, 0.0)) {
+            sn = 0.0;
+            sd = 1.0;
+            tn = e;
+            td = c;
+        }
+        else {
+            sn = b * e - c * d;
+            tn = a * e - b * d;
+            if (sn < 0.0) {
+                sn = 0.0;
+                tn = e;
+                td = c;
+            }
+            else if (sn > sd) {
+                sn = sd;
+                tn = e + b;
+                td = c;
+            }
+        }
+        if (tn < 0.0) {
+            tn = 0.0;
+            if (-d < 0.0)
+                sn = 0.0;
+            else if (-d > a)
+                sn = sd;
+            else {
+                sn = -d;
+                sd = a;
+            }
+        }
+        else if (tn > td) {
+            tn = td;
+            if (-d + b < 0.0)
+                sn = 0.0;
+            else if (-d + b > a)
+                sn = sd;
+            else {
+                sn = -d + b;
+                sd = a;
+            }
+        }
+        let sc = 0.0;
+        let tc = 0.0;
+        if (this.IsEqual(sn, 0.0))
+            sc = 0.0;
+        else
+            sc = sn / sd;
+        if (this.IsEqual(tn, 0.0))
+            tc = 0.0;
+        else
+            tc = tn / td;
+        let dx = wx + sc * ux - tc * vx;
+        let dy = wy + sc * uy - tc * vy;
+        let dz = wz + sc * uz - tc * vz;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    isNear(ray, maxDistance = 0, mat) {
+        // //@task to-do
+        let tmpP0 = Vector3.HELP_0;
+        let tmpP1 = Vector3.HELP_1;
+        tmpP0.copyFrom(ray.origin);
+        tmpP1.copyFrom(ray.direction);
+        tmpP1.scaleBy(9999);
+        tmpP1.add(tmpP0, tmpP1);
+        Line.cacluteLine0.set(tmpP0, tmpP1);
+        Line.cacluteLine1.copyFrom(this);
+        if (mat) {
+            mat.perspectiveMultiplyPoint3(Line.cacluteLine1.start, Line.cacluteLine1.start);
+            mat.perspectiveMultiplyPoint3(Line.cacluteLine1.end, Line.cacluteLine1.end);
+        }
+        let dis = Line.squreDistanceSegmentToSegment(Line.cacluteLine0, Line.cacluteLine1, mat);
+        if (dis + 1e-4 <= maxDistance) {
+            ray.length = dis;
+            return true;
+        }
+        ray.length = -999999;
+        return false;
+    }
+}

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

@@ -0,0 +1,86 @@
+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 declare let RADIANS_TO_DEGREES: number;
+export declare let DEGREES_TO_RADIANS: number;
+export declare let MAX_VALUE: number;
+export declare let MIN_VALUE: number;
+export declare function clamp(value: any, min: any, max: any): number;
+export declare class MathUtil {
+    private static gaussFunction;
+    private static computeGaussian;
+    private static gaussCoef;
+    static clampf(value: number, min_inclusive: number, max_inclusive: number): number;
+    static normalizeAngle(a: number): number;
+    static fract(v: number): number;
+    static getRandDirXZ(r: number): {
+        x: number;
+        z: number;
+    };
+    static getRandDirXYZ(r: number): Vector3;
+    static getCycleXYZ(r: number): Vector3;
+    static angle(p1: Vector3, p2: Vector3): number;
+    static angle_360(from: Vector3, to: Vector3): number;
+    getRotationY(v: Vector3): number;
+    static fromToRotation(fromDirection: Vector3, toDirection: Vector3, target?: Quaternion): Quaternion;
+    static getEularDir_yUp(v: number): Vector3;
+    static transformVector(matrix: Matrix4, vector: Vector3, result?: Vector3): Vector3;
+}
+export declare let lerp: (v0: number, v1: number, t: number) => number;
+export declare function lerpVector3(v0: Vector3, v1: Vector3, t: number): Vector3;
+export declare function lerpColor(c0: Color, c1: Color, t: any): Color;
+export declare function lerpByte(u0: any, u1: any, scale: any): number;
+export declare let PingPong: (t: number, start: number, end: number) => number;
+export declare let RepeatSE: (t: number, start: number, end: number) => number;
+export declare let GetRepeat: (datas: any[], element: any) => number;
+export declare class RandomSeed {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    randSeedList: number[];
+    constructor();
+    reset(): void;
+}
+export declare function dot(lhs: Vector2 | Quaternion | Vector3, rhs: Vector2 | Quaternion | Vector3): number;
+export declare function scale(lhs: Vector3, rhs: Vector3): Vector3;
+export declare function sqrtImpl(f: number): number;
+export declare function magnitude(inV: Vector2 | Vector3 | Quaternion): number;
+export declare function normalizeSafe(inV: Vector2 | Vector3 | Quaternion, defaultV?: Vector2 | Vector3 | Quaternion): Vector2 | Vector3 | Quaternion;
+export declare function getFloatFromInt(value: any): number;
+export declare function random01(value: any): any;
+export declare function rangedRandomFloat(r: Rand, min: number, max: number): number;
+export declare function rangedRandomInt(r: Rand, min: number, max: number): number;
+export declare function randomUnitVector(rand: Rand): Vector3;
+export declare function randomUnitVector2(rand: Rand): Vector2;
+export declare function randomQuaternion(rand: Rand): number | Quaternion;
+export declare function randomQuaternionUniformDistribution(rand: Rand): number | Quaternion;
+export declare function randomPointInsideCube(r: Rand, extents: Vector3): Vector3;
+export declare function randomPointInsideUnitSphere(r: Rand): Vector3;
+export declare function randomPointInsideEllipsoid(r: Rand, extents: Vector3): Vector3;
+export declare function randomPointBetweenSphere(r: Rand, minRadius: number, maxRadius: number): Vector3;
+export declare function randomPointInsideUnitCircle(r: Rand): Vector2;
+export declare function randomPointBetweenEllipsoid(r: Rand, maxExtents: Vector3, minRange: number): Vector3;
+export declare function randomBarycentricCoord(rand: Rand): Vector3;
+export declare function deg2Rad(deg: any): number;
+export declare function rad2Deg(deg: any): number;
+export declare function sin(v: number): number;
+export declare function cos(v: number): number;
+export declare let randomSeed: number;
+export declare function getGlobalRandomSeed(): number;
+export declare function swap(values: any[], i1: number, i2: number): void;
+export declare function floorfToIntPos(f: any): number;
+export declare function roundfToIntPos(f: any): number;
+export declare function normalizedToWord(f: any): number;
+export declare function normalizedToByte(f: any): number;
+export declare function fastInvSqrt(f: any): any;
+export declare function normalizeFast(inV: Vector3): Vector3;
+export declare function crossProduct(lhs: Vector3, rhs: Vector3): Vector3;
+export declare function sqrMagnitude(inV: Vector3): number;
+export declare function generateRandom(randomIn: any): any;
+export declare function generateRandom3(randomOut: Vector3, randomIn: number): void;
+export declare function clampRepeat(t: any, t0: any, t1: any): any;
+export declare function repeat(t: any, length: any): number;