knight-web 2.0.0

package/frame/utility/FileUtility.d.ts

@@ -0,0 +1,31 @@
+/** 文件工具 */
+export declare namespace FileUtility {
+    /** 路径工具 */
+    class Path {
+        /** 根据URL获取拓展名 */
+        static ExtName(_url: string): string;
+        /** 根据URL获取拓展名 */
+        static ExtNameWithoutPoint(_url: string): string;
+        /** 根据URL获取文件名(包含拓展名) */
+        static Name(_url: string): string;
+        /** 根据URL获取文件名(不包含拓展名) */
+        static OnlyName(_url: string): string;
+        /** 根据URL获取文件路径 */
+        static DirName(_url: string): string;
+    }
+    /** 文件工具 */
+    class File {
+        /** 加载Script脚本(动态加载指定的本地 JavaScript 文件) */
+        static LoadScript(_src: string, _callback: (_error: Error, _script?: HTMLScriptElement) => void): void;
+        /** 加载进制文件 */
+        static LoadBinaryFile(_url: string): Promise<Uint8Array>;
+        /** 将字节数组转为Hex16进制数组 */
+        static ByteArrayToHex(_binaryArray: Uint8Array, _bit: number): Array<string>;
+        /** 读取文件 */
+        static ReadFile<T extends {}>(_blob: Blob): Promise<Uint8Array>;
+        /** 读取文件执行函数 */
+        private static OnExecutorReadFile;
+        /** 解析Excel的XLSX数据 */
+        static ParseXLSXData<T extends {}>(_arrayData: Uint8Array): Array<T[]>;
+    }
+}

package/frame/utility/InputUtility.d.ts

@@ -0,0 +1,20 @@
+import { EnumUtility } from "./EnumUtility";
+import { InterfaceUtility } from "./InterfaceUtility";
+/** 输入工具 */
+export declare namespace InputUtility {
+    /** 输入类 */
+    class Input {
+        /** 构造函数 */
+        constructor();
+        /** 注册 */
+        RegistGlobalEvent(_eType: EnumUtility.E_EventType, _eventCallBack: InterfaceUtility.IEvent<Event>, _options?: boolean | AddEventListenerOptions): void;
+        /** 注销 */
+        DegistGlobalEvent(_eType: EnumUtility.E_EventType, _eventCallBack: InterfaceUtility.IEvent<Event>, _options?: boolean | AddEventListenerOptions): void;
+        /** 注册 */
+        RegistTargetEvent(_target: HTMLElement, _eType: EnumUtility.E_EventType, _eventCallBack: InterfaceUtility.IEvent<Event>, _options?: boolean | AddEventListenerOptions): void;
+        /** 注销 */
+        DegistTargetEvent(_target: HTMLElement, _eType: EnumUtility.E_EventType, _eventCallBack: InterfaceUtility.IEvent<Event>, _options?: boolean | AddEventListenerOptions): void;
+        /** 事件回调函数 */
+        private OnEventCallBack;
+    }
+}

package/frame/utility/InterfaceUtility.d.ts

@@ -0,0 +1,13 @@
+/** 接口模块 */
+export declare namespace InterfaceUtility {
+    /** 类型泛型接口(构造器签名接口) */
+    type IType<T> = new (...args: any[]) => T;
+    /** 行为类型泛型接口(类似于C#中的Action使用方法) */
+    interface IAction<T = any, K = any, M = any, N = any, Q = any, U = any, V = any, W = any> {
+        (t?: T, k?: K, m?: M, n?: N, q?: Q, u?: U, v?: V, w?: W): any;
+    }
+    /** 事件类型泛型接口(类似于C#中的Event使用方法) */
+    interface IEvent<T = any, K = any, M = any, N = any, Q = any, U = any, V = any, W = any> {
+        (t?: T, k?: K, m?: M, n?: N, q?: Q, u?: U, v?: V, w?: W): any;
+    }
+}

