gaesup-world 0.0.781 → 0.0.782

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

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

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

@@ -1,18 +1,17 @@
 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 state = prop.state, _a = prop.worldContext, activeState = _a.activeState, cameraOption = _a.cameraOption;
+    if (!state || !state.camera)
+        return;
     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.9);
+        .multiplyScalar(-cameraOption.XZDistance)
+        .add(V3(0, cameraOption.YDistance, 0)));
+    state.camera.position.lerp(cameraPosition, 1);
     state.camera.quaternion.copy(activeState.quat
         .clone()
-        .multiply(perspectiveCamera.isFront
-        ? quat().setFromAxisAngle(V3(0, 1, 0), Math.PI)
-        : quat()));
+        .multiply(quat().setFromAxisAngle(V3(0, 1, 0), Math.PI)));
     state.camera.lookAt(activeState.position.clone());
 }

package/dist/gaesup/camera/index.js

@@ -9,24 +9,24 @@ var __assign = (this && this.__assign) || function () {
     };
     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 { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { CameraControls } from "@react-three/drei";
 import { useFrame, useThree } from "@react-three/fiber";
-import { useContext, useEffect, useMemo } from "react";
+import { useContext, useEffect, useMemo, useRef } from "react";
 import * as THREE from "three";
 import { GaesupControllerContext } from "../controller/context";
 import { GaesupWorldContext } from "../world/context";
-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 mode = worldContext.mode, activeState = worldContext.activeState;
     var rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef;
     var scene = useThree().scene;
-    var activeState = worldContext.activeState;
+    var state = useThree();
+    var cameraRef = useRef();
     var intersectObjectMap = useMemo(function () { return ({}); }, []);
     var cameraProp = __assign(__assign({}, prop), { control: control, controllerContext: controllerContext, worldContext: worldContext, intersectObjectMap: intersectObjectMap });
     var getMeshs = function (object) {
@@ -49,23 +49,14 @@ export default function Camera(_a) {
             !outerGroupRef ||
             !outerGroupRef.current)
             return null;
-        cameraProp.state = state;
         cameraProp.delta = delta;
-        if (cameraMode.cameraType === "perspective") {
-            if (cameraMode.controlType === "orbit") {
-                orbit(cameraProp);
-            }
-            else if (cameraMode.controlType === "normal") {
-                normal(cameraProp);
-            }
+        cameraProp.state = state;
+        if (mode.control === "orbit") {
+            orbit(cameraProp);
         }
-        else if (cameraMode.cameraType === "orthographic") {
-            mapControl(cameraProp);
+        else if (mode.control === "normal") {
+            normal(cameraProp);
         }
-        // const distV3 = camera.position.clone().sub(activeState.position);
-        // cameraRay.origin.copy(camera.position);
-        // cameraRay.dir.copy(distV3.negate().normalize());
-        // detector(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))] }))] }));
+    return (_jsx(_Fragment, { children: _jsx(CameraControls, { ref: cameraRef }) }));
 }

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

@@ -27,9 +27,11 @@ export function PassiveAirplane(props) {
     }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation, airplaneUrl = _a.airplaneUrl;
     useFrame(function () {
         if (innerGroupRef && innerGroupRef.current) {
+            var _euler = euler.clone();
+            _euler.y = 0;
             innerGroupRef.current.setRotationFromQuaternion(quat()
                 .setFromEuler(innerGroupRef.current.rotation.clone())
-                .slerp(quat().setFromEuler(euler), 0.1));
+                .slerp(quat().setFromEuler(_euler), 0.2));
         }
         if (rigidBodyRef && rigidBodyRef.current) {
             rigidBodyRef.current.setGravityScale(props.gravity, false);

package/dist/gaesup/component/passive/common/RigidbodyRef.js

@@ -3,5 +3,8 @@ import { RigidBody } from "@react-three/rapier";
 import { forwardRef } from "react";
 export var RigidBodyRef = forwardRef(function (_a, ref) {
     var children = _a.children, position = _a.position, rotation = _a.rotation;
-    return (_jsx(RigidBody, { colliders: false, ref: ref, position: position, rotation: rotation, userData: { intangible: true }, children: children }));
+    var _euler = rotation.clone();
+    _euler.x = 0;
+    _euler.z = 0;
+    return (_jsx(RigidBody, { colliders: false, ref: ref, position: position, rotation: _euler, userData: { intangible: true }, children: children }));
 });

package/dist/gaesup/controller/context/index.d.ts

@@ -1,28 +1,7 @@
 /// <reference types="react" />
 import { dispatchType } from "../../utils/type";
-import { gaesupControllerType, orthographicCameraType, perspectiveCameraType } from "./type";
+import { gaesupControllerType } from "./type";
 export declare const gaesupControllerDefault: {
-    cameraMode: perspectiveCameraType | orthographicCameraType;
-    cameraOption: {
-        offset: import("three").Vector3;
-        initDistance: number;
-        maxDistance: number;
-        minDistance: number;
-        initDir: number;
-        collisionOff: number;
-        distance: number;
-        camFollow: number;
-    };
-    perspectiveCamera: {
-        isFront: boolean;
-        XZDistance: number;
-        YDistance: number;
-    };
-    orthographicCamera: {
-        zoom: number;
-        near: number;
-        far: number;
-    };
     airplane: {
         angleDelta: import("three").Vector3;
         maxAngle: import("three").Vector3;

package/dist/gaesup/controller/context/index.js

@@ -12,33 +12,9 @@ var __assign = (this && this.__assign) || function () {
 import { createContext } from "react";
 import { V3 } from "../../utils/vector";
 export var gaesupControllerDefault = {
-    cameraMode: {
-        cameraType: "perspective",
-        controlType: "normal",
-    },
-    cameraOption: {
-        offset: V3(-10, -10, -10),
-        initDistance: -5,
-        maxDistance: -7,
-        minDistance: -0.7,
-        initDir: 0,
-        collisionOff: 0.7,
-        distance: -1,
-        camFollow: 11,
-    },
-    perspectiveCamera: {
-        isFront: true,
-        XZDistance: 8,
-        YDistance: 1,
-    },
-    orthographicCamera: {
-        zoom: 1,
-        near: 0.1,
-        far: 1000,
-    },
     airplane: {
-        angleDelta: V3(0.01, 0.005, 0.005),
-        maxAngle: V3(0.1, 0.1, 0.1),
+        angleDelta: V3(Math.PI / 256, Math.PI / 256, Math.PI / 256),
+        maxAngle: V3(Math.PI / 8, Math.PI / 8, Math.PI / 8),
         maxSpeed: 60,
         accelRatio: 2,
         brakeRatio: 5,
@@ -53,10 +29,10 @@ export var gaesupControllerDefault = {
         linearDamping: 0.5,
     },
     character: {
-        walkSpeed: 4,
-        runSpeed: 10,
+        walkSpeed: 10,
+        runSpeed: 20,
         turnSpeed: 10,
-        jumpSpeed: 0.5,
+        jumpSpeed: 1,
         linearDamping: 1,
     },
     callbacks: {

package/dist/gaesup/controller/context/reducer.d.ts

@@ -3,10 +3,6 @@ export declare function gaesupControllerReducer(props: gaesupControllerType, act
     type: string;
     payload?: Partial<gaesupControllerType>;
 }): {
-    cameraMode: import("./type").gaesupCameraPropType;
-    cameraOption: import("./type").cameraOptionType;
-    perspectiveCamera: import("./type").perspectiveCameraPropType;
-    orthographicCamera: import("@react-three/fiber").OrthographicCameraProps;
     airplane: import("./type").airplaneType;
     vehicle: import("./type").vehicleType;
     character: import("./type").characterType;

package/dist/gaesup/controller/context/type.d.ts

@@ -31,39 +31,6 @@ export interface vehicleType extends GroupProps, vehicleDebugType {
 }
 export interface characterType extends GroupProps, characterDebugType {
 }
-export type perspectiveCameraType = {
-    cameraType?: "perspective";
-    controlType?: "orbit" | "normal";
-};
-export type orthographicCameraType = {
-    cameraType?: "orthographic";
-    controlType?: "orbit";
-};
-export type gaesupCameraPropType = perspectiveCameraType | orthographicCameraType;
-export type gaesupCameraOptionDebugType = {
-    initDistance?: number;
-    maxDistance?: number;
-    minDistance?: number;
-    initDir?: number;
-    distance?: number;
-    camFollow?: number;
-};
-export type cameraOptionType = {
-    offset?: THREE.Vector3;
-    collisionOff?: number;
-} & gaesupCameraOptionDebugType;
-export type perspectiveCameraDebugType = {
-    XZDistance?: number;
-    YDistance?: number;
-};
-export type orthographicCameraDebugType = {
-    zoom?: number;
-    near?: number;
-    far?: number;
-};
-export type perspectiveCameraPropType = {
-    isFront?: boolean;
-} & perspectiveCameraDebugType;
 export type gaesupControllerType = gaesupControllerContextPropType & {
     callbacks?: callbackType;
     refs?: refsType;

package/dist/gaesup/controller/debug/index.js

@@ -10,42 +10,17 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { useContext, useEffect } from "react";
-import { buttonGroup, useControls } from "leva";
 import { update } from "../../utils/context";
 import debug from "../../utils/debug";
 import { GaesupWorldContext } from "../../world/context";
 import { airplaneDebugMap } from "./airplane";
-import { cameraOptionDebugMap } from "./cameraOption";
 import { characterDebugMap } from "./character";
-import { orthographicCameraDebugMap } from "./orthographicCamera";
-import { perspectiveCameraDebugMap } from "./perspectiveCamera";
 import { vehicleDebugMap } from "./vehicle";
 export default function initDebug(_a) {
     var controllerContext = _a.controllerContext, controllerDispatch = _a.controllerDispatch;
     var worldDebug = useContext(GaesupWorldContext).debug;
-    var cameraMode = controllerContext.cameraMode;
     if (!worldDebug)
         return;
-    var _b = useControls(function () { return ({
-        cameraType: cameraMode.cameraType,
-        "   ": buttonGroup({
-            perspective: function () { return setcameraType({ cameraType: "perspective" }); },
-            orthographic: function () { return setcameraType({ cameraType: "orthographic" }); },
-        }),
-    }); }), cameraType = _b[0], setcameraType = _b[1];
-    var _c = useControls(function () { return ({
-        controlType: cameraMode.controlType,
-        "    ": buttonGroup({
-            orbit: function () { return controlTypeSet({ controlType: "orbit" }); },
-            normal: function () { return controlTypeSet({ controlType: "normal" }); },
-        }),
-    }); }), controlType = _c[0], controlTypeSet = _c[1];
-    var cameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.cameraOption,
-        tag: "cameraOption",
-        debugMap: cameraOptionDebugMap,
-    });
     var characterOptionValue = debug({
         debug: worldDebug,
         debugProps: controllerContext.character,
@@ -64,39 +39,11 @@ export default function initDebug(_a) {
         tag: "airplane",
         debugMap: airplaneDebugMap,
     });
-    var orthographicCameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.orthographicCamera,
-        tag: "orthographicCamera",
-        debugMap: orthographicCameraDebugMap,
-    });
-    var perspectiveCameraOptionValue = debug({
-        debug: worldDebug,
-        debugProps: controllerContext.perspectiveCamera,
-        tag: "perspectiveCamera",
-        debugMap: perspectiveCameraDebugMap,
-    });
     useEffect(function () {
         update({
-            cameraOption: __assign({}, cameraOptionValue),
             character: __assign({}, characterOptionValue),
             vehicle: __assign({}, vehicleOptionValue),
             airplane: __assign({}, airplaneOptionValue),
-            perspectiveCamera: __assign(__assign({}, controllerContext.perspectiveCamera), perspectiveCameraOptionValue),
-            orthographicCamera: __assign(__assign({}, controllerContext.orthographicCamera), orthographicCameraOptionValue),
-            cameraMode: {
-                cameraType: cameraType.cameraType,
-                controlType: controlType.controlType,
-            },
         }, controllerDispatch);
-    }, [
-        cameraOptionValue,
-        characterOptionValue,
-        vehicleOptionValue,
-        airplaneOptionValue,
-        perspectiveCameraOptionValue,
-        orthographicCameraOptionValue,
-        cameraType,
-        controlType,
-    ]);
+    }, [characterOptionValue, vehicleOptionValue, airplaneOptionValue]);
 }

package/dist/gaesup/controller/index.js

@@ -26,10 +26,6 @@ export function GaesupController(props) {
     var characterInnerRef = useRef(null);
     var passiveRigidBodyRef = useRef(null);
     var _a = useReducer(gaesupControllerReducer, {
-        cameraMode: Object.assign(gaesupControllerDefault.cameraMode, props.cameraMode || {}),
-        cameraOption: Object.assign(gaesupControllerDefault.cameraOption, props.cameraOption || {}),
-        perspectiveCamera: Object.assign(gaesupControllerDefault.perspectiveCamera, props.perspectiveCamera || {}),
-        orthographicCamera: Object.assign(gaesupControllerDefault.orthographicCamera, props.orthographicCamera || {}),
         airplane: Object.assign(gaesupControllerDefault.airplane, props.airplane || {}),
         vehicle: Object.assign(gaesupControllerDefault.vehicle, props.vehicle || {}),
         character: Object.assign(gaesupControllerDefault.character, props.character || {}),
@@ -65,7 +61,6 @@ export function GaesupController(props) {
         };
     }, []);
     var prop = __assign(__assign(__assign(__assign({}, initControllerProps({
-        controllerContext: gaesupControl.value,
         refs: refs,
     })), { children: props.children, groupProps: props.groupProps }), gaesupControl.value.callbacks), refs);
     initDebug({

package/dist/gaesup/controller/initialize/index.d.ts

@@ -1,9 +1,7 @@
 import { groundRayType, refsType, slopeRayType } from "../../controller/type";
 import { cameraRayType } from "../../camera/type";
 import { keyControlType } from "../../world/context/type";
-import { gaesupControllerType } from "../context/type";
-export default function initControllerProps({ controllerContext, refs, }: {
-    controllerContext: gaesupControllerType;
+export default function initControllerProps({ refs }: {
     refs: refsType;
 }): {
     slopeRay: slopeRayType;

package/dist/gaesup/controller/initialize/index.js

@@ -16,7 +16,7 @@ import * as THREE from "three";
 import { update } from "../../utils/context";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
 export default function initControllerProps(_a) {
-    var controllerContext = _a.controllerContext, refs = _a.refs;
+    var refs = _a.refs;
     var context = useContext(GaesupWorldContext);
     var dispatch = useContext(GaesupWorldDispatchContext);
     var _b = useKeyboardControls(), _ = _b[0], getKeys = _b[1];
@@ -63,13 +63,13 @@ export default function initControllerProps(_a) {
             rayCast: new THREE.Raycaster(vec3(), vec3(), 0, -7),
             dir: vec3(),
             position: vec3(),
-            length: -controllerContext.cameraOption.maxDistance,
+            length: -context.cameraOption.maxDistance,
             detected: [],
             intersects: [],
             intersectObjectMap: {},
         };
     }, []);
-    cameraRay.rayCast = new THREE.Raycaster(cameraRay.origin, cameraRay.dir, 0, -controllerContext.cameraOption.maxDistance);
+    cameraRay.rayCast = new THREE.Raycaster(cameraRay.origin, cameraRay.dir, 0, -context.cameraOption.maxDistance);
     var initRefs = useCallback(function (refs) {
         update({
             refs: __assign({}, refs),

package/dist/gaesup/controller/type.d.ts

@@ -1,11 +1,11 @@
 import { Collider, Ray, RayColliderToi } from "@dimforge/rapier3d-compat";
-import { GroupProps, OrthographicCameraProps } from "@react-three/fiber";
+import { GroupProps } from "@react-three/fiber";
 import { RapierRigidBody, RigidBodyProps } from "@react-three/rapier";
 import { ReactNode, RefObject } from "react";
 import * as THREE from "three";
 import { cameraRayType } from "../camera/type";
 import { keyControlType } from "../world/context/type";
-import { airplaneType, cameraOptionType, characterType, gaesupCameraPropType, perspectiveCameraPropType, vehicleType } from "./context/type";
+import { airplaneType, characterType, vehicleType } from "./context/type";
 import { callbackType } from "./initialize/callback/type";
 export type optionsType = {
     debug: boolean;
@@ -73,10 +73,6 @@ export type refsType = {
     characterInnerRef: RefObject<THREE.Group>;
 };
 export type gaesupControllerContextPropType = {
-    cameraMode: gaesupCameraPropType;
-    cameraOption: cameraOptionType;
-    perspectiveCamera: perspectiveCameraPropType;
-    orthographicCamera: OrthographicCameraProps;
     airplane: airplaneType;
     vehicle: vehicleType;
     character: characterType;

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

@@ -1,7 +1,6 @@
 /// <reference types="react" />
-export declare function GaeSupProps({ text, position, jumpPoint, children, }: {
+export declare function GaeSupProps({ text, position, children, }: {
     text?: string;
     position?: [number, number, number];
-    jumpPoint?: boolean;
     children: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/gaesupProps/index.js

@@ -9,38 +9,17 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { jsx as _jsx } from "react/jsx-runtime";
 import { vec3 } from "@react-three/rapier";
 import { Suspense, useContext, useEffect, useRef } from "react";
 import * as THREE from "three";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../world/context/index.js";
 export function GaeSupProps(_a) {
-    var text = _a.text, position = _a.position, jumpPoint = _a.jumpPoint, children = _a.children;
+    var text = _a.text, position = _a.position, children = _a.children;
     var groupRef = useRef(null);
-    var _b = useContext(GaesupWorldContext), minimap = _b.minimap, points = _b.points;
+    var minimap = useContext(GaesupWorldContext).minimap;
     var dispatch = useContext(GaesupWorldDispatchContext);
     useEffect(function () {
-        if (jumpPoint && position) {
-            points.push({
-                text: text || null,
-                position: vec3().set(position[0], 5, position[2]),
-            });
-            dispatch({
-                type: "update",
-                payload: {
-                    points: __spreadArray([], points, true),
-                },
-            });
-        }
         if (groupRef.current) {
             var box = new THREE.Box3().setFromObject(groupRef.current);
             var size = vec3(box.getSize(new THREE.Vector3())).clone();

package/dist/gaesup/physics/airplane/direction.js

@@ -1,7 +1,7 @@
 import { quat } from "@react-three/rapier";
 import { V3 } from "../../utils/vector";
 export default function direction(prop) {
-    var state = prop.state, innerGroupRef = prop.innerGroupRef, _a = prop.worldContext, joystick = _a.joystick, activeState = _a.activeState, control = _a.control, mode = _a.mode, airplane = prop.controllerContext.airplane;
+    var state = prop.state, innerGroupRef = prop.innerGroupRef, _a = prop.worldContext, joystick = _a.joystick, activeState = _a.activeState, control = _a.control, mode = _a.mode, airplane = prop.controllerContext.airplane, delta = prop.delta;
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward, shift = control.shift, space = control.space;
     var angleDelta = airplane.angleDelta, maxAngle = airplane.maxAngle, accelRatio = airplane.accelRatio;
     var boost = 0;
@@ -23,16 +23,12 @@ export default function direction(prop) {
     var _euler = activeState.euler.clone();
     var __euler = activeState.euler.clone();
     if (mode.controller === "joystick") {
-        __euler.y =
-            -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
+        __euler.y = -Math.PI / 2 + joystick.joyStickOrigin.angle;
+        activeState.euler.setFromQuaternion(quat().setFromEuler(_euler).slerp(quat().setFromEuler(__euler), 1));
     }
     else {
         activeState.euler.y += -leftRight * angleDelta.y;
     }
-    if (mode.controller === "joystick")
-        activeState.euler.setFromQuaternion(quat()
-            .setFromEuler(_euler)
-            .slerp(quat().setFromEuler(__euler), joystick.joyStickOrigin.isIn ? 0.01 : 0.1));
     var X = maxAngle.x * upDown;
     var Z = maxAngle.z * leftRight;
     var _x = innerGroupRef.current.rotation.x;
@@ -40,23 +36,29 @@ export default function direction(prop) {
     var maxX = maxAngle.x;
     var maxZ = maxAngle.z;
     var innerGrounRefRotation = innerGroupRef.current.clone();
-    if (_x < -maxX)
+    if (_x < -maxX) {
         innerGrounRefRotation.rotation.x = -maxX + X;
-    else if (_x > maxX)
+    }
+    else if (_x > maxX) {
         innerGrounRefRotation.rotation.x = maxX + X;
-    else
+    }
+    else {
         innerGrounRefRotation.rotateX(X);
+    }
     if (_z < -maxZ)
         innerGrounRefRotation.rotation.z = -maxZ + Z;
     else if (_z > maxZ)
         innerGrounRefRotation.rotation.z = maxZ + Z;
     else
         innerGrounRefRotation.rotateZ(Z);
+    activeState.euler.x = innerGrounRefRotation.rotation.x;
+    activeState.euler.z = innerGrounRefRotation.rotation.z;
+    innerGrounRefRotation.rotation.y = 0;
     innerGroupRef.current.setRotationFromQuaternion(quat()
         .setFromEuler(innerGroupRef.current.rotation.clone())
-        .slerp(quat().setFromEuler(innerGrounRefRotation.rotation), 0.1));
+        .slerp(quat().setFromEuler(innerGrounRefRotation.rotation.clone()), 0.2));
     activeState.rotation = innerGrounRefRotation.rotation;
     activeState.direction = front.multiply(V3(Math.sin(activeState.euler.y), -upDown, Math.cos(activeState.euler.y)));
     activeState.dir = activeState.direction.normalize();
-    activeState.euler = innerGroupRef.current.rotation;
+    // activeState.euler = innerGroupRef.current.rotation;
 }

package/dist/gaesup/physics/airplane/index.js

@@ -1,14 +1,12 @@
-import currentSetting from "./currentSetting";
 import damping from "./damping";
 import direction from "./direction";
 import gravity from "./gravity";
 import impulse from "./impulse";
-import turn from "./turn";
+import innerCalc from "./innerCalc";
 export default function airplaneCalculation(calcProp) {
     direction(calcProp);
-    turn(calcProp);
     impulse(calcProp);
     damping(calcProp);
     gravity(calcProp);
-    currentSetting(calcProp);
+    innerCalc(calcProp);
 }

package/dist/gaesup/physics/airplane/innerCalc.d.ts

@@ -0,0 +1,2 @@
+import { calcPropType } from "../type";
+export default function innerCalc(prop: calcPropType): void;

package/dist/gaesup/physics/{vehicle/currentSetting.js → airplane/innerCalc.js}

@@ -9,11 +9,15 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { vec3 } from "@react-three/rapier";
-export default function currentSetting(prop) {
+import { quat, vec3 } from "@react-three/rapier";
+export default function innerCalc(prop) {
     var rigidBodyRef = prop.rigidBodyRef, activeState = prop.worldContext.activeState, dispatch = prop.dispatch;
     activeState.position = vec3(rigidBodyRef.current.translation());
     activeState.velocity = vec3(rigidBodyRef.current.linvel());
+    var _euler = activeState.euler.clone();
+    _euler.x = 0;
+    _euler.z = 0;
+    rigidBodyRef.current.setRotation(quat().setFromEuler(_euler), true);
     dispatch({
         type: "update",
         payload: {

package/dist/gaesup/physics/character/direction.js

@@ -4,16 +4,16 @@ export function orbitDirection(_a) {
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward;
     var dirX = Number(leftward) - Number(rightward);
     var dirZ = Number(forward) - Number(backward);
-    if (dirX === 0 && dirZ === 0)
-        return;
     var start = 0;
     if (mode.controller === "joystick") {
-        if (!joystick.joyStickOrigin.isCenter)
-            activeState.euler.y =
-                -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
-        start = joystick.joyStickOrigin.isOn ? 1 : 0;
+        if (joystick.joyStickOrigin.isCenter)
+            return;
+        activeState.euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
+        start = 1;
     }
     else {
+        if (dirX === 0 && dirZ === 0)
+            return;
         activeState.euler.y += (dirX * Math.PI) / 32;
         start = dirZ;
     }
@@ -26,10 +26,10 @@ export function normalDirection(_a) {
     var forward = control.forward, backward = control.backward, leftward = control.leftward, rightward = control.rightward;
     var start = 0;
     if (mode.controller === "joystick") {
-        if (!joystick.joyStickOrigin.isCenter)
-            activeState.euler.y =
-                -state.camera.rotation.y - joystick.joyStickOrigin.angle - Math.PI / 2;
-        start = joystick.joyStickOrigin.isOn ? 1 : 0;
+        if (joystick.joyStickOrigin.isCenter)
+            return;
+        activeState.euler.y = Math.PI / 2 - joystick.joyStickOrigin.angle;
+        start = 1;
     }
     else {
         // 일반 컨트롤
@@ -45,11 +45,11 @@ export function normalDirection(_a) {
     }
 }
 export default function direction(prop) {
-    var state = prop.state, _a = prop.worldContext, joystick = _a.joystick, mode = _a.mode, activeState = _a.activeState, control = _a.control, cameraMode = prop.controllerContext.cameraMode;
-    if (cameraMode.controlType === "normal") {
+    var state = prop.state, _a = prop.worldContext, joystick = _a.joystick, mode = _a.mode, activeState = _a.activeState, control = _a.control;
+    if (mode.control === "normal") {
         normalDirection({ activeState: activeState, control: control, mode: mode, joystick: joystick, state: state });
     }
-    else if (cameraMode.controlType === "orbit") {
+    else if (mode.control === "orbit") {
         orbitDirection({ activeState: activeState, control: control, mode: mode, joystick: joystick, state: state });
     }
 }