gaesup-world 0.9.0 → 0.9.5

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

@@ -0,0 +1,37 @@
+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";
+    currentAnimation?: string;
+    actions: actionsType;
+    animationRef: Ref<Object3D<Object3DEventMap>>;
+    isActive: boolean;
+};
+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 }: subscribeActionsType): void;
+export default function playActions({ type, actions, animationRef, currentAnimation, isActive, }: playActionsType): {
+    animationRef: Ref<THREE.Object3D<THREE.Object3DEventMap>>;
+    currentAnimation: string;
+};

package/dist/gaesup/animation/actions.js

@@ -0,0 +1,117 @@
+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 { 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;
+    var states = useContext(GaesupWorldContext).states;
+    var subscribeAll = useGaesupAnimation({ type: type }).subscribeAll;
+    // 초기 기본 애니메이션 등록
+    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: "ride",
+                condition: function () { return states.isPush["keyR"]; },
+                action: function () { },
+                animationName: "ride",
+                key: "ride",
+            },
+            {
+                tag: "land",
+                condition: function () { return states.isLanding; },
+                action: function () { },
+                animationName: "land",
+                key: "land",
+            },
+            {
+                tag: "fall",
+                condition: function () { return states.isFalling; },
+                action: function () { },
+                animationName: "fall",
+                key: "fall",
+            },
+        ]);
+    }, []);
+}
+export default function playActions(_a) {
+    var _b, _c;
+    var type = _a.type, actions = _a.actions, animationRef = _a.animationRef, currentAnimation = _a.currentAnimation, isActive = _a.isActive;
+    var _d = useContext(GaesupWorldContext), mode = _d.mode, animationState = _d.animationState, block = _d.block;
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var _e = useGaesupAnimation({ type: type }), notify = _e.notify, store = _e.store;
+    if (isActive) {
+        currentAnimation = (_b = animationState === null || animationState === void 0 ? void 0 : animationState[type]) === null || _b === void 0 ? void 0 : _b.current;
+    }
+    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, type]);
+    useFrame(function () {
+        if (isActive) {
+            var tag = notify();
+            play(tag);
+        }
+    });
+    return {
+        animationRef: animationRef,
+        currentAnimation: (_c = animationState === null || animationState === void 0 ? void 0 : animationState[type]) === null || _c === void 0 ? void 0 : _c.current,
+    };
+}

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,15 @@
+import { V3 } from "../../utils/vector";
+export var makeNormalCameraPosition = function (activeState, cameraOption) {
+    var XDistance = cameraOption.XDistance, YDistance = cameraOption.YDistance, ZDistance = cameraOption.ZDistance;
+    var cameraPosition = activeState.position
+        .clone()
+        .add(V3(XDistance, YDistance, ZDistance));
+    return cameraPosition;
+};
+export default function normal(prop) {
+    var state = prop.state, cameraOption = prop.worldContext.cameraOption, lerp = prop.controllerOptions.lerp;
+    if (!state || !state.camera)
+        return;
+    state.camera.position.lerp(cameraOption.position.clone(), lerp.cameraPosition);
+    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, lerp = prop.controllerOptions.lerp;
+    if (!state || !state.camera)
+        return;
+    var cameraPosition = makeOrbitCameraPosition(activeState, cameraOption);
+    state.camera.position.lerp(cameraPosition.clone(), lerp.cameraTurn);
+    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/index.d.ts

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

package/dist/gaesup/camera/index.js

@@ -0,0 +1,24 @@
+import { useFrame } from "@react-three/fiber";
+import normal, { makeNormalCameraPosition } from "./control/normal";
+import orbit from "./control/orbit";
+export default function Camera(prop) {
+    useFrame(function (state) {
+        prop.state = state;
+        if (!prop.worldContext.block.camera) {
+            if (prop.worldContext.mode.control === "orbit") {
+                orbit(prop);
+            }
+            else if (prop.worldContext.mode.control === "normal") {
+                normal(prop);
+            }
+        }
+    });
+    // 포커스가 아닐 때 카메라 activeStae 따라가기
+    useFrame(function () {
+        if (!prop.worldContext.cameraOption.focus) {
+            prop.worldContext.cameraOption.target =
+                prop.worldContext.activeState.position;
+            prop.worldContext.cameraOption.position = makeNormalCameraPosition(prop.worldContext.activeState, prop.worldContext.cameraOption);
+        }
+    });
+}

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,2 @@
+import { activeAirplaneInnerType } from "./type";
+export declare function AirplaneRef(props: activeAirplaneInnerType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+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 { AirplaneInnerRef } from "../../inner/airplane";
+export function AirplaneRef(props) {
+    return (_jsx(AirplaneInnerRef, __assign({ name: "airplane", isActive: true, currentAnimation: "idle", componentType: "airplane", ridingUrl: props.ridingUrl }, props, { children: props.children })));
+}

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

@@ -0,0 +1,3 @@
+import { passiveAirplanePropsType } from "../../passive/airplane/type";
+import { innerRefType } from "../../passive/type";
+export type activeAirplaneInnerType = passiveAirplanePropsType & innerRefType;

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

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

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

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

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

@@ -0,0 +1,17 @@
+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 { CharacterInnerRef } from "../../inner/character";
+export function CharacterRef(_a) {
+    var children = _a.children, props = _a.props, refs = _a.refs, urls = _a.urls;
+    return (_jsx(CharacterInnerRef, __assign({ url: urls.characterUrl, isActive: true, componentType: "character", rigidbodyType: "dynamic", controllerOptions: props.controllerOptions, groundRay: props.groundRay, onAnimate: props.onAnimate, onFrame: props.onFrame, onReady: props.onReady, onDestory: props.onDestory, rigidBodyProps: props.rigidBodyProps, parts: props.parts }, refs, { children: children })));
+}

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

@@ -0,0 +1,12 @@
+import { RigidBodyTypeString } from "@react-three/rapier";
+import * as THREE from "three";
+import { controllerOptionsType } from "../../../controller/type";
+export type activeCharacterPropsType = {
+    characterUrl: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    controllerOptions?: controllerOptionsType;
+    currentAnimation?: string;
+    children?: React.ReactNode;
+    rigidbodyType?: RigidBodyTypeString;
+};

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

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

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

@@ -0,0 +1,2 @@
+import { activeVehicleInnerType } from "./type";
+export declare function VehicleRef(props: activeVehicleInnerType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+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 { VehicleInnerRef } from "../../inner/vehicle";
+export function VehicleRef(props) {
+    return (_jsx(VehicleInnerRef, __assign({ name: "vehicle", isActive: true, currentAnimation: "idle", componentType: "vehicle", ridingUrl: props.ridingUrl }, props, { children: props.children })));
+}

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

@@ -0,0 +1,3 @@
+import { innerRefType } from "../../passive/type";
+import { passiveVehiclePropsType } from "../../passive/vehicle/type";
+export type activeVehicleInnerType = passiveVehiclePropsType & innerRefType;

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

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

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

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

package/dist/gaesup/component/index.js

@@ -0,0 +1,28 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { vec3 } from "@react-three/rapier";
+import { useContext } from "react";
+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;
+    var _b = useContext(GaesupWorldContext), mode = _b.mode, states = _b.states, rideable = _b.rideable, urls = _b.urls;
+    var enableRiding = states.enableRiding, isRiderOn = states.isRiderOn, rideableId = states.rideableId;
+    return (_jsxs(_Fragment, { children: [mode.type === "character" && (_jsx(CharacterRef, { props: props, refs: refs, urls: urls, children: props.children })), mode.type === "vehicle" && (_jsx(VehicleRef, __assign({ controllerOptions: props.controllerOptions, url: urls.vehicleUrl, wheelUrl: urls.wheelUrl, ridingUrl: urls.ridingUrl, enableRiding: enableRiding, isRiderOn: isRiderOn, groundRay: props.groundRay, offset: rideableId && rideable[rideableId]
+                    ? rideable[rideableId].offset
+                    : vec3() }, refs, { children: props.children }))), mode.type === "airplane" && (_jsx(AirplaneRef, __assign({ controllerOptions: props.controllerOptions, url: urls.airplaneUrl, ridingUrl: urls.ridingUrl, enableRiding: enableRiding, isRiderOn: isRiderOn, groundRay: props.groundRay, offset: rideableId && rideable[rideableId]
+                    ? rideable[rideableId].offset
+                    : vec3() }, refs, { children: props.children })))] }));
+}

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

@@ -0,0 +1,2 @@
+import { airplaneInnerType } from "./type";
+export declare function AirplaneInnerRef(props: airplaneInnerType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,18 @@
+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 { OuterGroupRef } from "../common/OuterGroupRef";
+import { RigidBodyRef } from "../common/RigidbodyRef";
+export function AirplaneInnerRef(props) {
+    var rigidBodyRef = props.rigidBodyRef, outerGroupRef = props.outerGroupRef;
+    return (_jsx(OuterGroupRef, { ref: outerGroupRef, children: _jsx(RigidBodyRef, __assign({ ref: rigidBodyRef, name: props.name, componentType: "airplane", ridingUrl: props.ridingUrl }, props, { children: props.children })) }));
+}

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

@@ -0,0 +1,5 @@
+import { ridingType, rigidBodyRefType } from "../common/type";
+export type airplaneUrlType = {
+    wheelUrl?: string;
+};
+export type airplaneInnerType = rigidBodyRefType & ridingType & airplaneUrlType;

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

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

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

@@ -0,0 +1,2 @@
+import { characterInnerType } from "./type";
+export declare function CharacterInnerRef(props: characterInnerType): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,18 @@
+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 { OuterGroupRef } from "../common/OuterGroupRef";
+import { RigidBodyRef } from "../common/RigidbodyRef";
+export function CharacterInnerRef(props) {
+    var outerGroupRef = props.outerGroupRef;
+    return (_jsx(OuterGroupRef, { ref: outerGroupRef, children: _jsx(RigidBodyRef, __assign({ name: "character", url: props.url, controllerOptions: props.controllerOptions, ref: props.rigidBodyRef, groundRay: props.groundRay }, props, { children: props.children })) }));
+}

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

@@ -0,0 +1,10 @@
+import { callbackType } from "../../../controller/initialize/callback/type";
+import { groundRayType, partsType } from "../../../controller/type";
+import { passiveCharacterPropsType } from "../../passive/character/type";
+import { componentTypeString, innerRefType } from "../../passive/type";
+export type characterInnerType = {
+    componentType: componentTypeString;
+    isActive?: boolean;
+    groundRay: groundRayType;
+    parts?: partsType;
+} & passiveCharacterPropsType & innerRefType & callbackType;

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

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

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

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+export declare const InnerGroupRef: import("react").ForwardRefExoticComponent<{
+    children?: React.ReactNode;
+    objectNode: THREE.Object3D;
+    animationRef: import("react").MutableRefObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    nodes: {
+        [name: string]: THREE.Object3D<THREE.Object3DEventMap>;
+    };
+    isActive?: boolean;
+    ridingUrl?: string;
+    offset?: THREE.Vector3;
+    parts?: import("../../../controller/type").partsType;
+} & import("./type").ridingType & import("react").RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;

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

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import * as THREE from "three";
+import RiderRef from "../rider";
+export var InnerGroupRef = forwardRef(function (props, ref) {
+    return (_jsxs("group", { receiveShadow: true, castShadow: true, ref: ref, userData: { intangible: true }, children: [props.isRiderOn &&
+                props.enableRiding &&
+                props.isActive &&
+                props.ridingUrl && (_jsx(RiderRef, { url: props.ridingUrl, offset: props.offset })), props.children, props.objectNode && props.animationRef && (_jsx("primitive", { object: props.objectNode, visible: false, receiveShadow: true, castShadow: true, ref: props.animationRef })), Object.keys(props.nodes).map(function (name, key) {
+                var node = props.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,5 @@
+import { ReactNode } from "react";
+import * as THREE from "three";
+export declare const OuterGroupRef: import("react").ForwardRefExoticComponent<{
+    children: ReactNode;
+} & import("react").RefAttributes<THREE.Group<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,36 @@
+import { RapierRigidBody } from "@react-three/rapier";
+import * as THREE from "three";
+export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<{
+    name?: string;
+    userData?: {
+        intangible: boolean;
+    };
+    isActive?: boolean;
+    ridingUrl?: string;
+    groundRay?: import("../../../controller/type").groundRayType;
+    rigidBodyProps?: import("@react-three/rapier").RigidBodyProps;
+    parts?: import("../../../controller/type").partsType;
+} & {
+    children?: React.ReactNode;
+    groundRay?: import("../../../controller/type").groundRayType;
+    url: string;
+    ridingUrl?: string;
+    wheelUrl?: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    offset?: THREE.Vector3;
+    controllerOptions?: import("../../../controller/type").controllerOptionsType;
+    currentAnimation?: string;
+    rigidbodyType?: import("@react-three/rapier").RigidBodyTypeString;
+    sensor?: boolean;
+    onIntersectionEnter?: (e: import("@react-three/rapier").CollisionEnterPayload) => Promise<void>;
+    onCollisionEnter?: (e: import("@react-three/rapier").CollisionEnterPayload) => Promise<void>;
+    componentType: import("../../passive/type").componentTypeString;
+    userData?: {
+        intangible: boolean;
+    };
+    rigidBodyProps?: import("@react-three/rapier").RigidBodyProps;
+    outerGroupProps?: THREE.Group;
+    innerGroupProps?: THREE.Group;
+    parts?: import("../../../controller/type").partsType;
+} & import("./type").ridingType & import("../../passive/type").innerRefType & import("../../../controller/initialize/callback/type").callbackType & import("react").RefAttributes<RapierRigidBody>>;