package/frame/utility/LogUtility.d.ts

@@ -0,0 +1,44 @@
+/*********************************************************************************
+  * FileName     : LogUtility
+  * FileBasename : LogUtility.ts
+  * Description  : 日志工具
+  * Version      : V1.0.0
+  * Date         : Wed Mar 02 2022 17:03:42 GMT+0800 (中国标准时间)
+  * Path         : db://assets/Script/Utility/LogUtility.ts
+  * Author       : Seven_9t
+  * Others       : 修改默认TS脚本模板路径 C:\CocosDashboard_1.0.12\resources\.editors\Creator\<Version>\resources\resources\3d\engine\editor\assets\default_file_content\ts
+  * ManualUrl    : <指南手册>    https://docs.cocos.com/creator/3.4/manual/zh/
+  *              : <脚本手册>    https://docs.cocos.com/creator/3.4/manual/zh/scripting/
+  *              : <CC类手册>    https://docs.cocos.com/creator/3.4/manual/zh/scripting/decorator.html
+  *              : <生命周期手册>https://docs.cocos.com/creator/3.4/manual/zh/scripting/life-cycle-callbacks.html
+
+**********************************************************************************/
+/** 日志工具 */
+export declare namespace LogUtility {
+    /** 是否开启日志 */
+    const Switch: boolean;
+    /** 是否显示堆栈信息 */
+    const Stack: boolean;
+    /** 系统名称 */
+    const Name: string;
+    /** 日志标签 */
+    const Flag: string;
+    /** 设置日志开关 */
+    function SetSwitch(_value: boolean): void;
+    /** 提示日志 */
+    function LogTip(..._message: any[]): void;
+    /** 信息日志*/
+    function LogInfo(..._message: any[]): void;
+    /** 警告日志 */
+    function LogWarning(..._message: any[]): void;
+    /** 错误日志 */
+    function LogError(..._message: any[]): void;
+    /** 系统日志 */
+    function LogSystem(..._message: any[]): void;
+    /** 输出日志 */
+    function Print(_head: string, _color: string, ..._message: any[]): void;
+    /** 获取日期字符串 */
+    function getDateString(): string;
+    /** 调用堆栈 */
+    function OnStack(): string;
+}

package/frame/utility/MathUtility.d.ts

