feat(cannon): migrate spring

Author: Chau Tran

libs/cannon/services/src/constraint.ts

@@ -5,7 +5,7 @@ import {
     HingeConstraintOpts,
     PointToPointConstraintOpts,
 } from '@pmndrs/cannon-worker-api';
-import { NgtAnyRecord, NgtInjectedRef, assertInjectionContext, injectNgtRef, is } from 'angular-three';
+import { NgtAnyRecord, NgtInjectedRef, assertInjectionContext, injectNgtRef, is, makeId } from 'angular-three';
 import { NGTC_PHYSICS_API } from 'angular-three-cannon';
 import * as THREE from 'three';
 
@@ -105,14 +105,14 @@ function injectConstraint<
         const physicsApi = inject(NGTC_PHYSICS_API);
         const { worker } = physicsApi();
 
-        const uuid = THREE.MathUtils.generateUUID();
+        const uuid = makeId();
 
         const bodyARef = is.ref(bodyA) ? bodyA : injectNgtRef(bodyA);
         const bodyBRef = is.ref(bodyB) ? bodyB : injectNgtRef(bodyB);
 
         effect((onCleanup) => {
             deps();
-            if (bodyARef.untracked && bodyBRef.untracked) {
+            if (bodyARef.nativeElement && bodyBRef.nativeElement) {
                 worker.addConstraint({
                     props: [bodyARef.untracked.uuid, bodyBRef.untracked.uuid, untracked(opts)],
                     type,

libs/cannon/services/src/index.ts

@@ -1,2 +1,3 @@
 export * from './body';
 export * from './constraint';
+export * from './spring';

libs/cannon/services/src/spring.ts

@@ -0,0 +1,64 @@
+import { Injector, Signal, computed, effect, inject, runInInjectionContext, untracked } from '@angular/core';
+import { SpringOptns } from '@pmndrs/cannon-worker-api';
+import { NgtAnyRecord, NgtInjectedRef, assertInjectionContext, injectNgtRef, is, makeId } from 'angular-three';
+import { NGTC_PHYSICS_API } from 'angular-three-cannon';
+
+export interface NgtcSpringApi {
+    setDamping: (value: number) => void;
+    setRestLength: (value: number) => void;
+    setStiffness: (value: number) => void;
+    remove: () => void;
+}
+
+export interface NgtcSpringReturn<
+    TObjectA extends THREE.Object3D = THREE.Object3D,
+    TObjectB extends THREE.Object3D = THREE.Object3D
+> {
+    bodyA: NgtInjectedRef<TObjectA>;
+    bodyB: NgtInjectedRef<TObjectB>;
+    api: Signal<NgtcSpringApi>;
+}
+
+export function injectSpring<A extends THREE.Object3D, B extends THREE.Object3D>(
+    bodyA: NgtInjectedRef<A> | A,
+    bodyB: NgtInjectedRef<B> | B,
+    {
+        injector,
+        opts = () => ({}),
+        deps = () => ({}),
+    }: { injector?: Injector; deps?: () => NgtAnyRecord; opts?: () => SpringOptns } = {}
+): NgtcSpringReturn<A, B> {
+    injector = assertInjectionContext(injectSpring, injector);
+    return runInInjectionContext(injector, () => {
+        const physicsApi = inject(NGTC_PHYSICS_API);
+        const { worker } = physicsApi();
+
+        const uuid = makeId();
+
+        const bodyARef = is.ref(bodyA) ? bodyA : injectNgtRef(bodyA);
+        const bodyBRef = is.ref(bodyB) ? bodyB : injectNgtRef(bodyB);
+
+        effect((onCleanup) => {
+            deps();
+            if (bodyARef.nativeElement && bodyBRef.nativeElement) {
+                worker.addSpring({
+                    props: [bodyARef.nativeElement.uuid, bodyBRef.nativeElement.uuid, untracked(opts)],
+                    uuid,
+                });
+                onCleanup(() => worker.removeSpring({ uuid }));
+            }
+        });
+
+        const api = computed(() => {
+            deps();
+            return {
+                setDamping: (value: number) => worker.setSpringDamping({ props: value, uuid }),
+                setRestLength: (value: number) => worker.setSpringRestLength({ props: value, uuid }),
+                setStiffness: (value: number) => worker.setSpringStiffness({ props: value, uuid }),
+                remove: () => worker.removeSpring({ uuid }),
+            };
+        });
+
+        return { bodyA: bodyARef, bodyB: bodyBRef, api };
+    });
+}