gaesup-world 0.0.1

package/src/gaesup/initial/gaesupWorld/collider/gltf.ts

@@ -0,0 +1,91 @@
+import { useLoader } from "@react-three/fiber";
+import { useEffect } from "react";
+import * as THREE from "three";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { GLTFResult } from "../../../component/gltf/type";
+import { S3 } from "../../../utils/constant";
+import { innerColliderPropType } from "../type";
+
+export type getGltfResultType = {
+  characterGltf: GLTFResult;
+  vehicleGltf: GLTFResult;
+  wheelGltf: GLTFResult;
+  airplaneGltf: GLTFResult;
+  characterSize: THREE.Vector3;
+  vehicleSize: THREE.Vector3;
+  wheelSize: THREE.Vector3;
+  airplaneSize: THREE.Vector3;
+};
+
+export default function getGltf({
+  value,
+  dispatch,
+}: innerColliderPropType): getGltfResultType {
+  const { url } = value;
+  const result = {
+    characterGltf: null,
+    vehicleGltf: null,
+    wheelGltf: null,
+    airplaneGltf: null,
+    characterSize: null,
+    vehicleSize: null,
+    wheelSize: null,
+    airplaneSize: null,
+  };
+  if (url.characterUrl) {
+    const characterGltf: GLTFResult = useLoader(GLTFLoader, url.characterUrl);
+    const { scene: characterScene } = characterGltf;
+    const characterSize = new THREE.Box3()
+      .setFromObject(characterScene)
+      .getSize(new THREE.Vector3());
+    result.characterGltf = characterGltf;
+    result.characterSize = characterSize;
+  }
+  if (url.vehicleUrl) {
+    const vehicleGltf: GLTFResult = useLoader(GLTFLoader, url.vehicleUrl);
+    const wheelGltf: GLTFResult = useLoader(
+      GLTFLoader,
+      url.wheelUrl || S3 + "/wheel.glb"
+    );
+    const { scene: vehicleScene } = vehicleGltf;
+    const { scene: wheelScene } = wheelGltf;
+    const vehicleSize = new THREE.Box3()
+      .setFromObject(vehicleScene)
+      .getSize(new THREE.Vector3());
+    const wheelsize = new THREE.Box3()
+      .setFromObject(wheelScene)
+      .getSize(new THREE.Vector3());
+    result.vehicleGltf = vehicleGltf;
+    result.wheelGltf = wheelGltf;
+    result.vehicleSize = vehicleSize;
+    result.wheelSize = wheelsize;
+  }
+  if (url.airplaneUrl) {
+    const airplaneGltf: GLTFResult = useLoader(GLTFLoader, url.airplaneUrl);
+    const { scene: airplaneScene } = airplaneGltf;
+    const airplaneSize = new THREE.Box3()
+      .setFromObject(airplaneScene)
+      .getSize(new THREE.Vector3());
+    result.airplaneGltf = airplaneGltf;
+    result.airplaneSize = airplaneSize;
+  }
+
+  useEffect(() => {
+    dispatch({
+      type: "update",
+      payload: {
+        characterGltf: result.characterGltf,
+        vehicleGltf: result.vehicleGltf,
+        wheelGltf: result.wheelGltf,
+        airplaneGltf: result.airplaneGltf,
+      },
+    });
+  }, [
+    url,
+    result.airplaneGltf,
+    result.characterGltf,
+    result.vehicleGltf,
+    result.wheelGltf,
+  ]);
+  return result;
+}

package/src/gaesup/initial/gaesupWorld/collider/index.ts

@@ -0,0 +1,26 @@
+import { Dispatch } from "react";
+import { gaesupWorldPropType } from "../../../stores/context/gaesupworld/type";
+import { innerColliderPropType } from "../type";
+import { airplane } from "./airplane";
+import { character } from "./character";
+import getGltf from "./gltf";
+import { vehicle } from "./vehicle";
+
+export default function initColider(
+  value: gaesupWorldPropType,
+  dispatch: Dispatch<{
+    type: string;
+    payload?: Partial<gaesupWorldPropType>;
+  }>
+) {
+  const colliderProps: innerColliderPropType = {
+    gltf: null,
+    value,
+    dispatch,
+  };
+  const gltf = getGltf(colliderProps);
+  colliderProps.gltf = gltf;
+  character(colliderProps);
+  vehicle(colliderProps);
+  airplane(colliderProps);
+}

package/src/gaesup/initial/gaesupWorld/collider/vehicle.ts

