@pascal-app/editor 0.9.1 → 0.9.2

package/src/components/editor/first-person/bvh-ecctrl.tsx

@@ -1,860 +0,0 @@
-import '../../../three-types'
-import { TransformControls, useKeyboardControls } from '@react-three/drei'
-import { type ThreeElements, useFrame, useThree } from '@react-three/fiber'
-import type { ReactNode } from 'react'
-import { forwardRef, Suspense, useCallback, useImperativeHandle, useMemo, useRef } from 'react'
-import * as THREE from 'three'
-import { clamp } from 'three/src/math/MathUtils.js'
-
-export type MovementInput = {
-  forward?: boolean
-  backward?: boolean
-  leftward?: boolean
-  rightward?: boolean
-  joystick?: { x: number; y: number }
-  run?: boolean
-  jump?: boolean
-}
-
-export type CharacterAnimationStatus =
-  | 'IDLE'
-  | 'WALK'
-  | 'RUN'
-  | 'JUMP_START'
-  | 'JUMP_IDLE'
-  | 'JUMP_FALL'
-  | 'JUMP_LAND'
-
-export type FloatCheckType = 'RAYCAST' | 'SHAPECAST' | 'BOTH'
-
-export interface BVHEcctrlApi {
-  group: THREE.Group | null
-  model: THREE.Group | null
-  resetLinVel: () => void
-  addLinVel: (v: THREE.Vector3) => void
-  setLinVel: (v: THREE.Vector3) => void
-  setMovement: (input: MovementInput) => void
-}
-
-export interface EcctrlProps extends Omit<ThreeElements['group'], 'ref'> {
-  children?: ReactNode
-  debug?: boolean
-  colliderMeshes?: THREE.Mesh[]
-  colliderCapsuleArgs?: [
-    radius: number,
-    length: number,
-    capSegments: number,
-    radialSegments: number,
-  ]
-  paused?: boolean
-  delay?: number
-  gravity?: number
-  fallGravityFactor?: number
-  maxFallSpeed?: number
-  mass?: number
-  sleepTimeout?: number
-  slowMotionFactor?: number
-  turnSpeed?: number
-  maxWalkSpeed?: number
-  maxRunSpeed?: number
-  acceleration?: number
-  deceleration?: number
-  counterAccFactor?: number
-  airDragFactor?: number
-  jumpVel?: number
-  floatCheckType?: FloatCheckType
-  maxSlope?: number
-  floatHeight?: number
-  floatPullBackHeight?: number
-  floatSensorRadius?: number
-  floatSpringK?: number
-  floatDampingC?: number
-  collisionCheckIteration?: number
-  collisionPushBackDamping?: number
-  collisionPushBackThreshold?: number
-}
-
-type CharacterStatus = {
-  position: THREE.Vector3
-  linvel: THREE.Vector3
-  quaternion: THREE.Quaternion
-  inputDir: THREE.Vector3
-  movingDir: THREE.Vector3
-  isOnGround: boolean
-  isOnMovingPlatform: boolean
-  animationStatus: CharacterAnimationStatus
-}
-
-export const characterStatus: CharacterStatus = {
-  position: new THREE.Vector3(),
-  linvel: new THREE.Vector3(),
-  quaternion: new THREE.Quaternion(),
-  inputDir: new THREE.Vector3(),
-  movingDir: new THREE.Vector3(),
-  isOnGround: false,
-  isOnMovingPlatform: false,
-  animationStatus: 'IDLE',
-}
-
-const BVHEcctrl = forwardRef<BVHEcctrlApi, EcctrlProps>(
-  (
-    {
-      children,
-      debug = false,
-      colliderMeshes = [],
-      colliderCapsuleArgs = [0.3, 0.6, 4, 8],
-      paused = false,
-      delay = 1.5,
-      gravity = 9.81,
-      fallGravityFactor = 4,
-      maxFallSpeed = 50,
-      mass = 1,
-      sleepTimeout = 10,
-      slowMotionFactor = 1,
-      turnSpeed = 15,
-      maxWalkSpeed = 3,
-      maxRunSpeed = 5,
-      acceleration = 30,
-      deceleration = 20,
-      counterAccFactor = 0.5,
-      airDragFactor = 0.3,
-      jumpVel = 5,
-      floatCheckType = 'BOTH',
-      maxSlope = 1,
-      floatHeight = 0.2,
-      floatPullBackHeight = 0.25,
-      floatSensorRadius = 0.12,
-      floatSpringK = 600,
-      floatDampingC = 28,
-      collisionCheckIteration = 3,
-      collisionPushBackDamping = 0.1,
-      collisionPushBackThreshold = 0.05,
-      ...props
-    },
-    ref,
-  ) => {
-    const { camera } = useThree()
-    const capsuleRadius = useMemo(() => colliderCapsuleArgs[0], [colliderCapsuleArgs])
-    const capsuleLength = useMemo(() => colliderCapsuleArgs[1], [colliderCapsuleArgs])
-    const characterGroupRef = useRef<THREE.Group | null>(null)
-    const characterColliderRef = useRef<THREE.Mesh | null>(null)
-    const characterModelRef = useRef<THREE.Group | null>(null)
-    const debugLineStart = useRef<THREE.Mesh | null>(null)
-    const debugLineEnd = useRef<THREE.Mesh | null>(null)
-    const debugRaySensorStart = useRef<THREE.Mesh | null>(null)
-    const debugRaySensorEnd = useRef<THREE.Mesh | null>(null)
-    const standPointRef = useRef<THREE.Mesh | null>(null)
-    const lookDirRef = useRef<THREE.Mesh | null>(null)
-    const inputDirRef = useRef<THREE.ArrowHelper | null>(null)
-    const moveDirRef = useRef<THREE.ArrowHelper | null>(null)
-    const elapsedRef = useRef(0)
-
-    const [, getKeys] = useKeyboardControls()
-    const presetKeys = {
-      forward: false,
-      backward: false,
-      leftward: false,
-      rightward: false,
-      jump: false,
-      run: false,
-    }
-
-    const upAxis = useRef(new THREE.Vector3(0, 1, 0))
-    const localUpAxis = useRef(new THREE.Vector3())
-    const gravityDir = useRef(new THREE.Vector3(0, -1, 0))
-    const currentLinVel = useRef(new THREE.Vector3())
-    const currentLinVelOnPlane = useRef(new THREE.Vector3())
-    const isFalling = useRef(false)
-    const idleTime = useRef(0)
-    const isSleeping = useRef(false)
-    const camProjDir = useRef(new THREE.Vector3())
-    const camRightDir = useRef(new THREE.Vector3())
-    const inputDir = useRef(new THREE.Vector3())
-    const inputDirOnPlane = useRef(new THREE.Vector3())
-    const movingDir = useRef(new THREE.Vector3())
-    const deltaLinVel = useRef(new THREE.Vector3())
-    const wantToMoveVel = useRef(new THREE.Vector3())
-    const forwardState = useRef(false)
-    const backwardState = useRef(false)
-    const leftwardState = useRef(false)
-    const rightwardState = useRef(false)
-    const joystickState = useRef(new THREE.Vector2())
-    const runState = useRef(false)
-    const jumpState = useRef(false)
-    const isOnGround = useRef(false)
-    const prevIsOnGround = useRef(false)
-    const prevAnimation = useRef<CharacterAnimationStatus>('IDLE')
-    const characterModelTargetQuat = useRef(new THREE.Quaternion())
-    const characterModelLookMatrix = useRef(new THREE.Matrix4())
-    const characterOrigin = useMemo(() => new THREE.Vector3(0, 0, 0), [])
-    const contactDepth = useRef(0)
-    const contactNormal = useRef(new THREE.Vector3())
-    const triContactPoint = useRef(new THREE.Vector3())
-    const capsuleContactPoint = useRef(new THREE.Vector3())
-    const totalDepth = useRef(0)
-    const triangleCount = useRef(0)
-    const accumulatedContactNormal = useRef(new THREE.Vector3())
-    const accumulatedContactPoint = useRef(new THREE.Vector3())
-    const absorbVel = useRef(new THREE.Vector3())
-    const pushBackVel = useRef(new THREE.Vector3())
-    const characterBbox = useRef(new THREE.Box3())
-    const characterSegment = useRef(new THREE.Line3())
-    const localCharacterBbox = useRef(new THREE.Box3())
-    const localCharacterSegment = useRef(new THREE.Line3())
-    const collideInvertMatrix = useRef(new THREE.Matrix4())
-    const relativeCollideVel = useRef(new THREE.Vector3())
-    const scaledContactRadiusVec = useRef(new THREE.Vector3())
-    const deltaDist = useRef(new THREE.Vector3())
-    const currSlopeAngle = useRef(0)
-    const localMinDistance = useRef(Number.POSITIVE_INFINITY)
-    const localClosestPoint = useRef(new THREE.Vector3())
-    const localHitNormal = useRef(new THREE.Vector3())
-    const triNormal = useRef(new THREE.Vector3())
-    const globalMinDistance = useRef(Number.POSITIVE_INFINITY)
-    const globalClosestPoint = useRef(new THREE.Vector3())
-    const triHitPoint = useRef(new THREE.Vector3())
-    const segHitPoint = useRef(new THREE.Vector3())
-    const floatHitNormal = useRef(new THREE.Vector3())
-    const groundFriction = useRef(0.8)
-    const floatSensorBbox = useRef(new THREE.Box3())
-    const floatSensorBboxExpendPoint = useRef(new THREE.Vector3())
-    const floatSensorSegment = useRef(new THREE.Line3())
-    const localFloatSensorBbox = useRef(new THREE.Box3())
-    const localFloatSensorBboxExpendPoint = useRef(new THREE.Vector3())
-    const localFloatSensorSegment = useRef(new THREE.Line3())
-    const floatInvertMatrix = useRef(new THREE.Matrix4())
-    const floatNormalInverseMatrix = useRef(new THREE.Matrix3())
-    const floatNormalMatrix = useRef(new THREE.Matrix3())
-    const floatRaycaster = useRef(new THREE.Raycaster())
-    const relativeHitPoint = useRef(new THREE.Vector3())
-    const totalPlatformDeltaPos = useRef(new THREE.Vector3())
-    const isOnMovingPlatform = useRef(false)
-    const floatTempPos = useRef(new THREE.Vector3())
-    const floatTempQuat = useRef(new THREE.Quaternion())
-    const floatTempScale = useRef(new THREE.Vector3())
-    const scaledFloatRadiusVec = useRef(new THREE.Vector3())
-    const deltaHit = useRef(new THREE.Vector3())
-    const rotationDeltaPos = useRef(new THREE.Vector3())
-    const yawQuaternion = useRef(new THREE.Quaternion())
-    const contactTempPos = useRef(new THREE.Vector3())
-    const contactTempQuat = useRef(new THREE.Quaternion())
-    const contactTempScale = useRef(new THREE.Vector3())
-
-    floatRaycaster.current.far = capsuleRadius + floatHeight + floatPullBackHeight
-
-    const floatRaycastCandidates = useMemo(
-      () =>
-        colliderMeshes.filter(
-          (mesh) => mesh.geometry.boundsTree && !(mesh instanceof THREE.InstancedMesh),
-        ),
-      [colliderMeshes],
-    )
-
-    const applyGravity = useCallback(
-      (delta: number) => {
-        gravityDir.current.copy(upAxis.current).negate()
-        const fallingSpeed = currentLinVel.current.dot(gravityDir.current)
-        isFalling.current = fallingSpeed > 0
-        if (fallingSpeed < maxFallSpeed) {
-          currentLinVel.current.addScaledVector(
-            gravityDir.current,
-            gravity * (isFalling.current ? fallGravityFactor : 1) * delta,
-          )
-        }
-      },
-      [fallGravityFactor, gravity, maxFallSpeed],
-    )
-
-    const checkCharacterSleep = useCallback(
-      (jump: boolean, delta: number) => {
-        const moving = currentLinVel.current.lengthSq() > 1e-6
-        const platformIsMoving = totalPlatformDeltaPos.current.lengthSq() > 1e-6
-
-        if (
-          !moving &&
-          isOnGround.current &&
-          !jump &&
-          !isOnMovingPlatform.current &&
-          !platformIsMoving
-        ) {
-          idleTime.current += delta
-          if (idleTime.current > sleepTimeout) isSleeping.current = true
-        } else {
-          idleTime.current = 0
-          isSleeping.current = false
-        }
-      },
-      [sleepTimeout],
-    )
-
-    const setInputDirection = useCallback(
-      (dir: {
-        forward?: boolean
-        backward?: boolean
-        leftward?: boolean
-        rightward?: boolean
-        joystick?: THREE.Vector2
-      }) => {
-        inputDir.current.set(0, 0, 0)
-
-        camera.getWorldDirection(camProjDir.current)
-        camProjDir.current.projectOnPlane(upAxis.current).normalize()
-        camRightDir.current.crossVectors(camProjDir.current, upAxis.current).normalize()
-
-        if (dir.joystick && dir.joystick.lengthSq() > 0) {
-          inputDir.current
-            .addScaledVector(camProjDir.current, dir.joystick.y)
-            .addScaledVector(camRightDir.current, dir.joystick.x)
-        } else {
-          if (dir.forward) inputDir.current.add(camProjDir.current)
-          if (dir.backward) inputDir.current.sub(camProjDir.current)
-          if (dir.leftward) inputDir.current.sub(camRightDir.current)
-          if (dir.rightward) inputDir.current.add(camRightDir.current)
-        }
-
-        inputDir.current.normalize()
-      },
-      [camera],
-    )
-
-    const handleCharacterMovement = useCallback(
-      (run: boolean, delta: number) => {
-        const friction = clamp(groundFriction.current, 0, 1)
-
-        if (inputDir.current.lengthSq() > 0) {
-          if (characterModelRef.current) {
-            inputDirOnPlane.current.copy(inputDir.current).projectOnPlane(upAxis.current)
-            characterModelLookMatrix.current.lookAt(
-              inputDirOnPlane.current,
-              characterOrigin,
-              upAxis.current,
-            )
-            characterModelTargetQuat.current.setFromRotationMatrix(characterModelLookMatrix.current)
-            characterModelRef.current.quaternion.slerp(
-              characterModelTargetQuat.current,
-              delta * turnSpeed,
-            )
-          }
-
-          const maxSpeed = run ? maxRunSpeed : maxWalkSpeed
-          wantToMoveVel.current.copy(inputDir.current).multiplyScalar(maxSpeed)
-          const dot = movingDir.current.dot(inputDir.current)
-
-          deltaLinVel.current.subVectors(wantToMoveVel.current, currentLinVelOnPlane.current)
-          deltaLinVel.current.clampLength(
-            0,
-            (dot <= 0 ? 1 + counterAccFactor : 1) *
-              acceleration *
-              friction *
-              delta *
-              (isOnGround.current ? 1 : airDragFactor),
-          )
-          currentLinVel.current.add(deltaLinVel.current)
-        } else if (isOnGround.current) {
-          deltaLinVel.current
-            .copy(currentLinVelOnPlane.current)
-            .clampLength(0, deceleration * friction * delta)
-          currentLinVel.current.sub(deltaLinVel.current)
-        }
-      },
-      [
-        acceleration,
-        airDragFactor,
-        counterAccFactor,
-        deceleration,
-        maxRunSpeed,
-        maxWalkSpeed,
-        turnSpeed,
-        characterOrigin,
-      ],
-    )
-
-    const updateSegmentBBox = useCallback(() => {
-      if (!characterGroupRef.current) return
-
-      characterSegment.current.start
-        .set(0, capsuleLength / 2, 0)
-        .add(characterGroupRef.current.position)
-      characterSegment.current.end
-        .set(0, -capsuleLength / 2, 0)
-        .add(characterGroupRef.current.position)
-
-      characterBbox.current
-        .makeEmpty()
-        .expandByPoint(characterSegment.current.start)
-        .expandByPoint(characterSegment.current.end)
-        .expandByScalar(capsuleRadius)
-
-      floatSensorSegment.current.start.copy(characterSegment.current.end)
-      floatSensorSegment.current.end
-        .copy(floatSensorSegment.current.start)
-        .addScaledVector(gravityDir.current, floatHeight + capsuleRadius)
-      floatSensorBboxExpendPoint.current
-        .copy(floatSensorSegment.current.end)
-        .addScaledVector(gravityDir.current, floatPullBackHeight)
-
-      floatSensorBbox.current
-        .makeEmpty()
-        .expandByPoint(floatSensorSegment.current.start)
-        .expandByPoint(floatSensorBboxExpendPoint.current)
-        .expandByScalar(floatSensorRadius)
-    }, [capsuleLength, capsuleRadius, floatHeight, floatPullBackHeight, floatSensorRadius])
-
-    const collisionCheck = useCallback(
-      (mesh: THREE.Mesh, originMatrix: THREE.Matrix4, delta: number) => {
-        if (!(mesh.visible && mesh.geometry.boundsTree) || mesh.userData.excludeCollisionCheck)
-          return
-
-        originMatrix.decompose(
-          contactTempPos.current,
-          contactTempQuat.current,
-          contactTempScale.current,
-        )
-        collideInvertMatrix.current.copy(originMatrix).invert()
-        localCharacterSegment.current
-          .copy(characterSegment.current)
-          .applyMatrix4(collideInvertMatrix.current)
-
-        scaledContactRadiusVec.current.set(
-          capsuleRadius / contactTempScale.current.x,
-          capsuleRadius / contactTempScale.current.y,
-          capsuleRadius / contactTempScale.current.z,
-        )
-
-        localCharacterBbox.current
-          .makeEmpty()
-          .expandByPoint(localCharacterSegment.current.start)
-          .expandByPoint(localCharacterSegment.current.end)
-        localCharacterBbox.current.min.addScaledVector(scaledContactRadiusVec.current, -1)
-        localCharacterBbox.current.max.add(scaledContactRadiusVec.current)
-
-        contactDepth.current = 0
-        contactNormal.current.set(0, 0, 0)
-        absorbVel.current.set(0, 0, 0)
-        pushBackVel.current.set(0, 0, 0)
-        totalDepth.current = 0
-        triangleCount.current = 0
-        accumulatedContactNormal.current.set(0, 0, 0)
-        accumulatedContactPoint.current.set(0, 0, 0)
-
-        mesh.geometry.boundsTree.shapecast({
-          intersectsBounds: (box) => box.intersectsBox(localCharacterBbox.current),
-          intersectsTriangle: (tri) => {
-            tri.closestPointToSegment(
-              localCharacterSegment.current,
-              triContactPoint.current,
-              capsuleContactPoint.current,
-            )
-
-            deltaDist.current.copy(triContactPoint.current).sub(capsuleContactPoint.current)
-            deltaDist.current.divide(scaledContactRadiusVec.current)
-
-            if (deltaDist.current.lengthSq() < 1) {
-              triContactPoint.current.applyMatrix4(originMatrix)
-              capsuleContactPoint.current.applyMatrix4(originMatrix)
-
-              contactNormal.current
-                .copy(capsuleContactPoint.current)
-                .sub(triContactPoint.current)
-                .normalize()
-              contactDepth.current =
-                capsuleRadius - capsuleContactPoint.current.distanceTo(triContactPoint.current)
-
-              accumulatedContactNormal.current.addScaledVector(
-                contactNormal.current,
-                contactDepth.current,
-              )
-              accumulatedContactPoint.current.add(triContactPoint.current)
-              totalDepth.current += contactDepth.current
-              triangleCount.current += 1
-            }
-          },
-        })
-
-        if (triangleCount.current > 0) {
-          accumulatedContactNormal.current.normalize()
-          accumulatedContactPoint.current.divideScalar(triangleCount.current)
-          const avgDepth = totalDepth.current / triangleCount.current
-          relativeCollideVel.current.copy(currentLinVel.current)
-          const intoSurfaceVel = relativeCollideVel.current.dot(accumulatedContactNormal.current)
-
-          if (intoSurfaceVel < 0) {
-            absorbVel.current
-              .copy(accumulatedContactNormal.current)
-              .multiplyScalar(-intoSurfaceVel * (1 + (mesh.userData.restitution ?? 0.05)))
-            currentLinVel.current.add(absorbVel.current)
-          }
-
-          if (avgDepth > collisionPushBackThreshold) {
-            const correction = (collisionPushBackDamping / delta) * avgDepth
-            pushBackVel.current.copy(accumulatedContactNormal.current).multiplyScalar(correction)
-            currentLinVel.current.add(pushBackVel.current)
-          }
-        }
-      },
-      [capsuleRadius, collisionPushBackDamping, collisionPushBackThreshold],
-    )
-
-    const handleCollisionResponse = useCallback(
-      (meshes: THREE.Mesh[], delta: number) => {
-        if (meshes.length === 0) return
-
-        for (let iteration = 0; iteration < collisionCheckIteration; iteration += 1) {
-          for (const mesh of meshes) {
-            collisionCheck(mesh, mesh.matrixWorld, delta)
-          }
-        }
-      },
-      [collisionCheck, collisionCheckIteration],
-    )
-
-    const floatingCheck = useCallback(
-      (mesh: THREE.Mesh, originMatrix: THREE.Matrix4) => {
-        if (!(mesh.visible && mesh.geometry.boundsTree) || mesh.userData.excludeFloatHit) return
-
-        originMatrix.decompose(floatTempPos.current, floatTempQuat.current, floatTempScale.current)
-        floatInvertMatrix.current.copy(originMatrix).invert()
-        floatNormalInverseMatrix.current.getNormalMatrix(floatInvertMatrix.current)
-        floatNormalMatrix.current.getNormalMatrix(originMatrix)
-
-        localFloatSensorSegment.current
-          .copy(floatSensorSegment.current)
-          .applyMatrix4(floatInvertMatrix.current)
-        localFloatSensorBboxExpendPoint.current
-          .copy(floatSensorBboxExpendPoint.current)
-          .applyMatrix4(floatInvertMatrix.current)
-
-        scaledFloatRadiusVec.current.set(
-          floatSensorRadius / floatTempScale.current.x,
-          floatSensorRadius / floatTempScale.current.y,
-          floatSensorRadius / floatTempScale.current.z,
-        )
-
-        localFloatSensorBbox.current
-          .makeEmpty()
-          .expandByPoint(localFloatSensorSegment.current.start)
-          .expandByPoint(localFloatSensorBboxExpendPoint.current)
-        localFloatSensorBbox.current.min.addScaledVector(scaledFloatRadiusVec.current, -1)
-        localFloatSensorBbox.current.max.add(scaledFloatRadiusVec.current)
-
-        localMinDistance.current = Number.POSITIVE_INFINITY
-        localClosestPoint.current.set(
-          Number.POSITIVE_INFINITY,
-          Number.POSITIVE_INFINITY,
-          Number.POSITIVE_INFINITY,
-        )
-
-        mesh.geometry.boundsTree.shapecast({
-          intersectsBounds: (box) => box.intersectsBox(localFloatSensorBbox.current),
-          intersectsTriangle: (tri) => {
-            tri.closestPointToSegment(
-              localFloatSensorSegment.current,
-              triHitPoint.current,
-              segHitPoint.current,
-            )
-            localUpAxis.current
-              .copy(upAxis.current)
-              .applyMatrix3(floatNormalInverseMatrix.current)
-              .normalize()
-            deltaHit.current.subVectors(triHitPoint.current, localFloatSensorSegment.current.start)
-            deltaHit.current.divide(scaledFloatRadiusVec.current)
-
-            const totalLengthSq = deltaHit.current.lengthSq()
-            const dot = deltaHit.current.dot(localUpAxis.current)
-            const verticalLength =
-              Math.abs(dot) /
-              ((capsuleRadius + floatHeight + floatPullBackHeight) / floatSensorRadius)
-            const horizontalLength = Math.sqrt(Math.max(0, totalLengthSq - dot * dot))
-
-            if (horizontalLength < 1 && verticalLength < 1) {
-              tri.getNormal(triNormal.current)
-              triNormal.current.applyMatrix3(floatNormalMatrix.current).normalize()
-              triHitPoint.current.applyMatrix4(originMatrix)
-
-              const slopeAngle = triNormal.current.angleTo(upAxis.current)
-              if (verticalLength < localMinDistance.current && slopeAngle < maxSlope) {
-                localMinDistance.current = verticalLength
-                localClosestPoint.current.copy(triHitPoint.current)
-                localHitNormal.current.copy(triNormal.current)
-              }
-            }
-          },
-        })
-
-        if (localMinDistance.current < globalMinDistance.current) {
-          globalMinDistance.current = localMinDistance.current
-          globalClosestPoint.current.copy(localClosestPoint.current)
-          floatHitNormal.current.copy(localHitNormal.current)
-        }
-      },
-      [capsuleRadius, floatHeight, floatPullBackHeight, floatSensorRadius, maxSlope],
-    )
-
-    const handleFloatingResponse = useCallback(
-      (meshes: THREE.Mesh[], jump: boolean, delta: number) => {
-        if (meshes.length === 0) return
-        let shouldJump = jump
-
-        globalMinDistance.current = Number.POSITIVE_INFINITY
-        globalClosestPoint.current.set(
-          Number.POSITIVE_INFINITY,
-          Number.POSITIVE_INFINITY,
-          Number.POSITIVE_INFINITY,
-        )
-        floatHitNormal.current.set(0, 1, 0)
-        isOnGround.current = false
-        totalPlatformDeltaPos.current.set(0, 0, 0)
-        isOnMovingPlatform.current = false
-
-        if (floatCheckType !== 'RAYCAST') {
-          for (const mesh of meshes) {
-            floatingCheck(mesh, mesh.matrixWorld)
-          }
-        }
-
-        if (
-          floatCheckType !== 'SHAPECAST' &&
-          floatRaycastCandidates.length > 0 &&
-          globalMinDistance.current === Number.POSITIVE_INFINITY
-        ) {
-          floatRaycaster.current.ray.origin.copy(floatSensorSegment.current.start)
-          floatRaycaster.current.ray.direction.copy(gravityDir.current)
-          const hits = floatRaycaster.current.intersectObjects(floatRaycastCandidates, false)
-          const hit = hits[0]
-          if (hit?.point) {
-            globalClosestPoint.current.copy(hit.point)
-            if (hit.face) {
-              floatHitNormal.current
-                .copy(hit.face.normal)
-                .transformDirection(hit.object.matrixWorld)
-                .normalize()
-            }
-          }
-        }
-
-        if (globalClosestPoint.current.x === Number.POSITIVE_INFINITY) return
-
-        relativeHitPoint.current
-          .copy(globalClosestPoint.current)
-          .sub(floatSensorSegment.current.start)
-        const currentDistance = relativeHitPoint.current.length()
-        currSlopeAngle.current = floatHitNormal.current.angleTo(upAxis.current)
-
-        if (currentDistance < floatHeight + capsuleRadius) {
-          isOnGround.current = true
-          shouldJump = false
-        }
-
-        if (!shouldJump) {
-          const displacement = floatHeight + capsuleRadius - currentDistance
-          const velocityOnHitNormal = currentLinVel.current.dot(floatHitNormal.current)
-          const springForce = displacement * floatSpringK
-          const dampingForce = -velocityOnHitNormal * floatDampingC
-          const totalForce = springForce + dampingForce - mass * gravity
-
-          currentLinVel.current.addScaledVector(floatHitNormal.current, (totalForce / mass) * delta)
-        }
-      },
-      [
-        capsuleRadius,
-        floatCheckType,
-        floatDampingC,
-        floatHeight,
-        floatRaycastCandidates,
-        floatSpringK,
-        floatingCheck,
-        gravity,
-        mass,
-      ],
-    )
-
-    const updateCharacterWithPlatform = useCallback(() => {
-      if (!characterGroupRef.current) return
-      rotationDeltaPos.current.copy(totalPlatformDeltaPos.current)
-      characterGroupRef.current.position.add(rotationDeltaPos.current)
-      yawQuaternion.current.setFromUnitVectors(upAxis.current, floatHitNormal.current)
-    }, [])
-
-    const updateCharacterAnimation = useCallback(
-      (run: boolean, jump: boolean): CharacterAnimationStatus => {
-        if (prevIsOnGround.current && jump) return 'JUMP_START'
-        if (!isOnGround.current && currentLinVel.current.y > 0) return 'JUMP_IDLE'
-        if (!isOnGround.current && currentLinVel.current.y <= 0) return 'JUMP_FALL'
-        if (!prevIsOnGround.current && isOnGround.current) return 'JUMP_LAND'
-        if (inputDir.current.lengthSq() > 0) return run ? 'RUN' : 'WALK'
-        return 'IDLE'
-      },
-      [],
-    )
-
-    const updateCharacterStatus = useCallback(
-      (run: boolean, jump: boolean) => {
-        characterModelRef.current?.getWorldPosition(characterStatus.position)
-        characterModelRef.current?.getWorldQuaternion(characterStatus.quaternion)
-        characterStatus.linvel.copy(currentLinVel.current)
-        characterStatus.inputDir.copy(inputDir.current)
-        characterStatus.movingDir.copy(movingDir.current)
-        characterStatus.isOnGround = isOnGround.current
-        characterStatus.isOnMovingPlatform = isOnMovingPlatform.current
-        characterStatus.animationStatus = updateCharacterAnimation(run, jump)
-        prevAnimation.current = characterStatus.animationStatus
-      },
-      [updateCharacterAnimation],
-    )
-
-    const resetLinVel = useCallback(() => currentLinVel.current.set(0, 0, 0), [])
-    const addLinVel = useCallback(
-      (velocity: THREE.Vector3) => currentLinVel.current.add(velocity),
-      [],
-    )
-    const setLinVel = useCallback(
-      (velocity: THREE.Vector3) => currentLinVel.current.copy(velocity),
-      [],
-    )
-    const setMovement = useCallback((movement: MovementInput) => {
-      if (movement.forward !== undefined) forwardState.current = movement.forward
-      if (movement.backward !== undefined) backwardState.current = movement.backward
-      if (movement.leftward !== undefined) leftwardState.current = movement.leftward
-      if (movement.rightward !== undefined) rightwardState.current = movement.rightward
-      if (movement.joystick) joystickState.current.set(movement.joystick.x, movement.joystick.y)
-      if (movement.run !== undefined) runState.current = movement.run
-      if (movement.jump !== undefined) jumpState.current = movement.jump
-    }, [])
-
-    useImperativeHandle(
-      ref,
-      () => ({
-        get group() {
-          return characterGroupRef.current
-        },
-        get model() {
-          return characterModelRef.current
-        },
-        resetLinVel,
-        addLinVel,
-        setLinVel,
-        setMovement,
-      }),
-      [addLinVel, resetLinVel, setLinVel, setMovement],
-    )
-
-    const updateDebugger = useCallback(() => {
-      debugLineStart.current?.position.copy(characterSegment.current.start)
-      debugLineEnd.current?.position.copy(characterSegment.current.end)
-      debugRaySensorStart.current?.position.copy(floatSensorSegment.current.start)
-      debugRaySensorEnd.current?.position.copy(floatSensorSegment.current.end)
-      standPointRef.current?.position.copy(globalClosestPoint.current)
-      if (characterGroupRef.current) {
-        lookDirRef.current?.position
-          .copy(characterGroupRef.current.position)
-          .addScaledVector(upAxis.current, 0.7)
-      }
-      lookDirRef.current?.lookAt(lookDirRef.current.position.clone().add(camProjDir.current))
-      inputDirRef.current?.position.copy(characterSegment.current.end)
-      inputDirRef.current?.setDirection(inputDir.current)
-      inputDirRef.current?.setLength(inputDir.current.lengthSq())
-      moveDirRef.current?.position.copy(characterSegment.current.end)
-      moveDirRef.current?.setDirection(currentLinVel.current)
-      moveDirRef.current?.setLength(currentLinVel.current.length() / maxWalkSpeed)
-    }, [maxWalkSpeed])
-
-    useFrame((_, delta) => {
-      elapsedRef.current += delta
-      if (paused || elapsedRef.current < delay) return
-
-      const deltaTime = Math.min(1 / 45, delta) * slowMotionFactor
-      const keys = getKeys() ?? presetKeys
-      const forward = forwardState.current || (keys.forward ?? false)
-      const backward = backwardState.current || (keys.backward ?? false)
-      const leftward = leftwardState.current || (keys.leftward ?? false)
-      const rightward = rightwardState.current || (keys.rightward ?? false)
-      const run = runState.current || (keys.run ?? false)
-      const jump = jumpState.current || (keys.jump ?? false)
-
-      setInputDirection({
-        forward,
-        backward,
-        leftward,
-        rightward,
-        joystick: joystickState.current,
-      })
-      handleCharacterMovement(run, deltaTime)
-      if (jump && isOnGround.current) currentLinVel.current.y = jumpVel
-      movingDir.current.copy(currentLinVel.current).normalize()
-      currentLinVelOnPlane.current.copy(currentLinVel.current).projectOnPlane(upAxis.current)
-
-      checkCharacterSleep(jump, deltaTime)
-      if (!isSleeping.current) {
-        if (!isOnGround.current) applyGravity(deltaTime)
-
-        updateSegmentBBox()
-        handleCollisionResponse(colliderMeshes, deltaTime)
-        handleFloatingResponse(colliderMeshes, jump, deltaTime)
-        updateCharacterWithPlatform()
-
-        if (characterGroupRef.current) {
-          characterGroupRef.current.position.addScaledVector(currentLinVel.current, deltaTime)
-        }
-
-        updateCharacterStatus(run, jump)
-        prevIsOnGround.current = isOnGround.current
-      }
-
-      if (debug) updateDebugger()
-    })
-
-    return (
-      <Suspense fallback={null}>
-        <group {...props} dispose={null} ref={characterGroupRef}>
-          {debug && (
-            <mesh ref={characterColliderRef}>
-              <capsuleGeometry args={colliderCapsuleArgs} />
-              <meshNormalMaterial wireframe />
-            </mesh>
-          )}
-          <group name="BVHEcctrl-Model" ref={characterModelRef}>
-            {children}
-          </group>
-        </group>
-
-        {debug && (
-          <group>
-            <TransformControls object={characterGroupRef.current!} />
-            <box3Helper args={[characterBbox.current]} />
-            <mesh ref={debugLineStart}>
-              <octahedronGeometry args={[0.05, 0]} />
-              <meshNormalMaterial />
-            </mesh>
-            <mesh ref={debugLineEnd}>
-              <octahedronGeometry args={[0.05, 0]} />
-              <meshNormalMaterial />
-            </mesh>
-            <box3Helper args={[floatSensorBbox.current]} />
-            <mesh ref={debugRaySensorStart}>
-              <octahedronGeometry args={[0.1, 0]} />
-              <meshBasicMaterial color="yellow" wireframe />
-            </mesh>
-            <mesh ref={debugRaySensorEnd}>
-              <octahedronGeometry args={[0.1, 0]} />
-              <meshBasicMaterial color="yellow" wireframe />
-            </mesh>
-            <mesh ref={lookDirRef} scale={[1, 0.5, 4]}>
-              <octahedronGeometry args={[0.1, 0]} />
-              <meshNormalMaterial />
-            </mesh>
-            <arrowHelper args={[undefined, undefined, undefined, '#00f']} ref={inputDirRef} />
-            <arrowHelper args={[undefined, undefined, undefined, '#f00']} ref={moveDirRef} />
-            <mesh ref={standPointRef}>
-              <octahedronGeometry args={[0.12, 0]} />
-              <meshBasicMaterial color="red" opacity={0.2} transparent />
-            </mesh>
-          </group>
-        )}
-      </Suspense>
-    )
-  },
-)
-
-BVHEcctrl.displayName = 'BVHEcctrl'
-
-export default BVHEcctrl