gaesup-world 0.0.64 → 0.0.66

package/dist/gaesup/animation/actions.js

@@ -1,66 +1,79 @@
+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 default function playActions({ outerGroupRef, groundRay, isRider, }) {
-    const { characterGltf, animations: characterAnimations } = useContext(GaesupWorldContext);
-    const dispatch = useContext(GaesupWorldDispatchContext);
-    const { animations } = characterGltf;
-    const control = useKeyboardControls()[1]();
-    const { actions } = useAnimations(animations, outerGroupRef);
-    useEffect(() => {
+export default function playActions(_a) {
+    var outerGroupRef = _a.outerGroupRef, groundRay = _a.groundRay, isRider = _a.isRider;
+    var _b = useContext(GaesupWorldContext), characterGltf = _b.characterGltf, characterAnimations = _b.animations;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var animations = characterGltf.animations;
+    var control = useKeyboardControls()[1]();
+    var actions = useAnimations(animations, outerGroupRef).actions;
+    useEffect(function () {
         characterAnimations.keyControl = control;
         dispatch({
             type: "update",
             payload: {
-                animations: Object.assign({}, characterAnimations),
+                animations: __assign({}, characterAnimations),
             },
         });
     }, [control]);
-    const playAnimation = (tag) => {
+    var playAnimation = function (tag) {
         characterAnimations.current = tag;
         dispatch({
             type: "update",
             payload: {
-                animations: Object.assign({}, characterAnimations),
+                animations: __assign({}, characterAnimations),
             },
         });
     };
-    const setAnimationName = (actions) => {
-        characterAnimations.animationNames = Object.assign(characterAnimations.animationNames, Object.keys(actions).reduce((acc, cur) => {
-            return Object.assign(Object.assign({}, acc), { [cur]: cur });
+    var setAnimationName = function (actions) {
+        characterAnimations.animationNames = Object.assign(characterAnimations.animationNames, Object.keys(actions).reduce(function (acc, cur) {
+            var _a;
+            return __assign(__assign({}, acc), (_a = {}, _a[cur] = cur, _a));
         }, {}));
         dispatch({
             type: "update",
             payload: {
-                animations: Object.assign({}, characterAnimations),
+                animations: __assign({}, characterAnimations),
             },
         });
     };
-    const resetAni = () => playAnimation("idle");
-    const playIdle = () => playAnimation("idle");
-    const playWalk = () => playAnimation("walk");
-    const playRun = () => playAnimation("run");
-    const playJump = () => playAnimation("jump");
-    const playFall = () => playAnimation("fall");
-    const playRide = () => playAnimation("ride");
-    useEffect(() => {
-        return () => {
+    var resetAni = function () { return playAnimation("idle"); };
+    var playIdle = function () { return playAnimation("idle"); };
+    var playWalk = function () { return playAnimation("walk"); };
+    var playRun = function () { return playAnimation("run"); };
+    var playJump = function () { return playAnimation("jump"); };
+    var playFall = function () { return playAnimation("fall"); };
+    var playRide = function () { return playAnimation("ride"); };
+    useEffect(function () {
+        return function () {
             resetAni();
         };
     }, []);
-    useEffect(() => {
+    useEffect(function () {
         var _a;
         // Play animation
-        const action = (_a = actions[characterAnimations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+        var action = (_a = actions[characterAnimations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
         setAnimationName(actions);
-        return () => {
+        return function () {
             action === null || action === void 0 ? void 0 : action.fadeOut(0.2);
         };
     }, [characterAnimations.current]);
-    const { states, activeState } = useContext(GaesupWorldContext);
-    const { isNotMoving, isMoving, isJumping, isRunning, isAnimationOuter } = states;
-    useFrame(() => {
+    var _c = useContext(GaesupWorldContext), states = _c.states, activeState = _c.activeState;
+    var isNotMoving = states.isNotMoving, isMoving = states.isMoving, isJumping = states.isJumping, isRunning = states.isRunning, isAnimationOuter = states.isAnimationOuter;
+    useFrame(function () {
         if (isRider) {
             playRide();
         }

package/dist/gaesup/camera/cameraCollisionDetecter.js

@@ -1,7 +1,7 @@
 export default function cameraCollisionDetector(prop) {
     //   const { cameraRay, constant, options } = prop;
     //   const { camera } = useThree();
-    const checkCollision = (delta) => {
+    var checkCollision = function (delta) {
         //     cameraRay.origin.copy(cameraRay.pivot.position);
         //     camera.getWorldPosition(cameraRay.position);
         //     cameraRay.dir.subVectors(cameraRay.position, cameraRay.pivot.position);
@@ -46,5 +46,5 @@ export default function cameraCollisionDetector(prop) {
         //
         //     cameraRay.followCamera.position.lerp(cameraRay.lerpingPoint, delta * 4);
     };
-    return { checkCollision };
+    return { checkCollision: checkCollision };
 }

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

@@ -1,5 +1,5 @@
 export default function mapControl(prop) {
-    const { state, worldContext: { activeState }, } = prop;
-    const position = activeState.position.clone();
+    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

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

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

@@ -1,8 +1,8 @@
 import { quat } from "@react-three/rapier";
 import { V3 } from "../../utils/vector";
 export default function orbit(prop) {
-    const { state, controllerContext: { perspectiveCamera }, worldContext: { activeState }, } = prop;
-    const cameraPosition = activeState.position.clone().add(V3(Math.sin(activeState.euler.y), 0, Math.cos(activeState.euler.y))
+    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)

package/dist/gaesup/camera/index.js

@@ -1,3 +1,14 @@
+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";
@@ -9,32 +20,30 @@ import cameraCollisionDetector from "./cameraCollisionDetecter";
 import mapControl from "./control/map";
 import normal from "./control/normal";
 import orbit from "./control/orbit";
-export default function Camera({ refs, prop, control, }) {
-    const worldContext = useContext(GaesupWorldContext);
-    const controllerContext = useContext(GaesupControllerContext);
-    const { cameraMode, perspectiveCamera, orthographicCamera } = controllerContext;
-    const { rigidBodyRef, outerGroupRef } = refs;
-    const { cameraRay } = prop;
-    const { checkCollision } = cameraCollisionDetector(prop);
-    const { scene } = useThree();
-    const { activeState } = worldContext;
-    const intersectObjectMap = {};
-    const cameraProp = Object.assign(Object.assign({}, prop), { checkCollision,
-        control,
-        controllerContext,
-        worldContext });
-    const getMeshs = (object) => {
+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((child) => {
+        object.children.forEach(function (child) {
             getMeshs(child);
         });
     };
-    useFrame((state, delta) => {
+    useFrame(function (state, delta) {
         if (!rigidBodyRef ||
             !rigidBodyRef.current ||
             !outerGroupRef ||
@@ -43,7 +52,7 @@ export default function Camera({ refs, prop, control, }) {
         cameraProp.state = state;
         cameraProp.delta = delta;
         if (cameraMode.cameraType === "perspective") {
-            scene.children.forEach((child) => getMeshs(child));
+            scene.children.forEach(function (child) { return getMeshs(child); });
             cameraRay.intersectObjectMap = intersectObjectMap;
             if (cameraMode.controlType === "orbit") {
                 orbit(cameraProp);
@@ -56,5 +65,5 @@ export default function Camera({ refs, prop, control, }) {
             mapControl(cameraProp);
         }
     });
-    return (_jsxs(_Fragment, { children: [cameraMode.cameraType === "perspective" && (_jsxs(_Fragment, { children: [_jsx(OrbitControls, { target: activeState.position }), _jsx(PerspectiveCamera, Object.assign({ makeDefault: true }, perspectiveCamera))] })), cameraMode.cameraType === "orthographic" && (_jsxs(_Fragment, { children: [_jsx(MapControls, { target: activeState.position }), _jsx(OrthographicCamera, Object.assign({ makeDefault: true }, orthographicCamera))] }))] }));
+    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/Airplane.js

@@ -5,8 +5,9 @@ import { AirplaneInnerGroupRef } from "./gltf/AirplaneGltf";
 import { CharacterInnerGroupRef } from "./gltf/CharacterGltf";
 import { AirplaneCollider, AirplaneGroup, AirplaneRigidBody, } from "./ref/airplane";
 import setInit from "./setInit";
-export function Airplane({ controllerProps, refs, }) {
-    const { rigidBodyRef, outerGroupRef, capsuleColliderRef, innerGroupRef, characterInnerRef, } = refs;
+export function Airplane(_a) {
+    var controllerProps = _a.controllerProps, refs = _a.refs;
+    var rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef, capsuleColliderRef = refs.capsuleColliderRef, innerGroupRef = refs.innerGroupRef, characterInnerRef = refs.characterInnerRef;
     calculation(controllerProps);
     setInit(rigidBodyRef);
     return (_jsx(_Fragment, { children: _jsx(AirplaneGroup, { ref: outerGroupRef, controllerProps: controllerProps, children: _jsxs(AirplaneRigidBody, { ref: rigidBodyRef, controllerProps: controllerProps, children: [_jsx(AirplaneCollider, { prop: controllerProps, ref: capsuleColliderRef }), controllerProps.isRider && (_jsx(CharacterInnerGroupRef, { prop: controllerProps, groupProps: controllerProps.groupProps, groundRay: controllerProps.groundRay, refs: refs, callbacks: controllerProps.callbacks, isRider: controllerProps.isRider, ref: characterInnerRef })), _jsx(AirplaneInnerGroupRef, { ref: innerGroupRef })] }) }) }));

package/dist/gaesup/component/Character.js

@@ -4,8 +4,9 @@ import calculation from "../physics";
 import { CharacterInnerGroupRef, InnerGroupRef } from "./gltf/CharacterGltf";
 import { CharacterCapsuleCollider, CharacterGroup, CharacterRigidBody, CharacterSlopeRay, } from "./ref/character";
 import setInit from "./setInit";
-export function Character({ controllerProps, refs, }) {
-    const { capsuleColliderRef, rigidBodyRef, outerGroupRef, slopeRayOriginRef, characterInnerRef, innerGroupRef, } = refs;
+export function Character(_a) {
+    var controllerProps = _a.controllerProps, refs = _a.refs;
+    var capsuleColliderRef = refs.capsuleColliderRef, rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef, slopeRayOriginRef = refs.slopeRayOriginRef, characterInnerRef = refs.characterInnerRef, innerGroupRef = refs.innerGroupRef;
     calculation(controllerProps);
     setInit(rigidBodyRef);
     return (_jsxs(CharacterRigidBody, { ref: rigidBodyRef, controllerProps: controllerProps, children: [_jsx(CharacterCapsuleCollider, { prop: controllerProps, ref: capsuleColliderRef }), _jsxs(CharacterGroup, { ref: outerGroupRef, controllerProps: controllerProps, children: [_jsx(CharacterSlopeRay, { slopeRay: controllerProps.slopeRay, groundRay: controllerProps.groundRay, ref: slopeRayOriginRef }), controllerProps.children, _jsx(InnerGroupRef, { ref: innerGroupRef }), _jsx(CharacterInnerGroupRef, { prop: controllerProps, groupProps: controllerProps.groupProps, groundRay: controllerProps.groundRay, refs: refs, callbacks: controllerProps.callbacks, ref: characterInnerRef, isRider: false })] })] }));

package/dist/gaesup/component/Vehicle.js

@@ -6,8 +6,9 @@ import { VehicleInnerGroupRef } from "./gltf/VehicleGltf";
 import { Wheels } from "./gltf/WheelJoint";
 import { VehicleCollider, VehicleGroup, VehicleRigidBody } from "./ref/vehicle";
 import setInit from "./setInit";
-export function Vehicle({ controllerProps, refs, }) {
-    const { rigidBodyRef, outerGroupRef, characterInnerRef, innerGroupRef } = refs;
+export function Vehicle(_a) {
+    var controllerProps = _a.controllerProps, refs = _a.refs;
+    var rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef, characterInnerRef = refs.characterInnerRef, innerGroupRef = refs.innerGroupRef;
     calculation(controllerProps);
     setInit(rigidBodyRef);
     return (_jsxs(VehicleGroup, { ref: outerGroupRef, controllerProps: controllerProps, children: [_jsxs(VehicleRigidBody, { ref: rigidBodyRef, controllerProps: controllerProps, children: [_jsx(VehicleCollider, {}), controllerProps.isRider && (_jsx(CharacterInnerGroupRef, { prop: controllerProps, groupProps: controllerProps.groupProps, groundRay: controllerProps.groundRay, refs: refs, callbacks: controllerProps.callbacks, ref: characterInnerRef, isRider: true })), _jsx(VehicleInnerGroupRef, { ref: innerGroupRef })] }), _jsx(Wheels, { prop: controllerProps })] }));

package/dist/gaesup/component/gltf/AirplaneGltf.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { forwardRef, useContext } from "react";
 import { GaesupWorldContext } from "../../world/context";
-export const AirplaneInnerGroupRef = forwardRef((_, ref) => {
-    const { airplaneGltf: gltf } = useContext(GaesupWorldContext);
-    const { materials, nodes } = gltf;
-    return (_jsx(_Fragment, { children: nodes && materials && (_jsx("group", { receiveShadow: true, castShadow: true, ref: ref, children: Object.keys(nodes).map((name, key) => {
+export var AirplaneInnerGroupRef = forwardRef(function (_, ref) {
+    var gltf = useContext(GaesupWorldContext).airplaneGltf;
+    var materials = gltf.materials, nodes = gltf.nodes;
+    return (_jsx(_Fragment, { children: nodes && materials && (_jsx("group", { receiveShadow: true, castShadow: true, ref: ref, children: Object.keys(nodes).map(function (name, key) {
                 if (nodes[name].type === "Mesh" ||
                     nodes[name].type === "SkinnedMesh") {
                     return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: materials[name], geometry: nodes[name].geometry }, key));

package/dist/gaesup/component/gltf/CharacterGltf.js

@@ -1,32 +1,44 @@
+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, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { forwardRef, useContext } from "react";
 import playActions from "../../animation/actions";
 import initCallback from "../../initial/callback";
 import { GaesupWorldContext } from "../../world/context";
-export const InnerGroupRef = forwardRef((_, ref) => {
+export var InnerGroupRef = forwardRef(function (_, ref) {
     return _jsx("group", { ref: ref, visible: false });
 });
-export const CharacterInnerGroupRef = forwardRef(({ prop, groupProps, groundRay, refs, callbacks, isRider, }, ref) => {
-    const { characterGltf: gltf } = useContext(GaesupWorldContext);
-    const { materials, nodes } = gltf;
-    const { characterCollider, vehicleCollider } = useContext(GaesupWorldContext);
+export var CharacterInnerGroupRef = forwardRef(function (_a, ref) {
+    var prop = _a.prop, groupProps = _a.groupProps, groundRay = _a.groundRay, refs = _a.refs, callbacks = _a.callbacks, isRider = _a.isRider;
+    var gltf = useContext(GaesupWorldContext).characterGltf;
+    var materials = gltf.materials, nodes = gltf.nodes;
+    var _b = useContext(GaesupWorldContext), characterCollider = _b.characterCollider, vehicleCollider = _b.vehicleCollider;
     initCallback({
-        prop,
-        callbacks,
+        prop: prop,
+        callbacks: callbacks,
         outerGroupRef: refs.outerGroupRef,
     });
     playActions({
         outerGroupRef: refs.outerGroupRef,
         groundRay: groundRay,
-        isRider,
+        isRider: isRider,
     });
-    return (_jsx(_Fragment, { children: nodes && materials && (_jsxs("group", Object.assign({ receiveShadow: true, castShadow: true }, groupProps, { position: [
+    return (_jsx(_Fragment, { children: nodes && materials && (_jsxs("group", __assign({ receiveShadow: true, castShadow: true }, groupProps, { position: [
                 0,
                 isRider
                     ? vehicleCollider.vehicleSizeY / 2
                     : -characterCollider.height,
                 0,
-            ], ref: ref, children: [Object.values(nodes).find((node) => node.type === "Object3D") && (_jsx("primitive", { object: Object.values(nodes).find((node) => node.type === "Object3D"), visible: false, receiveShadow: true, castShadow: true })), Object.keys(nodes).map((name, key) => {
+            ], ref: ref, children: [Object.values(nodes).find(function (node) { return node.type === "Object3D"; }) && (_jsx("primitive", { object: Object.values(nodes).find(function (node) { return node.type === "Object3D"; }), visible: false, receiveShadow: true, castShadow: true })), Object.keys(nodes).map(function (name, key) {
                     if (nodes[name].type === "SkinnedMesh") {
                         return (_jsx("skinnedMesh", { castShadow: true, receiveShadow: true, material: materials[name], geometry: nodes[name].geometry, skeleton: nodes[name].skeleton }, key));
                     }

package/dist/gaesup/component/gltf/VehicleGltf.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { forwardRef, useContext } from "react";
 import { GaesupWorldContext } from "../../world/context";
-export const VehicleInnerGroupRef = forwardRef((_, ref) => {
-    const { vehicleGltf: gltf } = useContext(GaesupWorldContext);
-    const { materials, nodes } = gltf;
-    return (_jsx(_Fragment, { children: nodes && materials && (_jsx("group", { receiveShadow: true, castShadow: true, rotation: [0, Math.PI, 0], ref: ref, children: Object.keys(nodes).map((name, key) => {
+export var VehicleInnerGroupRef = forwardRef(function (_, ref) {
+    var gltf = useContext(GaesupWorldContext).vehicleGltf;
+    var materials = gltf.materials, nodes = gltf.nodes;
+    return (_jsx(_Fragment, { children: nodes && materials && (_jsx("group", { receiveShadow: true, castShadow: true, rotation: [0, Math.PI, 0], ref: ref, children: Object.keys(nodes).map(function (name, key) {
                 if (nodes[name].type === "Mesh" ||
                     nodes[name].type === "SkinnedMesh") {
                     return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: materials[name], geometry: nodes[name].geometry }, key));

package/dist/gaesup/component/gltf/WheelJoint.js

@@ -2,19 +2,20 @@ import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { createRef, useContext, useRef } from "react";
 import { GaesupWorldContext } from "../../world/context";
 import { WheelRegidBodyRef } from "../ref/vehicle";
-export function Wheels({ prop }) {
-    const { rigidBodyRef, constant } = prop;
-    const { wheelOffset } = constant;
-    const { vehicleCollider: collider } = useContext(GaesupWorldContext);
-    const { vehicleSizeX, vehicleSizeZ, wheelSizeX, wheelSizeZ } = collider;
-    const X = (vehicleSizeX + wheelSizeX) / 2 + wheelOffset;
-    const Z = (vehicleSizeZ + wheelSizeZ) / 2 + wheelOffset;
-    const wheelPositions = [
+export function Wheels(_a) {
+    var prop = _a.prop;
+    var rigidBodyRef = prop.rigidBodyRef, constant = prop.constant;
+    var wheelOffset = constant.wheelOffset;
+    var collider = useContext(GaesupWorldContext).vehicleCollider;
+    var vehicleSizeX = collider.vehicleSizeX, vehicleSizeZ = collider.vehicleSizeZ, wheelSizeX = collider.wheelSizeX, wheelSizeZ = collider.wheelSizeZ;
+    var X = (vehicleSizeX + wheelSizeX) / 2 + wheelOffset;
+    var Z = (vehicleSizeZ + wheelSizeZ) / 2 + wheelOffset;
+    var wheelPositions = [
         [-X, 0, Z],
         [-X, 0, -Z],
         [X, 0, Z],
         [X, 0, -Z],
     ];
-    const wheelRefs = useRef(wheelPositions.map(() => createRef()));
-    return (_jsx(_Fragment, { children: wheelPositions.map((wheelPosition, index) => (_jsx(WheelRegidBodyRef, { ref: wheelRefs.current[index], wheelPosition: wheelPosition, bodyRef: rigidBodyRef, wheel: wheelRefs.current[index], bodyAnchor: wheelPosition, wheelAnchor: [0, 0, 0], rotationAxis: [1, 0, 0] }, index))) }));
+    var wheelRefs = useRef(wheelPositions.map(function () { return createRef(); }));
+    return (_jsx(_Fragment, { children: wheelPositions.map(function (wheelPosition, index) { return (_jsx(WheelRegidBodyRef, { ref: wheelRefs.current[index], wheelPosition: wheelPosition, bodyRef: rigidBodyRef, wheel: wheelRefs.current[index], bodyAnchor: wheelPosition, wheelAnchor: [0, 0, 0], rotationAxis: [1, 0, 0] }, index)); }) }));
 }

package/dist/gaesup/component/ref/airplane.js

@@ -1,32 +1,46 @@
+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, jsxs as _jsxs } from "react/jsx-runtime";
 import { CuboidCollider, RigidBody, useRapier, } from "@react-three/rapier";
 import { forwardRef, useContext } from "react";
 import { getRayHit } from "../../utils/ray";
 import { useForwardRef } from "../../utils/ref";
 import { GaesupWorldContext } from "../../world/context";
-export const AirplaneRigidBody = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsxs(RigidBody, Object.assign({ colliders: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
+export var AirplaneRigidBody = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsxs(RigidBody, __assign({ colliders: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
                         controllerProps.groundRay.dir,
                         controllerProps.groundRay.origin,
                         controllerProps.groundRay.length,
                     ] }) })), children] })));
 });
-export const AirplaneCollider = forwardRef(({ prop }, ref) => {
-    var _a;
-    const { airplaneCollider: collider } = useContext(GaesupWorldContext);
-    const { airplaneSizeX, airplaneSizeY, airplaneSizeZ } = collider;
-    const colliderRef = useForwardRef(ref);
-    const { rapier } = useRapier();
-    const { groundRay } = prop;
+export var AirplaneCollider = forwardRef(function (_a, ref) {
+    var _b;
+    var prop = _a.prop;
+    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 = prop.groundRay;
     groundRay.length = airplaneSizeY * 5 + 2;
     groundRay.rayCast = new rapier.Ray(groundRay.origin, groundRay.dir);
     groundRay.hit = getRayHit({
         ray: groundRay,
         ref: colliderRef,
     });
-    groundRay.parent = (_a = groundRay.hit) === null || _a === void 0 ? void 0 : _a.collider.parent();
+    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] }));
 });
-export const AirplaneGroup = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsx("group", Object.assign({ ref: ref, userData: { intangible: true } }, controllerProps.airplane, { children: children })));
+export var AirplaneGroup = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, controllerProps.airplane, { children: children })));
 });

package/dist/gaesup/component/ref/character.js

@@ -1,38 +1,53 @@
+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, jsxs as _jsxs } from "react/jsx-runtime";
 import { CapsuleCollider, RigidBody, useRapier, } from "@react-three/rapier";
 import { forwardRef, useContext } from "react";
 import { getRayHit } from "../../utils/ray";
 import { useForwardRef } from "../../utils/ref";
 import { GaesupWorldContext } from "../../world/context";
-export const CharacterRigidBody = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsxs(RigidBody, Object.assign({ colliders: false, canSleep: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
+export var CharacterRigidBody = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsxs(RigidBody, __assign({ colliders: false, canSleep: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
                         controllerProps.groundRay.dir,
                         controllerProps.groundRay.origin,
                         controllerProps.groundRay.length,
                     ] }) })), children] })));
 });
-export const CharacterCapsuleCollider = forwardRef(({ prop }, ref) => {
-    var _a;
-    const { characterCollider: collider } = useContext(GaesupWorldContext);
-    const colliderRef = useForwardRef(ref);
-    const { rapier } = useRapier();
-    const { groundRay, slopeRay } = prop;
+export var CharacterCapsuleCollider = forwardRef(function (_a, ref) {
+    var _b;
+    var prop = _a.prop;
+    var collider = useContext(GaesupWorldContext).characterCollider;
+    var colliderRef = useForwardRef(ref);
+    var rapier = useRapier().rapier;
+    var groundRay = prop.groundRay, slopeRay = prop.slopeRay;
     groundRay.length = collider.radius + 2;
     groundRay.rayCast = new rapier.Ray(groundRay.origin, groundRay.dir);
     groundRay.hit = getRayHit({
         ray: groundRay,
         ref: colliderRef,
     });
-    groundRay.parent = (_a = groundRay.hit) === null || _a === void 0 ? void 0 : _a.collider.parent();
+    groundRay.parent = (_b = groundRay.hit) === null || _b === void 0 ? void 0 : _b.collider.parent();
     slopeRay.rayCast = new rapier.Ray(slopeRay.origin, slopeRay.dir);
     slopeRay.length = collider.radius + 3;
     slopeRay.rayCast = new rapier.Ray(slopeRay.origin, slopeRay.dir);
     return (_jsx(CapsuleCollider, { ref: ref, args: [collider.height, collider.radius] }));
 });
-export const CharacterGroup = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsx("group", Object.assign({ ref: ref, userData: { intangible: true } }, controllerProps.character, { children: children })));
+export var CharacterGroup = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, controllerProps.character, { children: children })));
 });
-export const CharacterSlopeRay = forwardRef(({ groundRay, slopeRay, }, ref) => {
+export var CharacterSlopeRay = forwardRef(function (_a, ref) {
+    var groundRay = _a.groundRay, slopeRay = _a.slopeRay;
     return (_jsx("mesh", { position: [
             groundRay.offset.x,
             groundRay.offset.y,

package/dist/gaesup/component/ref/vehicle.js

@@ -1,27 +1,41 @@
+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, jsxs as _jsxs } from "react/jsx-runtime";
 import { Gltf } from "@react-three/drei";
 import { CuboidCollider, CylinderCollider, RigidBody, useRevoluteJoint, } from "@react-three/rapier";
 import { forwardRef, useContext } from "react";
 import { S3 } from "../../utils/constant";
 import { GaesupWorldContext } from "../../world/context";
-export const VehicleRigidBody = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsxs(RigidBody, Object.assign({ colliders: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
+export var VehicleRigidBody = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsxs(RigidBody, __assign({ colliders: false, ref: ref }, controllerProps.rigidBodyProps, { children: [controllerProps.debug && (_jsx("mesh", { visible: controllerProps.debug, children: _jsx("arrowHelper", { args: [
                         controllerProps.groundRay.dir,
                         controllerProps.groundRay.origin,
                         controllerProps.groundRay.length,
                     ] }) })), children] })));
 });
-export const VehicleCollider = forwardRef((_, ref) => {
-    const { vehicleCollider: collider } = useContext(GaesupWorldContext);
-    const { vehicleSizeX, vehicleSizeY, vehicleSizeZ } = collider;
+export var VehicleCollider = forwardRef(function (_, ref) {
+    var collider = useContext(GaesupWorldContext).vehicleCollider;
+    var vehicleSizeX = collider.vehicleSizeX, vehicleSizeY = collider.vehicleSizeY, vehicleSizeZ = collider.vehicleSizeZ;
     return (_jsx(CuboidCollider, { ref: ref, args: [vehicleSizeX / 2, vehicleSizeY / 2, vehicleSizeZ / 2], position: [0, vehicleSizeY / 2, 0] }));
 });
-export const VehicleGroup = forwardRef(({ controllerProps, children, }, ref) => {
-    return (_jsx("group", Object.assign({ ref: ref, userData: { intangible: true } }, controllerProps.vehicle, { children: children })));
+export var VehicleGroup = forwardRef(function (_a, ref) {
+    var controllerProps = _a.controllerProps, children = _a.children;
+    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, controllerProps.vehicle, { children: children })));
 });
-export const WheelRegidBodyRef = forwardRef(({ wheelPosition, wheelsUrl, bodyRef, wheel, bodyAnchor, wheelAnchor, rotationAxis, }, ref) => {
-    const { vehicleCollider: collider } = useContext(GaesupWorldContext);
-    const { wheelSizeX, wheelSizeY } = collider;
+export var WheelRegidBodyRef = forwardRef(function (_a, ref) {
+    var wheelPosition = _a.wheelPosition, wheelsUrl = _a.wheelsUrl, bodyRef = _a.bodyRef, wheel = _a.wheel, bodyAnchor = _a.bodyAnchor, wheelAnchor = _a.wheelAnchor, rotationAxis = _a.rotationAxis;
+    var collider = useContext(GaesupWorldContext).vehicleCollider;
+    var wheelSizeX = collider.wheelSizeX, wheelSizeY = collider.wheelSizeY;
     useRevoluteJoint(bodyRef, wheel, [bodyAnchor, wheelAnchor, rotationAxis]);
     return (_jsxs(RigidBody, { position: wheelPosition, colliders: false, ref: ref, children: [_jsx(CylinderCollider, { args: [wheelSizeX / 2, wheelSizeY / 2], rotation: [0, 0, Math.PI / 2] }), _jsx(Gltf, { src: wheelsUrl || S3 + "/wheel.glb" })] }));
 });

package/dist/gaesup/component/setInit.js

@@ -2,8 +2,8 @@ import { useContext, useEffect } from "react";
 import { V3 } from "../utils/vector";
 import { GaesupWorldContext } from "../world/context";
 export default function setInit(rigidBodyRef) {
-    const { activeState } = useContext(GaesupWorldContext);
-    useEffect(() => {
+    var activeState = useContext(GaesupWorldContext).activeState;
+    useEffect(function () {
         var _a;
         (_a = rigidBodyRef.current) === null || _a === void 0 ? void 0 : _a.setTranslation(activeState.position.add(V3(0, 1, 0)), false);
     }, []);