@react-three/rapier 0.16.0-canary.0 → 1.0.0-canary.2

package/dist/react-three-rapier.cjs.prod.js

@@ -72,40 +72,6 @@ function _objectSpread2(target) {
   return target;
 }
 
-const createWorldApi = getWorld => {
-  return {
-    raw: () => getWorld(),
-    getCollider: handle => getWorld().getCollider(handle),
-    getRigidBody: handle => getWorld().getRigidBody(handle),
-    createRigidBody: desc => getWorld().createRigidBody(desc),
-    createCollider: (desc, rigidBody) => getWorld().createCollider(desc, rigidBody),
-    removeRigidBody: rigidBody => {
-      if (!getWorld().bodies.contains(rigidBody.handle)) return;
-      getWorld().removeRigidBody(rigidBody);
-    },
-    removeCollider: (collider, wakeUp = true) => {
-      if (!getWorld().colliders.contains(collider.handle)) return;
-      getWorld().removeCollider(collider, wakeUp);
-    },
-    createImpulseJoint: (params, rigidBodyA, rigidBodyB, wakeUp = true) => getWorld().createImpulseJoint(params, rigidBodyA, rigidBodyB, wakeUp),
-    removeImpulseJoint: (joint, wakeUp = true) => {
-      if (!getWorld().impulseJoints.contains(joint.handle)) return;
-      getWorld().removeImpulseJoint(joint, wakeUp);
-    },
-    forEachCollider: callback => getWorld().forEachCollider(callback),
-    setGravity: ({
-      x,
-      y,
-      z
-    }) => getWorld().gravity = {
-      x,
-      y,
-      z
-    },
-    debugRender: () => getWorld().debugRender()
-  };
-};
-
 const _quaternion = new three.Quaternion();
 new three.Euler();
 const _vector3 = new three.Vector3();
@@ -684,30 +650,37 @@ const Debug = /*#__PURE__*/React.memo(() => {
 });
 
 /**
- * Initiate an instance and return a safe getter
+ * Creates a proxy that will create a singleton instance of the given class
+ * when a property is accessed, and not before.
+ *
+ * @returns A proxy and a reset function, so that the instance can created again
  */
