@quake2ts/engine 0.0.804 → 0.0.807

package/dist/cjs/index.cjs

@@ -17538,6 +17538,524 @@ async function captureRenderTarget(device, texture) {
   outputBuffer.unmap();
   return result;
 }
+
+// src/render/null/renderer.ts
+var NullRenderer = class {
+  constructor(width = 800, height = 600) {
+    this.width = 0;
+    this.height = 0;
+    this.collisionVis = null;
+    this.debug = null;
+    this.particleSystem = null;
+    this.frameCount = 0;
+    this.callLog = [];
+    this.width = width;
+    this.height = height;
+  }
+  renderFrame(options, entities = []) {
+    this.frameCount++;
+    this.callLog.push(`renderFrame(frame=${this.frameCount}, entities=${entities.length})`);
+    const cameraState = options.cameraState ?? options.camera.toState();
+    this.callLog.push(`  camera: pos=${cameraState.position}, angles=${cameraState.angles}`);
+  }
+  // Stub implementations (all no-op)
+  async registerPic(name, data) {
+    this.callLog.push(`registerPic(${name})`);
+    return { width: 256, height: 256 };
+  }
+  registerTexture(name, texture) {
+    this.callLog.push(`registerTexture(${name})`);
+    return { width: texture.width, height: texture.height };
+  }
+  begin2D() {
+    this.callLog.push("begin2D()");
+  }
+  end2D() {
+    this.callLog.push("end2D()");
+  }
+  drawPic(x, y, pic, color) {
+    this.callLog.push(`drawPic(${x}, ${y})`);
+  }
+  drawString(x, y, text, color) {
+    this.callLog.push(`drawString(${x}, ${y}, "${text}")`);
+  }
+  drawCenterString(y, text) {
+    this.callLog.push(`drawCenterString(${y}, "${text}")`);
+  }
+  drawfillRect(x, y, width, height, color) {
+    this.callLog.push(`drawfillRect(${x}, ${y}, ${width}, ${height})`);
+  }
+  setEntityHighlight(entityId, color) {
+  }
+  clearEntityHighlight(entityId) {
+  }
+  highlightSurface(faceIndex, color) {
+  }
+  removeSurfaceHighlight(faceIndex) {
+  }
+  setDebugMode(mode) {
+  }
+  setBrightness(value) {
+  }
+  setGamma(value) {
+  }
+  setFullbright(enabled) {
+  }
+  setAmbient(value) {
+  }
+  setLightStyle(index, pattern) {
+  }
+  setUnderwaterWarp(enabled) {
+  }
+  setBloom(enabled) {
+  }
+  setBloomIntensity(value) {
+  }
+  setLodBias(bias) {
+  }
+  renderInstanced(model, instances) {
+  }
+  getPerformanceReport() {
+    return {
+      frameTimeMs: 0,
+      gpuTimeMs: 0,
+      cpuFrameTimeMs: 0,
+      drawCalls: 0,
+      triangles: 0,
+      vertices: 0,
+      textureBinds: 0,
+      shaderSwitches: 0,
+      visibleSurfaces: 0,
+      culledSurfaces: 0,
+      visibleEntities: 0,
+      culledEntities: 0,
+      memoryUsageMB: { textures: 0, geometry: 0, total: 0 }
+    };
+  }
+  getMemoryUsage() {
+    return {
+      texturesBytes: 0,
+      geometryBytes: 0,
+      shadersBytes: 0,
+      buffersBytes: 0,
+      totalBytes: 0
+    };
+  }
+  dispose() {
+    this.callLog.push("dispose()");
+  }
+  // Test utilities
+  getCallLog() {
+    return this.callLog;
+  }
+  resetCallLog() {
+    this.callLog = [];
+  }
+  getFrameCount() {
+    return this.frameCount;
+  }
+};
+
+// src/render/types/coordinates.ts
+var CoordinateSystem = /* @__PURE__ */ ((CoordinateSystem2) => {
+  CoordinateSystem2["QUAKE"] = "quake";
+  CoordinateSystem2["OPENGL"] = "opengl";
+  CoordinateSystem2["WEBGPU"] = "webgpu";
+  return CoordinateSystem2;
+})(CoordinateSystem || {});
+
+// src/render/matrix/webgl.ts
+var WebGLMatrixBuilder = class {
+  constructor() {
+    this.coordinateSystem = "opengl" /* OPENGL */;
+  }
+  buildProjectionMatrix(camera) {
+    const projection = glMatrix.mat4.create();
+    glMatrix.mat4.perspective(
+      projection,
+      camera.fov * shared.DEG2RAD,
+      camera.aspect,
+      camera.near,
+      camera.far
+    );
+    return projection;
+  }
+  buildViewMatrix(camera) {
+    const quakeToGl = glMatrix.mat4.fromValues(
+      0,
+      0,
+      -1,
+      0,
+      // Quake +X (forward) → GL -Z
+      -1,
+      0,
+      0,
+      0,
+      // Quake +Y (left) → GL -X
+      0,
+      1,
+      0,
+      0,
+      // Quake +Z (up) → GL +Y
+      0,
+      0,
+      0,
+      1
+    );
+    const [pitch, yaw, roll] = camera.angles;
+    const pitchRad = pitch * shared.DEG2RAD;
+    const yawRad = yaw * shared.DEG2RAD;
+    const rollRad = roll * shared.DEG2RAD;
+    const rotationQuake = glMatrix.mat4.create();
+    glMatrix.mat4.identity(rotationQuake);
+    glMatrix.mat4.rotateZ(rotationQuake, rotationQuake, -yawRad);
+    glMatrix.mat4.rotateY(rotationQuake, rotationQuake, -pitchRad);
+    glMatrix.mat4.rotateX(rotationQuake, rotationQuake, -rollRad);
+    const rotationGl = glMatrix.mat4.create();
+    glMatrix.mat4.multiply(rotationGl, quakeToGl, rotationQuake);
+    const negativePosition = glMatrix.vec3.negate(glMatrix.vec3.create(), camera.position);
+    const rotatedPosQuake = glMatrix.vec3.create();
+    glMatrix.vec3.transformMat4(rotatedPosQuake, negativePosition, rotationQuake);
+    const translationGl = glMatrix.vec3.fromValues(
+      rotatedPosQuake[1] ? -rotatedPosQuake[1] : 0,
+      // Y → -X
+      rotatedPosQuake[2] || 0,
+      // Z → Y
+      rotatedPosQuake[0] ? -rotatedPosQuake[0] : 0
+      // X → -Z
+    );
+    const view = glMatrix.mat4.clone(rotationGl);
+    view[12] = translationGl[0];
+    view[13] = translationGl[1];
+    view[14] = translationGl[2];
+    return view;
+  }
+};
+var WebGPUMatrixBuilder = class {
+  constructor() {
+    this.coordinateSystem = "webgpu" /* WEBGPU */;
+  }
+  buildProjectionMatrix(camera) {
+    const projection = glMatrix.mat4.create();
+    const f = 1 / Math.tan(camera.fov * shared.DEG2RAD / 2);
+    const rangeInv = 1 / (camera.near - camera.far);
+    projection[0] = f / camera.aspect;
+    projection[5] = f;
+    projection[10] = camera.far * rangeInv;
+    projection[11] = -1;
+    projection[14] = camera.near * camera.far * rangeInv;
+    return projection;
+  }
+  buildViewMatrix(camera) {
+    const [pitch, yaw, roll] = camera.angles;
+    const pitchRad = pitch * shared.DEG2RAD;
+    const yawRad = yaw * shared.DEG2RAD;
+    const rollRad = roll * shared.DEG2RAD;
+    const rotationQuake = glMatrix.mat4.create();
+    glMatrix.mat4.identity(rotationQuake);
+    glMatrix.mat4.rotateZ(rotationQuake, rotationQuake, -yawRad);
+    glMatrix.mat4.rotateY(rotationQuake, rotationQuake, -pitchRad);
+    glMatrix.mat4.rotateX(rotationQuake, rotationQuake, -rollRad);
+    glMatrix.mat4.fromValues(
+      0,
+      0,
+      -1,
+      0,
+      // Column 0: Quake X maps to View Z? Wait.
+      -1,
+      0,
+      0,
+      0,
+      // Column 1: Quake Y maps to View X?
+      0,
+      1,
+      0,
+      0,
+      // Column 2: Quake Z maps to View Y?
+      0,
+      0,
+      0,
+      1
+    );
+    const quakeToWgpu = glMatrix.mat4.fromValues(
+      0,
+      0,
+      -1,
+      0,
+      // Col 0: X -> -Z
+      -1,
+      0,
+      0,
+      0,
+      // Col 1: Y -> -X
+      0,
+      1,
+      0,
+      0,
+      // Col 2: Z -> Y
+      0,
+      0,
+      0,
+      1
+    );
+    const rotationView = glMatrix.mat4.create();
+    glMatrix.mat4.multiply(rotationView, quakeToWgpu, rotationQuake);
+    const cameraPos = glMatrix.vec3.fromValues(
+      camera.position[0],
+      camera.position[1],
+      camera.position[2]
+    );
+    const t = glMatrix.vec3.transformMat4(glMatrix.vec3.create(), cameraPos, rotationView);
+    glMatrix.vec3.negate(t, t);
+    const view = glMatrix.mat4.clone(rotationView);
+    view[12] = t[0];
+    view[13] = t[1];
+    view[14] = t[2];
+    return view;
+  }
+};
+var IdentityMatrixBuilder = class {
+  constructor() {
+    this.coordinateSystem = "quake" /* QUAKE */;
+  }
+  buildProjectionMatrix(camera) {
+    const projection = glMatrix.mat4.create();
+    glMatrix.mat4.perspective(
+      projection,
+      camera.fov * shared.DEG2RAD,
+      camera.aspect,
+      camera.near,
+      camera.far
+    );
+    return projection;
+  }
+  buildViewMatrix(camera) {
+    const [pitch, yaw, roll] = camera.angles;
+    const pitchRad = pitch * shared.DEG2RAD;
+    const yawRad = yaw * shared.DEG2RAD;
+    const rollRad = roll * shared.DEG2RAD;
+    const rotation = glMatrix.mat4.create();
+    glMatrix.mat4.identity(rotation);
+    glMatrix.mat4.rotateZ(rotation, rotation, yawRad);
+    glMatrix.mat4.rotateX(rotation, rotation, pitchRad);
+    glMatrix.mat4.rotateY(rotation, rotation, rollRad);
+    const translation = glMatrix.mat4.create();
+    glMatrix.mat4.fromTranslation(translation, [
+      -camera.position[0],
+      -camera.position[1],
+      -camera.position[2]
+    ]);
+    const view = glMatrix.mat4.create();
+    glMatrix.mat4.multiply(view, rotation, translation);
+    return view;
+  }
+};
+function buildMatrices(builder, camera) {
+  const view = builder.buildViewMatrix(camera);
+  const projection = builder.buildProjectionMatrix(camera);
+  const viewProjection = glMatrix.mat4.create();
+  glMatrix.mat4.multiply(viewProjection, projection, view);
+  return { view, projection, viewProjection };
+}
+function quakeToWebGL(v) {
+  return glMatrix.vec3.fromValues(-v[1], v[2], -v[0]);
+}
+function quakeToWebGPU(v) {
+  return glMatrix.vec3.fromValues(-v[1], v[2], -v[0]);
+}
+
+// src/render/logging/renderer.ts
+var LoggingRenderer = class {
+  constructor(options = {}) {
+    this.width = 0;
+    this.height = 0;
+    this.collisionVis = null;
+    this.debug = null;
+    this.particleSystem = null;
+    this.logs = [];
+    this.options = {
+      targetSystem: options.targetSystem ?? "quake" /* QUAKE */,
+      verbose: options.verbose ?? true,
+      validateTransforms: options.validateTransforms ?? true
+    };
+    switch (this.options.targetSystem) {
+      case "opengl" /* OPENGL */:
+        this.builder = new WebGLMatrixBuilder();
+        break;
+      case "webgpu" /* WEBGPU */:
+        this.builder = new WebGPUMatrixBuilder();
+        break;
+      default:
+        this.builder = new IdentityMatrixBuilder();
+    }
+    this.log(`LoggingRenderer initialized (target=${this.options.targetSystem})`);
+  }
+  renderFrame(options, entities = []) {
+    this.log(`
+=== FRAME START ===`);
+    const cameraState = options.cameraState ?? options.camera.toState();
+    this.log(`Camera State:`);
+    this.log(`  Position: ${this.formatVec3(cameraState.position)} (Quake space)`);
+    this.log(`  Angles:   ${this.formatVec3(cameraState.angles)} (degrees)`);
+    this.log(`  FOV: ${cameraState.fov}\xB0, Aspect: ${cameraState.aspect.toFixed(2)}`);
+    const matrices = buildMatrices(this.builder, cameraState);
+    this.log(`Matrices (${this.options.targetSystem}):`);
+    if (this.options.verbose) {
+      this.log(`  View Matrix:`);
+      this.logMatrix(matrices.view);
+      this.log(`  Projection Matrix:`);
+      this.logMatrix(matrices.projection);
+    }
+    if (this.options.validateTransforms) {
+      this.validateCoordinateTransforms(cameraState, matrices.view);
+    }
+    this.log(`Entities: ${entities.length}`);
+    if (this.options.verbose && entities.length > 0) {
+      entities.slice(0, 5).forEach((entity, i) => {
+        this.log(`  [${i}] type=${entity.type}, model=${entity.model ?? "none"}`);
+      });
+      if (entities.length > 5) {
+        this.log(`  ... and ${entities.length - 5} more`);
+      }
+    }
+    this.log(`=== FRAME END ===
+`);
+  }
+  validateCoordinateTransforms(cameraState, viewMatrix) {
+    const quakePos = cameraState.position;
+    const expectedGL = quakeToWebGL(quakePos);
+    const expectedGPU = quakeToWebGPU(quakePos);
+    const matrixTranslation = [viewMatrix[12], viewMatrix[13], viewMatrix[14]];
+    this.log(`Transform Validation:`);
+    this.log(`  Quake position: ${this.formatVec3(quakePos)}`);
+    switch (this.options.targetSystem) {
+      case "opengl" /* OPENGL */:
+        this.log(`  Expected GL transform: ${this.formatVec3(expectedGL)}`);
+        break;
+      case "webgpu" /* WEBGPU */:
+        this.log(`  Expected WebGPU transform: ${this.formatVec3(expectedGPU)}`);
+        break;
+    }
+    this.log(`  Matrix translation: [${matrixTranslation.map((v) => v.toFixed(2)).join(", ")}]`);
+    const posSum = Math.abs(quakePos[0]) + Math.abs(quakePos[1]) + Math.abs(quakePos[2]);
+    const matSum = Math.abs(matrixTranslation[0]) + Math.abs(matrixTranslation[1]) + Math.abs(matrixTranslation[2]);
+    if (posSum > 0 && matSum / posSum > 2) {
+      this.log(`  \u26A0\uFE0F WARNING: Matrix translation seems large relative to input - possible double-transform!`);
+    }
+  }
+  formatVec3(v) {
+    return `[${v[0].toFixed(2)}, ${v[1].toFixed(2)}, ${v[2].toFixed(2)}]`;
+  }
+  logMatrix(m) {
+    for (let row = 0; row < 4; row++) {
+      const values = [m[row], m[row + 4], m[row + 8], m[row + 12]];
+      this.log(`    [${values.map((v) => v.toFixed(4).padStart(8)).join(" ")}]`);
+    }
+  }
+  log(message) {
+    this.logs.push(message);
+    if (this.options.verbose) {
+      console.log(`[LogRenderer] ${message}`);
+    }
+  }
+  // Stub implementations (with logging)
+  async registerPic(name, data) {
+    this.log(`registerPic("${name}", ${data.byteLength} bytes)`);
+    return { width: 256, height: 256 };
+  }
+  registerTexture(name, texture) {
+    this.log(`registerTexture("${name}", ${texture.width}x${texture.height})`);
+    return { width: texture.width, height: texture.height };
+  }
+  begin2D() {
+    this.log("begin2D()");
+  }
+  end2D() {
+    this.log("end2D()");
+  }
+  drawPic(x, y, pic, color) {
+    this.log(`drawPic(${x}, ${y})`);
+  }
+  drawString(x, y, text, color) {
+    this.log(`drawString(${x}, ${y}, "${text}")`);
+  }
+  drawCenterString(y, text) {
+    this.log(`drawCenterString(${y}, "${text}")`);
+  }
+  drawfillRect(x, y, width, height, color) {
+    this.log(`drawfillRect(${x}, ${y}, ${width}x${height})`);
+  }
+  // All other IRenderer methods as no-ops
+  setEntityHighlight(entityId, color) {
+  }
+  clearEntityHighlight(entityId) {
+  }
+  highlightSurface(faceIndex, color) {
+  }
+  removeSurfaceHighlight(faceIndex) {
+  }
+  setDebugMode(mode) {
+  }
+  setBrightness(value) {
+  }
+  setGamma(value) {
+  }
+  setFullbright(enabled) {
+  }
+  setAmbient(value) {
+  }
+  setLightStyle(index, pattern) {
+  }
+  setUnderwaterWarp(enabled) {
+  }
+  setBloom(enabled) {
+  }
+  setBloomIntensity(value) {
+  }
+  setLodBias(bias) {
+  }
+  renderInstanced(model, instances) {
+  }
+  getPerformanceReport() {
+    return {
+      frameTimeMs: 0,
+      gpuTimeMs: 0,
+      cpuFrameTimeMs: 0,
+      drawCalls: 0,
+      triangles: 0,
+      vertices: 0,
+      textureBinds: 0,
+      shaderSwitches: 0,
+      visibleSurfaces: 0,
+      culledSurfaces: 0,
+      visibleEntities: 0,
+      culledEntities: 0,
+      memoryUsageMB: { textures: 0, geometry: 0, total: 0 }
+    };
+  }
+  getMemoryUsage() {
+    return {
+      texturesBytes: 0,
+      geometryBytes: 0,
+      shadersBytes: 0,
+      buffersBytes: 0,
+      totalBytes: 0
+    };
+  }
+  dispose() {
+    this.log("dispose()");
+  }
+  // Test utilities
+  getLogs() {
+    return this.logs;
+  }
+  resetLogs() {
+    this.logs = [];
+  }
+  printLogs() {
+    console.log(this.logs.join("\n"));
+  }
+};
 var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   ConnectionState2[ConnectionState2["Disconnected"] = 0] = "Disconnected";
   ConnectionState2[ConnectionState2["Connecting"] = 1] = "Connecting";
