@forgeax/engine-vfx-render 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-vfx-render",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -22,13 +22,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-assets-runtime": "0.1.6",
-    "@forgeax/engine-ecs": "0.1.6",
-    "@forgeax/engine-math": "0.1.6",
-    "@forgeax/engine-render": "0.1.6",
-    "@forgeax/engine-scene": "0.1.6",
-    "@forgeax/engine-types": "0.1.6",
-    "@forgeax/engine-vfx": "0.1.6"
+    "@forgeax/engine-assets-runtime": "0.1.7",
+    "@forgeax/engine-ecs": "0.1.7",
+    "@forgeax/engine-math": "0.1.7",
+    "@forgeax/engine-render": "0.1.7",
+    "@forgeax/engine-scene": "0.1.7",
+    "@forgeax/engine-types": "0.1.7",
+    "@forgeax/engine-vfx": "0.1.7"
   },
   "devDependencies": {},
   "forgeax": {

package/src/__tests__/gpu-host.integration.test.ts

@@ -1,4 +1,5 @@
 import { World } from '@forgeax/engine-ecs';
+import type { Asset, MaterialAsset } from '@forgeax/engine-types';
 import {
   ParticleEffectPlayer,
   VFX_GPU_RUNTIME_RESOURCE_KEY,
@@ -45,6 +46,89 @@ describe('GPU VFX public host', () => {
     });
   });
 
