@opsydyn/effect-three-foldkit 0.4.0 → 0.6.4

package/src/mount.ts

@@ -27,6 +27,7 @@ import {
   removal,
   sceneErrorDispatch,
   sceneEventDispatch,
+  dispatchAssetNotice,
 } from './dom/canvas.ts';
 import { applying, createLatch, type Latch, routedWhileOpen } from './dom/latch.ts';
 import { containOverlays, createOverlayWriter, type OverlayWriter } from './dom/overlays.ts';
@@ -140,6 +141,27 @@ const connectObserver =
 const observed = <A>(observe: (emit: (value: A) => void) => () => void) =>
   Stream.callback<A>(connectObserver(observe));
 
+/** What the scene asks for now, given to the environment's asset registry. */
+const asking = (mounted: Mounted, scene: SceneDescription) => () =>
+  mounted.environment.assetRegistry.want(mounted.element, scene.assets, (notice) =>
+    dispatchAssetNotice(mounted.element, notice),
+  );
+
+const lettingGo = (mounted: Mounted) => () =>
+  mounted.environment.assetRegistry.release(mounted.element);
+
+/** The scene's assets, asked for while it is mounted: going, it asks for none. */
+const acquireAssets = (mounted: Mounted, initial: SceneDescription) => {
+  const ask = Effect.sync(asking(mounted, initial));
+  return Effect.acquireRelease(ask, () => Effect.sync(lettingGo(mounted)));
+};
+
+/** An update applied, then what it asks for given to the registry (a refused one asks nothing). */
+const updated = (mounted: Mounted) => (scene: SceneDescription) => {
+  const ask = Effect.sync(asking(mounted, scene));
+  return Effect.tap(mounted.handle.update(scene), () => ask);
+};
+
 const applyUpdate = (mounted: Mounted) => (value: unknown) => {
   const reportError = sceneErrorDispatch(mounted.element);
   const reportReconciled = afterUpdate(
@@ -148,7 +170,7 @@ const applyUpdate = (mounted: Mounted) => (value: unknown) => {
   );
   const decoded = decodeScene(value);
   const applied = decoded.pipe(
-    Effect.flatMap(mounted.handle.update),
+    Effect.flatMap(updated(mounted)),
     Effect.flatMap((ops) => Effect.sync(reportReconciled(ops))),
   );
   return applied.pipe(
@@ -258,6 +280,7 @@ function* runScene(
     gate: createFrameGate(frames),
     live: createLatch(true),
   };
+  yield* acquireAssets(mounted, initial);
   yield* acquirePointer(canvas, mounted);
   yield* acquireXrTarget(mounted);
   yield* Effect.sync(touchActionSync(canvas, handle.graph));

package/src/view.ts

@@ -52,6 +52,9 @@ export type CollisionDetail = typeof SceneSchema.CollisionDetail.Type;
 
 /** Detail of contact force events: the two bodies, and how hard they pushed. */
 export type ContactForceDetail = typeof SceneSchema.ContactForceDetail.Type;
+export type PhysicsReachedDetail = typeof SceneSchema.PhysicsReachedDetail.Type;
+export type AssetLoadedDetail = typeof SceneSchema.AssetLoadedDetail.Type;
+export type AssetFailedDetail = typeof SceneSchema.AssetFailedDetail.Type;
 
 /** Detail of measured events: a node's world bounding box. */
 export type MeasuredDetail = typeof SceneSchema.MeasuredDetail.Type;
@@ -144,6 +147,12 @@ export type ViewConfig<Message> = {
    * set the threshold high.
    */
   readonly onContactForce?: (detail: ContactForceDetail) => Message;
+  /**
+   * A world on `physics({ until })` reached that step and waits there, with its run and a
+   * checksum of its bodies' poses (ADR-014): the moment to apply the inputs due at that
+   * step and move `until` on. It follows the collisions of the steps that led there.
+   */
+  readonly onPhysicsReached?: (detail: PhysicsReachedDetail) => Message;
   /**
    * A node listed in the scene's `measure` has a new world bounding box (Drei's `Bounds`
    * measuring, as a Message): fit the camera to it with `fitCamera`.
@@ -197,6 +206,13 @@ export type ViewConfig<Message> = {
   readonly onPerformanceChange?: (detail: PerformanceDetail) => Message;
   /** A scene update was rejected; the scene keeps its last good state. */
   readonly onError?: (detail: { readonly error: SceneError }) => Message;
+  /**
+   * An asset the scene asks for (`scene({ assets })`) has loaded and is lent under its id:
+   * at once, for one another scene loaded already. A model's parts and clips come with it.
+   */
+  readonly onAssetLoaded?: (detail: AssetLoadedDetail) => Message;
+  /** An asset the scene asks for could not be loaded, and why. */
+  readonly onAssetFailed?: (detail: AssetFailedDetail) => Message;
   /**
    * What each scene update did (operations by kind) and the GPU resources held afterwards.
    * Fires at startup and after every update that changed something, never for no-ops.
@@ -234,6 +250,7 @@ export const view = <Message>(
     Option.map(given(config.onDragEnd), element.OnSceneDragEnd),
     Option.map(given(config.onCollision), element.OnSceneCollision),
     Option.map(given(config.onContactForce), element.OnSceneContactForce),
+    Option.map(given(config.onPhysicsReached), element.OnScenePhysicsReached),
     Option.map(given(config.onMeasured), element.OnSceneMeasured),
     Option.map(given(config.onLabelMeasured), element.OnSceneLabelMeasured),
     Option.map(given(config.onXRSession), element.OnSceneXr),
@@ -250,6 +267,8 @@ export const view = <Message>(
     Option.map(given(config.onGestureEnd), element.OnSceneGestureEnd),
     Option.map(given(config.onPerformanceChange), element.OnScenePerformance),
     Option.map(given(config.onError), element.OnSceneError),
+    Option.map(given(config.onAssetLoaded), element.OnSceneAssetLoaded),
+    Option.map(given(config.onAssetFailed), element.OnSceneAssetFailed),
     Option.map(given(config.onReconciled), element.OnSceneReconciled),
     Option.map(given(config.className), h.Class),
   ]);