idioms/idiom/temp/programming/packer-driver/targets/editor/chunks/2d/2d836b3dc11c70cd1a8621bc539f2b1ca2080115.js

System.register(["cc"], function (_export, _context) {
  "use strict";

  var _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, misc, Vec2, Vec3, MathUtil, _crd, tempVec3, rad2Deg, deg2Rad;

  _export("MathUtil", void 0);

  return {
    setters: [function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      misc = _cc.misc;
      Vec2 = _cc.Vec2;
      Vec3 = _cc.Vec3;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "5df23qNkJ5Jco4b72bZLJJf", "MathUtil", undefined);

      /** 用于计算的临时工 */
      __checkObsolete__(['misc', 'Rect', 'Vec2', 'Vec3']);

      tempVec3 = new Vec3();
      /** 用于弧度转角度 */

      rad2Deg = 180 / Math.PI;
      /** 用于角度转弧度 */

      deg2Rad = Math.PI / 180;

      _export("MathUtil", MathUtil = class MathUtil {
        /**
        * 用于弧度转角度
        */
        static get rad2Deg() {
          return rad2Deg;
        }
        /**
         * 用于角度转弧度
         */


        static get deg2Rad() {
          return deg2Rad;
        }
        /**
        * 弧度转角度
        * @param radians 
        */


        static radiansToDegrees(radians) {
          return radians * rad2Deg;
        }
        /**
         * 角度转弧度
         * @param degree 
         */


        static degreesToRadians(degree) {
          return degree * deg2Rad;
        }
        /**限制数大小 */


        static Clamp(value, min, max) {
          if (value < min) {
            value = min;
          } else if (value > max) {
            value = max;
          }

          return value;
        }

        static Clamp01(value) {
          return this.Clamp(value, 0, 1);
        }

        static PingPong(t, length) {
          t = this.Repeat(t, length * 2);
          return length - Math.abs(t - length);
        }

        static Repeat(t, length) {
          return t - Math.floor(t / length) * length;
        }

        static Round(num) {
          return Math.floor(num + 0.5);
        }

        static Sign(num) {
          if (num > 0) {
            num = 1;
          } else if (num < 0) {
            num = -1;
          } else {
            num = 0;
          }

          return num;
        }

        static InverseLerp(from, to, value) {
          if (from < to) {
            if (value < from) return 0;
            if (value > to) return 1;
            value = value - from;
            value = value / (to - from);
            return value;
          }

          if (from <= to) return 0;
          if (value < to) return 1;
          if (value > from) return 0;
          return 1 - (value - to) / (from - to);
        }

        static Lerp(from, to, t) {
          return from + (to - from) * this.Clamp01(t);
        }

        static LerpUnclamped(a, b, t) {
          return a + (b - a) * t;
        }

        static DeltaAngle(current, target) {
          let num = this.Repeat(target - current, 360);
          if (num > 180) num = num - 360;
          return num;
        }

        static LerpAngle(a, b, t) {
          let num = this.Repeat(b - a, 360);
          if (num > 180) num = num - 360;
          return a + num * this.Clamp01(t);
        }
        /**
         * 在最小值和最大值之间进行插值，并在极限处进行平滑处理
         * @param from 
         * @param to 
         * @param t 
         */


        static smoothStep(from, to, t) {
          t = this.Clamp01(t);
          t = -2.0 * t * t * t + 3.0 * t * t;
          return to * t + from * (1.0 - t);
        }
        /**
        * 平滑控制
        * @param current 当前值
        * @param target 目标值
        * @param currentVelocity 当前速度
        * @param smoothTime 平滑时间
        * @param maxSpeed 最大速度
        * @param deltaTime 时间增量
        */


        static smoothDamp(current, target, currentVelocity, smoothTime, deltaTime, maxSpeed = Number.POSITIVE_INFINITY) {
          smoothTime = Math.max(0.0001, smoothTime);
          const num1 = 2 / smoothTime;
          const num2 = num1 * deltaTime;
          const num3 = 1 / (1 + num2 + 0.47999998927116394 * num2 * num2 + 0.23499999940395355 * num2 * num2 * num2);
          const num4 = current - target;
          const num5 = target;
          const max = maxSpeed * smoothTime;
          const num6 = this.Clamp(num4, -max, max);
          target = current - num6;
          const num7 = (currentVelocity + num1 * num6) * deltaTime;
          let velocity = (currentVelocity - num1 * num7) * num3;
          let num8 = target + (num6 + num7) * num3;

          if (num5 - current > 0 === num8 > num5) {
            num8 = num5;
            velocity = (num8 - num5) / deltaTime;
          }

          return {
            value: num8,
            velocity: velocity
          };
        }
        /**
         * 垂直于原向量V的单位向量
         * @param v 一个向量
         * @returns 
         */


        static getPerpendicular(v) {
          const perpendicular = new Vec2(-v.y, v.x); //计算垂直向量

          const normal = perpendicular.normalize(); //归一化

          return normal;
        } //角度转向量  


        static angleToVector(angle) {
          return this.zore.clone().rotate(-misc.degreesToRadians(angle));
        } // 向量转角度


        static vectorToAngle(dir) {
          return -misc.radiansToDegrees(dir.signAngle(this.zore));
        } // 角度转向量   


        static angle_to_vector(angle) {
          // tan = sin / cos
          // 将传入的角度转为弧度
          let radian = this.degreesToRadians(angle); // 算出cos,sin和tan

          let cos = Math.cos(radian); // 邻边 / 斜边

          let sin = Math.sin(radian); // 对边 / 斜边

          let tan = sin / cos; // 对边 / 邻边
          // 结合在一起并归一化

          let vec = new Vec2(cos, sin).normalize(); // 返回向量

          return vec;
        } // ！！！！！！！！其实使用Math.atan2求出弧度再转角度一样的效果
        // 向量转角度


        static vector_to_angle(dir) {
          // 将传入的向量归一化 一般已经归一化了
          //dir.normalize();
          // 计算出目标角度的弧度
          let radian = dir.signAngle(this.zore); // 把弧度计算成角度

          let angle = -this.radiansToDegrees(radian); // 返回角度

          return angle;
        } //向量转弧度


        static vector_to_radian(dir) {
          return dir.signAngle(this.zore);
        } /// <summary>
        /// 旋转向量，使其方向改变，大小不变
        /// </summary>
        /// <param name="v">需要旋转的向量</param>
        /// <param name="angle">旋转的角度</param>
        /// <returns>旋转后的向量</returns>


        static RotationMatrix(x, y, angle) {
          let radian = this.degreesToRadians(angle);
          let sin = Math.sin(radian);
          var cos = Math.cos(radian);
          var newX = x * cos + y * sin;
          var newY = x * -sin + y * cos; //var newX = x * cos - y * sin;
          //var newY = x * sin + y * cos;

          return new Vec2(newX, newY);
        }

        static RotationDir(dir, angle) {
          let radian = this.radiansToDegrees(angle);
          let sin = Math.sin(radian);
          var cos = Math.cos(radian);
          var newX = dir.x * cos + dir.y * sin;
          var newY = dir.x * -sin + dir.y * cos;
          dir.x = newX;
          dir.y = newY;
          return dir;
        } //扇形范围


        static CheckInView(mPos, faceDir, tPos, dis, angle) {
          //let t = tPos.subtract(mPos);
          //let distance = Vec2.lengthSqr(t);
          //if(distance<dis*dis)
          let distance = Vec2.distance(mPos, tPos);

          if (distance < dis) {
            if (angle >= 360) return true;
            let dir = tPos.subtract(mPos).normalize();
            let ang = this.radiansToDegrees(Vec2.angle(faceDir, dir));

            if (ang <= angle * 0.5) {
              return true;
            }
          }

          return false;
        } //检测点是否在一个凸四边形内


        static InConvexQuad(point, pointA, pointB, pointC, pointD) {
          let vec1, vec2;
          vec1.x = pointB.x - pointA.x;
          vec1.y = pointB.y - pointA.y;
          vec2.x = point.x - pointA.x;
          vec2.y = point.y - pointA.y;
          if (this.cross2DPoint(vec2.x, vec2.y, vec1.x, vec1.y)) return false;
          vec1.x = pointC.x - pointB.x;
          vec1.y = pointC.y - pointB.y;
          vec2.x = point.x - pointB.x;
          vec2.y = point.y - pointB.y;
          if (this.cross2DPoint(vec2.x, vec2.y, vec1.x, vec1.y)) return false;
          vec1.x = pointD.x - pointC.x;
          vec1.y = pointD.y - pointC.y;
          vec2.x = point.x - pointC.x;
          vec2.y = point.y - pointC.y;
          if (this.cross2DPoint(vec2.x, vec2.y, vec1.x, vec1.y)) return false;
          vec1.x = pointA.x - pointD.x;
          vec1.y = pointA.y - pointD.y;
          vec2.x = point.x - pointD.x;
          vec2.y = point.y - pointD.y;
          if (this.cross2DPoint(vec2.x, vec2.y, vec1.x, vec1.y)) return false;
          return true;
        }
        /**等同于Vec2.cross */


        static cross2DPoint(x1, y1, x2, y2) {
          return x1 * y2 - x2 * y1;
        }
        /**检测两个2D包围盒(xy为中心点 wh分别为x轴半径宽 y轴半径宽) 是否相交*/


        static AABBAABB2D(pointX1, pointY1, w1, h1, pointX2, pointY2, w2, h2) {
          if (Math.abs(pointX1 - pointX2) > w1 + w2) return false;
          if (Math.abs(pointY1 - pointY2) > h1 + h2) return false;
          return true;
        }
        /**检测两个3D包围盒 是否相交*/


        static AABBAABB3D(pointX1, pointY1, pointZ1, w1, h1, t1, pointX2, pointY2, pointZ2, w2, h2, t2) {
          if (Math.abs(pointX1 - pointX2) > w1 + w2) return false;
          if (Math.abs(pointY1 - pointY2) > h1 + h2) return false;
          if (Math.abs(pointZ1 - pointZ2) > t1 + t2) return false;
          return true;
        }
        /**点与点*/


        static pointPoint(point1, point2) {
          if (point1.x == point2.x && point1.y == point2.y) {
            return true;
          }

          return false;
        } //判断点是否在线上，在返回1，不在返回0


        static onSegement(Q, p1, p2) {
          let maxx, minx, maxy, miny;
          maxx = p1.x > p2.x ? p1.x : p2.x; //矩形的右边长

          minx = p1.x > p2.x ? p2.x : p1.x; //矩形的左边长

          maxy = p1.y > p2.y ? p1.y : p2.y; //矩形的上边长

          miny = p1.y > p2.y ? p2.y : p1.y; //矩形的下边长

          if ((Q.x - p1.x) * (p2.y - p1.y) == (p2.x - p1.x) * (Q.y - p1.y) && Q.x >= minx && Q.x <= maxx && Q.y >= miny && Q.y <= maxy) {
            return true;
          }

          return false;
        } //点与圆的碰撞
        //通过计算点到圆心的距离与半径比较判断circle(由中心点和半径构成)


        static pointInCircle(point, center, radius) {
          return Vec2.squaredDistance(point, center) <= radius * radius;
        } //点与矩形的碰撞
        //通过判断点坐标是否在矩形四个顶点围成的坐标区域内


        static pointInRect(point, rect) {
          if (point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height) return true;
          return false;
        } //线与矩形的碰撞


        static lineInRect(p1, p2, rect) {
          let height = p1.y - p2.y;
          let width = p2.x - p1.x;
          let c = p1.x * p2.y - p2.x - p1.y; //计算叉乘

          if (height * rect.xMin + width * rect.yMin + c >= 0 && height * rect.xMax + width * rect.yMax + c <= 0 || height * rect.xMin + width * rect.yMin + c <= 0 && height * rect.xMax + width * rect.yMax + c >= 0 || height * rect.xMin + width * rect.yMax + c >= 0 && height * rect.xMax + width * rect.yMin + c <= 0 || height * rect.xMin + width * rect.yMax + c <= 0 && height * rect.xMax + width * rect.yMin + c >= 0) {
            if (p1.x < rect.xMin && p2.x < rect.xMin || p1.x > rect.xMax && p2.x > rect.xMax || p1.y > rect.yMin && p2.y > rect.yMin || p1.y < rect.yMax && p2.y < rect.yMax) {
              return false;
            } else {
              return true;
            }
          } else {
            return false;
          }
        } //两个rect是否相交


        static collisionRectWithRect(rect1, rect2) {
          //计算相交部分的矩形
          //左下角坐标：( lx , ly )    //右上角坐标：( rx , ry )
          let lx = Math.max(rect1.xMin, rect2.xMin);
          let ly = Math.max(rect1.yMin, rect2.yMin);
          let rx = Math.min(rect1.xMax, rect2.xMax);
          let ry = Math.min(rect1.yMax, rect2.yMax); //判断是否能构成小矩形

          if (lx > rx || ly > ry) return false; //矩形不相交

          return true; //发生碰撞
        } //圆与矩形是否相交


        static collisionRectWithCircle(rect, p, r) {
          //获取矩形信息
          //左下角坐标：( lx , ly )
          //右上角坐标：( rx , ry )
          let lx = rect.xMin;
          let ly = rect.yMin;
          let rx = rect.xMax;
          let ry = rect.yMax; //计算圆心到四个顶点的距离

          let d1 = Vec2.distance(p, new Vec2(lx, ly));
          let d2 = Vec2.distance(p, new Vec2(lx, ry));
          let d3 = Vec2.distance(p, new Vec2(rx, ly));
          let d4 = Vec2.distance(p, new Vec2(rx, ry)); //判断是否碰撞//判断距离是否小于半径

          if (d1 < r || d2 < r || d3 < r || d4 < r) return true; //是否在圆角矩形的，横向矩形内

          if (p.x > lx - r && p.x < rx + r && p.y > ly && p.y < ry) return true; //是否在圆角矩形的，纵向矩形内

          if (p.x > lx && p.x < rx && p.y > ly - r && p.y < ry + r) return true; //不发生碰撞

          return false;
        }
        /**
           * 计算向量在指定平面上的投影
           * @param vector 被投影的向量
           * @param planeNormal 平面法线
           */


        static projectOnPlane(vector, planeNormal) {
          // 也可以直接用 Vec3 自带的平面投影函数
          // return Vec3.projectOnPlane(new Vec3, targetDir, planeNormal);
          // 使用点乘计算方向矢量在平面法线上的投影长度
          const projectionLength = Vec3.dot(vector, planeNormal); // 平面法线与长度相乘得到方向矢量在平面法线上的投影矢量

          const vectorOnPlane = tempVec3.set(planeNormal).multiplyScalar(projectionLength); // 方向矢量减去其在平面法线上的投影矢量即是其在平面上的投影矢量

          return Vec3.subtract(new Vec3(), vector, vectorOnPlane);
        }
        /**
         * 计算两个向量基于指定轴的夹角（逆时针方向为正方向，值范围 -180 ~ 180）
         * @param a 向量 a
         * @param b 向量 b
         * @param axis 参照轴向量（请确保是归一化的）
         */


        static signedAngle(a, b, axis) {
          // 将向量 a 和 b 分别投影到以 axis 为法线的平面上
          const aOnAxisPlane = this.projectOnPlane(a, axis);
          const bOnAxisPlane = this.projectOnPlane(b, axis); // 归一化处理

          const aNormalized = aOnAxisPlane.normalize();
          const bNormalized = bOnAxisPlane.normalize(); // 求出同时垂直于 a 和 b 的法向量

          const abNormal = Vec3.cross(new Vec3(), aNormalized, bNormalized).normalize(); // 将法向量到 axis 上的投影长度
          // 若投影长度为正值（+1）则表示法向量与 axis 同向（向量叉乘的右手法则）

          const sign = Vec3.dot(abNormal, axis); // 求出向量 a 和 b 的夹角

          const radian = Math.acos(Vec3.dot(aNormalized, bNormalized)); // 混合在一起！

          return radian * sign * this.rad2Deg;
        } //获取某点到某点的Y轴方向


        static GetYDir(from, to) {
          let dir = to.subtract(from);
          dir.y = from.y;
          return dir.normalize();
        } //向量绕Y轴转一个角度


        static RotateAroundAxisY(dir, angle) {
          dir = dir.clone();
          let rad = this.degreesToRadians(angle);
          let cos = Math.cos(rad);
          let sin = Math.sin(rad);
          dir.x = dir.x * cos + dir.z * sin;
          dir.z = dir.x * -sin + dir.z * cos;
          return dir;
        } //将一个向量围绕X轴旋转angle个角度


        static RotateAroundAxisX(dir, angle) {
          dir = dir.clone();
          let rad = this.degreesToRadians(angle);
          let cos = Math.cos(rad);
          let sin = Math.sin(rad);
          dir.y = dir.y * cos - dir.z * sin;
          dir.z = dir.y * sin + dir.z * cos;
          return dir;
        } //将一个向量围绕Z轴旋转angle个角度


        static RotateAroundAxisZ(dir, angle) {
          dir = dir.clone();
          let rad = this.degreesToRadians(angle);
          let cos = Math.cos(rad);
          let sin = Math.sin(rad);
          dir.x = dir.x * cos - dir.y * sin;
          dir.y = dir.x * sin + dir.y * cos;
          return dir;
        } //线段是否与矩形相交


        static LineRectIntersection(lineStartPoint, lineEndPoint, rectMinX, rectMaxX, rectMinY, rectMaxY) {
          //针对四种不同的情况，进行碰撞检测
          let minXLinePoint = lineEndPoint;

          if (lineStartPoint.x <= lineEndPoint.x) {
            minXLinePoint = lineStartPoint;
          }

          let maxXLinePoint = lineStartPoint;

          if (lineStartPoint.x <= lineEndPoint.x) {
            maxXLinePoint = lineEndPoint;
          }

          let minYLinePoint = lineEndPoint;

          if (lineStartPoint.y <= lineEndPoint.y) {
            minYLinePoint = lineStartPoint;
          }

          let maxYLinePoint = lineStartPoint;

          if (lineStartPoint.y <= lineEndPoint.y) {
            maxYLinePoint = lineEndPoint;
          }

          if (minXLinePoint.x <= rectMinX && rectMinX <= maxXLinePoint.x) {
            let m = (maxXLinePoint.y - minXLinePoint.y) / (maxXLinePoint.x - minXLinePoint.x);
            let intersectionY = (rectMinX - minXLinePoint.x) * m + minXLinePoint.y;

            if (minYLinePoint.y <= intersectionY && intersectionY <= maxYLinePoint.y && rectMinY <= intersectionY && intersectionY <= rectMaxY) {
              return true; //new Vec2(rectMinX, intersectionY)
            }
          }

          if (minXLinePoint.x <= rectMaxX && rectMaxX <= maxXLinePoint.x) {
            let m = (maxXLinePoint.y - minXLinePoint.y) / (maxXLinePoint.x - minXLinePoint.x);
            let intersectionY = (rectMaxX - minXLinePoint.x) * m + minXLinePoint.y;

            if (minYLinePoint.y <= intersectionY && intersectionY <= maxYLinePoint.y && rectMinY <= intersectionY && intersectionY <= rectMaxY) {
              return true; //new Vec2(rectMaxX, intersectionY)
            }
          }

          if (minYLinePoint.y <= rectMaxY && rectMaxY <= maxYLinePoint.y) {
            let rm = (maxYLinePoint.x - minYLinePoint.x) / (maxYLinePoint.y - minYLinePoint.y);
            let intersectionX = (rectMaxY - minYLinePoint.y) * rm + minYLinePoint.x;

            if (minXLinePoint.x <= intersectionX && intersectionX <= maxXLinePoint.x && rectMinX <= intersectionX && intersectionX <= rectMaxX) {
              return true; //new Vec2(intersectionX, rectMaxY)
            }
          }

          if (minYLinePoint.y <= rectMinY && rectMinY <= maxYLinePoint.y) {
            let rm = (maxYLinePoint.x - minYLinePoint.x) / (maxYLinePoint.y - minYLinePoint.y);
            let intersectionX = (rectMinY - minYLinePoint.y) * rm + minYLinePoint.x;

            if (minXLinePoint.x <= intersectionX && intersectionX <= maxXLinePoint.x && rectMinX <= intersectionX && intersectionX <= rectMaxX) {
              return true; //new Vec2(intersectionX, rectMinY)
            }
          }

          return false;
        }

      });

      MathUtil.zore = new Vec2(1, 0);

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=2d836b3dc11c70cd1a8621bc539f2b1ca2080115.js.map