@forgeax/engine-vfx 0.1.27 → 0.1.29

package/dist/particle-layout.d.ts

@@ -0,0 +1,62 @@
+import type { VfxReflectedStruct, VfxValueType } from './effect-contract.js';
+/**
+ * The particle core is a storage-buffer ABI, not a convenient object shape.
+ * Keep its fields in one ordered schema so WGSL, host-side allocation and
+ * renderer projections all consume the same offsets.
+ */
+export type VfxParticleCoreAttribute = 'position' | 'age' | 'velocity' | 'lifetime' | 'color' | 'sprite_size' | 'sprite_rotation' | 'sub_image' | 'mesh_orientation' | 'mesh_scale' | 'material_random' | 'id' | 'alive';
+export interface VfxParticleCoreField {
+    readonly name: VfxParticleCoreAttribute;
+    readonly type: VfxValueType | 'u32';
+    readonly offset: number;
+    readonly size: number;
+    readonly alignment: number;
+}
+export interface VfxParticleCoreLayout {
+    readonly name: 'VfxParticle';
+    readonly fields: readonly VfxParticleCoreField[];
+    readonly size: number;
+    readonly alignment: 16;
+    readonly stride: number;
+    readonly fingerprint: string;
+}
+/** Program v3 core layout. The 112-byte stride includes WGSL's final 16-byte alignment. */
+export declare const VFX_PARTICLE_CORE_LAYOUT: VfxParticleCoreLayout;
+export declare const VFX_PARTICLE_CORE_STRIDE: number;
+export declare function vfxParticleCoreField(name: VfxParticleCoreAttribute): VfxParticleCoreField;
+/** WGSL declaration generated from the core schema. */
+export declare function vfxParticleCoreWgsl(): string;
+/** Effect-level data is intentionally separate from per-particle custom data. */
+export interface VfxParametersLayout extends VfxReflectedStruct {
+    readonly name: 'VfxParameters';
+}
+export interface VfxCustomLayout extends VfxReflectedStruct {
+    readonly name: 'VfxCustom';
+    /** Array stride for `array<VfxCustom>` in the persistent GPU storage buffer. */
+    readonly stride: number;
+    /** Number of vec4-equivalent lanes consumed by the custom record. */
+    readonly lanes: number;
+}
+/** Re-derive custom offsets from reflected fields and reject the bounded renderer budget. */
+export declare function deriveVfxCustomLayout(struct: VfxReflectedStruct, maxLanes?: number): VfxCustomLayout;
+export type VfxParticleCoreValue = readonly [number, number, number] | readonly [number, number, number, number] | readonly [number, number] | number;
+export interface VfxParticleCoreValues {
+    readonly position: readonly [number, number, number];
+    readonly age: number;
+    readonly velocity: readonly [number, number, number];
+    readonly lifetime: number;
+    readonly color: readonly [number, number, number, number];
+    readonly sprite_size: readonly [number, number];
+    readonly sprite_rotation: number;
+    readonly sub_image: number;
+    readonly mesh_orientation: readonly [number, number, number, number];
+    readonly mesh_scale: readonly [number, number, number];
+    readonly material_random: number;
+    readonly id: number;
+    readonly alive: number;
+}
+/** Pack a core record using schema offsets. This is for inspection/replay fixtures, not a particle mirror. */
+export declare function encodeVfxParticleCore(value: VfxParticleCoreValues): Uint8Array;
+/** Return the normalized age used by all renderer semantic projections. */
+export declare function normalizedVfxParticleAge(age: number, lifetime: number): number;
+//# sourceMappingURL=particle-layout.d.ts.map

