@quake2ts/test-utils 0.0.838 → 0.0.839

package/src/engine/builders/pcxBuilder.ts

@@ -0,0 +1,51 @@
+interface PcxOptions {
+  readonly width: number;
+  readonly height: number;
+  readonly pixels: readonly number[];
+  readonly palette?: Uint8Array;
+}
+
+export function buildPcx(options: PcxOptions): ArrayBuffer {
+  const { width, height } = options;
+  const headerSize = 128;
+  const paletteSize = 769;
+  const encodedPixels: number[] = [];
+  for (const value of options.pixels) {
+    if (value >= 0xc0) {
+      encodedPixels.push(0xc1, value);
+    } else {
+      encodedPixels.push(value);
+    }
+  }
+  const imageSize = encodedPixels.length;
+  const buffer = new ArrayBuffer(headerSize + imageSize + paletteSize);
+  const view = new DataView(buffer);
+  view.setUint8(0, 0x0a); // manufacturer
+  view.setUint8(1, 5); // version
+  view.setUint8(2, 1); // encoding
+  view.setUint8(3, 8); // bits per pixel
+  view.setUint16(4, 0, true);
+  view.setUint16(6, 0, true);
+  view.setUint16(8, width - 1, true);
+  view.setUint16(10, height - 1, true);
+  view.setUint16(66, width, true);
+
+  const encoded = new Uint8Array(buffer, headerSize, imageSize);
+  encoded.set(encodedPixels);
+
+  const paletteMarkerOffset = headerSize + imageSize;
+  view.setUint8(paletteMarkerOffset, 0x0c);
+  const palette = new Uint8Array(buffer, paletteMarkerOffset + 1, 768);
+  palette.fill(0);
+  if (options.palette) {
+    palette.set(options.palette.subarray(0, 768));
+  } else {
+    for (let i = 0; i < 256; i += 1) {
+      palette[i * 3] = i;
+      palette[i * 3 + 1] = 255 - i;
+      palette[i * 3 + 2] = i;
+    }
+  }
+
+  return buffer;
+}

package/src/engine/builders/visual-testing.ts