+const createSingletonProxy = createInstance => {
+  let instance;
+  const handler = {
+    get(target, prop) {
+      if (!instance) {
+        instance = createInstance();
+      }
 
-const useImperativeInstance = (createFn, destroyFn, dependencyList) => {
-  const ref = React.useRef();
-  const getInstance = React.useCallback(() => {
-    if (!ref.current) {
-      ref.current = createFn();
+      return Reflect.get(instance, prop);
     }
 
-    return ref.current;
-  }, dependencyList);
-  React.useEffect(() => {
-    // Save the destroy function and instance
-    const instance = getInstance();
+  };
+  const proxy = new Proxy({}, handler);
 
-    const destroy = () => destroyFn(instance);
+  const reset = () => {
+    instance = undefined;
+  };
+  /**
+   * Return the proxy and a reset function
+   */
 
-    return () => {
-      destroy();
-      ref.current = undefined;
-    };
-  }, [getInstance]);
-  return getInstance;
+
+  return {
+    proxy,
+    reset
+  };
 };
 
 const rapierContext = /*#__PURE__*/React.createContext(undefined);
@@ -759,38 +732,42 @@ const Physics = ({
   const rapier = useAsset.useAsset(importRapier);
   const {
     invalidate
-  } = fiber.useThree(); // Init World
-
-  const getWorld = useImperativeInstance(() => {
-    return new rapier.World(vectorArrayToVector3(_gravity));
-  }, world => {
-    world.free();
-  }, []);
+  } = fiber.useThree();
   const rigidBodyStates = useConst(() => new Map());
   const colliderStates = useConst(() => new Map());
   const rigidBodyEvents = useConst(() => new Map());
   const colliderEvents = useConst(() => new Map());
   const eventQueue = useConst(() => new rapier3dCompat.EventQueue(false));
   const beforeStepCallbacks = useConst(() => new Set());
-  const afterStepCallbacks = useConst(() => new Set()); // Update gravity
+  const afterStepCallbacks = useConst(() => new Set());
+  /**
+   * Initiate the world
+   * This creates a singleton proxy, so that the world is only created when
+   * something within it is accessed.
+   */
 
+  const {
+    proxy: worldProxy,
+    reset: resetWorldProxy
+  } = useConst(() => createSingletonProxy(() => new rapier.World(vectorArrayToVector3(_gravity))));
   React.useEffect(() => {
-    const world = getWorld();
+    return () => {
+      worldProxy.free();
+      resetWorldProxy();
+    };
+  }, []); // Update gravity
 
-    if (world) {
-      world.gravity = vectorArrayToVector3(_gravity);
-    }
+  React.useEffect(() => {
+    worldProxy.gravity = vectorArrayToVector3(_gravity);
   }, [_gravity]);
-  const api = React.useMemo(() => createWorldApi(getWorld), []);
   const getSourceFromColliderHandle = React.useCallback(handle => {
     var _collider$parent;
 
-    const world = getWorld();
-    const collider = world.getCollider(handle);
+    const collider = worldProxy.getCollider(handle);
     const colEvents = colliderEvents.get(handle);
     const colliderState = colliderStates.get(handle);
     const rigidBodyHandle = collider === null || collider === void 0 ? void 0 : (_collider$parent = collider.parent()) === null || _collider$parent === void 0 ? void 0 : _collider$parent.handle;
-    const rigidBody = rigidBodyHandle !== undefined ? world.getRigidBody(rigidBodyHandle) : undefined;
+    const rigidBody = rigidBodyHandle !== undefined ? worldProxy.getRigidBody(rigidBodyHandle) : undefined;
     const rbEvents = rigidBody && rigidBodyHandle !== undefined ? rigidBodyEvents.get(rigidBodyHandle) : undefined;
     const rigidBodyState = rigidBodyHandle !== undefined ? rigidBodyStates.get(rigidBodyHandle) : undefined;
     const source = {
@@ -812,7 +789,7 @@ const Physics = ({
     accumulator: 0
   });
   const step = React.useCallback(dt => {
-    const world = getWorld();
+    const world = worldProxy;
     /* Check if the timestep is supposed to be variable. We'll do this here
       once so we don't have to string-check every frame. */
 
@@ -827,12 +804,12 @@ const Physics = ({
     const stepWorld = () => {
       // Trigger beforeStep callbacks
       beforeStepCallbacks.forEach(callback => {
-        callback.current(api);
+        callback.current(worldProxy);
       });
       world.step(eventQueue); // Trigger afterStep callbacks
 
       afterStepCallbacks.forEach(callback => {
-        callback.current(api);
+        callback.current(worldProxy);
       });
     };
 
@@ -1022,7 +999,7 @@ const Physics = ({
   }, [_paused, _timeStep, _interpolate]);
   const context = React.useMemo(() => ({
     rapier,
-    world: api,
+    world: worldProxy,
     physicsOptions: {
       colliders: _colliders,
       gravity: _gravity
@@ -1068,6 +1045,33 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
+/**
+ * Initiate an instance and return a safe getter
+ */
+
+const useImperativeInstance = (createFn, destroyFn, dependencyList) => {
+  const ref = React.useRef();
+  const getInstance = React.useCallback(() => {
+    if (!ref.current) {
+      ref.current = createFn();
+    }
+
+    return ref.current;
+  }, dependencyList);
+  React.useEffect(() => {
+    // Save the destroy function and instance
+    const instance = getInstance();
+
+    const destroy = () => destroyFn(instance);
+
+    return () => {
+      destroy();
+      ref.current = undefined;
+    };
+  }, [getInstance]);
+  return getInstance;
+};
+
 /**
  * Takes an object resembling a Vector3 and returs a Three.Vector3
  * @category Math helpers
@@ -1119,6 +1123,20 @@ const euler = ({
   return new three.Euler(x, y, z);
 };
 
+const useForwardedRef = (forwardedRef, defaultValue = null) => {
+  const innerRef = React.useRef(defaultValue); // Update the forwarded ref when the inner ref changes
+
+  if (forwardedRef && typeof forwardedRef !== "function") {
+    if (!forwardedRef.current) {
+      forwardedRef.current = innerRef.current;
+    }
+
+    return forwardedRef;
+  }
+
+  return innerRef;
+};
+
 /**
  * A collider is a shape that can be attached to a rigid body to define its physical properties.
  * @internal
@@ -1138,24 +1156,30 @@ const AnyCollider = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((prop
     colliderStates
   } = useRapier();
   const rigidBodyContext = useRigidBodyContext();
-  const ref = React.useRef(null); // We spread the props out here to make sure that the ref is updated when the props change.
+  const colliderRef = useForwardedRef(forwardedRef);
+  const objectRef = React.useRef(null); // We spread the props out here to make sure that the ref is updated when the props change.
 
   const immutablePropArray = immutableColliderOptions.flatMap(key => Array.isArray(props[key]) ? [...props[key]] : props[key]);
   const getInstance = useImperativeInstance(() => {
-    const worldScale = ref.current.getWorldScale(vec3());
+    const worldScale = objectRef.current.getWorldScale(vec3());
     const collider = createColliderFromOptions(props, world, worldScale, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.getRigidBody);
+
+    if (typeof forwardedRef == "function") {
+      forwardedRef(collider);
+    }
+
+    colliderRef.current = collider;
     return collider;
   }, collider => {
-    world.removeCollider(collider);
+    world.removeCollider(collider, true);
   }, [...immutablePropArray, rigidBodyContext]);
   React.useEffect(() => {
     const collider = getInstance();
-    colliderStates.set(collider.handle, createColliderState(collider, ref.current, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.ref.current));
+    colliderStates.set(collider.handle, createColliderState(collider, objectRef.current, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.ref.current));
     return () => {
       colliderStates.delete(collider.handle);
     };
   }, [getInstance]);
-  React.useImperativeHandle(forwardedRef, () => getInstance(), [getInstance]);
   const mergedProps = React.useMemo(() => {
     return _objectSpread2(_objectSpread2({}, cleanRigidBodyPropsForCollider(rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.options)), props);
   }, [props, rigidBodyContext === null || rigidBodyContext === void 0 ? void 0 : rigidBodyContext.options]);
@@ -1166,7 +1190,7 @@ const AnyCollider = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((prop
     rotation: rotation,
     quaternion: quaternion,
     scale: scale,
-    ref: ref,
+    ref: objectRef,
     name: name
   }, children);
 }));
@@ -1454,7 +1478,8 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
   } = props,
         objectProps = _objectWithoutProperties(props, _excluded$1);
 
-  const ref = React.useRef(null);
+  const objectRef = React.useRef(null);
+  const rigidBodyRef = useForwardedRef(forwardedRef);
   const {
     world,
     rigidBodyStates,
@@ -1469,11 +1494,17 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
   const immutablePropArray = immutableRigidBodyOptions.flatMap(key => {
     return Array.isArray(mergedOptions[key]) ? [...mergedOptions[key]] : mergedOptions[key];
   });
-  const childColliderProps = useChildColliderProps(ref, mergedOptions); // Provide a way to eagerly create rigidbody
+  const childColliderProps = useChildColliderProps(objectRef, mergedOptions); // Provide a way to eagerly create rigidbody
 
   const getRigidBody = useImperativeInstance(() => {
     const desc = rigidBodyDescFromOptions(mergedOptions);
     const rigidBody = world.createRigidBody(desc);
+
+    if (typeof forwardedRef === "function") {
+      forwardedRef(rigidBody);
+    }
+
+    rigidBodyRef.current = rigidBody;
     return rigidBody;
   }, rigidBody => {
     world.removeRigidBody(rigidBody);
@@ -1483,7 +1514,7 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
     const rigidBody = getRigidBody();
     const state = createRigidBodyState({
       rigidBody,
-      object: ref.current
+      object: objectRef.current
     });
     rigidBodyStates.set(rigidBody.handle, props.transformState ? props.transformState(state) : state);
     return () => {
@@ -1492,10 +1523,9 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
   }, [getRigidBody]);
   useUpdateRigidBodyOptions(getRigidBody, mergedOptions, rigidBodyStates);
   useRigidBodyEvents(getRigidBody, mergedOptions, rigidBodyEvents);
-  React.useImperativeHandle(forwardedRef, () => getRigidBody(), [getRigidBody]);
   const contextValue = React.useMemo(() => {
     return {
-      ref,
+      ref: objectRef,
       getRigidBody: getRigidBody,
       options: mergedOptions
     };
@@ -1503,7 +1533,7 @@ const RigidBody = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props,
   return /*#__PURE__*/React__default["default"].createElement(RigidBodyContext.Provider, {
     value: contextValue
   }, /*#__PURE__*/React__default["default"].createElement("object3D", _extends({
-    ref: ref
+    ref: objectRef
   }, objectProps, {
     position: position,
     rotation: rotation,
@@ -1550,9 +1580,10 @@ const MeshCollider = /*#__PURE__*/React.memo(props => {
 MeshCollider.displayName = "MeshCollider";
 
 const _excluded = ["children", "instances", "colliderNodes", "position", "rotation", "quaternion", "scale"];
-const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props, ref) => {
-  const object = React.useRef(null);
-  const instancedWrapper = React.useRef(null);
+const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  const rigidBodiesRef = useForwardedRef(forwardedRef, []);
+  const objectRef = React.useRef(null);
+  const instanceWrapperRef = React.useRef(null);
 
   const {
     // instanced props
@@ -1567,14 +1598,12 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forward
   } = props,
         rigidBodyProps = _objectWithoutProperties(props, _excluded);
 
-  const rigidBodyApis = React.useRef([]);
-  React.useImperativeHandle(ref, () => rigidBodyApis.current, [instances]);
-  const childColliderProps = useChildColliderProps(object, _objectSpread2(_objectSpread2({}, props), {}, {
+  const childColliderProps = useChildColliderProps(objectRef, _objectSpread2(_objectSpread2({}, props), {}, {
     children: undefined
   }));
 
   const getInstancedMesh = () => {
-    const firstChild = instancedWrapper.current.children[0];
+    const firstChild = instanceWrapperRef.current.children[0];
 
     if (firstChild && "isInstancedMesh" in firstChild) {
       return firstChild;
@@ -1614,16 +1643,16 @@ const InstancedRigidBodies = /*#__PURE__*/React.memo( /*#__PURE__*/React.forward
   };
 
   return /*#__PURE__*/React__default["default"].createElement("object3D", _extends({
-    ref: object
+    ref: objectRef
   }, rigidBodyProps, {
     position: position,
     rotation: rotation,
     quaternion: quaternion,
     scale: scale
   }), /*#__PURE__*/React__default["default"].createElement("object3D", {
-    ref: instancedWrapper
+    ref: instanceWrapperRef
   }, children), instances === null || instances === void 0 ? void 0 : instances.map((instance, index) => /*#__PURE__*/React__default["default"].createElement(RigidBody, _extends({}, rigidBodyProps, instance, {
-    ref: body => rigidBodyApis.current[index] = body,
+    ref: body => rigidBodiesRef.current[index] = body,
     transformState: state => applyInstancedState(state, index)
   }), /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, colliderNodes.map((node, index) => /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
     key: index
@@ -1644,14 +1673,15 @@ const useImpulseJoint = (body1, body2, params) => {
   const jointRef = React.useRef();
   useImperativeInstance(() => {
     if (body1.current && body2.current) {
-      const newJoint = world.createImpulseJoint(params, body1.current, body2.current);
-      jointRef.current = newJoint;
+      const newJoint = world.createImpulseJoint(params, body1.current, body2.current, true);
+      jointRef.current = newJoint; // console.log(body1.current, body2.current, newJoint);
+
       return newJoint;
     }
   }, joint => {
     if (joint) {
       jointRef.current = undefined;
-      world.removeImpulseJoint(joint);
+      world.removeImpulseJoint(joint, true);
     }
   }, []);
   return jointRef;