react-three-rapier-unified 1.0.0

package/src/utils/utils-rigidbody.ts

@@ -0,0 +1,231 @@
+import { RigidBody, RigidBodyDesc } from "@dimforge/rapier3d-compat";
+import { useEffect, useMemo } from "react";
+import { Matrix4, Object3D, Vector3 } from "three";
+import { Boolean3Tuple, RigidBodyProps, Vector3Tuple } from "..";
+import {
+  EventMap,
+  RigidBodyState,
+  RigidBodyStateMap
+} from "../components/Physics";
+import {
+  _matrix4,
+  _position,
+  _rotation,
+  _scale,
+  _vector3
+} from "./shared-objects";
+import { rigidBodyTypeFromString, vectorToTuple } from "./utils";
+
+export const rigidBodyDescFromOptions = (options: RigidBodyProps) => {
+  const type = rigidBodyTypeFromString(options?.type || "dynamic");
+
+  const desc = new RigidBodyDesc(type);
+
+  // Apply immutable options
+  desc.canSleep = options?.canSleep ?? true;
+
+  return desc;
+};
+
+interface CreateRigidBodyStateOptions {
+  object: Object3D;
+  rigidBody: RigidBody;
+  setMatrix?: (matrix: Matrix4) => void;
+  getMatrix?: (matrix: Matrix4) => Matrix4;
+  worldScale?: Vector3;
+  meshType?: RigidBodyState["meshType"];
+}
+
+export const createRigidBodyState = ({
+  rigidBody,
+  object,
+  setMatrix,
+  getMatrix,
+  worldScale,
+  meshType = "mesh"
+}: CreateRigidBodyStateOptions): RigidBodyState => {
+  object.updateWorldMatrix(true, false);
+  const invertedWorldMatrix = object.parent!.matrixWorld.clone().invert();
+
+  return {
+    object,
+    rigidBody,
+    invertedWorldMatrix,
+    setMatrix: setMatrix
+      ? setMatrix
+      : (matrix: Matrix4) => {
+          object.matrix.copy(matrix);
+        },
+    getMatrix: getMatrix
+      ? getMatrix
+      : (matrix: Matrix4) => matrix.copy(object.matrix),
+    scale: worldScale || object.getWorldScale(_scale).clone(),
+    isSleeping: false,
+    meshType
+  };
+};
+
+type ImmutableRigidBodyOptions = (keyof RigidBodyProps)[];
+
+export const immutableRigidBodyOptions: ImmutableRigidBodyOptions = [
+  "args",
+  "colliders",
+  "canSleep"
+];
+
+type MutableRigidBodyOptions = {
+  [Prop in keyof RigidBodyProps]: (rb: RigidBody, value: any) => void;
+};
+
+export const mutableRigidBodyOptions: MutableRigidBodyOptions = {
+  gravityScale: (rb: RigidBody, value: number) => {
+    rb.setGravityScale(value, true);
+  },
+  additionalSolverIterations(rb: RigidBody, value: number) {
+    rb.setAdditionalSolverIterations(value);
+  },
+  linearDamping: (rb: RigidBody, value: number) => {
+    rb.setLinearDamping(value);
+  },
+  angularDamping: (rb: RigidBody, value: number) => {
+    rb.setAngularDamping(value);
+  },
+  dominanceGroup: (rb: RigidBody, value: number) => {
+    rb.setDominanceGroup(value);
+  },
+  enabledRotations: (rb: RigidBody, [x, y, z]: Boolean3Tuple) => {
+    rb.setEnabledRotations(x, y, z, true);
+  },
+  enabledTranslations: (rb: RigidBody, [x, y, z]: Boolean3Tuple) => {
+    rb.setEnabledTranslations(x, y, z, true);
+  },
+  lockRotations: (rb: RigidBody, value: boolean) => {
+    rb.lockRotations(value, true);
+  },
+  lockTranslations: (rb: RigidBody, value: boolean) => {
+    rb.lockTranslations(value, true);
+  },
+  angularVelocity: (rb: RigidBody, [x, y, z]: Vector3Tuple) => {
+    rb.setAngvel({ x, y, z }, true);
+  },
+  linearVelocity: (rb: RigidBody, [x, y, z]: Vector3Tuple) => {
+    rb.setLinvel({ x, y, z }, true);
+  },
+  ccd: (rb: RigidBody, value: boolean) => {
+    rb.enableCcd(value);
+  },
+  softCcdPrediction: (rb: RigidBody, value: number) => {
+    rb.setSoftCcdPrediction(value);
+  },
+  userData: (rb: RigidBody, value: { [key: string]: any }) => {
+    rb.userData = value;
+  },
+  type(rb, value) {
+    rb.setBodyType(rigidBodyTypeFromString(value), true);
+  },
+  position: () => {},
+  rotation: () => {},
+  quaternion: () => {},
+  scale: () => {}
+};
+
+const mutableRigidBodyOptionKeys = Object.keys(mutableRigidBodyOptions);
+
+export const setRigidBodyOptions = (
+  rigidBody: RigidBody,
+  options: RigidBodyProps,
+  states: RigidBodyStateMap,
+  updateTranslations: boolean = true
+) => {
+  if (!rigidBody) {
+    return;
+  }
+
+  const state = states.get(rigidBody.handle);
+
+  if (state) {
+    if (updateTranslations) {
+      state.object.updateWorldMatrix(true, false);
+
+      _matrix4
+        .copy(state.object.matrixWorld)
+        .decompose(_position, _rotation, _scale);
+
+      rigidBody.setTranslation(_position, false);
+      rigidBody.setRotation(_rotation, false);
+    }
+
+    mutableRigidBodyOptionKeys.forEach((key) => {
+      if (key in options) {
+        mutableRigidBodyOptions[key as keyof RigidBodyProps]!(
+          rigidBody,
+          options[key as keyof RigidBodyProps]
+        );
+      }
+    });
+  }
+};
+
+export const useUpdateRigidBodyOptions = (
+  getRigidBody: () => RigidBody,
+  props: RigidBodyProps,
+  states: RigidBodyStateMap,
+  updateTranslations: boolean = true
+) => {
+  // TODO: Improve this, split each prop into its own effect
+  const mutablePropsAsFlatArray = useMemo(
+    () =>
+      mutableRigidBodyOptionKeys.flatMap((key) => {
+        return vectorToTuple(props[key as keyof RigidBodyProps]);
+      }),
+    [props]
+  );
+
+  useEffect(() => {
+    const rigidBody = getRigidBody();
+    setRigidBodyOptions(rigidBody, props, states, updateTranslations);
+  }, mutablePropsAsFlatArray);
+};
+
+export const useRigidBodyEvents = (
+  getRigidBody: () => RigidBody,
+  props: RigidBodyProps,
+  events: EventMap
+) => {
+  const {
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  } = props;
+
+  const eventHandlers = {
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  };
+
+  useEffect(() => {
+    const rigidBody = getRigidBody();
+    events.set(rigidBody.handle, eventHandlers);
+
+    return () => {
+      events.delete(rigidBody.handle);
+    };
+  }, [
+    onWake,
+    onSleep,
+    onCollisionEnter,
+    onCollisionExit,
+    onIntersectionEnter,
+    onIntersectionExit,
+    onContactForce
+  ]);
+};

