gaesup-world 0.2.24 → 0.2.26

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

@@ -0,0 +1,38 @@
+import { GroupProps } from "@react-three/fiber";
+import { dispatchType } from "../../utils/type";
+import { callbackType } from "../initialize/callback/type";
+import { gaesupControllerContextPropType, refsType } from "../type";
+export type airplaneDebugType = {
+    angleDelta?: THREE.Vector3;
+    maxAngle?: THREE.Vector3;
+    buoyancy?: number;
+    maxSpeed?: number;
+    accelRatio?: number;
+    brakeRatio?: number;
+    linearDamping?: number;
+};
+export type vehicleDebugType = {
+    maxSpeed?: number;
+    accelRatio?: number;
+    brakeRatio?: number;
+    wheelOffset?: number;
+    linearDamping?: number;
+};
+export type characterDebugType = {
+    jumpSpeed?: number;
+    turnSpeed?: number;
+    walkSpeed?: number;
+    runSpeed?: number;
+    linearDamping?: number;
+};
+export interface airplaneType extends GroupProps, airplaneDebugType {
+}
+export interface vehicleType extends GroupProps, vehicleDebugType {
+}
+export interface characterType extends GroupProps, characterDebugType {
+}
+export type gaesupControllerType = gaesupControllerContextPropType & {
+    callbacks?: callbackType;
+    refs?: refsType;
+};
+export type gaesupDisptachType = dispatchType<gaesupControllerType>;

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

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

package/dist/gaesup/controller/debug/airplane.d.ts

