@forgeax/engine-render 0.1.2

package/src/prepare/prepared-graphics-resolver.ts

@@ -0,0 +1,455 @@
+import type { BindGroup, Buffer, RenderPipeline, RhiDevice } from '@forgeax/engine-rhi';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import {
+  type RenderError,
+  RenderFeaturePreparationFailedError,
+  RenderFeaturePreparedStateMismatchError,
+  RenderFeatureStageFailedError,
+} from '../errors/render';
+import type { RenderFeatureResolvedGpuBuffer } from '../features/prepared-gpu-work';
+import type {
+  RenderFeatureBindingsDescriptor,
+  RenderFeaturePreparedRef,
+} from '../features/prepared-graphics';
+import type {
+  PreparedGraphicsItem,
+  PreparedGraphicsKind,
+  PreparedGraphicsNormalizedDescriptor,
+} from '../features/prepared-graphics-store';
+
+type PreparedBufferKind = Exclude<PreparedGraphicsKind, 'pipeline' | 'bindings'>;
+
+type PreparedGraphicsMismatch =
+  | {
+      readonly reason: 'missing-prepared-state';
+      readonly missingResource: string;
+    }
+  | {
+      readonly reason: 'generation-mismatch';
+      readonly expectedGeneration: number;
+      readonly actualGeneration: number;
+    };
+
+export type PreparedGraphicsReference =
+  | RenderFeaturePreparedRef<'pipeline'>
+  | RenderFeaturePreparedRef<'bindings'>
+  | RenderFeaturePreparedRef<'vertex-data'>
+  | RenderFeaturePreparedRef<'index-data'>;
+
+export type PreparedGraphicsResolvedResource =
+  | {
+      readonly kind: 'pipeline';
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: RenderPipeline;
+    }
+  | {
+      readonly kind: 'bindings';
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: BindGroup | undefined;
+      readonly pipeline?: RenderPipeline;
+      readonly descriptor?: RenderFeatureBindingsDescriptor;
+      readonly dynamicOffsets?: readonly number[];
+    }
+  | {
+      readonly kind: PreparedBufferKind;
+      readonly reference: RenderFeaturePreparedRef;
+      readonly handle: Buffer;
+      readonly size: number;
+      readonly physicalUsage: number;
+    };
+
+export interface PreparedGraphicsResolverInput {
+  readonly device: RhiDevice;
+  /** Owning feature identity survives lookup failures for feature-local diagnostics. */
+  readonly featureIdentity?: string;
+  readonly generation: number;
+  readonly capabilityAvailable: boolean;
+  readonly lookup: (reference: RenderFeaturePreparedRef) => PreparedGraphicsItem | undefined;
+  readonly resolvePipeline: (
+    descriptor: PreparedGraphicsNormalizedDescriptor & { readonly kind: 'pipeline' },
+  ) => Result<RenderPipeline, unknown>;
+  readonly resolveBindings: (
+    descriptor: RenderFeatureBindingsDescriptor,
+    pipeline: RenderPipeline,
+  ) => Result<
+    | undefined
+    | BindGroup
+    | {
+        readonly handle: BindGroup;
+        readonly dynamicOffsets?: readonly number[];
+        readonly release: () => Result<void, unknown>;
+      },
+    unknown
+  >;
+  readonly resolveGpuBuffer?: (
+    reference: import('../features/prepared-gpu-work').RenderFeatureGpuBufferRef,
+  ) => RenderFeatureResolvedGpuBuffer | undefined;
+  readonly featureOrder?: number;
+}
+
+export interface PreparedGraphicsResolver {
+  resolve(
+    reference: PreparedGraphicsReference,
+  ): Result<PreparedGraphicsResolvedResource, RenderError>;
+  readonly leases: readonly PreparedGraphicsResourceLease[];
+  readonly resolveGpuBuffer?: PreparedGraphicsResolverInput['resolveGpuBuffer'];
+  release(): Result<void, RenderError>;
+}
+
+export interface PreparedGraphicsResourceLease {
+  release(): Result<void, RenderError>;
+}
+
+export interface PreparedGraphicsResolvedSnapshot {
+  readonly generation: number;
+  readonly leases?: readonly PreparedGraphicsResourceLease[];
+  readonly resolve: (
+    reference: RenderFeaturePreparedRef,
+  ) => PreparedGraphicsResolvedResource | undefined;
+  readonly resolveGpuBuffer?: (
+    reference: import('../features/prepared-gpu-work').RenderFeatureGpuBufferRef,
+  ) => RenderFeatureResolvedGpuBuffer | undefined;
+}
+
+function preparationFailure(
+  item: PreparedGraphicsItem | undefined,
+  input: PreparedGraphicsResolverInput,
+  kind: RenderFeaturePreparedRef['kind'],
+  name: string,
+  reason: string,
+): RenderError {
+  return new RenderFeaturePreparationFailedError(
+    item?.featureIdentity ?? input.featureIdentity ?? 'unknown',
+    input.featureOrder ?? -1,
+    'resolve',
+    kind,
+    name,
+    reason,
+    'next-frame',
+  );
+}
+
+function pipelineResolutionReason(error: unknown): string {
+  return typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    error.code === 'rhi-not-available'
+    ? 'pipeline-pending'
+    : 'pipeline resolution failed';
+}
+
+function stateMismatch(
+  input: PreparedGraphicsResolverInput,
+  reference: RenderFeaturePreparedRef,
+  detail: PreparedGraphicsMismatch,
+): RenderError {
+  if (detail.reason === 'missing-prepared-state') {
+    return new RenderFeaturePreparedStateMismatchError({
+      featureIdentity: input.featureIdentity ?? 'unknown',
+      order: input.featureOrder ?? -1,
+      stage: 'contribute',
+      operation: 'resolve',
+      resourceKind: reference.kind,
+      reason: detail.reason,
+      missingResource: detail.missingResource,
+      recovery: 'next-frame',
+    });
+  }
+  return new RenderFeaturePreparedStateMismatchError({
+    featureIdentity: input.featureIdentity ?? 'unknown',
+    order: input.featureOrder ?? -1,
+    stage: 'contribute',
+    operation: 'resolve',
+    resourceKind: reference.kind,
+    reason: detail.reason,
+    expectedGeneration: detail.expectedGeneration,
+    actualGeneration: detail.actualGeneration,
+    recovery: 'next-frame',
+  });
+}
+
+function bufferUsage(kind: PreparedBufferKind): number {
+  const copyDst = 8;
+  return kind === 'vertex-data' ? 32 | copyDst : 16 | copyDst;
+}
+
+function uploadBuffer(
+  input: PreparedGraphicsResolverInput,
+  item: PreparedGraphicsItem,
+  kind: PreparedBufferKind,
+): Result<Buffer, RenderError> {
+  const bytes = item.uploadBytes;
+  if (bytes === undefined || bytes.length === 0) {
+    return err(preparationFailure(item, input, kind, item.name, 'upload bytes are missing'));
+  }
+  const size = Math.max(4, (bytes.length + 3) & ~3);
+  const created = input.device.createBuffer({
+    label: `${item.featureIdentity}::${item.name}`,
+    size,
+    usage: bufferUsage(kind),
+  });
+  if (!created.ok) {
+    return err(preparationFailure(item, input, kind, item.name, 'device buffer creation failed'));
+  }
+  const payload = new Uint8Array(size);
+  payload.set(bytes);
+  const uploaded = input.device.queue.writeBuffer(created.value, 0, payload);
+  if (!uploaded.ok) {
+    input.device.destroyBuffer(created.value);
+    return err(preparationFailure(item, input, kind, item.name, 'device buffer upload failed'));
+  }
+  return ok(created.value);
+}
+
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: 'pipeline',
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: 'pipeline' }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: 'bindings',
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: 'bindings' }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: PreparedBufferKind,
+): Extract<PreparedGraphicsNormalizedDescriptor, { readonly kind: PreparedBufferKind }> | undefined;
+function descriptorFor(
+  item: PreparedGraphicsItem,
+  kind: PreparedGraphicsNormalizedDescriptor['kind'],
+): PreparedGraphicsNormalizedDescriptor | undefined {
+  return item.descriptor?.kind === kind ? item.descriptor : undefined;
+}
+
+export function createPreparedGraphicsResolver(
+  input: PreparedGraphicsResolverInput,
+): PreparedGraphicsResolver {
+  const resolved = new WeakMap<object, PreparedGraphicsResolvedResource>();
+  const leases: PreparedGraphicsResourceLease[] = [];
+
+  const resolve = (
+    reference: PreparedGraphicsReference,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    if (!input.capabilityAvailable) {
+      return err(
+        preparationFailure(
+          undefined,
+          input,
+          reference.kind,
+          reference.kind,
+          'required capability is unavailable',
+        ),
+      );
+    }
+    const item = input.lookup(reference);
+    if (item === undefined || item.reference !== reference) {
+      return err(
+        stateMismatch(input, reference, {
+          reason: 'missing-prepared-state',
+          missingResource: reference.kind,
+        }),
+      );
+    }
+    if (item.generation !== input.generation || reference.generation !== input.generation) {
+      return err(
+        stateMismatch(input, reference, {
+          reason: 'generation-mismatch',
+          expectedGeneration: input.generation,
+          actualGeneration: reference.generation,
+        }),
+      );
+    }
+    const cached = resolved.get(reference);
+    if (cached !== undefined) return ok(cached);
+
+    switch (reference.kind) {
+      case 'pipeline':
+        return resolvePipeline(item, reference);
+      case 'bindings':
+        return resolveBindings(item, reference);
+      case 'vertex-data':
+      case 'index-data':
+        return resolveBuffer(item, reference);
+    }
+  };
+
+  const resolvePipeline = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<'pipeline'>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, 'pipeline');
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          'pipeline descriptor is missing',
+        ),
+      );
+    }
+    const created = input.resolvePipeline(descriptor);
+    if (!created.ok || created.value === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          created.ok ? 'pipeline resolution failed' : pipelineResolutionReason(created.error),
+        ),
+      );
+    }
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: 'pipeline',
+      reference,
+      handle: created.value,
+    };
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  const resolveBindings = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<'bindings'>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, 'bindings');
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          'bindings descriptor is missing',
+        ),
+      );
+    }
+    const pipeline = resolve(descriptor.pipeline);
+    if (!pipeline.ok || pipeline.value.kind !== 'pipeline') return pipeline;
+    const created = input.resolveBindings(descriptor, pipeline.value.handle);
+    if (!created.ok) {
+      return err(
+        preparationFailure(item, input, reference.kind, item.name, 'bindings resolution failed'),
+      );
+    }
+    const binding =
+      created.value !== undefined &&
+      typeof created.value === 'object' &&
+      created.value !== null &&
+      'handle' in created.value &&
+      'release' in created.value
+        ? created.value
+        : undefined;
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: 'bindings',
+      reference,
+      handle: binding?.handle ?? (created.value as BindGroup | undefined),
+      pipeline: pipeline.value.handle,
+      descriptor,
+      ...(binding?.dynamicOffsets === undefined ? {} : { dynamicOffsets: binding.dynamicOffsets }),
+    };
+    if (binding !== undefined) {
+      let released = false;
+      leases.push({
+        release: () => {
+          if (released) return ok(undefined);
+          released = true;
+          const result = binding.release();
+          return result.ok
+            ? ok(undefined)
+            : err(
+                new RenderFeatureStageFailedError(
+                  item.featureIdentity,
+                  input.featureOrder ?? -1,
+                  'dispose',
+                  'renderer-recover',
+                ),
+              );
+        },
+      });
+    }
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  const resolveBuffer = (
+    item: PreparedGraphicsItem,
+    reference: RenderFeaturePreparedRef<PreparedBufferKind>,
+  ): Result<PreparedGraphicsResolvedResource, RenderError> => {
+    const descriptor = descriptorFor(item, reference.kind);
+    if (descriptor === undefined) {
+      return err(
+        preparationFailure(
+          item,
+          input,
+          reference.kind,
+          item.name,
+          `${reference.kind} descriptor is missing`,
+        ),
+      );
+    }
+    if ('buffer' in descriptor && descriptor.buffer !== undefined) {
+      const handle = input.resolveGpuBuffer?.(descriptor.buffer);
+      if (handle === undefined) {
+        return err(
+          preparationFailure(item, input, reference.kind, item.name, 'GPU buffer is unavailable'),
+        );
+      }
+      const resource: PreparedGraphicsResolvedResource = {
+        kind: reference.kind,
+        reference,
+        handle: handle.buffer,
+        size: handle.size,
+        physicalUsage: handle.physicalUsage,
+      };
+      resolved.set(reference, resource);
+      return ok(resource);
+    }
+    const buffer = uploadBuffer(input, item, reference.kind);
+    if (!buffer.ok) return buffer;
+    const resource: PreparedGraphicsResolvedResource = {
+      kind: reference.kind,
+      reference,
+      handle: buffer.value,
+      size: Math.max(4, ((item.uploadBytes?.length ?? 0) + 3) & ~3),
+      physicalUsage: bufferUsage(reference.kind),
+    };
+    leases.push({
+      release: (() => {
+        let released = false;
+        return () => {
+          if (released) return ok(undefined);
+          released = true;
+          const destroyed = input.device.destroyBuffer(buffer.value);
+          return destroyed.ok
+            ? ok(undefined)
+            : err(
+                new RenderFeatureStageFailedError(
+                  item.featureIdentity,
+                  input.featureOrder ?? -1,
+                  'dispose',
+                  'renderer-recover',
+                ),
+              );
+        };
+      })(),
+    });
+    resolved.set(reference, resource);
+    return ok(resource);
+  };
+
+  return {
+    resolve,
+    leases,
+    ...(input.resolveGpuBuffer === undefined ? {} : { resolveGpuBuffer: input.resolveGpuBuffer }),
+    release: () => {
+      let firstError: RenderError | undefined;
+      for (const lease of leases) {
+        const released = lease.release();
+        if (!released.ok && firstError === undefined) firstError = released.error;
+      }
+      return firstError === undefined ? ok(undefined) : err(firstError);
+    },
+  };
+}

