quake2ts 0.0.577 → 0.0.580

package/packages/test-utils/dist/index.js

@@ -1521,128 +1521,221 @@ function createInputInjector(target) {
   return new InputInjector(doc, win);
 }
 
-// src/setup/webgl.ts
-function createMockWebGL2Context(canvas) {
-  const gl = {
-    canvas,
-    drawingBufferWidth: canvas.width,
-    drawingBufferHeight: canvas.height,
-    // Constants
-    VERTEX_SHADER: 35633,
-    FRAGMENT_SHADER: 35632,
-    COMPILE_STATUS: 35713,
-    LINK_STATUS: 35714,
-    ARRAY_BUFFER: 34962,
-    ELEMENT_ARRAY_BUFFER: 34963,
-    STATIC_DRAW: 35044,
-    DYNAMIC_DRAW: 35048,
-    FLOAT: 5126,
-    DEPTH_TEST: 2929,
-    BLEND: 3042,
-    SRC_ALPHA: 770,
-    ONE_MINUS_SRC_ALPHA: 771,
-    TEXTURE_2D: 3553,
-    RGBA: 6408,
-    UNSIGNED_BYTE: 5121,
-    COLOR_BUFFER_BIT: 16384,
-    DEPTH_BUFFER_BIT: 256,
-    TRIANGLES: 4,
-    TRIANGLE_STRIP: 5,
-    TRIANGLE_FAN: 6,
-    // Methods
-    createShader: () => ({}),
-    shaderSource: () => {
-    },
-    compileShader: () => {
-    },
-    getShaderParameter: (_, param) => {
-      if (param === 35713) return true;
-      return true;
-    },
-    getShaderInfoLog: () => "",
-    createProgram: () => ({}),
-    attachShader: () => {
-    },
-    linkProgram: () => {
-    },
-    getProgramParameter: (_, param) => {
-      if (param === 35714) return true;
-      return true;
-    },
-    getProgramInfoLog: () => "",
-    useProgram: () => {
-    },
-    createBuffer: () => ({}),
-    bindBuffer: () => {
-    },
-    bufferData: () => {
-    },
-    enableVertexAttribArray: () => {
-    },
-    vertexAttribPointer: () => {
-    },
-    enable: () => {
-    },
-    disable: () => {
-    },
-    depthMask: () => {
-    },
-    blendFunc: () => {
-    },
-    viewport: () => {
-    },
-    clearColor: () => {
-    },
-    clear: () => {
-    },
-    createTexture: () => ({}),
-    bindTexture: () => {
-    },
-    texImage2D: () => {
-    },
-    texParameteri: () => {
-    },
-    activeTexture: () => {
-    },
-    uniform1i: () => {
-    },
-    uniform1f: () => {
-    },
-    uniform2f: () => {
-    },
-    uniform3f: () => {
-    },
-    uniform4f: () => {
-    },
-    uniformMatrix4fv: () => {
-    },
-    getUniformLocation: () => ({}),
-    getAttribLocation: () => 0,
-    drawArrays: () => {
-    },
-    drawElements: () => {
-    },
-    createVertexArray: () => ({}),
-    bindVertexArray: () => {
-    },
-    deleteShader: () => {
-    },
-    deleteProgram: () => {
-    },
-    deleteBuffer: () => {
-    },
-    deleteTexture: () => {
-    },
-    deleteVertexArray: () => {
-    },
-    // WebGL2 specific
-    texImage3D: () => {
-    },
-    uniformBlockBinding: () => {
-    },
-    getExtension: () => null
-  };
-  return gl;
+// src/engine/mocks/webgl.ts
+import { vi as vi10 } from "vitest";
+var MockWebGL2RenderingContext = class {
+  constructor(canvas) {
+    this.ARRAY_BUFFER = 34962;
+    this.ELEMENT_ARRAY_BUFFER = 34963;
+    this.STATIC_DRAW = 35044;
+    this.DYNAMIC_DRAW = 35048;
+    this.FLOAT = 5126;
+    this.UNSIGNED_SHORT = 5123;
+    this.TEXTURE_2D = 3553;
+    this.TEXTURE_CUBE_MAP = 34067;
+    this.TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+    this.TEXTURE0 = 33984;
+    this.TEXTURE_WRAP_S = 10242;
+    this.TEXTURE_WRAP_T = 10243;
+    this.TEXTURE_MIN_FILTER = 10241;
+    this.TEXTURE_MAG_FILTER = 10240;
+    this.LINEAR = 9729;
+    this.NEAREST = 9728;
+    this.CLAMP_TO_EDGE = 33071;
+    this.RGBA = 6408;
+    this.UNSIGNED_BYTE = 5121;
+    this.FRAMEBUFFER = 36160;
+    this.COLOR_ATTACHMENT0 = 36064;
+    this.DEPTH_ATTACHMENT = 36096;
+    this.RENDERBUFFER = 36161;
+    this.DEPTH_COMPONENT24 = 33190;
+    this.FRAMEBUFFER_COMPLETE = 36053;
+    this.TRIANGLES = 4;
+    this.DEPTH_TEST = 2929;
+    this.CULL_FACE = 2884;
+    this.BLEND = 3042;
+    this.SRC_ALPHA = 770;
+    this.ONE_MINUS_SRC_ALPHA = 771;
+    this.ONE = 1;
+    this.BACK = 1029;
+    this.LEQUAL = 515;
+    this.VERTEX_SHADER = 35633;
+    this.FRAGMENT_SHADER = 35632;
+    this.COMPILE_STATUS = 35713;
+    this.LINK_STATUS = 35714;
+    this.ONE_MINUS_SRC_COLOR = 769;
+    this.TRIANGLE_STRIP = 5;
+    this.QUERY_RESULT_AVAILABLE = 34919;
+    this.QUERY_RESULT = 34918;
+    // Constants commonly used in setup/webgl.ts
+    this.TRIANGLE_FAN = 6;
+    this.COLOR_BUFFER_BIT = 16384;
+    this.DEPTH_BUFFER_BIT = 256;
+    this.shaderCounter = 0;
+    this.programCounter = 0;
+    this.compileSucceeds = true;
+    this.linkSucceeds = true;
+    this.shaderInfoLog = "shader failed";
+    this.programInfoLog = "program failed";
+    this.extensions = /* @__PURE__ */ new Map();
+    this.calls = [];
+    this.uniformLocations = /* @__PURE__ */ new Map();
+    this.attributeLocations = /* @__PURE__ */ new Map();
+    this.enable = vi10.fn((cap) => this.calls.push(`enable:${cap}`));
+    this.disable = vi10.fn((cap) => this.calls.push(`disable:${cap}`));
+    this.depthFunc = vi10.fn((func) => this.calls.push(`depthFunc:${func}`));
+    this.cullFace = vi10.fn((mode) => this.calls.push(`cullFace:${mode}`));
+    this.depthMask = vi10.fn((flag) => this.calls.push(`depthMask:${flag}`));
+    this.blendFuncSeparate = vi10.fn(
+      (srcRGB, dstRGB, srcAlpha, dstAlpha) => this.calls.push(`blendFuncSeparate:${srcRGB}:${dstRGB}:${srcAlpha}:${dstAlpha}`)
+    );
+    this.blendFunc = vi10.fn((sfactor, dfactor) => this.calls.push(`blendFunc:${sfactor}:${dfactor}`));
+    this.getExtension = vi10.fn((name) => this.extensions.get(name) ?? null);
+    this.viewport = vi10.fn((x, y, w, h) => this.calls.push(`viewport:${x}:${y}:${w}:${h}`));
+    this.clear = vi10.fn((mask) => this.calls.push(`clear:${mask}`));
+    this.clearColor = vi10.fn((r, g, b, a) => this.calls.push(`clearColor:${r}:${g}:${b}:${a}`));
+    this.createShader = vi10.fn((type) => ({ id: ++this.shaderCounter, type }));
+    this.shaderSource = vi10.fn((shader, source) => this.calls.push(`shaderSource:${shader.id}:${source}`));
+    this.compileShader = vi10.fn((shader) => this.calls.push(`compileShader:${shader.id}`));
+    this.getShaderParameter = vi10.fn(
+      (shader, pname) => pname === this.COMPILE_STATUS ? this.compileSucceeds : null
+    );
+    this.getShaderInfoLog = vi10.fn(() => this.compileSucceeds ? "" : this.shaderInfoLog);
+    this.deleteShader = vi10.fn((shader) => this.calls.push(`deleteShader:${shader.id}`));
+    this.createProgram = vi10.fn(() => ({ id: ++this.programCounter }));
+    this.attachShader = vi10.fn(
+      (program, shader) => this.calls.push(`attach:${program.id}:${shader.id}`)
+    );
+    this.bindAttribLocation = vi10.fn(
+      (program, index, name) => this.calls.push(`bindAttribLocation:${program.id}:${index}:${name}`)
+    );
+    this.linkProgram = vi10.fn((program) => this.calls.push(`link:${program.id}`));
+    this.getProgramParameter = vi10.fn(
+      (program, pname) => pname === this.LINK_STATUS ? this.linkSucceeds : null
+    );
+    this.getProgramInfoLog = vi10.fn(() => this.linkSucceeds ? "" : this.programInfoLog);
+    this.deleteProgram = vi10.fn((program) => this.calls.push(`deleteProgram:${program.id}`));
+    this.useProgram = vi10.fn((program) => this.calls.push(`useProgram:${program?.id ?? "null"}`));
+    this.getUniformLocation = vi10.fn((program, name) => {
+      this.calls.push(`getUniformLocation:${program.id}:${name}`);
+      return this.uniformLocations.get(name) ?? null;
+    });
+    this.getAttribLocation = vi10.fn((program, name) => {
+      this.calls.push(`getAttribLocation:${program.id}:${name}`);
+      return this.attributeLocations.get(name) ?? -1;
+    });
+    this.createBuffer = vi10.fn(() => ({ buffer: {} }));
+    this.bindBuffer = vi10.fn((target, buffer) => this.calls.push(`bindBuffer:${target}:${!!buffer}`));
+    this.bufferData = vi10.fn(
+      (target, data, usage) => this.calls.push(`bufferData:${target}:${usage}:${typeof data === "number" ? data : "data"}`)
+    );
+    this.bufferSubData = vi10.fn(
+      (target, offset, data) => this.calls.push(`bufferSubData:${target}:${offset}:${data.byteLength ?? "len"}`)
+    );
+    this.deleteBuffer = vi10.fn((buffer) => this.calls.push(`deleteBuffer:${!!buffer}`));
+    this.createVertexArray = vi10.fn(() => ({ vao: {} }));
+    this.bindVertexArray = vi10.fn((vao) => this.calls.push(`bindVertexArray:${!!vao}`));
+    this.enableVertexAttribArray = vi10.fn((index) => this.calls.push(`enableAttrib:${index}`));
+    this.vertexAttribPointer = vi10.fn(
+      (index, size, type, normalized, stride, offset) => this.calls.push(`vertexAttribPointer:${index}:${size}:${type}:${normalized}:${stride}:${offset}`)
+    );
+    this.vertexAttribDivisor = vi10.fn((index, divisor) => this.calls.push(`divisor:${index}:${divisor}`));
+    this.deleteVertexArray = vi10.fn((vao) => this.calls.push(`deleteVertexArray:${!!vao}`));
+    this.createTexture = vi10.fn(() => ({ texture: {} }));
+    this.activeTexture = vi10.fn((unit) => this.calls.push(`activeTexture:${unit}`));
+    this.bindTexture = vi10.fn((target, texture) => this.calls.push(`bindTexture:${target}:${!!texture}`));
+    this.texParameteri = vi10.fn(
+      (target, pname, param) => this.calls.push(`texParameteri:${target}:${pname}:${param}`)
+    );
+    this.texImage2D = vi10.fn(
+      (target, level, internalFormat, width, height, border, format, type, pixels) => this.calls.push(
+        `texImage2D:${target}:${level}:${internalFormat}:${width}:${height}:${border}:${format}:${type}:${pixels ? "data" : "null"}`
+      )
+    );
+    this.texImage3D = vi10.fn();
+    // Stub for compatibility
+    this.deleteTexture = vi10.fn((texture) => this.calls.push(`deleteTexture:${!!texture}`));
+    this.createFramebuffer = vi10.fn(() => ({ fb: {} }));
+    this.bindFramebuffer = vi10.fn(
+      (target, framebuffer) => this.calls.push(`bindFramebuffer:${target}:${!!framebuffer}`)
+    );
+    this.framebufferTexture2D = vi10.fn(
+      (target, attachment, textarget, texture, level) => this.calls.push(`framebufferTexture2D:${target}:${attachment}:${textarget}:${!!texture}:${level}`)
+    );
+    this.deleteFramebuffer = vi10.fn((fb) => this.calls.push(`deleteFramebuffer:${!!fb}`));
+    this.checkFramebufferStatus = vi10.fn((target) => this.FRAMEBUFFER_COMPLETE);
+    this.createRenderbuffer = vi10.fn(() => ({ rb: {} }));
+    this.bindRenderbuffer = vi10.fn(
+      (target, renderbuffer) => this.calls.push(`bindRenderbuffer:${target}:${!!renderbuffer}`)
+    );
+    this.renderbufferStorage = vi10.fn(
+      (target, internalformat, width, height) => this.calls.push(`renderbufferStorage:${target}:${internalformat}:${width}:${height}`)
+    );
+    this.framebufferRenderbuffer = vi10.fn(
+      (target, attachment, renderbuffertarget, renderbuffer) => this.calls.push(`framebufferRenderbuffer:${target}:${attachment}:${renderbuffertarget}:${!!renderbuffer}`)
+    );
+    this.deleteRenderbuffer = vi10.fn((rb) => this.calls.push(`deleteRenderbuffer:${!!rb}`));
+    this.drawArrays = vi10.fn(
+      (mode, first, count) => this.calls.push(`drawArrays:${mode}:${first}:${count}`)
+    );
+    this.drawElements = vi10.fn(
+      (mode, count, type, offset) => this.calls.push(`drawElements:${mode}:${count}:${type}:${offset}`)
+    );
+    // Queries
+    this.createQuery = vi10.fn(() => ({}));
+    this.beginQuery = vi10.fn();
+    this.endQuery = vi10.fn();
+    this.deleteQuery = vi10.fn();
+    this.getQueryParameter = vi10.fn();
+    this.getParameter = vi10.fn();
+    this.uniform1f = vi10.fn(
+      (location, x) => this.calls.push(`uniform1f:${location ? "set" : "null"}:${x}`)
+    );
+    this.uniform1i = vi10.fn(
+      (location, x) => this.calls.push(`uniform1i:${location ? "set" : "null"}:${x}`)
+    );
+    this.uniform4f = vi10.fn(
+      (location, x, y, z, w) => this.calls.push(`uniform4f:${location ? "set" : "null"}:${x}:${y}:${z}:${w}`)
+    );
+    this.uniform3fv = vi10.fn(
+      (location, data) => this.calls.push(`uniform3fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
+    );
+    this.uniform3f = vi10.fn(
+      (location, x, y, z) => this.calls.push(`uniform3f:${location ? "set" : "null"}:${x}:${y}:${z}`)
+    );
+    this.uniform2f = vi10.fn(
+      (location, x, y) => this.calls.push(`uniform2f:${location ? "set" : "null"}:${x}:${y}`)
+    );
+    this.uniform4fv = vi10.fn(
+      (location, data) => this.calls.push(`uniform4fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
+    );
+    this.uniformMatrix4fv = vi10.fn(
+      (location, transpose, data) => this.calls.push(`uniformMatrix4fv:${location ? "set" : "null"}:${transpose}:${Array.from(data).join(",")}`)
+    );
+    this.uniformBlockBinding = vi10.fn();
+    this.isContextLost = vi10.fn(() => false);
+    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;
+    }
+  }
+};
+function createMockWebGL2Context(overridesOrCanvas) {
+  let context;
+  if (overridesOrCanvas instanceof Object && "width" in overridesOrCanvas && "height" in overridesOrCanvas && "getContext" in overridesOrCanvas) {
+    context = new MockWebGL2RenderingContext(overridesOrCanvas);
+  } else {
+    context = new MockWebGL2RenderingContext();
+    if (overridesOrCanvas) {
+      Object.assign(context, overridesOrCanvas);
+    }
+  }
+  return context;
 }
 
 // src/setup/browser.ts
@@ -1900,10 +1993,10 @@ function createMockImage(width, height, src) {
 }
 
 // src/engine/mocks/webgpu.ts
-import { vi as vi10 } from "vitest";
+import { vi as vi11 } from "vitest";
 function createMockGPUAdapter() {
   return {
-    requestDevice: vi10.fn().mockResolvedValue(createMockGPUDevice()),
+    requestDevice: vi11.fn().mockResolvedValue(createMockGPUDevice()),
     features: /* @__PURE__ */ new Set(),
     limits: {}
   };
@@ -1913,40 +2006,40 @@ function createMockGPUDevice() {
     features: /* @__PURE__ */ new Set(),
     limits: {},
     queue: {
-      submit: vi10.fn(),
-      writeBuffer: vi10.fn(),
-      writeTexture: vi10.fn(),
-      copyExternalImageToTexture: vi10.fn()
-    },
-    createCommandEncoder: vi10.fn().mockReturnValue({
-      beginRenderPass: vi10.fn().mockReturnValue({
-        setPipeline: vi10.fn(),
-        draw: vi10.fn(),
-        end: vi10.fn()
+      submit: vi11.fn(),
+      writeBuffer: vi11.fn(),
+      writeTexture: vi11.fn(),
+      copyExternalImageToTexture: vi11.fn()
+    },
+    createCommandEncoder: vi11.fn().mockReturnValue({
+      beginRenderPass: vi11.fn().mockReturnValue({
+        setPipeline: vi11.fn(),
+        draw: vi11.fn(),
+        end: vi11.fn()
       }),
-      finish: vi10.fn()
+      finish: vi11.fn()
     }),
-    createRenderPipeline: vi10.fn(),
-    createShaderModule: vi10.fn(),
-    createBindGroup: vi10.fn(),
-    createBindGroupLayout: vi10.fn(),
-    createBuffer: vi10.fn(),
-    createTexture: vi10.fn(),
-    createSampler: vi10.fn()
+    createRenderPipeline: vi11.fn(),
+    createShaderModule: vi11.fn(),
+    createBindGroup: vi11.fn(),
+    createBindGroupLayout: vi11.fn(),
+    createBuffer: vi11.fn(),
+    createTexture: vi11.fn(),
+    createSampler: vi11.fn()
   };
 }
 function createMockGPUCanvasContext() {
   return {
-    configure: vi10.fn(),
-    unconfigure: vi10.fn(),
-    getCurrentTexture: vi10.fn()
+    configure: vi11.fn(),
+    unconfigure: vi11.fn(),
+    getCurrentTexture: vi11.fn()
   };
 }
 function setupWebGPUMocks() {
   const mockAdapter = createMockGPUAdapter();
   const mockGpu = {
-    requestAdapter: vi10.fn().mockResolvedValue(mockAdapter),
-    getPreferredCanvasFormat: vi10.fn().mockReturnValue("bgra8unorm")
+    requestAdapter: vi11.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: vi11.fn().mockReturnValue("bgra8unorm")
   };
   Object.defineProperty(global.navigator, "gpu", {
     value: mockGpu,
@@ -3041,6 +3134,7 @@ export {
   InputInjector,
   MockPointerLock,
   MockTransport,
+  MockWebGL2RenderingContext,
   captureAudioEvents,
   captureCanvasDrawCalls,
   captureGameScreenshot,