gaesup-world 0.6.1 → 0.6.31

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

@@ -0,0 +1,50 @@
+import { Ref } from "react";
+import * as THREE 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;
+};
+export type playResultType = {
+    actions: actionsType;
+    ref: Ref<Object3D<Object3DEventMap>>;
+};
+export declare function subscribeActions({ type, groundRay, animations, }: subscribeActionsType): {
+    animationResult: {
+        ref: import("react").MutableRefObject<THREE.Object3D<THREE.Object3DEventMap>>;
+        clips: THREE.AnimationClip[];
+        mixer: THREE.AnimationMixer;
+        names: string[];
+        actions: {
+            [x: string]: THREE.AnimationAction;
+        };
+    };
+};
+export default function playActions({ type, animationResult, currentAnimation, }: playActionsType): {
+    animationRef: import("react").MutableRefObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    currentAnimation: string;
+};
+export declare const setAnimation: ({ currentAnimation, actions, type, }: {
+    currentAnimation?: string;
+    actions?: actionsType;
+    type?: "character" | "vehicle" | "airplane";
+}) => void;

package/dist/gaesup/animation/actions.js

@@ -0,0 +1,123 @@
+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 } 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 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([
+            {
+                tag: "walk",
+                condition: function () { return !states.isRunning && states.isMoving; },
+                action: function () { },
+                animationName: "walk",
+                key: "walk",
+            },
+            {
+                tag: "run",
+                condition: function () { return states.isRunning; },
+                action: function () { },
+                animationName: "run",
+                key: "run",
+            },
+            {
+                tag: "jump",
+                condition: function () { return states.isJumping; },
+                action: function () { },
+                animationName: "jump",
+                key: "jump",
+            },
+            {
+                tag: "fall",
+                condition: function () { return groundRay.hit === null && activeState.velocity.y < 0; },
+                action: function () { },
+                animationName: "fall",
+                key: "fall",
+            },
+            {
+                tag: "ride",
+                condition: function () { return states.isPush["keyR"]; },
+                action: function () { },
+                animationName: "ride",
+                key: "ride",
+            },
+        ]);
+    }, []);
+    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, block = _c.block;
+    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: {
+                animationState: __assign({}, animationState),
+            },
+        });
+    };
+    useEffect(function () {
+        var _a;
+        var animation = "idle";
+        if (block.animation) {
+            animation = "idle";
+        }
+        else if (currentAnimation) {
+            animation = currentAnimation;
+        }
+        else if (animationState[type].current) {
+            animation = animationState[type].current;
+        }
+        var action = (_a = actions[animation]) === 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);
+        };
+    }, [currentAnimation, mode.type, block.animation]);
+    useFrame(function () {
+        if (!currentAnimation) {
+            var tag = notify();
+            play(tag);
+        }
+    });
+    return {
+        animationRef: ref,
+        currentAnimation: (_b = animationState === null || animationState === void 0 ? void 0 : animationState[type]) === null || _b === void 0 ? void 0 : _b.current,
+    };
+}
+export var setAnimation = function (_a) {
+    var currentAnimation = _a.currentAnimation, actions = _a.actions, type = _a.type;
+    useEffect(function () {
+        var _a;
+        var action = (_a = actions[currentAnimation]) === 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);
+        };
+    }, [currentAnimation, type]);
+};

package/dist/gaesup/camera/control/normal.d.ts

@@ -0,0 +1,4 @@
+import { cameraPropType } from "../../physics/type";
+import { activeStateType, cameraOptionType } from "../../world/context/type";
+export declare const makeNormalCameraPosition: (activeState: activeStateType, cameraOption: cameraOptionType) => import("three").Vector3;
+export default function normal(prop: cameraPropType): void;

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

@@ -0,0 +1,18 @@
+import { V3 } from "../../utils/vector";
+export var makeNormalCameraPosition = function (activeState, cameraOption) {
+    var YDistance = cameraOption.YDistance, ZDistance = cameraOption.ZDistance;
+    var cameraPosition = activeState.position
+        .clone()
+        .add(V3(0, YDistance, ZDistance));
+    return cameraPosition;
+};
+export default function normal(prop) {
+    var delta = prop.delta, state = prop.state, _a = prop.worldContext, activeState = _a.activeState, cameraOption = _a.cameraOption;
+    if (!state || !state.camera)
+        return;
+    // const cameraPosition = activeState.position
+    //   .clone()
+    //   .add(V3(0, cameraOption.YDistance, cameraOption.ZDistance));
+    state.camera.position.lerp(cameraOption.position.clone(), 1);
+    state.camera.lookAt(cameraOption.target);
+}

package/dist/gaesup/camera/control/orbit.d.ts

@@ -0,0 +1,4 @@
+import { cameraPropType } from "../../physics/type";
+import { activeStateType, cameraOptionType } from "../../world/context/type";
+export declare const makeOrbitCameraPosition: (activeState: activeStateType, cameraOption: cameraOptionType) => import("three").Vector3;
+export default function orbit(prop: cameraPropType): void;

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