package/src/prepare/schema-readers.ts

@@ -0,0 +1,20 @@
+import type { RenderExtract } from '../extract/schema-readers';
+
+export interface PreparedRenderSchemas {
+  readonly meshAssetHandle: unknown;
+  readonly lightDirection: unknown;
+  readonly cameraProjection: number;
+  readonly cameraNear: number;
+  readonly cameraFar: number;
+}
+
+/** Prepare the extracted fields for record without substituting provisional defaults. */
+export function prepareRenderSchemas(frame: RenderExtract): PreparedRenderSchemas {
+  return {
+    meshAssetHandle: frame.mesh.assetHandle,
+    lightDirection: frame.light.direction,
+    cameraProjection: frame.camera.projection,
+    cameraNear: frame.camera.near,
+    cameraFar: frame.camera.far,
+  };
+}

package/src/record/__tests__/environment-record.test.ts

@@ -0,0 +1,35 @@
+import { World } from '@forgeax/engine-ecs';
+import { describe, expect, it } from 'vitest';
+import { Atmosphere, DirectionalLight, Skylight } from '../../index';
+import { extractFrames } from '../../render-system-extract';
+
+describe('ExtractedEnvironment record cutover', () => {
+  it('carries one atmosphere source and one co-located normalized Sun snapshot', () => {
+    const world = new World();
+    world
+      .spawn(
+        { component: Atmosphere, data: {} },
+        { component: DirectionalLight, data: { direction: [0, -1, 0], intensity: 2 } },
+      )
+      .unwrap();
+
+    const frame = extractFrames([world], 0);
+    expect(frame.environment.kind).toBe('atmosphere');
+    if (frame.environment.kind === 'atmosphere') {
+      expect(frame.environment.atmosphere.entity).toBe(frame.environment.atmosphere.sun.entity);
+      expect([...frame.environment.atmosphere.sun.direction]).toEqual([0, 1, 0]);
+      expect(frame.environment.atmosphere.sun.illuminance).toBe(2);
+    }
+  });
+
+  it('keeps solid-color ambient facts in none without entering the image lane', () => {
+    const world = new World();
+    world.spawn({ component: Skylight, data: { intensity: 0.25 } }).unwrap();
+
+    const frame = extractFrames([world], 0);
+    expect(frame.environment.kind).toBe('none');
+    if (frame.environment.kind === 'none') {
+      expect(frame.environment.skylight?.equirectHandle).toBe(0);
+    }
+  });
+});

