@quake2ts/test-utils 0.0.1

package/src/engine/mocks/webgl.ts

@@ -0,0 +1,267 @@
+import { vi } from 'vitest';
+
+interface ShaderRecord {
+  readonly id: number;
+  readonly type: GLenum;
+}
+
+interface ProgramRecord {
+  readonly id: number;
+}
+
+export class MockWebGL2RenderingContext {
+  readonly ARRAY_BUFFER = 0x8892;
+  readonly ELEMENT_ARRAY_BUFFER = 0x8893;
+  readonly STATIC_DRAW = 0x88e4;
+  readonly DYNAMIC_DRAW = 0x88e8;
+  readonly FLOAT = 0x1406;
+  readonly UNSIGNED_SHORT = 0x1403;
+  readonly TEXTURE_2D = 0x0de1;
+  readonly TEXTURE_CUBE_MAP = 0x8513;
+  readonly TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
+  readonly TEXTURE0 = 0x84c0;
+  readonly TEXTURE_WRAP_S = 0x2802;
+  readonly TEXTURE_WRAP_T = 0x2803;
+  readonly TEXTURE_MIN_FILTER = 0x2801;
+  readonly TEXTURE_MAG_FILTER = 0x2800;
+  readonly LINEAR = 0x2601;
+  readonly NEAREST = 0x2600;
+  readonly CLAMP_TO_EDGE = 0x812f;
+  readonly RGBA = 0x1908;
+  readonly UNSIGNED_BYTE = 0x1401;
+  readonly FRAMEBUFFER = 0x8d40;
+  readonly COLOR_ATTACHMENT0 = 0x8ce0;
+  readonly DEPTH_ATTACHMENT = 0x8d00;
+  readonly RENDERBUFFER = 0x8d41;
+  readonly DEPTH_COMPONENT24 = 0x81a6;
+  readonly FRAMEBUFFER_COMPLETE = 0x8cd5;
+  readonly TRIANGLES = 0x0004;
+  readonly DEPTH_TEST = 0x0b71;
+  readonly CULL_FACE = 0x0b44;
+  readonly BLEND = 0x0be2;
+  readonly SRC_ALPHA = 0x0302;
+  readonly ONE_MINUS_SRC_ALPHA = 0x0303;
+  readonly ONE = 1;
+  readonly BACK = 0x0405;
+  readonly LEQUAL = 0x0203;
+  readonly VERTEX_SHADER = 0x8b31;
+  readonly FRAGMENT_SHADER = 0x8b30;
+  readonly COMPILE_STATUS = 0x8b81;
+  readonly LINK_STATUS = 0x8b82;
+  readonly ONE_MINUS_SRC_COLOR = 0x0301;
+  readonly TRIANGLE_STRIP = 0x0005;
+  readonly QUERY_RESULT_AVAILABLE = 0x8867;
+  readonly QUERY_RESULT = 0x8866;
+
+  // Constants commonly used in setup/webgl.ts
+  readonly TRIANGLE_FAN = 0x0006;
+  readonly COLOR_BUFFER_BIT = 0x4000;
+  readonly DEPTH_BUFFER_BIT = 0x0100;
+
+  readonly canvas: HTMLCanvasElement | { width: number; height: number };
+  readonly drawingBufferWidth: number;
+  readonly drawingBufferHeight: number;
+
+  private shaderCounter = 0;
+  private programCounter = 0;
+
+  compileSucceeds = true;
+  linkSucceeds = true;
+  shaderInfoLog = 'shader failed';
+  programInfoLog = 'program failed';
+
+  readonly extensions = new Map<string, unknown>();
+  readonly calls: string[] = [];
+  readonly uniformLocations = new Map<string, WebGLUniformLocation | null>();
+  readonly attributeLocations = new Map<string, number>();
+
+  constructor(canvas?: HTMLCanvasElement) {
+    if (canvas) {
+      this.canvas = canvas;
+      this.drawingBufferWidth = canvas.width;
+      this.drawingBufferHeight = canvas.height;
+    } else {
+      this.canvas = { width: 800, height: 600 };
+      this.drawingBufferWidth = 800;
+      this.drawingBufferHeight = 600;
+    }
+  }
+
+  enable = vi.fn((cap: GLenum) => this.calls.push(`enable:${cap}`));
+  disable = vi.fn((cap: GLenum) => this.calls.push(`disable:${cap}`));
+  depthFunc = vi.fn((func: GLenum) => this.calls.push(`depthFunc:${func}`));
+  cullFace = vi.fn((mode: GLenum) => this.calls.push(`cullFace:${mode}`));
+  depthMask = vi.fn((flag: GLboolean) => this.calls.push(`depthMask:${flag}`));
+  blendFuncSeparate = vi.fn((srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) =>
+    this.calls.push(`blendFuncSeparate:${srcRGB}:${dstRGB}:${srcAlpha}:${dstAlpha}`)
+  );
+  blendFunc = vi.fn((sfactor: GLenum, dfactor: GLenum) => this.calls.push(`blendFunc:${sfactor}:${dfactor}`));
+  getExtension = vi.fn((name: string) => this.extensions.get(name) ?? null);
+  viewport = vi.fn((x: number, y: number, w: number, h: number) => this.calls.push(`viewport:${x}:${y}:${w}:${h}`));
+  clear = vi.fn((mask: number) => this.calls.push(`clear:${mask}`));
+  clearColor = vi.fn((r: number, g: number, b: number, a: number) => this.calls.push(`clearColor:${r}:${g}:${b}:${a}`));
+
+  createShader = vi.fn((type: GLenum) => ({ id: ++this.shaderCounter, type } as unknown as WebGLShader));
+  shaderSource = vi.fn((shader: ShaderRecord, source: string) => this.calls.push(`shaderSource:${shader.id}:${source}`));
+  compileShader = vi.fn((shader: ShaderRecord) => this.calls.push(`compileShader:${shader.id}`));
+  getShaderParameter = vi.fn((shader: ShaderRecord, pname: GLenum) =>
+    pname === this.COMPILE_STATUS ? this.compileSucceeds : null
+  );
+  getShaderInfoLog = vi.fn(() => (this.compileSucceeds ? '' : this.shaderInfoLog));
+  deleteShader = vi.fn((shader: ShaderRecord) => this.calls.push(`deleteShader:${shader.id}`));
+
+  createProgram = vi.fn(() => ({ id: ++this.programCounter } as unknown as WebGLProgram));
+  attachShader = vi.fn((program: ProgramRecord, shader: ShaderRecord) =>
+    this.calls.push(`attach:${program.id}:${shader.id}`)
+  );
+  bindAttribLocation = vi.fn((program: ProgramRecord, index: number, name: string) =>
+    this.calls.push(`bindAttribLocation:${program.id}:${index}:${name}`)
+  );
+  linkProgram = vi.fn((program: ProgramRecord) => this.calls.push(`link:${program.id}`));
+  getProgramParameter = vi.fn((program: ProgramRecord, pname: GLenum) =>
+    pname === this.LINK_STATUS ? this.linkSucceeds : null
+  );
+  getProgramInfoLog = vi.fn(() => (this.linkSucceeds ? '' : this.programInfoLog));
+  deleteProgram = vi.fn((program: ProgramRecord) => this.calls.push(`deleteProgram:${program.id}`));
+  useProgram = vi.fn((program: ProgramRecord | null) => this.calls.push(`useProgram:${program?.id ?? 'null'}`));
+  getUniformLocation = vi.fn((program: ProgramRecord, name: string) => {
+    this.calls.push(`getUniformLocation:${program.id}:${name}`);
+    return this.uniformLocations.get(name) ?? null;
+  });
+  getAttribLocation = vi.fn((program: ProgramRecord, name: string) => {
+    this.calls.push(`getAttribLocation:${program.id}:${name}`);
+    return this.attributeLocations.get(name) ?? -1;
+  });
+
+  createBuffer = vi.fn(() => ({ buffer: {} } as unknown as WebGLBuffer));
+  bindBuffer = vi.fn((target: GLenum, buffer: WebGLBuffer | null) => this.calls.push(`bindBuffer:${target}:${!!buffer}`));
+  bufferData = vi.fn((target: GLenum, data: number | BufferSource, usage: GLenum) =>
+    this.calls.push(`bufferData:${target}:${usage}:${typeof data === 'number' ? data : 'data'}`)
+  );
+  bufferSubData = vi.fn((target: GLenum, offset: number, data: BufferSource) =>
+    this.calls.push(`bufferSubData:${target}:${offset}:${data.byteLength ?? 'len'}`)
+  );
+  deleteBuffer = vi.fn((buffer: WebGLBuffer) => this.calls.push(`deleteBuffer:${!!buffer}`));
+
+  createVertexArray = vi.fn(() => ({ vao: {} } as unknown as WebGLVertexArrayObject));
+  bindVertexArray = vi.fn((vao: WebGLVertexArrayObject | null) => this.calls.push(`bindVertexArray:${!!vao}`));
+  enableVertexAttribArray = vi.fn((index: number) => this.calls.push(`enableAttrib:${index}`));
+  vertexAttribPointer = vi.fn(
+    (index: number, size: number, type: GLenum, normalized: boolean, stride: number, offset: number) =>
+      this.calls.push(`vertexAttribPointer:${index}:${size}:${type}:${normalized}:${stride}:${offset}`)
+  );
+  vertexAttribDivisor = vi.fn((index: number, divisor: number) => this.calls.push(`divisor:${index}:${divisor}`));
+  deleteVertexArray = vi.fn((vao: WebGLVertexArrayObject) => this.calls.push(`deleteVertexArray:${!!vao}`));
+
+  createTexture = vi.fn(() => ({ texture: {} } as unknown as WebGLTexture));
+  activeTexture = vi.fn((unit: GLenum) => this.calls.push(`activeTexture:${unit}`));
+  bindTexture = vi.fn((target: GLenum, texture: WebGLTexture | null) => this.calls.push(`bindTexture:${target}:${!!texture}`));
+  texParameteri = vi.fn((target: GLenum, pname: GLenum, param: GLint) =>
+    this.calls.push(`texParameteri:${target}:${pname}:${param}`)
+  );
+  texImage2D = vi.fn(
+    (
+      target: GLenum,
+      level: GLint,
+      internalFormat: GLenum,
+      width: GLsizei,
+      height: GLsizei,
+      border: GLint,
+      format: GLenum,
+      type: GLenum,
+      pixels: ArrayBufferView | null
+    ) =>
+      this.calls.push(
+        `texImage2D:${target}:${level}:${internalFormat}:${width}:${height}:${border}:${format}:${type}:${pixels ? 'data' : 'null'}`
+      )
+  );
+  texImage3D = vi.fn(); // Stub for compatibility
+  deleteTexture = vi.fn((texture: WebGLTexture) => this.calls.push(`deleteTexture:${!!texture}`));
+
+  createFramebuffer = vi.fn(() => ({ fb: {} } as unknown as WebGLFramebuffer));
+  bindFramebuffer = vi.fn((target: GLenum, framebuffer: WebGLFramebuffer | null) =>
+    this.calls.push(`bindFramebuffer:${target}:${!!framebuffer}`)
+  );
+  framebufferTexture2D = vi.fn(
+    (target: GLenum, attachment: GLenum, textarget: GLenum, texture: WebGLTexture | null, level: GLint) =>
+      this.calls.push(`framebufferTexture2D:${target}:${attachment}:${textarget}:${!!texture}:${level}`)
+  );
+  deleteFramebuffer = vi.fn((fb: WebGLFramebuffer) => this.calls.push(`deleteFramebuffer:${!!fb}`));
+  checkFramebufferStatus = vi.fn((target: GLenum) => this.FRAMEBUFFER_COMPLETE);
+
+  createRenderbuffer = vi.fn(() => ({ rb: {} } as unknown as WebGLRenderbuffer));
+  bindRenderbuffer = vi.fn((target: GLenum, renderbuffer: WebGLRenderbuffer | null) =>
+      this.calls.push(`bindRenderbuffer:${target}:${!!renderbuffer}`)
+  );
+  renderbufferStorage = vi.fn((target: GLenum, internalformat: GLenum, width: GLsizei, height: GLsizei) =>
+      this.calls.push(`renderbufferStorage:${target}:${internalformat}:${width}:${height}`)
+  );
+  framebufferRenderbuffer = vi.fn((target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: WebGLRenderbuffer | null) =>
+      this.calls.push(`framebufferRenderbuffer:${target}:${attachment}:${renderbuffertarget}:${!!renderbuffer}`)
+  );
+  deleteRenderbuffer = vi.fn((rb: WebGLRenderbuffer) => this.calls.push(`deleteRenderbuffer:${!!rb}`));
+
+  drawArrays = vi.fn((mode: GLenum, first: GLint, count: GLsizei) =>
+    this.calls.push(`drawArrays:${mode}:${first}:${count}`)
+  );
+
+  drawElements = vi.fn((mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr) =>
+    this.calls.push(`drawElements:${mode}:${count}:${type}:${offset}`)
+  );
+
+  // Queries
+  createQuery = vi.fn(() => ({}) as WebGLQuery);
+  beginQuery = vi.fn();
+  endQuery = vi.fn();
+  deleteQuery = vi.fn();
+  getQueryParameter = vi.fn();
+  getParameter = vi.fn();
+
+  uniform1f = vi.fn((location: WebGLUniformLocation | null, x: GLfloat) =>
+    this.calls.push(`uniform1f:${location ? 'set' : 'null'}:${x}`)
+  );
+  uniform1i = vi.fn((location: WebGLUniformLocation | null, x: GLint) =>
+    this.calls.push(`uniform1i:${location ? 'set' : 'null'}:${x}`)
+  );
+  uniform4f = vi.fn((location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) =>
+    this.calls.push(`uniform4f:${location ? 'set' : 'null'}:${x}:${y}:${z}:${w}`)
+  );
+  uniform3fv = vi.fn((location: WebGLUniformLocation | null, data: Float32List | number[]) =>
+    this.calls.push(`uniform3fv:${location ? 'set' : 'null'}:${Array.from(data as Iterable<number>).join(',')}`)
+  );
+  uniform3f = vi.fn((location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat, z: GLfloat) =>
+    this.calls.push(`uniform3f:${location ? 'set' : 'null'}:${x}:${y}:${z}`)
+  );
+  uniform2f = vi.fn((location: WebGLUniformLocation | null, x: GLfloat, y: GLfloat) =>
+    this.calls.push(`uniform2f:${location ? 'set' : 'null'}:${x}:${y}`)
+  );
+  uniform4fv = vi.fn((location: WebGLUniformLocation | null, data: Float32List) =>
+    this.calls.push(`uniform4fv:${location ? 'set' : 'null'}:${Array.from(data as Iterable<number>).join(',')}`)
+  );
+  uniformMatrix4fv = vi.fn(
+    (location: WebGLUniformLocation | null, transpose: GLboolean, data: Float32List | Iterable<number>) =>
+      this.calls.push(`uniformMatrix4fv:${location ? 'set' : 'null'}:${transpose}:${Array.from(data as Iterable<number>).join(',')}`)
+  );
+
+  uniformBlockBinding = vi.fn();
+
+  isContextLost = vi.fn(() => false);
+}
+
+export function createMockWebGL2Context(
+  overridesOrCanvas?: Partial<WebGL2RenderingContext> | HTMLCanvasElement
+): MockWebGL2RenderingContext {
+  let context: MockWebGL2RenderingContext;
+
+  if (overridesOrCanvas instanceof Object && 'width' in overridesOrCanvas && 'height' in overridesOrCanvas && 'getContext' in overridesOrCanvas) {
+    // It's likely a canvas element (or mock of it)
+    context = new MockWebGL2RenderingContext(overridesOrCanvas as HTMLCanvasElement);
+  } else {
+    context = new MockWebGL2RenderingContext();
+    if (overridesOrCanvas) {
+      Object.assign(context, overridesOrCanvas);
+    }
+  }
+
+  return context;
+}

