gaesup-world 0.0.662 → 0.0.663

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaesup-world",
-  "version": "0.0.662",
+  "version": "0.0.663",
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/gaesup/animation/actions.ts

@@ -1,123 +0,0 @@
-import { useAnimations, useKeyboardControls } from "@react-three/drei";
-import { useFrame } from "@react-three/fiber";
-import { RefObject, useContext, useEffect } from "react";
-import { animationTagType, groundRayType } from "../controller/type";
-import {
-  GaesupWorldContext,
-  GaesupWorldDispatchContext,
-} from "../world/context";
-
-export type playActionsType = {
-  outerGroupRef: RefObject<THREE.Group>;
-  groundRay: groundRayType;
-  isRider?: boolean;
-};
-
-export default function playActions({
-  outerGroupRef,
-  groundRay,
-  isRider,
-}: playActionsType) {
-  const { characterGltf, animations: characterAnimations } =
-    useContext(GaesupWorldContext);
-  const dispatch = useContext(GaesupWorldDispatchContext);
-  const { animations } = characterGltf;
-  const control = useKeyboardControls()[1]();
-  const { actions } = useAnimations(animations, outerGroupRef);
-
-  useEffect(() => {
-    characterAnimations.keyControl = control;
-    dispatch({
-      type: "update",
-      payload: {
-        animations: {
-          ...characterAnimations,
-        },
-      },
-    });
-  }, [control]);
-
-  const playAnimation = (tag: keyof animationTagType) => {
-    characterAnimations.current = tag;
-    dispatch({
-      type: "update",
-      payload: {
-        animations: {
-          ...characterAnimations,
-        },
-      },
-    });
-  };
-
-  const setAnimationName = (actions: {
-    [x: string]: THREE.AnimationAction | null;
-  }) => {
-    characterAnimations.animationNames = Object.assign(
-      characterAnimations.animationNames,
-      Object.keys(actions).reduce((acc, cur) => {
-        return {
-          ...acc,
-          [cur]: cur,
-        };
-      }, {})
-    );
-    dispatch({
-      type: "update",
-      payload: {
-        animations: {
-          ...characterAnimations,
-        },
-      },
-    });
-  };
-
-  const resetAni = () => playAnimation("idle");
-  const playIdle = () => playAnimation("idle");
-  const playWalk = () => playAnimation("walk");
-  const playRun = () => playAnimation("run");
-  const playJump = () => playAnimation("jump");
-  const playFall = () => playAnimation("fall");
-  const playRide = () => playAnimation("ride");
-
-  useEffect(() => {
-    return () => {
-      resetAni();
-    };
-  }, []);
-
-  useEffect(() => {
-    // Play animation
-    const action = actions[characterAnimations.current]
-      ?.reset()
-      .fadeIn(0.2)
-      .play();
-    setAnimationName(actions);
-    return () => {
-      action?.fadeOut(0.2);
-    };
-  }, [characterAnimations.current]);
-
-  const { states, activeState } = useContext(GaesupWorldContext);
-  const { isNotMoving, isMoving, isJumping, isRunning, isAnimationOuter } =
-    states;
-  useFrame(() => {
-    if (isRider) {
-      playRide();
-    } else {
-      if (!isAnimationOuter) {
-        if (isJumping) {
-          playJump();
-        } else if (isNotMoving) {
-          playIdle();
-        } else if (isRunning) {
-          playRun();
-        } else if (isMoving) {
-          playWalk();
-        }
-        if (groundRay.hit === null && activeState.velocity.y < 0) {
-          playFall();
-        }
-      }
-    }
-  });
-}

package/src/gaesup/animation/index.ts

@@ -1 +0,0 @@
-export * as playActions from "./actions";

package/src/gaesup/camera/cameraCollisionDetecter.tsx