package/src/record/__tests__/frame-targets.unit.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import type { RenderSystemInternals } from '../../render-system';
+import type { ExtractedLights } from '../../render-system-extract';
+import { resolveSpotShadowMapSize } from '../frame-targets';
+
+function spotLights(mapSize: number, shadowAtlasTile = 0): ExtractedLights {
+  return {
+    directional: undefined,
+    directionalCount: 0,
+    point: [],
+    spot: [
+      {
+        kind: 'spot',
+        entity: 1,
+        position: new Float32Array([0, 4, 0]),
+        direction: new Float32Array([0, -1, 0]),
+        color: new Float32Array([1, 1, 1]),
+        intensity: 1,
+        invRangeSquared: 1,
+        cosInner: 1,
+        cosOuter: 0.5,
+        castShadow: true,
+        lightViewProj: new Float32Array(16),
+        mapSize,
+        nearPlane: 0.1,
+        farPlane: 50,
+        shadowAtlasTile,
+      },
+    ],
+    lightViewProj: undefined,
+    splitPlanes: undefined,
+    cascadeCount: undefined,
+    cascadeBlend: undefined,
+    shadowMapSize: undefined,
+    depthBias: undefined,
+    normalBias: undefined,
+    pcfKernelSize: undefined,
+    pointShadow: [],
+    directionalCsmConfig: undefined,
+    directionalCsmDirection: undefined,
+  } as unknown as ExtractedLights;
+}
+
+function internals(maxTextureDimension2D: number): RenderSystemInternals {
+  return { device: { limits: { maxTextureDimension2D } } } as unknown as RenderSystemInternals;
+}
+
+describe('spot-only shadow target sizing', () => {
+  it('resolves a non-zero per-tile viewport without a directional light', () => {
+    expect(resolveSpotShadowMapSize(internals(4096), spotLights(2048))).toBe(2048);
+    expect(resolveSpotShadowMapSize(internals(4096), spotLights(8192))).toBe(2048);
+    expect(resolveSpotShadowMapSize(internals(4096), spotLights(2048, -1))).toBeUndefined();
+  });
+});

