quake2ts 0.0.408 → 0.0.412

package/packages/engine/dist/cjs/index.cjs

@@ -50,6 +50,7 @@ __export(index_exports, {
   DemoReader: () => DemoReader,
   DemoRecorder: () => DemoRecorder,
   DemoValidator: () => DemoValidator,
+  DynamicLightManager: () => DynamicLightManager,
   EngineHost: () => EngineHost,
   EngineRuntime: () => EngineRuntime,
   FileType: () => FileType,
@@ -377,6 +378,7 @@ function normalizeVec3(a) {
 var DEG2RAD_FACTOR = Math.PI / 180;
 var RAD2DEG_FACTOR = 180 / Math.PI;
 var DEG2RAD = DEG2RAD_FACTOR;
+var RAD2DEG = RAD2DEG_FACTOR;
 var ANORMS = [
   [-0.525731, 0, 0.850651],
   [-0.442863, 0.238856, 0.864188],
@@ -2034,6 +2036,28 @@ var VirtualFileSystem = class {
   async readBinaryFile(path) {
     return this.readFile(path);
   }
+  streamFile(path, chunkSize = 1024 * 1024) {
+    const source = this.files.get(normalizePath(path));
+    if (!source) {
+      throw new Error(`File not found in VFS: ${path}`);
+    }
+    const { archive, entry } = source;
+    const fullData = archive.readFile(path);
+    let offset = 0;
+    const totalSize = fullData.length;
+    return new ReadableStream({
+      pull(controller) {
+        if (offset >= totalSize) {
+          controller.close();
+          return;
+        }
+        const end = Math.min(offset + chunkSize, totalSize);
+        const chunk = fullData.slice(offset, end);
+        offset = end;
+        controller.enqueue(chunk);
+      }
+    });
+  }
   async readTextFile(path) {
     const data = await this.readFile(path);
     return new TextDecoder("utf-8").decode(data);
@@ -5684,6 +5708,43 @@ function gatherVisibleFaces(map, cameraPosition, frustum) {
 
 // src/render/dlight.ts
 var MAX_DLIGHTS = 32;
+var DynamicLightManager = class {
+  constructor() {
+    this.lights = [];
+  }
+  /**
+   * Adds a dynamic light or updates an existing one with the same key.
+   */
+  addLight(dlight, time) {
+    if (dlight.key !== void 0) {
+      const index = this.lights.findIndex((l) => l.key === dlight.key);
+      if (index !== -1) {
+        this.lights[index] = dlight;
+        return;
+      }
+    }
+    this.lights.push(dlight);
+  }
+  /**
+   * Clears all lights (e.g., map change).
+   */
+  clear() {
+    this.lights = [];
+  }
+  /**
+   * Updates the list of active lights, removing expired ones.
+   * @param time Current game time in seconds.
+   */
+  update(time) {
+    this.lights = this.lights.filter((l) => l.die > time);
+  }
+  /**
+   * Returns the current list of active lights.
+   */
+  getActiveLights() {
+    return this.lights;
+  }
+};
 
 // src/render/geometry.ts
 function generateWireframeIndices(indices) {
@@ -6535,15 +6596,21 @@ var Camera = class {
     return this._position;
   }
   set position(value) {
-    import_gl_matrix.vec3.copy(this._position, value);
-    this._dirty = true;
+    if (!import_gl_matrix.vec3.equals(this._position, value)) {
+      import_gl_matrix.vec3.copy(this._position, value);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
   }
   get angles() {
     return this._angles;
   }
   set angles(value) {
-    import_gl_matrix.vec3.copy(this._angles, value);
-    this._dirty = true;
+    if (!import_gl_matrix.vec3.equals(this._angles, value)) {
+      import_gl_matrix.vec3.copy(this._angles, value);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
   }
   get bobAngles() {
     return this._bobAngles;
@@ -6587,6 +6654,47 @@ var Camera = class {
     this._aspect = value;
     this._dirty = true;
   }
+  // API Methods
+  setPosition(x, y, z) {
+    const newPos = import_gl_matrix.vec3.fromValues(x, y, z);
+    if (!import_gl_matrix.vec3.equals(this._position, newPos)) {
+      import_gl_matrix.vec3.copy(this._position, newPos);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
+  }
+  setRotation(pitch, yaw, roll) {
+    const newAngles = import_gl_matrix.vec3.fromValues(pitch, yaw, roll);
+    if (!import_gl_matrix.vec3.equals(this._angles, newAngles)) {
+      import_gl_matrix.vec3.copy(this._angles, newAngles);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
+  }
+  setFov(fov) {
+    this.fov = fov;
+  }
+  setAspectRatio(aspect) {
+    this.aspect = aspect;
+  }
+  lookAt(target) {
+    const direction = import_gl_matrix.vec3.create();
+    import_gl_matrix.vec3.subtract(direction, target, this._position);
+    const len = import_gl_matrix.vec3.length(direction);
+    if (len < 1e-3) return;
+    const yaw = Math.atan2(direction[1], direction[0]) * RAD2DEG;
+    const hyp = Math.hypot(direction[0], direction[1]);
+    const pitch = -Math.atan2(direction[2], hyp) * RAD2DEG;
+    this.setRotation(pitch, yaw, 0);
+  }
+  triggerMoveEvent() {
+    if (this.onCameraMove) {
+      this.onCameraMove({
+        position: import_gl_matrix.vec3.clone(this._position),
+        angles: import_gl_matrix.vec3.clone(this._angles)
+      });
+    }
+  }
   get viewMatrix() {
     this.updateMatrices();
     return this._viewMatrix;
@@ -6610,6 +6718,25 @@ var Camera = class {
     );
     return projectionMatrix;
   }
+  screenToWorldRay(screenX, screenY) {
+    const ndcX = screenX * 2 - 1;
+    const ndcY = 1 - screenY * 2;
+    const clipStart = import_gl_matrix.vec3.fromValues(ndcX, ndcY, -1);
+    const clipEnd = import_gl_matrix.vec3.fromValues(ndcX, ndcY, 1);
+    const invViewProj = import_gl_matrix.mat4.create();
+    import_gl_matrix.mat4.invert(invViewProj, this.viewProjectionMatrix);
+    const worldStart = import_gl_matrix.vec3.create();
+    const worldEnd = import_gl_matrix.vec3.create();
+    import_gl_matrix.vec3.transformMat4(worldStart, clipStart, invViewProj);
+    import_gl_matrix.vec3.transformMat4(worldEnd, clipEnd, invViewProj);
+    const direction = import_gl_matrix.vec3.create();
+    import_gl_matrix.vec3.subtract(direction, worldEnd, worldStart);
+    import_gl_matrix.vec3.normalize(direction, direction);
+    return {
+      origin: import_gl_matrix.vec3.clone(this._position),
+      direction
+    };
+  }
   updateMatrices() {
     if (!this._dirty) {
       return;
@@ -6623,20 +6750,20 @@ var Camera = class {
     );
     const quakeToGl = import_gl_matrix.mat4.fromValues(
       0,
-      -1,
       0,
+      -1,
       0,
-      // column 0: Quake X -> WebGL (0, -1, 0)
+      // column 0: Quake X -> WebGL -Z
+      -1,
       0,
       0,
-      1,
       0,
-      // column 1: Quake Y -> WebGL (0, 0, 1)
-      -1,
+      // column 1: Quake Y -> WebGL -X
       0,
+      1,
       0,
       0,
-      // column 2: Quake Z -> WebGL (-1, 0, 0)
+      // column 2: Quake Z -> WebGL Y
       0,
       0,
       0,
@@ -6661,12 +6788,12 @@ var Camera = class {
     const rotatedPosQuake = import_gl_matrix.vec3.create();
     import_gl_matrix.vec3.transformMat4(rotatedPosQuake, negativePosition, rotationQuake);
     const translationGl = import_gl_matrix.vec3.fromValues(
-      rotatedPosQuake[1] || 0,
-      // Y in Quake -> X in WebGL (negation already applied above)
+      rotatedPosQuake[1] ? -rotatedPosQuake[1] : 0,
+      // Y in Quake -> -X in WebGL
       rotatedPosQuake[2] || 0,
       // Z in Quake -> Y in WebGL
-      rotatedPosQuake[0] || 0
-      // X in Quake -> Z in WebGL (negation already applied above)
+      rotatedPosQuake[0] ? -rotatedPosQuake[0] : 0
+      // X in Quake -> -Z in WebGL
     );
     import_gl_matrix.mat4.copy(this._viewMatrix, rotationGl);
     this._viewMatrix[12] = translationGl[0];
@@ -13730,6 +13857,7 @@ function createEngine(imports) {
   DemoReader,
   DemoRecorder,
   DemoValidator,
+  DynamicLightManager,
   EngineHost,
   EngineRuntime,
   FileType,