@@ -0,0 +1,43 @@
+import { useEffect } from "react";
+import { innerColliderPropType } from "../type";
+
+export function vehicle({ gltf, value, dispatch }: innerColliderPropType) {
+  const { url } = value;
+  if (!url || !url.vehicleUrl) return;
+  const { vehicleSize, wheelSize } = gltf;
+
+  useEffect(() => {
+    if (
+      vehicleSize.x !== 0 &&
+      vehicleSize.y !== 0 &&
+      vehicleSize.z !== 0 &&
+      wheelSize.x !== 0 &&
+      wheelSize.y !== 0 &&
+      wheelSize.z !== 0
+    ) {
+      dispatch({
+        type: "update",
+        payload: {
+          vehicleCollider: {
+            vehicleSizeX: vehicleSize.x,
+            vehicleSizeY: wheelSize.y,
+            vehicleSizeZ: vehicleSize.z,
+            wheelSizeX: wheelSize.x,
+            wheelSizeY: wheelSize.y,
+            wheelSizeZ: wheelSize.z,
+            vehicleX: vehicleSize.x / 2,
+            vehicleY: wheelSize.y / 2,
+            vehicleZ: vehicleSize.z / 2,
+          },
+        },
+      });
+    }
+  }, [
+    vehicleSize.x,
+    vehicleSize.y,
+    vehicleSize.z,
+    wheelSize.x,
+    wheelSize.y,
+    wheelSize.z,
+  ]);
+}

package/src/gaesup/initial/gaesupWorld/index.ts

@@ -0,0 +1,82 @@
+import { useMemo, useReducer } from "react";
+import { activeStateDefault } from "../../stores/active";
+import { animationDefault } from "../../stores/animation";
+import {
+  airplaneColliderDefault,
+  characterColliderDefault,
+  vehicleColliderDefault,
+} from "../../stores/collider";
+import { modeDefault } from "../../stores/context/gaesupworld";
+import { gaesupReducer } from "../../stores/context/gaesupworld/reducer";
+import { controlDefault } from "../../stores/control";
+import { joyStickDefault } from "../../stores/joystick";
+import { minimapDefault } from "../../stores/minimap";
+import { statesDefault } from "../../stores/states";
+import { urlDefault } from "../../stores/url";
+import minimap from "../../tools/minimap";
+import { V3 } from "../../utils/vector";
+import initColider from "./collider";
+import { initGaesupWorldPropsType } from "./type";
+
+export default function initGaesupWorld(props: initGaesupWorldPropsType) {
+  const [value, dispatch] = useReducer(gaesupReducer, {
+    activeState: {
+      ...activeStateDefault,
+      ...{ position: props.startPosition || V3(0, 2, 5) },
+    },
+    characterCollider: Object.assign(
+      characterColliderDefault,
+      props.characterCollider || {}
+    ),
+    vehicleCollider: Object.assign(
+      vehicleColliderDefault,
+      props.vehicleCollider || {}
+    ),
+    airplaneCollider: Object.assign(
+      airplaneColliderDefault,
+      props.airplaneCollider || {}
+    ),
+    mode: Object.assign(modeDefault, props.mode || {}),
+    url: Object.assign(urlDefault, props.url || {}),
+    characterGltf: null,
+    vehicleGltf: null,
+    wheelGltf: null,
+    airplaneGltf: null,
+    states: statesDefault,
+    debug: false,
+    minimap: Object.assign(minimapDefault, minimap || {}),
+    joystick: joyStickDefault,
+    control: controlDefault,
+    points: [],
+    refs: null,
+    animations: animationDefault,
+  });
+
+  const gaesupProps = useMemo(
+    () => ({ value, dispatch }),
+    [
+      value.characterCollider,
+      value.vehicleCollider,
+      value.airplaneCollider,
+      value.airplaneGltf,
+      value.vehicleGltf,
+      value.wheelGltf,
+      value.url,
+      value.mode,
+      value.states,
+      value.debug,
+      value.minimap,
+      value.joystick,
+      value.control,
+      value.points,
+      value.refs,
+      value.animations,
+      value.activeState,
+      dispatch,
+    ]
+  );
+  initColider(value, dispatch);
+  return {
+    gaesupProps,
+  };
+}

package/src/gaesup/initial/gaesupWorld/type.ts