+  it('preserves the asset registry receiver while planning a material projection', async () => {
+    const world = new World();
+    const lookups: string[] = [];
+    class StatefulAssets {
+      readonly material: MaterialAsset = { kind: 'material', values: {} };
+      readonly loaders = { registerPackLoader: () => {} };
+
+      lookup<T extends Asset = Asset>(guid: string): T | undefined {
+        if (this !== assets) throw new Error('asset registry receiver was lost');
+        lookups.push(guid);
+        return guid === 'material-guid' ? (this.material as T) : undefined;
+      }
+    }
+    const assets = new StatefulAssets();
+    const host = createVfxRuntimeHost({
+      camera: {
+        read: () => ({
+          position: new Float32Array(3),
+          right: new Float32Array([1, 0, 0]),
+          up: new Float32Array([0, 1, 0]),
+          viewProjection: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+        }),
+      },
+    });
+    expect(await host.attachWorld({ world, assets })).toMatchObject({ ok: true });
+
+    const intent = {
+      player: world.spawn().unwrap(),
+      fixedDelta: 1 / 60,
+      phaseTick: 0,
+      seed: 1,
+      playCycle: 0,
+      spawnCount: 1,
+      firstParticleId: 0,
+      reset: true,
+      channelInputs: [],
+      emitter: {
+        id: 'receiver-check',
+        capacity: 4,
+        backend: { required: 'gpu' },
+        space: 'world',
+        simulationWhenCulled: 'continue',
+        schedule: { rate: 0, bursts: [] },
+        bounds: { kind: 'sphere', center: [0, 0, 0], radius: 1 },
+        wgsl: '// receiver check',
+        reflection: { entryPoints: [], bindings: [] },
+        renderers: [{ kind: 'billboard', material: 'material-guid' }],
+      },
+    } as unknown as VfxGpuTickIntent;
+    const planned = host.feature.plan(
+      {
+        worlds: [
+          {
+            world,
+            runtime: {
+              isEmitterSessionEnabled: () => true,
+              setEmitterCameraVisibility: () => {},
+              markEventDispatched: () => {},
+              commit: () => {},
+            },
+            camera: {
+              position: new Float32Array(3),
+              right: new Float32Array([1, 0, 0]),
+              up: new Float32Array([0, 1, 0]),
+              viewProjection: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+            },
+            intents: [intent],
+          },
+        ],
+        frameNumber: 1,
+      } as never,
+      {
+        targets: [],
+        caps: {},
+        frame: { frameNumber: 1 },
+        generation: 1,
+      } as never,
+    );
+    expect(planned.ok).toBe(true);
+    expect(lookups).toEqual(['material-guid']);
+    await host.detachWorld({ world });
+  });
+
   it('fences preview controls to one attached host generation', async () => {
     const world = new World();
     const assets = {

package/src/host/vfx-runtime-host.ts

@@ -1,11 +1,17 @@
-import type { AssetRegistry as LegacyAssetRegistry } from '@forgeax/engine-assets-runtime';
-import type { AssetRegistry as CoreAssetRegistry } from '@forgeax/engine-assets-runtime/internal';
-import {
-  type AssetRegistryResolver,
-  getAssetRegistryResolver,
-} from '@forgeax/engine-assets-runtime/internal';
+import type {
+  AssetRegistryResolver,
+  AssetRegistry as LegacyAssetRegistry,
+  RuntimeAssetRegistry,
+} from '@forgeax/engine-assets-runtime';
+import { getAssetRegistryResolver } from '@forgeax/engine-assets-runtime';
 import { createWorldContext, type EntityHandle, type World } from '@forgeax/engine-ecs';
-import type { AssetDecoderLease, MaterialAsset, MeshAsset, Result } from '@forgeax/engine-types';
+import type {
+  Asset,
+  AssetDecoderLease,
+  MaterialAsset,
+  MeshAsset,
+  Result,
+} from '@forgeax/engine-types';
 import { err, ok } from '@forgeax/engine-types';
 import type {
   VfxDataInterfaceError,
@@ -32,7 +38,22 @@ import {
   type VfxDataInterfaceRegistry,
 } from './data-interface-providers.js';
 
-type AssetRegistry = LegacyAssetRegistry | CoreAssetRegistry;
+/**
+ * Public authoring projection accepted by the VFX host. Editor owns the
+ * projection, while the Engine App still owns bytes/decoders/cache. Keeping
+ * this small structural seam public lets the Editor pass that projection
+ * without importing the runtime registry's internal module or fabricating a
+ * second registry identity.
+ */
+export interface VfxAuthoringAssetRegistry {
+  readonly loaders: {
+    registerPackLoader(loader: unknown): void;
+  };
+  lookup<T extends Asset = Asset>(guid: string): T | undefined;
+  readonly load?: (guid: string, kind: string) => Promise<Result<unknown, unknown>>;
+}
+
+type AssetRegistry = LegacyAssetRegistry | RuntimeAssetRegistry | VfxAuthoringAssetRegistry;
 
 export interface VfxRuntimeHostOptions {
   readonly camera: ParticleRenderCameraSource;
@@ -113,7 +134,7 @@ export interface VfxRuntimeHost {
 }
 
 /** Install the VFX owner decoder into the core registry. */
-export function installVfxRuntimeDecoder(registry: CoreAssetRegistry): AssetDecoderLease {
+export function installVfxRuntimeDecoder(registry: RuntimeAssetRegistry): AssetDecoderLease {
   return registry.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
 }
 
@@ -174,7 +195,12 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
     const cached = attached.renderAssets.get(key);
     if (cached?.kind === kind) return cached as Kind extends 'material' ? MaterialAsset : MeshAsset;
     if ('lookup' in attached.assets) {
-      const legacy = attached.assets.lookup(guid);
+      const lookup = attached.assets.lookup as (guid: string) => Asset | undefined;
+      // Preserve the registry receiver: the Engine-owned legacy class uses
+      // `this` to read its load-state/catalogue maps. The Editor facade may
+      // expose an arrow function, but calling through the owner is safe for
+      // both shapes and avoids turning a lookup into a swallowed plan error.
+      const legacy = lookup.call(attached.assets, guid);
       if (legacy?.kind === kind) {
         attached.renderAssets.set(key, legacy);
         return legacy as Kind extends 'material' ? MaterialAsset : MeshAsset;
@@ -185,10 +211,17 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
       attached.renderAssets.set(key, resolved);
       return resolved as Kind extends 'material' ? MaterialAsset : MeshAsset;
     }
-    if ('load' in attached.assets && !attached.pendingRenderAssets.has(key)) {
+    if (
+      'load' in attached.assets &&
+      typeof attached.assets.load === 'function' &&
+      !attached.pendingRenderAssets.has(key)
+    ) {
       const epoch = attached.catalogEpoch;
-      const request = attached.assets
-        .load(guid, kind)
+      const load = attached.assets.load as (
+        guid: string,
+        kind: string,
+      ) => Promise<Result<MaterialAsset | MeshAsset, unknown>>;
+      const request = load(guid, kind)
         .then((result) => {
           if (!result.ok || worlds.get(world) !== attached || attached.catalogEpoch !== epoch)
             return;
@@ -327,10 +360,17 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
       if (worlds.has(world)) return ok({ state: 'already-attached' });
       if (!registries.has(assets)) {
         try {
-          if ('installDecoder' in assets) {
+          // The Editor facade deliberately exposes the legacy LoaderRegistry
+          // while projecting the Engine-owned App.assets instance. Prefer
+          // that public authoring seam before looking for the five-action
+          // runtime registry; otherwise a facade that happens to expose
+          // `load` would be misclassified as a decoder owner.
+          if ('loaders' in assets) {
+            assets.loaders.registerPackLoader(vfxGpuEffectPackLoader);
+          } else if ('installDecoder' in assets) {
             assets.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
           } else {
-            assets.loaders.registerPackLoader(vfxGpuEffectPackLoader);
+            throw new TypeError('VFX assets registry exposes neither loaders nor installDecoder');
           }
           registries.add(assets);
         } catch (cause) {
@@ -362,7 +402,7 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
         );
       }
       let resolver: AssetRegistryResolver | undefined;
-      if ('installDecoder' in assets) {
+      if (!('loaders' in assets) && 'installDecoder' in assets) {
         try {
           resolver = getAssetRegistryResolver(assets);
         } catch {

package/src/index.ts

@@ -46,6 +46,7 @@ export {
   createVfxDataInterfaceRegistry,
 } from './host/data-interface-providers.js';
 export type {
+  VfxAuthoringAssetRegistry,
   VfxRuntimeHost,
   VfxRuntimeHostControl,
   VfxRuntimeHostControlError,