@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/math/CubicBezierPath.js

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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,45 +0,0 @@
-/**
- * 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

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

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

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