package/src/record/__tests__/material-bg-cache.unit.test.ts

@@ -0,0 +1,41 @@
+import type { BindGroup, BindGroupLayout, Buffer } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import type { MaterialSnapshot } from '../../render-system-extract';
+import type { MaterialBgAssemblyCacheEntry } from '../frame-snapshot';
+import { isMaterialBgAssemblyCacheHit } from '../main-pass-material';
+
+describe('material bind-group assembly cache', () => {
+  it('invalidates when material buffer capacity growth replaces the buffer', () => {
+    const material = {} as MaterialSnapshot;
+    const materialBgl = {} as BindGroupLayout;
+    const oldBuffer = {} as Buffer;
+    const newBuffer = {} as Buffer;
+    const skylightResources = {
+      irradianceView: {},
+      irradianceSampler: {},
+      prefilterView: {},
+      prefilterSampler: {},
+      brdfLutView: {},
+      brdfLutSampler: {},
+      intensityBuffer: {},
+    } as MaterialBgAssemblyCacheEntry['skylightResources'];
+    const cached: MaterialBgAssemblyCacheEntry = {
+      material,
+      materialResourceEpoch: 7,
+      materialBgl,
+      materialBuffer: oldBuffer,
+      skylightResources,
+      bindGroup: {} as BindGroup,
+    };
+
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, oldBuffer, skylightResources, 7),
+    ).toBe(true);
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, newBuffer, skylightResources, 7),
+    ).toBe(false);
+    expect(
+      isMaterialBgAssemblyCacheHit(cached, material, materialBgl, oldBuffer, skylightResources, 8),
+    ).toBe(false);
+  });
+});

