quake2ts 0.0.405 → 0.0.408

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

@@ -1583,6 +1583,9 @@ var AudioApi = class {
   stop_entity_sounds(entnum) {
     this.system.stopEntitySounds(entnum);
   }
+  setPlaybackRate(rate) {
+    this.system.setPlaybackRate(rate);
+  }
   set_listener(listener) {
     this.system.setListener(listener);
   }
@@ -4405,6 +4408,7 @@ function spatializeOrigin(origin, listener, masterVolume, attenuation, isListene
 var AudioSystem = class {
   constructor(options) {
     this.activeSources = /* @__PURE__ */ new Map();
+    this.playbackRate = 1;
     this.contextController = options.context;
     this.registry = options.registry;
     this.playerEntity = options.playerEntity;
@@ -4426,6 +4430,15 @@ var AudioSystem = class {
   setSfxVolume(volume) {
     this.sfxVolume = volume;
   }
+  setPlaybackRate(rate) {
+    this.playbackRate = rate;
+    for (const active of this.activeSources.values()) {
+      if (active.source.playbackRate) {
+        active.source.playbackRate.value = rate;
+      }
+      this.updateSourceGain(active);
+    }
+  }
   async ensureRunning() {
     await this.contextController.resume();
   }
@@ -4448,6 +4461,9 @@ var AudioSystem = class {
     const source = ctx.createBufferSource();
     source.buffer = buffer;
     source.loop = request.looping ?? false;
+    if (source.playbackRate) {
+      source.playbackRate.value = this.playbackRate;
+    }
     const origin = request.origin ?? this.listener.origin;
     const gain = ctx.createGain();
     const panner = this.createPanner(ctx, request.attenuation);
@@ -4459,7 +4475,8 @@ var AudioSystem = class {
     const spatial = spatializeOrigin(origin, this.listener, request.volume, request.attenuation, isListenerSound);
     const attenuationScale = request.volume === 0 ? 0 : Math.max(spatial.left, spatial.right) / Math.max(1, request.volume);
     const gainValue = attenuationScale * (request.volume / 255) * this.masterVolume * this.sfxVolume;
-    gain.gain.value = gainValue * occlusionScale;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    gain.gain.value = gainValue * occlusionScale * playbackRateMute;
     const startTimeSec = ctx.currentTime + (request.timeOffsetMs ?? 0) / 1e3;
     const endTimeMs = (request.looping ? Number.POSITIVE_INFINITY : buffer.duration * 1e3) + startTimeSec * 1e3;
     source.connect(panner);
@@ -4607,9 +4624,15 @@ var AudioSystem = class {
     filter.frequency.value = clamp(cutoffHz, 10, 2e4);
     return filter;
   }
+  updateSourceGain(active) {
+    const occlusionScale = active.occlusion?.scale ?? 1;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    active.gain.gain.value = active.baseGain * occlusionScale * playbackRateMute;
+  }
   applyOcclusion(active, occlusion) {
     const scale = clamp01(occlusion?.gainScale ?? 1);
-    active.gain.gain.value = active.baseGain * scale;
+    const playbackRateMute = Math.abs(this.playbackRate - 1) < 1e-3 ? 1 : 0;
+    active.gain.gain.value = active.baseGain * scale * playbackRateMute;
     if (active.occlusion?.filter) {
       const cutoff = occlusion?.lowpassHz ?? 2e4;
       active.occlusion.filter.frequency.value = clamp(cutoff, 10, 2e4);
@@ -13399,6 +13422,67 @@ var AssetPreviewGenerator = class {
   }
 };
 
+// src/assets/mapStatistics.ts
+var MapAnalyzer = class {
+  constructor(loader) {
+    this.loader = loader;
+  }
+  async getMapStatistics(mapName) {
+    const map = await this.loader.load(mapName);
+    const lightmapCount = map.faces.filter((f) => f.lightOffset !== -1).length;
+    const worldModel = map.models[0];
+    const bounds = worldModel ? {
+      mins: worldModel.mins,
+      maxs: worldModel.maxs
+    } : {
+      mins: [0, 0, 0],
+      maxs: [0, 0, 0]
+    };
+    return {
+      entityCount: map.entities.entities.length,
+      surfaceCount: map.faces.length,
+      lightmapCount,
+      vertexCount: map.vertices.length,
+      bounds
+    };
+  }
+  async getUsedTextures(mapName) {
+    const map = await this.loader.load(mapName);
+    const textures = /* @__PURE__ */ new Set();
+    for (const info of map.texInfo) {
+      if (info.texture) {
+        textures.add(info.texture);
+      }
+    }
+    return Array.from(textures).sort();
+  }
+  async getUsedModels(mapName) {
+    const map = await this.loader.load(mapName);
+    const models = /* @__PURE__ */ new Set();
+    for (const ent of map.entities.entities) {
+      if (ent.properties["model"] && !ent.properties["model"].startsWith("*")) {
+        models.add(ent.properties["model"]);
+      }
+    }
+    return Array.from(models).sort();
+  }
+  async getUsedSounds(mapName) {
+    const map = await this.loader.load(mapName);
+    const sounds = /* @__PURE__ */ new Set();
+    for (const ent of map.entities.entities) {
+      if (ent.properties["noise"]) {
+        sounds.add(ent.properties["noise"]);
+      }
+      for (const [key, value] of Object.entries(ent.properties)) {
+        if ((key === "noise" || key.endsWith("_sound") || key === "sound") && typeof value === "string") {
+          sounds.add(value);
+        }
+      }
+    }
+    return Array.from(sounds).sort();
+  }
+};
+
 // src/index.ts
 function createEngine(imports) {
   return {
@@ -13455,6 +13539,7 @@ export {
   MD2_VERTEX_SHADER,
   MD3_FRAGMENT_SHADER,
   MD3_VERTEX_SHADER,
+  MapAnalyzer,
   Md2Loader,
   Md2MeshBuffers,
   Md2ParseError,