gaesup-world 0.1.4 → 0.2.1

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

@@ -1,8 +1,24 @@
 import { Ref } from "react";
-import { Object3D, Object3DEventMap } from "three";
+import { AnimationAction, AnimationClip, AnimationMixer, Object3D, Object3DEventMap } from "three";
 import { groundRayType } from "../controller/type";
+export type Api<T extends AnimationClip> = {
+    ref: React.MutableRefObject<Object3D | undefined | null>;
+    clips: AnimationClip[];
+    mixer: AnimationMixer;
+    names: T["name"][];
+    actions: {
+        [key in T["name"]]: AnimationAction | null;
+    };
+};
 export type playActionsType = {
+    type: "character" | "vehicle" | "airplane";
+    animationResult: Api<AnimationClip>;
+    currentAnimation?: string;
+};
+export type subscribeActionsType = {
+    type: "character" | "vehicle" | "airplane";
     groundRay: groundRayType;
+    animations: AnimationClip[];
 };
 export type actionsType = {
     [x: string]: THREE.AnimationAction | null;
@@ -11,18 +27,18 @@ export type playResultType = {
     actions: actionsType;
     ref: Ref<Object3D<Object3DEventMap>>;
 };
-export declare function readyAnimation(): {
-    resultRef: {
-        character: playResultType;
-        vehicle: playResultType;
-        airplane: playResultType;
+export declare function subscribeActions({ type, groundRay, animations, }: subscribeActionsType): {
+    animationResult: {
+        ref: import("react").MutableRefObject<Object3D<Object3DEventMap>>;
+        clips: AnimationClip[];
+        mixer: AnimationMixer;
+        names: string[];
+        actions: {
+            [x: string]: AnimationAction;
+        };
     };
 };
-export default function playCharacterActions({ groundRay }: playActionsType): {
-    ref: Ref<Object3D<Object3DEventMap>>;
-    resultRef: {
-        character: playResultType;
-        vehicle: playResultType;
-        airplane: playResultType;
-    };
+export default function playActions({ type, animationResult, currentAnimation, }: playActionsType): {
+    animationRef: import("react").MutableRefObject<Object3D<Object3DEventMap>>;
+    currentAnimation: string;
 };

package/dist/gaesup/animation/actions.js

@@ -9,60 +9,16 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-import { useAnimations, useKeyboardControls } from "@react-three/drei";
+import { useAnimations } from "@react-three/drei";
 import { useFrame } from "@react-three/fiber";
 import { useContext, useEffect } from "react";
 import { useGaesupAnimation } from "../hooks/useGaesupAnimation";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../world/context";
-// 캐릭터 등록, 애니메이션 이름 설정, 애니메이션 실행
-export function readyAnimation() {
-    var _a = useContext(GaesupWorldContext), characterGltf = _a.characterGltf, vehicleGltf = _a.vehicleGltf, airplaneGltf = _a.airplaneGltf;
-    var resultRef = {
-        character: null,
-        vehicle: null,
-        airplane: null,
-    };
-    if (characterGltf && characterGltf.animations)
-        resultRef.character = useAnimations(characterGltf.animations);
-    if (vehicleGltf && vehicleGltf.animations)
-        resultRef.vehicle = useAnimations(vehicleGltf.animations);
-    if (airplaneGltf && airplaneGltf.animations)
-        resultRef.airplane = useAnimations(airplaneGltf.animations);
-    return {
-        resultRef: resultRef,
-    };
-}
-export default function playCharacterActions(_a) {
-    var groundRay = _a.groundRay;
-    var _b = useContext(GaesupWorldContext), states = _b.states, activeState = _b.activeState, animations = _b.animations, mode = _b.mode, characterGltf = _b.characterGltf, vehicleGltf = _b.vehicleGltf, airplaneGltf = _b.airplaneGltf;
-    var dispatch = useContext(GaesupWorldDispatchContext);
-    var control = useKeyboardControls()[1]();
-    var _c = useGaesupAnimation(), subscribeAll = _c.subscribeAll, notify = _c.notify, store = _c.store;
-    var resultRef = {
-        character: null,
-        vehicle: null,
-        airplane: null,
-    };
-    if (characterGltf && characterGltf.animations)
-        resultRef.character = useAnimations(characterGltf.animations);
-    if (vehicleGltf && vehicleGltf.animations)
-        resultRef.vehicle = useAnimations(vehicleGltf.animations);
-    if (airplaneGltf && airplaneGltf.animations)
-        resultRef.airplane = useAnimations(airplaneGltf.animations);
-    var play = function (tag) {
-        animations.current = tag;
-        var currentAnimation = store[tag];
-        if (currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.action) {
-            currentAnimation.action();
-        }
-        dispatch({
-            type: "update",
-            payload: {
-                animations: __assign({}, animations),
-            },
-        });
-    };
-    var _d = resultRef.character, actions = _d.actions, ref = _d.ref;
+export function subscribeActions(_a) {
+    var type = _a.type, groundRay = _a.groundRay, animations = _a.animations;
+    var _b = useContext(GaesupWorldContext), states = _b.states, activeState = _b.activeState;
+    var subscribeAll = useGaesupAnimation({ type: type }).subscribeAll;
+    var animationResult = useAnimations(animations);
     // 초기 기본 애니메이션 등록
     useEffect(function () {
         subscribeAll([
@@ -103,28 +59,45 @@ export default function playCharacterActions(_a) {
             },
         ]);
     }, []);
-    useEffect(function () {
-        animations.keyControl = control;
+    return {
+        animationResult: animationResult,
+    };
+}
+export default function playActions(_a) {
+    var _b;
+    var type = _a.type, animationResult = _a.animationResult, currentAnimation = _a.currentAnimation;
+    var _c = useContext(GaesupWorldContext), mode = _c.mode, animationState = _c.animationState;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var _d = useGaesupAnimation({ type: type }), notify = _d.notify, store = _d.store;
+    var actions = animationResult.actions, ref = animationResult.ref;
+    var play = function (tag) {
+        animationState[type].current = tag;
+        var currentAnimation = store[tag];
+        if (currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.action) {
+            currentAnimation.action();
+        }
         dispatch({
             type: "update",
             payload: {
-                animations: __assign({}, animations),
+                animationState: __assign({}, animationState),
             },
         });
-    }, [control]);
+    };
     useEffect(function () {
         var _a;
-        var action = (_a = actions[animations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+        var action = (_a = actions[currentAnimation || animationState[type].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);
         };
-    }, [animations.current, mode.type]);
+    }, [currentAnimation, mode.type]);
     useFrame(function () {
-        var tag = notify();
-        play(tag);
+        if (!currentAnimation) {
+            var tag = notify();
+            play(tag);
+        }
     });
     return {
-        ref: ref,
-        resultRef: resultRef,
+        animationRef: ref,
+        currentAnimation: (_b = animationState === null || animationState === void 0 ? void 0 : animationState[type]) === null || _b === void 0 ? void 0 : _b.current,
     };
 }

package/dist/gaesup/camera/index.js

@@ -96,7 +96,7 @@ export default function Camera(_a) {
             return;
         cameraProp.delta = delta;
         cameraProp.state = state;
-        if (!worldContext.cameraBlock) {
+        if (!worldContext.block.camera) {
             if (mode.control === "orbit") {
                 orbit(cameraProp);
             }

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

@@ -1,5 +1,11 @@
-import { controllerInnerType, refsType } from "../../../controller/type";
-export declare function AirplaneRef({ props, refs, }: {
-    props: controllerInnerType;
+import { ReactNode } from "react";
+import { refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function AirplaneRef({ children, enableRiding, isRiderOn, offset, refs, urls, }: {
+    children: ReactNode;
+    enableRiding?: boolean;
+    isRiderOn?: boolean;
+    offset?: THREE.Vector3;
     refs: refsType;
+    urls: urlsType;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -1,10 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from "react";
-import { GaesupWorldContext } from "../../../world/context";
-import { WrapperRef } from "../common/WrapperRef";
-import { AirplaneCollider } from "./collider";
+import { AirplaneInnerRef } from "../../inner/airplane";
 export function AirplaneRef(_a) {
-    var props = _a.props, refs = _a.refs;
-    var airplaneGltf = useContext(GaesupWorldContext).airplaneGltf;
-    return (_jsx(WrapperRef, { props: props, refs: refs, gltf: airplaneGltf, children: _jsx(AirplaneCollider, { props: props }) }));
+    var children = _a.children, enableRiding = _a.enableRiding, isRiderOn = _a.isRiderOn, offset = _a.offset, refs = _a.refs, urls = _a.urls;
+    return (_jsx(AirplaneInnerRef, { refs: refs, urls: urls, isRiderOn: isRiderOn, enableRiding: enableRiding, offset: offset, children: children }));
 }

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

@@ -1,5 +1,7 @@
 import { controllerInnerType, refsType } from "../../../controller/type";
-export declare function CharacterRef({ props, refs, }: {
+import { urlsType } from "../../../world/context/type";
+export declare function CharacterRef({ props, refs, urls, }: {
     props: controllerInnerType;
     refs: refsType;
+    urls: urlsType;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -1,16 +1,34 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext } from "react";
+import { vec3 } from "@react-three/rapier";
+import playActions, { subscribeActions } from "../../../animation/actions";
 import initCallback from "../../../controller/initialize/callback";
-import { GaesupWorldContext } from "../../../world/context";
-import { CharacterCapsuleCollider } from "./collider";
-import playCharacterActions from "../../../animation/actions";
-import { WrapperRef } from "../common/WrapperRef";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { CharacterInnerRef, calcCharacterColliderProps, } from "../../inner/character";
+import { setGroundRay } from "../../inner/common/setGroundRay";
 export function CharacterRef(_a) {
-    var props = _a.props, refs = _a.refs;
-    initCallback(props);
-    var characterGltf = useContext(GaesupWorldContext).characterGltf;
-    var ref = playCharacterActions({
+    var props = _a.props, refs = _a.refs, urls = _a.urls;
+    initCallback(props, "character");
+    var colliderRef = refs.colliderRef;
+    var _b = useGltfAndSize({ url: urls.characterUrl }), size = _b.size, gltf = _b.gltf;
+    var collider = calcCharacterColliderProps(size);
+    props.groundRay.offset = vec3({
+        x: 0,
+        y: (collider === null || collider === void 0 ? void 0 : collider.halfHeight) ? -(collider === null || collider === void 0 ? void 0 : collider.halfHeight) : -1,
+        z: 0,
+    });
+    setGroundRay({
         groundRay: props.groundRay,
-    }).ref;
-    return (_jsx(WrapperRef, { props: props, refs: refs, gltf: characterGltf, animationRef: ref, name: "character", children: _jsx(CharacterCapsuleCollider, { props: props, ref: refs.capsuleColliderRef }) }));
+        length: (collider === null || collider === void 0 ? void 0 : collider.radius) || 0 + 2,
+        colliderRef: colliderRef,
+    });
+    var animationResult = subscribeActions({
+        type: "character",
+        groundRay: props.groundRay,
+        animations: gltf.animations,
+    }).animationResult;
+    var _c = playActions({
+        type: "character",
+        animationResult: animationResult,
+    }), animationRef = _c.animationRef, currentAnimation = _c.currentAnimation;
+    return (_jsx(CharacterInnerRef, { animationRef: animationRef, refs: refs, urls: urls, currentAnimation: currentAnimation, children: props.children }));
 }

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

@@ -1,5 +1,12 @@
-import { controllerInnerType, refsType } from "../../../controller/type";
-export declare function VehicleRef({ props, refs, }: {
-    props: controllerInnerType;
+import { ReactNode } from "react";
+import { groundRayType, refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function VehicleRef({ children, groundRay, enableRiding, isRiderOn, offset, refs, urls, }: {
+    children: ReactNode;
+    groundRay: groundRayType;
+    enableRiding?: boolean;
+    isRiderOn?: boolean;
+    offset?: THREE.Vector3;
     refs: refsType;
+    urls: urlsType;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -1,11 +1,31 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useContext } from "react";
-import { GaesupWorldContext } from "../../../world/context";
-import { WrapperRef } from "../common/WrapperRef";
-import { VehicleCollider } from "./collider";
-import { Wheels } from "./wheels";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+import playActions, { subscribeActions } from "../../../animation/actions";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { setGroundRay } from "../../inner/common/setGroundRay";
+import { VehicleInnerRef } from "../../inner/vehicle";
 export function VehicleRef(_a) {
-    var props = _a.props, refs = _a.refs;
-    var _b = useContext(GaesupWorldContext), url = _b.url, vehicleGltf = _b.vehicleGltf;
-    return (_jsx(WrapperRef, { props: props, refs: refs, gltf: vehicleGltf, outerChildren: url.wheelUrl ? _jsx(Wheels, { props: props }) : _jsx(_Fragment, {}), children: _jsx(VehicleCollider, {}) }));
+    var children = _a.children, groundRay = _a.groundRay, enableRiding = _a.enableRiding, isRiderOn = _a.isRiderOn, offset = _a.offset, refs = _a.refs, urls = _a.urls;
+    var colliderRef = refs.colliderRef;
+    var _b = useGltfAndSize({ url: urls.vehicleUrl }), size = _b.size, gltf = _b.gltf;
+    groundRay.offset = vec3({
+        x: 0,
+        y: size.y * 3,
+        z: 0,
+    });
+    setGroundRay({
+        groundRay: groundRay,
+        length: size.y * 3,
+        colliderRef: colliderRef,
+    });
+    var animationResult = subscribeActions({
+        type: "vehicle",
+        groundRay: groundRay,
+        animations: gltf.animations,
+    }).animationResult;
+    var _c = playActions({
+        type: "vehicle",
+        animationResult: animationResult,
+    }), animationRef = _c.animationRef, currentAnimation = _c.currentAnimation;
+    return (_jsx(VehicleInnerRef, { refs: refs, urls: urls, isRiderOn: isRiderOn, enableRiding: enableRiding, offset: offset, currentAnimation: currentAnimation, children: children }));
 }

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

@@ -1,5 +1,7 @@
 import { controllerInnerType, refsType } from "../controller/type";
-export declare function GaesupComponent({ props, refs, }: {
+import { urlsType } from "../world/context/type";
+export declare function GaesupComponent({ props, refs, urls, }: {
     props: controllerInnerType;
     refs: refsType;
+    urls: urlsType;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/index.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
 import { useContext } from "react";
 import calculation from "../physics";
 import { GaesupWorldContext } from "../world/context";
@@ -6,8 +7,13 @@ import { AirplaneRef } from "./active/airplane";
 import { CharacterRef } from "./active/character";
 import { VehicleRef } from "./active/vehicle";
 export function GaesupComponent(_a) {
-    var props = _a.props, refs = _a.refs;
-    var mode = useContext(GaesupWorldContext).mode;
+    var props = _a.props, refs = _a.refs, urls = _a.urls;
+    var _b = useContext(GaesupWorldContext), mode = _b.mode, states = _b.states, rideable = _b.rideable;
+    var enableRiding = states.enableRiding, isRiderOn = states.isRiderOn, rideableId = states.rideableId;
     calculation(props);
-    return (_jsxs(_Fragment, { children: [mode.type === "character" && _jsx(CharacterRef, { props: props, refs: refs }), mode.type === "vehicle" && _jsx(VehicleRef, { props: props, refs: refs }), mode.type === "airplane" && _jsx(AirplaneRef, { props: props, refs: refs })] }));
+    return (_jsxs(_Fragment, { children: [mode.type === "character" && (_jsx(CharacterRef, { props: props, refs: refs, urls: urls })), mode.type === "vehicle" && (_jsx(VehicleRef, { groundRay: props.groundRay, refs: refs, urls: urls, enableRiding: enableRiding, isRiderOn: isRiderOn, offset: rideableId && rideable[rideableId]
+                    ? rideable[rideableId].offset
+                    : vec3(), children: props.children })), mode.type === "airplane" && (_jsx(AirplaneRef, { refs: refs, urls: urls, enableRiding: enableRiding, isRiderOn: isRiderOn, offset: rideableId && rideable[rideableId]
+                    ? rideable[rideableId].offset
+                    : vec3(), children: props.children }))] }));
 }

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

@@ -0,0 +1,2 @@
+import { refPropsType } from "../common/type";
+export declare function AirplaneInnerRef({ children, refs, urls, isRiderOn, enableRiding, offset, name, position, rotation, userData, onCollisionEnter, }: refPropsType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CuboidCollider } from "@react-three/rapier";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { OuterGroupRef } from "../common/OuterGroupRef";
+import { RigidBodyRef } from "../common/RigidbodyRef";
+import RiderRef from "../rider";
+export function AirplaneInnerRef(_a) {
+    var children = _a.children, refs = _a.refs, urls = _a.urls, isRiderOn = _a.isRiderOn, enableRiding = _a.enableRiding, offset = _a.offset, name = _a.name, position = _a.position, rotation = _a.rotation, userData = _a.userData, onCollisionEnter = _a.onCollisionEnter;
+    var airplaneUrl = urls.airplaneUrl;
+    var rigidBodyRef = refs.rigidBodyRef, innerGroupRef = refs.innerGroupRef, outerGroupRef = refs.outerGroupRef;
+    var size = useGltfAndSize({
+        url: airplaneUrl,
+    }).size;
+    return (_jsx(OuterGroupRef, { ref: outerGroupRef, children: airplaneUrl && (_jsxs(RigidBodyRef, { ref: rigidBodyRef, name: name, position: position, rotation: rotation, userData: userData, onCollisionEnter: onCollisionEnter, children: [_jsx(CuboidCollider, { args: [size.x / 2, size.y / 2, size.z / 2], position: [0, size.y / 2, 0] }), children, _jsx(InnerGroupRef, { type: "airplane", url: airplaneUrl, currentAnimation: "idle", ref: innerGroupRef, children: enableRiding && isRiderOn && urls.characterUrl && (_jsx(RiderRef, { urls: urls, offset: offset })) })] })) }));
+}

package/dist/gaesup/component/inner/character/index.d.ts

@@ -0,0 +1,25 @@
+import { refsType } from "../../../controller/type";
+import { ReactNode, Ref } from "react";
+import { Object3D, Object3DEventMap } from "three";
+import { urlsType } from "../../../world/context/type";
+export declare const calcCharacterColliderProps: (characterSize: THREE.Vector3) => {
+    height: number;
+    halfHeight: number;
+    radius: number;
+    diameter: number;
+};
+export type characterColliderType = {
+    height: number;
+    halfHeight: number;
+    radius: number;
+    diameter: number;
+};
+export declare function CharacterInnerRef({ children, refs, urls, position, euler, currentAnimation, }: {
+    children: ReactNode;
+    refs: Partial<refsType>;
+    urls: urlsType;
+    position?: THREE.Vector3;
+    euler?: THREE.Euler;
+    animationRef?: Ref<Object3D<Object3DEventMap>>;
+    currentAnimation?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/inner/character/index.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { CapsuleCollider } from "@react-three/rapier";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { OuterGroupRef } from "../common/OuterGroupRef";
+import { RigidBodyRef } from "../common/RigidbodyRef";
+export var calcCharacterColliderProps = function (characterSize) {
+    if (!characterSize)
+        return null;
+    var heightPlusDiameter = characterSize.y / 2;
+    var diameter = Math.max(characterSize.x, characterSize.z);
+    var radius = diameter / 2;
+    var height = heightPlusDiameter - radius;
+    var halfHeight = height / 2;
+    return {
+        height: height,
+        halfHeight: halfHeight,
+        radius: radius,
+        diameter: diameter,
+    };
+};
+export function CharacterInnerRef(_a) {
+    var children = _a.children, refs = _a.refs, urls = _a.urls, position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation;
+    var outerGroupRef = refs.outerGroupRef, rigidBodyRef = refs.rigidBodyRef, colliderRef = refs.colliderRef, innerGroupRef = refs.innerGroupRef;
+    var size = useGltfAndSize({ url: urls.characterUrl }).size;
+    var collider = calcCharacterColliderProps(size);
+    return (_jsx(_Fragment, { children: collider && (_jsxs(OuterGroupRef, { ref: outerGroupRef, children: [children, _jsxs(RigidBodyRef, { ref: rigidBodyRef, name: "character", position: position, rotation: euler, children: [_jsx(CapsuleCollider, { ref: colliderRef, args: [collider.height, collider.radius], position: [0, collider.height + collider.radius, 0] }), _jsx(InnerGroupRef, { type: "character", ref: innerGroupRef, url: urls.characterUrl, currentAnimation: currentAnimation })] })] })) }));
+}

package/dist/gaesup/component/{passive → inner}/common/InnerGroupRef.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="react" />
 import * as THREE from "three";
 export type InnerGroupRefType = {
+    children?: React.ReactNode;
+    type: "character" | "vehicle" | "airplane";
     currentAnimation: string;
     url: string;
     rotation?: THREE.Euler;

package/dist/gaesup/component/{passive → inner}/common/InnerGroupRef.js

@@ -1,27 +1,29 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Suspense, forwardRef, useMemo } from "react";
-import { useGLTF } from "@react-three/drei";
 import { useGraph } from "@react-three/fiber";
+import { Suspense, forwardRef, useMemo } from "react";
 import * as THREE from "three";
 import { SkeletonUtils } from "three-stdlib";
-import playPassiveActions from "../../../animation/passiveActions";
+import { useAnimations, useGLTF } from "@react-three/drei";
+import playActions from "../../../animation/actions";
 export var InnerGroupRef = forwardRef(function (_a, ref) {
-    var currentAnimation = _a.currentAnimation, url = _a.url, rotation = _a.rotation;
+    var children = _a.children, type = _a.type, currentAnimation = _a.currentAnimation, url = _a.url, rotation = _a.rotation;
     var _b = useGLTF(url), scene = _b.scene, animations = _b.animations;
-    var animationRef = playPassiveActions({
-        current: currentAnimation,
-        animations: animations,
+    var animationResult = useAnimations(animations);
+    var animationRef = playActions({
+        type: type,
+        animationResult: animationResult,
+        currentAnimation: currentAnimation,
     }).animationRef;
     var clone = useMemo(function () { return SkeletonUtils.clone(scene); }, [scene]);
     var nodes = useGraph(clone).nodes;
     var objectNode = Object.values(nodes).find(function (node) { return node.type === "Object3D"; });
-    return (_jsx(Suspense, { fallback: null, children: _jsxs("group", { receiveShadow: true, castShadow: true, ref: ref, rotation: rotation, userData: { intangible: true }, children: [objectNode && animationRef && (_jsx("primitive", { object: objectNode, visible: false, receiveShadow: true, castShadow: true, ref: animationRef })), Object.keys(nodes).map(function (name, key) {
+    return (_jsx(Suspense, { fallback: null, children: _jsxs("group", { receiveShadow: true, castShadow: true, ref: ref, rotation: rotation, userData: { intangible: true }, children: [children, objectNode && animationRef && (_jsx("primitive", { object: objectNode, visible: false, receiveShadow: true, castShadow: true, ref: animationRef })), Object.keys(nodes).map(function (name, key) {
                     var node = nodes[name];
                     if (node instanceof THREE.SkinnedMesh) {
-                        return (_jsx("skinnedMesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry, skeleton: node.skeleton, userData: { intangible: true } }, key));
+                        return (_jsx("skinnedMesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry, skeleton: node.skeleton }, key));
                     }
                     else if (node instanceof THREE.Mesh) {
-                        return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry, userData: { intangible: true } }, key));
+                        return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry }, key));
                     }
                 })] }) }));
 });

package/dist/gaesup/component/{passive → inner}/common/RigidbodyRef.d.ts

@@ -2,7 +2,11 @@ import { CollisionEnterPayload, RapierRigidBody } from "@react-three/rapier";
 import { ReactNode } from "react";
 export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<{
     children: ReactNode;
+    name?: string;
     position?: THREE.Vector3;
     rotation?: THREE.Euler;
+    userData?: {
+        intangible: boolean;
+    };
     onCollisionEnter?: (e: CollisionEnterPayload) => Promise<void>;
 } & import("react").RefAttributes<RapierRigidBody>>;

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

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RigidBody, euler, } from "@react-three/rapier";
+import { forwardRef } from "react";
+export var RigidBodyRef = forwardRef(function (_a, ref) {
+    var children = _a.children, name = _a.name, position = _a.position, rotation = _a.rotation, userData = _a.userData, onCollisionEnter = _a.onCollisionEnter;
+    return (_jsx(RigidBody, { colliders: false, ref: ref, name: name, position: position, rotation: euler().set(0, (rotation === null || rotation === void 0 ? void 0 : rotation.clone().y) || 0, 0), userData: userData, onCollisionEnter: onCollisionEnter, children: children }));
+});

package/dist/gaesup/component/inner/common/setGroundRay.d.ts

@@ -0,0 +1,9 @@
+import { Collider } from "@dimforge/rapier3d-compat";
+import { RefObject } from "react";
+import { groundRayType } from "../../../controller/type";
+export type setGroundRayType = {
+    groundRay: groundRayType;
+    length: number;
+    colliderRef: RefObject<Collider>;
+};
+export declare function setGroundRay({ groundRay, length, colliderRef, }: setGroundRayType): void;

package/dist/gaesup/component/inner/common/setGroundRay.js

@@ -0,0 +1,14 @@
+import { useRapier } from "@react-three/rapier";
+import { getRayHit } from "../../../utils";
+export function setGroundRay(_a) {
+    var _b;
+    var groundRay = _a.groundRay, length = _a.length, colliderRef = _a.colliderRef;
+    var rapier = useRapier().rapier;
+    groundRay.length = length;
+    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();
+}

package/dist/gaesup/component/inner/common/type.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { CollisionEnterPayload } from "@react-three/rapier";
+import { refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export type refPropsType = {
+    children: React.ReactNode;
+    refs: Partial<refsType>;
+    urls: urlsType;
+    isRiderOn?: boolean;
+    enableRiding?: boolean;
+    offset?: THREE.Vector3;
+    name?: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    userData?: {
+        intangible: boolean;
+    };
+    currentAnimation?: string;
+    onCollisionEnter?: (e: CollisionEnterPayload) => Promise<void>;
+};

package/dist/gaesup/component/inner/rider/index.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import * as THREE from "three";
+import { urlsType } from "../../../world/context/type";
+export type riderRefType = {
+    urls: urlsType;
+    children?: ReactNode;
+    offset?: THREE.Vector3;
+    euler?: THREE.Euler;
+    currentAnimation?: string;
+};
+export default function RiderRef({ urls, children, offset, euler, currentAnimation, }: riderRefType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/inner/rider/index.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useAnimations } from "@react-three/drei";
+import { useGraph } from "@react-three/fiber";
+import { useMemo } from "react";
+import * as THREE from "three";
+import { SkeletonUtils } from "three-stdlib";
+import playActions from "../../../animation/actions";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+export default function RiderRef(_a) {
+    var urls = _a.urls, children = _a.children, offset = _a.offset, euler = _a.euler, currentAnimation = _a.currentAnimation;
+    var gltf = useGltfAndSize({ url: urls.characterUrl }).gltf;
+    var animations = gltf.animations, scene = gltf.scene;
+    var animationResult = useAnimations(animations);
+    var animationRef = playActions({
+        type: "character",
+        animationResult: animationResult,
+        currentAnimation: currentAnimation || "ride",
+    }).animationRef;
+    var characterClone = useMemo(function () { return SkeletonUtils.clone(scene); }, [scene]);
+    var characterNodes = useGraph(characterClone).nodes;
+    var characterObjectNode = Object.values(characterNodes).find(function (node) { return node.type === "Object3D"; });
+    return (_jsx(_Fragment, { children: _jsxs("group", { position: offset, rotation: euler, children: [characterObjectNode && (_jsx("primitive", { object: characterObjectNode, visible: false, receiveShadow: true, castShadow: true, ref: animationRef })), Object.keys(characterNodes).map(function (name, key) {
+                    var characterNode = characterNodes[name];
+                    if (characterNode instanceof THREE.SkinnedMesh) {
+                        return (_jsx("skinnedMesh", { castShadow: true, receiveShadow: true, material: characterNode.material, geometry: characterNode.geometry, skeleton: characterNode.skeleton }, key));
+                    }
+                    else if (characterNode instanceof THREE.Mesh) {
+                        return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: characterNode.material, geometry: characterNode.geometry }, key));
+                    }
+                }), children] }) }));
+}

package/dist/gaesup/component/inner/vehicle/collider.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Collider } from "@dimforge/rapier3d-compat";
+import { urlsType } from "../../../world/context/type";
+export declare const VehicleWheelCollider: import("react").ForwardRefExoticComponent<{
+    urls: urlsType;
+    vehicleSize: THREE.Vector3;
+} & import("react").RefAttributes<Collider>>;
+export declare const VehicleCollider: import("react").ForwardRefExoticComponent<{
+    vehicleSize: THREE.Vector3;
+} & import("react").RefAttributes<Collider>>;