@@ -0,0 +1,37 @@
+import { Dispatch, ReactNode } from "react";
+import {
+  airplaneColliderType,
+  characterColliderType,
+  vehicleColliderType,
+} from "../../stores/collider";
+
+import {
+  gaesupControllerPropType,
+  gaesupWorldPartialPropType,
+  gaesupWorldPropType,
+} from "../../stores/context/gaesupworld/type";
+import { minimapType } from "../../stores/minimap/type";
+import { urlType } from "../../stores/url/type";
+import { getGltfResultType } from "./collider/gltf";
+
+export type initGaesupWorldPropsType = {
+  children: ReactNode;
+  startPosition?: THREE.Vector3;
+  props?: gaesupWorldPartialPropType;
+  url?: urlType;
+  characterCollider?: characterColliderType;
+  vehicleCollider?: vehicleColliderType;
+  airplaneCollider?: airplaneColliderType;
+  mode?: gaesupControllerPropType;
+  debug?: boolean;
+  minimap?: Omit<minimapType, "props">;
+};
+
+export type innerColliderPropType = {
+  gltf?: getGltfResultType;
+  value: gaesupWorldPropType;
+  dispatch: Dispatch<{
+    type: string;
+    payload?: Partial<gaesupWorldPropType>;
+  }>;
+};

package/src/gaesup/physics/airplane/currentSetting.ts

@@ -0,0 +1,20 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function currentSetting(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+    dispatch,
+  } = prop;
+  activeState.position = vec3(rigidBodyRef.current.translation());
+  activeState.velocity = vec3(rigidBodyRef.current.linvel());
+  dispatch({
+    type: "update",
+    payload: {
+      activeState: {
+        ...activeState,
+      },
+    },
+  });
+}

package/src/gaesup/physics/airplane/damping.ts

@@ -0,0 +1,8 @@
+import { calcPropType } from "../type";
+
+export default function damping(prop: calcPropType) {
+  const { rigidBodyRef, constant, control } = prop;
+  const { space } = control;
+  const { brakeRate } = constant;
+  rigidBodyRef.current.setLinearDamping(space ? brakeRate : 0.5);
+}

package/src/gaesup/physics/airplane/direction.ts

@@ -0,0 +1,70 @@
+import { V3 } from "../../utils/vector";
+import { calcPropType } from "../type";
+
+export default function direction(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    innerGroupRef,
+    worldContext: { activeState },
+  } = prop;
+  const { forward, backward, leftward, rightward, shift } = prop.control;
+
+  const boost = Number(shift);
+  const upDown = Number(backward) - Number(forward);
+  const leftRight = Number(rightward) - Number(leftward);
+  const front = V3().set(boost, boost, boost);
+  activeState.euler.y += (Number(leftward) - Number(rightward)) * 0.02;
+
+  const X = Math.PI * 0.01 * upDown;
+  const Z = Math.PI * 0.005 * leftRight;
+
+  const _x = innerGroupRef.current.rotation.x;
+  const _z = innerGroupRef.current.rotation.z;
+
+  const maxX = Math.PI / 16;
+  const maxZ = Math.PI / 16;
+
+  if (_x < -maxX) innerGroupRef.current.rotation.x = -maxX + X;
+  else if (_x > maxX) innerGroupRef.current.rotation.x = maxX + X;
+  else innerGroupRef.current.rotateX(X);
+
+  if (_z < -maxZ) innerGroupRef.current.rotation.z = -maxZ + Z;
+  else if (_z > maxZ) innerGroupRef.current.rotation.z = maxZ + Z;
+  else innerGroupRef.current.rotateZ(Z);
+
+  // current.dir = V3(
+  //   Math.sin(current.euler.y),
+  //   0,
+  //   Math.cos(current.euler.y)
+  // ).normalize();
+  // current.direction = front
+  //   .multiply(current.dir)
+  //   .multiplyScalar(shift ? accelRate : 1);
+  activeState.direction = front.multiply(
+    V3(Math.sin(activeState.euler.y), -upDown, Math.cos(activeState.euler.y))
+  );
+  activeState.dir = activeState.direction.normalize();
+
+  //   const pitch = Number(forward) - Number(backward);
+  //   // const front = vec3().set(start, start * 1, start);
+  //   const yaw = Number(leftward) - Number(rightward);
+  //
+  //   // activeState.euler.y += (side * Math.PI) / 64;
+  //
+  //   // if (euler.x > Math.PI / 16) euler.x = Math.PI / 16 - 0.005;
+  //   // else if (euler.x < -Math.PI / 16) euler.x = -Math.PI / 16 + 0.005;
+  //   // if (euler.z > Math.PI / 16) euler.z = Math.PI / 16 - 0.005;
+  //   // else if (euler.z < -Math.PI / 16) euler.z = -Math.PI / 16 + 0.005;
+  //   // if (euler.y > Math.PI / 4) euler.y = Math.PI / 4 - 0.005;
+  //   // else if (euler.y < -Math.PI / 4) euler.y = -Math.PI / 4 + 0.005;
+  //
+  //   const delta = Math.PI * 0.005;
+  //   euler.x += pitch * delta * Math.cos(euler.z) * Math.cos(euler.y);
+  //   euler.z += -yaw * delta;
+  //   euler.y += pitch * delta * Math.sin(euler.z) * Math.sin(euler.y);
+  //
+  //   // activeState.direction = front.multiply(
+  //   //   V3(Math.sin(activeState.euler.y), 1, Math.cos(activeState.euler.y))
+  //   // );
+  //   // activeState.dir = activeState.direction.normalize();
+}