package/src/utils/utils.ts

@@ -0,0 +1,105 @@
+import { useRef } from "react";
+import {
+  Quaternion as RapierQuaternion,
+  Vector3 as RapierVector3
+} from "@dimforge/rapier3d-compat";
+import { Euler, Quaternion, Vector3 } from "three";
+import { _euler, _quaternion, _vector3 } from "./shared-objects";
+import { RigidBodyTypeString, Vector3Tuple } from "../types";
+import {
+  Vector3 as Vector3Like,
+  Quaternion as QuaternionLike
+} from "@react-three/fiber";
+
+export const vectorArrayToVector3 = (arr: Vector3Tuple) => {
+  const [x, y, z] = arr;
+  return new Vector3(x, y, z);
+};
+
+export const vector3ToQuaternion = (v: Vector3) => {
+  return _quaternion.setFromEuler(_euler.setFromVector3(v));
+};
+
+export const rapierVector3ToVector3 = ({ x, y, z }: RapierVector3) =>
+  _vector3.set(x, y, z);
+
+export const rapierQuaternionToQuaternion = ({
+  x,
+  y,
+  z,
+  w
+}: RapierQuaternion) => _quaternion.set(x, y, z, w);
+
+export const vector3ToRapierVector = (v: Vector3Like) => {
+  if (Array.isArray(v)) {
+    return new RapierVector3(v[0], v[1], v[2]);
+  } else if (typeof v === "number") {
+    return new RapierVector3(v, v, v);
+  } else {
+    const threeVector3 = v as Vector3;
+    return new RapierVector3(threeVector3.x, threeVector3.y, threeVector3.z);
+  }
+};
+
+export const quaternionToRapierQuaternion = (v: QuaternionLike) => {
+  if (Array.isArray(v)) {
+    return new RapierQuaternion(v[0], v[1], v[2], v[3]);
+  } else {
+    return new RapierQuaternion(v.x, v.y, v.z, v.w);
+  }
+};
+
+const rigidBodyTypeMap = {
+  fixed: 1,
+  dynamic: 0,
+  kinematicPosition: 2,
+  kinematicVelocity: 3
+} as const;
+
+export const rigidBodyTypeFromString = (type: RigidBodyTypeString) =>
+  rigidBodyTypeMap[type];
+
+export const scaleVertices = (vertices: ArrayLike<number>, scale: Vector3) => {
+  const scaledVerts = Array.from(vertices);
+
+  for (let i = 0; i < vertices.length / 3; i++) {
+    scaledVerts[i * 3] *= scale.x;
+    scaledVerts[i * 3 + 1] *= scale.y;
+    scaledVerts[i * 3 + 2] *= scale.z;
+  }
+
+  return scaledVerts;
+};
+
+export const vectorToTuple = (
+  v: Vector3 | Quaternion | any[] | undefined | number | Euler
+) => {
+  if (!v) return [0];
+
+  if (v instanceof Quaternion) {
+    return [v.x, v.y, v.z, v.w];
+  }
+
+  if (v instanceof Vector3 || v instanceof Euler) {
+    return [v.x, v.y, v.z];
+  }
+
+  if (Array.isArray(v)) {
+    return v;
+  }
+
+  return [v];
+};
+
+export function useConst<T>(initialValue: T | (() => T)): T {
+  const ref = useRef<{ value: T }>(undefined);
+  if (ref.current === undefined) {
+    ref.current = {
+      value:
+        typeof initialValue === "function"
+          ? (initialValue as Function)()
+          : initialValue
+    };
+  }
+  return ref.current.value;
+}