@@ -0,0 +1,144 @@
+import { test as base } from 'vitest';
+import {
+    expectSnapshot,
+    createRenderTestSetup,
+    RenderTestSetup,
+    captureTexture
+} from '@quake2ts/test-utils';
+import path from 'path';
+
+interface VisualTestContext {
+  expectSnapshot: (pixels: Uint8ClampedArray, nameOrOptions: string | { name: string; description: string }) => Promise<void>;
+  renderAndExpectSnapshot: (
+    fn: (
+        device: GPUDevice,
+        format: GPUTextureFormat,
+        encoder: GPUCommandEncoder,
+        view: GPUTextureView
+    ) => Promise<((pass: GPURenderPassEncoder) => void) | void>,
+    nameOrOptions: string | { name: string; description: string; depth?: boolean }
+  ) => Promise<void>;
+}
+
+export const test = base.extend<VisualTestContext>({
+  expectSnapshot: async ({ task }, use) => {
+    const impl = async (pixels: Uint8ClampedArray, nameOrOptions: string | { name: string; description: string }) => {
+        const updateBaseline = process.env.UPDATE_VISUAL === '1' || process.argv.includes('--update-snapshots') || process.argv.includes('-u');
+        const testFile = task.file?.filepath;
+        const testDir = testFile ? path.dirname(testFile) : path.join(process.cwd(), 'tests');
+        const snapshotDir = path.join(testDir, '__snapshots__');
+
+        const name = typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions.name;
+        const description = typeof nameOrOptions === 'string' ? undefined : nameOrOptions.description;
+
+        await expectSnapshot(pixels, {
+            name,
+            description,
+            width: 256,
+            height: 256,
+            updateBaseline,
+            snapshotDir
+        });
+    };
+    await use(impl);
+  },
+
+  renderAndExpectSnapshot: async ({ task }, use) => {
+    const updateBaseline = process.env.UPDATE_VISUAL === '1' || process.argv.includes('--update-snapshots') || process.argv.includes('-u');
+    const testFile = task.file?.filepath;
+    const testDir = testFile ? path.dirname(testFile) : path.join(process.cwd(), 'tests');
+    const snapshotDir = path.join(testDir, '__snapshots__');
+
+    let setup: RenderTestSetup | undefined;
+
+    const impl = async (
+        fn: (
+            device: GPUDevice,
+            format: GPUTextureFormat,
+            encoder: GPUCommandEncoder,
+            view: GPUTextureView
+        ) => Promise<((pass: GPURenderPassEncoder) => void) | void>,
+        nameOrOptions: string | { name: string; description: string; depth?: boolean }
+    ) => {
+        const name = typeof nameOrOptions === 'string' ? nameOrOptions : nameOrOptions.name;
+        const description = typeof nameOrOptions === 'string' ? undefined : nameOrOptions.description;
+        const depth = typeof nameOrOptions === 'string' ? false : !!nameOrOptions.depth;
+
+        setup = await createRenderTestSetup(256, 256, { depth });
+        const { device } = setup.context;
+
+        try {
+            const commandEncoder = device.createCommandEncoder();
+
+            // Allow the test to create resources and get the render function
+            // We pass all context info so the test can manage passes manually if needed
+            // Fallback to 'rgba8unorm' if format is missing (quick fix)
+            const renderFn = await fn(
+                device,
+                setup.context.format || 'rgba8unorm',
+                commandEncoder,
+                setup.renderTargetView
+            );
+
+            device.pushErrorScope('validation');
+
+            if (typeof renderFn === 'function') {
+                // Legacy mode: Wrap in a render pass
+                const passDescriptor: GPURenderPassDescriptor = {
+                    colorAttachments: [{
+                        view: setup.renderTargetView,
+                        loadOp: 'clear',
+                        clearValue: { r: 0, g: 0, b: 0, a: 0 },
+                        storeOp: 'store'
+                    }]
+                };
+
+                if (setup.depthTargetView) {
+                    passDescriptor.depthStencilAttachment = {
+                        view: setup.depthTargetView,
+                        depthClearValue: 1.0,
+                        depthLoadOp: 'clear',
+                        depthStoreOp: 'discard'
+                    };
+                }
+
+                const pass = commandEncoder.beginRenderPass(passDescriptor);
+                renderFn(pass);
+                pass.end();
+            } else {
+                // Manual mode: User should have used encoder to record commands
+                // We ensure it's submitted
+            }
+
+            device.queue.submit([commandEncoder.finish()]);
+
+            const error = await device.popErrorScope();
+            if (error) {
+                throw new Error(`WebGPU validation error: ${error.message}`);
+            }
+
+            const pixels = await captureTexture(device, setup.renderTarget, setup.width, setup.height);
+
+            await expectSnapshot(pixels, {
+                name,
+                description,
+                width: setup.width,
+                height: setup.height,
+                updateBaseline,
+                snapshotDir
+            });
+        } finally {
+            if (setup) {
+                await setup.cleanup();
+                setup = undefined;
+            }
+        }
+    };
+
+    await use(impl);
+
+    if (setup) {
+        await setup.cleanup();
+    }
+  },
+});

package/src/engine/builders/walBuilder.ts

