@forgeax/engine-vfx-render 0.1.4 → 0.1.6

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,4 +1,5 @@
-import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+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,
@@ -21,6 +22,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 +32,8 @@ import {
   type VfxDataInterfaceRegistry,
 } from './data-interface-providers.js';
 
+type AssetRegistry = LegacyAssetRegistry | CoreAssetRegistry;
+
 export interface VfxRuntimeHostOptions {
   readonly camera: ParticleRenderCameraSource;
   readonly maxQueuedTicks?: number;
@@ -108,8 +112,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: CoreAssetRegistry): AssetDecoderLease {
   return registry.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
 }
 
@@ -142,7 +146,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,12 +173,19 @@ 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 legacy = attached.assets.lookup(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 && !attached.pendingRenderAssets.has(key)) {
       const epoch = attached.catalogEpoch;
       const request = attached.assets
         .load(guid, kind)
@@ -314,15 +325,20 @@ 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));
+          if ('installDecoder' in assets) {
+            assets.installDecoder(vfxGpuEffectContribution.kind, vfxGpuEffectContribution.decoder);
+          } else {
+            assets.loaders.registerPackLoader(vfxGpuEffectPackLoader);
+          }
+          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 +362,12 @@ export function createVfxRuntimeHost(options: VfxRuntimeHostOptions): VfxRuntime
         );
       }
       let resolver: AssetRegistryResolver | undefined;
-      try {
-        resolver = getAssetRegistryResolver(assets);
-      } catch {
-        resolver = undefined;
+      if ('installDecoder' in assets) {
+        try {
+          resolver = getAssetRegistryResolver(assets);
+        } catch {
+          resolver = undefined;
+        }
       }
       const attached = {
         assets,
@@ -359,14 +377,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,