package/src/gaesup/physics/airplane/gravity.ts

@@ -0,0 +1,11 @@
+import { calcPropType } from "../type";
+
+export default function gravity(prop: calcPropType) {
+  const { rigidBodyRef, groundRay } = prop;
+
+  if (groundRay.hit) {
+    rigidBodyRef.current.setGravityScale(1, false);
+  } else {
+    rigidBodyRef.current.setGravityScale(0.2, false);
+  }
+}

package/src/gaesup/physics/airplane/impulse.ts

@@ -0,0 +1,22 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function impulse(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    constant,
+    control,
+    worldContext: { activeState },
+  } = prop;
+  const { shift } = control;
+  const { accelRate } = constant;
+
+  rigidBodyRef.current.applyImpulse(
+    vec3({
+      x: activeState.direction.x,
+      y: activeState.direction.y,
+      z: activeState.direction.z,
+    }),
+    false
+  );
+}

package/src/gaesup/physics/airplane/index.tsx

@@ -0,0 +1,16 @@
+import { calcPropType } from "../type";
+import currentSetting from "./currentSetting";
+import damping from "./damping";
+import direction from "./direction";
+import gravity from "./gravity";
+import impulse from "./impulse";
+import turn from "./turn";
+
+export default function airplaneCalculation(calcProp: calcPropType) {
+  direction(calcProp);
+  turn(calcProp);
+  impulse(calcProp);
+  damping(calcProp);
+  gravity(calcProp);
+  currentSetting(calcProp);
+}

package/src/gaesup/physics/airplane/turn.ts

@@ -0,0 +1,12 @@
+import { calcPropType } from "../type";
+
+export default function turn(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    innerGroupRef,
+    worldContext: { activeState },
+  } = prop;
+
+  activeState.quat.setFromEuler(activeState.euler);
+  rigidBodyRef.current.setRotation(activeState.quat, true);
+}

package/src/gaesup/physics/airplane copy/currentSetting.ts

@@ -0,0 +1,20 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function currentSetting(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+    dispatch,
+  } = prop;
+  activeState.position = vec3(rigidBodyRef.current.translation());
+  activeState.velocity = vec3(rigidBodyRef.current.linvel());
+  dispatch({
+    type: "update",
+    payload: {
+      activeState: {
+        ...activeState,
+      },
+    },
+  });
+}

package/src/gaesup/physics/airplane copy/direction.ts

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+import { calcPropType } from "../type";
+
+export default function direction(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+  } = prop;
+  const { forward, backward, leftward, rightward } = prop.control;
+  const maxVelocity = 0.04;
+  activeState.yaw *= 0.95;
+  activeState.pitch *= 0.95;
+  if (Math.abs(activeState.yaw) > maxVelocity)
+    activeState.yaw = Math.sign(activeState.yaw) * maxVelocity;
+
+  if (Math.abs(activeState.pitch) > maxVelocity)
+    activeState.pitch = Math.sign(activeState.pitch) * maxVelocity;
+  activeState.yaw += (Number(rightward) - Number(leftward)) * 0.0025;
+  activeState.pitch += (Number(backward) - Number(forward)) * 0.0025;
+
+  activeState.axisX.applyAxisAngle(activeState.axisZ, activeState.yaw);
+  activeState.axisY.applyAxisAngle(activeState.axisX, activeState.pitch);
+  activeState.axisY.applyAxisAngle(activeState.axisZ, activeState.yaw);
+  activeState.axisZ.applyAxisAngle(activeState.axisX, activeState.pitch);
+  activeState.axisX.normalize();
+  activeState.axisY.normalize();
+  activeState.axisZ.normalize();
+  const rotMatrix = new THREE.Matrix4().makeBasis(
+    activeState.axisX,
+    activeState.axisY,
+    activeState.axisZ
+  );
+  activeState.position.add(activeState.axisZ.clone().multiplyScalar(0.1));
+  const matrix = new THREE.Matrix4()
+    .multiply(
+      new THREE.Matrix4().makeTranslation(
+        activeState.position.x,
+        activeState.position.y,
+        activeState.position.z
+      )
+    )
+    .multiply(rotMatrix);
+
+  // rigidBodyRef.current.setTranslation(
+  //   vec3().setFromMatrixPosition(matrix),
+  //   true
+  // );
+  // rigidBodyRef.current.setRotation(
+  //   new THREE.Quaternion().setFromRotationMatrix(matrix),
+  //   true
+  // );
+}

