@esengine/ecs-framework-math 1.0.3 → 2.8.0

package/bin/MathUtils.js

@@ -7,26 +7,26 @@ import { Vector2 } from './Vector2';
 export class MathUtils {
     // 角度转换
     /**
-     * 角度转弧度
-     * @param degrees 角度值
-     * @returns 弧度值
-     */
+   * 角度转弧度
+   * @param degrees 角度值
+   * @returns 弧度值
+   */
     static degToRad(degrees) {
         return degrees * MathUtils.DEG_TO_RAD;
     }
     /**
-     * 弧度转角度
-     * @param radians 弧度值
-     * @returns 角度值
-     */
+   * 弧度转角度
+   * @param radians 弧度值
+   * @returns 角度值
+   */
     static radToDeg(radians) {
         return radians * MathUtils.RAD_TO_DEG;
     }
     /**
-     * 规范化角度到[0, 2π)范围
-     * @param radians 角度（弧度）
-     * @returns 规范化后的角度
-     */
+   * 规范化角度到[0, 2π)范围
+   * @param radians 角度（弧度）
+   * @returns 规范化后的角度
+   */
     static normalizeAngle(radians) {
         while (radians < 0)
             radians += MathUtils.TWO_PI;
@@ -35,10 +35,10 @@ export class MathUtils {
         return radians;
     }
     /**
-     * 规范化角度到(-π, π]范围
-     * @param radians 角度（弧度）
-     * @returns 规范化后的角度
-     */
+   * 规范化角度到(-π, π]范围
+   * @param radians 角度（弧度）
+   * @returns 规范化后的角度
+   */
     static normalizeAngleSigned(radians) {
         while (radians <= -Math.PI)
             radians += MathUtils.TWO_PI;
@@ -47,63 +47,63 @@ export class MathUtils {
         return radians;
     }
     /**
-     * 计算两个角度之间的最短角度差
-     * @param from 起始角度（弧度）
-     * @param to 目标角度（弧度）
-     * @returns 角度差（-π到π）
-     */
+   * 计算两个角度之间的最短角度差
+   * @param from 起始角度（弧度）
+   * @param to 目标角度（弧度）
+   * @returns 角度差（-π到π）
+   */
     static angleDifference(from, to) {
         let diff = to - from;
         diff = MathUtils.normalizeAngleSigned(diff);
         return diff;
     }
     /**
-     * 角度插值（处理角度环绕）
-     * @param from 起始角度（弧度）
-     * @param to 目标角度（弧度）
-     * @param t 插值参数（0到1）
-     * @returns 插值结果角度
-     */
+   * 角度插值（处理角度环绕）
+   * @param from 起始角度（弧度）
+   * @param to 目标角度（弧度）
+   * @param t 插值参数（0到1）
+   * @returns 插值结果角度
+   */
     static lerpAngle(from, to, t) {
         const diff = MathUtils.angleDifference(from, to);
         return from + diff * t;
     }
     // 数值操作
     /**
-     * 限制数值在指定范围内
-     * @param value 待限制的值
-     * @param min 最小值
-     * @param max 最大值
-     * @returns 限制后的值
-     */
+   * 限制数值在指定范围内
+   * @param value 待限制的值
+   * @param min 最小值
+   * @param max 最大值
+   * @returns 限制后的值
+   */
     static clamp(value, min, max) {
         return Math.max(min, Math.min(max, value));
     }
     /**
-     * 限制数值在0到1之间
-     * @param value 待限制的值
-     * @returns 限制后的值
-     */
+   * 限制数值在0到1之间
+   * @param value 待限制的值
+   * @returns 限制后的值
+   */
     static clamp01(value) {
         return Math.max(0, Math.min(1, value));
     }
     /**
-     * 线性插值
-     * @param a 起始值
-     * @param b 目标值
-     * @param t 插值参数（0到1）
-     * @returns 插值结果
-     */
+   * 线性插值
+   * @param a 起始值
+   * @param b 目标值
+   * @param t 插值参数（0到1）
+   * @returns 插值结果
+   */
     static lerp(a, b, t) {
         return a + (b - a) * t;
     }
     /**
-     * 反向线性插值（获取插值参数）
-     * @param a 起始值
-     * @param b 目标值
-     * @param value 当前值
-     * @returns 插值参数
-     */
+   * 反向线性插值（获取插值参数）
+   * @param a 起始值
+   * @param b 目标值
+   * @param value 当前值
+   * @returns 插值参数
+   */
     static inverseLerp(a, b, value) {
         if (Math.abs(b - a) < MathUtils.EPSILON) {
             return 0;
@@ -111,132 +111,132 @@ export class MathUtils {
         return (value - a) / (b - a);
     }
     /**
-     * 重映射数值从一个范围到另一个范围
-     * @param value 输入值
-     * @param inMin 输入范围最小值
-     * @param inMax 输入范围最大值
-     * @param outMin 输出范围最小值
-     * @param outMax 输出范围最大值
-     * @returns 重映射后的值
-     */
+   * 重映射数值从一个范围到另一个范围
+   * @param value 输入值
+   * @param inMin 输入范围最小值
+   * @param inMax 输入范围最大值
+   * @param outMin 输出范围最小值
+   * @param outMax 输出范围最大值
+   * @returns 重映射后的值
+   */
     static remap(value, inMin, inMax, outMin, outMax) {
         const t = MathUtils.inverseLerp(inMin, inMax, value);
         return MathUtils.lerp(outMin, outMax, t);
     }
     /**
-     * 平滑阶跃函数（Hermite插值）
-     * @param t 输入参数（0到1）
-     * @returns 平滑输出（0到1）
-     */
+   * 平滑阶跃函数（Hermite插值）
+   * @param t 输入参数（0到1）
+   * @returns 平滑输出（0到1）
+   */
     static smoothStep(t) {
         t = MathUtils.clamp01(t);
         return t * t * (3 - 2 * t);
     }
     /**
-     * 更平滑的阶跃函数
-     * @param t 输入参数（0到1）
-     * @returns 平滑输出（0到1）
-     */
+   * 更平滑的阶跃函数
+   * @param t 输入参数（0到1）
+   * @returns 平滑输出（0到1）
+   */
     static smootherStep(t) {
         t = MathUtils.clamp01(t);
         return t * t * t * (t * (t * 6 - 15) + 10);
     }
     // 比较操作
     /**
-     * 浮点数相等比较
-     * @param a 数值a
-     * @param b 数值b
-     * @param epsilon 容差，默认为EPSILON
-     * @returns 是否相等
-     */
+   * 浮点数相等比较
+   * @param a 数值a
+   * @param b 数值b
+   * @param epsilon 容差，默认为EPSILON
+   * @returns 是否相等
+   */
     static approximately(a, b, epsilon = MathUtils.EPSILON) {
         return Math.abs(a - b) < epsilon;
     }
     /**
-     * 检查数值是否为零
-     * @param value 数值
-     * @param epsilon 容差，默认为EPSILON
-     * @returns 是否为零
-     */
+   * 检查数值是否为零
+   * @param value 数值
+   * @param epsilon 容差，默认为EPSILON
+   * @returns 是否为零
+   */
     static isZero(value, epsilon = MathUtils.EPSILON) {
         return Math.abs(value) < epsilon;
     }
     /**
-     * 获取数值的符号
-     * @param value 数值
-     * @returns 1、-1或0
-     */
+   * 获取数值的符号
+   * @param value 数值
+   * @returns 1、-1或0
+   */
     static sign(value) {
         return value > 0 ? 1 : value < 0 ? -1 : 0;
     }
     // 随机数生成
     /**
-     * 生成指定范围内的随机数
-     * @param min 最小值（包含）
-     * @param max 最大值（不包含）
-     * @returns 随机数
-     */
+   * 生成指定范围内的随机数
+   * @param min 最小值（包含）
+   * @param max 最大值（不包含）
+   * @returns 随机数
+   */
     static random(min = 0, max = 1) {
         return Math.random() * (max - min) + min;
     }
     /**
-     * 生成指定范围内的随机整数
-     * @param min 最小值（包含）
-     * @param max 最大值（包含）
-     * @returns 随机整数
-     */
+   * 生成指定范围内的随机整数
+   * @param min 最小值（包含）
+   * @param max 最大值（包含）
+   * @returns 随机整数
+   */
     static randomInt(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
     }
     /**
-     * 随机选择数组中的一个元素
-     * @param array 数组
-     * @returns 随机元素
-     */
+   * 随机选择数组中的一个元素
+   * @param array 数组
+   * @returns 随机元素
+   */
     static randomChoice(array) {
         return array[Math.floor(Math.random() * array.length)];
     }
     /**
-     * 生成随机布尔值
-     * @param probability 为true的概率（0到1），默认0.5
-     * @returns 随机布尔值
-     */
+   * 生成随机布尔值
+   * @param probability 为true的概率（0到1），默认0.5
+   * @returns 随机布尔值
+   */
     static randomBoolean(probability = 0.5) {
         return Math.random() < probability;
     }
     /**
-     * 生成单位圆内的随机点
-     * @returns 随机向量
-     */
+   * 生成单位圆内的随机点
+   * @returns 随机向量
+   */
     static randomInUnitCircle() {
         const angle = Math.random() * MathUtils.TWO_PI;
         const radius = Math.sqrt(Math.random());
         return Vector2.fromPolar(radius, angle);
     }
     /**
-     * 生成单位圆上的随机点
-     * @returns 随机单位向量
-     */
+   * 生成单位圆上的随机点
+   * @returns 随机单位向量
+   */
     static randomOnUnitCircle() {
         const angle = Math.random() * MathUtils.TWO_PI;
         return Vector2.fromAngle(angle);
     }
     // 数学函数
     /**
-     * 快速平方根倒数（用于归一化）
-     * @param value 输入值
-     * @returns 平方根倒数
-     */
+   * 快速平方根倒数（用于归一化）
+   * @param value 输入值
+   * @returns 平方根倒数
+   */
     static fastInverseSqrt(value) {
         // 简化版本，现代JavaScript引擎优化很好
         return 1 / Math.sqrt(value);
     }
     /**
-     * 快速幂运算（整数指数）
-     * @param base 底数
-     * @param exponent 指数（整数）
-     * @returns 幂运算结果
-     */
+   * 快速幂运算（整数指数）
+   * @param base 底数
+   * @param exponent 指数（整数）
+   * @returns 幂运算结果
+   */
     static fastPow(base, exponent) {
         if (exponent === 0)
             return 1;
@@ -249,10 +249,10 @@ export class MathUtils {
         return Math.pow(base, exponent);
     }
     /**
-     * 阶乘
-     * @param n 非负整数
-     * @returns 阶乘结果
-     */
+   * 阶乘
+   * @param n 非负整数
+   * @returns 阶乘结果
+   */
     static factorial(n) {
         if (n < 0)
             return NaN;
@@ -265,11 +265,11 @@ export class MathUtils {
         return result;
     }
     /**
-     * 最大公约数
-     * @param a 整数a
-     * @param b 整数b
-     * @returns 最大公约数
-     */
+   * 最大公约数
+   * @param a 整数a
+   * @param b 整数b
+   * @returns 最大公约数
+   */
     static gcd(a, b) {
         a = Math.abs(Math.floor(a));
         b = Math.abs(Math.floor(b));
@@ -281,20 +281,20 @@ export class MathUtils {
         return a;
     }
     /**
-     * 最小公倍数
-     * @param a 整数a
-     * @param b 整数b
-     * @returns 最小公倍数
-     */
+   * 最小公倍数
+   * @param a 整数a
+   * @param b 整数b
+   * @returns 最小公倍数
+   */
     static lcm(a, b) {
         return Math.abs(a * b) / MathUtils.gcd(a, b);
     }
     // 序列和级数
     /**
-     * 斐波那契数列
-     * @param n 项数
-     * @returns 第n项斐波那契数
-     */
+   * 斐波那契数列
+   * @param n 项数
+   * @returns 第n项斐波那契数
+   */
     static fibonacci(n) {
         if (n <= 0)
             return 0;
@@ -309,22 +309,22 @@ export class MathUtils {
         return b;
     }
     /**
-     * 等差数列求和
-     * @param first 首项
-     * @param last 末项
-     * @param count 项数
-     * @returns 等差数列和
-     */
+   * 等差数列求和
+   * @param first 首项
+   * @param last 末项
+   * @param count 项数
+   * @returns 等差数列和
+   */
     static arithmeticSum(first, last, count) {
         return (first + last) * count * 0.5;
     }
     /**
-     * 等比数列求和
-     * @param first 首项
-     * @param ratio 公比
-     * @param count 项数
-     * @returns 等比数列和
-     */
+   * 等比数列求和
+   * @param first 首项
+   * @param ratio 公比
+   * @param count 项数
+   * @returns 等比数列和
+   */
     static geometricSum(first, ratio, count) {
         if (Math.abs(ratio - 1) < MathUtils.EPSILON) {
             return first * count;
@@ -333,13 +333,13 @@ export class MathUtils {
     }
     // 曲线和插值
     /**
-     * 贝塞尔二次曲线
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param t 参数（0到1）
-     * @returns 曲线上的点
-     */
+   * 贝塞尔二次曲线
+   * @param p0 控制点0
+   * @param p1 控制点1
+   * @param p2 控制点2
+   * @param t 参数（0到1）
+   * @returns 曲线上的点
+   */
     static quadraticBezier(p0, p1, p2, t) {
         const u = 1 - t;
         const tt = t * t;
@@ -347,14 +347,14 @@ export class MathUtils {
         return new Vector2(uu * p0.x + 2 * u * t * p1.x + tt * p2.x, uu * p0.y + 2 * u * t * p1.y + tt * p2.y);
     }
     /**
-     * 贝塞尔三次曲线
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param p3 控制点3
-     * @param t 参数（0到1）
-     * @returns 曲线上的点
-     */
+   * 贝塞尔三次曲线
+   * @param p0 控制点0
+   * @param p1 控制点1
+   * @param p2 控制点2
+   * @param p3 控制点3
+   * @param t 参数（0到1）
+   * @returns 曲线上的点
+   */
     static cubicBezier(p0, p1, p2, p3, t) {
         const u = 1 - t;
         const tt = t * t;
@@ -364,14 +364,14 @@ export class MathUtils {
         return new Vector2(uuu * p0.x + 3 * uu * t * p1.x + 3 * u * tt * p2.x + ttt * p3.x, uuu * p0.y + 3 * uu * t * p1.y + 3 * u * tt * p2.y + ttt * p3.y);
     }
     /**
-     * Catmull-Rom样条插值
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param p3 控制点3
-     * @param t 参数（0到1）
-     * @returns 插值结果点
-     */
+   * Catmull-Rom样条插值
+   * @param p0 控制点0
+   * @param p1 控制点1
+   * @param p2 控制点2
+   * @param p3 控制点3
+   * @param t 参数（0到1）
+   * @returns 插值结果点
+   */
     static catmullRom(p0, p1, p2, p3, t) {
         const t2 = t * t;
         const t3 = t2 * t;
@@ -387,23 +387,23 @@ export class MathUtils {
     }
     // 噪声函数
     /**
-     * 简单伪随机噪声（基于种子）
-     * @param x 输入X
-     * @param y 输入Y
-     * @param seed 种子
-     * @returns 噪声值（0到1）
-     */
+   * 简单伪随机噪声（基于种子）
+   * @param x 输入X
+   * @param y 输入Y
+   * @param seed 种子
+   * @returns 噪声值（0到1）
+   */
     static noise(x, y = 0, seed = 0) {
-        let n = Math.sin(x * 12.9898 + y * 78.233 + seed * 37.719) * 43758.5453;
+        const n = Math.sin(x * 12.9898 + y * 78.233 + seed * 37.719) * 43758.5453;
         return n - Math.floor(n);
     }
     /**
-     * 平滑噪声
-     * @param x 输入X
-     * @param y 输入Y
-     * @param seed 种子
-     * @returns 平滑噪声值（0到1）
-     */
+   * 平滑噪声
+   * @param x 输入X
+   * @param y 输入Y
+   * @param seed 种子
+   * @returns 平滑噪声值（0到1）
+   */
     static smoothNoise(x, y = 0, seed = 0) {
         const intX = Math.floor(x);
         const intY = Math.floor(y);
@@ -419,56 +419,56 @@ export class MathUtils {
     }
     // 实用工具
     /**
-     * 将数值转换为指定精度
-     * @param value 数值
-     * @param precision 精度（小数位数）
-     * @returns 转换后的数值
-     */
+   * 将数值转换为指定精度
+   * @param value 数值
+   * @param precision 精度（小数位数）
+   * @returns 转换后的数值
+   */
     static toPrecision(value, precision) {
         const factor = Math.pow(10, precision);
         return Math.round(value * factor) / factor;
     }
     /**
-     * 检查数值是否在指定范围内
-     * @param value 数值
-     * @param min 最小值
-     * @param max 最大值
-     * @returns 是否在范围内
-     */
+   * 检查数值是否在指定范围内
+   * @param value 数值
+   * @param min 最小值
+   * @param max 最大值
+   * @returns 是否在范围内
+   */
     static inRange(value, min, max) {
         return value >= min && value <= max;
     }
     /**
-     * 获取数组中的最小值
-     * @param values 数值数组
-     * @returns 最小值
-     */
+   * 获取数组中的最小值
+   * @param values 数值数组
+   * @returns 最小值
+   */
     static min(...values) {
         return Math.min(...values);
     }
     /**
-     * 获取数组中的最大值
-     * @param values 数值数组
-     * @returns 最大值
-     */
+   * 获取数组中的最大值
+   * @param values 数值数组
+   * @returns 最大值
+   */
     static max(...values) {
         return Math.max(...values);
     }
     /**
-     * 计算数组的平均值
-     * @param values 数值数组
-     * @returns 平均值
-     */
+   * 计算数组的平均值
+   * @param values 数值数组
+   * @returns 平均值
+   */
     static average(values) {
         if (values.length === 0)
             return 0;
         return values.reduce((sum, val) => sum + val, 0) / values.length;
     }
     /**
-     * 计算数组的中位数
-     * @param values 数值数组
-     * @returns 中位数
-     */
+   * 计算数组的中位数
+   * @param values 数值数组
+   * @returns 中位数
+   */
     static median(values) {
         if (values.length === 0)
             return 0;