gaesup-world 0.3.5 → 0.3.7

package/dist/gaesup/animation/actions.js

@@ -66,7 +66,7 @@ export function subscribeActions(_a) {
 export default function playActions(_a) {
     var _b;
     var type = _a.type, animationResult = _a.animationResult, currentAnimation = _a.currentAnimation;
-    var _c = useContext(GaesupWorldContext), mode = _c.mode, animationState = _c.animationState;
+    var _c = useContext(GaesupWorldContext), mode = _c.mode, animationState = _c.animationState, block = _c.block;
     var dispatch = useContext(GaesupWorldDispatchContext);
     var _d = useGaesupAnimation({ type: type }), notify = _d.notify, store = _d.store;
     var actions = animationResult.actions, ref = animationResult.ref;
@@ -85,11 +85,21 @@ export default function playActions(_a) {
     };
     useEffect(function () {
         var _a;
-        var action = (_a = actions[currentAnimation || animationState[type].current]) === null || _a === void 0 ? void 0 : _a.reset().fadeIn(0.2).play();
+        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]);
+    }, [currentAnimation, mode.type, block.animation]);
     useFrame(function () {
         if (!currentAnimation) {
             var tag = notify();

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

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

package/dist/gaesup/camera/index.js

@@ -17,7 +17,7 @@ import { useContext, useEffect, useMemo, useRef } from "react";
 import * as THREE from "three";
 import { GaesupControllerContext } from "../controller/context";
 import { GaesupWorldContext } from "../world/context";
-import normal from "./control/normal";
+import normal, { makeNormalCameraPosition } from "./control/normal";
 import orbit from "./control/orbit";
 export default function Camera(_a) {
     var refs = _a.refs, prop = _a.prop, control = _a.control;
@@ -60,18 +60,40 @@ export default function Camera(_a) {
             cameraRef.current.zoomTo(worldContext.cameraOption.zoom, true);
         }
     }, [worldContext.cameraOption.zoom]);
-    // lookat
-    useEffect(function () {
-        if (cameraRef.current) {
-            var currentCamera = camera.position.clone();
-            if (cameraOption.focus) {
-                cameraRef.current.setLookAt(currentCamera.x, currentCamera.y, currentCamera.z, cameraOption.target.x, cameraOption.target.y, cameraOption.target.z, true);
-                // 포커스 품
-            }
-            else if (!cameraOption.focus) {
-                cameraRef.current.setLookAt(currentCamera.x, currentCamera.y, currentCamera.z, activeState.position.x, activeState.position.y, activeState.position.z, true);
-            }
+    // 포커스가 아닐 때 카메라 activeStae 따라가기
+    useFrame(function () {
+        if (!cameraOption.focus) {
+            cameraOption.target = activeState.position;
+            cameraOption.position = makeNormalCameraPosition(activeState, cameraOption);
         }
-    }, [cameraOption.focus]);
+    });
+    // lookat
+    // useEffect(() => {
+    //   if (cameraRef.current) {
+    //     const currentCamera = camera.position.clone();
+    //     if (cameraOption.focus) {
+    //       cameraRef.current.setLookAt(
+    //         currentCamera.x,
+    //         currentCamera.y,
+    //         currentCamera.z,
+    //         cameraOption.target.x,
+    //         cameraOption.target.y,
+    //         cameraOption.target.z,
+    //         true
+    //       );
+    //       // 포커스 품
+    //     } else if (!cameraOption.focus) {
+    //       cameraRef.current.setLookAt(
+    //         currentCamera.x,
+    //         currentCamera.y,
+    //         currentCamera.z,
+    //         activeState.position.x,
+    //         activeState.position.y,
+    //         activeState.position.z,
+    //         true
+    //       );
+    //     }
+    //   }
+    // }, [cameraOption.focus]);
     return _jsx(CameraControls, { ref: cameraRef });
 }

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

@@ -17,7 +17,8 @@ export function CharacterRef(_a) {
     });
     setGroundRay({
         groundRay: props.groundRay,
-        length: (collider === null || collider === void 0 ? void 0 : collider.radius) || 0 + 2,
+        length: ((collider === null || collider === void 0 ? void 0 : collider.height) || 0) + 2,
+        // length: collider?.radius || 0 + 2,
         colliderRef: colliderRef,
     });
     var animationResult = subscribeActions({

package/dist/gaesup/hooks/useClicker/index.js

@@ -1,4 +1,3 @@
-import _ from "lodash";
 import { useContext, useEffect } from "react";
 import { V3 } from "../../utils";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
@@ -13,33 +12,19 @@ export default function useClicker() {
         var newAngle = Math.atan2(newPosition.z - originPoint.z, newPosition.x - originPoint.x);
         var norm = Math.sqrt(Math.pow(newPosition.z - originPoint.z, 2) +
             Math.pow(newPosition.x - originPoint.x, 2));
-        if (norm < 1)
+        if (norm < 2)
             return;
-        var dispatcher = _.debounce(function () {
-            dispatch({
-                type: "update",
-                payload: {
-                    clicker: {
-                        point: V3(e.point.x, e.point.y, e.point.z),
-                        angle: newAngle,
-                        isOn: true,
-                        isRun: isRun,
-                    },
+        dispatch({
+            type: "update",
+            payload: {
+                clicker: {
+                    point: V3(e.point.x, e.point.y, e.point.z),
+                    angle: newAngle,
+                    isOn: true,
+                    isRun: isRun,
                 },
-            });
-        }, 100);
-        dispatcher();
-        // dispatch({
-        //   type: "update",
-        //   payload: {
-        //     clicker: {
-        //       point: V3(e.point.x, e.point.y, e.point.z),
-        //       angle: newAngle,
-        //       isOn: true,
-        //       isRun: isRun,
-        //     },
-        //   },
-        // });
+            },
+        });
     };
     // const moveClicker = _.throttle(moveClick, 100);
     // 거리 계산

package/dist/gaesup/hooks/useFocus/index.d.ts

@@ -1,7 +1,22 @@
 export declare function useFocus(): {
-    open: ({ zoom, target }: {
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    on: () => Promise<void>;
+    off: () => Promise<void>;
+    focus: ({ zoom, target, position, }: {
         zoom?: number;
         target: THREE.Vector3;
-    }) => void;
-    close: () => void;
+        position: THREE.Vector3;
+    }) => Promise<void>;
+    free: ({ zoom }: {
+        zoom?: number;
+    }) => Promise<void>;
+    focusOn: ({ zoom, target, position, }: {
+        zoom?: number;
+        target: THREE.Vector3;
+        position: THREE.Vector3;
+    }) => Promise<void>;
+    focusOff: ({ zoom }: {
+        zoom?: number;
+    }) => Promise<void>;
 };

package/dist/gaesup/hooks/useFocus/index.js

@@ -1,32 +1,200 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { useContext } from "react";
+import { makeNormalCameraPosition } from "../../camera/control/normal";
 import { GaesupWorldContext, GaesupWorldDispatchContext, } from "../../world/context";
 export function useFocus() {
-    var cameraOption = useContext(GaesupWorldContext).cameraOption;
+    var _this = this;
+    var _a = useContext(GaesupWorldContext), cameraOption = _a.cameraOption, activeState = _a.activeState, block = _a.block;
     var dispatch = useContext(GaesupWorldDispatchContext);
-    var open = function (_a) {
-        var zoom = _a.zoom, target = _a.target;
-        if (zoom)
-            cameraOption.zoom = zoom;
-        cameraOption.target = target;
-        cameraOption.focus = true;
-        dispatch({
-            type: "update",
-            payload: {
-                cameraOption: cameraOption,
-            },
+    var dispatchAsync = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            dispatch({
+                type: "update",
+                payload: {
+                    cameraOption: cameraOption,
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var close = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            block.control = true;
+            block.animation = true;
+            dispatch({
+                type: "update",
+                payload: {
+                    block: block,
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var open = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            block.control = false;
+            block.animation = false;
+            dispatch({
+                type: "update",
+                payload: {
+                    block: block,
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var on = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            cameraOption.focus = true;
+            dispatch({
+                type: "update",
+                payload: {
+                    cameraOption: cameraOption,
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var off = function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            cameraOption.focus = false;
+            dispatch({
+                type: "update",
+                payload: {
+                    cameraOption: cameraOption,
+                },
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var focus = function (_a) {
+        var zoom = _a.zoom, target = _a.target, position = _a.position;
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (zoom)
+                    cameraOption.zoom = zoom;
+                cameraOption.position.lerp(position, 0.1);
+                cameraOption.target.lerp(target, 0.1);
+                return [2 /*return*/];
+            });
+        });
+    };
+    var free = function (_a) {
+        var zoom = _a.zoom;
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (zoom)
+                    cameraOption.zoom = zoom;
+                cameraOption.position.lerp(makeNormalCameraPosition(activeState, cameraOption), 0.1);
+                cameraOption.target.lerp(activeState.position.clone(), 0.1);
+                return [2 /*return*/];
+            });
+        });
+    };
+    var move = function (_a) {
+        var newPosition = _a.newPosition;
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                cameraOption.position.lerp(newPosition.clone(), 0.1);
+                return [2 /*return*/];
+            });
+        });
+    };
+    var focusOn = function (_a) {
+        var zoom = _a.zoom, target = _a.target, position = _a.position;
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, close()];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, on()];
+                    case 2:
+                        _b.sent();
+                        return [4 /*yield*/, move({ newPosition: position })];
+                    case 3:
+                        _b.sent();
+                        return [4 /*yield*/, focus({ zoom: zoom, target: target, position: position })];
+                    case 4:
+                        _b.sent();
+                        return [4 /*yield*/, dispatchAsync()];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
         });
     };
-    var close = function () {
-        cameraOption.focus = false;
-        dispatch({
-            type: "update",
-            payload: {
-                cameraOption: cameraOption,
-            },
+    var focusOff = function (_a) {
+        var zoom = _a.zoom;
+        return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, open()];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, off()];
+                    case 2:
+                        _b.sent();
+                        return [4 /*yield*/, move({
+                                newPosition: makeNormalCameraPosition(activeState, cameraOption),
+                            })];
+                    case 3:
+                        _b.sent();
+                        return [4 /*yield*/, free({ zoom: zoom })];
+                    case 4:
+                        _b.sent();
+                        return [4 /*yield*/, dispatchAsync()];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
         });
     };
     return {
         open: open,
         close: close,
+        on: on,
+        off: off,
+        focus: focus,
+        free: free,
+        focusOn: focusOn,
+        focusOff: focusOff,
     };
 }

package/dist/gaesup/physics/check/ground.js

@@ -4,12 +4,14 @@ export default function checkOnTheGround(prop) {
     groundRay.origin.addVectors(activeState.position, vec3(groundRay.offset));
     if (!groundRay.hit || !groundRay.rayCast || !colliderRef.current) {
         states.isOnTheGround = false;
-        return;
+        // return;
     }
-    if (groundRay.hit.toi < groundRay.length + 0.5) {
-        states.isOnTheGround = true;
-    }
-    else {
-        states.isOnTheGround = false;
+    if (groundRay.hit) {
+        if (groundRay.hit.toi < groundRay.length + 0.5) {
+            states.isOnTheGround = true;
+        }
+        else {
+            states.isOnTheGround = false;
+        }
     }
 }

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

@@ -107,7 +107,8 @@ export var gaesupWorldDefault = {
         YDistance: 10,
         ZDistance: 20,
         zoom: 1,
-        target: null,
+        target: vec3(),
+        position: vec3(),
         focus: false,
     },
     moveTo: null,
@@ -116,6 +117,7 @@ export var gaesupWorldDefault = {
     block: {
         camera: false,
         control: false,
+        animation: false,
         scroll: true,
     },
     callback: {

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

@@ -13,6 +13,7 @@ export type gaesupCameraOptionDebugType = {
     zoom?: number;
     target?: THREE.Vector3;
     focus?: boolean;
+    position?: THREE.Vector3;
 };
 export type cameraOptionType = {
     offset?: THREE.Vector3;
@@ -108,6 +109,7 @@ export type wheelStateType = {
 export type blockType = {
     camera: boolean;
     control: boolean;
+    animation: boolean;
     scroll: boolean;
 };
 export type sizeType = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaesup-world",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",