@@ -1,53 +0,0 @@
-import { propType } from "../controller/type";
-
-export default function cameraCollisionDetector(prop: propType) {
-  //   const { cameraRay, constant, options } = prop;
-  //   const { camera } = useThree();
-  const checkCollision = (delta: number) => {
-    //     cameraRay.origin.copy(cameraRay.pivot.position);
-    //     camera.getWorldPosition(cameraRay.position);
-    //     cameraRay.dir.subVectors(cameraRay.position, cameraRay.pivot.position);
-    //     cameraRay.intersects = cameraRay.rayCast!.intersectObjects(
-    //       Object.values(cameraRay.intersectObjectMap)
-    //     );
-    //     if (
-    //       cameraRay.intersects.length &&
-    //       cameraRay.intersects[0].distance <= -constant.cameraInitDistance
-    //     ) {
-    //       if (options.cameraCollisionType === "transparent") {
-    //         cameraRay.intersetesAndTransParented = [...cameraRay.intersects];
-    //         cameraRay.intersetesAndTransParented.map((intersect) => {
-    //           const mesh = intersect.object as THREE.Mesh;
-    //           const material = mesh.material as THREE.MeshStandardMaterial;
-    //           material.opacity = 0.2;
-    //           material.transparent = true;
-    //         });
-    //       } else if (options.cameraCollisionType === "closeUp") {
-    //         constant.cameraMinDistance =
-    //           -cameraRay.intersects[0].distance * constant.cameraCollisionOff < -0.7
-    //             ? -cameraRay.intersects[0].distance * constant.cameraCollisionOff
-    //             : -0.7;
-    //       }
-    //     } else {
-    //       if (options.cameraCollisionType === "transparent") {
-    //         cameraRay.intersetesAndTransParented.map((intersect) => {
-    //           const mesh = intersect.object as THREE.Mesh;
-    //           const material = mesh.material as THREE.MeshStandardMaterial;
-    //           material.opacity = 1;
-    //           material.transparent = false;
-    //         });
-    //         cameraRay.intersetesAndTransParented = [];
-    //       }
-    //       constant.cameraMinDistance = constant.cameraInitDistance;
-    //     }
-    //     cameraRay.lerpingPoint.set(
-    //       cameraRay.followCamera.position.x,
-    //       constant.cameraMinDistance * Math.sin(-cameraRay.followCamera.rotation.x),
-    //       constant.cameraMinDistance * Math.cos(-cameraRay.followCamera.rotation.x)
-    //     );
-    //
-    //     cameraRay.followCamera.position.lerp(cameraRay.lerpingPoint, delta * 4);
-  };
-
-  return { checkCollision };
-}

package/src/gaesup/camera/control/map.ts

@@ -1,10 +0,0 @@
-import { cameraPropType } from "../../physics/type";
-
-export default function mapControl(prop: cameraPropType) {
-  const {
-    state,
-    worldContext: { activeState },
-  } = prop;
-  const position = activeState.position.clone();
-  state.camera.position.set(-10, 10, -10).add(position);
-}

package/src/gaesup/camera/control/normal.ts

@@ -1,16 +0,0 @@
-import { cameraPropType } from "../../physics/type";
-import { V3 } from "../../utils/vector";
-
-export default function normal(prop: cameraPropType) {
-  const {
-    state,
-    controllerContext: { perspectiveCamera },
-    worldContext: { activeState },
-  } = prop;
-  const cameraPosition = activeState.position
-    .clone()
-    .add(V3(perspectiveCamera.XZDistance, perspectiveCamera.YDistance, 0));
-
-  state.camera.position.lerp(cameraPosition, 1);
-  state.camera.lookAt(activeState.position.clone());
-}

package/src/gaesup/camera/control/orbit.ts

@@ -1,31 +0,0 @@
-import { quat } from "@react-three/rapier";
-import { cameraPropType } from "../../physics/type";
-import { V3 } from "../../utils/vector";
-
-export default function orbit(prop: cameraPropType) {
-  const {
-    state,
-    controllerContext: { perspectiveCamera },
-    worldContext: { activeState },
-  } = prop;
-  const cameraPosition = activeState.position.clone().add(
-    V3(Math.sin(activeState.euler.y), 0, Math.cos(activeState.euler.y))
-      .normalize()
-      .clone()
-      .multiplyScalar(perspectiveCamera.XZDistance)
-      .multiplyScalar(perspectiveCamera.isFront ? -1 : 1)
-      .add(V3(0, perspectiveCamera.YDistance, 0))
-  );
-
-  state.camera.position.lerp(cameraPosition, 0.5);
-  state.camera.quaternion.copy(
-    activeState.quat
-      .clone()
-      .multiply(
-        perspectiveCamera.isFront
-          ? quat().setFromAxisAngle(V3(0, 1, 0), Math.PI)
-          : quat()
-      )
-  );
-  state.camera.lookAt(activeState.position);
-}

package/src/gaesup/camera/index.tsx

