three-player-controller 0.1.0

package/dist/index.js

@@ -0,0 +1,894 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  offAllEvent: () => offAllEvent,
+  onAllEvent: () => onAllEvent,
+  usePlayer: () => usePlayer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/playerController.ts
+var THREE = __toESM(require("three"));
+var import_three_mesh_bvh = require("three-mesh-bvh");
+var import_RoundedBoxGeometry = require("three/examples/jsm/geometries/RoundedBoxGeometry.js");
+var import_DRACOLoader = require("three/examples/jsm/loaders/DRACOLoader.js");
+var import_GLTFLoader = require("three/examples/jsm/loaders/GLTFLoader.js");
+var BufferGeometryUtils = __toESM(require("three/examples/jsm/utils/BufferGeometryUtils.js"));
+var controllerInstance = null;
+var PlayerController = class {
+  // 射线检测时只返回第一个碰撞
+  constructor() {
+    this.loader = new import_GLTFLoader.GLTFLoader();
+    this.isFirstPerson = false;
+    this.mouseSensity = 5;
+    this.boundingBoxMinY = 0;
+    // 测试参数
+    this.displayPlayer = false;
+    this.displayCollider = false;
+    this.displayVisualizer = false;
+    //  场景对象
+    this.collider = null;
+    this.visualizer = null;
+    this.person = null;
+    //  状态开关
+    this.playerIsOnGround = false;
+    this.isUpdatePlayer = true;
+    //  输入状态
+    this.fwdPressed = false;
+    // w
+    this.bkdPressed = false;
+    // s
+    this.lftPressed = false;
+    // a
+    this.rgtPressed = false;
+    // d
+    this.spacePressed = false;
+    // 空格
+    this.ctPressed = false;
+    // ctrl
+    this.shiftPressed = false;
+    // shift
+    this.sustainSpacePressed = false;
+    // 空格键是否持续按下
+    this.spaceLongPressTimer = null;
+    // 第三人称
+    this._camCollisionLerp = 0.18;
+    // 平滑系数
+    this._camEpsilon = 0.35;
+    // 摄像机与障碍物之间的安全距离（米）
+    this._minCamDistance = 1;
+    // 摄像机最小距离
+    this._maxCamDistance = 4.4;
+    // 摄像机最大距离
+    //  物理/运动
+    this.playerVelocity = new THREE.Vector3();
+    // 玩家速度向量
+    this.upVector = new THREE.Vector3(0, 1, 0);
+    //  临时复用向量/矩阵
+    this.tempVector = new THREE.Vector3();
+    this.tempVector2 = new THREE.Vector3();
+    this.tempBox = new THREE.Box3();
+    this.tempMat = new THREE.Matrix4();
+    this.tempSegment = new THREE.Line3();
+    //  复用向量：用于相机朝向 / 移动
+    this.camDir = new THREE.Vector3();
+    this.moveDir = new THREE.Vector3();
+    this.targetQuat = new THREE.Quaternion();
+    this.targetMat = new THREE.Matrix4();
+    this.rotationSpeed = 10;
+    this.DIR_FWD = new THREE.Vector3(0, 0, -1);
+    this.DIR_BKD = new THREE.Vector3(0, 0, 1);
+    this.DIR_LFT = new THREE.Vector3(-1, 0, 0);
+    this.DIR_RGT = new THREE.Vector3(1, 0, 0);
+    this._personToCam = new THREE.Vector3();
+    this._originTmp = new THREE.Vector3();
+    this._raycaster = new THREE.Raycaster(
+      new THREE.Vector3(),
+      new THREE.Vector3(0, -1, 0)
+    );
+    this._raycasterPersonToCam = new THREE.Raycaster(
+      new THREE.Vector3(),
+      new THREE.Vector3()
+    );
+    // 键盘按下事件
+    this._boundOnKeydown = async (e) => {
+      if (e.ctrlKey && (e.code === "KeyW" || e.code === "KeyA" || e.code === "KeyS" || e.code === "KeyD")) {
+        e.preventDefault();
+      }
+      switch (e.code) {
+        case "KeyW":
+          this.fwdPressed = true;
+          this.setAnimationByPressed();
+          break;
+        case "KeyS":
+          this.bkdPressed = true;
+          this.setAnimationByPressed();
+          break;
+        case "KeyD":
+          this.rgtPressed = true;
+          this.setAnimationByPressed();
+          break;
+        case "KeyA":
+          this.lftPressed = true;
+          this.setAnimationByPressed();
+          break;
+        case "ShiftLeft":
+          this.shiftPressed = true;
+          this.setAnimationByPressed();
+          break;
+        case "Space":
+          if (!this.spacePressed) this.spacePressed = true;
+          if (!this.spaceLongPressTimer) {
+            this.spaceLongPressTimer = setTimeout(() => {
+              this.sustainSpacePressed = true;
+            }, 2e3);
+          }
+          break;
+        case "ControlLeft":
+          this.ctPressed = true;
+          break;
+        case "KeyV":
+          this.changeView();
+          break;
+      }
+    };
+    // 键盘抬起事件
+    this._boundOnKeyup = (e) => {
+      switch (e.code) {
+        case "KeyW":
+          this.fwdPressed = false;
+          this.setAnimationByPressed();
+          break;
+        case "KeyS":
+          this.bkdPressed = false;
+          this.setAnimationByPressed();
+          break;
+        case "KeyD":
+          this.rgtPressed = false;
+          this.setAnimationByPressed();
+          break;
+        case "KeyA":
+          this.lftPressed = false;
+          this.setAnimationByPressed();
+          break;
+        case "ShiftLeft":
+          this.shiftPressed = false;
+          this.setAnimationByPressed();
+          break;
+        case "Space":
+          if (this.spaceLongPressTimer) {
+            clearTimeout(this.spaceLongPressTimer);
+            this.spaceLongPressTimer = null;
+          }
+          this.spacePressed = false;
+          this.sustainSpacePressed = false;
+          break;
+        case "ControlLeft":
+          this.ctPressed = false;
+          break;
+      }
+    };
+    // 根据按键设置人物动画
+    this.setAnimationByPressed = () => {
+      if (this.playerIsOnGround) {
+        if (!this.fwdPressed && !this.bkdPressed && !this.lftPressed && !this.rgtPressed) {
+          this.playPersonAnimationByName("idle");
+          return;
+        }
+        if (this.fwdPressed) {
+          if (this.shiftPressed) {
+            this.playPersonAnimationByName("running");
+          } else {
+            this.playPersonAnimationByName("walking");
+          }
+          return;
+        }
+        if (!this.isFirstPerson && (this.lftPressed || this.rgtPressed || this.bkdPressed)) {
+          if (this.shiftPressed) {
+            this.playPersonAnimationByName("running");
+          } else {
+            this.playPersonAnimationByName("walking");
+          }
+          return;
+        }
+        if (this.lftPressed) {
+          this.playPersonAnimationByName("left_walking");
+          return;
+        }
+        if (this.rgtPressed) {
+          this.playPersonAnimationByName("right_walking");
+          return;
+        }
+        if (this.bkdPressed) {
+          this.playPersonAnimationByName("walking_backward");
+          return;
+        }
+      }
+    };
+    // 鼠标移动事件
+    this._mouseMove = (e) => {
+      if (document.pointerLockElement !== document.body) return;
+      if (this.isFirstPerson) {
+        const yaw = -e.movementX * 1e-4 * this.mouseSensity;
+        const pitch = -e.movementY * 1e-4 * this.mouseSensity;
+        this.player.rotateY(yaw);
+        this.camera.rotation.x = THREE.MathUtils.clamp(
+          this.camera.rotation.x + pitch,
+          -1.3,
+          1.4
+        );
+      } else {
+        const sensitivity = 1e-4 * this.mouseSensity;
+        const deltaX = -e.movementX * sensitivity;
+        const deltaY = -e.movementY * sensitivity;
+        const target = this.player.position.clone();
+        const distance = this.camera.position.distanceTo(target);
+        const currentPosition = this.camera.position.clone().sub(target);
+        let theta = Math.atan2(currentPosition.x, currentPosition.z);
+        let phi = Math.acos(currentPosition.y / distance);
+        theta += deltaX;
+        phi += deltaY;
+        phi = Math.max(0.1, Math.min(Math.PI - 0.1, phi));
+        const newX = distance * Math.sin(phi) * Math.sin(theta);
+        const newY = distance * Math.cos(phi);
+        const newZ = distance * Math.sin(phi) * Math.cos(theta);
+        this.camera.position.set(
+          target.x + newX,
+          target.y + newY,
+          target.z + newZ
+        );
+        this.camera.lookAt(target);
+      }
+    };
+    this._mouseClick = (e) => {
+      if (document.pointerLockElement !== document.body)
+        document.body.requestPointerLock();
+    };
+    this._raycaster.firstHitOnly = true;
+    this._raycasterPersonToCam.firstHitOnly = true;
+  }
+  // 初始化
+  async init(opts, callback) {
+    this.scene = opts.scene;
+    this.camera = opts.camera;
+    this.controls = opts.controls;
+    this.playerModel = opts.playerModel;
+    this.playerModel.scale = opts.playerModel.scale ? opts.playerModel.scale : 1;
+    this.initPos = opts.initPos ? opts.initPos : new THREE.Vector3(0, 0, 0);
+    this.visualizeDepth = 0 * this.playerModel.scale;
+    this.gravity = -2400 * this.playerModel.scale;
+    this.jumpHeight = 300 * this.playerModel.scale;
+    this.highJumpHeight = 1e3 * this.playerModel.scale;
+    this.playerSpeed = 400 * this.playerModel.scale;
+    await this.createBVH();
+    this.createPlayer();
+    await this.loadPersonGLB();
+    if (this.isFirstPerson && this.player) {
+      this.player.add(this.camera);
+    }
+    this.onAllEvent();
+    this.setCameraPos();
+    this.setControls();
+    if (callback) callback();
+  }
+  // 第一/三视角切换
+  changeView() {
+    this.isFirstPerson = !this.isFirstPerson;
+    if (this.isFirstPerson) {
+      this.player.attach(this.camera);
+      this.camera.position.set(
+        0,
+        40 * this.playerModel.scale,
+        30 * this.playerModel.scale
+      );
+      this.camera.rotation.set(0, Math.PI, 0);
+      document.body.requestPointerLock();
+    } else {
+      this.scene.attach(this.camera);
+      const worldPos = this.player.position.clone();
+      const dir = new THREE.Vector3(0, 0, -1).applyQuaternion(
+        this.player.quaternion
+      );
+      const angle = Math.atan2(dir.z, dir.x);
+      const offset = new THREE.Vector3(
+        Math.cos(angle) * 400 * this.playerModel.scale,
+        200 * this.playerModel.scale,
+        Math.sin(angle) * 400 * this.playerModel.scale
+      );
+      this.camera.position.copy(worldPos).add(offset);
+      this.controls.target.copy(worldPos);
+      document.body.requestPointerLock();
+    }
+  }
+  // 摄像机/控制器设置
+  setCameraPos() {
+    if (this.isFirstPerson) {
+      this.camera.position.set(0, 40 * this.playerModel.scale, 30 * this.playerModel.scale);
+    } else {
+      const worldPos = this.player.position.clone();
+      const dir = new THREE.Vector3(0, 0, -1).applyQuaternion(
+        this.player.quaternion
+      );
+      const angle = Math.atan2(dir.z, dir.x);
+      const offset = new THREE.Vector3(
+        Math.cos(angle) * 400 * this.playerModel.scale,
+        200 * this.playerModel.scale,
+        Math.sin(angle) * 400 * this.playerModel.scale
+      );
+      this.camera.position.copy(worldPos).add(offset);
+    }
+    this.camera.updateProjectionMatrix();
+  }
+  // 设置控制器
+  setControls() {
+    this.controls.enabled = false;
+    this.controls.maxPolarAngle = Math.PI * (230 / 360);
+  }
+  // 重置控制器
+  resetControls() {
+    this.controls.enabled = true;
+    this.controls.enablePan = true;
+    this.controls.maxPolarAngle = Math.PI / 2;
+    this.controls.rotateSpeed = 1;
+    this.controls.enableZoom = true;
+    this.controls.mouseButtons = {
+      LEFT: 0,
+      MIDDLE: 1,
+      RIGHT: 2
+    };
+  }
+  // 初始化加载器
+  async initLoader() {
+    const dracoLoader = new import_DRACOLoader.DRACOLoader();
+    dracoLoader.setDecoderPath(
+      "https://unpkg.com/three@0.180.0/examples/jsm/libs/draco/gltf/"
+    );
+    dracoLoader.setDecoderConfig({ type: "js" });
+    this.loader.setDRACOLoader(dracoLoader);
+  }
+  // 人物与动画加载
+  async loadPersonGLB() {
+    try {
+      const gltf = await this.loader.loadAsync(
+        this.playerModel.url,
+        (xhr) => {
+        }
+      );
+      this.person = gltf.scene;
+      this.person.name = "\u89D2\u8272";
+      this.person.scale.set(
+        0.9 * this.playerModel.scale,
+        0.9 * this.playerModel.scale,
+        0.9 * this.playerModel.scale
+      );
+      this.person.position.set(0, -125 * this.playerModel.scale, 0);
+      this.player.add(this.person);
+      this.reset();
+      this.personMixer = new THREE.AnimationMixer(this.person);
+      const animations = gltf.animations ?? [];
+      this.personActions = /* @__PURE__ */ new Map();
+      const findClip = (name) => animations.find((a) => a.name === name);
+      const regs = [
+        [this.playerModel.idleAnim, "idle"],
+        [this.playerModel.walkAnim, "walking"],
+        [this.playerModel.leftWalkAnim || this.playerModel.walkAnim, "left_walking"],
+        [this.playerModel.rightWalkAnim || this.playerModel.walkAnim, "right_walking"],
+        [this.playerModel.backwardAnim || this.playerModel.walkAnim, "walking_backward"],
+        [this.playerModel.jumpAnim, "jumping"],
+        [this.playerModel.runAnim, "running"]
+      ];
+      for (const [key, clipName] of regs) {
+        const clip = findClip(key);
+        if (!clip) continue;
+        const action = this.personMixer.clipAction(clip);
+        if (clipName === "jumping") {
+          action.setLoop(THREE.LoopOnce, 1);
+          action.clampWhenFinished = true;
+          action.setEffectiveTimeScale(1.2);
+        } else {
+          action.setLoop(THREE.LoopRepeat, Infinity);
+          action.clampWhenFinished = false;
+          action.setEffectiveTimeScale(1);
+        }
+        action.enabled = true;
+        action.setEffectiveWeight(0);
+        this.personActions.set(clipName, action);
+      }
+      this.idleAction = this.personActions.get("idle");
+      this.walkAction = this.personActions.get("walking");
+      this.leftWalkAction = this.personActions.get("left_walking");
+      this.rightWalkAction = this.personActions.get("right_walking");
+      this.backwardAction = this.personActions.get("walking_backward");
+      this.jumpAction = this.personActions.get("jumping");
+      this.runAction = this.personActions.get("running");
+      this.idleAction.setEffectiveWeight(1);
+      this.idleAction.play();
+      this.actionState = this.idleAction;
+      this.personMixer.addEventListener("finished", (ev) => {
+        const finishedAction = ev.action;
+        if (finishedAction === this.jumpAction) {
+          if (this.fwdPressed) {
+            if (this.shiftPressed) this.playPersonAnimationByName("running");
+            else this.playPersonAnimationByName("walking");
+            return;
+          }
+          if (this.bkdPressed) {
+            this.playPersonAnimationByName("walking_backward");
+            return;
+          }
+          if (this.rgtPressed || this.lftPressed) {
+            this.playPersonAnimationByName("walking");
+            return;
+          }
+          this.playPersonAnimationByName("idle");
+        }
+      });
+    } catch (error) {
+    }
+  }
+  // 平滑切换人物动画
+  playPersonAnimationByName(name, fade = 0.18) {
+    if (!this.personActions) return;
+    if (this.ctPressed) return;
+    const next = this.personActions.get(name);
+    if (!next) return;
+    if (this.actionState === next) return;
+    const prev = this.actionState;
+    next.reset();
+    next.setEffectiveWeight(1);
+    next.play();
+    if (prev && prev !== next) {
+      prev.fadeOut(fade);
+      next.fadeIn(fade);
+    } else {
+      next.fadeIn(fade);
+    }
+    this.actionState = next;
+  }
+  // 创建玩家胶囊体
+  createPlayer() {
+    const material = new THREE.MeshStandardMaterial({
+      color: new THREE.Color(1, 0, 0),
+      shadowSide: THREE.DoubleSide,
+      depthTest: false
+    });
+    material.transparent = true;
+    material.opacity = this.displayPlayer ? 0.5 : 0;
+    material.wireframe = true;
+    this.player = new THREE.Mesh(
+      new import_RoundedBoxGeometry.RoundedBoxGeometry(
+        75 * this.playerModel.scale,
+        180 * this.playerModel.scale,
+        75 * this.playerModel.scale,
+        100 * this.playerModel.scale,
+        75 * this.playerModel.scale
+      ),
+      material
+    );
+    this.player.geometry.translate(0, -30 * this.playerModel.scale, 0);
+    this.player.capsuleInfo = {
+      radius: 25 * this.playerModel.scale,
+      segment: new THREE.Line3(
+        new THREE.Vector3(),
+        new THREE.Vector3(0, -1, 0)
+      )
+    };
+    this.player.name = "\u89D2\u8272\u80F6\u56CA\u4F53";
+    this.player.rotateY(Math.PI / 2);
+    this.scene.add(this.player);
+    this.reset();
+  }
+  // 每帧更新
+  async updatePlayer(delta) {
+    if (!this.isUpdatePlayer || !this.player) return;
+    delta = Math.min(delta, 1 / 30);
+    this.updateMixers(delta);
+    if (!this.collider) return;
+    this.camera.getWorldDirection(this.camDir);
+    let angle = Math.atan2(this.camDir.z, this.camDir.x) + Math.PI / 2;
+    angle = 2 * Math.PI - angle;
+    this.moveDir.set(0, 0, 0);
+    if (this.fwdPressed) this.moveDir.add(this.DIR_FWD);
+    if (this.bkdPressed) this.moveDir.add(this.DIR_BKD);
+    if (this.lftPressed) this.moveDir.add(this.DIR_LFT);
+    if (this.rgtPressed) this.moveDir.add(this.DIR_RGT);
+    if (this.spacePressed && this.playerIsOnGround) {
+      this.playPersonAnimationByName("jumping");
+      setTimeout(() => {
+        this.playerVelocity.y = this.jumpHeight;
+        this.playerIsOnGround = false;
+        this.spacePressed = false;
+        this.player.position.addScaledVector(this.playerVelocity, delta);
+        this.player.updateMatrixWorld();
+      }, 200);
+    }
+    if (this.sustainSpacePressed && this.playerIsOnGround) {
+      this.playPersonAnimationByName("jumping");
+      setTimeout(() => {
+        this.playerVelocity.y = this.highJumpHeight;
+        this.playerIsOnGround = false;
+        this.spacePressed = false;
+        this.player.position.addScaledVector(this.playerVelocity, delta);
+        this.player.updateMatrixWorld();
+      }, 200);
+    }
+    this.playerSpeed = this.shiftPressed ? 900 * this.playerModel.scale : 400 * this.playerModel.scale;
+    if (this.moveDir.lengthSq() > 1e-6) {
+      this.moveDir.normalize().applyAxisAngle(this.upVector, angle);
+      this.player.position.addScaledVector(
+        this.moveDir,
+        this.playerSpeed * delta
+      );
+    }
+    let playerDistanceFromGround = Infinity;
+    this._originTmp.set(
+      this.player.position.x,
+      this.player.position.y,
+      this.player.position.z
+    );
+    this._raycaster.ray.origin.copy(this._originTmp);
+    const intersects = this._raycaster.intersectObject(
+      this.collider,
+      false
+    );
+    if (intersects.length > 0) {
+      playerDistanceFromGround = this.player.position.y - intersects[0].point.y;
+    }
+    if (playerDistanceFromGround > 130 * this.playerModel.scale) {
+      this.playerVelocity.y += delta * this.gravity;
+      this.player.position.addScaledVector(this.playerVelocity, delta);
+    } else {
+      this.playerIsOnGround = true;
+    }
+    this.player.updateMatrixWorld();
+    const capsuleInfo = this.player.capsuleInfo;
+    this.tempBox.makeEmpty();
+    this.tempMat.copy(this.collider.matrixWorld).invert();
+    this.tempSegment.copy(capsuleInfo.segment);
+    this.tempSegment.start.applyMatrix4(this.player.matrixWorld).applyMatrix4(this.tempMat);
+    this.tempSegment.end.applyMatrix4(this.player.matrixWorld).applyMatrix4(this.tempMat);
+    this.tempBox.expandByPoint(this.tempSegment.start);
+    this.tempBox.expandByPoint(this.tempSegment.end);
+    this.tempBox.expandByScalar(capsuleInfo.radius);
+    const bvh = this.collider?.geometry;
+    bvh?.boundsTree?.shapecast({
+      // 检测包围盒碰撞
+      intersectsBounds: (box) => box.intersectsBox(this.tempBox),
+      // 检测三角形碰撞
+      intersectsTriangle: (tri) => {
+        const triPoint = this.tempVector;
+        const capsulePoint = this.tempVector2;
+        const distance = tri.closestPointToSegment(
+          this.tempSegment,
+          triPoint,
+          capsulePoint
+        );
+        if (distance < capsuleInfo.radius) {
+          const depth = capsuleInfo.radius - distance;
+          const direction = capsulePoint.sub(triPoint).normalize();
+          this.tempSegment.start.addScaledVector(direction, depth);
+          this.tempSegment.end.addScaledVector(direction, depth);
+        }
+      }
+    });
+    const newPosition = this.tempVector.copy(this.tempSegment.start).applyMatrix4(this.collider.matrixWorld);
+    const deltaVector = this.tempVector2.subVectors(
+      newPosition,
+      this.player.position
+    );
+    const len = deltaVector.length();
+    const offset = Math.max(0, len - 1e-5);
+    if (offset > 0 && len > 0) {
+      const n = deltaVector.multiplyScalar(1 / len);
+      this.player.position.addScaledVector(n, offset);
+      this.playerVelocity.set(0, 0, 0);
+    }
+    if (!this.isFirstPerson && this.moveDir.lengthSq() > 0) {
+      this.camDir.y = 0;
+      this.camDir.normalize();
+      this.camDir.negate();
+      this.moveDir.normalize();
+      this.moveDir.negate();
+      const lookTarget = this.player.position.clone().add(this.moveDir);
+      this.targetMat.lookAt(this.player.position, lookTarget, this.player.up);
+      this.targetQuat.setFromRotationMatrix(this.targetMat);
+      const alpha = Math.min(1, this.rotationSpeed * delta);
+      this.player.quaternion.slerp(this.targetQuat, alpha);
+    }
+    if (!this.isFirstPerson) {
+      const lookTarget = this.player.position.clone();
+      lookTarget.y += 30 * this.playerModel.scale;
+      this.camera.position.sub(this.controls.target);
+      this.controls.target.copy(lookTarget);
+      this.camera.position.add(lookTarget);
+      this.controls.update();
+      this._personToCam.subVectors(this.camera.position, this.player.position);
+      const origin = this.player.position.clone().add(new THREE.Vector3(0, 0, 0));
+      const direction = this._personToCam.clone().normalize();
+      const desiredDist = this._personToCam.length();
+      this._raycasterPersonToCam.set(origin, direction);
+      this._raycasterPersonToCam.far = desiredDist;
+      const intersects2 = this._raycasterPersonToCam.intersectObject(
+        this.collider,
+        false
+      );
+      if (intersects2.length > 0) {
+        const hit = intersects2[0];
+        const safeDist = Math.max(
+          hit.distance - this._camEpsilon,
+          this._minCamDistance
+        );
+        const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+        this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+      } else {
+        const dis = this.player.position.distanceTo(this.camera.position);
+        this._raycasterPersonToCam.far = this._maxCamDistance;
+        const intersectsMaxDis = this._raycasterPersonToCam.intersectObject(
+          this.collider,
+          false
+        );
+        if (dis < this._maxCamDistance) {
+          let safeDist = this._maxCamDistance;
+          if (intersectsMaxDis.length) {
+            const hitMax = intersectsMaxDis[0];
+            safeDist = hitMax.distance - this._camEpsilon;
+          }
+          const targetCamPos = origin.clone().add(direction.clone().multiplyScalar(safeDist));
+          this.camera.position.lerp(targetCamPos, this._camCollisionLerp);
+        }
+      }
+    }
+    if (this.player.position.y < this.boundingBoxMinY - 1) {
+      this._originTmp.set(
+        this.player.position.x,
+        1e4,
+        this.player.position.z
+      );
+      this._raycaster.ray.origin.copy(this._originTmp);
+      const intersects2 = this._raycaster.intersectObject(
+        this.collider,
+        false
+      );
+      if (intersects2.length > 0) {
+        console.log("\u73A9\u5BB6\u4E3Abug\u610F\u5916\u6389\u843D");
+        this.reset(
+          new THREE.Vector3(
+            this.player.position.x,
+            intersects2[0].point.y + 5,
+            this.player.position.z
+          )
+        );
+      } else {
+        console.log("\u73A9\u5BB6\u6B63\u5E38\u6389\u843D");
+        this.reset(
+          new THREE.Vector3(
+            this.player.position.x,
+            this.player.position.y + 15,
+            this.player.position.z
+          )
+        );
+      }
+    }
+  }
+  // 重置 / 销毁
+  reset(position) {
+    if (!this.player) return;
+    this.playerVelocity.set(0, 0, 0);
+    this.player.position.copy(position ? position : this.initPos);
+  }
+  // 销毁
+  destroy() {
+    this.offAllEvent();
+    if (this.player) {
+      this.player.remove(this.camera);
+      this.scene.remove(this.player);
+    }
+    this.player = null;
+    if (this.person) {
+      this.scene.remove(this.person);
+      this.person = null;
+    }
+    this.resetControls();
+    if (this.visualizer) {
+      this.scene.remove(this.visualizer);
+      this.visualizer = null;
+    }
+    if (this.collider) {
+      this.scene.remove(this.collider);
+      this.collider = null;
+    }
+    controllerInstance = null;
+  }
+  // 事件绑定
+  onAllEvent() {
+    this.isUpdatePlayer = true;
+    document.body.requestPointerLock();
+    window.addEventListener("keydown", this._boundOnKeydown);
+    window.addEventListener("keyup", this._boundOnKeyup);
+    window.addEventListener("mousemove", this._mouseMove);
+    window.addEventListener("click", this._mouseClick);
+  }
+  // 事件解绑
+  offAllEvent() {
+    this.isUpdatePlayer = false;
+    document.exitPointerLock();
+    window.removeEventListener("keydown", this._boundOnKeydown);
+    window.removeEventListener("keyup", this._boundOnKeyup);
+    window.removeEventListener("mousemove", this._mouseMove);
+    window.removeEventListener("click", this._mouseClick);
+  }
+  // 更新模型动画
+  updateMixers(delta) {
+    if (this.personMixer) this.personMixer.update(delta);
+    if (this.droneMixer) this.droneMixer.update(delta);
+  }
+  // BVH构建
+  async createBVH(meshUrl = "") {
+    await this.initLoader();
+    const ensureAttributesMinimal = (geom) => {
+      if (!geom.attributes.position) {
+        return null;
+      }
+      if (!geom.attributes.normal) geom.computeVertexNormals();
+      if (!geom.attributes.uv) {
+        const count = geom.attributes.position.count;
+        const dummyUV = new Float32Array(count * 2);
+        geom.setAttribute("uv", new THREE.BufferAttribute(dummyUV, 2));
+      }
+      return geom;
+    };
+    const collected = [];
+    if (meshUrl == "") {
+      if (this.collider) {
+        this.scene.remove(this.collider);
+        this.collider = null;
+      }
+      this.scene.traverse((c) => {
+        const mesh = c;
+        if (mesh?.isMesh && mesh.geometry && c.name !== "\u89D2\u8272\u80F6\u56CA\u4F53") {
+          try {
+            let geom = mesh.geometry.clone();
+            geom.applyMatrix4(mesh.matrixWorld);
+            if (geom.index) geom = geom.toNonIndexed();
+            const safe = ensureAttributesMinimal(geom);
+            if (safe) collected.push(safe);
+          } catch (e) {
+            console.warn("\u5904\u7406\u7F51\u683C\u65F6\u51FA\u9519\uFF1A", mesh, e);
+          }
+        }
+      });
+      if (!collected.length) {
+        return;
+      }
+      const attrMap = /* @__PURE__ */ new Map();
+      const attrConflict = /* @__PURE__ */ new Set();
+      for (const g of collected) {
+        for (const name of Object.keys(g.attributes)) {
+          const attr = g.attributes[name];
+          const ctor = attr.array.constructor;
+          const itemSize = attr.itemSize;
+          if (!attrMap.has(name)) {
+            attrMap.set(name, { itemSize, arrayCtor: ctor, examples: 1 });
+          } else {
+            const m = attrMap.get(name);
+            if (m.itemSize !== itemSize || m.arrayCtor !== ctor)
+              attrConflict.add(name);
+            else m.examples++;
+          }
+        }
+      }
+      if (attrConflict.size) {
+        for (const g of collected) {
+          for (const name of Array.from(attrConflict)) {
+            if (g.attributes[name]) g.deleteAttribute(name);
+          }
+        }
+        for (const name of attrConflict) attrMap.delete(name);
+      }
+      const attrNames = Array.from(attrMap.keys());
+      for (const g of collected) {
+        const count = g.attributes.position.count;
+        for (const name of attrNames) {
+          if (!g.attributes[name]) {
+            const meta = attrMap.get(name);
+            const len = count * meta.itemSize;
+            const array = new meta.arrayCtor(len);
+            g.setAttribute(
+              name,
+              new THREE.BufferAttribute(array, meta.itemSize)
+            );
+          }
+        }
+      }
+    } else {
+      const gltf = await this.loader.loadAsync(meshUrl, (xhr) => {
+      });
+      const mesh = gltf.scene.children[0];
+      mesh.name = "BVH\u52A0\u8F7D\u6A21\u578B";
+      let geom = mesh.geometry.clone();
+      geom.applyMatrix4(mesh.matrixWorld);
+      if (geom.index) geom = geom.toNonIndexed();
+      const safe = ensureAttributesMinimal(geom);
+      if (safe) collected.push(safe);
+    }
+    const merged = BufferGeometryUtils.mergeGeometries(collected, false);
+    if (!merged) {
+      console.error("\u5408\u5E76\u51E0\u4F55\u5931\u8D25");
+      return;
+    }
+    merged.boundsTree = new import_three_mesh_bvh.MeshBVH(merged);
+    this.collider = new THREE.Mesh(
+      merged,
+      new THREE.MeshBasicMaterial({
+        color: "red",
+        opacity: 0.2,
+        transparent: true,
+        wireframe: false
+      })
+    );
+    if (this.displayCollider) this.scene.add(this.collider);
+    if (this.displayVisualizer) {
+      if (this.visualizer) this.scene.remove(this.visualizer);
+      this.visualizer = new import_three_mesh_bvh.MeshBVHHelper(this.collider, this.visualizeDepth);
+      this.scene.add(this.visualizer);
+    }
+    this.boundingBoxMinY = this.collider.geometry.boundingBox.min.y;
+    console.log("bvh\u52A0\u8F7D\u6A21\u578B\u6210\u529F", this.collider);
+  }
+};
+function usePlayer() {
+  if (!controllerInstance) controllerInstance = new PlayerController();
+  const c = controllerInstance;
+  return {
+    init: (opts, callback) => c.init(opts, callback),
+    changeView: () => c.changeView(),
+    createBVH: (url = "") => c.createBVH(url),
+    createPlayer: () => c.createPlayer(),
+    reset: (pos) => c.reset(pos),
+    updatePlayer: (dt) => c.updatePlayer(dt),
+    destroy: () => c.destroy()
+  };
+}
+function onAllEvent() {
+  if (!controllerInstance) controllerInstance = new PlayerController();
+  controllerInstance.onAllEvent();
+}
+function offAllEvent() {
+  if (!controllerInstance) return;
+  controllerInstance.offAllEvent();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  offAllEvent,
+  onAllEvent,
+  usePlayer
+});
+//# sourceMappingURL=index.js.map