@@ -0,0 +1,559 @@
+import { InterfaceUtility } from "./InterfaceUtility";
+/** 数学工具 */
+export declare namespace MathUtility {
+    /** UUID工具 */
+    class UUID {
+        /** 字符集 */
+        private static _unicodes;
+        /** 创建新UUID */
+        static NewUUID(): string;
+        /** 时间ID */
+        static TimeID(): string;
+        /** 创建新GUID */
+        static NewGuid(): number;
+        static GetHash(key: string): number;
+        /** 创建GUID */
+        private static CreatGuid;
+        /** 获取一个唯一标识的字符串 */
+        static GetGUID(): string;
+    }
+    /** 时间工具 */
+    class Time {
+        /** 获取时间戳 */
+        static TimeStemp(): number;
+        /** 格式化时间 */
+        static CurTimeFormat(value?: number): string;
+        /** 时间日期(格式化) */
+        static TimeFormat(_time: string | number | Date, _format?: string): string;
+        /** 时间日期(格式化传入秒) */
+        static SecondsTimeFormat(_seconds: number): string;
+        /**
+         * 随时间变化进度值
+         * @param start 初始值
+         * @param end   结束值
+         * @param t     时间
+         */
+        static progress(start: number, end: number, t: number): number;
+    }
+    /** 时间类 */
+    class Timer {
+        /** 开始时间戳(ms) */
+        private _startTimeStemp;
+        /** 游戏帧间隔(ms) */
+        private _deltaTime;
+        /** 游戏帧率(ms) */
+        get frameRate(): number;
+        set frameRate(_value: number);
+        private _frameRate;
+        /** 逝去时间 */
+        get elapsedTime(): number;
+        private _elapsedTime;
+        /** 累积时间 */
+        get totalTime(): number;
+        private _totalTime;
+        /** 进度 */
+        get progress(): number;
+        /** 开始开关 */
+        private _switch;
+        /** 定时触发回调 */
+        Evt_Timeout: InterfaceUtility.IEvent;
+        /**
+        * 构造函数
+        * @param _frameRate 帧率
+        */
+        constructor(_frameRate: number);
+        /** 游戏引擎的cc.Component组件的update方法调用 */
+        update(_deltaTime: number): boolean;
+        /** 启动 */
+        OnLaunch(): void;
+        /** 重置 */
+        OnReset(): void;
+        /** 获取时间格式字符串 */
+        OnTimeFormat(): string;
+    }
+    /** 数学工具 */
+    class MathEx {
+        /** 种子 */
+        private static _seed;
+        /** 角度转弧度 */
+        private static Deg2Rad;
+        /** 弧度转角度 */
+        private static Rad2Deg;
+        /**
+        * 获得随机方向
+        * @param x -1为左，1为右
+        * @returns
+        */
+        static sign(x: number): 0 | 1 | -1;
+        /**
+         * 获得一个值的概率
+         * @param value 值
+         */
+        static probability(value: number): boolean;
+        /** 数字限制 */
+        static clamp(value: number, min: number, max: number): number;
+        /** 数字精度(保留一个数字的总有效数字位数，包括小数点前和小数点后的数字) */
+        static toPrecision(_value: number, _count: number): number;
+        /** 数字精度(保留一个数字的总有效数字位数，包括小数点前和小数点后的数字) */
+        static toFixed(_value: number, _count: number): number;
+        /** 计算m % n的欧氏模(https://en.wikipedia.org/wiki/Modulo_operation) */
+        static euclideanModulo(n: number, m: number): number;
+        /** 从range <a1, a2>到range <b1, b2>的线性映射 */
+        static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
+        /** 逆向插值(https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/) */
+        static inverseLerp(x: number, y: number, value: number): number;
+        /** 插值(https://en.wikipedia.org/wiki/Linear_interpolation) */
+        static lerp(x: number, y: number, t: number): number;
+        /**
+         * 角度插值
+         * @param angle1 角度1
+         * @param angle2 角度2
+         * @param t      时间
+         */
+        static lerpAngle(current: number, target: number, t: number): number;
+        /**
+         * 按一定的速度从一个角度转向令一个角度
+         * @param current 当前角度
+         * @param target  目标角度
+         * @param speed   速度
+         */
+        static angleTowards(current: number, target: number, speed: number): number;
+        /** 阻尼（http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/） */
+        static damp(x: number, y: number, lambda: number, dt: number): number;
+        /** 乒乓（https://www.desmos.com/calculator/vcsjnyz7x4） */
+        static pingpong(x: number, length?: number): number;
+        /** 缓动（http://en.wikipedia.org/wiki/Smoothstep） */
+        static smoothstep(x: number, min: number, max: number): number;
+        /** 缓动 */
+        static smootherstep(x: number, min: number, max: number): number;
+        /** 随机整数[最小、最大] */
+        static RandomInt(low: number, high: number): number;
+        /** 随机浮点数 */
+        static randFloat(low: number, high: number): number;
+        /** 随机区间浮点数<-range/2, range/2> */
+        static randFloatSpread(range: number): number;
+        /** 区间[0,1]的确定性伪随机浮点数 */
+        static SeededRandom(s: number): number;
+        /** 高精度随机种子随机数 [min, max]  */
+        static HighRandom(min: number, max: number, _isInt?: boolean): number;
+        /** 角度转弧度 */
+        static degToRad(degrees: number): number;
+        /** 弧度转角度 */
+        static radToDeg(radians: number): number;
+        /** 检测数字是否是2的平方数 */
+        static isPowerOfTwo(value: number): boolean;
+        /** 向2的近似指数幂上趋近 */
+        static ceilPowerOfTwo(value: number): number;
+        /** 向2的近似指数幂下趋近 */
+        static floorPowerOfTwo(value: number): number;
+        /** 使非规一化 */
+        static denormalize(value: number, array: any): number;
+        /** 归一化 */
+        static normalize(value: number, array: any): number;
+        /** 值类型限制 */
+        static Clamp01(_value: number): number;
+        /** 值限制(包含最大最小值) */
+        static Clamp(_value: number, _minValue: number, _maxValue: number): number;
+        /** 产生多个随机整数(排序),包含下限值,但不包含上限值
+         * @params _minNumber 下限值
+         * @params _maxNumber 上限值
+         * @params _count 筛选数量
+         * @params _exclude 排除数据
+         */
+        static Randoms(_minNumber: number, _maxNumber: number, _count: number, _exclude?: number[]): number[];
+        /** 产生随机整数,包含下限值,但不包含上限值 */
+        static RandomCMin(_minNumber: number, _maxNumber: number): number;
+        /** 产生随机整数,包含下限值,也包含上限值 */
+        static RandomA(_minNumber: number, _maxNumber: number): number;
+        /** 产生随机整数,不包含下限值,但包含上限值 */
+        static RandomCMax(_minNumber: number, _maxNumber: number): number;
+        /** 产生随机整数,不包含下限值,也不包含上限值 */
+        static RandomN(_minNumber: number, _maxNumber: number): number;
+        /** 随机生成RGB值,每个颜色值在0 - 255之间 */
+        static RandomColor(): string;
+        /** 绝对值 */
+        static Abs(_number: number): number;
+        /** 取整函数:返回小于等于数字参数的最大整数，对数字进行下舍入 */
+        static FloorToInt(_value: number): number;
+        /** 取整函数:返回大于等于数字参数的最小整数,对数字进行上舍入 */
+        static CeilToInt(_value: number): number;
+        /** 取整函数:返回数字最接近的整数，四舍五入 */
+        static RoundToInt(_value: number): number;
+    }
+    /** 数组工具 */
+    class ArrayEx {
+        /**
+         * 数组交集
+         * @introduce 两个数组中共有元素集合
+         * @param _array1 A数组
+         * @param _array2 B数组
+         * @returns 交集数组
+         */
+        static Intersection<T>(_array1: Array<T>, _array2: Array<T>): Array<T>;
+        /**
+         * 数组并集
+         * @introduce 两个数组中所有有不同元素集合
+         * @param _array1 A数组
+         * @param _array2 B数组
+         * @returns 并集数组
+         */
+        static Union<T>(_array1: Array<T>, _array2: Array<T>): Array<T>;
+        /**
+         * 数组差集
+         * @introduce 第一个数组中有，第二个数组中没有的元素
+         * @param _array1 A数组
+         * @param _array2 B数组
+         * @returns 并集数组
+         */
+        static Difference<T>(_array1: Array<T>, _array2: Array<T>): Array<T>;
+        /**
+         * 数组补集
+         * @introduce 在全集中有但在指定数组中没有的元素。其中全集是指两个数组的并集
+         * @param _array1 A数组
+         * @param _array2 B数组
+         * @returns 补集数组
+         */
+        static Complement<T>(_array1: Array<T>, _array2: Array<T>): Array<T>;
+        /**
+         * 数组去重，并创建一个新数组返回
+         * @param arr  源数组
+         */
+        static NoRepeated(arr: any[]): any[];
+        /**
+         * 复制二维数组
+         * @param array 目标数组
+         */
+        static Copy2DArray(array: any[][]): any[][];
+        /**
+         * Fisher-Yates Shuffle 随机置乱算法
+         * @param array 目标数组
+         */
+        static FisherYatesShuffle(array: any[]): any[];
+        /**
+         * 混淆数组
+         * @param array 目标数组
+         */
+        static Confound(array: []): any[];
+        /**
+         * 数组扁平化
+         * @param array 目标数组
+         */
+        static Flattening(array: any[]): any[];
+        /** 删除数组中指定项 */
+        static RemoveItem(array: any[], item: any): void;
+        /**
+         * 合并数组
+         * @param array1 目标数组1
+         * @param array2 目标数组2
+         */
+        static CombineArrays(array1: any[], array2: any[]): any[];
+        /**
+         * 获取随机数组成员
+         * @param array 目标数组
+         */
+        static GetRandomValueInArray(array: any[]): any;
+    }
+    /** 颜色 */
+    class Color {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        constructor(_r?: number, _g?: number, _b?: number, _a?: number);
+        /** 设置标量 */
+        SetScalar(_scalar: number): void;
+        /** 设置HEX */
+        SetHex(_hex: number): void;
+        /** 设置RGB */
+        SetRGB(_r: number, _g: number, _b: number): void;
+        /** 设置HSL */
+        SetHSL(_h: number, _s: number, _l: number): void;
+        private hue2rgb;
+        /** 克隆颜色 */
+        Clone(): Color;
+        /** 拷贝颜色 */
+        Copy(_color: Color): Color;
+        /** 将HEX颜色转换成RGB(0~1)颜色 */
+        static HEX2RGB(_hex: string): {
+            _r: number;
+            _g: number;
+            _b: number;
+            _a: number;
+        };
+        /** 将RGB(0~1)颜色转换成HEX颜色 */
+        static RGB2HEX(_r: number, _g: number, _b: number, _a: number): string;
+    }
+    /** 平面 */
+    class Plane {
+        /**
+         * Normal of the plane (a,b,c)
+         */
+        normal: Vector3;
+        /**
+         * d component of the plane
+         */
+        d: number;
+        /**
+         * Creates a Plane object according to the given floats a, b, c, d and the plane equation : ax + by + cz + d = 0
+         * @param a a component of the plane
+         * @param b b component of the plane
+         * @param c c component of the plane
+         * @param d d component of the plane
+         */
+        constructor(a: number, b: number, c: number, d: number);
+        /**
+         * @returns the plane coordinates as a new array of 4 elements [a, b, c, d].
+         */
+        asArray(): number[];
+        /**
+         * @returns a new plane copied from the current Plane.
+         */
+        clone(): Plane;
+        /**
+         * @returns the string "Plane".
+         */
+        getClassName(): string;
+        /**
+         * @returns the Plane hash code.
+         */
+        getHashCode(): number;
+        /**
+         * Normalize the current Plane in place.
+         * @returns the updated Plane.
+         */
+        normalize(): Plane;
+        /**
+         * Applies a transformation the plane and returns the result
+         * @param transformation the transformation matrix to be applied to the plane
+         * @returns a new Plane as the result of the transformation of the current Plane by the given matrix.
+         */
+        /**
+         * Compute the dot product between the point and the plane normal
+         * @param point point to calculate the dot product with
+         * @returns the dot product (float) of the point coordinates and the plane normal.
+         */
+        dotCoordinate(point: Vector3): number;
+        /**
+         * Updates the current Plane from the plane defined by the three given points.
+         * @param point1 one of the points used to construct the plane
+         * @param point2 one of the points used to construct the plane
+         * @param point3 one of the points used to construct the plane
+         * @returns the updated Plane.
+         */
+        copyFromPoints(point1: Vector3, point2: Vector3, point3: Vector3): Plane;
+        /**
+         * Checks if the plane is facing a given direction (meaning if the plane's normal is pointing in the opposite direction of the given vector).
+         * Note that for this function to work as expected you should make sure that:
+         *   - direction and the plane normal are normalized
+         *   - epsilon is a number just bigger than -1, something like -0.99 for eg
+         * @param direction the direction to check if the plane is facing
+         * @param epsilon value the dot product is compared against (returns true if dot <= epsilon)
+         * @returns True if the plane is facing the given direction
+         */
+        isFrontFacingTo(direction: Vector3, epsilon: number): boolean;
+        /**
+         * Calculates the distance to a point
+         * @param point point to calculate distance to
+         * @returns the signed distance (float) from the given point to the Plane.
+         */
+        signedDistanceTo(point: Vector3): number;
+        /**
+         * Creates a plane from an  array
+         * @param array the array to create a plane from
+         * @returns a new Plane from the given array.
+         */
+        static FromArray(array: ArrayLike<number>): Plane;
+        /**
+         * Creates a plane from three points
+         * @param point1 point used to create the plane
+         * @param point2 point used to create the plane
+         * @param point3 point used to create the plane
+         * @returns a new Plane defined by the three given points.
+         */
+        static FromPoints(point1: Vector3, point2: Vector3, point3: Vector3): Plane;
+        /**
+         * Creates a plane from an origin point and a normal
+         * @param origin origin of the plane to be constructed
+         * @param normal normal of the plane to be constructed
+         * @returns a new Plane the normal vector to this plane at the given origin point.
+         * Note : the vector "normal" is updated because normalized.
+         */
+        static FromPositionAndNormal(origin: Vector3, normal: Vector3): Plane;
+        /**
+         * Calculates the distance from a plane and a point
+         * @param origin origin of the plane to be constructed
+         * @param normal normal of the plane to be constructed
+         * @param point point to calculate distance to
+         * @returns the signed distance between the plane defined by the normal vector at the "origin"" point and the given other point.
+         */
+        static SignedDistanceToPlaneFromPositionAndNormal(origin: Vector3, normal: Vector3, point: Vector3): number;
+    }
+    /** 二维向量 */
+    class Vector2 {
+        private static _ZeroReadOnly;
+        x: number;
+        y: number;
+        constructor(_x?: number, _y?: number);
+        toString(): string;
+        getHashCode(): number;
+        toArray(): number[];
+        fromArray(array: number[]): void;
+        copyFrom(source: Vector2): void;
+        set(x: number, y: number): void;
+        add(otherVector: Vector2): this;
+        addVector3(otherVector: Vector3): this;
+        subtract(otherVector: Vector2): this;
+        multiply(otherVector: Vector2): this;
+        multiplyByFloats(x: number, y: number): Vector2;
+        divide(otherVector: Vector2): this;
+        negate(): this;
+        scale(scale: number): this;
+        equals(otherVector: Vector2): boolean;
+        floor(): Vector2;
+        fract(): Vector2;
+        rotate(angle: number): Vector2;
+        length(): number;
+        lengthSquared(): number;
+        normalize(): this;
+        clone(): Vector2;
+        static Zero(): Vector2;
+        static One(): Vector2;
+        static Random(min?: number, max?: number): Vector2;
+        static get ZeroReadOnly(): Vector2;
+        static FromArray(array: ArrayLike<number>, offset?: number): Vector2;
+        static FromArrayToRef<T extends Vector2>(array: ArrayLike<number>, offset: number, result: T): T;
+        static CatmullRomVector2(value1: Vector2, value2: Vector2, value3: Vector2, value4: Vector2, amount: number): Vector2;
+        static Clamp(value: Vector2, min: Vector2, max: Vector2): Vector2;
+        static Hermite(value1: Vector2, tangent1: Vector2, value2: Vector2, tangent2: Vector2, amount: number): Vector2;
+        static Hermite1stDerivative(value1: Vector2, tangent1: Vector2, value2: Vector2, tangent2: Vector2, time: number): Vector2;
+        static Lerp(start: Vector2, end: Vector2, amount: number): Vector2;
+        static Dot(left: Vector2, right: Vector2): number;
+        static Normalize(vector: Vector2): Vector2;
+        static Minimize(left: Vector2, right: Vector2): Vector2;
+        static Maximize(left: Vector2, right: Vector2): Vector2;
+        static PointInTriangle(p: Vector2, p0: Vector2, p1: Vector2, p2: Vector2): boolean;
+        static Distance(value1: Vector2, value2: Vector2): number;
+        static DistanceSquared(value1: Vector2, value2: Vector2): number;
+        static Center(value1: Vector2, value2: Vector2): Vector2;
+        static DistanceOfPointFromSegment(p: Vector2, segA: Vector2, segB: Vector2): number;
+    }
+    /** 三维向量 */
+    class Vector3 {
+        private static _UpReadOnly;
+        private static _DownReadOnly;
+        private static _LeftHandedForwardReadOnly;
+        private static _RightHandedForwardReadOnly;
+        private static _LeftHandedBackwardReadOnly;
+        private static _RightHandedBackwardReadOnly;
+        private static _RightReadOnly;
+        private static _LeftReadOnly;
+        private static _ZeroReadOnly;
+        private _x;
+        private _y;
+        private _z;
+        private _isDirty;
+        get x(): number;
+        set x(value: number);
+        get y(): number;
+        set y(value: number);
+        get z(): number;
+        set z(value: number);
+        constructor(x?: number, y?: number, z?: number);
+        toString(): string;
+        getHashCode(): number;
+        asArray(): number[];
+        toArray(array: number[], index?: number): this;
+        fromArray(array: ArrayLike<number>, offset: number): this;
+        add(otherVector: Vector3): this;
+        addFromFloats(x: number, y: number, z: number): this;
+        addToRef(otherVector: Vector3): Vector3;
+        subtract(otherVector: Vector3): this;
+        subtractToRef(otherVector: Vector3): Vector3;
+        subtractFromFloats(x: number, y: number, z: number): this;
+        negate(): this;
+        scale(scale: number): this;
+        scaleToRef(scale: number): Vector3;
+        getNormalToRef(): Vector3;
+        projectOnPlane(plane: Plane, origin: Vector3): Vector3;
+        equals(otherVector: Vector3): boolean;
+        equalsToFloats(x: number, y: number, z: number): boolean;
+        multiplyInPlace(otherVector: Vector3): this;
+        multiply(otherVector: Vector3): Vector3;
+        multiplyToRef(otherVector: Vector3): Vector3;
+        multiplyByFloats(x: number, y: number, z: number): Vector3;
+        divide(otherVector: Vector3): Vector3;
+        divideToRef(otherVector: Vector3): Vector3;
+        divideInPlace(otherVector: Vector3): Vector3;
+        minimizeInPlace(other: Vector3): this;
+        maximizeInPlace(other: Vector3): this;
+        minimizeInPlaceFromFloats(x: number, y: number, z: number): this;
+        maximizeInPlaceFromFloats(x: number, y: number, z: number): this;
+        get isNonUniform(): boolean;
+        floor(): Vector3;
+        fract(): Vector3;
+        length(): number;
+        lengthSquared(): number;
+        get hasAZeroComponent(): boolean;
+        normalize(): this;
+        cross(other: Vector3): Vector3;
+        normalizeFromLength(len: number): this;
+        normalizeToNew(): Vector3;
+        normalizeToRef(): Vector3;
+        clone(): Vector3;
+        copyFrom(source: Vector3): this;
+        copyFromFloats(x: number, y: number, z: number): this;
+        set(x: number, y: number, z: number): this;
+        setAll(v: number): this;
+        static GetClipFactor(vector0: Vector3, vector1: Vector3, axis: Vector3, size: number): number;
+        static GetAngleBetweenVectors(vector0: Vector3, vector1: Vector3, normal: Vector3): number;
+        static GetAngleBetweenVectorsOnPlane(vector0: Vector3, vector1: Vector3, normal: Vector3): number;
+        static PitchYawRollToMoveBetweenPointsToRef(start: Vector3, target: Vector3): Vector3;
+        static PitchYawRollToMoveBetweenPoints(start: Vector3, target: Vector3): Vector3;
+        static SlerpToRef(vector0: Vector3, vector1: Vector3, slerp: number): Vector3;
+        static SmoothToRef<T extends Vector3 = Vector3>(source: Vector3, goal: Vector3, deltaTime: number, lerpTime: number): Vector3;
+        static FromArray(array: ArrayLike<number>, offset?: number): Vector3;
+        static FromFloatArray(array: Float32Array, offset?: number): Vector3;
+        static FromArrayToRef(array: ArrayLike<number>, offset: number): Vector3;
+        static FromFloatArrayToRef(array: Float32Array, offset: number): Vector3;
+        static FromFloatsToRef(x: number, y: number, z: number): Vector3;
+        static Zero(): Vector3;
+        static One(): Vector3;
+        static Up(): Vector3;
+        static get UpReadOnly(): Vector3;
+        static get DownReadOnly(): Vector3;
+        static get RightReadOnly(): Vector3;
+        static get LeftReadOnly(): Vector3;
+        static get LeftHandedForwardReadOnly(): Vector3;
+        static get RightHandedForwardReadOnly(): Vector3;
+        static get LeftHandedBackwardReadOnly(): Vector3;
+        static get RightHandedBackwardReadOnly(): Vector3;
+        static get ZeroReadOnly(): Vector3;
+        static Down(): Vector3;
+        static Forward(rightHandedSystem?: boolean): Vector3;
+        static Backward(rightHandedSystem?: boolean): Vector3;
+        static Right(): Vector3;
+        static Left(): Vector3;
+        static Random(min?: number, max?: number): Vector3;
+        static CatmullRom(value1: Vector3, value2: Vector3, value3: Vector3, value4: Vector3, amount: number): Vector3;
+        static Clamp(value: Vector3, min: Vector3, max: Vector3): Vector3;
+        static ClampToRef(value: Vector3, min: Vector3, max: Vector3): Vector3;
+        static CheckExtends(v: Vector3, min: Vector3, max: Vector3): void;
+        static Hermite(value1: Vector3, tangent1: Vector3, value2: Vector3, tangent2: Vector3, amount: number): Vector3;
+        static Hermite1stDerivative(value1: Vector3, tangent1: Vector3, value2: Vector3, tangent2: Vector3, time: number): Vector3;
+        static Hermite1stDerivativeToRef(value1: Vector3, tangent1: Vector3, value2: Vector3, tangent2: Vector3, time: number): Vector3;
+        static Lerp(start: Vector3, end: Vector3, amount: number): Vector3;
+        static LerpToRef(start: Vector3, end: Vector3, amount: number): Vector3;
+        static Dot(left: Vector3, right: Vector3): number;
+        static Cross(left: Vector3, right: Vector3): Vector3;
+        static CrossToRef(left: Vector3, right: Vector3): Vector3;
+        static Normalize(vector: Vector3): Vector3;
+        static NormalizeToRef(vector: Vector3): Vector3;
+        static Reflect(inDirection: Vector3, normal: Vector3): Vector3;
+        static ReflectToRef(inDirection: Vector3, normal: Vector3): Vector3;
+        static Distance(value1: Vector3, value2: Vector3): number;
+        static DistanceSquared(value1: Vector3, value2: Vector3): number;
+        static ProjectOnTriangleToRef(vector: Vector3, p0: Vector3, p1: Vector3, p2: Vector3, ref: Vector3): number;
+        static Center(value1: Vector3, value2: Vector3): Vector3;
+        static CenterToRef(value1: Vector3, value2: Vector3): Vector3;
+    }
+}