gaesup-world 0.8.47 → 0.8.51

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

@@ -13,5 +13,5 @@ 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 }, refs, { children: children })));
+    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/inner/character/type.d.ts

@@ -1,9 +1,10 @@
 import { callbackType } from "../../../controller/initialize/callback/type";
-import { groundRayType } from "../../../controller/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/common/InnerGroupRef.d.ts

@@ -10,4 +10,5 @@ export declare const InnerGroupRef: import("react").ForwardRefExoticComponent<{
     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/RigidbodyRef.d.ts

@@ -10,6 +10,7 @@ export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<{
     ridingUrl?: string;
     groundRay?: import("../../../controller/type").groundRayType;
     rigidBodyProps?: import("@react-three/rapier").RigidBodyProps;
+    parts?: import("../../../controller/type").partsType;
 } & {
     children?: import("react").ReactNode;
     groundRay?: import("../../../controller/type").groundRayType;
@@ -32,4 +33,5 @@ export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<{
     rigidBodyProps?: import("@react-three/rapier").RigidBodyProps;
     outerGroupProps?: THREE.Group<THREE.Object3DEventMap>;
     innerGroupProps?: THREE.Group<THREE.Object3DEventMap>;
+    parts?: string[];
 } & import("./type").ridingType & import("../../passive/type").innerRefType & import("../../../controller/initialize/callback/type").callbackType & import("react").RefAttributes<RapierRigidBody>>;

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

@@ -25,6 +25,7 @@ import calculation from "../../../physics";
 import { V3 } from "../../../utils";
 import { GaesupWorldContext } from "../../../world/context";
 import { InnerGroupRef } from "./InnerGroupRef";
+import { PartsGroupRef } from "./partsGroupRef";
 import { setGroundRay } from "./setGroundRay";
 export var RigidBodyRef = forwardRef(function (props, ref) {
     var _a;
@@ -85,5 +86,8 @@ export var RigidBodyRef = forwardRef(function (props, ref) {
     });
     return (_jsxs(RigidBody, __assign({ colliders: false, ref: ref, name: props.name, rotation: euler()
             .set(0, ((_a = props.rotation) === null || _a === void 0 ? void 0 : _a.clone().y) || 0, 0)
-            .clone(), userData: props.userData, type: props.rigidbodyType || (props.isActive ? "dynamic" : "fixed"), sensor: props.sensor, onIntersectionEnter: props.onIntersectionEnter, onCollisionEnter: props.onCollisionEnter }, props.rigidBodyProps, { children: [_jsx(CapsuleCollider, { ref: props.colliderRef, args: [(size.y / 2 - size.x) * 1.2, size.x * 1.2], position: [0, (size.y / 2 + size.x / 2) * 1.2, 0] }), _jsx(InnerGroupRef, { objectNode: objectNode, animationRef: animationRef, nodes: nodes, ref: props.innerGroupRef, isActive: props.isActive, isRiderOn: props.isRiderOn, enableRiding: props.enableRiding, ridingUrl: props.ridingUrl, offset: props.offset, children: props.children })] })));
+            .clone(), userData: props.userData, type: props.rigidbodyType || (props.isActive ? "dynamic" : "fixed"), sensor: props.sensor, onIntersectionEnter: props.onIntersectionEnter, onCollisionEnter: props.onCollisionEnter }, props.rigidBodyProps, { children: [_jsx(CapsuleCollider, { ref: props.colliderRef, args: [(size.y / 2 - size.x) * 1.2, size.x * 1.2], position: [0, (size.y / 2 + size.x / 2) * 1.2, 0] }), _jsxs(InnerGroupRef, { objectNode: objectNode, animationRef: animationRef, nodes: nodes, ref: props.innerGroupRef, isActive: props.isActive, isRiderOn: props.isRiderOn, enableRiding: props.enableRiding, ridingUrl: props.ridingUrl, offset: props.offset, parts: props.parts, children: [props.children, props.parts &&
+                        props.parts.map(function (url, key) {
+                            return (_jsx(PartsGroupRef, { url: url, isActive: props.isActive, componentType: props.componentType, currentAnimation: props.currentAnimation }, key + url));
+                        })] })] })));
 });

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

