quake2ts 0.0.72 → 0.0.73

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

@@ -1030,10 +1030,418 @@ function wireFileInput(input, handler) {
   return () => input.removeEventListener("change", onChange);
 }
 
+// src/assets/bsp.ts
+var BSP_MAGIC = "IBSP";
+var BSP_VERSION = 38;
+var HEADER_LUMPS = 19;
+var HEADER_SIZE2 = 4 + 4 + HEADER_LUMPS * 8;
+var BspParseError = class extends Error {
+};
+var BspLoader = class {
+  constructor(vfs) {
+    this.vfs = vfs;
+  }
+  async load(path) {
+    const buffer = await this.vfs.readFile(path);
+    const copy = new Uint8Array(buffer.byteLength);
+    copy.set(buffer);
+    return parseBsp(copy.buffer);
+  }
+};
+function parseBsp(buffer) {
+  if (buffer.byteLength < HEADER_SIZE2) {
+    throw new BspParseError("BSP too small to contain header");
+  }
+  const view = new DataView(buffer);
+  const magic = String.fromCharCode(view.getUint8(0), view.getUint8(1), view.getUint8(2), view.getUint8(3));
+  if (magic !== BSP_MAGIC) {
+    throw new BspParseError(`Invalid BSP magic ${magic}`);
+  }
+  const version = view.getInt32(4, true);
+  if (version !== BSP_VERSION) {
+    throw new BspParseError(`Unsupported BSP version ${version}`);
+  }
+  const lumps = /* @__PURE__ */ new Map();
+  for (let i = 0; i < HEADER_LUMPS; i += 1) {
+    const offset = view.getInt32(8 + i * 8, true);
+    const length = view.getInt32(12 + i * 8, true);
+    if (offset < 0 || length < 0 || offset + length > buffer.byteLength) {
+      throw new BspParseError(`Invalid lump bounds for index ${i}`);
+    }
+    lumps.set(i, { offset, length });
+  }
+  const header = { version, lumps };
+  const entities = parseEntities(buffer, lumps.get(0 /* Entities */));
+  const planes = parsePlanes(buffer, lumps.get(1 /* Planes */));
+  const vertices = parseVertices(buffer, lumps.get(2 /* Vertices */));
+  const nodes = parseNodes(buffer, lumps.get(4 /* Nodes */));
+  const texInfo = parseTexInfo(buffer, lumps.get(5 /* TexInfo */));
+  const faces = parseFaces(buffer, lumps.get(6 /* Faces */));
+  const lightMaps = new Uint8Array(buffer, lumps.get(7 /* Lighting */).offset, lumps.get(7 /* Lighting */).length);
+  const lightMapInfo = buildLightMapInfo(faces, lumps.get(7 /* Lighting */));
+  const leafs = parseLeafs(buffer, lumps.get(8 /* Leafs */));
+  const edges = parseEdges(buffer, lumps.get(11 /* Edges */));
+  const surfEdges = parseSurfEdges(buffer, lumps.get(12 /* SurfEdges */));
+  const models = parseModels(buffer, lumps.get(13 /* Models */));
+  const brushes = parseBrushes(buffer, lumps.get(14 /* Brushes */));
+  const brushSides = parseBrushSides(buffer, lumps.get(15 /* BrushSides */));
+  const leafLists = parseLeafLists(buffer, lumps.get(9 /* LeafFaces */), lumps.get(10 /* LeafBrushes */), leafs);
+  const visibility = parseVisibility(buffer, lumps.get(3 /* Visibility */));
+  return {
+    header,
+    entities,
+    planes,
+    vertices,
+    nodes,
+    texInfo,
+    faces,
+    lightMaps,
+    lightMapInfo,
+    leafs,
+    leafLists,
+    edges,
+    surfEdges,
+    models,
+    brushes,
+    brushSides,
+    visibility
+  };
+}
+function parseEntities(buffer, info) {
+  const raw = new TextDecoder().decode(new Uint8Array(buffer, info.offset, info.length));
+  const entities = parseEntityString(raw);
+  const worldspawn = entities.find((ent) => ent.classname === "worldspawn");
+  return { raw, entities, worldspawn };
+}
+function parseEntityString(text) {
+  const entities = [];
+  const tokenizer = /\{([^}]*)\}/gms;
+  let match;
+  while ((match = tokenizer.exec(text)) !== null) {
+    const entityText = match[1];
+    const properties = {};
+    const kvRegex = /"([^\"]*)"\s+"([^\"]*)"/g;
+    let kv;
+    while ((kv = kvRegex.exec(entityText)) !== null) {
+      properties[kv[1]] = kv[2];
+    }
+    entities.push({ classname: properties.classname, properties });
+  }
+  return entities;
+}
+function parsePlanes(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const count = info.length / 20;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Plane lump has invalid length");
+  }
+  const planes = [];
+  for (let i = 0; i < count; i += 1) {
+    const normal = [view.getFloat32(i * 20, true), view.getFloat32(i * 20 + 4, true), view.getFloat32(i * 20 + 8, true)];
+    const dist = view.getFloat32(i * 20 + 12, true);
+    const type = view.getInt32(i * 20 + 16, true);
+    planes.push({ normal, dist, type });
+  }
+  return planes;
+}
+function parseVertices(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const count = info.length / 12;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Vertex lump has invalid length");
+  }
+  const vertices = [];
+  for (let i = 0; i < count; i += 1) {
+    vertices.push([
+      view.getFloat32(i * 12, true),
+      view.getFloat32(i * 12 + 4, true),
+      view.getFloat32(i * 12 + 8, true)
+    ]);
+  }
+  return vertices;
+}
+function parseNodes(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 36;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Node lump has invalid length");
+  }
+  const nodes = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    const planeIndex = view.getInt32(base, true);
+    const children = [view.getInt32(base + 4, true), view.getInt32(base + 8, true)];
+    const mins = [view.getInt16(base + 12, true), view.getInt16(base + 14, true), view.getInt16(base + 16, true)];
+    const maxs = [view.getInt16(base + 18, true), view.getInt16(base + 20, true), view.getInt16(base + 22, true)];
+    const firstFace = view.getUint16(base + 24, true);
+    const numFaces = view.getUint16(base + 26, true);
+    nodes.push({ planeIndex, children, mins, maxs, firstFace, numFaces });
+  }
+  return nodes;
+}
+function parseTexInfo(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 76;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("TexInfo lump has invalid length");
+  }
+  const texInfos = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    const s = [view.getFloat32(base, true), view.getFloat32(base + 4, true), view.getFloat32(base + 8, true)];
+    const sOffset = view.getFloat32(base + 12, true);
+    const t = [view.getFloat32(base + 16, true), view.getFloat32(base + 20, true), view.getFloat32(base + 24, true)];
+    const tOffset = view.getFloat32(base + 28, true);
+    const flags = view.getInt32(base + 32, true);
+    const value = view.getInt32(base + 36, true);
+    const textureBytes = new Uint8Array(buffer, info.offset + base + 40, 32);
+    const texture = new TextDecoder("utf-8").decode(textureBytes).replace(/\0.*$/, "");
+    const nextTexInfo = view.getInt32(base + 72, true);
+    texInfos.push({ s, sOffset, t, tOffset, flags, value, texture, nextTexInfo });
+  }
+  return texInfos;
+}
+function parseFaces(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 20;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Face lump has invalid length");
+  }
+  const faces = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    const planeIndex = view.getUint16(base, true);
+    const side = view.getInt16(base + 2, true);
+    const firstEdge = view.getInt32(base + 4, true);
+    const numEdges = view.getInt16(base + 8, true);
+    const texInfo = view.getInt16(base + 10, true);
+    const styles = [
+      view.getUint8(base + 12),
+      view.getUint8(base + 13),
+      view.getUint8(base + 14),
+      view.getUint8(base + 15)
+    ];
+    const lightOffset = view.getInt32(base + 16, true);
+    faces.push({ planeIndex, side, firstEdge, numEdges, texInfo, styles, lightOffset });
+  }
+  return faces;
+}
+function parseLeafs(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 28;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Leaf lump has invalid length");
+  }
+  const leafs = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    const contents = view.getInt32(base, true);
+    const cluster = view.getInt16(base + 4, true);
+    const area = view.getInt16(base + 6, true);
+    const mins = [view.getInt16(base + 8, true), view.getInt16(base + 10, true), view.getInt16(base + 12, true)];
+    const maxs = [view.getInt16(base + 14, true), view.getInt16(base + 16, true), view.getInt16(base + 18, true)];
+    const firstLeafFace = view.getUint16(base + 20, true);
+    const numLeafFaces = view.getUint16(base + 22, true);
+    const firstLeafBrush = view.getUint16(base + 24, true);
+    const numLeafBrushes = view.getUint16(base + 26, true);
+    leafs.push({ contents, cluster, area, mins, maxs, firstLeafFace, numLeafFaces, firstLeafBrush, numLeafBrushes });
+  }
+  return leafs;
+}
+function parseEdges(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 4;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Edge lump has invalid length");
+  }
+  const edges = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    edges.push({ vertices: [view.getUint16(base, true), view.getUint16(base + 2, true)] });
+  }
+  return edges;
+}
+function parseSurfEdges(buffer, info) {
+  const count = info.length / 4;
+  if (count % 1 !== 0) {
+    throw new BspParseError("SurfEdge lump has invalid length");
+  }
+  const view = new DataView(buffer, info.offset, info.length);
+  const edges = new Int32Array(count);
+  for (let i = 0; i < count; i += 1) {
+    edges[i] = view.getInt32(i * 4, true);
+  }
+  return edges;
+}
+function parseModels(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 48;
+  if (info.length % entrySize !== 0) {
+    throw new BspParseError("Model lump has invalid length");
+  }
+  const count = info.length / entrySize;
+  const models = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    const mins = [view.getFloat32(base, true), view.getFloat32(base + 4, true), view.getFloat32(base + 8, true)];
+    const maxs = [view.getFloat32(base + 12, true), view.getFloat32(base + 16, true), view.getFloat32(base + 20, true)];
+    const origin = [view.getFloat32(base + 24, true), view.getFloat32(base + 28, true), view.getFloat32(base + 32, true)];
+    const headNode = view.getInt32(base + 36, true);
+    const firstFace = view.getInt32(base + 40, true);
+    const numFaces = view.getInt32(base + 44, true);
+    models.push({ mins, maxs, origin, headNode, firstFace, numFaces });
+  }
+  return models;
+}
+function parseBrushes(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 12;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Brush lump has invalid length");
+  }
+  const brushes = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    brushes.push({
+      firstSide: view.getInt32(base, true),
+      numSides: view.getInt32(base + 4, true),
+      contents: view.getInt32(base + 8, true)
+    });
+  }
+  return brushes;
+}
+function parseBrushSides(buffer, info) {
+  const view = new DataView(buffer, info.offset, info.length);
+  const entrySize = 8;
+  const count = info.length / entrySize;
+  if (count % 1 !== 0) {
+    throw new BspParseError("Brush side lump has invalid length");
+  }
+  const sides = [];
+  for (let i = 0; i < count; i += 1) {
+    const base = i * entrySize;
+    sides.push({ planeIndex: view.getUint16(base, true), texInfo: view.getInt16(base + 2, true) });
+  }
+  return sides;
+}
+function parseLeafLists(buffer, leafFacesInfo, leafBrushesInfo, leafs) {
+  const leafFaces = [];
+  const leafBrushes = [];
+  const maxLeafFaceIndex = leafFacesInfo.length / 2;
+  const maxLeafBrushIndex = leafBrushesInfo.length / 2;
+  const faceView = new DataView(buffer, leafFacesInfo.offset, leafFacesInfo.length);
+  const brushView = new DataView(buffer, leafBrushesInfo.offset, leafBrushesInfo.length);
+  for (const leaf of leafs) {
+    if (leaf.firstLeafFace + leaf.numLeafFaces > maxLeafFaceIndex) {
+      throw new BspParseError("Leaf faces reference data past lump bounds");
+    }
+    if (leaf.firstLeafBrush + leaf.numLeafBrushes > maxLeafBrushIndex) {
+      throw new BspParseError("Leaf brushes reference data past lump bounds");
+    }
+    const faces = [];
+    for (let i = 0; i < leaf.numLeafFaces; i += 1) {
+      faces.push(faceView.getUint16((leaf.firstLeafFace + i) * 2, true));
+    }
+    const brushes = [];
+    for (let i = 0; i < leaf.numLeafBrushes; i += 1) {
+      brushes.push(brushView.getUint16((leaf.firstLeafBrush + i) * 2, true));
+    }
+    leafFaces.push(faces);
+    leafBrushes.push(brushes);
+  }
+  return { leafFaces, leafBrushes };
+}
+function parseVisibility(buffer, info) {
+  if (info.length === 0) {
+    return void 0;
+  }
+  if (info.length < 4) {
+    throw new BspParseError("Visibility lump too small");
+  }
+  const view = new DataView(buffer, info.offset, info.length);
+  const numClusters = view.getInt32(0, true);
+  const headerBytes = 4 + numClusters * 8;
+  if (numClusters < 0 || headerBytes > info.length) {
+    throw new BspParseError("Visibility lump truncated");
+  }
+  let cursor = 4;
+  const clusters = [];
+  for (let i = 0; i < numClusters; i += 1) {
+    const pvsOffset = view.getInt32(cursor, true);
+    const phsOffset = view.getInt32(cursor + 4, true);
+    cursor += 8;
+    const absolutePvs = info.offset + pvsOffset;
+    const absolutePhs = info.offset + phsOffset;
+    const lumpEnd = info.offset + info.length;
+    if (pvsOffset < 0 || phsOffset < 0 || absolutePvs >= lumpEnd || absolutePhs >= lumpEnd) {
+      throw new BspParseError("Visibility offsets out of range");
+    }
+    clusters.push({
+      pvs: decompressVis(buffer, absolutePvs, numClusters, info),
+      phs: decompressVis(buffer, absolutePhs, numClusters, info)
+    });
+  }
+  return { numClusters, clusters };
+}
+function decompressVis(buffer, offset, numClusters, lump) {
+  const rowBytes = Math.ceil(numClusters / 8);
+  const result = new Uint8Array(rowBytes);
+  const src = new Uint8Array(buffer);
+  let srcIndex = offset;
+  let destIndex = 0;
+  const maxOffset = lump.offset + lump.length;
+  while (destIndex < rowBytes) {
+    if (srcIndex >= maxOffset) {
+      throw new BspParseError("Visibility data truncated");
+    }
+    const value = src[srcIndex++];
+    if (value !== 0) {
+      result[destIndex++] = value;
+      continue;
+    }
+    if (srcIndex >= maxOffset) {
+      throw new BspParseError("Visibility run exceeds lump bounds");
+    }
+    const runLength = src[srcIndex++];
+    for (let i = 0; i < runLength && destIndex < rowBytes; i += 1) {
+      result[destIndex++] = 0;
+    }
+  }
+  return result;
+}
+function buildLightMapInfo(faces, lightingLump) {
+  return faces.map((face) => {
+    if (face.lightOffset < 0) {
+      return void 0;
+    }
+    return {
+      offset: face.lightOffset,
+      length: Math.max(0, lightingLump.length - face.lightOffset)
+    };
+  });
+}
+function createFaceLightmap(face, lightMaps, info) {
+  if (face.lightOffset < 0 || face.lightOffset >= lightMaps.byteLength) {
+    return void 0;
+  }
+  const available = lightMaps.byteLength - face.lightOffset;
+  const length = Math.min(info?.length ?? available, available);
+  if (length <= 0) {
+    return void 0;
+  }
+  return lightMaps.subarray(face.lightOffset, face.lightOffset + length);
+}
+
 // src/assets/md2.ts
 var MD2_MAGIC = 844121161;
 var MD2_VERSION = 8;
