gaesup-world 0.0.692 → 0.0.762

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

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

package/dist/gaesup/animation/actions.js

@@ -13,43 +13,53 @@ 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(_a) {
-    var groundRay = _a.groundRay, isRider = _a.isRider;
-    var _b = useContext(GaesupWorldContext), characterGltf = _b.characterGltf, characterAnimations = _b.animations;
+export function usePlayActions() {
+    var _a = useContext(GaesupWorldContext), characterGltf = _a.characterGltf, vehicleGltf = _a.vehicleGltf, airplaneGltf = _a.airplaneGltf, animations = _a.animations;
+    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 dispatch = useContext(GaesupWorldDispatchContext);
-    var animations = characterGltf.animations;
-    var control = useKeyboardControls()[1]();
-    var _c = useAnimations(animations), actions = _c.actions, animationRef = _c.ref;
-    useEffect(function () {
-        characterAnimations.keyControl = control;
-        dispatch({
-            type: "update",
-            payload: {
-                animations: __assign({}, characterAnimations),
-            },
-        });
-    }, [control]);
     var play = function (tag) {
-        characterAnimations.current = tag;
+        animations.current = tag;
         dispatch({
             type: "update",
             payload: {
-                animations: __assign({}, characterAnimations),
+                animations: __assign({}, animations),
             },
         });
     };
     var setAnimationName = function (actions) {
-        characterAnimations.animationNames = Object.assign(characterAnimations.animationNames, Object.keys(actions).reduce(function (acc, cur) {
+        animations.animationNames = Object.assign(animations.animationNames, Object.keys(actions).reduce(function (acc, cur) {
             var _a;
             return __assign(__assign({}, acc), (_a = {}, _a[cur] = cur, _a));
         }, {}));
         dispatch({
             type: "update",
             payload: {
-                animations: __assign({}, characterAnimations),
+                animations: __assign({}, animations),
             },
         });
     };
+    return { resultRef: resultRef, play: play, setAnimationName: setAnimationName };
+}
+export default function playCharacterActions(_a) {
+    var groundRay = _a.groundRay;
+    var _b = usePlayActions(), _c = _b.resultRef.character, actions = _c.actions, ref = _c.ref, play = _b.play, setAnimationName = _b.setAnimationName;
+    var _d = useContext(GaesupWorldContext), states = _d.states, activeState = _d.activeState, animations = _d.animations, mode = _d.mode;
+    var isNotMoving = states.isNotMoving, isMoving = states.isMoving, isJumping = states.isJumping, isRunning = states.isRunning, isAnimationOuter = states.isAnimationOuter, isOnTheGround = states.isOnTheGround;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var control = useKeyboardControls()[1]();
     var resetAni = function () { return play("idle"); };
     var playIdle = function () { return play("idle"); };
     var playWalk = function () { return play("walk"); };
@@ -63,21 +73,27 @@ export default function playActions(_a) {
             resetAni();
         };
     }, []);
+    useEffect(function () {
+        animations.keyControl = control;
+        dispatch({
+            type: "update",
+            payload: {
+                animations: __assign({}, animations),
+            },
+        });
+    }, [control]);
     useEffect(function () {
         var _a;
-        var action = (_a = actions[characterAnimations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
-        setAnimationName(actions);
-        return function () {
-            action === null || action === void 0 ? void 0 : action.fadeOut(0.2);
-        };
-    }, [characterAnimations.current]);
-    var _d = useContext(GaesupWorldContext), states = _d.states, activeState = _d.activeState;
-    var isNotMoving = states.isNotMoving, isMoving = states.isMoving, isJumping = states.isJumping, isRunning = states.isRunning, isAnimationOuter = states.isAnimationOuter, isOnTheGround = states.isOnTheGround;
-    useFrame(function () {
-        if (isRider) {
-            playRide();
+        if (mode.type === "character") {
+            var action_1 = (_a = actions[animations.current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+            setAnimationName(actions);
+            return function () {
+                action_1 === null || action_1 === void 0 ? void 0 : action_1.fadeOut(0.2);
+            };
         }
-        else {
+    }, [animations.current, mode.type]);
+    useFrame(function () {
+        if (mode.type === "character") {
             if (!isAnimationOuter) {
                 if (isJumping) {
                     playJump();
@@ -91,23 +107,22 @@ export default function playActions(_a) {
                 else if (isMoving) {
                     playWalk();
                 }
-                if (groundRay.hit) {
-                    if (!isJumping && !isOnTheGround) {
-                        if (groundRay.hit.toi < 5) {
-                            playLanding();
-                        }
-                        else {
-                            playFall();
-                        }
-                    }
-                }
-                if (groundRay.hit === null && activeState.velocity.y < 0) {
-                    playFall();
-                }
+                // if (groundRay.hit) {
+                //   if (!isJumping && !isOnTheGround) {
+                //     if (groundRay.hit.toi < 5) {
+                //       playLanding();
+                //     } else {
+                //       playFall();
+                //     }
+                //   }
+                // }
+                // if (groundRay.hit === null && activeState.velocity.y < 0) {
+                //   playFall();
+                // }
             }
         }
     });
     return {
-        animationRef: animationRef,
+        ref: ref,
     };
 }

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

@@ -3,7 +3,7 @@ export default function normal(prop) {
     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);
+        .add(V3(0, perspectiveCamera.YDistance, perspectiveCamera.XZDistance));
+    state.camera.position.lerp(cameraPosition, 0.9);
     state.camera.lookAt(activeState.position.clone());
 }

package/dist/gaesup/camera/detector/index.d.ts

@@ -0,0 +1,2 @@
+import { cameraPropType } from "../../physics/type";
+export default function detector(cameraProp: cameraPropType): void;

package/dist/gaesup/camera/detector/index.js

@@ -0,0 +1,25 @@
+import * as THREE from "three";
+export default function detector(cameraProp) {
+    var cameraRay = cameraProp.cameraRay, intersectObjectMap = cameraProp.intersectObjectMap;
+    var intersects = cameraRay.rayCast.intersectObjects(Object.values(intersectObjectMap));
+    var intersectId = {};
+    intersects.map(function (_a) {
+        var object = _a.object;
+        if (object instanceof THREE.Mesh) {
+            intersectId[object.uuid] = true;
+        }
+    });
+    Object.values(intersectObjectMap).map(function (mesh) {
+        if (mesh instanceof THREE.Mesh && mesh.material instanceof THREE.Material) {
+            var material = mesh.material;
+            if (intersectId[mesh.uuid]) {
+                material.opacity = 0.2;
+                material.transparent = true;
+            }
+            else {
+                material.opacity = 1;
+                material.transparent = false;
+            }
+        }
+    });
+}

package/dist/gaesup/camera/index.js

@@ -12,11 +12,10 @@ var __assign = (this && this.__assign) || function () {
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { MapControls, OrbitControls, OrthographicCamera, PerspectiveCamera, } from "@react-three/drei";
 import { useFrame, useThree } from "@react-three/fiber";
-import { useContext } from "react";
+import { useContext, useEffect, useMemo } from "react";
 import * as THREE from "three";
 import { GaesupControllerContext } from "../controller/context";
 import { GaesupWorldContext } from "../world/context";
-import cameraCollisionDetector from "./cameraCollisionDetecter";
 import mapControl from "./control/map";
 import normal from "./control/normal";
 import orbit from "./control/orbit";
@@ -27,11 +26,10 @@ export default function Camera(_a) {
     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 _b = useThree(), camera = _b.camera, scene = _b.scene;
     var activeState = worldContext.activeState;
-    var intersectObjectMap = {};
-    var cameraProp = __assign(__assign({}, prop), { checkCollision: checkCollision, control: control, controllerContext: controllerContext, worldContext: worldContext });
+    var intersectObjectMap = useMemo(function () { return ({}); }, []);
+    var cameraProp = __assign(__assign({}, prop), { control: control, controllerContext: controllerContext, worldContext: worldContext, intersectObjectMap: intersectObjectMap });
     var getMeshs = function (object) {
         if (object.userData && object.userData.intangible)
             return;
@@ -43,6 +41,9 @@ export default function Camera(_a) {
             getMeshs(child);
         });
     };
+    useEffect(function () {
+        scene.children.forEach(function (child) { return getMeshs(child); });
+    }, []);
     useFrame(function (state, delta) {
         if (!rigidBodyRef ||
             !rigidBodyRef.current ||
@@ -52,8 +53,6 @@ export default function Camera(_a) {
         cameraProp.state = state;
         cameraProp.delta = delta;
         if (cameraMode.cameraType === "perspective") {
-            scene.children.forEach(function (child) { return getMeshs(child); });
-            cameraRay.intersectObjectMap = intersectObjectMap;
             if (cameraMode.controlType === "orbit") {
                 orbit(cameraProp);
             }
@@ -64,6 +63,10 @@ export default function Camera(_a) {
         else if (cameraMode.cameraType === "orthographic") {
             mapControl(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))] }))] }));
 }

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

@@ -2,16 +2,12 @@ export type cameraRayType = {
     origin: THREE.Vector3;
     hit: THREE.Raycaster;
     rayCast: THREE.Raycaster | null;
-    lerpingPoint: THREE.Vector3;
     length: number;
     dir: THREE.Vector3;
     position: THREE.Vector3;
-    followCamera: THREE.Object3D;
-    pivot: THREE.Object3D;
-    intersetesAndTransParented: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
-    intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
-    intersectObjects: THREE.Object3D[];
+    intersects: THREE.Intersection<THREE.Mesh>[];
+    detected: THREE.Intersection<THREE.Mesh>[];
     intersectObjectMap: {
-        [uuid: string]: THREE.Object3D;
+        [uuid: string]: THREE.Mesh;
     };
 };

package/dist/gaesup/component/{ref → active}/airplane/collider.d.ts

@@ -2,5 +2,5 @@
 import { Collider } from "@dimforge/rapier3d-compat";
 import { controllerInnerType } from "../../../controller/type";
 export declare const AirplaneCollider: import("react").ForwardRefExoticComponent<{
-    prop: controllerInnerType;
+    props: controllerInnerType;
 } & import("react").RefAttributes<Collider>>;

package/dist/gaesup/component/{ref → active}/airplane/collider.js

@@ -5,12 +5,12 @@ import { getRayHit, useForwardRef } from "../../../utils";
 import { GaesupWorldContext } from "../../../world/context";
 export var AirplaneCollider = forwardRef(function (_a, ref) {
     var _b;
-    var prop = _a.prop;
+    var props = _a.props;
     var collider = useContext(GaesupWorldContext).airplaneCollider;
     var airplaneSizeX = collider.airplaneSizeX, airplaneSizeY = collider.airplaneSizeY, airplaneSizeZ = collider.airplaneSizeZ;
     var colliderRef = useForwardRef(ref);
     var rapier = useRapier().rapier;
-    var groundRay = prop.groundRay;
+    var groundRay = props.groundRay;
     groundRay.length = airplaneSizeY * 5 + 2;
     groundRay.rayCast = new rapier.Ray(groundRay.origin, groundRay.dir);
     groundRay.hit = getRayHit({

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

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

package/dist/gaesup/component/{ref → active}/character/collider.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { CapsuleCollider, useRapier } from "@react-three/rapier";
 import { forwardRef, useContext } from "react";
 import { getRayHit, useForwardRef } from "../../../utils";
@@ -20,5 +20,5 @@ export var CharacterCapsuleCollider = forwardRef(function (_a, ref) {
     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] }));
+    return (_jsx(_Fragment, { children: _jsx(CapsuleCollider, { ref: ref, args: [collider.height, collider.radius], position: [0, collider.height + collider.radius, 0] }) }));
 });

package/dist/gaesup/component/{ref → active}/character/index.d.ts

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

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

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+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";
+export function CharacterRef(_a) {
+    var props = _a.props, refs = _a.refs;
+    initCallback(props);
+    var _b = useContext(GaesupWorldContext), characterGltf = _b.characterGltf, characterCollider = _b.characterCollider, vehicleCollider = _b.vehicleCollider;
+    var ref = playCharacterActions({
+        groundRay: props.groundRay,
+    }).ref;
+    return (_jsx(WrapperRef, { props: props, refs: refs, gltf: characterGltf, animationRef: ref, children: _jsx(CharacterCapsuleCollider, { props: props, ref: refs.capsuleColliderRef }) }));
+}

package/dist/gaesup/component/active/common/InnerGroupRef.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from "react";
+import { controllerInnerType } from "../../../controller/type";
+import * as THREE from "three";
+import { GLTFResult } from "../../type";
+export type InnerGroupRefType = {
+    props: controllerInnerType;
+    animationRef?: Ref<THREE.Object3D<THREE.Object3DEventMap>>;
+    gltf: GLTFResult;
+};
+export declare const InnerGroupRef: import("react").ForwardRefExoticComponent<InnerGroupRefType & import("react").RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;

package/dist/gaesup/component/active/common/InnerGroupRef.js

@@ -0,0 +1,32 @@
+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 { forwardRef, useMemo } from "react";
+import { useGraph } from "@react-three/fiber";
+import * as THREE from "three";
+import { SkeletonUtils } from "three-stdlib";
+export var InnerGroupRef = forwardRef(function (_a, ref) {
+    var props = _a.props, animationRef = _a.animationRef, gltf = _a.gltf;
+    var scene = gltf.scene;
+    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 (_jsxs("group", __assign({ receiveShadow: true, castShadow: true }, props.groupProps, { ref: ref, 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 }, key));
+                }
+                else if (node instanceof THREE.Mesh) {
+                    return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry }, key));
+                }
+            })] })));
+});

