gaesup-world 0.2.24 → 0.2.26

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

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useGraph } from "@react-three/fiber";
+import { Suspense, forwardRef, useMemo } from "react";
+import * as THREE from "three";
+import { SkeletonUtils } from "three-stdlib";
+import { useAnimations, useGLTF } from "@react-three/drei";
+import playActions from "../../../animation/actions";
+export var InnerGroupRef = forwardRef(function (_a, ref) {
+    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 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: [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/inner/common/OuterGroupRef.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+export declare const OuterGroupRef: import("react").ForwardRefExoticComponent<{
+    children: ReactNode;
+} & import("react").RefAttributes<import("three").Group<import("three").Object3DEventMap>>>;

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

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+export var OuterGroupRef = forwardRef(function (_a, ref) {
+    var children = _a.children;
+    return (_jsx("group", { ref: ref, userData: { intangible: true }, children: children }));
+});

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

@@ -0,0 +1,12 @@
+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/common/type.js

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

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>>;

package/dist/gaesup/component/inner/vehicle/collider.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CuboidCollider } from "@react-three/rapier";
+import { forwardRef } from "react";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+export var VehicleWheelCollider = forwardRef(function (_a, ref) {
+    var urls = _a.urls, vehicleSize = _a.vehicleSize;
+    var wheelSize = useGltfAndSize({
+        url: urls.wheelUrl,
+    }).size;
+    return (_jsx(CuboidCollider, { ref: ref, args: [
+            vehicleSize.x / 2,
+            vehicleSize.y / 2 - wheelSize.y / 2,
+            vehicleSize.z / 2,
+        ], position: [0, vehicleSize.y / 2 + wheelSize.y / 2, 0] }));
+});
+export var VehicleCollider = forwardRef(function (_a, ref) {
+    var vehicleSize = _a.vehicleSize;
+    return (_jsx(CuboidCollider, { ref: ref, args: [vehicleSize.x / 2, vehicleSize.y / 2, vehicleSize.z / 2], position: [0, vehicleSize.y / 2, 0] }));
+});

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

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

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

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { InnerGroupRef } from "../common/InnerGroupRef";
+import { OuterGroupRef } from "../common/OuterGroupRef";
+import { RigidBodyRef } from "../common/RigidbodyRef";
+import RiderRef from "../rider";
+import { VehicleCollider, VehicleWheelCollider } from "./collider";
+import { WheelsRef } from "./wheels";
+export function VehicleInnerRef(_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, currentAnimation = _a.currentAnimation, onCollisionEnter = _a.onCollisionEnter;
+    var vehicleUrl = urls.vehicleUrl, wheelUrl = urls.wheelUrl;
+    var rigidBodyRef = refs.rigidBodyRef, innerGroupRef = refs.innerGroupRef, outerGroupRef = refs.outerGroupRef;
+    var vehicleSize = useGltfAndSize({
+        url: urls.vehicleUrl,
+    }).size;
+    return (_jsxs(OuterGroupRef, { ref: outerGroupRef, children: [vehicleUrl && rigidBodyRef && (_jsxs(RigidBodyRef, { ref: rigidBodyRef, name: name, position: position, rotation: rotation, userData: userData, onCollisionEnter: onCollisionEnter, children: [wheelUrl ? (_jsx(VehicleWheelCollider, { urls: urls, vehicleSize: vehicleSize })) : (_jsx(VehicleCollider, { vehicleSize: vehicleSize })), enableRiding && isRiderOn && urls.characterUrl && (_jsx(RiderRef, { urls: urls, offset: offset })), children, _jsx(InnerGroupRef, { type: "vehicle", url: vehicleUrl, currentAnimation: currentAnimation, ref: innerGroupRef })] })), wheelUrl && (_jsx(WheelsRef, { refs: refs, urls: urls, vehicleSize: vehicleSize }))] }));
+}

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

@@ -0,0 +1,7 @@
+import { refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function WheelsRef({ vehicleSize, refs, urls, }: {
+    vehicleSize: THREE.Vector3;
+    refs: Partial<refsType>;
+    urls: urlsType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/component/inner/vehicle/wheels.js

@@ -0,0 +1,64 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Gltf } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { CylinderCollider, RigidBody, useRevoluteJoint, } from "@react-three/rapier";
+import { createRef, useContext, useRef } from "react";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { GaesupWorldContext } from "../../../world/context";
+var WheelJoint = function (_a) {
+    var body = _a.body, wheel = _a.wheel, bodyAnchor = _a.bodyAnchor, wheelAnchor = _a.wheelAnchor, rotationAxis = _a.rotationAxis;
+    var joint = useRevoluteJoint(body, wheel, [
+        bodyAnchor,
+        wheelAnchor,
+        rotationAxis,
+    ]);
+    var activeState = useContext(GaesupWorldContext).activeState;
+    useFrame(function () {
+        if (joint.current) {
+            joint.current.configureMotorPosition(activeState.position.length(), 0.8, 0);
+        }
+    });
+    return null;
+};
+export function WheelsRef(_a) {
+    var vehicleSize = _a.vehicleSize, refs = _a.refs, urls = _a.urls;
+    var wheelUrl = urls.wheelUrl;
+    var rigidBodyRef = refs.rigidBodyRef;
+    var wheelSize = useGltfAndSize({
+        url: urls.wheelUrl,
+    }).size;
+    var X = (vehicleSize.x - wheelSize.x) / 2;
+    var Z = (vehicleSize.z - 2 * wheelSize.z) / 2;
+    var wheelPositions = [
+        [-X, 0, Z],
+        [-X, 0, -Z],
+        [X, 0, Z],
+        [X, 0, -Z],
+    ];
+    var wheelRefs = useRef(wheelPositions.map(function () { return createRef(); }));
+    return (_jsxs(_Fragment, { children: [rigidBodyRef &&
+                wheelUrl &&
+                wheelRefs &&
+                wheelPositions.map(function (wheelPosition, index) {
+                    if (!wheelRefs ||
+                        !wheelRefs.current ||
+                        !wheelRefs.current[index] ||
+                        !wheelSize.x ||
+                        !wheelSize.y)
+                        return _jsx(_Fragment, {});
+                    var wheelRef = wheelRefs.current[index];
+                    return (_jsxs(RigidBody, { position: wheelPosition, colliders: false, type: "dynamic", ref: wheelRef, rotation: [0, 0, Math.PI / 2], children: [_jsx(CylinderCollider, { rotation: [0, 0, Math.PI / 2], args: [wheelSize.x / 2, wheelSize.y / 2] }), _jsx(Gltf, { src: wheelUrl })] }, index));
+                }), rigidBodyRef &&
+                wheelUrl &&
+                wheelRefs &&
+                wheelPositions.map(function (wheelPosition, index) {
+                    if (!wheelRefs ||
+                        !wheelRefs.current ||
+                        !wheelRefs.current[index] ||
+                        !wheelSize.x ||
+                        !wheelSize.y)
+                        return _jsx(_Fragment, {});
+                    var wheelRef = wheelRefs.current[index];
+                    return (_jsx(WheelJoint, { body: rigidBodyRef, wheel: wheelRef, bodyAnchor: wheelPosition, wheelAnchor: [0, 0, 0], rotationAxis: [1, 0, 0] }, index));
+                })] }));
+}

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { CollisionEnterPayload } from "@react-three/rapier";
+import { urlsType } from "../../../world/context/type";
+export type passiveAirplanePropsType = {
+    position: THREE.Vector3;
+    euler: THREE.Euler;
+    urls: urlsType;
+    currentAnimation: string;
+    offset?: THREE.Vector3;
+    children?: React.ReactNode;
+    onCollisionEnter?: (e: CollisionEnterPayload) => Promise<void>;
+};
+export declare function PassiveAirplane(props: passiveAirplanePropsType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { quat, } from "@react-three/rapier";
+import { useMemo, useRef } from "react";
+import { AirplaneInnerRef } from "../../inner/airplane";
+export function PassiveAirplane(props) {
+    var rigidBodyRef = useRef(null);
+    var outerGroupRef = useRef(null);
+    var innerGroupRef = useRef(null);
+    var colliderRef = useRef(null);
+    var refs = {
+        rigidBodyRef: rigidBodyRef,
+        outerGroupRef: outerGroupRef,
+        innerGroupRef: innerGroupRef,
+        colliderRef: colliderRef,
+    };
+    var _a = useMemo(function () {
+        return {
+            position: props.position,
+            euler: props.euler,
+            currentAnimation: props.currentAnimation,
+            urls: props.urls,
+        };
+    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation, urls = _a.urls;
+    useFrame(function () {
+        if (innerGroupRef && innerGroupRef.current) {
+            var _euler = euler.clone();
+            _euler.y = 0;
+            innerGroupRef.current.setRotationFromQuaternion(quat()
+                .setFromEuler(innerGroupRef.current.rotation.clone())
+                .slerp(quat().setFromEuler(_euler), 0.2));
+        }
+        if (rigidBodyRef && rigidBodyRef.current) {
+            rigidBodyRef.current.setGravityScale(props.position.y < 10
+                ? ((1 - 0.1) / (0 - 10)) * props.position.y + 1
+                : 0.1, false);
+        }
+    });
+    return (_jsx(AirplaneInnerRef, { refs: refs, urls: urls, position: position, rotation: euler, userData: { intangible: true }, onCollisionEnter: props.onCollisionEnter, currentAnimation: props.currentAnimation, children: props.children }));
+}

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { urlsType } from "../../../world/context/type";
+export type passiveCharacterPropsType = {
+    position: THREE.Vector3;
+    euler: THREE.Euler;
+    urls: urlsType;
+    currentAnimation: string;
+    children?: React.ReactNode;
+};
+export declare function PassiveCharacter(props: passiveCharacterPropsType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAnimations } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { quat } from "@react-three/rapier";
+import { useEffect, useMemo, useRef } from "react";
+import playActions from "../../../animation/actions";
+import { useGltfAndSize } from "../../../hooks/useGaesupGltf";
+import { CharacterInnerRef } from "../../inner/character";
+export function PassiveCharacter(props) {
+    var rigidBodyRef = useRef(null);
+    var outerGroupRef = useRef(null);
+    var innerGroupRef = useRef(null);
+    var colliderRef = useRef(null);
+    var refs = {
+        rigidBodyRef: rigidBodyRef,
+        outerGroupRef: outerGroupRef,
+        innerGroupRef: innerGroupRef,
+        colliderRef: colliderRef,
+    };
+    var _a = useMemo(function () {
+        return {
+            position: props.position,
+            euler: props.euler,
+            currentAnimation: props.currentAnimation,
+            characterUrl: props.urls.characterUrl,
+        };
+    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation;
+    useEffect(function () {
+        if (rigidBodyRef || rigidBodyRef.current) {
+            rigidBodyRef.current.setEnabledRotations(false, false, false, false);
+        }
+    }, []);
+    useFrame(function (_, delta) {
+        if (innerGroupRef && innerGroupRef.current) {
+            innerGroupRef.current.quaternion.rotateTowards(quat().setFromEuler(euler), 10 * delta);
+        }
+    });
+    var gltf = useGltfAndSize({ url: props.urls.characterUrl }).gltf;
+    var animationResult = useAnimations(gltf.animations);
+    var animationRef = playActions({
+        type: "character",
+        animationResult: animationResult,
+        currentAnimation: currentAnimation,
+    }).animationRef;
+    return (_jsx(CharacterInnerRef, { animationRef: animationRef, position: position, refs: refs, urls: props.urls, children: props.children }));
+}

package/dist/gaesup/component/passive/type.d.ts

@@ -0,0 +1,20 @@
+import { gaesupPassivePropsType } from "../../hooks/useGaesupController";
+import { activeStateType, modeType, wheelsStateType } from "../../world/context/type";
+export type passiveComponentType = {
+    props: gaesupPassivePropsType;
+};
+export type passiveCharacterType = {
+    mode: modeType;
+    state: activeStateType;
+    current: string;
+    url: string;
+};
+export type passiveVehicleType = {
+    mode: modeType;
+    state: activeStateType;
+    wheelsState?: wheelsStateType;
+    wheelPositions?: number[][];
+    current: string;
+    url: string;
+    wheelUrl?: string;
+};

package/dist/gaesup/component/passive/type.js

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

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { CollisionEnterPayload } from "@react-three/rapier";
+import { urlsType } from "../../../world/context/type";
+export type passiveVehiclePropsType = {
+    position: THREE.Vector3;
+    euler: THREE.Euler;
+    urls: urlsType;
+    currentAnimation: string;
+    children?: React.ReactNode;
+    offset?: THREE.Vector3;
+    onCollisionEnter?: (e: CollisionEnterPayload) => Promise<void>;
+};
+export declare function PassiveVehicle(props: passiveVehiclePropsType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRef } from "react";
+import { VehicleInnerRef } from "../../inner/vehicle";
+export function PassiveVehicle(props) {
+    var rigidBodyRef = useRef(null);
+    var outerGroupRef = useRef(null);
+    var innerGroupRef = useRef(null);
+    var colliderRef = useRef(null);
+    var refs = {
+        rigidBodyRef: rigidBodyRef,
+        outerGroupRef: outerGroupRef,
+        innerGroupRef: innerGroupRef,
+        colliderRef: colliderRef,
+    };
+    var position = props.position, euler = props.euler, currentAnimation = props.currentAnimation, urls = props.urls;
+    return (_jsx(VehicleInnerRef, { refs: refs, urls: urls, position: position, rotation: euler, userData: { intangible: true }, onCollisionEnter: props.onCollisionEnter, currentAnimation: currentAnimation, children: props.children }));
+}

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

@@ -0,0 +1,17 @@
+import { ObjectMap } from "@react-three/fiber";
+import { RapierRigidBody } from "@react-three/rapier";
+import { RefObject } from "react";
+import { GLTF } from "three-stdlib";
+export type GLTFResult = GLTF & {
+    nodes: {
+        [name: string]: THREE.Mesh | THREE.SkinnedMesh;
+    };
+    materials: {
+        [name: string]: THREE.Material | THREE.MeshStandardMaterial;
+    };
+} & ObjectMap;
+export type passiveRefsType = {
+    rigidBodyRef: RefObject<RapierRigidBody>;
+    outerGroupRef: RefObject<THREE.Group>;
+    innerGroupRef: RefObject<THREE.Group>;
+};

package/dist/gaesup/component/type.js

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

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

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import { dispatchType } from "../../utils/type";
+import { gaesupControllerType } from "./type";
+export declare const gaesupControllerDefault: {
+    airplane: {
+        angleDelta: import("three").Vector3;
+        maxAngle: import("three").Vector3;
+        maxSpeed: number;
+        accelRatio: number;
+        brakeRatio: number;
+        buoyancy: number;
+        linearDamping: number;
+    };
+    vehicle: {
+        maxSpeed: number;
+        accelRatio: number;
+        brakeRatio: number;
+        wheelOffset: number;
+        linearDamping: number;
+    };
+    character: {
+        walkSpeed: number;
+        runSpeed: number;
+        turnSpeed: number;
+        jumpSpeed: number;
+        linearDamping: number;
+    };
+    callbacks: {
+        onReady: () => void;
+        onFrame: () => void;
+        onDestory: () => void;
+        onAnimate: () => void;
+    };
+    refs: {
+        colliderRef: any;
+        rigidBodyRef: any;
+        outerGroupRef: any;
+        innerGroupRef: any;
+        characterInnerRef: any;
+    };
+    urls: {
+        airplaneUrl: any;
+        vehicleUrl: any;
+        characterUrl: any;
+        wheelUrl: any;
+    };
+};
+export declare const GaesupControllerContext: import("react").Context<gaesupControllerType>;
+export declare const GaesupControllerDispatchContext: import("react").Context<dispatchType<gaesupControllerType>>;

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

@@ -0,0 +1,59 @@
+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 { createContext } from "react";
+import { V3 } from "../../utils/vector";
+export var gaesupControllerDefault = {
+    airplane: {
+        angleDelta: V3(Math.PI / 256, Math.PI / 256, Math.PI / 256),
+        maxAngle: V3(Math.PI / 8, Math.PI / 8, Math.PI / 8),
+        maxSpeed: 60,
+        accelRatio: 2,
+        brakeRatio: 5,
+        buoyancy: 0.2,
+        linearDamping: 1,
+    },
+    vehicle: {
+        maxSpeed: 60,
+        accelRatio: 2,
+        brakeRatio: 5,
+        wheelOffset: 0.1,
+        linearDamping: 0.5,
+    },
+    character: {
+        walkSpeed: 10,
+        runSpeed: 20,
+        turnSpeed: 10,
+        jumpSpeed: 1,
+        linearDamping: 1,
+    },
+    callbacks: {
+        onReady: function () { },
+        onFrame: function () { },
+        onDestory: function () { },
+        onAnimate: function () { },
+    },
+    refs: {
+        colliderRef: null,
+        rigidBodyRef: null,
+        outerGroupRef: null,
+        innerGroupRef: null,
+        characterInnerRef: null,
+    },
+    urls: {
+        airplaneUrl: null,
+        vehicleUrl: null,
+        characterUrl: null,
+        wheelUrl: null,
+    },
+};
+export var GaesupControllerContext = createContext(__assign({}, gaesupControllerDefault));
+export var GaesupControllerDispatchContext = createContext(null);

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

@@ -0,0 +1,12 @@
+import { gaesupControllerType } from "./type";
+export declare function gaesupControllerReducer(props: gaesupControllerType, action: {
+    type: string;
+    payload?: Partial<gaesupControllerType>;
+}): {
+    airplane: import("./type").airplaneType;
+    vehicle: import("./type").vehicleType;
+    character: import("./type").characterType;
+    urls: import("../../world/context/type").urlsType;
+    callbacks?: import("../initialize/callback/type").callbackType;
+    refs?: import("../type").refsType;
+};

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

@@ -0,0 +1,21 @@
+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);
+};
+export function gaesupControllerReducer(props, action) {
+    switch (action.type) {
+        case "init": {
+            return __assign({}, props);
+        }
+        case "update": {
+            return __assign(__assign({}, props), action.payload);
+        }
+    }
+}