@@ -1,102 +0,0 @@
-import {
-  MapControls,
-  OrbitControls,
-  OrthographicCamera,
-  PerspectiveCamera,
-} from "@react-three/drei";
-import { useFrame, useThree } from "@react-three/fiber";
-import { useContext } from "react";
-import * as THREE from "three";
-import { GaesupControllerContext } from "../controller/context";
-import { propType, refsType } from "../controller/type";
-import { cameraPropType } from "../physics/type";
-import { GaesupWorldContext } from "../world/context";
-import cameraCollisionDetector from "./cameraCollisionDetecter";
-import mapControl from "./control/map";
-import normal from "./control/normal";
-import orbit from "./control/orbit";
-
-export default function Camera({
-  refs,
-  prop,
-  control,
-}: {
-  refs: refsType;
-  prop: propType;
-  control: {
-    [key: string]: boolean;
-  };
-}) {
-  const worldContext = useContext(GaesupWorldContext);
-  const controllerContext = useContext(GaesupControllerContext);
-  const { cameraMode, perspectiveCamera, orthographicCamera } =
-    controllerContext;
-  const { rigidBodyRef, outerGroupRef } = refs;
-  const { cameraRay } = prop;
-  const { checkCollision } = cameraCollisionDetector(prop);
-  const { scene } = useThree();
-  const { activeState } = worldContext;
-
-  const intersectObjectMap: { [uuid: string]: THREE.Object3D } = {};
-  const cameraProp: cameraPropType = {
-    ...prop,
-    checkCollision,
-    control,
-    controllerContext,
-    worldContext,
-  };
-
-  const getMeshs = (object: THREE.Object3D) => {
-    if (object.userData && object.userData.intangible) return;
-    if (
-      object instanceof THREE.Mesh &&
-      object.geometry.type !== "InstancedBufferGeometry"
-    ) {
-      intersectObjectMap[object.uuid] = object;
-    }
-    object.children.forEach((child) => {
-      getMeshs(child);
-    });
-  };
-
-  useFrame((state, delta) => {
-    if (
-      !rigidBodyRef ||
-      !rigidBodyRef.current ||
-      !outerGroupRef ||
-      !outerGroupRef.current
-    )
-      return null;
-    cameraProp.state = state;
-    cameraProp.delta = delta;
-
-    if (cameraMode.cameraType === "perspective") {
-      scene.children.forEach((child) => getMeshs(child));
-      cameraRay.intersectObjectMap = intersectObjectMap;
-      if (cameraMode.controlType === "orbit") {
-        orbit(cameraProp);
-      } else if (cameraMode.controlType === "normal") {
-        normal(cameraProp);
-      }
-    } else if (cameraMode.cameraType === "orthographic") {
-      mapControl(cameraProp);
-    }
-  });
-
-  return (
-    <>
-      {cameraMode.cameraType === "perspective" && (
-        <>
-          <OrbitControls target={activeState.position} />
-          <PerspectiveCamera makeDefault {...perspectiveCamera} />
-        </>
-      )}
-      {cameraMode.cameraType === "orthographic" && (
-        <>
-          <MapControls target={activeState.position} />
-          <OrthographicCamera makeDefault {...orthographicCamera} />
-        </>
-      )}
-    </>
-  );
-}

package/src/gaesup/camera/type.ts

@@ -1,17 +0,0 @@
-export type cameraRayType = {
-  origin: THREE.Vector3;
-  hit: THREE.Raycaster;
-  rayCast: THREE.Raycaster | null;
-  lerpingPoint: THREE.Vector3;
-  length: number;
-  dir: THREE.Vector3;
-  position: THREE.Vector3;
-  followCamera: THREE.Object3D;
-  pivot: THREE.Object3D;
-  intersetesAndTransParented: THREE.Intersection<
-    THREE.Object3D<THREE.Object3DEventMap>
-  >[];
-  intersects: THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
-  intersectObjects: THREE.Object3D[];
-  intersectObjectMap: { [uuid: string]: THREE.Object3D };
-};

package/src/gaesup/component/Airplane.tsx

@@ -1,52 +0,0 @@
-"use client";
-
-import { propType, refsType } from "../controller/type";
-import calculation from "../physics";
-import { AirplaneInnerGroupRef } from "./gltf/AirplaneGltf";
-import { CharacterInnerGroupRef } from "./gltf/CharacterGltf";
-import {
-  AirplaneCollider,
-  AirplaneGroup,
-  AirplaneRigidBody,
-} from "./ref/airplane";
-import setInit from "./setInit";
-
-export function Airplane({
-  controllerProps,
-  refs,
-}: {
-  controllerProps: propType;
-  refs: refsType;
-}) {
-  const {
-    rigidBodyRef,
-    outerGroupRef,
-    capsuleColliderRef,
-    innerGroupRef,
-    characterInnerRef,
-  } = refs;
-  calculation(controllerProps);
-  setInit(rigidBodyRef);
-
-  return (
-    <>
-      <AirplaneGroup ref={outerGroupRef} controllerProps={controllerProps}>
-        <AirplaneRigidBody ref={rigidBodyRef} controllerProps={controllerProps}>
-          <AirplaneCollider prop={controllerProps} ref={capsuleColliderRef} />
-          {controllerProps.isRider && (
-            <CharacterInnerGroupRef
-              prop={controllerProps}
-              groupProps={controllerProps.groupProps}
-              groundRay={controllerProps.groundRay}
-              refs={refs}
-              callbacks={controllerProps.callbacks}
-              isRider={controllerProps.isRider}
-              ref={characterInnerRef}
-            />
-          )}
-          <AirplaneInnerGroupRef ref={innerGroupRef} />
-        </AirplaneRigidBody>
-      </AirplaneGroup>
-    </>
-  );
-}

