gaesup-world 0.1.4 → 0.2.0

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

@@ -1,2 +1,13 @@
-import { passiveAirplanePropsType } from "./type";
+/// <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

@@ -1,10 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useFrame } from "@react-three/fiber";
-import { CuboidCollider, quat } from "@react-three/rapier";
+import { quat, } from "@react-three/rapier";
 import { useMemo, useRef } from "react";
-import { InnerGroupRef } from "../common/InnerGroupRef";
-import { OuterGroupRef } from "../common/OuterGroupRef";
-import { RigidBodyRef } from "../common/RigidbodyRef";
+import { AirplaneInnerRef } from "../../inner/airplane";
 export function PassiveAirplane(props) {
     var rigidBodyRef = useRef(null);
     var outerGroupRef = useRef(null);
@@ -21,10 +19,9 @@ export function PassiveAirplane(props) {
             position: props.position,
             euler: props.euler,
             currentAnimation: props.currentAnimation,
-            airplaneUrl: props.airplaneUrl,
-            airplaneSize: props.airplaneSize,
+            urls: props.urls,
         };
-    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation, airplaneUrl = _a.airplaneUrl, airplaneSize = _a.airplaneSize;
+    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation, urls = _a.urls;
     useFrame(function () {
         if (innerGroupRef && innerGroupRef.current) {
             var _euler = euler.clone();
@@ -39,5 +36,5 @@ export function PassiveAirplane(props) {
                 : 0.1, false);
         }
     });
-    return (_jsxs(OuterGroupRef, { ref: refs.outerGroupRef, children: [props.children, airplaneUrl && (_jsxs(RigidBodyRef, { ref: refs.rigidBodyRef, position: position, rotation: euler, onCollisionEnter: props.onCollisionEnter, children: [_jsx(InnerGroupRef, { currentAnimation: currentAnimation, ref: refs.innerGroupRef, url: airplaneUrl }), _jsx(CuboidCollider, { ref: colliderRef, args: [airplaneSize.x / 2, airplaneSize.y / 2, airplaneSize.z / 2], position: [0, airplaneSize.y / 2, 0] })] }))] }));
+    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

@@ -1,2 +1,10 @@
-import { passiveCharacterPropsType } from "./type";
+/// <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

@@ -1,11 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+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 { InnerGroupRef } from "../common/InnerGroupRef";
-import { OuterGroupRef } from "../common/OuterGroupRef";
-import { RigidBodyRef } from "../common/RigidbodyRef";
-import { CharacterCapsuleCollider } from "./collider";
+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);
@@ -15,16 +15,16 @@ export function PassiveCharacter(props) {
         rigidBodyRef: rigidBodyRef,
         outerGroupRef: outerGroupRef,
         innerGroupRef: innerGroupRef,
-        capsuleColliderRef: colliderRef,
+        colliderRef: colliderRef,
     };
     var _a = useMemo(function () {
         return {
             position: props.position,
             euler: props.euler,
             currentAnimation: props.currentAnimation,
-            characterUrl: props.url.characterUrl,
+            characterUrl: props.urls.characterUrl,
         };
-    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation, characterUrl = _a.characterUrl;
+    }, [props]), position = _a.position, euler = _a.euler, currentAnimation = _a.currentAnimation;
     useEffect(function () {
         if (rigidBodyRef || rigidBodyRef.current) {
             rigidBodyRef.current.setEnabledRotations(false, false, false, false);
@@ -35,5 +35,12 @@ export function PassiveCharacter(props) {
             innerGroupRef.current.quaternion.rotateTowards(quat().setFromEuler(euler), 10 * delta);
         }
     });
-    return (_jsxs(OuterGroupRef, { ref: refs.outerGroupRef, children: [props.children, characterUrl && (_jsxs(RigidBodyRef, { ref: refs.rigidBodyRef, position: position, children: [_jsx(CharacterCapsuleCollider, { height: props.height, diameter: props.diameter, ref: colliderRef }), _jsx(InnerGroupRef, { currentAnimation: currentAnimation, ref: refs.innerGroupRef, url: characterUrl })] }))] }));
+    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

@@ -1,6 +1,5 @@
-/// <reference types="react" />
 import { gaesupPassivePropsType } from "../../hooks/useGaesupController";
-import { activeStateType, characterColliderType, modeType, vehicleColliderType, wheelsStateType } from "../../world/context/type";
+import { activeStateType, modeType, wheelsStateType } from "../../world/context/type";
 export type passiveComponentType = {
     props: gaesupPassivePropsType;
 };
@@ -19,12 +18,3 @@ export type passiveVehicleType = {
     url: string;
     wheelUrl?: string;
 };
-export type passiveVehicleInnerType = {
-    rigidBodyRef: React.MutableRefObject<THREE.Object3D | undefined>;
-    collider: vehicleColliderType;
-    wheelOffset: number;
-};
-export type passiveCharacterInnerType = {
-    rigidBodyRef: React.MutableRefObject<THREE.Object3D | undefined>;
-    collider: characterColliderType;
-};

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

@@ -1,2 +1,13 @@
-import { passiveVehiclePropsType } from "./type";
+/// <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

@@ -1,10 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CuboidCollider } from "@react-three/rapier";
-import { useEffect, useMemo, useRef } from "react";
-import { InnerGroupRef } from "../common/InnerGroupRef";
-import { OuterGroupRef } from "../common/OuterGroupRef";
-import { RigidBodyRef } from "../common/RigidbodyRef";
-import { Wheels } from "./wheels";
+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);
@@ -14,23 +10,8 @@ export function PassiveVehicle(props) {
         rigidBodyRef: rigidBodyRef,
         outerGroupRef: outerGroupRef,
         innerGroupRef: innerGroupRef,
-        capsuleColliderRef: colliderRef,
+        colliderRef: colliderRef,
     };
