quake2ts 0.0.408 → 0.0.412

package/packages/engine/dist/esm/index.js

@@ -175,6 +175,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],
@@ -1832,6 +1833,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);
@@ -5482,6 +5505,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) {
@@ -6333,15 +6393,21 @@ var Camera = class {
     return this._position;
   }
   set position(value) {
-    vec3.copy(this._position, value);
-    this._dirty = true;
+    if (!vec3.equals(this._position, value)) {
+      vec3.copy(this._position, value);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
   }
   get angles() {
     return this._angles;
   }
   set angles(value) {
-    vec3.copy(this._angles, value);
-    this._dirty = true;
+    if (!vec3.equals(this._angles, value)) {
+      vec3.copy(this._angles, value);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
   }
   get bobAngles() {
     return this._bobAngles;
@@ -6385,6 +6451,47 @@ var Camera = class {
     this._aspect = value;
     this._dirty = true;
   }
+  // API Methods
+  setPosition(x, y, z) {
+    const newPos = vec3.fromValues(x, y, z);
+    if (!vec3.equals(this._position, newPos)) {
+      vec3.copy(this._position, newPos);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
+  }
+  setRotation(pitch, yaw, roll) {
+    const newAngles = vec3.fromValues(pitch, yaw, roll);
+    if (!vec3.equals(this._angles, newAngles)) {
+      vec3.copy(this._angles, newAngles);
+      this._dirty = true;
+      this.triggerMoveEvent();
+    }
+  }
+  setFov(fov) {
+    this.fov = fov;
+  }
+  setAspectRatio(aspect) {
+    this.aspect = aspect;
+  }
+  lookAt(target) {
+    const direction = vec3.create();
+    vec3.subtract(direction, target, this._position);
+    const len = 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: vec3.clone(this._position),
+        angles: vec3.clone(this._angles)
+      });
+    }
+  }
   get viewMatrix() {
     this.updateMatrices();
     return this._viewMatrix;
@@ -6408,6 +6515,25 @@ var Camera = class {
     );
     return projectionMatrix;
   }
+  screenToWorldRay(screenX, screenY) {
+    const ndcX = screenX * 2 - 1;
+    const ndcY = 1 - screenY * 2;
+    const clipStart = vec3.fromValues(ndcX, ndcY, -1);
+    const clipEnd = vec3.fromValues(ndcX, ndcY, 1);
+    const invViewProj = mat4.create();
+    mat4.invert(invViewProj, this.viewProjectionMatrix);
+    const worldStart = vec3.create();
+    const worldEnd = vec3.create();
+    vec3.transformMat4(worldStart, clipStart, invViewProj);
+    vec3.transformMat4(worldEnd, clipEnd, invViewProj);
+    const direction = vec3.create();
+    vec3.subtract(direction, worldEnd, worldStart);
+    vec3.normalize(direction, direction);
+    return {
+      origin: vec3.clone(this._position),
+      direction
+    };
+  }
   updateMatrices() {
     if (!this._dirty) {
       return;
@@ -6421,20 +6547,20 @@ var Camera = class {
     );
     const quakeToGl = 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,
@@ -6459,12 +6585,12 @@ var Camera = class {
     const rotatedPosQuake = vec3.create();
     vec3.transformMat4(rotatedPosQuake, negativePosition, rotationQuake);
     const translationGl = 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
     );
     mat4.copy(this._viewMatrix, rotationGl);
     this._viewMatrix[12] = translationGl[0];
@@ -13527,6 +13653,7 @@ export {
   DemoReader,
   DemoRecorder,
   DemoValidator,
+  DynamicLightManager,
   EngineHost,
   EngineRuntime,
   FileType,