package/src/gaesup/component/Character.tsx

@@ -1,58 +0,0 @@
-"use client";
-
-import calculation from "../physics";
-
-import { propType, refsType } from "../controller/type";
-import { CharacterInnerGroupRef, InnerGroupRef } from "./gltf/CharacterGltf";
-import {
-  CharacterCapsuleCollider,
-  CharacterGroup,
-  CharacterRigidBody,
-  CharacterSlopeRay,
-} from "./ref/character";
-import setInit from "./setInit";
-
-export function Character({
-  controllerProps,
-  refs,
-}: {
-  controllerProps: propType;
-  refs: refsType;
-}) {
-  const {
-    capsuleColliderRef,
-    rigidBodyRef,
-    outerGroupRef,
-    slopeRayOriginRef,
-    characterInnerRef,
-    innerGroupRef,
-  } = refs;
-  calculation(controllerProps);
-  setInit(rigidBodyRef);
-  return (
-    <CharacterRigidBody ref={rigidBodyRef} controllerProps={controllerProps}>
-      <CharacterCapsuleCollider
-        prop={controllerProps}
-        ref={capsuleColliderRef}
-      />
-      <CharacterGroup ref={outerGroupRef} controllerProps={controllerProps}>
-        <CharacterSlopeRay
-          slopeRay={controllerProps.slopeRay}
-          groundRay={controllerProps.groundRay}
-          ref={slopeRayOriginRef}
-        />
-        {controllerProps.children}
-        <InnerGroupRef ref={innerGroupRef} />
-        <CharacterInnerGroupRef
-          prop={controllerProps}
-          groupProps={controllerProps.groupProps}
-          groundRay={controllerProps.groundRay}
-          refs={refs}
-          callbacks={controllerProps.callbacks}
-          ref={characterInnerRef}
-          isRider={false}
-        />
-      </CharacterGroup>
-    </CharacterRigidBody>
-  );
-}

package/src/gaesup/component/Vehicle.tsx

@@ -1,43 +0,0 @@
-"use client";
-
-import { propType, refsType } from "../controller/type";
-import calculation from "../physics";
-import { CharacterInnerGroupRef } from "./gltf/CharacterGltf";
-import { VehicleInnerGroupRef } from "./gltf/VehicleGltf";
-import { Wheels } from "./gltf/WheelJoint";
-import { VehicleCollider, VehicleGroup, VehicleRigidBody } from "./ref/vehicle";
-import setInit from "./setInit";
-
-export function Vehicle({
-  controllerProps,
-  refs,
-}: {
-  controllerProps: propType;
-  refs: refsType;
-}) {
-  const { rigidBodyRef, outerGroupRef, characterInnerRef, innerGroupRef } =
-    refs;
-  calculation(controllerProps);
-  setInit(rigidBodyRef);
-
-  return (
-    <VehicleGroup ref={outerGroupRef} controllerProps={controllerProps}>
-      <VehicleRigidBody ref={rigidBodyRef} controllerProps={controllerProps}>
-        <VehicleCollider />
-        {controllerProps.isRider && (
-          <CharacterInnerGroupRef
-            prop={controllerProps}
-            groupProps={controllerProps.groupProps}
-            groundRay={controllerProps.groundRay}
-            refs={refs}
-            callbacks={controllerProps.callbacks}
-            ref={characterInnerRef}
-            isRider={true}
-          />
-        )}
-        <VehicleInnerGroupRef ref={innerGroupRef} />
-      </VehicleRigidBody>
-      <Wheels prop={controllerProps} />
-    </VehicleGroup>
-  );
-}

package/src/gaesup/component/gltf/AirplaneGltf.tsx