package/src/engine/mocks/webgpu.ts

@@ -0,0 +1,262 @@
+import { vi } from 'vitest';
+import { globals } from 'webgpu';
+
+export interface MockWebGPUContext {
+  adapter: GPUAdapter;
+  device: GPUDevice;
+  queue: GPUQueue;
+}
+
+/**
+ * Patches globalThis with WebGPU globals (GPUBufferUsage, etc.)
+ * and optionally patches navigator.gpu.
+ */
+export function setupWebGPUMocks() {
+    // 1. Inject globals like GPUBufferUsage, GPUTextureUsage
+    Object.assign(globalThis, globals);
+
+    // 2. Setup Navigator mock
+    const mockGpu = {
+      requestAdapter: vi.fn(),
+      getPreferredCanvasFormat: vi.fn().mockReturnValue('bgra8unorm'),
+    };
+
+    // Create mocks for Adapter and Device
+    const mockAdapter = createMockGPUAdapter();
+    const mockDevice = createMockGPUDevice();
+
+    // Wire them up
+    mockGpu.requestAdapter.mockResolvedValue(mockAdapter);
+    // @ts-ignore - vitest mock manipulation
+    mockAdapter.requestDevice.mockResolvedValue(mockDevice);
+
+    if (!globalThis.navigator) {
+      // @ts-ignore
+      globalThis.navigator = {};
+    }
+
+    // Safely redefine navigator.gpu
+    try {
+        // If it exists and is configurable, define it.
+        // If it doesn't exist, define it.
+        // If it exists and is NOT configurable, we can't do much (but that shouldn't happen in our test env if we control it)
+        Object.defineProperty(globalThis.navigator, 'gpu', {
+            value: mockGpu,
+            writable: true,
+            configurable: true
+        });
+    } catch (e) {
+        // Fallback: simple assignment if defineProperty fails (e.g. some JSDOM quirks)
+        // @ts-ignore
+        globalThis.navigator.gpu = mockGpu;
+    }
+
+    return {
+      mockGpu,
+      mockAdapter,
+      mockDevice
+    };
+}
+
+export function createMockGPUAdapter(options: Partial<GPUAdapter> = {}): GPUAdapter {
+  return {
+    features: new Set(),
+    limits: {},
+    isFallbackAdapter: false,
+    requestDevice: vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestAdapterInfo: vi.fn().mockResolvedValue({}),
+    ...options,
+  } as unknown as GPUAdapter;
+}
+
+export function createMockGPUDevice(features: Set<GPUFeatureName> = new Set()): GPUDevice {
+  const queue = createMockQueue();
+
+  return {
+    features,
+    limits: {},
+    queue,
+    destroy: vi.fn(),
+    createBuffer: vi.fn((descriptor: GPUBufferDescriptor) => createMockGPUBuffer(descriptor)),
+    createTexture: vi.fn((descriptor: GPUTextureDescriptor) => createMockGPUTexture(descriptor)),
+    createSampler: vi.fn(() => createMockSampler()),
+    createBindGroupLayout: vi.fn(() => ({ label: 'mock-bind-group-layout' })),
+    createPipelineLayout: vi.fn(() => ({ label: 'mock-pipeline-layout' })),
+    createBindGroup: vi.fn(() => ({ label: 'mock-bind-group' })),
+    createShaderModule: vi.fn((descriptor: GPUShaderModuleDescriptor) => createMockShaderModule(descriptor)),
+    createComputePipeline: vi.fn(() => createMockComputePipeline()),
+    createRenderPipeline: vi.fn(() => createMockRenderPipeline()),
+    createComputePipelineAsync: vi.fn().mockResolvedValue(createMockComputePipeline()),
+    createRenderPipelineAsync: vi.fn().mockResolvedValue(createMockRenderPipeline()),
+    createCommandEncoder: vi.fn(() => createMockCommandEncoder()),
+    createQuerySet: vi.fn(() => ({ label: 'mock-query-set' })),
+    pushErrorScope: vi.fn(),
+    popErrorScope: vi.fn().mockResolvedValue(null),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+    onuncapturederror: null,
+    label: '',
+    lost: Promise.resolve({ reason: 'destroyed', message: 'Device lost' }),
+  } as unknown as GPUDevice;
+}
+
+export function createMockQueue(): GPUQueue {
+  return {
+    submit: vi.fn(),
+    onSubmittedWorkDone: vi.fn().mockResolvedValue(undefined),
+    writeBuffer: vi.fn(),
+    writeTexture: vi.fn(),
+    copyExternalImageToTexture: vi.fn(),
+    label: '',
+  } as unknown as GPUQueue;
+}
+
+export function createMockGPUBuffer(descriptor: GPUBufferDescriptor): GPUBuffer {
+  return {
+    size: descriptor.size,
+    usage: descriptor.usage,
+    mapState: 'unmapped',
+    mapAsync: vi.fn().mockResolvedValue(undefined),
+    getMappedRange: vi.fn(() => new ArrayBuffer(descriptor.size)),
+    unmap: vi.fn(),
+    destroy: vi.fn(),
+    label: descriptor.label || '',
+  } as unknown as GPUBuffer;
+}
+
+export function createMockGPUTexture(descriptor: GPUTextureDescriptor): GPUTexture {
+  const size = descriptor.size;
+  let width = 0;
+  let height = 0;
+  let depthOrArrayLayers = 1;
+
+  if (Array.isArray(size) || size instanceof Float32Array || size instanceof Uint32Array) {
+      // Iterable<number>
+      const arr = Array.from(size as Iterable<number>);
+      width = arr[0] || 0;
+      height = arr[1] || 1;
+      depthOrArrayLayers = arr[2] || 1;
+  } else if (typeof size === 'object') {
+      // GPUExtent3DDict
+      const dict = size as GPUExtent3DDict;
+      width = dict.width;
+      height = dict.height || 1;
+      depthOrArrayLayers = dict.depthOrArrayLayers || 1;
+  }
+
+  return {
+    width,
+    height,
+    depthOrArrayLayers,
+    mipLevelCount: descriptor.mipLevelCount || 1,
+    sampleCount: descriptor.sampleCount || 1,
+    dimension: descriptor.dimension || '2d',
+    format: descriptor.format,
+    usage: descriptor.usage,
+    createView: vi.fn(() => createMockTextureView()),
+    destroy: vi.fn(),
+    label: descriptor.label || '',
+  } as unknown as GPUTexture;
+}
+
+export function createMockTextureView(): GPUTextureView {
+  return {
+    label: '',
+  } as unknown as GPUTextureView;
+}
+
+export function createMockSampler(): GPUSampler {
+  return {
+    label: '',
+  } as unknown as GPUSampler;
+}
+
+export function createMockShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule {
+  return {
+    getCompilationInfo: vi.fn().mockResolvedValue({ messages: [] }),
+    label: descriptor.label || '',
+  } as unknown as GPUShaderModule;
+}
+
+export function createMockComputePipeline(): GPUComputePipeline {
+  return {
+    getBindGroupLayout: vi.fn(() => ({ label: 'mock-bind-group-layout' })),
+    label: '',
+  } as unknown as GPUComputePipeline;
+}
+
+export function createMockRenderPipeline(): GPURenderPipeline {
+  return {
+    getBindGroupLayout: vi.fn(() => ({ label: 'mock-bind-group-layout' })),
+    label: '',
+  } as unknown as GPURenderPipeline;
+}
+
+export function createMockCommandEncoder(): GPUCommandEncoder {
+  return {
+    beginRenderPass: vi.fn(() => createMockRenderPassEncoder()),
+    beginComputePass: vi.fn(() => createMockComputePassEncoder()),
+    copyBufferToBuffer: vi.fn(),
+    copyBufferToTexture: vi.fn(),
+    copyTextureToBuffer: vi.fn(),
+    copyTextureToTexture: vi.fn(),
+    clearBuffer: vi.fn(),
+    writeTimestamp: vi.fn(),
+    resolveQuerySet: vi.fn(),
+    finish: vi.fn(() => ({ label: 'mock-command-buffer' })),
+    pushDebugGroup: vi.fn(),
+    popDebugGroup: vi.fn(),
+    insertDebugMarker: vi.fn(),
+    label: '',
+  } as unknown as GPUCommandEncoder;
+}
+
+export function createMockRenderPassEncoder(): GPURenderPassEncoder {
+  return {
+    setPipeline: vi.fn(),
+    setIndexBuffer: vi.fn(),
+    setVertexBuffer: vi.fn(),
+    setBindGroup: vi.fn(),
+    setViewport: vi.fn(),
+    setScissorRect: vi.fn(),
+    setBlendConstant: vi.fn(),
+    setStencilReference: vi.fn(),
+    beginOcclusionQuery: vi.fn(),
+    endOcclusionQuery: vi.fn(),
+    executeBundles: vi.fn(),
+    draw: vi.fn(),
+    drawIndexed: vi.fn(),
+    drawIndirect: vi.fn(),
+    drawIndexedIndirect: vi.fn(),
+    end: vi.fn(),
+    pushDebugGroup: vi.fn(),
+    popDebugGroup: vi.fn(),
+    insertDebugMarker: vi.fn(),
+    label: '',
+  } as unknown as GPURenderPassEncoder;
+}
+
+export function createMockComputePassEncoder(): GPUComputePassEncoder {
+  return {
+    setPipeline: vi.fn(),
+    setBindGroup: vi.fn(),
+    dispatchWorkgroups: vi.fn(),
+    dispatchWorkgroupsIndirect: vi.fn(),
+    end: vi.fn(),
+    pushDebugGroup: vi.fn(),
+    popDebugGroup: vi.fn(),
+    insertDebugMarker: vi.fn(),
+    label: '',
+  } as unknown as GPUComputePassEncoder;
+}
+
+export function createMockWebGPUContext(): MockWebGPUContext {
+  const adapter = createMockGPUAdapter();
+  const device = createMockGPUDevice();
+  return {
+    adapter,
+    device,
+    queue: device.queue,
+  };
+}

