Vec.js from 偶弦

/**
 * @typedef {Object} UnitVec
 * @property {number} dx
 * @property {number} dy
 * @property {number} dz
 */

/**
 * 获取单位向量物件
 * @param {number} dx
 * @param {number} dy
 * @param {number} dz
 * @returns {UnitVec}
 */
function UnitVec(dx, dy, dz) {
  return {
    dx: dx,
    dy: dy,
    dz: dz,
  };
}

/**
 * @typedef {Object} YawPitch
 * @property {number} yaw
 * @property {number} pitch
 */

/**
 * 获取偏航角和俯仰角物件
 * @param {number} yaw
 * @param {number} pitch
 * @returns {YawPitch}
 */
function YawPitch(yaw, pitch) {
  return {
    yaw: yaw,
    pitch: pitch,
  };
}

function Distance(x, y, z) {
  return Math.sqrt(x * x + y * y + z * z);
}

/**
 * 获取玩家视线向量的单位向量
 * @param {Internal.Entity_} entity
 * @returns {UnitVec}
 */
function getUnitLookingVec(entity) {
  let tx = -Math.sin((entity.yaw / 180) * Math.PI);
  let ty = -Math.sin((entity.pitch / 180) * Math.PI);
  let tz = Math.cos((entity.yaw / 180) * Math.PI);

  let distance = Distance(tx, ty, tz);

  return UnitVec(tx / distance, ty / distance, tz / distance);
}

/**
 * 通过向量获取偏航角和俯仰角
 * @param {UnitVec} Vec
 * @returns {YawPitch}
 */
function getVecYaw(Vec) {
  let tyaw = (-Math.atan2(Vec.dx, Vec.dz) * 180) / Math.PI;
  let tpitch = (Math.asin(-Vec.dy) * 180) / Math.PI;

  return YawPitch(tyaw, tpitch);
}

/**
 * 获取规定向量向左旋转一定角度的向量的单位向量
 * @param {UnitVec} Vec
 * @param {number} angle
 * @returns {UnitVec}
 */
function getUnitLeftVec(Vec, angle) {
  let angles = getVecYaw(Vec);
  let leftVec = getLookUnitLeftVec(angles, angle);

  return UnitVec(leftVec.dx, leftVec.dy, leftVec.dz);
}

/**
 * 获取规定向量向右旋转一定角度的向量的单位向量
 * @param {UnitVec} Vec
 * @param {number} angle
 * @returns {UnitVec}
 */
function getUnitRightVec(Vec, angle) {
  let angles = getVecYaw(Vec);
  let rightVec = getLookUnitRightVec(angles, angle);

  return UnitVec(rightVec.dx, rightVec.dy, rightVec.dz);
}

/**
 * 获取视线向量向左旋转一定角度的向量的单位向量
 * @param {Internal.Entity_} entity
 * @param {number} angle
 * @returns {UnitVec}
 */
function getLookUnitLeftVec(entity, angle) {
  let x = -Math.sin(((entity.yaw - angle) / 180) * Math.PI);
  let y = -Math.sin((entity.pitch / 180) * Math.PI);
  let z = Math.cos(((entity.yaw - angle) / 180) * Math.PI);

  let distance = Distance(x, y, z);

  return UnitVec(x / distance, y / distance, z / distance);
}

/**
 * 获取视线向量向右旋转一定角度的向量的单位向量
 * @param {Internal.Entity_} entity
 * @param {number} angle
 * @returns {UnitVec}
 */
function getLookUnitRightVec(entity, angle) {
  let x = -Math.sin(((entity.yaw + angle) / 180) * Math.PI);
  let y = -Math.sin((entity.pitch / 180) * Math.PI);
  let z = Math.cos(((entity.yaw + angle) / 180) * Math.PI);

  let distance = Distance(x, y, z);

  return UnitVec(x / distance, y / distance, z / distance);
}

/**
 * 获取两个实体之间的单位向量
 * @param {Internal.Entity_} entity1
 * @param {Internal.Entity_} entity2
 * @returns {UnitVec}
 */
function getUnitVec(entity1, entity2) {
  let x = entity1.x - entity2.x;
  let y = entity1.y - entity2.y;
  let z = entity1.z - entity2.z;

  let distance = Distance(x, y, z);

  return UnitVec(x / distance, y / distance, z / distance);
}