@@ -0,0 +1,22 @@
+import { quat } from "@react-three/rapier";
+import { V3 } from "../../utils/vector";
+export var makeOrbitCameraPosition = function (activeState, cameraOption) {
+    var XDistance = cameraOption.XDistance, YDistance = cameraOption.YDistance, ZDistance = cameraOption.ZDistance;
+    var cameraPosition = activeState.position.clone().add(V3(Math.sin(activeState.euler.y), 1, Math.cos(activeState.euler.y))
+        .normalize()
+        .clone()
+        .multiply(V3(-XDistance, YDistance, -ZDistance)));
+    return cameraPosition;
+};
+export default function orbit(prop) {
+    var state = prop.state, _a = prop.worldContext, activeState = _a.activeState, cameraOption = _a.cameraOption;
+    if (!state || !state.camera)
+        return;
+    var cameraPosition = makeOrbitCameraPosition(activeState, cameraOption);
+    state.camera.position.lerp(cameraPosition, 1);
+    state.camera.quaternion.copy(activeState.quat
+        .clone()
+        .multiply(quat().setFromAxisAngle(V3(0, 1, 0), Math.PI)));
+    state.camera.rotation.copy(activeState.euler);
+    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.d.ts

@@ -0,0 +1,8 @@
+import { controllerInnerType, refsType } from "../controller/type";
+export default function Camera({ refs, prop, control, }: {
+    refs: refsType;
+    prop: controllerInnerType;
+    control: {
+        [key: string]: boolean;
+    };
+}): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/camera/index.js

@@ -0,0 +1,99 @@
+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 } from "react/jsx-runtime";
+import { CameraControls } from "@react-three/drei";
+import { useFrame, useThree } from "@react-three/fiber";
+import { vec3 } from "@react-three/rapier";
+import { useContext, useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { GaesupControllerContext } from "../controller/context";
+import { GaesupWorldContext } from "../world/context";
+import normal, { makeNormalCameraPosition } from "./control/normal";
+import orbit from "./control/orbit";
+export default function Camera(_a) {
+    var refs = _a.refs, prop = _a.prop, control = _a.control;
+    var worldContext = useContext(GaesupWorldContext);
+    var controllerContext = useContext(GaesupControllerContext);
+    var mode = worldContext.mode, cameraOption = worldContext.cameraOption, activeState = worldContext.activeState;
+    var rigidBodyRef = refs.rigidBodyRef, outerGroupRef = refs.outerGroupRef;
+    var camera = useThree().camera;
+    var cameraRef = useRef();
+    var intersectObjectMap = useMemo(function () { return ({}); }, []);
+    var cameraProp = __assign(__assign({}, prop), { control: control, controllerContext: controllerContext, worldContext: worldContext, intersectObjectMap: intersectObjectMap });
+    var position = useMemo(function () { return camera.position; }, []);
+    var dir = useMemo(function () { return vec3(); }, []);
+    cameraProp.cameraRay.rayCast = new THREE.Raycaster(cameraProp.cameraRay.origin, cameraProp.cameraRay.dir, 0, -cameraOption.maxDistance);
+    useEffect(function () {
+        cameraProp.cameraRay.origin.copy(position);
+        cameraProp.cameraRay.dir.copy(camera.getWorldDirection(dir));
+    }, [cameraProp]);
+    useFrame(function (state, delta) {
+        if (!rigidBodyRef ||
+            !rigidBodyRef.current ||
+            !outerGroupRef ||
+            !outerGroupRef.current)
+            return;
+        cameraProp.delta = delta;
+        cameraProp.state = state;
+        if (!worldContext.block.camera) {
+            if (mode.control === "orbit") {
+                orbit(cameraProp);
+            }
+            else if (mode.control === "normal") {
+                normal(cameraProp);
+            }
+            // detector(cameraProp);
+        }
+    });
+    // zoom
+    useEffect(function () {
+        if (cameraRef.current) {
+            cameraRef.current.zoomTo(worldContext.cameraOption.zoom, true);
+        }
+    }, [worldContext.cameraOption.zoom]);
+    // 포커스가 아닐 때 카메라 activeStae 따라가기
+    useFrame(function () {
+        if (!cameraOption.focus) {
+            cameraOption.target = activeState.position;
+            cameraOption.position = makeNormalCameraPosition(activeState, cameraOption);
+        }
+    });
+    // lookat
+    // useEffect(() => {
+    //   if (cameraRef.current) {
+    //     const currentCamera = camera.position.clone();
+    //     if (cameraOption.focus) {
+    //       cameraRef.current.setLookAt(
+    //         currentCamera.x,
+    //         currentCamera.y,
+    //         currentCamera.z,
+    //         cameraOption.target.x,
+    //         cameraOption.target.y,
+    //         cameraOption.target.z,
+    //         true
+    //       );
+    //       // 포커스 품
+    //     } else if (!cameraOption.focus) {
+    //       cameraRef.current.setLookAt(
+    //         currentCamera.x,
+    //         currentCamera.y,
+    //         currentCamera.z,
+    //         activeState.position.x,
+    //         activeState.position.y,
+    //         activeState.position.z,
+    //         true
+    //       );
+    //     }
+    //   }
+    // }, [cameraOption.focus]);
+    return _jsx(CameraControls, { ref: cameraRef });
+}

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

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+export type cameraRayType = {
+    origin: THREE.Vector3;
+    hit: THREE.Raycaster;
+    rayCast: THREE.Raycaster | null;
+    length: number;
+    dir: THREE.Vector3;
+    position: THREE.Vector3;
+    intersects: THREE.Intersection<THREE.Mesh>[];
+    detected: THREE.Intersection<THREE.Mesh>[];
+    intersectObjectMap: {
+        [uuid: string]: THREE.Mesh;
+    };
+};

package/dist/gaesup/camera/type.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import * as THREE from "three";
+import { controllerInnerType, groundRayType, refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function AirplaneRef({ children, props, groundRay, enableRiding, isRiderOn, offset, refs, urls, }: {
+    children: ReactNode;
+    props: controllerInnerType;
+    groundRay: groundRayType;
+    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

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+import playActions, { subscribeActions } from "../../../animation/actions";
+import initCallback from "../../../controller/initialize/callback";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { AirplaneInnerRef } from "../../inner/airplane";
+import { setGroundRay } from "../../inner/common/setGroundRay";
+export function AirplaneRef(_a) {
+    var children = _a.children, props = _a.props, 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 * 5,
+        z: 0,
+    });
+    setGroundRay({
+        groundRay: groundRay,
+        length: size.y * 5,
+        colliderRef: colliderRef,
+    });
+    var animationResult = subscribeActions({
+        type: "airplane",
+        groundRay: groundRay,
+        animations: gltf.animations,
+    }).animationResult;
+    var currentAnimation = playActions({
+        type: "airplane",
+        animationResult: animationResult,
+    }).currentAnimation;
+    // callback
+    initCallback({
+        props: props,
+        animationResult: animationResult,
+        type: "airplane",
+    });
+    return (_jsx(AirplaneInnerRef, { refs: refs, urls: urls, isRiderOn: isRiderOn, enableRiding: enableRiding, offset: offset, currentAnimation: currentAnimation, children: children }));
+}

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

@@ -0,0 +1,7 @@
+import { controllerInnerType, refsType } from "../../../controller/type";
+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

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+import playActions, { subscribeActions } from "../../../animation/actions";
+import initCallback from "../../../controller/initialize/callback";
+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, urls = _a.urls;
+    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,
+        length: ((collider === null || collider === void 0 ? void 0 : collider.height) || 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;
+    // callback
+    initCallback({
+        props: props,
+        animationResult: animationResult,
+        type: "character",
+    });
+    return (_jsx(CharacterInnerRef, { animationRef: animationRef, refs: refs, urls: urls, currentAnimation: currentAnimation, children: props.children }));
+}

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

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import * as THREE from "three";
+import { controllerInnerType, groundRayType, refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function VehicleRef({ children, props, groundRay, enableRiding, isRiderOn, offset, refs, urls, }: {
+    children: ReactNode;
+    props: controllerInnerType;
+    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

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+import playActions, { subscribeActions } from "../../../animation/actions";
+import initCallback from "../../../controller/initialize/callback";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { setGroundRay } from "../../inner/common/setGroundRay";
+import { VehicleInnerRef } from "../../inner/vehicle";
+export function VehicleRef(_a) {
+    var children = _a.children, props = _a.props, 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 currentAnimation = playActions({
+        type: "vehicle",
+        animationResult: animationResult,
+    }).currentAnimation;
+    // callback
+    initCallback({
+        props: props,
+        animationResult: animationResult,
+        type: "vehicle",
+    });
+    return (_jsx(VehicleInnerRef, { refs: refs, urls: urls, isRiderOn: isRiderOn, enableRiding: enableRiding, offset: offset, currentAnimation: currentAnimation, children: children }));
+}

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

@@ -0,0 +1,7 @@
+import { controllerInnerType, refsType } from "../controller/type";
+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

@@ -0,0 +1,19 @@
+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";
+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, 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, urls: urls })), mode.type === "vehicle" && (_jsx(VehicleRef, { props: props, 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, { props: props, groundRay: props.groundRay, 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, type, }: 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, type = _a.type;
+    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, type: type, 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,29 @@
+import { refsType } from "../../../controller/type";
+import { RigidBodyTypeString } from "@react-three/rapier";
+import { ReactNode, Ref } from "react";
+import * as THREE from "three";
+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, positionLerp, type, }: {
+    children: ReactNode;
+    refs: Partial<refsType>;
+    urls: urlsType;
+    position?: THREE.Vector3;
+    euler?: THREE.Euler;
+    animationRef?: Ref<Object3D<Object3DEventMap>>;
+    currentAnimation?: string;
+    positionLerp?: number;
+    type?: RigidBodyTypeString;
+}): 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, positionLerp = _a.positionLerp, type = _a.type;
+    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 && (_jsx(OuterGroupRef, { ref: outerGroupRef, children: _jsxs(RigidBodyRef, { ref: rigidBodyRef, name: "character", position: position, positionLerp: positionLerp, rotation: euler, type: type, 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, children: children })] }) })) }));
+}