package/dist/gaesup/component/{ref/airplane/group.d.ts → active/common/OuterGroupRef.d.ts}

@@ -1,6 +1,6 @@
 import { ReactNode } from "react";
 import { controllerType } from "../../../controller/type";
-export declare const AirplaneGroup: import("react").ForwardRefExoticComponent<{
+export declare const OuterGroupRef: import("react").ForwardRefExoticComponent<{
     props: controllerType;
     children: ReactNode;
 } & import("react").RefAttributes<import("three").Group<import("three").Object3DEventMap>>>;

package/dist/gaesup/component/{ref/character/group.js → active/common/OuterGroupRef.js}

@@ -11,7 +11,7 @@ var __assign = (this && this.__assign) || function () {
 };
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
-export var CharacterGroup = forwardRef(function (_a, ref) {
+export var OuterGroupRef = forwardRef(function (_a, ref) {
     var props = _a.props, children = _a.children;
-    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, props.character, { children: children })));
+    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, props.vehicle, { children: children })));
 });

package/dist/gaesup/component/{ref/vehicle/rigidbody.d.ts → active/common/RigidbodyRef.d.ts}

@@ -1,7 +1,7 @@
 import { RapierRigidBody } from "@react-three/rapier";
 import { ReactNode } from "react";
 import { controllerInnerType } from "../../../controller/type";