@@ -0,0 +1,71 @@
+export declare const airplaneDebugMap: {
+    angleDelta: {
+        value: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        x: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        y: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        z: {
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    maxAngle: {
+        value: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        x: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        y: {
+            min: number;
+            max: number;
+            step: number;
+        };
+        z: {
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    maxSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    accelRatio: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    brakeRatio: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    buoyancy: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    linearDamping: {
+        min: number;
+        max: number;
+        step: number;
+    };
+};

package/dist/gaesup/controller/debug/airplane.js

@@ -0,0 +1,71 @@
+export var airplaneDebugMap = {
+    angleDelta: {
+        value: {
+            x: 0.01,
+            y: 0.005,
+            z: 0.005,
+        },
+        x: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+        y: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+        z: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+    },
+    maxAngle: {
+        value: {
+            x: 0.1,
+            y: 0.1,
+            z: 0.1,
+        },
+        x: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+        y: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+        z: {
+            min: -Math.PI,
+            max: Math.PI,
+            step: 0.01,
+        },
+    },
+    maxSpeed: {
+        min: 50,
+        max: 100,
+        step: 0.01,
+    },
+    accelRatio: {
+        min: 1,
+        max: 10,
+        step: 0.01,
+    },
+    brakeRatio: {
+        min: 1,
+        max: 20,
+        step: 0.01,
+    },
+    buoyancy: {
+        min: 0.1,
+        max: 1,
+        step: 0.01,
+    },
+    linearDamping: {
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+};

package/dist/gaesup/controller/debug/character.d.ts

@@ -0,0 +1,27 @@
+export declare const characterDebugMap: {
+    walkSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    runSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    turnSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    jumpSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    linearDamping: {
+        min: number;
+        max: number;
+        step: number;
+    };
+};

package/dist/gaesup/controller/debug/character.js

@@ -0,0 +1,27 @@
+export var characterDebugMap = {
+    walkSpeed: {
+        min: 1,
+        max: 20,
+        step: 0.01,
+    },
+    runSpeed: {
+        min: 1,
+        max: 20,
+        step: 0.01,
+    },
+    turnSpeed: {
+        min: 1,
+        max: 20,
+        step: 0.01,
+    },
+    jumpSpeed: {
+        min: 0.1,
+        max: 20,
+        step: 0.01,
+    },
+    linearDamping: {
+        min: -10,
+        max: 10,
+        step: 0.01,
+    },
+};

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

@@ -0,0 +1,6 @@
+import { dispatchType } from "../../utils/type";
+import { gaesupControllerType } from "../context/type";
+export default function initDebug({ controllerContext, controllerDispatch, }: {
+    controllerContext: gaesupControllerType;
+    controllerDispatch: dispatchType<gaesupControllerType>;
+}): void;

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

@@ -0,0 +1,49 @@
+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 { useContext, useEffect } from "react";
+import { update } from "../../utils/context";
+import debug from "../../utils/debug";
+import { GaesupWorldContext } from "../../world/context";
+import { airplaneDebugMap } from "./airplane";
+import { characterDebugMap } from "./character";
+import { vehicleDebugMap } from "./vehicle";
+export default function initDebug(_a) {
+    var controllerContext = _a.controllerContext, controllerDispatch = _a.controllerDispatch;
+    var worldDebug = useContext(GaesupWorldContext).debug;
+    if (!worldDebug)
+        return;
+    var characterOptionValue = debug({
+        debug: worldDebug,
+        debugProps: controllerContext.character,
+        tag: "character",
+        debugMap: characterDebugMap,
+    });
+    var vehicleOptionValue = debug({
+        debug: worldDebug,
+        debugProps: controllerContext.vehicle,
+        tag: "vehicle",
+        debugMap: vehicleDebugMap,
+    });
+    var airplaneOptionValue = debug({
+        debug: worldDebug,
+        debugProps: controllerContext.airplane,
+        tag: "airplane",
+        debugMap: airplaneDebugMap,
+    });
+    useEffect(function () {
+        update({
+            character: __assign({}, characterOptionValue),
+            vehicle: __assign({}, vehicleOptionValue),
+            airplane: __assign({}, airplaneOptionValue),
+        }, controllerDispatch);
+    }, [characterOptionValue, vehicleOptionValue, airplaneOptionValue]);
+}

package/dist/gaesup/controller/debug/vehicle.d.ts

@@ -0,0 +1,27 @@
+export declare const vehicleDebugMap: {
+    maxSpeed: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    accelRatio: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    brakeRatio: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    wheelOffset: {
+        min: number;
+        max: number;
+        step: number;
+    };
+    linearDamping: {
+        min: number;
+        max: number;
+        step: number;
+    };
+};

package/dist/gaesup/controller/debug/vehicle.js

@@ -0,0 +1,27 @@
+export var vehicleDebugMap = {
+    maxSpeed: {
+        min: 50,
+        max: 100,
+        step: 0.01,
+    },
+    accelRatio: {
+        min: 1,
+        max: 10,
+        step: 0.01,
+    },
+    brakeRatio: {
+        min: 1,
+        max: 20,
+        step: 0.01,
+    },
+    wheelOffset: {
+        min: 0.1,
+        max: 10,
+        step: 0.01,
+    },
+    linearDamping: {
+        min: 0,
+        max: 1,
+        step: 0.01,
+    },
+};

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

@@ -0,0 +1,3 @@
+import { controllerType } from "./type";
+export declare function GaesupController(props: controllerType): import("react/jsx-runtime").JSX.Element;
+export declare function GaesupControllerInner(props: controllerType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/controller/index.js

@@ -0,0 +1,74 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext, useMemo, useReducer, useRef } from "react";
+import Camera from "../camera";
+import { KeyboardControls } from "@react-three/drei";
+import { GaesupComponent } from "../component";
+import { GaesupWorldContext } from "../world/context";
+import { GaesupControllerContext, GaesupControllerDispatchContext, gaesupControllerDefault, } from "./context";
+import { gaesupControllerReducer } from "./context/reducer";
+import initDebug from "./debug";
+import initControllerProps from "./initialize";
+export function GaesupController(props) {
+    var keyBoardMap = useContext(GaesupWorldContext).keyBoardMap;
+    return (_jsx(KeyboardControls, { map: keyBoardMap, children: _jsx(GaesupControllerInner, __assign({}, props, { children: props.children })) }));
+}
+export function GaesupControllerInner(props) {
+    var colliderRef = useRef(null);
+    var rigidBodyRef = useRef(null);
+    var outerGroupRef = useRef(null);
+    var innerGroupRef = useRef(null);
+    var characterInnerRef = useRef(null);
+    var passiveRigidBodyRef = useRef(null);
+    var _a = useReducer(gaesupControllerReducer, {
+        airplane: Object.assign(gaesupControllerDefault.airplane, props.airplane || {}),
+        vehicle: Object.assign(gaesupControllerDefault.vehicle, props.vehicle || {}),
+        character: Object.assign(gaesupControllerDefault.character, props.character || {}),
+        callbacks: Object.assign(gaesupControllerDefault.callbacks, {
+            onReady: props.onReady,
+            onFrame: props.onFrame,
+            onDestory: props.onDestory,
+            onAnimate: props.onAnimate,
+        }),
+        urls: Object.assign(gaesupControllerDefault.urls, props.urls || {}),
+        refs: {
+            colliderRef: colliderRef,
+            rigidBodyRef: rigidBodyRef,
+            outerGroupRef: outerGroupRef,
+            innerGroupRef: innerGroupRef,
+            characterInnerRef: characterInnerRef,
+        },
+    }), controller = _a[0], controllerDispatch = _a[1];
+    var gaesupControl = useMemo(function () { return ({
+        value: controller,
+        dispatch: controllerDispatch,
+    }); }, [controller, controllerDispatch]);
+    var refs = useMemo(function () {
+        return {
+            colliderRef: colliderRef,
+            rigidBodyRef: rigidBodyRef,
+            outerGroupRef: outerGroupRef,
+            innerGroupRef: innerGroupRef,
+            characterInnerRef: characterInnerRef,
+            passiveRigidBodyRef: passiveRigidBodyRef,
+        };
+    }, []);
+    var prop = __assign(__assign(__assign(__assign({}, initControllerProps({
+        refs: refs,
+    })), { children: props.children, groupProps: props.groupProps }), gaesupControl.value.callbacks), refs);
+    initDebug({
+        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, urls: props.urls }) })] }));
+}

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

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

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