package/dist/particle-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle-layout.d.ts","sourceRoot":"","sources":["../src/particle-layout.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/engine-vfx",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "license": "Apache-2.0",
@@ -29,10 +29,10 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@forgeax/engine-assets-runtime": "0.1.27",
-    "@forgeax/engine-ecs": "0.1.27",
-    "@forgeax/engine-plugin": "0.1.27",
-    "@forgeax/engine-types": "0.1.27"
+    "@forgeax/engine-assets-runtime": "0.1.29",
+    "@forgeax/engine-ecs": "0.1.29",
+    "@forgeax/engine-plugin": "0.1.29",
+    "@forgeax/engine-types": "0.1.29"
   },
   "forgeax": {
     "metrics": {

package/src/__tests__/authoring-descriptor.unit.test.ts

@@ -2,15 +2,16 @@ import { describe, expect, it } from 'vitest';
 import { describeVfxGpuEffect, isVfxGpuEffectAsset } from '../authoring-descriptor.js';
 import type { VfxGpuEffectAsset } from '../gpu-program.js';
 import { VFX_GPU_PROGRAM_ARTIFACT_KEY, VFX_GPU_PROGRAM_FORMAT } from '../gpu-program.js';
+import { VFX_PARTICLE_CORE_LAYOUT } from '../particle-layout.js';
 
-const effect: VfxGpuEffectAsset = {
+const effect = {
   guid: 'effect-guid',
   kind: 'particle-effect',
-  schemaVersion: 2,
+  schemaVersion: 3,
   programFingerprint: 'sha256:effect',
   emitters: [{ id: 'sparks', capacity: 128 }],
   program: {
-    format: 'forgeax-vfx-program-2',
+    format: 'forgeax-vfx-program-3',
     fingerprint: 'sha256:effect',
     emitters: [
       {
@@ -22,7 +23,7 @@ const effect: VfxGpuEffectAsset = {
         schedule: { rate: 8, bursts: [{ time: 0, count: 4 }], loopDuration: 2 },
         bounds: { kind: 'sphere', center: [0, 1, 0], radius: 4 },
         renderers: [
-          { kind: 'billboard', material: 'material-guid', sorting: 'back-to-front' },
+          { kind: 'billboard', material: 'material-guid', sorting: 'view-depth' },
           { kind: 'beam', material: 'beam-material-guid', endpointField: 'velocity', capacity: 32 },
         ],
         channels: [{ id: 'impact', payload: 'impact', capacity: 8, overflow: 'drop-newest' }],
@@ -44,7 +45,7 @@ const effect: VfxGpuEffectAsset = {
           entryPoints: ['forgeax_vfx_spawn_main'],
           bindings: [],
           layout: {
-            version: 1,
+            version: 3,
             parameters: {
               name: 'VfxParameters',
               fields: [
@@ -61,6 +62,15 @@ const effect: VfxGpuEffectAsset = {
               alignment: 16,
             },
             custom: { name: 'VfxCustom', fields: [], size: 0, alignment: 1 },
+            core: VFX_PARTICLE_CORE_LAYOUT,
+            customLayout: {
+              name: 'VfxCustom',
+              fields: [],
+              size: 0,
+              alignment: 1,
+              stride: 0,
+              lanes: 0,
+            },
             fingerprint: 'sha256:layout',
           },
           stages: [
@@ -78,11 +88,11 @@ const effect: VfxGpuEffectAsset = {
       },
     ],
   },
-};
+} as unknown as VfxGpuEffectAsset;
 
 describe('VFX authoring descriptor', () => {
   it('keeps the complete program format and asset-local artifact key canonical', () => {
-    expect(VFX_GPU_PROGRAM_FORMAT).toBe('forgeax-vfx-program-2');
+    expect(VFX_GPU_PROGRAM_FORMAT).toBe('forgeax-vfx-program-3');
     expect(VFX_GPU_PROGRAM_ARTIFACT_KEY).toBe('particle-effect/program.json');
     expect(effect.program.format).toBe(VFX_GPU_PROGRAM_FORMAT);
     expect(effect.programFingerprint).toMatch(/^sha256:/);
@@ -129,7 +139,7 @@ describe('VFX authoring descriptor', () => {
     );
     expect(descriptor.capabilities).toEqual(
       expect.arrayContaining([
-        expect.objectContaining({ id: 'runtime-parameters', state: 'partial' }),
+        expect.objectContaining({ id: 'runtime-parameters', state: 'executable' }),
         expect.objectContaining({ id: 'deterministic-replay', state: 'executable' }),
       ]),
     );

package/src/__tests__/channel-input.unit.test.ts

@@ -1,11 +1,14 @@
 import { describe, expect, it } from 'vitest';
 import { createVfxEffectContract } from '../effect-contract.js';
 import { ParticleEffectInstance, type VfxChannelInput } from '../instance.js';
+import { VFX_PARTICLE_CORE_LAYOUT } from '../particle-layout.js';
 
 const reflection = {
-  version: 1,
+  version: 3,
   parameters: { name: 'VfxParameters', fields: [], size: 0, alignment: 1 },
   custom: { name: 'VfxCustom', fields: [], size: 0, alignment: 1 },
+  core: VFX_PARTICLE_CORE_LAYOUT,
+  customLayout: { name: 'VfxCustom', fields: [], size: 0, alignment: 1, stride: 0, lanes: 0 },
   fingerprint: 'sha256:channel-input',
 } as const;
 

package/src/__tests__/channel-overflow-policy-owner.test-d.ts

@@ -4,14 +4,14 @@ import type {
   ParticleChannelOverflowPolicy,
   ParticleChannelSource,
   ParticleRendererOverflowPolicy,
-  ParticleRendererSource,
 } from '../code-source.js';
+import type { ParticleRendererSourceV3 } from '../code-source-v3.js';
 import type {
   ParticleChannelOverflowPolicy as PublicParticleChannelOverflowPolicy,
   ParticleRendererOverflowPolicy as PublicParticleRendererOverflowPolicy,
 } from '../index.js';
 
-type BillboardRenderer = Extract<ParticleRendererSource, { readonly kind: 'billboard' }>;
+type BillboardRenderer = Extract<ParticleRendererSourceV3, { readonly kind: 'billboard' }>;
 type RendererOverflow = BillboardRenderer['overflow'];
 type ChannelOverflow = ParticleChannelSource['overflow'];
 type RendererOverflowSlot = Pick<BillboardRenderer, 'overflow'>;

package/src/__tests__/code-source-v2.unit.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from 'vitest';
-import { parseParticleEffectSourceV2, parseVfxStageDeclarations } from '../code-source.js';
+import { parseVfxStageDeclarations } from '../code-source.js';
+import { parseParticleEffectSourceV3 } from '../code-source-v3.js';
 
 const source = {
-  schemaVersion: 2,
+  schemaVersion: 3,
   emitters: [
     {
       id: 'sparks',
@@ -17,9 +18,9 @@ const source = {
   ],
 };
 
-describe('ParticleCodeEffectSource v2', () => {
+describe('ParticleCodeEffectSource v3', () => {
   it('accepts typed bounded channels and same-effect visual events', () => {
-    const result = parseParticleEffectSourceV2({
+    const result = parseParticleEffectSourceV3({
       ...source,
       emitters: [
         {
@@ -41,7 +42,7 @@ describe('ParticleCodeEffectSource v2', () => {
   });
 
   it('accepts the code-first source without an operator stack', () => {
-    const result = parseParticleEffectSourceV2(source);
+    const result = parseParticleEffectSourceV3(source);
     expect(result.ok).toBe(true);
     if (result.ok) {
       expect(result.value.emitters[0]?.program.module).toBe('sparks.vfx.wgsl');
@@ -56,12 +57,12 @@ describe('ParticleCodeEffectSource v2', () => {
   });
 
   it('rejects v1 with an executable recook hint', () => {
-    const result = parseParticleEffectSourceV2({ schemaVersion: 1, emitters: [] });
+    const result = parseParticleEffectSourceV3({ schemaVersion: 1, emitters: [] });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error.code).toBe('vfx-source-version-unsupported');
-      expect(result.error.hint).toContain('WGSL');
-      expect(result.error.hint).toContain('recook');
+      expect(result.error.hint).toContain('Program v3');
+      expect(result.error.hint).toContain('cold-cook');
     }
   });
 
@@ -73,10 +74,10 @@ describe('ParticleCodeEffectSource v2', () => {
     expect(emitter).toBeDefined();
     if (emitter === undefined) return;
     emitter.backend = { required: 'cpu' };
-    expect(parseParticleEffectSourceV2(backend).ok).toBe(false);
+    expect(parseParticleEffectSourceV3(backend).ok).toBe(false);
     const derived = structuredClone(source) as typeof source & { backendPlan: string };
     derived.backendPlan = 'gpu';
-    expect(parseParticleEffectSourceV2(derived).ok).toBe(false);
+    expect(parseParticleEffectSourceV3(derived).ok).toBe(false);
   });
 
   it.each([
@@ -88,7 +89,7 @@ describe('ParticleCodeEffectSource v2', () => {
     ['custom data', { customData: { value: 1 } }],
   ])('rejects unknown nested %s fields', (_name, override) => {
     const emitter = { ...source.emitters[0], ...override };
-    expect(parseParticleEffectSourceV2({ ...source, emitters: [emitter] }).ok).toBe(false);
+    expect(parseParticleEffectSourceV3({ ...source, emitters: [emitter] }).ok).toBe(false);
   });
 
   it('keeps Data Interface requirements out of the source-side roster', () => {
@@ -96,7 +97,7 @@ describe('ParticleCodeEffectSource v2', () => {
       ...source.emitters[0],
       dataInterfaces: [{ token: 'vfx:camera' }],
     };
-    expect(parseParticleEffectSourceV2({ ...source, emitters: [emitter] }).ok).toBe(false);
+    expect(parseParticleEffectSourceV3({ ...source, emitters: [emitter] }).ok).toBe(false);
   });
 
   it('accepts an explicit mesh submesh and rejects ambiguous indices', () => {
@@ -111,11 +112,11 @@ describe('ParticleCodeEffectSource v2', () => {
       { kind: 'mesh', material: 'material-guid', mesh: 'mesh-guid', submesh: 2 },
     ];
     emitter.renderers = renderers;
-    expect(parseParticleEffectSourceV2(mesh).ok).toBe(true);
+    expect(parseParticleEffectSourceV3(mesh).ok).toBe(true);
     const renderer = renderers[0];
     expect(renderer).toBeDefined();
     if (renderer === undefined) return;
     renderer.submesh = -1;
-    expect(parseParticleEffectSourceV2(mesh).ok).toBe(false);
+    expect(parseParticleEffectSourceV3(mesh).ok).toBe(false);
   });
 });

package/src/__tests__/data-interface-contract.unit.test.ts

@@ -42,7 +42,15 @@ describe('VFX Data Interface contract', () => {
     ],
     [
       'stale generation',
-      [provider({ token: 'vfx:camera', kind: 'camera', bindingType: 'uniform', generation: 2 })],
+      [
+        provider({
+          token: 'vfx:camera',
+          kind: 'camera',
+          bindingType: 'uniform',
+          generation: 2,
+          resource: { kind: 'buffer', value: {}, size: 16, usage: 'uniform' },
+        }),
+      ],
       'vfx-data-interface-stale',
     ],
   ])('%s is a structured failure', (_name, providers, code) => {
@@ -63,12 +71,43 @@ describe('VFX Data Interface contract', () => {
   it('returns generation-scoped readiness for a valid provider', () => {
     const result = resolveVfxDataInterfaces(
       [camera],
-      [provider({ token: 'vfx:camera', kind: 'camera', bindingType: 'uniform' })],
+      [
+        provider({
+          token: 'vfx:camera',
+          kind: 'camera',
+          bindingType: 'uniform',
+          resource: { kind: 'buffer', value: {}, size: 16, usage: 'uniform' },
+        }),
+      ],
       7,
     );
     expect(result).toMatchObject({ ok: true, value: { generation: 7, readiness: 'ready' } });
   });
 
+  it('rejects an opaque resource whose kind cannot satisfy the reflected binding', () => {
+    const result = resolveVfxDataInterfaces(
+      [camera],
+      [
+        provider({
+          token: 'vfx:camera',
+          kind: 'camera',
+          bindingType: 'uniform',
+          resource: { kind: 'texture-view', value: {} },
+        }),
+      ],
+      7,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('vfx-data-interface-wrong-type');
+      expect(result.error.detail).toMatchObject({
+        token: 'vfx:camera',
+        expectedResourceKind: 'buffer',
+        actualResourceKind: 'texture-view',
+      });
+    }
+  });
+
   it('keeps provider failures exhaustive without parsing messages', () => {
     const result: Result<unknown, VfxDataInterfaceError> = resolveVfxDataInterfaces(
       [camera],

package/src/__tests__/effect-contract.unit.test.ts

@@ -1,9 +1,10 @@
 import type { ParticleEffectAsset } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
 import { createVfxEffectContract } from '../effect-contract.js';
+import { VFX_PARTICLE_CORE_LAYOUT } from '../particle-layout.js';
 
 const reflection = {
-  version: 1,
+  version: 3,
   parameters: {
     name: 'VfxParameters',
     fields: [
@@ -14,6 +15,8 @@ const reflection = {
     alignment: 16,
   },
   custom: { name: 'VfxCustom', fields: [], size: 0, alignment: 1 },
+  core: VFX_PARTICLE_CORE_LAYOUT,
+  customLayout: { name: 'VfxCustom', fields: [], size: 0, alignment: 1, stride: 0, lanes: 0 },
   fingerprint: 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
 } as const;
 
@@ -21,11 +24,11 @@ describe('VfxEffectContract', () => {
   it('models the executable program on the ordinary particle asset', () => {
     const asset: ParticleEffectAsset = {
       kind: 'particle-effect',
-      schemaVersion: 2,
+      schemaVersion: 3,
       programFingerprint: 'sha256:program',
       emitters: [{ id: 'sparks', capacity: 8 }],
       program: {
-        format: 'forgeax-vfx-program-2',
+        format: 'forgeax-vfx-program-3',
         fingerprint: 'sha256:program',
         emitters: [],
       },

package/src/__tests__/gpu-program-simulation-culling-owner.test-d.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { describe, expect, expectTypeOf, it } from 'vitest';
-import type { ParticleEmitterSourceV2 } from '../code-source.js';
+import type { ParticleEmitterSourceV3 } from '../code-source-v3.js';
 import type { VfxGpuEmitterProgram } from '../gpu-program.js';
 import type {
   VfxGpuEmitterProgram as PublicVfxGpuEmitterProgram,
@@ -8,7 +8,7 @@ import type {
   VfxGpuProgram,
 } from '../index.js';
 
-type SourceSimulationWhenCulled = ParticleEmitterSourceV2['simulationWhenCulled'];
+type SourceSimulationWhenCulled = ParticleEmitterSourceV3['simulationWhenCulled'];
 type CookedSimulationWhenCulled = VfxGpuEmitterProgram['simulationWhenCulled'];
 type RequiredSimulationWhenCulled = Pick<VfxGpuEmitterProgram, 'simulationWhenCulled'>;
 type PublicProgramEmitter = VfxGpuProgram['emitters'][number];
@@ -19,13 +19,13 @@ const gpuProgramSource = readFileSync(new URL('../gpu-program.ts', import.meta.u
 describe('VFX GPU program simulation culling owner', () => {
   it('derives the cooked policy from the authored source while keeping it required', () => {
     expectTypeOf<CookedSimulationWhenCulled>().toEqualTypeOf<
-      NonNullable<ParticleEmitterSourceV2['simulationWhenCulled']>
+      NonNullable<ParticleEmitterSourceV3['simulationWhenCulled']>
     >();
     expectTypeOf<SourceSimulationWhenCulled>().toEqualTypeOf<
-      NonNullable<ParticleEmitterSourceV2['simulationWhenCulled']> | undefined
+      NonNullable<ParticleEmitterSourceV3['simulationWhenCulled']> | undefined
     >();
     expectTypeOf<RequiredSimulationWhenCulled>().toEqualTypeOf<{
-      readonly simulationWhenCulled: NonNullable<ParticleEmitterSourceV2['simulationWhenCulled']>;
+      readonly simulationWhenCulled: NonNullable<ParticleEmitterSourceV3['simulationWhenCulled']>;
     }>();
   });
 
@@ -49,7 +49,7 @@ describe('VFX GPU program simulation culling owner', () => {
 
   it('keeps the source-derived owner explicit in the declaration', () => {
     expect(gpuProgramSource).toContain(
-      "readonly simulationWhenCulled: NonNullable<ParticleEmitterSourceV2['simulationWhenCulled']>;",
+      "readonly simulationWhenCulled: NonNullable<ParticleEmitterSourceV3['simulationWhenCulled']>;",
     );
     expect(gpuProgramSource).not.toContain(
       "readonly simulationWhenCulled: 'continue' | 'pause' | 'restart-on-visible';",

package/src/__tests__/gpu-reflection-vocabulary-owner.test-d.ts

@@ -1,10 +1,10 @@
 import { describe, expectTypeOf, it } from 'vitest';
 import type {
   ParticleRendererOverflowPolicy,
-  ParticleRendererSorting,
   ParticleStageDomain,
   ParticleStageResourceAccess,
 } from '../code-source.js';
+import type { ParticleRendererSortingV3 } from '../code-source-v3.js';
 import type { VfxGpuRendererReflection, VfxGpuStageReflection } from '../gpu-program.js';
 
 describe('VFX GPU reflection vocabulary owner', () => {
@@ -14,7 +14,7 @@ describe('VFX GPU reflection vocabulary owner', () => {
     >().toEqualTypeOf<ParticleRendererOverflowPolicy>();
     expectTypeOf<
       NonNullable<VfxGpuRendererReflection['sorting']>
-    >().toEqualTypeOf<ParticleRendererSorting>();
+    >().toEqualTypeOf<ParticleRendererSortingV3>();
     expectTypeOf<VfxGpuStageReflection['domain']>().toEqualTypeOf<ParticleStageDomain>();
     expectTypeOf<
       VfxGpuStageReflection['resources'][number]['access']