-export declare const VehicleRigidBody: import("react").ForwardRefExoticComponent<{
+export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<{
     props: controllerInnerType;
     children: ReactNode;
 } & import("react").RefAttributes<RapierRigidBody>>;

package/dist/gaesup/component/{ref/vehicle/group.js → active/common/RigidbodyRef.js}

@@ -10,10 +10,9 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { forwardRef, useContext } from "react";
-import { GaesupWorldContext } from "../../../world/context";
-export var VehicleGroup = forwardRef(function (_a, ref) {
+import { RigidBody } from "@react-three/rapier";
+import { forwardRef } from "react";
+export var RigidBodyRef = forwardRef(function (_a, ref) {
     var props = _a.props, children = _a.children;
-    var mode = useContext(GaesupWorldContext).mode;
-    return (_jsx("group", __assign({ ref: ref, userData: { intangible: true } }, props.vehicle, { visible: mode.type === "vehicle", children: children })));
+    return (_jsx(RigidBody, __assign({ colliders: false, ref: ref }, props.rigidBodyProps, { children: children })));
 });

package/dist/gaesup/component/active/common/WrapperRef.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode, Ref } from "react";
+import * as THREE from "three";
+import { controllerInnerType, refsType } from "../../../controller/type";
+import { GLTFResult } from "../../type";
+export declare function WrapperRef({ children, outerChildren, props, refs, gltf, animationRef, }: {
+    children: ReactNode;
+    outerChildren?: ReactNode;
+    props: controllerInnerType;
+    refs: refsType;
+    gltf: GLTFResult;
+    animationRef?: Ref<THREE.Object3D<THREE.Object3DEventMap>>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/active/common/WrapperRef.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { OuterGroupRef } from "../common/OuterGroupRef";
+import { SlopeRayRef } from "../common/slopeRayRef";
+import { RigidBodyRef } from "./RigidbodyRef";
+export function WrapperRef(_a) {
+    var children = _a.children, outerChildren = _a.outerChildren, props = _a.props, refs = _a.refs, gltf = _a.gltf, animationRef = _a.animationRef;
+    return (_jsxs(OuterGroupRef, { ref: refs.outerGroupRef, props: props, children: [_jsxs(RigidBodyRef, { ref: refs.rigidBodyRef, props: props, children: [_jsx(SlopeRayRef, { slopeRay: props.slopeRay, groundRay: props.groundRay, ref: refs.slopeRayOriginRef }), children, props.children, _jsx(InnerGroupRef, { props: props, gltf: gltf, ref: refs.innerGroupRef, animationRef: animationRef })] }), outerChildren] }));
+}

package/dist/gaesup/component/{ref/character/slopeRay.d.ts → active/common/slopeRayRef.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { groundRayType, slopeRayType } from "../../../controller/type";
-export declare const CharacterSlopeRay: import("react").ForwardRefExoticComponent<{
+export declare const SlopeRayRef: import("react").ForwardRefExoticComponent<{
     groundRay: groundRayType;
     slopeRay: slopeRayType;
 } & import("react").RefAttributes<import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>>;

package/dist/gaesup/component/{ref/character/slopeRay.js → active/common/slopeRayRef.js}

@@ -1,10 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
-export var CharacterSlopeRay = forwardRef(function (_a, ref) {
+export var SlopeRayRef = forwardRef(function (_a, ref) {
     var groundRay = _a.groundRay, slopeRay = _a.slopeRay;
     return (_jsx("mesh", { position: [
             groundRay.offset.x,
             groundRay.offset.y,
             groundRay.offset.z + slopeRay.offset.z,
-        ], ref: ref, visible: false, userData: { intangible: true }, children: _jsx("boxGeometry", { args: [0.15, 0.15, 0.15] }) }));
+        ], ref: ref, visible: false, children: _jsx("boxGeometry", { args: [0.15, 0.15, 0.15] }) }));
 });

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

@@ -0,0 +1,12 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { GaesupWorldContext } from "../../../world/context";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { WrapperRef } from "../common/WrapperRef";
+import { VehicleCollider } from "./collider";
+import { Wheels } from "./wheels";
+export function VehicleRef(_a) {
+    var props = _a.props, refs = _a.refs;
+    var _b = useContext(GaesupWorldContext), url = _b.url, characterGltf = _b.characterGltf, vehicleGltf = _b.vehicleGltf;
+    return (_jsxs(WrapperRef, { props: props, refs: refs, gltf: vehicleGltf, outerChildren: url.wheelUrl ? _jsx(Wheels, { props: props }) : _jsx(_Fragment, {}), children: [props.isRider && (_jsx(InnerGroupRef, { props: props, gltf: characterGltf, ref: refs.characterInnerRef })), _jsx(VehicleCollider, {})] }));
+}

package/dist/gaesup/component/{ref → active}/vehicle/wheel.d.ts

@@ -1,6 +1,7 @@
 import { RapierRigidBody } from "@react-three/rapier";
 import { RefObject } from "react";
 export type wheelRegidBodyType = {
+    index: number;
     wheelPosition: [number, number, number];
     bodyRef: RefObject<RapierRigidBody>;
     wheel: RefObject<RapierRigidBody>;

package/dist/gaesup/component/{ref → active}/vehicle/wheel.js

@@ -1,12 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Gltf } from "@react-three/drei";
 import { CylinderCollider, RigidBody, useRevoluteJoint, } from "@react-three/rapier";
-import { forwardRef, useContext } from "react";
+import { forwardRef, useContext, useRef } from "react";
 import { GaesupWorldContext } from "../../../world/context";
 export var WheelRegidBodyRef = forwardRef(function (_a, ref) {
-    var wheelPosition = _a.wheelPosition, bodyRef = _a.bodyRef, wheel = _a.wheel, bodyAnchor = _a.bodyAnchor, wheelAnchor = _a.wheelAnchor, rotationAxis = _a.rotationAxis;
+    var index = _a.index, wheelPosition = _a.wheelPosition, bodyRef = _a.bodyRef, wheel = _a.wheel, bodyAnchor = _a.bodyAnchor, wheelAnchor = _a.wheelAnchor, rotationAxis = _a.rotationAxis;
     var _b = useContext(GaesupWorldContext), collider = _b.vehicleCollider, url = _b.url;
     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: url.wheelUrl })] }));