-    var _a = useMemo(function () {
-        return {
-            position: props.position,
-            euler: props.euler,
-            vehicleSize: props.vehicleSize,
-            wheelSize: props.wheelSize,
-            currentAnimation: props.currentAnimation,
-            wheelUrl: props.url.wheelUrl,
-            vehicleUrl: props.url.vehicleUrl,
-        };
-    }, [props]), position = _a.position, euler = _a.euler, vehicleSize = _a.vehicleSize, wheelSize = _a.wheelSize, currentAnimation = _a.currentAnimation, wheelUrl = _a.wheelUrl, vehicleUrl = _a.vehicleUrl;
-    useEffect(function () {
-        if (rigidBodyRef.current) {
-            rigidBodyRef.current.lockRotations(true, true);
-        }
-    }, []);
-    return (_jsxs(OuterGroupRef, { ref: refs.outerGroupRef, children: [props.children, vehicleUrl && (_jsxs(RigidBodyRef, { ref: refs.rigidBodyRef, position: position, rotation: euler, onCollisionEnter: props.onCollisionEnter, children: [_jsx(InnerGroupRef, { currentAnimation: currentAnimation, ref: refs.innerGroupRef, url: vehicleUrl }), wheelUrl ? (_jsx(CuboidCollider, { ref: colliderRef, args: [vehicleSize.x / 2, vehicleSize.y / 2, vehicleSize.z / 2], position: [0, vehicleSize.y + wheelSize.y / 2, 0] })) : (_jsx(CuboidCollider, { ref: colliderRef, args: [vehicleSize.x / 2, vehicleSize.y / 2, vehicleSize.z / 2], position: [0, vehicleSize.y, 0] }))] })), wheelUrl && (_jsx(Wheels, { vehicleSize: vehicleSize, wheelSize: wheelSize, rigidBodyRef: rigidBodyRef, url: wheelUrl }))] }));
+    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/controller/context/index.d.ts

@@ -32,14 +32,18 @@ export declare const gaesupControllerDefault: {
         onAnimate: () => void;
     };
     refs: {
-        capsuleColliderRef: any;
+        colliderRef: any;
         rigidBodyRef: any;
         outerGroupRef: any;
         innerGroupRef: any;
-        slopeRayOriginRef: any;
         characterInnerRef: any;
     };