@@ -0,0 +1,62 @@
+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/callback/type.d.ts

@@ -0,0 +1,27 @@
+import { RootState } from "@react-three/fiber";
+import { cameraRayType } from "../../../camera/type";
+import { activeStateType, animationAtomType, animationPropType, keyControlType, statesType } from "../../../world/context/type";
+import { actionsType, groundRayType, slopeRayType } from "../../type";
+export type callbackPropType = {
+    activeState: activeStateType;
+    states: statesType;
+    slopeRay: slopeRayType;
+    groundRay: groundRayType;
+    cameraRay: cameraRayType;
+    control: keyControlType;
+    subscribe: (props: animationAtomType) => void;
+};
+export type onFramePropType = callbackPropType & RootState;
+export type onAnimatePropType = onFramePropType & {
+    actions: {
+        [x: string]: THREE.AnimationAction | null;
+    };
+    animation: animationPropType;
+    playAnimation: (tag: keyof actionsType, key: string) => void;
+};
+export type callbackType = {
+    onReady?: (prop: callbackPropType) => void;
+    onFrame?: (prop: onFramePropType) => void;
+    onDestory?: (prop: callbackPropType) => void;
+    onAnimate?: (prop: onAnimatePropType) => void;
+};

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

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

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

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

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

@@ -0,0 +1,75 @@
+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 { useKeyboardControls } from "@react-three/drei";
+import { vec3 } from "@react-three/rapier";
+import { useCallback, useContext, useEffect, useMemo } from "react";
+import * as THREE from "three";
+import { update } from "../../utils/context";
+import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
+export default function initControllerProps(_a) {
+    var refs = _a.refs;
+    var context = useContext(GaesupWorldContext);
+    var dispatch = useContext(GaesupWorldDispatchContext);
+    var _b = useKeyboardControls(), _ = _b[0], getKeys = _b[1];
+    var keyControl = getKeys();
+    useEffect(function () {
+        if (context && keyControl && context.control) {
+            dispatch({
+                type: "update",
+                payload: {
+                    control: __assign({}, (context.mode.controller === "keyboard"
+                        ? keyControl
+                        : context.control)),
+                },
+            });
+        }
+    }, [context === null || context === void 0 ? void 0 : context.mode.controller, keyControl, context === null || context === void 0 ? void 0 : context.control]);
+    var groundRay = useMemo(function () {
+        return {
+            origin: vec3(),
+            dir: vec3({ x: 0, y: -1, z: 0 }),
+            offset: vec3({ x: 0, y: -1, z: 0 }),
+            hit: null,
+            parent: null,
+            rayCast: null,
+            length: 0.5,
+        };
+    }, []);
+    var cameraRay = useMemo(function () {
+        return {
+            origin: vec3(),
+            hit: new THREE.Raycaster(),
+            rayCast: new THREE.Raycaster(vec3(), vec3(), 0, -7),
+            dir: vec3(),
+            position: vec3(),
+            length: -context.cameraOption.maxDistance,
+            detected: [],
+            intersects: [],
+            intersectObjectMap: {},
+        };
+    }, []);
+    var initRefs = useCallback(function (refs) {
+        update({
+            refs: __assign({}, refs),
+        }, dispatch);
+    }, [refs]);
+    useEffect(function () {
+        if (refs) {
+            initRefs(refs);
+        }
+    }, []);
+    return {
+        groundRay: groundRay,
+        cameraRay: cameraRay,
+        keyControl: keyControl,
+    };
+}