@@ -0,0 +1,40 @@
+interface WalOptions {
+  readonly name: string;
+  readonly width: number;
+  readonly height: number;
+  readonly palette?: Uint8Array;
+}
+
+export function buildWal(options: WalOptions): ArrayBuffer {
+  const { width, height } = options;
+  const headerSize = 100;
+  const mipSizes = [
+    width * height,
+    Math.max(1, (width >> 1) * (height >> 1)),
+    Math.max(1, (width >> 2) * (height >> 2)),
+    Math.max(1, (width >> 3) * (height >> 3)),
+  ];
+  const totalSize = headerSize + mipSizes.reduce((a, b) => a + b, 0);
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  const encoder = new TextEncoder();
+  new Uint8Array(buffer, 0, 32).set(encoder.encode(options.name));
+  view.setInt32(32, width, true);
+  view.setInt32(36, height, true);
+
+  let offset = headerSize;
+  mipSizes.forEach((size, index) => {
+    view.setInt32(40 + index * 4, offset, true);
+    const data = new Uint8Array(buffer, offset, size);
+    for (let i = 0; i < size; i += 1) {
+      data[i] = (i + index) % 256;
+    }
+    offset += size;
+  });
+
+  new Uint8Array(buffer, 56, 32).set(encoder.encode(options.name + '_anim'));
+  view.setInt32(88, 0, true);
+  view.setInt32(92, 0, true);
+  view.setInt32(96, 0, true);
+  return buffer;
+}

package/src/engine/builders/wavBuilder.ts

@@ -0,0 +1,49 @@
+interface WavOptions {
+  readonly sampleRate: number;
+  readonly channels: number;
+  readonly samples: readonly number[];
+  readonly bitsPerSample?: number;
+}
+
+export function buildWav(options: WavOptions): ArrayBuffer {
+  const bitsPerSample = options.bitsPerSample ?? 16;
+  const bytesPerSample = bitsPerSample / 8;
+  const frameCount = options.samples.length / options.channels;
+  const dataSize = frameCount * options.channels * bytesPerSample;
+  const buffer = new ArrayBuffer(44 + dataSize);
+  const view = new DataView(buffer);
+
+  const writeString = (offset: number, text: string) => {
+    new Uint8Array(buffer, offset, text.length).set(new TextEncoder().encode(text));
+  };
+
+  writeString(0, 'RIFF');
+  view.setUint32(4, 36 + dataSize, true);
+  writeString(8, 'WAVE');
+  writeString(12, 'fmt ');
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, options.channels, true);
+  view.setUint32(24, options.sampleRate, true);
+  view.setUint32(28, options.sampleRate * options.channels * bytesPerSample, true);
+  view.setUint16(32, options.channels * bytesPerSample, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeString(36, 'data');
+  view.setUint32(40, dataSize, true);
+
+  let offset = 44;
+  for (let i = 0; i < options.samples.length; i += 1) {
+    const sample = options.samples[i]!;
+    if (bitsPerSample === 8) {
+      view.setUint8(offset, Math.max(0, Math.min(255, Math.round(sample * 128 + 128))));
+      offset += 1;
+    } else if (bitsPerSample === 16) {
+      view.setInt16(offset, Math.round(sample * 32767), true);
+      offset += 2;
+    } else {
+      throw new Error('Unsupported bit depth for builder');
+    }
+  }
+
+  return buffer;
+}

package/src/index.ts

@@ -51,6 +51,13 @@ export * from './engine/helpers/webgl-playwright.js';
 export * from './engine/helpers/pipeline-test-template.js';
 export * from './engine/helpers/textures.js';
 export * from './engine/renderers.js';
+export * from './engine/builders/bspBuilder.js';
+export * from './engine/builders/md2Builder.js';
+export * from './engine/builders/md3Builder.js';
+export * from './engine/builders/pakBuilder.js';
+export * from './engine/builders/pcxBuilder.js';
+export * from './engine/builders/walBuilder.js';
+export * from './engine/builders/wavBuilder.js';
 
 // Client Mocks
 export * from './client/mocks/input.js';

package/src/shared/math.ts

@@ -1,4 +1,4 @@
-import type { Vec3, Bounds3 } from '@quake2ts/shared/math/vec3';
+import type { Vec3, Bounds3 } from '@quake2ts/shared';
 
 /**
  * Creates a Vector3 object.