@@ -1,31 +0,0 @@
-import { Ref, forwardRef, useContext } from "react";
-import { GaesupWorldContext } from "../../world/context";
-
-export const AirplaneInnerGroupRef = forwardRef((_, ref: Ref<THREE.Group>) => {
-  const { airplaneGltf: gltf } = useContext(GaesupWorldContext);
-  const { materials, nodes } = gltf;
-  return (
-    <>
-      {nodes && materials && (
-        <group receiveShadow castShadow ref={ref}>
-          {Object.keys(nodes).map((name: string, key: number) => {
-            if (
-              nodes[name].type === "Mesh" ||
-              nodes[name].type === "SkinnedMesh"
-            ) {
-              return (
-                <mesh
-                  castShadow
-                  receiveShadow
-                  material={materials[name]}
-                  geometry={nodes[name].geometry}
-                  key={key}
-                />
-              );
-            }
-          })}
-        </group>
-      )}
-    </>
-  );
-});

package/src/gaesup/component/gltf/CharacterGltf.tsx

@@ -1,96 +0,0 @@
-import { GroupProps } from "@react-three/fiber";
-import { Ref, forwardRef, useContext } from "react";
-import playActions from "../../animation/actions";
-import { groundRayType, propType, refsType } from "../../controller/type";
-import initCallback from "../../initial/callback";
-import { callbackType } from "../../initial/callback/type";
-import { GaesupWorldContext } from "../../world/context";
-
-export type characterGltfType = {
-  prop: propType;
-  groupProps?: GroupProps;
-  groundRay: groundRayType;
-  refs: refsType;
-  callbacks?: callbackType;
-  isRider?: boolean;
-};
-
-export const InnerGroupRef = forwardRef((_, ref: Ref<THREE.Group>) => {
-  return <group ref={ref} visible={false} />;
-});
-
-export const CharacterInnerGroupRef = forwardRef(
-  (
-    {
-      prop,
-      groupProps,
-      groundRay,
-      refs,
-      callbacks,
-      isRider,
-    }: characterGltfType,
-    ref: Ref<THREE.Group>
-  ) => {
-    const { characterGltf: gltf } = useContext(GaesupWorldContext);
-    const { materials, nodes } = gltf;
-    const { characterCollider, vehicleCollider } =
-      useContext(GaesupWorldContext);
-
-    initCallback({
-      prop,
-      callbacks,
-      outerGroupRef: refs.outerGroupRef,
-    });
-
-    playActions({
-      outerGroupRef: refs.outerGroupRef,
-      groundRay: groundRay,
-      isRider,
-    });
-
-    return (
-      <>
-        {nodes && materials && (
-          <group
-            receiveShadow
-            castShadow
-            {...groupProps}
-            position={[
-              0,
-              isRider
-                ? vehicleCollider.vehicleSizeY / 2
-                : -characterCollider.height,
-              0,
-            ]}
-            ref={ref}
-          >
-            {Object.values(nodes).find((node) => node.type === "Object3D") && (
-              <primitive
-                object={Object.values(nodes).find(
-                  (node) => node.type === "Object3D"
-                )}
-                visible={false}
-                receiveShadow
-                castShadow
-              />
-            )}
-            {Object.keys(nodes).map((name: string, key: number) => {
-              if (nodes[name].type === "SkinnedMesh") {
-                return (
-                  <skinnedMesh
-                    castShadow
-                    receiveShadow
-                    material={materials[name]}
-                    geometry={nodes[name].geometry}
-                    skeleton={(nodes[name] as THREE.SkinnedMesh).skeleton}
-                    key={key}
-                  />
-                );
-              }
-            })}
-          </group>
-        )}
-      </>
-    );
-  }
-);

package/src/gaesup/component/gltf/VehicleGltf.tsx

@@ -1,31 +0,0 @@
-import { Ref, forwardRef, useContext } from "react";
-import { GaesupWorldContext } from "../../world/context";
-
-export const VehicleInnerGroupRef = forwardRef((_, ref: Ref<THREE.Group>) => {
-  const { vehicleGltf: gltf } = useContext(GaesupWorldContext);
-  const { materials, nodes } = gltf;
-  return (
-    <>
-      {nodes && materials && (
-        <group receiveShadow castShadow rotation={[0, Math.PI, 0]} ref={ref}>
-          {Object.keys(nodes).map((name: string, key: number) => {
-            if (
-              nodes[name].type === "Mesh" ||
-              nodes[name].type === "SkinnedMesh"
-            ) {
-              return (
-                <mesh
-                  castShadow
-                  receiveShadow
-                  material={materials[name]}
-                  geometry={nodes[name].geometry}
-                  key={key}
-                />
-              );
-            }
-          })}
-        </group>
-      )}
-    </>
-  );
-});