quake2ts 0.0.593 → 0.0.596

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

@@ -1552,101 +1552,6 @@ var EngineHost = class {
   }
 };
 
-// src/configstrings.ts
-function assertWithinBounds(index) {
-  if (index < 0 || index >= ConfigStringIndex.MaxConfigStrings) {
-    throw new RangeError(`Configstring index ${index} is out of range (0-${ConfigStringIndex.MaxConfigStrings - 1})`);
-  }
-}
-function assertLength(index, value) {
-  const maxLength = configStringSize(index);
-  if (value.length > maxLength) {
-    throw new RangeError(
-      `Configstring ${index} exceeds maximum length (${value.length} > ${maxLength}); limit is ${CS_MAX_STRING_LENGTH} chars per slot`
-    );
-  }
-}
-var ConfigStringRegistry = class {
-  constructor() {
-    this.values = /* @__PURE__ */ new Map();
-    this.modelCursor = ConfigStringIndex.Models;
-    this.soundCursor = ConfigStringIndex.Sounds;
-    this.imageCursor = ConfigStringIndex.Images;
-    this.lightCursor = ConfigStringIndex.Lights;
-    this.shadowLightCursor = ConfigStringIndex.ShadowLights;
-    this.itemCursor = ConfigStringIndex.Items;
-    this.playerSkinCursor = ConfigStringIndex.PlayerSkins;
-    this.generalCursor = ConfigStringIndex.General;
-  }
-  set(index, value) {
-    assertWithinBounds(index);
-    assertLength(index, value);
-    this.values.set(index, value);
-    return index;
-  }
-  get(index) {
-    return this.values.get(index);
-  }
-  getName(index) {
-    return this.get(index);
-  }
-  getAll() {
-    const result = new Array(MAX_CONFIGSTRINGS).fill("");
-    for (const [index, value] of this.values.entries()) {
-      result[index] = value;
-    }
-    return result;
-  }
-  modelIndex(path) {
-    return this.register(path, ConfigStringIndex.Models, MAX_MODELS, "modelCursor");
-  }
-  soundIndex(path) {
-    return this.register(path, ConfigStringIndex.Sounds, MAX_SOUNDS, "soundCursor");
-  }
-  findSoundIndex(path) {
-    for (let i = ConfigStringIndex.Sounds; i < ConfigStringIndex.Sounds + MAX_SOUNDS; i += 1) {
-      if (this.values.get(i) === path) {
-        return i;
-      }
-    }
-    return void 0;
-  }
-  imageIndex(path) {
-    return this.register(path, ConfigStringIndex.Images, MAX_IMAGES, "imageCursor");
-  }
-  lightIndex(definition) {
-    return this.register(definition, ConfigStringIndex.Lights, MAX_LIGHTSTYLES, "lightCursor");
-  }
-  shadowLightIndex(definition) {
-    return this.register(definition, ConfigStringIndex.ShadowLights, MAX_SHADOW_LIGHTS, "shadowLightCursor");
-  }
-  itemIndex(name) {
-    return this.register(name, ConfigStringIndex.Items, MAX_ITEMS, "itemCursor");
-  }
-  playerSkinIndex(name) {
-    return this.register(name, ConfigStringIndex.PlayerSkins, MAX_CLIENTS, "playerSkinCursor");
-  }
-  generalIndex(value) {
-    return this.register(value, ConfigStringIndex.General, MAX_GENERAL, "generalCursor");
-  }
-  register(value, start, maxCount, cursorKey) {
-    for (let i = start; i < start + maxCount; i += 1) {
-      if (this.values.get(i) === value) {
-        return i;
-      }
-    }
-    const next = this[cursorKey];
-    const limit = start + maxCount;
-    if (next >= limit) {
-      throw new RangeError(`Out of configstring slots for range starting at ${start}`);
-    }
-    assertLength(next, value);
-    this.values.set(next, value);
-    this[cursorKey] = next + 1;
-    return next;
-  }
-};
-
 // src/audio/api.ts
 var AudioApi = class {
   constructor(options) {
@@ -1773,6 +1678,101 @@ function createEngineRuntime(engine, game, client, audioOptions, options) {
   return { runtime, audio };
 }
 
+// src/configstrings.ts
+function assertWithinBounds(index) {
+  if (index < 0 || index >= ConfigStringIndex.MaxConfigStrings) {
+    throw new RangeError(`Configstring index ${index} is out of range (0-${ConfigStringIndex.MaxConfigStrings - 1})`);
+  }
+}
+function assertLength(index, value) {
+  const maxLength = configStringSize(index);
+  if (value.length > maxLength) {
+    throw new RangeError(
+      `Configstring ${index} exceeds maximum length (${value.length} > ${maxLength}); limit is ${CS_MAX_STRING_LENGTH} chars per slot`
+    );
+  }
+}
+var ConfigStringRegistry = class {
+  constructor() {
+    this.values = /* @__PURE__ */ new Map();
+    this.modelCursor = ConfigStringIndex.Models;
+    this.soundCursor = ConfigStringIndex.Sounds;
+    this.imageCursor = ConfigStringIndex.Images;
+    this.lightCursor = ConfigStringIndex.Lights;
+    this.shadowLightCursor = ConfigStringIndex.ShadowLights;
+    this.itemCursor = ConfigStringIndex.Items;
+    this.playerSkinCursor = ConfigStringIndex.PlayerSkins;
+    this.generalCursor = ConfigStringIndex.General;
+  }
+  set(index, value) {
+    assertWithinBounds(index);
+    assertLength(index, value);
+    this.values.set(index, value);
+    return index;
+  }
+  get(index) {
+    return this.values.get(index);
+  }
+  getName(index) {
+    return this.get(index);
+  }
+  getAll() {
+    const result = new Array(MAX_CONFIGSTRINGS).fill("");
+    for (const [index, value] of this.values.entries()) {
+      result[index] = value;
+    }
+    return result;
+  }
+  modelIndex(path) {
+    return this.register(path, ConfigStringIndex.Models, MAX_MODELS, "modelCursor");
+  }
+  soundIndex(path) {
+    return this.register(path, ConfigStringIndex.Sounds, MAX_SOUNDS, "soundCursor");
+  }
+  findSoundIndex(path) {
+    for (let i = ConfigStringIndex.Sounds; i < ConfigStringIndex.Sounds + MAX_SOUNDS; i += 1) {
+      if (this.values.get(i) === path) {
+        return i;
+      }
+    }
+    return void 0;
+  }
+  imageIndex(path) {
+    return this.register(path, ConfigStringIndex.Images, MAX_IMAGES, "imageCursor");
+  }
+  lightIndex(definition) {
+    return this.register(definition, ConfigStringIndex.Lights, MAX_LIGHTSTYLES, "lightCursor");
+  }
+  shadowLightIndex(definition) {
+    return this.register(definition, ConfigStringIndex.ShadowLights, MAX_SHADOW_LIGHTS, "shadowLightCursor");
+  }
+  itemIndex(name) {
+    return this.register(name, ConfigStringIndex.Items, MAX_ITEMS, "itemCursor");
+  }
+  playerSkinIndex(name) {
+    return this.register(name, ConfigStringIndex.PlayerSkins, MAX_CLIENTS, "playerSkinCursor");
+  }
+  generalIndex(value) {
+    return this.register(value, ConfigStringIndex.General, MAX_GENERAL, "generalCursor");
+  }
+  register(value, start, maxCount, cursorKey) {
+    for (let i = start; i < start + maxCount; i += 1) {
+      if (this.values.get(i) === value) {
+        return i;
+      }
+    }
+    const next = this[cursorKey];
+    const limit = start + maxCount;
+    if (next >= limit) {
+      throw new RangeError(`Out of configstring slots for range starting at ${start}`);
+    }
+    assertLength(next, value);
+    this.values.set(next, value);
+    this[cursorKey] = next + 1;
+    return next;
+  }
+};
+
 // src/assets/pak.ts
 var PAK_MAGIC = "PACK";
 var HEADER_SIZE = 12;
@@ -17764,55 +17764,43 @@ async function createWebGPUContext(canvas, options) {
   if (!navigator.gpu) {
     throw new Error("WebGPU is not supported in this environment");
   }
-  const adapterOptions = {
-    powerPreference: options?.powerPreference ?? "high-performance",
-    forceFallbackAdapter: options?.forceFallbackAdapter
-  };
-  const adapter = await navigator.gpu.requestAdapter(adapterOptions);
+  const adapter = await navigator.gpu.requestAdapter({
+    powerPreference: options?.powerPreference || "high-performance"
+  });
   if (!adapter) {
-    console.error("WebGPU Adapter Request Failed");
-    console.error("Options:", JSON.stringify(adapterOptions));
-    console.error("Navigator.gpu:", navigator.gpu);
-    if (typeof process !== "undefined" && process.env) {
-      console.error("Environment:", {
-        VK_ICD_FILENAMES: process.env.VK_ICD_FILENAMES,
-        DISPLAY: process.env.DISPLAY
-      });
-    }
-    throw new Error("Failed to request WebGPU adapter");
+    throw new Error("No appropriate GPUAdapter found");
   }
   if (options?.requiredFeatures) {
     for (const feature of options.requiredFeatures) {
       if (!adapter.features.has(feature)) {
-        throw new Error(`Required WebGPU feature '${feature}' is not supported by the adapter`);
+        throw new Error(`Required feature not available: ${feature}`);
       }
     }
   }
-  const device = await adapter.requestDevice({
+  const deviceDescriptor = {
     requiredFeatures: options?.requiredFeatures,
     requiredLimits: options?.requiredLimits
-  });
-  if (!device) {
-    throw new Error("Failed to request WebGPU device");
-  }
+  };
+  const device = await adapter.requestDevice(deviceDescriptor);
   let context;
-  let format;
+  let format = "bgra8unorm";
+  let isHeadless = true;
   if (canvas) {
     context = canvas.getContext("webgpu");
     if (!context) {
       throw new Error("Failed to get WebGPU context from canvas");
     }
+    isHeadless = false;
     format = navigator.gpu.getPreferredCanvasFormat();
     context.configure({
       device,
       format,
-      alphaMode: "premultiplied"
+      alphaMode: "opaque"
+      // Standard for game rendering
     });
-  } else {
-    format = "rgba8unorm";
   }
   const features = /* @__PURE__ */ new Set();
-  for (const feature of device.features) {
+  for (const feature of adapter.features) {
     features.add(feature);
   }
   return {
@@ -17822,7 +17810,7 @@ async function createWebGPUContext(canvas, options) {
     format,
     features,
     limits: device.limits,
-    isHeadless: !canvas
+    isHeadless
   };
 }
 function queryCapabilities(state) {
@@ -17842,10 +17830,11 @@ function queryCapabilities(state) {
 
 // src/render/webgpu/headless.ts
 function createHeadlessRenderTarget(device, width, height, format = "rgba8unorm") {
+  const usage = typeof GPUTextureUsage !== "undefined" ? GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC : 17;
   const texture = device.createTexture({
     size: { width, height, depthOrArrayLayers: 1 },
     format,
-    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
+    usage
   });
   const view = texture.createView();
   return {
@@ -17863,9 +17852,10 @@ async function captureRenderTarget(device, texture) {
   const align = 256;
   const paddedBytesPerRow = Math.max(bytesPerPixel * width, Math.ceil(width * bytesPerPixel / align) * align);
   const bufferSize = paddedBytesPerRow * height;
+  const usage = typeof GPUBufferUsage !== "undefined" ? GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ : 9;
   const outputBuffer = device.createBuffer({
     size: bufferSize,
-    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    usage
   });
   const commandEncoder = device.createCommandEncoder();
   commandEncoder.copyTextureToBuffer(
@@ -17883,7 +17873,8 @@ async function captureRenderTarget(device, texture) {
     }
   );
   device.queue.submit([commandEncoder.finish()]);
-  await outputBuffer.mapAsync(GPUMapMode.READ);
+  const mapMode = typeof GPUMapMode !== "undefined" ? GPUMapMode.READ : 1;
+  await outputBuffer.mapAsync(mapMode);
   const mappedRange = outputBuffer.getMappedRange();
   const data = new Uint8Array(mappedRange);
   const result = new Uint8ClampedArray(width * height * 4);