package/src/gaesup/physics/airplane copy/gravity.ts

@@ -0,0 +1,6 @@
+import { calcPropType } from "../type";
+
+export default function gravity(prop: calcPropType) {
+  const { rigidBodyRef } = prop;
+  // rigidBodyRef.current.setGravityScale(0, false);
+}

package/src/gaesup/physics/airplane copy/impulse.ts

@@ -0,0 +1,28 @@
+import { calcPropType } from "../type";
+
+export default function impulse(prop: calcPropType) {
+  const { rigidBodyRef, constant, control, outerGroupRef } = prop;
+  const { accelRate } = constant;
+  const { shift } = control;
+  // current.direction.multiplyScalar(shift ? accelRate : 1);
+  // current.position.setFrom
+  // rigidBodyRef.current.applyImpulse(
+  //   V30()
+  //     .addScalar(shift ? 1 : 0)
+  //     .multiply(
+  //       vec3({
+  //         x: current.direction.x,
+  //         y: current.direction.y,
+  //         z: current.direction.z,
+  //       })
+  //     ),
+  //   false
+  // );
+  // current.position.setFromEuler(current.euler);
+
+  // setCurrent((current) => ({
+  //   ...current,
+  //   position: vec3(rigidBodyRef.current!.translation()),
+  //   velocity: vec3(rigidBodyRef.current!.linvel()),
+  // }));
+}

package/src/gaesup/physics/airplane copy/index.tsx

@@ -0,0 +1,14 @@
+import { calcPropType } from "../type";
+import currentSetting from "./currentSetting";
+import direction from "./direction";
+import gravity from "./gravity";
+import impulse from "./impulse";
+import turn from "./turn";
+
+export default function airplaneCalculation(calcProp: calcPropType) {
+  direction(calcProp);
+  turn(calcProp);
+  impulse(calcProp);
+  gravity(calcProp);
+  currentSetting(calcProp);
+}

package/src/gaesup/physics/airplane copy/turn.ts

@@ -0,0 +1,9 @@
+import { calcPropType } from "../type";
+
+export default function turn(prop: calcPropType) {
+  // const [current] = prop.current;
+  // const { constant, rigidBodyRef } = prop;
+  // const { turnSpeed } = constant;
+  // current.quat.setFromEuler(current.euler);
+  // rigidBodyRef.current.setRotation(current.quat, false);
+}

package/src/gaesup/physics/character/accelaration.ts

@@ -0,0 +1,14 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function accelaration(prop: calcPropType) {
+  const {
+    constant: { walkSpeed, runSpeed },
+    worldContext: { states, activeState },
+  } = prop;
+  const { isMoving, isRunning } = states;
+  if (!isMoving) return null;
+  const speed = isRunning ? runSpeed : walkSpeed;
+  const velocity = vec3().addScalar(speed).multiply(activeState.dir);
+  activeState.acceleration.copy(velocity).sub(activeState.velocity);
+}

package/src/gaesup/physics/character/currentSetting.ts

@@ -0,0 +1,20 @@
+import { vec3 } from "@react-three/rapier";
+import { calcPropType } from "../type";
+
+export default function currentSetting(prop: calcPropType) {
+  const {
+    rigidBodyRef,
+    worldContext: { activeState },
+    dispatch,
+  } = prop;
+  activeState.position = vec3(rigidBodyRef.current.translation());
+  activeState.velocity = vec3(rigidBodyRef.current.linvel());
+  dispatch({
+    type: "update",
+    payload: {
+      activeState: {
+        ...activeState,
+      },
+    },
+  });
+}

package/src/gaesup/physics/character/damping.ts

@@ -0,0 +1,6 @@
+import { calcPropType } from "../type";
+
+export default function damping(prop: calcPropType) {
+  const { rigidBodyRef, constant } = prop;
+  rigidBodyRef.current.setLinearDamping(constant.linearDamping);
+}