+    var colliderRef = useRef(null);
+    return (_jsxs(RigidBody, { position: wheelPosition, colliders: false, ref: ref, userData: { intangible: true }, children: [_jsx(CylinderCollider, { args: [wheelSizeX / 2, wheelSizeY / 2], rotation: [0, 0, Math.PI / 2], ref: colliderRef }), _jsx(Gltf, { src: url.wheelUrl })] }));
 });

package/dist/gaesup/component/{ref → active}/vehicle/wheels.d.ts

@@ -1,4 +1,7 @@
 import { controllerInnerType } from "../../../controller/type";
+export type useSetWheelType = {
+    wheelPositions: [number, number, number][];
+};
 export declare function Wheels({ props }: {
     props: controllerInnerType;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/{ref → active}/vehicle/wheels.js

@@ -18,5 +18,5 @@ export function Wheels(_a) {
         [X, 0, -Z],
     ];
     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)); }) }));
+    return (_jsx(_Fragment, { children: wheelPositions.map(function (wheelPosition, index) { return (_jsx(WheelRegidBodyRef, { index: index, 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/index.d.ts

@@ -1,4 +1,6 @@
 import { controllerInnerType, refsType } from "../controller/type";
+import { gaesupPassivePropsType } from "../hooks/useGaesupController";
+export declare function GaesupPassiveComponent(props: gaesupPassivePropsType): import("react/jsx-runtime").JSX.Element;
 export declare function GaesupComponent({ props, refs, }: {
     props: controllerInnerType;
     refs: refsType;

package/dist/gaesup/component/index.js

@@ -1,11 +1,20 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useContext } from "react";
+import calculation from "../physics";
 import { GaesupWorldContext } from "../world/context";
-import { Airplane } from "./mode/Airplane";
-import { Character } from "./mode/Character";
-import { Vehicle } from "./mode/Vehicle";
+import { AirplaneRef } from "./active/airplane";
+import { CharacterRef } from "./active/character";
+import { VehicleRef } from "./active/vehicle";
+import { PassiveAirplane } from "./passive/airplane";
+import { PassiveCharacter } from "./passive/character";
+import { PassiveVehicle } from "./passive/vehicle";
+export function GaesupPassiveComponent(props) {
+    var mode = props.mode;
+    return (_jsxs(_Fragment, { children: [mode.type === "character" && _jsx(PassiveCharacter, { props: props }), mode.type === "vehicle" && _jsx(PassiveVehicle, { props: props }), mode.type === "airplane" && _jsx(PassiveAirplane, { props: props })] }));
+}
 export function GaesupComponent(_a) {
     var props = _a.props, refs = _a.refs;
     var mode = useContext(GaesupWorldContext).mode;
-    return (_jsxs(_Fragment, { children: [mode.type === "character" && _jsx(Character, { props: props, refs: refs }), mode.type === "vehicle" && _jsx(Vehicle, { props: props, refs: refs }), mode.type === "airplane" && _jsx(Airplane, { props: props, refs: refs })] }));
+    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 })] }));
 }

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

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