@forgeax/engine-vfx-render 0.1.4 → 0.1.7

package/src/feature/particle-resources.ts

@@ -1,4 +1,3 @@
-import type { RenderFeatureMaterialShaderBindingContract } from '@forgeax/engine-render';
 import {
   err,
   type MaterialAsset,
@@ -157,13 +156,6 @@ export function particleMaterialPass(
   };
 }
 
-/** Scene-depth is a shader binding contract, not a renderer-kind convention. */
-export function particleMaterialUsesSceneDepth(
-  contract: RenderFeatureMaterialShaderBindingContract | 'view-with-resource',
-): boolean {
-  return contract === 'group-0-resource' || contract === 'view-with-resource';
-}
-
 /** True when the authored particle shader consumes the standard material bind group. */
 export function particleMaterialUsesBindings(material: MaterialAsset | undefined): boolean {
   return (material?.parameters?.length ?? 0) > 0;

package/src/feature/stage-plan.ts

@@ -1,5 +1,8 @@
-import type { RenderFeatureGpuBindingsRef, RenderFeatureGpuDispatch } from '@forgeax/engine-render';
 import type { VfxGpuStageReflection } from '@forgeax/engine-vfx';
+import type {
+  RenderFeatureGpuBindingsRef,
+  RenderFeatureGpuDispatch,
+} from '../../../render/src/features/prepared-gpu-work.js';
 
 const MANAGED_STAGES = new Set(['spawn', 'update', 'scan', 'compact']);
 const RESOURCE_NAMES = new Set([

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

@@ -1,10 +1,17 @@
-import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
-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,
@@ -21,6 +28,7 @@ import {
   VFX_GPU_RUNTIME_RESOURCE_KEY,
   type VfxGpuRuntime,
   vfxGpuEffectContribution,
+  vfxGpuEffectPackLoader,
   vfxGpuRuntimePlugin,
 } from '@forgeax/engine-vfx';
 import type { ParticleRenderCameraSource } from '../feature/camera.js';
@@ -30,6 +38,23 @@ import {
   type VfxDataInterfaceRegistry,
 } from './data-interface-providers.js';
 
+/**
+ * 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;
   readonly maxQueuedTicks?: number;
@@ -108,8 +133,8 @@ export interface VfxRuntimeHost {
   }): Promise<Result<{ readonly state: 'detached' | 'not-attached' }, VfxRuntimeHostError>>;
 }
 
-/** Install the VFX owner decoder into the one host registry. */
-export function installVfxRuntimeDecoder(registry: AssetRegistry): AssetDecoderLease {
+/** Install the VFX owner decoder into the core registry. */
+export function installVfxRuntimeDecoder(registry: RuntimeAssetRegistry): AssetDecoderLease {
   return registry.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
 }
 
@@ -142,7 +167,7 @@ function controlFailure(
 }
 
 export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntimeHost {
-  const decoderLeases = new WeakMap<AssetRegistry, AssetDecoderLease>();
+  const registries = new WeakSet<AssetRegistry>();
   const worlds = new WeakMap<
     World,
     {
@@ -169,15 +194,34 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
     const key = `${kind}:${guid.toLowerCase()}`;
     const cached = attached.renderAssets.get(key);
     if (cached?.kind === kind) return cached as Kind extends 'material' ? MaterialAsset : MeshAsset;
+    if ('lookup' in attached.assets) {
+      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;
+      }
+    }
     const resolved = attached.resolver?.lookup<MaterialAsset | MeshAsset>(guid);
     if (resolved?.kind === kind) {
       attached.renderAssets.set(key, resolved);
       return resolved as Kind extends 'material' ? MaterialAsset : MeshAsset;
     }
-    if (!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;
@@ -314,15 +358,27 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
       dataInterfaces.resolve(requirements, generation),
     attachWorld: async ({ world, assets }) => {
       if (worlds.has(world)) return ok({ state: 'already-attached' });
-      if (!decoderLeases.has(assets)) {
+      if (!registries.has(assets)) {
         try {
-          decoderLeases.set(assets, installVfxRuntimeDecoder(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 {
+            throw new TypeError('VFX assets registry exposes neither loaders nor installDecoder');
+          }
+          registries.add(assets);
         } catch (cause) {
           return err(
             failure(
               'vfx-host-loader-install-failed',
-              'the VFX owner decoder to be installed once in the runtime core',
-              'remove a conflicting particle-effect decoder and retry attachWorld',
+              'the v2 VFX loader to be registered once',
+              'remove a conflicting particle-effect loader and retry attachWorld',
               cause,
             ),
           );
@@ -346,10 +402,12 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
         );
       }
       let resolver: AssetRegistryResolver | undefined;
-      try {
-        resolver = getAssetRegistryResolver(assets);
-      } catch {
-        resolver = undefined;
+      if (!('loaders' in assets) && 'installDecoder' in assets) {
+        try {
+          resolver = getAssetRegistryResolver(assets);
+        } catch {
+          resolver = undefined;
+        }
       }
       const attached = {
         assets,
@@ -359,14 +417,13 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
         renderAssets: new Map<string, MaterialAsset | MeshAsset>(),
         pendingRenderAssets: new Map<string, Promise<void>>(),
         catalogEpoch:
-          typeof (assets as { readonly snapshot?: unknown }).snapshot === 'function'
+          'snapshot' in assets && typeof assets.snapshot === 'function'
             ? assets.snapshot().epoch
             : 0,
         unsubscribeAssets: () => {},
       };
-      const subscribe = (assets as { readonly subscribe?: AssetRegistry['subscribe'] }).subscribe;
-      if (subscribe !== undefined) {
-        attached.unsubscribeAssets = subscribe((snapshot) => {
+      if ('subscribe' in assets && typeof assets.subscribe === 'function') {
+        attached.unsubscribeAssets = assets.subscribe((snapshot) => {
           if (snapshot.epoch === attached.catalogEpoch) return;
           attached.catalogEpoch = snapshot.epoch;
           attached.renderAssets.clear();

package/src/index.ts

@@ -10,7 +10,6 @@ export {
   VFX_EVENT_COUNTER_BYTES,
   VFX_EVENT_INPUT_BYTES,
 } from './feature/event-resources.js';
-export type { VfxGpuRenderObservation } from './feature/gpu-particle-feature.js';
 export {
   createVfxRenderInspectSnapshot,
   gpuParticleRenderFeature,
@@ -47,6 +46,7 @@ export {
   createVfxDataInterfaceRegistry,
 } from './host/data-interface-providers.js';
 export type {
+  VfxAuthoringAssetRegistry,
   VfxRuntimeHost,
   VfxRuntimeHostControl,
   VfxRuntimeHostControlError,