@opsydyn/effect-three-foldkit 0.4.0 → 0.6.4

package/dist/index.js

@@ -85,6 +85,7 @@ __export(exports_viewportGizmo, {
 import { Data, Effect } from "effect";
 import {
   EquirectangularReflectionMapping,
+  LoadingManager,
   SRGBColorSpace,
   TextureLoader
 } from "three";
@@ -124,6 +125,48 @@ var namesIn = (root) => {
 // src/assets.ts
 class AssetLoadError extends Data.TaggedError("AssetLoadError") {
 }
+var nothing = [];
+var plain = (release) => ({ parts: nothing, clips: nothing, release });
+var lentTexture = (store, id, texture) => {
+  texture.colorSpace = SRGBColorSpace;
+  const withdraw = store.lendTexture(id, texture);
+  return plain(() => {
+    withdraw();
+    texture.dispose();
+  });
+};
+var lentModel = (store, id, gltf) => {
+  gltf.scene.animations = gltf.animations;
+  const withdraw = store.lend(id, gltf.scene);
+  return {
+    parts: namesIn(gltf.scene),
+    clips: gltf.animations.map((clip) => clip.name),
+    release: () => {
+      withdraw();
+      disposeModel(gltf.scene);
+    }
+  };
+};
+var lentEnvironment = (store, id, texture) => {
+  texture.mapping = EquirectangularReflectionMapping;
+  const withdraw = store.lendTexture(id, texture);
+  return plain(() => {
+    withdraw();
+    texture.dispose();
+  });
+};
+var lentFont = (store, id, font) => plain(store.lendFont(id, font));
+var loadAndLend = {
+  model: async (store, { id, url }, manager) => lentModel(store, id, await new GLTFLoader(manager).loadAsync(url)),
+  texture: async (store, { id, url }, manager) => lentTexture(store, id, await new TextureLoader(manager).loadAsync(url)),
+  environment: async (store, { id, url }, manager) => lentEnvironment(store, id, await new HDRLoader(manager).loadAsync(url)),
+  font: async (store, { id, url }, manager) => lentFont(store, id, await new FontLoader(manager).loadAsync(url))
+};
+var assetLoader = (store) => (asset, signal) => {
+  const manager = new LoadingManager;
+  signal.addEventListener("abort", () => manager.abort(), { once: true });
+  return loadAndLend[asset.kind](store, asset, manager);
+};
 var makeAssets = (store) => {
   const releases = new Map;
   const own = (id, release) => {
@@ -131,39 +174,21 @@ var makeAssets = (store) => {
     releases.set(id, release);
   };
   const lendTexture = (id) => (texture) => {
-    texture.colorSpace = SRGBColorSpace;
-    const withdraw = store.lendTexture(id, texture);
-    own(id, () => {
-      withdraw();
-      texture.dispose();
-    });
+    own(id, lentTexture(store, id, texture).release);
     return id;
   };
   const lendModel = (id) => (gltf) => {
-    gltf.scene.animations = gltf.animations;
-    const withdraw = store.lend(id, gltf.scene);
-    own(id, () => {
-      withdraw();
-      disposeModel(gltf.scene);
-    });
-    const info = {
-      id,
-      parts: namesIn(gltf.scene),
-      clips: gltf.animations.map((clip) => clip.name)
-    };
+    const lent = lentModel(store, id, gltf);
+    own(id, lent.release);
+    const info = { id, parts: lent.parts, clips: lent.clips };
     return info;
   };
   const lendEnvironment = (id) => (texture) => {
-    texture.mapping = EquirectangularReflectionMapping;
-    const withdraw = store.lendTexture(id, texture);
-    own(id, () => {
-      withdraw();
-      texture.dispose();
-    });
+    own(id, lentEnvironment(store, id, texture).release);
     return id;
   };
   const lendFont = (id) => (font) => {
-    own(id, store.lendFont(id, font));
+    own(id, lentFont(store, id, font).release);
     return id;
   };
   const releaseAll = () => {
@@ -245,6 +270,7 @@ var modifiersOf = (event) => ({
   meta: event.metaKey,
   alt: event.altKey
 });
+var deviceOf = (event) => event instanceof PointerEvent && (event.pointerType === "touch" || event.pointerType === "pen") ? event.pointerType : "mouse";
 var pointerIdOf = (event) => event instanceof PointerEvent ? event.pointerId : 0;
 var wheelScale = [1, 16, 100];
 var toPointerInput = (event, rect) => {
@@ -263,7 +289,8 @@ var toPointerInput = (event, rect) => {
         y,
         button: event.button,
         pointer,
-        modifiers: modifiersOf(event)
+        modifiers: modifiersOf(event),
+        device: deviceOf(event)
       };
     case "pointerup":
       return { _tag: "PointerUp", x, y, button: event.button, pointer };
@@ -969,6 +996,7 @@ var sceneElement = CustomElement.define({
     "scene-auto-rotated": SceneSchema.AutoRotatedDetail,
     "scene-collision": SceneSchema.CollisionDetail,
     "scene-contact-force": SceneSchema.ContactForceDetail,
+    "scene-physics-reached": SceneSchema.PhysicsReachedDetail,
     "scene-measured": SceneSchema.MeasuredDetail,
     "scene-label-measured": SceneSchema.LabelMeasuredDetail,
     "scene-xr": XrSessionDetail,
@@ -980,6 +1008,8 @@ var sceneElement = CustomElement.define({
     "scene-xr-meshes": SceneSchema.XrMeshesDetail,
     "scene-performance": SceneSchema.PerformanceDetail,
     "scene-error": Schema.Struct({ error: SceneError }),
+    "scene-asset-loaded": SceneSchema.AssetLoadedDetail,
+    "scene-asset-failed": SceneSchema.AssetFailedDetail,
     "scene-reconciled": ReconciledDetail
   }
 });
@@ -1001,6 +1031,7 @@ var domEventName = {
   AutoRotated: "scene-auto-rotated",
   Collision: "scene-collision",
   ContactForce: "scene-contact-force",
+  PhysicsReached: "scene-physics-reached",
   Measured: "scene-measured",
   LabelMeasured: "scene-label-measured",
   XrStick: "scene-xr-stick",
@@ -1075,6 +1106,135 @@ import {
   createResourceStore
 } from "@opsydyn/effect-three";
 
+// src/assetRegistry.ts
+import { assetsEqual } from "@opsydyn/effect-three";
+var sameAsset = (a, b) => a.kind === b.kind && a.url === b.url && a.levels.length === b.levels.length && a.levels.every((level, i) => level === b.levels[i]);
+var urlsOf = (asset) => [...asset.levels, asset.url];
+var reasonOf = (asset, cause) => cause instanceof Error && cause.message !== "" ? `Could not load ${asset.url}: ${cause.message}` : `Could not load ${asset.url}`;
+var taken = (asset, holding) => ({
+  _tag: "Failed",
+  ...asset,
+  reason: `"${asset.id}" is already ${holding.url} for another scene`
+});
+var makeAssetRegistry = (load) => {
+  const entries = new Map;
+  const asking = new Map;
+  const tellAll = (entry, notice) => {
+    for (const holder of entry.holders)
+      asking.get(holder)?.notify(notice);
+  };
+  const loadedNotice = (entry, level, lent) => ({
+    _tag: "Loaded",
+    ...entry.asset,
+    level,
+    final: level === entry.asset.levels.length,
+    parts: lent.parts,
+    clips: lent.clips
+  });
+  const noticesOf = (entry) => [
+    ...entry.shown === undefined ? [] : [loadedNotice(entry, entry.shown.level, entry.shown.lent)],
+    ...entry.failure === undefined ? [] : [{ _tag: "Failed", ...entry.asset, reason: entry.failure }]
+  ];
+  const start = (asset) => {
+    const urls = urlsOf(asset);
+    const finest = urls.length - 1;
+    const entry = {
+      asset,
+      holders: new Set,
+      controllers: urls.map(() => new AbortController),
+      shown: undefined,
+      failure: undefined
+    };
+    entries.set(asset.id, entry);
+    function current(level) {
+      return entries.get(asset.id) === entry && entry.controllers[level]?.signal.aborted === false;
+    }
+    function loaded(level) {
+      return (lent) => {
+        if (!current(level) || entry.shown !== undefined && entry.shown.level >= level) {
+          lent.release();
+          return;
+        }
+        const before = entry.shown;
+        entry.shown = { level, lent };
+        before?.lent.release();
+        if (level === finest)
+          for (const coarser of entry.controllers.slice(0, level))
+            coarser.abort();
+        tellAll(entry, loadedNotice(entry, level, lent));
+      };
+    }
+    function failed(level) {
+      return (cause) => {
+        if (!current(level) || level !== finest)
+          return;
+        const reason = reasonOf({ ...asset, url: urls[level] ?? asset.url }, cause);
+        entry.failure = reason;
+        tellAll(entry, { _tag: "Failed", ...asset, reason });
+      };
+    }
+    urls.forEach((url, level) => {
+      const signal = entry.controllers[level]?.signal ?? AbortSignal.abort();
+      load({ ...asset, url }, signal).then(loaded(level), failed(level));
+    });
+    return entry;
+  };
+  const end = (entry) => {
+    entries.delete(entry.asset.id);
+    for (const controller of entry.controllers)
+      controller.abort();
+    entry.shown?.lent.release();
+  };
+  const letGo = (holder, id) => {
+    const entry = entries.get(id);
+    if (entry === undefined || !entry.holders.delete(holder) || entry.holders.size > 0)
+      return;
+    end(entry);
+    for (const [waiting, { assets }] of asking) {
+      if (assets.some((asset) => asset.id === id))
+        hold(waiting, assets);
+    }
+  };
+  const hold = (holder, assets) => {
+    for (const asset of assets) {
+      const entry = entries.get(asset.id) ?? start(asset);
+      if (!sameAsset(entry.asset, asset)) {
+        asking.get(holder)?.notify(taken(asset, entry.asset));
+        continue;
+      }
+      if (entry.holders.has(holder))
+        continue;
+      entry.holders.add(holder);
+      for (const notice of noticesOf(entry))
+        asking.get(holder)?.notify(notice);
+    }
+  };
+  const want = (holder, assets, notify) => {
+    const before = asking.get(holder);
+    asking.set(holder, { assets, notify });
+    if (before !== undefined && assetsEqual(before.assets, assets))
+      return;
+    for (const old of before?.assets ?? []) {
+      const still = assets.find((asset) => asset.id === old.id);
+      if (still === undefined || !sameAsset(still, old))
+        letGo(holder, old.id);
+    }
+    hold(holder, assets);
+  };
+  const release = (holder) => {
+    want(holder, [], () => {
+      return;
+    });
+    asking.delete(holder);
+  };
+  const dispose = () => {
+    asking.clear();
+    for (const entry of [...entries.values()])
+      end(entry);
+  };
+  return { want, release, dispose };
+};
+
 // src/dom/xr.ts
 import { Group as Group2 } from "three";
 
@@ -1729,6 +1889,7 @@ var createXrHub = (system) => {
 var makeEnvironment = (host, options = {}) => {
   const store = createResourceStore();
   const assets = makeAssets(store);
+  const assetRegistry = makeAssetRegistry(assetLoader(store));
   const xrHub = createXrHub(() => host.navigator?.xr);
   return {
     host,
@@ -1740,9 +1901,11 @@ var makeEnvironment = (host, options = {}) => {
     physics: Promise.resolve(options.physics),
     labels: options.labels,
     assets,
+    assetRegistry,
     xr: makeXr(xrHub),
     xrHub,
     dispose: () => {
+      assetRegistry.dispose();
       assets.dispose();
       store.dispose();
     }
@@ -1821,6 +1984,11 @@ var dispatchSceneEvent = (element, event) => {
 var dispatchSceneError = (element, error) => {
   element.dispatchEvent(new CustomEvent("scene-error", { detail: { error } }));
 };
+var dispatchAssetNotice = (element, notice) => {
+  const { _tag, ...detail } = notice;
+  const name = _tag === "Loaded" ? "scene-asset-loaded" : "scene-asset-failed";
+  element.dispatchEvent(new CustomEvent(name, { detail }));
+};
 var canvasIn = (host) => () => appendCanvas(host);
 var removal = (node) => () => node.remove();
 var sceneEventDispatch = (element, live) => (event) => () => {
@@ -1844,10 +2012,10 @@ var createLatch = (open) => {
     }
   };
 };
-var nothing = [];
+var nothing2 = [];
 var routedWhileOpen = (latch, route) => (value) => {
   if (!latch.isOpen())
-    return nothing;
+    return nothing2;
   return route(value);
 };
 var applying = (f, value) => () => f(value);
@@ -2018,11 +2186,21 @@ var connectObserver = (observe) => (queue) => {
   return Effect3.acquireRelease(connect, Effect3.sync);
 };
 var observed = (observe) => Stream.callback(connectObserver(observe));
+var asking = (mounted, scene) => () => mounted.environment.assetRegistry.want(mounted.element, scene.assets, (notice) => dispatchAssetNotice(mounted.element, notice));
+var lettingGo = (mounted) => () => mounted.environment.assetRegistry.release(mounted.element);
+var acquireAssets = (mounted, initial) => {
+  const ask = Effect3.sync(asking(mounted, initial));
+  return Effect3.acquireRelease(ask, () => Effect3.sync(lettingGo(mounted)));
+};
+var updated = (mounted) => (scene) => {
+  const ask = Effect3.sync(asking(mounted, scene));
+  return Effect3.tap(mounted.handle.update(scene), () => ask);
+};
 var applyUpdate = (mounted) => (value) => {
   const reportError = sceneErrorDispatch(mounted.element);
   const reportReconciled = afterUpdate(reconciledDispatch(mounted.element, mounted.environment.store), [touchActionSync(mounted.canvas, mounted.handle.graph), mounted.overlays.rewrite]);
   const decoded = decodeScene(value);
-  const applied = decoded.pipe(Effect3.flatMap(mounted.handle.update), Effect3.flatMap((ops) => Effect3.sync(reportReconciled(ops))));
+  const applied = decoded.pipe(Effect3.flatMap(updated(mounted)), Effect3.flatMap((ops) => Effect3.sync(reportReconciled(ops))));
   return applied.pipe(Effect3.catchTags({
     SchemaError: (error) => Effect3.sync(reportError({ _tag: "MalformedScene", issue: error.message })),
     InvalidScene: ({ error }) => Effect3.sync(reportError(error))
@@ -2083,6 +2261,7 @@ function* runScene(environment, element, viewStateChanges) {
     gate: createFrameGate(frames),
     live: createLatch(true)
   };
+  yield* acquireAssets(mounted, initial);
   yield* acquirePointer(canvas, mounted);
   yield* acquireXrTarget(mounted);
   yield* Effect3.sync(touchActionSync(canvas, handle.graph));
@@ -2487,6 +2666,7 @@ var view = (config, h) => {
     Option7.map(given(config.onDragEnd), element.OnSceneDragEnd),
     Option7.map(given(config.onCollision), element.OnSceneCollision),
     Option7.map(given(config.onContactForce), element.OnSceneContactForce),
+    Option7.map(given(config.onPhysicsReached), element.OnScenePhysicsReached),
     Option7.map(given(config.onMeasured), element.OnSceneMeasured),
     Option7.map(given(config.onLabelMeasured), element.OnSceneLabelMeasured),
     Option7.map(given(config.onXRSession), element.OnSceneXr),
@@ -2501,6 +2681,8 @@ var view = (config, h) => {
     Option7.map(given(config.onGestureEnd), element.OnSceneGestureEnd),
     Option7.map(given(config.onPerformanceChange), element.OnScenePerformance),
     Option7.map(given(config.onError), element.OnSceneError),
+    Option7.map(given(config.onAssetLoaded), element.OnSceneAssetLoaded),
+    Option7.map(given(config.onAssetFailed), element.OnSceneAssetFailed),
     Option7.map(given(config.onReconciled), element.OnSceneReconciled),
     Option7.map(given(config.className), h.Class)
   ]);
@@ -2540,5 +2722,5 @@ export {
   webgpuRendererFactory
 };
 
-//# debugId=B27477F988FB686A64756E2164756E21
+//# debugId=91E3923C3006D06864756E2164756E21
 //# sourceMappingURL=index.js.map