@quake2ts/test-utils 0.0.838 → 0.0.839

package/dist/index.js

@@ -4910,6 +4910,602 @@ function expectNoDoubleTransform(renderer) {
   expect2(warnings).toHaveLength(0);
 }
 
+// src/engine/builders/bspBuilder.ts
+import { BspLump } from "@quake2ts/engine";
+var HEADER_LUMPS = 19;
+var HEADER_SIZE = 4 + 4 + HEADER_LUMPS * 8;
+function allocBuffer(size) {
+  return new DataView(new ArrayBuffer(size));
+}
+function writeVec3(view, offset, vec) {
+  view.setFloat32(offset, vec[0], true);
+  view.setFloat32(offset + 4, vec[1], true);
+  view.setFloat32(offset + 8, vec[2], true);
+}
+function encodePlanes(planes) {
+  const view = allocBuffer(planes.length * 20);
+  planes.forEach((plane, index) => {
+    const base = index * 20;
+    writeVec3(view, base, plane.normal);
+    view.setFloat32(base + 12, plane.dist, true);
+    view.setInt32(base + 16, plane.type, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeVertices(vertices) {
+  const view = allocBuffer(vertices.length * 12);
+  vertices.forEach((vertex, index) => writeVec3(view, index * 12, vertex));
+  return new Uint8Array(view.buffer);
+}
+function encodeNodes(nodes) {
+  const view = allocBuffer(nodes.length * 28);
+  nodes.forEach((node, index) => {
+    const base = index * 28;
+    view.setInt32(base, node.planeIndex, true);
+    view.setInt32(base + 4, node.children[0], true);
+    view.setInt32(base + 8, node.children[1], true);
+    view.setInt16(base + 12, node.mins[0], true);
+    view.setInt16(base + 14, node.mins[1], true);
+    view.setInt16(base + 16, node.mins[2], true);
+    view.setInt16(base + 18, node.maxs[0], true);
+    view.setInt16(base + 20, node.maxs[1], true);
+    view.setInt16(base + 22, node.maxs[2], true);
+    view.setUint16(base + 24, node.firstFace, true);
+    view.setUint16(base + 26, node.numFaces, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeTexInfo(texInfos) {
+  const view = allocBuffer(texInfos.length * 76);
+  texInfos.forEach((tex, index) => {
+    const base = index * 76;
+    writeVec3(view, base, tex.s);
+    view.setFloat32(base + 12, tex.sOffset, true);
+    writeVec3(view, base + 16, tex.t);
+    view.setFloat32(base + 28, tex.tOffset, true);
+    view.setInt32(base + 32, tex.flags, true);
+    view.setInt32(base + 36, tex.value, true);
+    const textureBytes = new TextEncoder().encode(tex.texture);
+    new Uint8Array(view.buffer).set(textureBytes.slice(0, 32), base + 40);
+    view.setInt32(base + 72, tex.nextTexInfo, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeFaces(faces) {
+  const view = allocBuffer(faces.length * 20);
+  faces.forEach((face, index) => {
+    const base = index * 20;
+    view.setUint16(base, face.planeIndex, true);
+    view.setInt16(base + 2, face.side, true);
+    view.setInt32(base + 4, face.firstEdge, true);
+    view.setInt16(base + 8, face.numEdges, true);
+    view.setInt16(base + 10, face.texInfo, true);
+    face.styles.forEach((style, sIndex) => view.setUint8(base + 12 + sIndex, style));
+    view.setInt32(base + 16, face.lightOffset, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeLeafs(leafs) {
+  const view = allocBuffer(leafs.length * 28);
+  leafs.forEach((leaf, index) => {
+    const base = index * 28;
+    view.setInt32(base, leaf.contents, true);
+    view.setInt16(base + 4, leaf.cluster, true);
+    view.setInt16(base + 6, leaf.area, true);
+    view.setInt16(base + 8, leaf.mins[0], true);
+    view.setInt16(base + 10, leaf.mins[1], true);
+    view.setInt16(base + 12, leaf.mins[2], true);
+    view.setInt16(base + 14, leaf.maxs[0], true);
+    view.setInt16(base + 16, leaf.maxs[1], true);
+    view.setInt16(base + 18, leaf.maxs[2], true);
+    view.setUint16(base + 20, leaf.firstLeafFace, true);
+    view.setUint16(base + 22, leaf.numLeafFaces, true);
+    view.setUint16(base + 24, leaf.firstLeafBrush, true);
+    view.setUint16(base + 26, leaf.numLeafBrushes, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeEdges(edges) {
+  const view = allocBuffer(edges.length * 4);
+  edges.forEach((edge, index) => {
+    const base = index * 4;
+    view.setUint16(base, edge[0], true);
+    view.setUint16(base + 2, edge[1], true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeModels(models) {
+  const entrySize = 48;
+  const view = allocBuffer(models.length * entrySize);
+  models.forEach((model, index) => {
+    const base = index * entrySize;
+    writeVec3(view, base, model.mins);
+    writeVec3(view, base + 12, model.maxs);
+    writeVec3(view, base + 24, model.origin);
+    view.setInt32(base + 36, model.headNode, true);
+    view.setInt32(base + 40, model.firstFace, true);
+    view.setInt32(base + 44, model.numFaces, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeBrushes(brushes) {
+  const view = allocBuffer(brushes.length * 12);
+  brushes.forEach((brush, index) => {
+    const base = index * 12;
+    view.setInt32(base, brush.firstSide, true);
+    view.setInt32(base + 4, brush.numSides, true);
+    view.setInt32(base + 8, brush.contents, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeBrushSides(sides) {
+  const view = allocBuffer(sides.length * 4);
+  sides.forEach((side, index) => {
+    const base = index * 4;
+    view.setUint16(base, side.planeIndex, true);
+    view.setInt16(base + 2, side.texInfo, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeVisibility(numClusters, pvsRows, phsRows) {
+  const headerBytes = 4 + numClusters * 8;
+  const header = allocBuffer(headerBytes);
+  header.setInt32(0, numClusters, true);
+  let cursor = headerBytes;
+  const payloads = [];
+  for (let i = 0; i < numClusters; i += 1) {
+    const pvs = pvsRows[i];
+    const phs = phsRows?.[i] ?? pvs;
+    const pvsOffset = cursor - 0;
+    const phsOffset = cursor + pvs.byteLength - 0;
+    payloads.push(pvs, phs);
+    header.setInt32(4 + i * 8, pvsOffset, true);
+    header.setInt32(8 + i * 8, phsOffset, true);
+    cursor += pvs.byteLength + phs.byteLength;
+  }
+  const result = new Uint8Array(cursor);
+  result.set(new Uint8Array(header.buffer), 0);
+  let payloadCursor = headerBytes;
+  for (const payload of payloads) {
+    result.set(payload, payloadCursor);
+    payloadCursor += payload.byteLength;
+  }
+  return result;
+}
+function buildTestBsp(options) {
+  const lumps = {};
+  lumps[BspLump.Entities] = new TextEncoder().encode(options.entities ?? '{"classname" "worldspawn"}\n');
+  lumps[BspLump.Planes] = options.planes ? encodePlanes(options.planes) : new Uint8Array();
+  lumps[BspLump.Vertices] = options.vertices ? encodeVertices(options.vertices) : new Uint8Array();
+  lumps[BspLump.Visibility] = options.visibility ?? new Uint8Array();
+  lumps[BspLump.Nodes] = options.nodes ? encodeNodes(options.nodes) : new Uint8Array();
+  lumps[BspLump.TexInfo] = options.texInfo ? encodeTexInfo(options.texInfo) : new Uint8Array();
+  lumps[BspLump.Faces] = options.faces ? encodeFaces(options.faces) : new Uint8Array();
+  lumps[BspLump.Lighting] = options.lighting ?? new Uint8Array();
+  lumps[BspLump.Leafs] = options.leafs ? encodeLeafs(options.leafs) : new Uint8Array();
+  lumps[BspLump.LeafFaces] = options.leafFaces ? new Uint8Array(options.leafFaces.buffer) : new Uint8Array();
+  lumps[BspLump.LeafBrushes] = options.leafBrushes ? new Uint8Array(options.leafBrushes.buffer) : new Uint8Array();
+  lumps[BspLump.Edges] = options.edges ? encodeEdges(options.edges) : new Uint8Array();
+  lumps[BspLump.SurfEdges] = options.surfEdges ? new Uint8Array(options.surfEdges.buffer) : new Uint8Array();
+  lumps[BspLump.Models] = options.models ? encodeModels(options.models) : new Uint8Array();
+  lumps[BspLump.Brushes] = options.brushes ? encodeBrushes(options.brushes) : new Uint8Array();
+  lumps[BspLump.BrushSides] = options.brushSides ? encodeBrushSides(options.brushSides) : new Uint8Array();
+  lumps[BspLump.Areas] = options.areas ?? new Uint8Array();
+  lumps[BspLump.AreaPortals] = options.areaPortals ?? new Uint8Array();
+  let cursor = HEADER_SIZE;
+  const ordered = [];
+  for (let i = 0; i < HEADER_LUMPS; i += 1) {
+    const data = lumps[i] ?? new Uint8Array();
+    const info = { offset: cursor, length: data.byteLength };
+    ordered.push({ info, data });
+    cursor += data.byteLength;
+  }
+  const buffer = new ArrayBuffer(cursor);
+  const header = new DataView(buffer);
+  header.setUint8(0, 73);
+  header.setUint8(1, 66);
+  header.setUint8(2, 83);
+  header.setUint8(3, 80);
+  header.setInt32(4, 38, true);
+  ordered.forEach((entry, index) => {
+    header.setInt32(8 + index * 8, entry.info.offset, true);
+    header.setInt32(12 + index * 8, entry.info.length, true);
+  });
+  const body = new Uint8Array(buffer);
+  ordered.forEach((entry) => body.set(entry.data, entry.info.offset));
+  return buffer;
+}
+function runLengthVisRow(values) {
+  return new Uint8Array(values);
+}
+function encodedVisForClusters(numClusters, rows) {
+  const rowBytes = Math.ceil(numClusters / 8);
+  const encodedRows = rows.map((row) => new Uint8Array(row));
+  return encodeVisibility(numClusters, encodedRows);
+}
+
+// src/engine/builders/md2Builder.ts
+function allocBuffer2(size) {
+  return new DataView(new ArrayBuffer(size));
+}
+function writeCString(view, offset, text, max) {
+  const bytes = new TextEncoder().encode(text);
+  const length = Math.min(bytes.length, max - 1);
+  new Uint8Array(view.buffer, view.byteOffset + offset, length).set(bytes.slice(0, length));
+  view.setUint8(offset + length, 0);
+}
+function encodeFrames(frames, numVertices) {
+  const frameSize = 40 + numVertices * 4;
+  const view = allocBuffer2(frames.length * frameSize);
+  frames.forEach((frame, frameIndex) => {
+    const base = frameIndex * frameSize;
+    const scale = frame.scale ?? { x: 1, y: 1, z: 1 };
+    const translate = frame.translate ?? { x: 0, y: 0, z: 0 };
+    view.setFloat32(base, scale.x, true);
+    view.setFloat32(base + 4, scale.y, true);
+    view.setFloat32(base + 8, scale.z, true);
+    view.setFloat32(base + 12, translate.x, true);
+    view.setFloat32(base + 16, translate.y, true);
+    view.setFloat32(base + 20, translate.z, true);
+    writeCString(view, base + 24, frame.name, 16);
+    frame.vertices.forEach((vertex, index) => {
+      const offset = base + 40 + index * 4;
+      view.setUint8(offset, Math.round((vertex.position.x - translate.x) / scale.x));
+      view.setUint8(offset + 1, Math.round((vertex.position.y - translate.y) / scale.y));
+      view.setUint8(offset + 2, Math.round((vertex.position.z - translate.z) / scale.z));
+      view.setUint8(offset + 3, vertex.normalIndex);
+    });
+  });
+  return new Uint8Array(view.buffer);
+}
+function encodeGlCommands(commands) {
+  const bytes = [];
+  (commands ?? []).forEach((command) => {
+    const count = command.vertices.length * (command.mode === "strip" ? 1 : -1);
+    bytes.push(count);
+    command.vertices.forEach((vertex) => {
+      const floatView = new DataView(new ArrayBuffer(4));
+      floatView.setFloat32(0, vertex.s, true);
+      bytes.push(floatView.getInt32(0, true));
+      floatView.setFloat32(0, vertex.t, true);
+      bytes.push(floatView.getInt32(0, true));
+      bytes.push(vertex.vertexIndex);
+    });
+  });
+  bytes.push(0);
+  const data = new Uint8Array(bytes.length * 4);
+  const view = new DataView(data.buffer);
+  bytes.forEach((value, index) => view.setInt32(index * 4, value, true));
+  return { data, count: bytes.length };
+}
+function buildMd2(options) {
+  const numVertices = options.frames[0]?.vertices.length ?? 0;
+  const frameSize = 40 + numVertices * 4;
+  const skins = options.skins ?? [];
+  const { data: glData, count: glCount } = encodeGlCommands(options.glCommands);
+  const headerSize = 68;
+  const skinsSize = skins.length * 64;
+  const texCoordSize = options.texCoords.length * 4;
+  const triangleSize = options.triangles.length * 12;
+  const frameBlockSize = options.frames.length * frameSize;
+  const glSize = glData.length;
+  const offsetSkins = headerSize;
+  const offsetTexCoords = offsetSkins + skinsSize;
+  const offsetTriangles = offsetTexCoords + texCoordSize;
+  const offsetFrames = offsetTriangles + triangleSize;
+  const offsetGlCommands = offsetFrames + frameBlockSize;
+  const offsetEnd = offsetGlCommands + glSize;
+  const view = allocBuffer2(offsetEnd);
+  view.setInt32(0, 844121161, true);
+  view.setInt32(4, 8, true);
+  view.setInt32(8, options.skinWidth ?? 64, true);
+  view.setInt32(12, options.skinHeight ?? 64, true);
+  view.setInt32(16, frameSize, true);
+  view.setInt32(20, skins.length, true);
+  view.setInt32(24, numVertices, true);
+  view.setInt32(28, options.texCoords.length, true);
+  view.setInt32(32, options.triangles.length, true);
+  view.setInt32(36, glCount, true);
+  view.setInt32(40, options.frames.length, true);
+  view.setInt32(44, offsetSkins, true);
+  view.setInt32(48, offsetTexCoords, true);
+  view.setInt32(52, offsetTriangles, true);
+  view.setInt32(56, offsetFrames, true);
+  view.setInt32(60, offsetGlCommands, true);
+  view.setInt32(64, offsetEnd, true);
+  skins.forEach((skin, index) => writeCString(view, offsetSkins + index * 64, skin, 64));
+  options.texCoords.forEach((coord, index) => {
+    const base = offsetTexCoords + index * 4;
+    view.setInt16(base, coord.s, true);
+    view.setInt16(base + 2, coord.t, true);
+  });
+  options.triangles.forEach((tri, index) => {
+    const base = offsetTriangles + index * 12;
+    view.setUint16(base, tri.vertexIndices[0], true);
+    view.setUint16(base + 2, tri.vertexIndices[1], true);
+    view.setUint16(base + 4, tri.vertexIndices[2], true);
+    view.setUint16(base + 6, tri.texCoordIndices[0], true);
+    view.setUint16(base + 8, tri.texCoordIndices[1], true);
+    view.setUint16(base + 10, tri.texCoordIndices[2], true);
+  });
+  new Uint8Array(view.buffer, offsetFrames, frameBlockSize).set(encodeFrames(options.frames, numVertices));
+  new Uint8Array(view.buffer, offsetGlCommands, glSize).set(glData);
+  return view.buffer;
+}
+
+// src/engine/builders/md3Builder.ts
+var HEADER_SIZE2 = 108;
+var FRAME_SIZE = 56;
+var TAG_SIZE = 112;
+var SURFACE_HEADER_SIZE = 108;
+function writeString(target, offset, text, length) {
+  const encoder = new TextEncoder();
+  const encoded = encoder.encode(text);
+  const bytes = new Uint8Array(target.buffer, target.byteOffset + offset, length);
+  bytes.fill(0);
+  bytes.set(encoded.subarray(0, length));
+}
+function buildSurface(buffer, offset, surface, numFrames) {
+  const view = new DataView(buffer);
+  writeString(view, offset + 4, surface.name, 64);
+  view.setInt32(offset, 860898377, true);
+  view.setInt32(offset + 72, numFrames, true);
+  view.setInt32(offset + 76, surface.shaders?.length ?? 0, true);
+  view.setInt32(offset + 80, surface.vertices[0]?.length ?? 0, true);
+  view.setInt32(offset + 84, surface.triangles.length, true);
+  let cursor = SURFACE_HEADER_SIZE;
+  view.setInt32(offset + 88, cursor, true);
+  for (const tri of surface.triangles) {
+    view.setInt32(offset + cursor, tri[0], true);
+    view.setInt32(offset + cursor + 4, tri[1], true);
+    view.setInt32(offset + cursor + 8, tri[2], true);
+    cursor += 12;
+  }
+  view.setInt32(offset + 92, cursor, true);
+  for (const shader of surface.shaders ?? []) {
+    writeString(view, offset + cursor, shader.name, 64);
+    view.setInt32(offset + cursor + 64, shader.index, true);
+    cursor += 68;
+  }
+  view.setInt32(offset + 96, cursor, true);
+  for (const tex of surface.texCoords) {
+    view.setFloat32(offset + cursor, tex.s, true);
+    view.setFloat32(offset + cursor + 4, tex.t, true);
+    cursor += 8;
+  }
+  view.setInt32(offset + 100, cursor, true);
+  for (const frame of surface.vertices) {
+    for (const vertex of frame) {
+      view.setInt16(offset + cursor, Math.round(vertex.position.x * 64), true);
+      view.setInt16(offset + cursor + 2, Math.round(vertex.position.y * 64), true);
+      view.setInt16(offset + cursor + 4, Math.round(vertex.position.z * 64), true);
+      view.setUint16(offset + cursor + 6, vertex.latLng, true);
+      cursor += 8;
+    }
+  }
+  view.setInt32(offset + 104, cursor, true);
+  return cursor;
+}
+function buildMd3(options) {
+  const numFrames = options.frames.length;
+  const numTags = options.tags?.length ?? 0;
+  const numSurfaces = options.surfaces.length;
+  let size = HEADER_SIZE2;
+  size += numFrames * FRAME_SIZE;
+  size += numFrames * numTags * TAG_SIZE;
+  for (const surface of options.surfaces) {
+    const verts = surface.vertices[0]?.length ?? 0;
+    const triangles = surface.triangles.length;
+    const shaders = surface.shaders?.length ?? 0;
+    const texCoordBytes = surface.texCoords.length * 8;
+    const surfaceSize = SURFACE_HEADER_SIZE + triangles * 12 + shaders * 68 + texCoordBytes + verts * 8 * numFrames;
+    size += surfaceSize;
+  }
+  const buffer = new ArrayBuffer(size);
+  const view = new DataView(buffer);
+  writeString(view, 8, options.name ?? "builder", 64);
+  view.setInt32(0, 860898377, true);
+  view.setInt32(4, 15, true);
+  view.setInt32(72, 0, true);
+  view.setInt32(76, numFrames, true);
+  view.setInt32(80, numTags, true);
+  view.setInt32(84, numSurfaces, true);
+  view.setInt32(88, 0, true);
+  let offset = HEADER_SIZE2;
+  view.setInt32(92, offset, true);
+  for (const frame of options.frames) {
+    view.setFloat32(offset, frame.min.x, true);
+    view.setFloat32(offset + 4, frame.min.y, true);
+    view.setFloat32(offset + 8, frame.min.z, true);
+    view.setFloat32(offset + 12, frame.max.x, true);
+    view.setFloat32(offset + 16, frame.max.y, true);
+    view.setFloat32(offset + 20, frame.max.z, true);
+    view.setFloat32(offset + 24, frame.origin.x, true);
+    view.setFloat32(offset + 28, frame.origin.y, true);
+    view.setFloat32(offset + 32, frame.origin.z, true);
+    view.setFloat32(offset + 36, frame.radius, true);
+    writeString(view, offset + 40, frame.name, 16);
+    offset += FRAME_SIZE;
+  }
+  view.setInt32(96, offset, true);
+  for (let frame = 0; frame < numFrames; frame += 1) {
+    for (const tag of options.tags ?? []) {
+      writeString(view, offset, tag.name, 64);
+      view.setFloat32(offset + 64, tag.origin.x, true);
+      view.setFloat32(offset + 68, tag.origin.y, true);
+      view.setFloat32(offset + 72, tag.origin.z, true);
+      for (let axis = 0; axis < 3; axis += 1) {
+        const v = tag.axis[axis];
+        view.setFloat32(offset + 76 + axis * 12, v.x, true);
+        view.setFloat32(offset + 80 + axis * 12, v.y, true);
+        view.setFloat32(offset + 84 + axis * 12, v.z, true);
+      }
+      offset += TAG_SIZE;
+    }
+  }
+  view.setInt32(100, offset, true);
+  for (let i = 0; i < options.surfaces.length; i += 1) {
+    const written = buildSurface(buffer, offset, options.surfaces[i], numFrames);
+    offset += written;
+  }
+  view.setInt32(104, offset, true);
+  return buffer;
+}
+
+// src/engine/builders/pakBuilder.ts
+var HEADER_SIZE3 = 12;
+var DIRECTORY_ENTRY_SIZE = 64;
+function buildPak(entries) {
+  let offset = HEADER_SIZE3;
+  const fileBuffers = [];
+  const directory = new Uint8Array(entries.length * DIRECTORY_ENTRY_SIZE);
+  const dirView = new DataView(directory.buffer);
+  entries.forEach((entry, index) => {
+    const data = entry.data;
+    fileBuffers.push(data);
+    const nameBytes = new TextEncoder().encode(entry.path);
+    directory.set(nameBytes.slice(0, 56), index * DIRECTORY_ENTRY_SIZE);
+    dirView.setInt32(index * DIRECTORY_ENTRY_SIZE + 56, offset, true);
+    dirView.setInt32(index * DIRECTORY_ENTRY_SIZE + 60, data.byteLength, true);
+    offset += data.byteLength;
+  });
+  const directoryOffset = offset;
+  const directoryLength = directory.byteLength;
+  const totalSize = HEADER_SIZE3 + fileBuffers.reduce((sum, buf) => sum + buf.byteLength, 0) + directoryLength;
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  const writer = new Uint8Array(buffer);
+  writer.set([80, 65, 67, 75]);
+  view.setInt32(4, directoryOffset, true);
+  view.setInt32(8, directoryLength, true);
+  let cursor = HEADER_SIZE3;
+  for (const data of fileBuffers) {
+    writer.set(data, cursor);
+    cursor += data.byteLength;
+  }
+  writer.set(directory, directoryOffset);
+  return buffer;
+}
+function textData(text) {
+  return new TextEncoder().encode(text);
+}
+
+// src/engine/builders/pcxBuilder.ts
+function buildPcx(options) {
+  const { width, height } = options;
+  const headerSize = 128;
+  const paletteSize = 769;
+  const encodedPixels = [];
+  for (const value of options.pixels) {
+    if (value >= 192) {
+      encodedPixels.push(193, value);
+    } else {
+      encodedPixels.push(value);
+    }
+  }
+  const imageSize = encodedPixels.length;
+  const buffer = new ArrayBuffer(headerSize + imageSize + paletteSize);
+  const view = new DataView(buffer);
+  view.setUint8(0, 10);
+  view.setUint8(1, 5);
+  view.setUint8(2, 1);
+  view.setUint8(3, 8);
+  view.setUint16(4, 0, true);
+  view.setUint16(6, 0, true);
+  view.setUint16(8, width - 1, true);
+  view.setUint16(10, height - 1, true);
+  view.setUint16(66, width, true);
+  const encoded = new Uint8Array(buffer, headerSize, imageSize);
+  encoded.set(encodedPixels);
+  const paletteMarkerOffset = headerSize + imageSize;
+  view.setUint8(paletteMarkerOffset, 12);
+  const palette = new Uint8Array(buffer, paletteMarkerOffset + 1, 768);
+  palette.fill(0);
+  if (options.palette) {
+    palette.set(options.palette.subarray(0, 768));
+  } else {
+    for (let i = 0; i < 256; i += 1) {
+      palette[i * 3] = i;
+      palette[i * 3 + 1] = 255 - i;
+      palette[i * 3 + 2] = i;
+    }
+  }
+  return buffer;
+}
+
+// src/engine/builders/walBuilder.ts
+function buildWal(options) {
+  const { width, height } = options;
+  const headerSize = 100;
+  const mipSizes = [
+    width * height,
+    Math.max(1, (width >> 1) * (height >> 1)),
+    Math.max(1, (width >> 2) * (height >> 2)),
+    Math.max(1, (width >> 3) * (height >> 3))
+  ];
+  const totalSize = headerSize + mipSizes.reduce((a, b) => a + b, 0);
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  const encoder = new TextEncoder();
+  new Uint8Array(buffer, 0, 32).set(encoder.encode(options.name));
+  view.setInt32(32, width, true);
+  view.setInt32(36, height, true);
+  let offset = headerSize;
+  mipSizes.forEach((size, index) => {
+    view.setInt32(40 + index * 4, offset, true);
+    const data = new Uint8Array(buffer, offset, size);
+    for (let i = 0; i < size; i += 1) {
+      data[i] = (i + index) % 256;
+    }
+    offset += size;
+  });
+  new Uint8Array(buffer, 56, 32).set(encoder.encode(options.name + "_anim"));
+  view.setInt32(88, 0, true);
+  view.setInt32(92, 0, true);
+  view.setInt32(96, 0, true);
+  return buffer;
+}
+
+// src/engine/builders/wavBuilder.ts
+function buildWav(options) {
+  const bitsPerSample = options.bitsPerSample ?? 16;
+  const bytesPerSample = bitsPerSample / 8;
+  const frameCount = options.samples.length / options.channels;
+  const dataSize = frameCount * options.channels * bytesPerSample;
+  const buffer = new ArrayBuffer(44 + dataSize);
+  const view = new DataView(buffer);
+  const writeString2 = (offset2, text) => {
+    new Uint8Array(buffer, offset2, text.length).set(new TextEncoder().encode(text));
+  };
+  writeString2(0, "RIFF");
+  view.setUint32(4, 36 + dataSize, true);
+  writeString2(8, "WAVE");
+  writeString2(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, options.channels, true);
+  view.setUint32(24, options.sampleRate, true);
+  view.setUint32(28, options.sampleRate * options.channels * bytesPerSample, true);
+  view.setUint16(32, options.channels * bytesPerSample, true);
+  view.setUint16(34, bitsPerSample, true);
+  writeString2(36, "data");
+  view.setUint32(40, dataSize, true);
+  let offset = 44;
+  for (let i = 0; i < options.samples.length; i += 1) {
+    const sample = options.samples[i];
+    if (bitsPerSample === 8) {
+      view.setUint8(offset, Math.max(0, Math.min(255, Math.round(sample * 128 + 128))));
+      offset += 1;
+    } else if (bitsPerSample === 16) {
+      view.setInt16(offset, Math.round(sample * 32767), true);
+      offset += 2;
+    } else {
+      throw new Error("Unsupported bit depth for builder");
+    }
+  }
+  return buffer;
+}
+
 // src/client/helpers/view.ts
 import { vec3 } from "gl-matrix";
 import { Camera } from "@quake2ts/engine";
@@ -5587,6 +6183,13 @@ export {
   ShaderProgram,
   VertexBuffer,
   ZERO_VEC3,
+  buildMd2,
+  buildMd3,
+  buildPak,
+  buildPcx,
+  buildTestBsp,
+  buildWal,
+  buildWav,
   captureAudioEvents,
   captureCanvasDrawCalls,
   captureFramebufferAsPNG,
@@ -5770,6 +6373,7 @@ export {
   createVisualTestScenario,
   createWebGLPlaywrightSetup,
   createWebGLRenderTestSetup,
+  encodedVisForClusters,
   expectAnimationSnapshot,
   expectNoDoubleTransform,
   expectRendererCalls,
@@ -5800,6 +6404,7 @@ export {
   renderAndExpectSnapshot,
   restoreSaveGameSnapshot,
   runComputeAndReadback,
+  runLengthVisRow,
   savePNG,
   serializeUserInfo,
   setupBrowserEnvironment,
@@ -5836,6 +6441,7 @@ export {
   testPipelineRendering,
   testWebGLAnimation,
   testWebGLRenderer,
+  textData,
   throttleBandwidth,
   verifySmoothing,
   verifySnapshotConsistency,