quake2ts 0.0.579 → 0.0.581

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quake2ts",
-  "version": "0.0.579",
+  "version": "0.0.581",
   "description": "Quake II re-release port to TypeScript with WebGL renderer - A complete game engine with physics, networking, and BSP rendering",
   "type": "module",
   "keywords": [

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

@@ -34,6 +34,7 @@ __export(index_exports, {
   InputInjector: () => InputInjector,
   MockPointerLock: () => MockPointerLock,
   MockTransport: () => MockTransport,
+  MockWebGL2RenderingContext: () => MockWebGL2RenderingContext,
   captureAudioEvents: () => captureAudioEvents,
   captureCanvasDrawCalls: () => captureCanvasDrawCalls,
   captureGameScreenshot: () => captureGameScreenshot,
@@ -1656,128 +1657,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
+var import_vitest10 = require("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 = import_vitest10.vi.fn((cap) => this.calls.push(`enable:${cap}`));
+    this.disable = import_vitest10.vi.fn((cap) => this.calls.push(`disable:${cap}`));
+    this.depthFunc = import_vitest10.vi.fn((func) => this.calls.push(`depthFunc:${func}`));
+    this.cullFace = import_vitest10.vi.fn((mode) => this.calls.push(`cullFace:${mode}`));
+    this.depthMask = import_vitest10.vi.fn((flag) => this.calls.push(`depthMask:${flag}`));
+    this.blendFuncSeparate = import_vitest10.vi.fn(
+      (srcRGB, dstRGB, srcAlpha, dstAlpha) => this.calls.push(`blendFuncSeparate:${srcRGB}:${dstRGB}:${srcAlpha}:${dstAlpha}`)
+    );
+    this.blendFunc = import_vitest10.vi.fn((sfactor, dfactor) => this.calls.push(`blendFunc:${sfactor}:${dfactor}`));
+    this.getExtension = import_vitest10.vi.fn((name) => this.extensions.get(name) ?? null);
+    this.viewport = import_vitest10.vi.fn((x, y, w, h) => this.calls.push(`viewport:${x}:${y}:${w}:${h}`));
+    this.clear = import_vitest10.vi.fn((mask) => this.calls.push(`clear:${mask}`));
+    this.clearColor = import_vitest10.vi.fn((r, g, b, a) => this.calls.push(`clearColor:${r}:${g}:${b}:${a}`));
+    this.createShader = import_vitest10.vi.fn((type) => ({ id: ++this.shaderCounter, type }));
+    this.shaderSource = import_vitest10.vi.fn((shader, source) => this.calls.push(`shaderSource:${shader.id}:${source}`));
+    this.compileShader = import_vitest10.vi.fn((shader) => this.calls.push(`compileShader:${shader.id}`));
+    this.getShaderParameter = import_vitest10.vi.fn(
+      (shader, pname) => pname === this.COMPILE_STATUS ? this.compileSucceeds : null
+    );
+    this.getShaderInfoLog = import_vitest10.vi.fn(() => this.compileSucceeds ? "" : this.shaderInfoLog);
+    this.deleteShader = import_vitest10.vi.fn((shader) => this.calls.push(`deleteShader:${shader.id}`));
+    this.createProgram = import_vitest10.vi.fn(() => ({ id: ++this.programCounter }));
+    this.attachShader = import_vitest10.vi.fn(
+      (program, shader) => this.calls.push(`attach:${program.id}:${shader.id}`)
+    );
+    this.bindAttribLocation = import_vitest10.vi.fn(
+      (program, index, name) => this.calls.push(`bindAttribLocation:${program.id}:${index}:${name}`)
+    );
+    this.linkProgram = import_vitest10.vi.fn((program) => this.calls.push(`link:${program.id}`));
+    this.getProgramParameter = import_vitest10.vi.fn(
+      (program, pname) => pname === this.LINK_STATUS ? this.linkSucceeds : null
+    );
+    this.getProgramInfoLog = import_vitest10.vi.fn(() => this.linkSucceeds ? "" : this.programInfoLog);
+    this.deleteProgram = import_vitest10.vi.fn((program) => this.calls.push(`deleteProgram:${program.id}`));
+    this.useProgram = import_vitest10.vi.fn((program) => this.calls.push(`useProgram:${program?.id ?? "null"}`));
+    this.getUniformLocation = import_vitest10.vi.fn((program, name) => {
+      this.calls.push(`getUniformLocation:${program.id}:${name}`);
+      return this.uniformLocations.get(name) ?? null;
+    });
+    this.getAttribLocation = import_vitest10.vi.fn((program, name) => {
+      this.calls.push(`getAttribLocation:${program.id}:${name}`);
+      return this.attributeLocations.get(name) ?? -1;
+    });
+    this.createBuffer = import_vitest10.vi.fn(() => ({ buffer: {} }));
+    this.bindBuffer = import_vitest10.vi.fn((target, buffer) => this.calls.push(`bindBuffer:${target}:${!!buffer}`));
+    this.bufferData = import_vitest10.vi.fn(
+      (target, data, usage) => this.calls.push(`bufferData:${target}:${usage}:${typeof data === "number" ? data : "data"}`)
+    );
+    this.bufferSubData = import_vitest10.vi.fn(
+      (target, offset, data) => this.calls.push(`bufferSubData:${target}:${offset}:${data.byteLength ?? "len"}`)
+    );
+    this.deleteBuffer = import_vitest10.vi.fn((buffer) => this.calls.push(`deleteBuffer:${!!buffer}`));
+    this.createVertexArray = import_vitest10.vi.fn(() => ({ vao: {} }));
+    this.bindVertexArray = import_vitest10.vi.fn((vao) => this.calls.push(`bindVertexArray:${!!vao}`));
+    this.enableVertexAttribArray = import_vitest10.vi.fn((index) => this.calls.push(`enableAttrib:${index}`));
+    this.vertexAttribPointer = import_vitest10.vi.fn(
+      (index, size, type, normalized, stride, offset) => this.calls.push(`vertexAttribPointer:${index}:${size}:${type}:${normalized}:${stride}:${offset}`)
+    );
+    this.vertexAttribDivisor = import_vitest10.vi.fn((index, divisor) => this.calls.push(`divisor:${index}:${divisor}`));
+    this.deleteVertexArray = import_vitest10.vi.fn((vao) => this.calls.push(`deleteVertexArray:${!!vao}`));
+    this.createTexture = import_vitest10.vi.fn(() => ({ texture: {} }));
+    this.activeTexture = import_vitest10.vi.fn((unit) => this.calls.push(`activeTexture:${unit}`));
+    this.bindTexture = import_vitest10.vi.fn((target, texture) => this.calls.push(`bindTexture:${target}:${!!texture}`));
+    this.texParameteri = import_vitest10.vi.fn(
+      (target, pname, param) => this.calls.push(`texParameteri:${target}:${pname}:${param}`)
+    );
+    this.texImage2D = import_vitest10.vi.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 = import_vitest10.vi.fn();
+    // Stub for compatibility
+    this.deleteTexture = import_vitest10.vi.fn((texture) => this.calls.push(`deleteTexture:${!!texture}`));
+    this.createFramebuffer = import_vitest10.vi.fn(() => ({ fb: {} }));
+    this.bindFramebuffer = import_vitest10.vi.fn(
+      (target, framebuffer) => this.calls.push(`bindFramebuffer:${target}:${!!framebuffer}`)
+    );
+    this.framebufferTexture2D = import_vitest10.vi.fn(
+      (target, attachment, textarget, texture, level) => this.calls.push(`framebufferTexture2D:${target}:${attachment}:${textarget}:${!!texture}:${level}`)
+    );
+    this.deleteFramebuffer = import_vitest10.vi.fn((fb) => this.calls.push(`deleteFramebuffer:${!!fb}`));
+    this.checkFramebufferStatus = import_vitest10.vi.fn((target) => this.FRAMEBUFFER_COMPLETE);
+    this.createRenderbuffer = import_vitest10.vi.fn(() => ({ rb: {} }));
+    this.bindRenderbuffer = import_vitest10.vi.fn(
+      (target, renderbuffer) => this.calls.push(`bindRenderbuffer:${target}:${!!renderbuffer}`)
+    );
+    this.renderbufferStorage = import_vitest10.vi.fn(
+      (target, internalformat, width, height) => this.calls.push(`renderbufferStorage:${target}:${internalformat}:${width}:${height}`)
+    );
+    this.framebufferRenderbuffer = import_vitest10.vi.fn(
+      (target, attachment, renderbuffertarget, renderbuffer) => this.calls.push(`framebufferRenderbuffer:${target}:${attachment}:${renderbuffertarget}:${!!renderbuffer}`)
+    );
+    this.deleteRenderbuffer = import_vitest10.vi.fn((rb) => this.calls.push(`deleteRenderbuffer:${!!rb}`));
+    this.drawArrays = import_vitest10.vi.fn(
+      (mode, first, count) => this.calls.push(`drawArrays:${mode}:${first}:${count}`)
+    );
+    this.drawElements = import_vitest10.vi.fn(
+      (mode, count, type, offset) => this.calls.push(`drawElements:${mode}:${count}:${type}:${offset}`)
+    );
+    // Queries
+    this.createQuery = import_vitest10.vi.fn(() => ({}));
+    this.beginQuery = import_vitest10.vi.fn();
+    this.endQuery = import_vitest10.vi.fn();
+    this.deleteQuery = import_vitest10.vi.fn();
+    this.getQueryParameter = import_vitest10.vi.fn();
+    this.getParameter = import_vitest10.vi.fn();
+    this.uniform1f = import_vitest10.vi.fn(
+      (location, x) => this.calls.push(`uniform1f:${location ? "set" : "null"}:${x}`)
+    );
+    this.uniform1i = import_vitest10.vi.fn(
+      (location, x) => this.calls.push(`uniform1i:${location ? "set" : "null"}:${x}`)
+    );
+    this.uniform4f = import_vitest10.vi.fn(
+      (location, x, y, z, w) => this.calls.push(`uniform4f:${location ? "set" : "null"}:${x}:${y}:${z}:${w}`)
+    );
+    this.uniform3fv = import_vitest10.vi.fn(
+      (location, data) => this.calls.push(`uniform3fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
+    );
+    this.uniform3f = import_vitest10.vi.fn(
+      (location, x, y, z) => this.calls.push(`uniform3f:${location ? "set" : "null"}:${x}:${y}:${z}`)
+    );
+    this.uniform2f = import_vitest10.vi.fn(
+      (location, x, y) => this.calls.push(`uniform2f:${location ? "set" : "null"}:${x}:${y}`)
+    );
+    this.uniform4fv = import_vitest10.vi.fn(
+      (location, data) => this.calls.push(`uniform4fv:${location ? "set" : "null"}:${Array.from(data).join(",")}`)
+    );
+    this.uniformMatrix4fv = import_vitest10.vi.fn(
+      (location, transpose, data) => this.calls.push(`uniformMatrix4fv:${location ? "set" : "null"}:${transpose}:${Array.from(data).join(",")}`)
+    );
+    this.uniformBlockBinding = import_vitest10.vi.fn();
+    this.isContextLost = import_vitest10.vi.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
@@ -2035,10 +2129,10 @@ function createMockImage(width, height, src) {
 }
 
 // src/engine/mocks/webgpu.ts
-var import_vitest10 = require("vitest");
+var import_vitest11 = require("vitest");
 function createMockGPUAdapter() {
   return {
-    requestDevice: import_vitest10.vi.fn().mockResolvedValue(createMockGPUDevice()),
+    requestDevice: import_vitest11.vi.fn().mockResolvedValue(createMockGPUDevice()),
     features: /* @__PURE__ */ new Set(),
     limits: {}
   };
@@ -2048,40 +2142,40 @@ function createMockGPUDevice() {
     features: /* @__PURE__ */ new Set(),
     limits: {},
     queue: {
-      submit: import_vitest10.vi.fn(),
-      writeBuffer: import_vitest10.vi.fn(),
-      writeTexture: import_vitest10.vi.fn(),
-      copyExternalImageToTexture: import_vitest10.vi.fn()
-    },
-    createCommandEncoder: import_vitest10.vi.fn().mockReturnValue({
-      beginRenderPass: import_vitest10.vi.fn().mockReturnValue({
-        setPipeline: import_vitest10.vi.fn(),
-        draw: import_vitest10.vi.fn(),
-        end: import_vitest10.vi.fn()
+      submit: import_vitest11.vi.fn(),
+      writeBuffer: import_vitest11.vi.fn(),
+      writeTexture: import_vitest11.vi.fn(),
+      copyExternalImageToTexture: import_vitest11.vi.fn()
+    },
+    createCommandEncoder: import_vitest11.vi.fn().mockReturnValue({
+      beginRenderPass: import_vitest11.vi.fn().mockReturnValue({
+        setPipeline: import_vitest11.vi.fn(),
+        draw: import_vitest11.vi.fn(),
+        end: import_vitest11.vi.fn()
       }),
-      finish: import_vitest10.vi.fn()
+      finish: import_vitest11.vi.fn()
     }),
-    createRenderPipeline: import_vitest10.vi.fn(),
-    createShaderModule: import_vitest10.vi.fn(),
-    createBindGroup: import_vitest10.vi.fn(),
-    createBindGroupLayout: import_vitest10.vi.fn(),
-    createBuffer: import_vitest10.vi.fn(),
-    createTexture: import_vitest10.vi.fn(),
-    createSampler: import_vitest10.vi.fn()
+    createRenderPipeline: import_vitest11.vi.fn(),
+    createShaderModule: import_vitest11.vi.fn(),
+    createBindGroup: import_vitest11.vi.fn(),
+    createBindGroupLayout: import_vitest11.vi.fn(),
+    createBuffer: import_vitest11.vi.fn(),
+    createTexture: import_vitest11.vi.fn(),
+    createSampler: import_vitest11.vi.fn()
   };
 }
 function createMockGPUCanvasContext() {
   return {
-    configure: import_vitest10.vi.fn(),
-    unconfigure: import_vitest10.vi.fn(),
-    getCurrentTexture: import_vitest10.vi.fn()
+    configure: import_vitest11.vi.fn(),
+    unconfigure: import_vitest11.vi.fn(),
+    getCurrentTexture: import_vitest11.vi.fn()
   };
 }
 function setupWebGPUMocks() {
   const mockAdapter = createMockGPUAdapter();
   const mockGpu = {
-    requestAdapter: import_vitest10.vi.fn().mockResolvedValue(mockAdapter),
-    getPreferredCanvasFormat: import_vitest10.vi.fn().mockReturnValue("bgra8unorm")
+    requestAdapter: import_vitest11.vi.fn().mockResolvedValue(mockAdapter),
+    getPreferredCanvasFormat: import_vitest11.vi.fn().mockReturnValue("bgra8unorm")
   };
   Object.defineProperty(global.navigator, "gpu", {
     value: mockGpu,
@@ -3177,6 +3271,7 @@ function createVisualTestScenario(page, sceneName) {
   InputInjector,
   MockPointerLock,
   MockTransport,
+  MockWebGL2RenderingContext,
   captureAudioEvents,
   captureCanvasDrawCalls,
   captureGameScreenshot,