gaesup-world 0.0.5 → 0.0.7

package/README.md

@@ -1,51 +1,200 @@
 # Gaesup World
 
-Web 3D Character Controller and World Platform Library
-
-[![npm (tag)](https://img.shields.io/npm/v/leva?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/leva)
-
-@react-three/fiber
-@react-three/drei
-three @types/three
-@react-three/rapier
+[![Version](https://img.shields.io/npm/v/gaesup-world?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/gaesup-world)
+[![Downloads](https://img.shields.io/npm/dt/gaesup-world.svg?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/gaesup-world)
 
-Gaesup World는 @react/three-fiber, @react/three-drei, rapier 를 사용하여 웹 3D 환경에서 캐릭터, 비행기, 자동자 등의 컨트롤 도구를 제공하는 라이브러리입니다.
+Web 3D Character Controller and World Platform Library
 
-이 컨트롤러는 캐릭터의 움직임, 애니메이션, 상호작용을 쉽게 관리할 수 있도록 설계되었습니다. 가상의 세계에서 캐릭터를 움직이거나 탈것을 쉽게 활용할 수 있고, 미니맵이나 조이스틱 등의 유틸 등도 설계되어 있습니다
+[![main](https://github.com/jigglypop/gaesup-world/blob/master/image/main_image.png)](https://codesandbox.io/p/github/jigglypop/gaesup-world-examples/master?workspaceId=e8ae627a-af61-415e-aa21-1fe5af422c86)
+
+> click and watch code sandbox example!
+
+---
+
+## introduction
+
+Gaesup World is a library that uses @react/three-fiber, @react/three-drei, and rapier to provide control tools for characters, airplanes, cars, and more in a web 3D environment. This controller is designed to easily manage character movement, animation, and interaction. It allows for easy manipulation of characters or vehicles in a virtual world, and is also equipped with utilities like minimaps and joysticks.
+
+## How to start
+
+```tsx
+"use client";
+
+import { Environment, KeyboardControls } from "@react-three/drei";
+import { Canvas } from "@react-three/fiber";
+import { Physics, RigidBody } from "@react-three/rapier";
+
+import { GaesupController, GaesupWorld } from "gaesup-world";
+
+export const keyboardMap = [
+  { name: "forward", keys: ["ArrowUp", "KeyW"] },
+  { name: "backward", keys: ["ArrowDown", "KeyS"] },
+  { name: "leftward", keys: ["ArrowLeft", "KeyA"] },
+  { name: "rightward", keys: ["ArrowRight", "KeyD"] },
+  { name: "space", keys: ["Space"] },
+  { name: "shift", keys: ["Shift"] },
+  { name: "keyZ", keys: ["KeyZ"] },
+];
+
+export default function App() {
+  const CHARACTER_URL = "./gaesupyee.glb";
+
+  return (
+    <GaesupWorld
+      url={{
+        characterUrl: CHARACTER_URL,
+      }}
+    >
+      <Canvas shadows style={{ width: "100dvw", height: "100dvh" }}>
+        <Environment background preset="sunset" blur={0.8} />
+        <Physics>
+          <KeyboardControls map={keyboardMap}>
+            <GaesupController
+              groupProps={{
+                rotation: [0, Math.PI, 0],
+              }}
+            />
+          </KeyboardControls>
+          <RigidBody type="fixed">
+            <mesh receiveShadow position={[0, 0, 0]}>
+              <boxGeometry args={[300, 5, 300]} />
+              <meshStandardMaterial />
+            </mesh>
+          </RigidBody>
+        </Physics>
+      </Canvas>
+    </GaesupWorld>
+  );
+}
+```
 
-## 특징
+### Features
 
-- React Three Fiber를 기반으로 하는 3D 캐릭터 컨트롤
-- 간단한 API를 통한 캐릭터 움직임 및 애니메이션 제어
-- 확장 가능한 구조로 다양한 커스터마이징 지원
-- 가벼운 라이브러리로 빠른 로딩 및 성능 최적화
+- 3D character control based on React Three Fiber.
+- Simple API for controlling character movement and animation.
+- Extensible structure for various customizations.
+- Lightweight library for fast loading and performance optimization.
 
-## 설치 방법
+### Installation
 
 ```bash
 npm install @react-three/fiber @react-three/drei three @types/three @react-three/rapier gaesup-world
 ```
 
-또는
+Or
 
 ```bash
 yarn add @react-three/fiber @react-three/drei three @types/three @react-three/rapier gaesup-world
 ```
 
-## 문서
+### Documentation
+
+it is detailed usage methods and API documentation
+
+- [how to contribute](#how-to-contribute)
+
+### How to Contribute
+
+If you would like to contribute to this project, please follow these steps:
+
+1. Fork the project.
+2. Create a new Feature branch (`git checkout -b feature/AmazingFeature`).
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`).
+4. Push to the branch (`git push origin feature/AmazingFeature`).
+5. Create a Pull Request.
+
+### License
+
+This project is distributed under the MIT License.
+
+---
+
+## Controller
+
+#### [Controller](#controller)
+
+- [Character](#character)
+- [Vehicle](#vehicle)
+- [Airplane](#airplane)
+
+## Character
+
+This is the character control in Gaesup World.
+
+- Possible Camera Types
+
+| Name   | Camera              | Control       | Info                                                                                          |
+| ------ | ------------------- | ------------- | --------------------------------------------------------------------------------------------- |
+| Normal | Perspective Camera  | Orbit Control | Positioned parallel to the Z-axis from the character's location and not affected by rotation. |
+| Orbit  | Perspective Camera  | Orbit Control | Moves with the character and rotates according to the character's direction.                  |
+| Map    | Orthographic Camera | Map Control   | A top-down control view.                                                                      |
+
+- Controller Tools
+
+| Name     | Info                                                                    |
+| -------- | ----------------------------------------------------------------------- |
+| Keyboard | A standard keyboard tool. You can see where on the keyboard is clicked. |
+| Joystick | A joystick implementation tool. It works on mobile devices.             |
+| Gameboy  | A Gameboy implementation tool. It works on mobile devices.              |
+
+## Vehicle
+
+This is the vehicle control in Gaesup World. Characters can board the vehicle.
+
+- Possible Camera Types
+
+| Name   | Camera              | Control       | Info                                                                                          |
+| ------ | ------------------- | ------------- | --------------------------------------------------------------------------------------------- |
+| Normal | Perspective Camera  | Orbit Control | Positioned parallel to the Z-axis from the character's location and not affected by rotation. |
+| Orbit  | Perspective Camera  | Orbit Control | Moves with the character and rotates according to the character's direction.                  |
+| Map    | Orthographic Camera | Map Control   | A top-down control view.                                                                      |
+
+- Controller Tools
+
+| Name     | Info                                                                    |
+| -------- | ----------------------------------------------------------------------- |
+| Keyboard | A standard keyboard tool. You can see where on the keyboard is clicked. |
+| Joystick | A joystick implementation tool. It works on mobile devices.             |
+| Gameboy  | A Gameboy implementation tool. It works on mobile devices.              |
+
+## Airplane
+
+This is the airplane control in Gaesup World. Characters can board the airplane.
+
+- Possible Camera Types
+
+| Name   | Camera              | Control       | Info                                                                                          |
+| ------ | ------------------- | ------------- | --------------------------------------------------------------------------------------------- |
+| Normal | Perspective Camera  | Orbit Control | Positioned parallel to the Z-axis from the character's location and not affected by rotation. |
+| Orbit  | Perspective Camera  | Orbit Control | Moves with the character and rotates according to the character's direction.                  |
+| Map    | Orthographic Camera | Map Control   | A top-down control view.                                                                      |
+
+- Controller Tools
+
+| Name     | Info                                                                    |
+| -------- | ----------------------------------------------------------------------- |
+| Keyboard | A standard keyboard tool. You can see where on the keyboard is clicked. |
+| Joystick | A joystick implementation tool. It works on mobile devices.             |
+| Gameboy  | A Gameboy implementation tool. It works on mobile devices.              |
+
+---
+
+## Tools
+
+#### [Tools](#tools)
+
+#### [joystick](#joystick)
+
+#### [keyboardtooltip](#keyboard tooltip)
 
-더 자세한 사용 방법 및 API 문서는 [여기](#)를 참조하세요.
+#### [minimap](#minimap)
 
-## 기여 방법
+#### [gameboy](#gameboy)
 
-이 프로젝트에 기여하고 싶으시다면, 다음 단계를 따라주세요:
+## joystick
 
-1. 프로젝트를 Fork합니다.
-2. 새로운 Feature 브랜치를 생성합니다 (`git checkout -b feature/AmazingFeature`).
-3. 변경사항을 Commit합니다 (`git commit -m 'Add some AmazingFeature'`).
-4. 브랜치에 Push합니다 (`git push origin feature/AmazingFeature`).
-5. Pull Request를 생성합니다.
+## keyboard tooltip
 
-## 라이센스
+## minimap
 
-이 프로젝트는 [MIT 라이센스](LICENSE) 하에 배포됩니다.
+## gameboy

package/dist/gaesup/animation/actions.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from "react";
+import { Object3D, Object3DEventMap } from "three";
+import { animationTagType, groundRayType } from "../controller/type";
+export type playActionsType = {
+    groundRay: groundRayType;
+};
+export type actionsType = {
+    [x: string]: THREE.AnimationAction | null;
+};
+export type playResultType = {
+    actions: actionsType;
+    ref: Ref<Object3D<Object3DEventMap>>;
+};
+export declare function usePlayActions(): {
+    resultRef: {
+        character: playResultType;
+        vehicle: playResultType;
+        airplane: playResultType;
+    };
+    play: (tag: keyof animationTagType) => void;
+    setAnimationName: (actions: actionsType) => void;
+};
+export default function playCharacterActions({ groundRay }: playActionsType): {
+    ref: Ref<Object3D<Object3DEventMap>>;
+};

package/dist/gaesup/animation/actions.js

@@ -0,0 +1,126 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { useAnimations, useKeyboardControls } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useContext, useEffect } from "react";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../world/context";
+export function usePlayActions() {
+    var _a = useContext(GaesupWorldContext), characterGltf = _a.characterGltf, vehicleGltf = _a.vehicleGltf, airplaneGltf = _a.airplaneGltf, animations = _a.animations;
+    var characterAnimations = characterGltf.animations;
+    var characterResult = useAnimations(characterAnimations);
+    var vehicleAnimations = vehicleGltf.animations;
+    var vehicleResult = useAnimations(vehicleAnimations);
+    var airplaneAnimations = airplaneGltf.animations;
+    var airplaneResult = useAnimations(airplaneAnimations);
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var play = function (tag) {
+        animations.current = tag;
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    };
+    var setAnimationName = function (actions) {
+        animations.animationNames = Object.assign(animations.animationNames, Object.keys(actions).reduce(function (acc, cur) {
+            var _a;
+            return __assign(__assign({}, acc), (_a = {}, _a[cur] = cur, _a));
+        }, {}));
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    };
+    var resultRef = {
+        character: characterResult,
+        vehicle: vehicleResult,
+        airplane: airplaneResult,
+    };
+    return { resultRef: resultRef, play: play, setAnimationName: setAnimationName };
+}
+export default function playCharacterActions(_a) {
+    var groundRay = _a.groundRay;
+    var _b = usePlayActions(), _c = _b.resultRef.character, actions = _c.actions, ref = _c.ref, play = _b.play, setAnimationName = _b.setAnimationName;
+    var _d = useContext(GaesupWorldContext), states = _d.states, activeState = _d.activeState, animations = _d.animations, mode = _d.mode;
+    var isNotMoving = states.isNotMoving, isMoving = states.isMoving, isJumping = states.isJumping, isRunning = states.isRunning, isAnimationOuter = states.isAnimationOuter, isOnTheGround = states.isOnTheGround;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var control = useKeyboardControls()[1]();
+    var resetAni = function () { return play("idle"); };
+    var playIdle = function () { return play("idle"); };
+    var playWalk = function () { return play("walk"); };
+    var playRun = function () { return play("run"); };
+    var playJump = function () { return play("jump"); };
+    var playFall = function () { return play("fall"); };
+    var playRide = function () { return play("ride"); };
+    var playLanding = function () { return play("land"); };
+    useEffect(function () {
+        return function () {
+            resetAni();
+        };
+    }, []);
+    useEffect(function () {
+        animations.keyControl = control;
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    }, [control]);
+    useEffect(function () {
+        var _a;
+        if (mode.type === "character") {
+            var action_1 = (_a = actions[animations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+            setAnimationName(actions);
+            return function () {
+                action_1 === null || action_1 === void 0 ? void 0 : action_1.fadeOut(0.2);
+            };
+        }
+    }, [animations.current, mode.type]);
+    useFrame(function () {
+        if (mode.type === "character") {
+            if (!isAnimationOuter) {
+                if (isJumping) {
+                    playJump();
+                }
+                else if (isNotMoving) {
+                    playIdle();
+                }
+                else if (isRunning) {
+                    playRun();
+                }
+                else if (isMoving) {
+                    playWalk();
+                }
+                if (groundRay.hit) {
+                    if (!isJumping && !isOnTheGround) {
+                        if (groundRay.hit.toi < 5) {
+                            playLanding();
+                        }
+                        else {
+                            playFall();
+                        }
+                    }
+                }
+                if (groundRay.hit === null && activeState.velocity.y < 0) {
+                    playFall();
+                }
+            }
+        }
+    });
+    return {
+        ref: ref,
+    };
+}

package/dist/gaesup/animation/index.d.ts

@@ -0,0 +1 @@
+export * as playActions from "./actions";

package/dist/gaesup/animation/index.js

@@ -0,0 +1 @@
+export * as playActions from "./actions";

package/dist/gaesup/animation/passiveActions.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { AnimationClip } from "three";
+export type playPassiveActionsType = {
+    current: string;
+    animations: AnimationClip[];
+};
+export default function playPassiveActions({ current, animations, }: playPassiveActionsType): {
+    animationRef: import("react").MutableRefObject<import("three").Object3D<import("three").Object3DEventMap>>;
+};

package/dist/gaesup/animation/passiveActions.js

@@ -0,0 +1,16 @@
+import { useAnimations } from "@react-three/drei";
+import { useEffect } from "react";
+export default function playPassiveActions(_a) {
+    var current = _a.current, animations = _a.animations;
+    var _b = useAnimations(animations), actions = _b.actions, animationRef = _b.ref;
+    useEffect(function () {
+        var _a;
+        var action = (_a = actions[current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+        return function () {
+            action === null || action === void 0 ? void 0 : action.fadeOut(0.2);
+        };
+    }, [current]);
+    return {
+        animationRef: animationRef,
+    };
+}

package/dist/gaesup/camera/cameraCollisionDetecter.d.ts

@@ -0,0 +1,4 @@
+import { controllerInnerType } from "../controller/type";
+export default function cameraCollisionDetector(prop: controllerInnerType): {
+    checkCollision: (delta: number) => void;
+};

package/dist/gaesup/camera/cameraCollisionDetecter.js

@@ -0,0 +1,50 @@
+export default function cameraCollisionDetector(prop) {
+    //   const { cameraRay, constant, options } = prop;
+    //   const { camera } = useThree();
+    var checkCollision = function (delta) {
+        //     cameraRay.origin.copy(cameraRay.pivot.position);
+        //     camera.getWorldPosition(cameraRay.position);
+        //     cameraRay.dir.subVectors(cameraRay.position, cameraRay.pivot.position);
+        //     cameraRay.intersects = cameraRay.rayCast!.intersectObjects(
+        //       Object.values(cameraRay.intersectObjectMap)
+        //     );
+        //     if (
+        //       cameraRay.intersects.length &&
+        //       cameraRay.intersects[0].distance <= -constant.cameraInitDistance
+        //     ) {
+        //       if (options.cameraCollisionType === "transparent") {
+        //         cameraRay.intersetesAndTransParented = [...cameraRay.intersects];
+        //         cameraRay.intersetesAndTransParented.map((intersect) => {
+        //           const mesh = intersect.object as THREE.Mesh;
+        //           const material = mesh.material as THREE.MeshStandardMaterial;
+        //           material.opacity = 0.2;
+        //           material.transparent = true;
+        //         });
+        //       } else if (options.cameraCollisionType === "closeUp") {
+        //         constant.cameraMinDistance =
+        //           -cameraRay.intersects[0].distance * constant.cameraCollisionOff < -0.7
+        //             ? -cameraRay.intersects[0].distance * constant.cameraCollisionOff
+        //             : -0.7;
+        //       }
+        //     } else {
+        //       if (options.cameraCollisionType === "transparent") {
+        //         cameraRay.intersetesAndTransParented.map((intersect) => {
+        //           const mesh = intersect.object as THREE.Mesh;
+        //           const material = mesh.material as THREE.MeshStandardMaterial;
+        //           material.opacity = 1;
+        //           material.transparent = false;
+        //         });
+        //         cameraRay.intersetesAndTransParented = [];
+        //       }
+        //       constant.cameraMinDistance = constant.cameraInitDistance;
+        //     }
+        //     cameraRay.lerpingPoint.set(
+        //       cameraRay.followCamera.position.x,
+        //       constant.cameraMinDistance * Math.sin(-cameraRay.followCamera.rotation.x),
+        //       constant.cameraMinDistance * Math.cos(-cameraRay.followCamera.rotation.x)
+        //     );
+        //
+        //     cameraRay.followCamera.position.lerp(cameraRay.lerpingPoint, delta * 4);
+    };
+    return { checkCollision: checkCollision };
+}

package/dist/gaesup/camera/control/map.js

@@ -0,0 +1,5 @@
+export default function mapControl(prop) {
+    var state = prop.state, activeState = prop.worldContext.activeState;
+    var position = activeState.position.clone();
+    state.camera.position.set(-10, 10, -10).add(position);
+}

package/dist/gaesup/camera/control/normal.js

@@ -0,0 +1,9 @@
+import { V3 } from "../../utils/vector";
+export default function normal(prop) {
+    var state = prop.state, perspectiveCamera = prop.controllerContext.perspectiveCamera, activeState = prop.worldContext.activeState;
+    var cameraPosition = activeState.position
+        .clone()
+        .add(V3(0, perspectiveCamera.YDistance, perspectiveCamera.XZDistance));
+    state.camera.position.lerp(cameraPosition, 1);
+    state.camera.lookAt(activeState.position.clone());
+}

package/dist/gaesup/camera/control/orbit.js

@@ -0,0 +1,18 @@
+import { quat } from "@react-three/rapier";
+import { V3 } from "../../utils/vector";
+export default function orbit(prop) {
+    var state = prop.state, perspectiveCamera = prop.controllerContext.perspectiveCamera, activeState = prop.worldContext.activeState;
+    var cameraPosition = activeState.position.clone().add(V3(Math.sin(activeState.euler.y), 0, Math.cos(activeState.euler.y))
+        .normalize()
+        .clone()
+        .multiplyScalar(perspectiveCamera.XZDistance)
+        .multiplyScalar(perspectiveCamera.isFront ? -1 : 1)
+        .add(V3(0, perspectiveCamera.YDistance, 0)));
+    state.camera.position.lerp(cameraPosition, 0.5);
+    state.camera.quaternion.copy(activeState.quat
+        .clone()
+        .multiply(perspectiveCamera.isFront
+        ? quat().setFromAxisAngle(V3(0, 1, 0), Math.PI)
+        : quat()));
+    state.camera.lookAt(activeState.position);
+}

package/{src → dist}/gaesup/camera/index.d.ts

@@ -1,7 +1,7 @@
-import { propType, refsType } from "../controller/type";
+import { controllerInnerType, refsType } from "../controller/type";
 export default function Camera({ refs, prop, control, }: {
     refs: refsType;
-    prop: propType;
+    prop: controllerInnerType;
     control: {
         [key: string]: boolean;
     };

package/dist/gaesup/camera/index.js

@@ -0,0 +1,69 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { MapControls, OrbitControls, OrthographicCamera, PerspectiveCamera, } from "@react-three/drei";
+import { useFrame, useThree } from "@react-three/fiber";
+import { useContext } from "react";
+import * as THREE from "three";
+import { GaesupControllerContext } from "../controller/context";
+import { GaesupWorldContext } from "../world/context";
+import cameraCollisionDetector from "./cameraCollisionDetecter";
+import mapControl from "./control/map";
+import normal from "./control/normal";
+import orbit from "./control/orbit";
+export default function Camera(_a) {
+    var refs = _a.refs, prop = _a.prop, control = _a.control;
+    var worldContext = useContext(GaesupWorldContext);
+    var controllerContext = useContext(GaesupControllerContext);
+    var cameraMode = controllerContext.cameraMode, perspectiveCamera = controllerContext.perspectiveCamera, orthographicCamera = controllerContext.orthographicCamera;
+    var rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef;
+    var cameraRay = prop.cameraRay;
+    var checkCollision = cameraCollisionDetector(prop).checkCollision;
+    var scene = useThree().scene;
+    var activeState = worldContext.activeState;
+    var intersectObjectMap = {};
+    var cameraProp = __assign(__assign({}, prop), { checkCollision: checkCollision, control: control, controllerContext: controllerContext, worldContext: worldContext });
+    var getMeshs = function (object) {
+        if (object.userData && object.userData.intangible)
+            return;
+        if (object instanceof THREE.Mesh &&
+            object.geometry.type !== "InstancedBufferGeometry") {
+            intersectObjectMap[object.uuid] = object;
+        }
+        object.children.forEach(function (child) {
+            getMeshs(child);
+        });
+    };
+    useFrame(function (state, delta) {
+        if (!rigidBodyRef ||
+            !rigidBodyRef.current ||
+            !outerGroupRef ||
+            !outerGroupRef.current)
+            return null;
+        cameraProp.state = state;
+        cameraProp.delta = delta;
+        if (cameraMode.cameraType === "perspective") {
+            scene.children.forEach(function (child) { return getMeshs(child); });
+            cameraRay.intersectObjectMap = intersectObjectMap;
+            if (cameraMode.controlType === "orbit") {
+                orbit(cameraProp);
+            }
+            else if (cameraMode.controlType === "normal") {
+                normal(cameraProp);
+            }
+        }
+        else if (cameraMode.cameraType === "orthographic") {
+            mapControl(cameraProp);
+        }
+    });
+    return (_jsxs(_Fragment, { children: [cameraMode.cameraType === "perspective" && (_jsxs(_Fragment, { children: [_jsx(OrbitControls, { target: activeState.position }), _jsx(PerspectiveCamera, __assign({ makeDefault: true }, perspectiveCamera))] })), cameraMode.cameraType === "orthographic" && (_jsxs(_Fragment, { children: [_jsx(MapControls, { target: activeState.position }), _jsx(OrthographicCamera, __assign({ makeDefault: true }, orthographicCamera))] }))] }));
+}

package/dist/gaesup/component/active/airplane/collider.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { Collider } from "@dimforge/rapier3d-compat";
+import { controllerInnerType } from "../../../controller/type";
+export declare const AirplaneCollider: import("react").ForwardRefExoticComponent<{
+    props: controllerInnerType;
+} & import("react").RefAttributes<Collider>>;

package/dist/gaesup/component/active/airplane/collider.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CuboidCollider, useRapier } from "@react-three/rapier";
+import { forwardRef, useContext } from "react";
+import { getRayHit, useForwardRef } from "../../../utils";
+import { GaesupWorldContext } from "../../../world/context";
+export var AirplaneCollider = forwardRef(function (_a, ref) {
+    var _b;
+    var props = _a.props;
+    var collider = useContext(GaesupWorldContext).airplaneCollider;
+    var airplaneSizeX = collider.airplaneSizeX, airplaneSizeY = collider.airplaneSizeY, airplaneSizeZ = collider.airplaneSizeZ;
+    var colliderRef = useForwardRef(ref);
+    var rapier = useRapier().rapier;
+    var groundRay = props.groundRay;
+    groundRay.length = airplaneSizeY * 5 + 2;
+    groundRay.rayCast = new rapier.Ray(groundRay.origin, groundRay.dir);
+    groundRay.hit = getRayHit({
+        ray: groundRay,
+        ref: colliderRef,
+    });
+    groundRay.parent = (_b = groundRay.hit) === null || _b === void 0 ? void 0 : _b.collider.parent();
+    return (_jsx(CuboidCollider, { ref: ref, args: [airplaneSizeX / 2, airplaneSizeY / 2, airplaneSizeZ / 2], position: [0, airplaneSizeY / 2, 0] }));
+});

package/dist/gaesup/component/active/airplane/index.d.ts

@@ -0,0 +1,5 @@
+import { controllerInnerType, refsType } from "../../../controller/type";
+export declare function AirplaneRef({ props, refs, }: {
+    props: controllerInnerType;
+    refs: refsType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/active/airplane/index.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { GaesupWorldContext } from "../../../world/context";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { WrapperRef } from "../common/WrapperRef";
+import { AirplaneCollider } from "./collider";
+export function AirplaneRef(_a) {
+    var props = _a.props, refs = _a.refs;
+    var _b = useContext(GaesupWorldContext), characterGltf = _b.characterGltf, airplaneGltf = _b.airplaneGltf;
+    return (_jsxs(WrapperRef, { props: props, refs: refs, gltf: airplaneGltf, children: [props.isRider && (_jsx(InnerGroupRef, { props: props, gltf: characterGltf, ref: refs.characterInnerRef })), _jsx(AirplaneCollider, { props: props })] }));
+}

package/dist/gaesup/component/active/character/collider.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { Collider } from "@dimforge/rapier3d-compat";
+import { controllerInnerType } from "../../../controller/type";
+export declare const CharacterCapsuleCollider: import("react").ForwardRefExoticComponent<{
+    props: controllerInnerType;
+} & import("react").RefAttributes<Collider>>;