-    isRider: boolean;
+    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

@@ -42,14 +42,18 @@ export var gaesupControllerDefault = {
         onAnimate: function () { },
     },
     refs: {
-        capsuleColliderRef: null,
+        colliderRef: null,
         rigidBodyRef: null,
         outerGroupRef: null,
         innerGroupRef: null,
-        slopeRayOriginRef: null,
         characterInnerRef: null,
     },
-    isRider: false,
+    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

@@ -6,7 +6,7 @@ export declare function gaesupControllerReducer(props: gaesupControllerType, act
     airplane: import("./type").airplaneType;
     vehicle: import("./type").vehicleType;
     character: import("./type").characterType;
-    isRider: boolean;
+    urls: import("../../world/context/type").urlsType;
     callbacks?: import("../initialize/callback/type").callbackType;
     refs?: import("../type").refsType;
 };

package/dist/gaesup/controller/index.js

@@ -24,11 +24,10 @@ export function GaesupController(props) {
     return (_jsx(KeyboardControls, { map: keyBoardMap, children: _jsx(GaesupControllerInner, __assign({}, props, { children: props.children })) }));
 }
 export function GaesupControllerInner(props) {
-    var capsuleColliderRef = useRef(null);
+    var colliderRef = useRef(null);
     var rigidBodyRef = useRef(null);
     var outerGroupRef = useRef(null);
     var innerGroupRef = useRef(null);
-    var slopeRayOriginRef = useRef(null);
     var characterInnerRef = useRef(null);
     var passiveRigidBodyRef = useRef(null);
     var _a = useReducer(gaesupControllerReducer, {
@@ -41,15 +40,14 @@ export function GaesupControllerInner(props) {
             onDestory: props.onDestory,
             onAnimate: props.onAnimate,
         }),
+        urls: Object.assign(gaesupControllerDefault.urls, props.urls || {}),
         refs: {
-            capsuleColliderRef: capsuleColliderRef,
+            colliderRef: colliderRef,
             rigidBodyRef: rigidBodyRef,
             outerGroupRef: outerGroupRef,
             innerGroupRef: innerGroupRef,
-            slopeRayOriginRef: slopeRayOriginRef,
             characterInnerRef: characterInnerRef,
         },
-        isRider: props.isRider !== null ? props.isRider : false,
     }), controller = _a[0], controllerDispatch = _a[1];
     var gaesupControl = useMemo(function () { return ({
         value: controller,
@@ -57,11 +55,10 @@ export function GaesupControllerInner(props) {
     }); }, [controller, controllerDispatch]);
     var refs = useMemo(function () {
         return {
-            capsuleColliderRef: capsuleColliderRef,
+            colliderRef: colliderRef,
             rigidBodyRef: rigidBodyRef,
             outerGroupRef: outerGroupRef,
             innerGroupRef: innerGroupRef,
-            slopeRayOriginRef: slopeRayOriginRef,
             characterInnerRef: characterInnerRef,
             passiveRigidBodyRef: passiveRigidBodyRef,
         };
@@ -73,5 +70,5 @@ export function GaesupControllerInner(props) {
         controllerContext: gaesupControl.value,
         controllerDispatch: gaesupControl.dispatch,
     });
-    return (_jsxs(GaesupControllerContext.Provider, { value: gaesupControl.value, children: [_jsx(Camera, { refs: refs, prop: prop, control: prop.keyControl }), _jsx(GaesupControllerDispatchContext.Provider, { value: gaesupControl.dispatch, children: _jsx(GaesupComponent, { props: prop, refs: refs }) })] }));
+    return (_jsxs(GaesupControllerContext.Provider, { value: gaesupControl.value, children: [_jsx(Camera, { refs: refs, prop: prop, control: prop.keyControl }), _jsx(GaesupControllerDispatchContext.Provider, { value: gaesupControl.dispatch, children: _jsx(GaesupComponent, { props: prop, refs: refs, urls: props.urls }) })] }));
 }

package/dist/gaesup/controller/initialize/callback/index.d.ts

@@ -1,2 +1,2 @@
 import { controllerInnerType } from "../../type";
-export default function initCallback(props: controllerInnerType): void;
+export default function initCallback(props: controllerInnerType, type: "character" | "vehicle" | "airplane"): void;

package/dist/gaesup/controller/initialize/callback/index.js

@@ -1,55 +1,62 @@
-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 default function initCallback(props) {
-    var _a = useContext(GaesupWorldContext), characterGltf = _a.characterGltf, characterAnimations = _a.animations, activeState = _a.activeState, states = _a.states, control = _a.control;
-    var dispatch = useContext(GaesupWorldDispatchContext);
-    var animations = characterGltf.animations;
-    var actions = useAnimations(animations, props.outerGroupRef).actions;
-    var subscribe = useGaesupAnimation().subscribe;
-    var playAnimation = function (tag, key) {
-        if (!(key in control))
-            return;
-        if (control[key]) {
-            characterAnimations.current = tag;
-            dispatch({
-                type: "update",
-                payload: {
-                    animations: __assign({}, characterAnimations),
-                },
-            });
-        }
-    };
-    var controllerProp = __assign(__assign({}, props), { activeState: activeState, control: control, states: states, subscribe: subscribe });
-    useEffect(function () {
-        if (props.onReady) {
-            props.onReady(controllerProp);
-        }
-        return function () {
-            if (props.onDestory) {
-                props.onDestory(controllerProp);
-            }
-        };
-    }, []);
-    useFrame(function (prop) {
-        if (props.onFrame) {
-            props.onFrame(__assign(__assign({}, controllerProp), prop));
-        }
-        if (props.onAnimate) {
-            props.onAnimate(__assign(__assign(__assign({}, controllerProp), prop), { actions: actions, animation: characterAnimations, playAnimation: playAnimation }));
-        }
-    });
+export default function initCallback(props, type) {
+    //   const {
+    //     characterGltf,
+    //     animations: characterAnimations,
+    //     activeState,
+    //     states,
+    //     control,
+    //   } = useContext(GaesupWorldContext);
+    //   const dispatch = useContext(GaesupWorldDispatchContext);
+    //   const { animations } = characterGltf;
+    //   const { actions } = useAnimations(animations, props.outerGroupRef);
+    //   const { subscribe } = useGaesupAnimation({ type });
+    //
+    //   const playAnimation = (tag: keyof animationTagType, key: string) => {
+    //     if (!(key in control)) return;
+    //     if (control[key]) {
+    //       characterAnimations.current = tag;
+    //       dispatch({
+    //         type: "update",
+    //         payload: {
+    //           animations: {
+    //             ...characterAnimations,
+    //           },
+    //         },
+    //       });
+    //     }
+    //   };
+    //
+    //   const controllerProp: callbackPropType = {
+    //     ...props,
+    //     activeState,
+    //     control,
+    //     states,
+    //     subscribe,
+    //   };
+    //
+    //   useEffect(() => {
+    //     if (props.onReady) {
+    //       props.onReady(controllerProp);
+    //     }
+    //     return () => {
+    //       if (props.onDestory) {
+    //         props.onDestory(controllerProp);
+    //       }
+    //     };
+    //   }, []);
+    //
+    //   useFrame((prop) => {
+    //     if (props.onFrame) {
+    //       props.onFrame({ ...controllerProp, ...prop });
+    //     }
+    //     if (props.onAnimate) {
+    //       props.onAnimate({
+    //         ...controllerProp,
+    //         ...prop,
+    //         actions,
+    //         animation: characterAnimations,
+    //         playAnimation,
+    //       });
+    //     }
+    //   });
 }

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

@@ -1,10 +1,9 @@
-import { groundRayType, refsType, slopeRayType } from "../../controller/type";
+import { groundRayType, refsType } from "../../controller/type";
 import { cameraRayType } from "../../camera/type";
 import { keyControlType } from "../../world/context/type";
 export default function initControllerProps({ refs }: {
     refs: refsType;
 }): {
-    slopeRay: slopeRayType;
     groundRay: groundRayType;
     cameraRay: cameraRayType;
     keyControl: keyControlType;

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

@@ -37,25 +37,13 @@ export default function initControllerProps(_a) {
         return {
             origin: vec3(),
             dir: vec3({ x: 0, y: -1, z: 0 }),
-            offset: vec3({ x: 0, y: -context.characterCollider.halfHeight, z: 0 }),
+            offset: vec3({ x: 0, y: -1, z: 0 }),
             hit: null,
             parent: null,
             rayCast: null,
             length: 0.5,
         };
     }, []);
-    var slopeRay = useMemo(function () {
-        return {
-            current: vec3(),
-            origin: vec3(),
-            hit: null,
-            rayCast: null,
-            dir: vec3({ x: 0, y: -1, z: 0 }),
-            offset: vec3({ x: 0, y: 0, z: context.characterCollider.radius - 0.03 }),
-            length: context.characterCollider.radius + 3,
-            angle: 0,
-        };
-    }, []);
     var cameraRay = useMemo(function () {
         return {
             origin: vec3(),
@@ -80,7 +68,6 @@ export default function initControllerProps(_a) {
         }
     }, []);
     return {
-        slopeRay: slopeRay,
         groundRay: groundRay,
         cameraRay: cameraRay,
         keyControl: keyControl,

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

@@ -4,7 +4,7 @@ import { RapierRigidBody, RigidBodyProps } from "@react-three/rapier";
 import { ReactNode, RefObject } from "react";
 import * as THREE from "three";
 import { cameraRayType } from "../camera/type";
-import { keyControlType } from "../world/context/type";
+import { keyControlType, urlsType } from "../world/context/type";
 import { airplaneType, characterType, vehicleType } from "./context/type";
 import { callbackType } from "./initialize/callback/type";
 export type optionsType = {
@@ -43,9 +43,7 @@ export type rayType = {
 export type slopeRayType = Omit<rayType, "parent">;
 export type groundRayType = Omit<rayType, "current" | "angle">;
 export type controllerInnerType = {
-    isRider?: boolean;
     name?: string;
-    slopeRay: slopeRayType;
     groundRay: groundRayType;
     cameraRay: cameraRayType;
     keyControl: keyControlType;
@@ -66,18 +64,17 @@ export type actionsType = animationTagType & {
     [key: string]: string;
 };
 export type refsType = {
-    capsuleColliderRef: RefObject<Collider>;
+    colliderRef: RefObject<Collider>;
     rigidBodyRef: RefObject<RapierRigidBody>;
     outerGroupRef: RefObject<THREE.Group>;
     innerGroupRef: RefObject<THREE.Group>;
-    slopeRayOriginRef: RefObject<THREE.Mesh>;
     characterInnerRef: RefObject<THREE.Group>;
 };
 export type gaesupControllerContextPropType = {
     airplane: airplaneType;
     vehicle: vehicleType;
     character: characterType;
-    isRider: boolean;
+    urls: urlsType;
 };
 export interface controllerOtherPropType extends RigidBodyProps {
     children?: ReactNode;

package/dist/gaesup/gaesupProps/index.js

@@ -15,7 +15,7 @@ import { Suspense, useContext, useEffect, useMemo, useRef } from "react";
 import * as THREE from "three";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../world/context/index.js";
 export function GaeSupProps(_a) {
-    var type = _a.type, text = _a.text, position = _a.position, children = _a.children;
+    var _b = _a.type, type = _b === void 0 ? "normal" : _b, text = _a.text, position = _a.position, children = _a.children;
     var groupRef = useRef(null);
     var minimap = useContext(GaesupWorldContext).minimap;
     var dispatch = useContext(GaesupWorldDispatchContext);