package/src/record/__tests__/material-slot-plan.unit.test.ts

@@ -0,0 +1,76 @@
+import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
+import { describe, expect, it } from 'vitest';
+import { createDerivedMaterialSlotPlan, materialBindingByteLength } from '../material-payload.js';
+import {
+  buildMaterialSlotPlan,
+  findRenderablePrefixForSlotCapacity,
+  materialSlotCountForPrefix,
+} from '../material-slot-plan';
+
+describe('material slot plan', () => {
+  it('interns repeated snapshot identities across renderables', () => {
+    const a = {};
+    const b = {};
+    const c = {};
+    expect(
+      buildMaterialSlotPlan([
+        [a, b],
+        [a, c],
+        [b, a],
+      ]),
+    ).toEqual({
+      slotIndices: [
+        [0, 1],
+        [0, 2],
+        [1, 0],
+      ],
+      slots: [a, b, c],
+      slotOwners: [0, 0, 1],
+    });
+  });
+
+  it('does not merge equal-looking snapshots with distinct identities', () => {
+    expect(buildMaterialSlotPlan([[{}], [{}]])).toMatchObject({
+      slotIndices: [[0], [1]],
+      slots: [{}, {}],
+      slotOwners: [0, 1],
+    });
+  });
+
+  it('truncates only at complete mesh and material prefixes', () => {
+    const indices = [[0], [1, 2, 3], [0, 4], [5, 6, 7, 8]];
+    expect(findRenderablePrefixForSlotCapacity(indices, 3)).toBe(1);
+    expect(findRenderablePrefixForSlotCapacity(indices, 5)).toBe(3);
+    expect(materialSlotCountForPrefix(indices, 3)).toBe(5);
+  });
+});
+
+describe('derived material slot plan', () => {
+  it('exposes one exact owner plan for numeric and texture entries', () => {
+    const plan = createDerivedMaterialSlotPlan([
+      { name: 'roughness', type: 'f32' },
+      { name: 'color', type: 'vec4' },
+      { name: 'albedo', type: 'texture2d' },
+    ]);
+    expect(plan.totalBytes).toBe(plan.layout.totalBytes);
+    expect(plan.numericMembers.map((member) => member.name)).toEqual(['roughness', 'color']);
+    expect(plan.coordinateRecords.map((record) => record.parameter)).toEqual(['albedo']);
+    expect(plan.layoutIdentity).toMatch(/^sha256-/);
+  });
+
+  it('uses the selected shared-PBR schema for the bind range, not a compact authored slot', () => {
+    expect(materialBindingByteLength(DEFAULT_STANDARD_PBR_PARAM_SCHEMA, 512)).toBe(288);
+    expect(
+      materialBindingByteLength(
+        [
+          { name: 'baseColor', type: 'color' },
+          { name: 'metallic', type: 'f32' },
+          { name: 'roughness', type: 'f32' },
+        ],
+        512,
+      ),
+    ).toBe(32);
+    expect(materialBindingByteLength([], 512)).toBe(512);
+    expect(materialBindingByteLength(undefined, 512)).toBe(512);
+  });
+});