quake2ts 0.0.407 → 0.0.410

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],
@@ -5684,6 +5686,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 +6574,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 +6632,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;
@@ -6662,11 +6748,8 @@ var Camera = class {
     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[2] || 0,
-      // Z in Quake -> Y in WebGL
       rotatedPosQuake[0] || 0
-      // X in Quake -> Z in WebGL (negation already applied above)
     );
     import_gl_matrix.mat4.copy(this._viewMatrix, rotationGl);
     this._viewMatrix[12] = translationGl[0];
@@ -13730,6 +13813,7 @@ function createEngine(imports) {
   DemoReader,
   DemoRecorder,
   DemoValidator,
+  DynamicLightManager,
   EngineHost,
   EngineRuntime,
   FileType,