@@ -18012,6 +18530,7 @@ exports.Command = Command;
 exports.CommandRegistry = CommandRegistry;
 exports.ConfigStringRegistry = ConfigStringRegistry;
 exports.ConnectionState = ConnectionState;
+exports.CoordinateSystem = CoordinateSystem;
 exports.Cvar = Cvar;
 exports.CvarRegistry = CvarRegistry;
 exports.DemoAnalyzer = DemoAnalyzer;
@@ -18029,6 +18548,7 @@ exports.FileType = FileType;
 exports.FixedTimestepLoop = FixedTimestepLoop;
 exports.Framebuffer = Framebuffer;
 exports.IndexBuffer = IndexBuffer;
+exports.LoggingRenderer = LoggingRenderer;
 exports.LruCache = LruCache;
 exports.MD2_FRAGMENT_SHADER = MD2_FRAGMENT_SHADER;
 exports.MD2_VERTEX_SHADER = MD2_VERTEX_SHADER;
@@ -18047,6 +18567,7 @@ exports.Md3SurfaceMesh = Md3SurfaceMesh;
 exports.MessageWriter = MessageWriter;
 exports.MusicSystem = MusicSystem;
 exports.NetworkMessageParser = NetworkMessageParser;
+exports.NullRenderer = NullRenderer;
 exports.PARTICLE_FRAGMENT_SHADER = PARTICLE_FRAGMENT_SHADER;
 exports.PARTICLE_VERTEX_SHADER = PARTICLE_VERTEX_SHADER;
 exports.PROTOCOL_VERSION_RERELEASE = PROTOCOL_VERSION_RERELEASE;