package/src/engine/rendering.ts

@@ -0,0 +1,103 @@
+import { vi } from 'vitest';
+import { createMockWebGL2Context, MockWebGL2RenderingContext } from './mocks/webgl.js';
+
+// Define minimal mock interfaces for internal engine components not publicly exported.
+interface MockPipeline {
+  render: ReturnType<typeof vi.fn>;
+  init: ReturnType<typeof vi.fn>;
+  resize: ReturnType<typeof vi.fn>;
+}
+
+interface MockCamera {
+  update: ReturnType<typeof vi.fn>;
+  getViewMatrix: ReturnType<typeof vi.fn>;
+  getProjectionMatrix: ReturnType<typeof vi.fn>;
+  getViewProjectionMatrix: ReturnType<typeof vi.fn>;
+  getPosition: ReturnType<typeof vi.fn>;
+  getForward: ReturnType<typeof vi.fn>;
+  getRight: ReturnType<typeof vi.fn>;
+  getUp: ReturnType<typeof vi.fn>;
+  extractFrustumPlanes: ReturnType<typeof vi.fn>;
+  transform: {
+    origin: number[];
+    angles: number[];
+    fov: number;
+  };
+}
+
+export interface MockRenderingContext {
+  gl: MockWebGL2RenderingContext;
+  camera: MockCamera;
+  pipelines: {
+    md2: MockPipeline;
+    bsp: MockPipeline;
+    sprite: MockPipeline;
+    poly: MockPipeline;
+    particle: MockPipeline;
+  };
+}
+
+export function createMockRenderingContext(): MockRenderingContext {
+  const gl = createMockWebGL2Context();
+
+  // Mock Camera
+  const camera: MockCamera = {
+    update: vi.fn(),
+    getViewMatrix: vi.fn().mockReturnValue(new Float32Array(16)),
+    getProjectionMatrix: vi.fn().mockReturnValue(new Float32Array(16)),
+    getViewProjectionMatrix: vi.fn().mockReturnValue(new Float32Array(16)),
+    getPosition: vi.fn().mockReturnValue([0, 0, 0]),
+    getForward: vi.fn().mockReturnValue([0, 0, -1]),
+    getRight: vi.fn().mockReturnValue([1, 0, 0]),
+    getUp: vi.fn().mockReturnValue([0, 1, 0]),
+    extractFrustumPlanes: vi.fn(),
+    transform: {
+      origin: [0, 0, 0],
+      angles: [0, 0, 0],
+      fov: 90
+    }
+  };
+
+  // Mock Pipelines
+  const md2: MockPipeline = {
+    render: vi.fn(),
+    init: vi.fn(),
+    resize: vi.fn(),
+  };
+
+  const bsp: MockPipeline = {
+    render: vi.fn(),
+    init: vi.fn(),
+    resize: vi.fn(),
+  };
+
+  const sprite: MockPipeline = {
+    render: vi.fn(),
+    init: vi.fn(),
+    resize: vi.fn(),
+  };
+
+  const poly: MockPipeline = {
+    render: vi.fn(),
+    init: vi.fn(),
+    resize: vi.fn(),
+  };
+
+  const particle: MockPipeline = {
+    render: vi.fn(),
+    init: vi.fn(),
+    resize: vi.fn(),
+  };
+
+  return {
+    gl,
+    camera,
+    pipelines: {
+      md2,
+      bsp,
+      sprite,
+      poly,
+      particle
+    }
+  };
+}