-var HEADER_SIZE2 = 17 * 4;
+var HEADER_SIZE3 = 17 * 4;
 var MD2_NORMALS = [
   { x: -0.525731, y: 0, z: 0.850651 },
   { x: -0.442863, y: 0.238856, z: 0.864188 },
@@ -1222,12 +1630,12 @@ function readCString2(view, offset, maxLength) {
 }
 function validateSection(buffer, offset, length, label) {
   if (length === 0) return;
-  if (offset < HEADER_SIZE2 || offset + length > buffer.byteLength) {
+  if (offset < HEADER_SIZE3 || offset + length > buffer.byteLength) {
     throw new Md2ParseError(`${label} section is out of bounds`);
   }
 }
 function parseHeader(buffer) {
-  if (buffer.byteLength < HEADER_SIZE2) {
+  if (buffer.byteLength < HEADER_SIZE3) {
     throw new Md2ParseError("MD2 buffer too small to contain header");
   }
   const view = new DataView(buffer);
@@ -1641,7 +2049,7 @@ var Md3Loader = class {
 var IDSPRITEHEADER = 1229214514;
 var SPRITE_VERSION = 2;
 var MAX_SKINNAME = 64;
-var HEADER_SIZE3 = 12;
+var HEADER_SIZE4 = 12;
 var SpriteParseError = class extends Error {
 };
 function readCString3(view, offset, maxLength) {
@@ -1654,7 +2062,7 @@ function readCString3(view, offset, maxLength) {
   return String.fromCharCode(...chars);
 }
 function parseSprite(buffer) {
-  if (buffer.byteLength < HEADER_SIZE3) {
+  if (buffer.byteLength < HEADER_SIZE4) {
     throw new SpriteParseError("Sprite buffer too small to contain header");
   }
   const view = new DataView(buffer);
@@ -1669,7 +2077,7 @@ function parseSprite(buffer) {
   }
   const frames = [];
   const frameSize = 16 + MAX_SKINNAME;
-  let offset = HEADER_SIZE3;
+  let offset = HEADER_SIZE4;
   for (let i = 0; i < numFrames; i += 1) {
     if (offset + frameSize > buffer.byteLength) {
       throw new SpriteParseError("Sprite frame data exceeds buffer length");
@@ -3335,6 +3743,70 @@ function buildVertexData(surface, placement) {
   }
   return interleaved;
 }
+function createBspSurfaces(map) {
+  const results = [];
+  for (let faceIndex = 0; faceIndex < map.faces.length; faceIndex++) {
+    const face = map.faces[faceIndex];
+    if (face.texInfo < 0) continue;
+    const texInfo = map.texInfo[face.texInfo];
+    const vertices = [];
+    const textureCoords = [];
+    const lightmapCoords = [];
+    for (let i = 0; i < face.numEdges; i++) {
+      const edgeIndex = map.surfEdges[face.firstEdge + i];
+      const edge = map.edges[Math.abs(edgeIndex)];
+      const vIndex = edgeIndex >= 0 ? edge.vertices[0] : edge.vertices[1];
+      const vertex = map.vertices[vIndex];
+      vertices.push(vertex[0], vertex[1], vertex[2]);
+      const s = vertex[0] * texInfo.s[0] + vertex[1] * texInfo.s[1] + vertex[2] * texInfo.s[2] + texInfo.sOffset;
+      const t = vertex[0] * texInfo.t[0] + vertex[1] * texInfo.t[1] + vertex[2] * texInfo.t[2] + texInfo.tOffset;
+      textureCoords.push(s, t);
+      lightmapCoords.push(s, t);
+    }
+    const indices = [];
+    const vertexCount = vertices.length / 3;
+    for (let i = 1; i < vertexCount - 1; i++) {
+      indices.push(0, i, i + 1);
+    }
+    let lightmapData;
+    const lightmapInfo = map.lightMapInfo[faceIndex];
+    if (lightmapInfo) {
+      let minS = Infinity, maxS = -Infinity, minT = Infinity, maxT = -Infinity;
+      for (let k = 0; k < textureCoords.length; k += 2) {
+        const s = textureCoords[k];
+        const t = textureCoords[k + 1];
+        if (s < minS) minS = s;
+        if (s > maxS) maxS = s;
+        if (t < minT) minT = t;
+        if (t > maxT) maxT = t;
+      }
+      const floorMinS = Math.floor(minS / 16);
+      const floorMinT = Math.floor(minT / 16);
+      const lmWidth = Math.ceil(maxS / 16) - floorMinS + 1;
+      const lmHeight = Math.ceil(maxT / 16) - floorMinT + 1;
+      const samples = createFaceLightmap(face, map.lightMaps, lightmapInfo);
+      if (samples) {
+        if (samples.length === lmWidth * lmHeight * 3) {
+          lightmapData = { width: lmWidth, height: lmHeight, samples };
+          for (let k = 0; k < lightmapCoords.length; k += 2) {
+            lightmapCoords[k] = textureCoords[k] / 16 - floorMinS + 0.5;
+            lightmapCoords[k + 1] = textureCoords[k + 1] / 16 - floorMinT + 0.5;
+          }
+        }
+      }
+    }
+    results.push({
+      vertices: new Float32Array(vertices),
+      textureCoords: new Float32Array(textureCoords),
+      lightmapCoords: new Float32Array(lightmapCoords),
+      indices: new Uint16Array(indices),
+      texture: texInfo.texture,
+      surfaceFlags: texInfo.flags,
+      lightmap: lightmapData
+    });
+  }
+  return results;
+}
 function buildBspGeometry(gl, surfaces, options = {}) {
   const resolved = {
     atlasSize: options.atlasSize ?? 1024,
@@ -5013,6 +5485,8 @@ export {
   BSP_SURFACE_FRAGMENT_SOURCE,
   BSP_SURFACE_VERTEX_SOURCE,
   BSP_VERTEX_LAYOUT,
+  BspLoader,
+  BspParseError,
   BspSurfacePipeline,
   Camera,
   ConfigStringRegistry,
@@ -5082,8 +5556,10 @@ export {
   computeSkyScroll,
   createAnimationState,
   createAudioGraph,
+  createBspSurfaces,
   createEngine,
   createEngineRuntime,
+  createFaceLightmap,
   createInitialChannels,
   createProgramFromSources,
   createWebGLContext,
@@ -5098,6 +5574,7 @@ export {
   ingestPaks,
   interpolateMd3Tag,
   interpolateVec3,
+  parseBsp,
   parseMd2,
   parseMd3,
   parsePcx,