@@ -0,0 +1,7 @@
+import { componentTypeString } from "../../passive/type";
+export declare const PartsGroupRef: ({ url, isActive, componentType, currentAnimation, }: {
+    url: string;
+    isActive: boolean;
+    componentType: componentTypeString;
+    currentAnimation: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,31 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAnimations, useGLTF } from "@react-three/drei";
+import { useGraph } from "@react-three/fiber";
+import { useMemo } from "react";
+import * as THREE from "three";
+import { SkeletonUtils } from "three-stdlib";
+import playActions from "../../../animation/actions";
+export var PartsGroupRef = function (_a) {
+    var url = _a.url, isActive = _a.isActive, componentType = _a.componentType, currentAnimation = _a.currentAnimation;
+    var _b = useGLTF(url), scene = _b.scene, animations = _b.animations;
+    var clone = useMemo(function () { return SkeletonUtils.clone(scene); }, [scene]);
+    var _c = useAnimations(animations), actions = _c.actions, ref = _c.ref;
+    var nodes = useGraph(clone).nodes;
+    var objectNode = Object.values(nodes).find(function (node) { return node.type === "Object3D"; });
+    playActions({
+        type: componentType,
+        actions: actions,
+        animationRef: ref,
+        currentAnimation: isActive ? undefined : currentAnimation,
+        isActive: isActive,
+    });
+    return (_jsxs(_Fragment, { children: [_jsx("primitive", { object: objectNode, visible: false, receiveShadow: true, castShadow: true, ref: ref }), Object.keys(nodes).map(function (name, key) {
+                var node = nodes[name];
+                if (node instanceof THREE.SkinnedMesh) {
+                    return (_jsx("skinnedMesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry, skeleton: node.skeleton }, key));
+                }
+                else if (node instanceof THREE.Mesh) {
+                    return (_jsx("mesh", { castShadow: true, receiveShadow: true, material: node.material, geometry: node.geometry }, key));
+                }
+            })] }));
+};

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

@@ -3,7 +3,7 @@ import { RigidBodyProps, RigidBodyTypeString } from "@react-three/rapier";
 import { MutableRefObject, RefObject } from "react";
 import * as THREE from "three";
 import { callbackType } from "../../../controller/initialize/callback/type";
-import { groundRayType } from "../../../controller/type";
+import { groundRayType, partsType } from "../../../controller/type";
 import { urlsType } from "../../../world/context/type";
 import { innerRefType, passivePropsType } from "../../passive/type";
 export type characterColliderType = {
@@ -22,6 +22,7 @@ export type InnerGroupRefType = {
     isActive?: boolean;
     ridingUrl?: string;
     offset?: THREE.Vector3;
+    parts?: partsType;
 } & ridingType;
 export type ridingType = {
     isRiderOn?: boolean;
@@ -56,4 +57,5 @@ export type rigidBodyRefType = {
     ridingUrl?: string;
     groundRay?: groundRayType;
     rigidBodyProps?: RigidBodyProps;
+    parts?: partsType;
 } & passivePropsType & innerRefType & callbackType;

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

@@ -33,4 +33,5 @@ export type passivePropsType = {
     rigidBodyProps?: RigidBodyProps;
     outerGroupProps?: THREE.Group;
     innerGroupProps?: THREE.Group;
+    parts?: string[];
 } & ridingType;

package/dist/gaesup/controller/index.js

@@ -65,7 +65,7 @@ export function GaesupControllerInner(props) {
     }, []);
     var prop = __assign(__assign(__assign(__assign({}, initControllerProps({
         refs: refs,
-    })), { children: props.children, groupProps: props.groupProps, rigidBodyProps: props.rigidBodyProps, controllerOptions: gaesupControl.value.controllerOptions }), gaesupControl.value.callbacks), refs);
+    })), { children: props.children, groupProps: props.groupProps, rigidBodyProps: props.rigidBodyProps, controllerOptions: gaesupControl.value.controllerOptions, parts: props.parts }), gaesupControl.value.callbacks), refs);
     initDebug({
         controllerContext: gaesupControl.value,
         controllerDispatch: gaesupControl.dispatch,

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

@@ -54,6 +54,7 @@ export type controllerInnerType = {
     cameraRay: cameraRayType;
     keyControl: keyControlType;
     controllerOptions: controllerOptionsType;
+    parts?: partsType;
 } & controllerOtherPropType & refsType & callbackType;
 export type animationTagType = {
     idle: string;
@@ -89,6 +90,8 @@ export interface controllerOtherPropType extends RigidBodyProps {
     rigidBodyProps?: RigidBodyProps;
     debug?: boolean;
 }
+export type partsType = string[];
 export type controllerType = controllerOtherPropType & urlsType & Partial<gaesupControllerContextPropType> & callbackType & {
     controllerOptions?: controllerOptionsType;
+    parts?: partsType;
 };

package/dist/gaesup/physics/character/index.js

@@ -1,10 +1,12 @@
 import direction from "./direction";
 import impulse from "./impulse";
 import innerCalc from "./innerCalc";
+import queue from "./queue";
 import stop from "./stop";
 export default function characterCalculation(calcProp) {
     direction(calcProp);
     impulse(calcProp);
     innerCalc(calcProp);
     stop(calcProp);
+    queue(calcProp);
 }

package/dist/gaesup/physics/character/queue.d.ts

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

package/dist/gaesup/physics/character/queue.js

@@ -0,0 +1,48 @@
+import { vec3 } from "@react-three/rapier";
+import * as THREE from "three";
+import { calcNorm } from "../../utils";
+export default function queue(prop) {
+    var _a;
+    var rigidBodyRef = prop.rigidBodyRef, state = prop.state, _b = prop.worldContext, clicker = _b.clicker, mode = _b.mode, clickerOption = _b.clickerOption, block = _b.block;
+    var u = vec3((_a = rigidBodyRef.current) === null || _a === void 0 ? void 0 : _a.translation());
+    var norm = calcNorm(u, clicker.point, false);
+    if (clickerOption.autoStart) {
+        if (clickerOption.queue[0] instanceof THREE.Vector3) {
+            clicker.isOn = true;
+            norm = calcNorm(u, clickerOption.queue[0], false);
+            var v = vec3(clickerOption.queue[0]);
+            var newAngle = Math.atan2(v.z - u.z, v.x - u.x);
+            clicker.angle = newAngle;
+        }
+    }
+    if (norm < 1 && mode.controller === "clicker") {
+        if (clickerOption.track && clickerOption.queue.length !== 0) {
+            var Q = clickerOption.queue.shift();
+            if (Q instanceof THREE.Vector3) {
+                clicker.point = Q;
+                var v = vec3(clicker.point);
+                var newAngle = Math.atan2(v.z - u.z, v.x - u.x);
+                clicker.angle = newAngle;
+            }
+            else {
+                var action = Q.action, beforeCB = Q.beforeCB, afterCB_1 = Q.afterCB, time = Q.time;
+                if (action === "stop") {
+                    state.clock.stop();
+                    beforeCB(state);
+                    console.log();
+                    setTimeout(function () {
+                        state.clock.start();
+                        afterCB_1(state);
+                    }, time);
+                }
+            }
+            if (clickerOption.loop) {
+                clickerOption.queue.push(Q);
+            }
+        }
+        else {
+            clicker.isOn = false;
+            clicker.isRun = false;
+        }
+    }
+}

package/dist/gaesup/physics/character/stop.js

@@ -1,35 +1,8 @@
-import { vec3 } from "@react-three/rapier";
-import { calcNorm } from "../../utils";
 export default function stop(prop) {
-    var _a;
-    var rigidBodyRef = prop.rigidBodyRef, _b = prop.worldContext, control = _b.control, clicker = _b.clicker, mode = _b.mode, clickerOption = _b.clickerOption;
+    var _a = prop.worldContext, control = _a.control, clicker = _a.clicker, mode = _a.mode;
     var keyS = control.keyS;
     if (keyS && mode.controller === "clicker") {
         clicker.isOn = false;
         clicker.isRun = false;
     }
-    var u = vec3((_a = rigidBodyRef.current) === null || _a === void 0 ? void 0 : _a.translation());
-    var norm = calcNorm(u, clicker.point, false);
-    if (clickerOption.autoStart) {
-        clicker.isOn = true;
-        norm = calcNorm(u, clickerOption.queue[0], false);
-        var v = vec3(clickerOption.queue[0]);
-        var newAngle = Math.atan2(v.z - u.z, v.x - u.x);
-        clicker.angle = newAngle;
-    }
-    if (norm < 1 && mode.controller === "clicker") {
-        if (clickerOption.track && clickerOption.queue.length !== 0) {
-            clicker.point = clickerOption.queue.shift();
-            var v = vec3(clicker.point);
-            var newAngle = Math.atan2(v.z - u.z, v.x - u.x);
-            clicker.angle = newAngle;
-            if (clickerOption.loop) {
-                clickerOption.queue.push(clicker.point);
-            }
-        }
-        else {
-            clicker.isOn = false;
-            clicker.isRun = false;
-        }
-    }
 }

package/dist/gaesup/tools/clicker/index.js

@@ -1,17 +1,23 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { Line } from "@react-three/drei";
 import { useContext } from "react";
+import * as THREE from "three";
 import { GaesupWorldContext } from "../../world/context";
 export function Clicker(_a) {
     var onMarker = _a.onMarker, runMarker = _a.runMarker;
     var _b = useContext(GaesupWorldContext), clicker = _b.clicker, mode = _b.mode, clickerOption = _b.clickerOption;
+    var pointQ = [];
+    for (var i = 0; i < clickerOption.queue.length; i++) {
+        if (clickerOption.queue[i] instanceof THREE.Vector3) {
+            pointQ.push(clickerOption.queue[i]);
+        }
+    }
     return (_jsxs(_Fragment, { children: [mode.controller === "clicker" && (_jsxs("group", { position: clicker.point, children: [clicker.isOn && onMarker, clicker.isOn && clickerOption.isRun && clicker.isRun && runMarker] })), clickerOption.line &&
-                clickerOption.queue.map(function (item, key) {
-                    var current = key;
-                    var before = key === 0 ? clickerOption.queue.length - 1 : key - 1;
-                    return (_jsxs("group", { position: [0, 1, 0], children: [_jsx(Line, { worldUnits: true, points: [
-                                    clickerOption.queue[before],
-                                    clickerOption.queue[current],
-                                ], color: "turquoise", transparent: true, opacity: 0.5, lineWidth: 0.4 }), _jsxs("mesh", { position: item, children: [_jsx("sphereGeometry", { args: [0.6, 30, 0.6] }), _jsx("meshStandardMaterial", { color: "turquoise", transparent: true, opacity: 0.8 })] }, key)] }));
+                pointQ.map(function (queueItem, key) {
+                    if (queueItem instanceof THREE.Vector3) {
+                        var current = key;
+                        var before = key === 0 ? pointQ.length - 1 : key - 1;
+                        return (_jsxs("group", { position: [0, 1, 0], children: [_jsx(Line, { worldUnits: true, points: [pointQ[before], pointQ[current]], color: "turquoise", transparent: true, opacity: 0.5, lineWidth: 0.4 }), _jsxs("mesh", { position: queueItem, children: [_jsx("sphereGeometry", { args: [0.6, 30, 0.6] }), _jsx("meshStandardMaterial", { color: "turquoise", transparent: true, opacity: 0.8 })] }, key)] }, key));
+                    }
                 })] }));
 }

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

@@ -1,5 +1,6 @@
 import { CSSProperties } from "react";
 import { actionsType, refsType } from "../../controller/type";
+import { RootState } from "@react-three/fiber";
 import * as THREE from "three";
 import { rideableType } from "../../hooks/useRideable/type";
 import { joyStickInnerType } from "../../tools/joystick/type";
@@ -107,13 +108,22 @@ export type clickerType = {
     isOn: boolean;
     isRun: boolean;
 };
+export type queueActionType = "stop";
+export type queueFunctionType = {
+    action: queueActionType;
+    beforeCB: (state: RootState) => void;
+    afterCB: (state: RootState) => void;
+    time: number;
+};
+export type queueItemtype = THREE.Vector3 | queueFunctionType;
+export type queueType = queueItemtype[];
 export type clickerOptionType = {
     autoStart?: boolean;
     isRun?: boolean;
     throttle?: number;
     track?: boolean;
     loop?: boolean;
-    queue?: THREE.Vector3[];
+    queue?: queueType;
     line?: boolean;
 };
 export type wheelStateType = {

package/package.json

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