@quake2ts/test-utils 0.0.838 → 0.0.839

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quake2ts/test-utils",
-  "version": "0.0.838",
+  "version": "0.0.839",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -55,10 +55,10 @@
     "serve-handler": "^6.1.6",
     "vitest": "^1.6.0",
     "webgpu": "^0.3.8",
-    "@quake2ts/engine": "^0.0.838",
-    "@quake2ts/game": "0.0.838",
-    "@quake2ts/server": "0.0.838",
-    "@quake2ts/shared": "0.0.838"
+    "@quake2ts/engine": "^0.0.839",
+    "@quake2ts/game": "0.0.839",
+    "@quake2ts/shared": "0.0.839",
+    "@quake2ts/server": "0.0.839"
   },
   "peerDependenciesMeta": {
     "@quake2ts/engine": {
@@ -114,10 +114,10 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16",
     "webgpu": "^0.3.8",
-    "@quake2ts/engine": "^0.0.838",
-    "@quake2ts/game": "0.0.838",
-    "@quake2ts/shared": "0.0.838",
-    "@quake2ts/server": "0.0.838"
+    "@quake2ts/engine": "^0.0.839",
+    "@quake2ts/server": "0.0.839",
+    "@quake2ts/shared": "0.0.839",
+    "@quake2ts/game": "0.0.839"
   },
   "dependencies": {
     "upng-js": "^2.1.0"

package/src/engine/builders/bspBuilder.ts

@@ -0,0 +1,278 @@
+import { BspBrush, BspBrushSide, BspFace, BspLeaf, BspLump, BspModel, BspNode, BspPlane, BspTexInfo } from '@quake2ts/engine';
+
+type Vec3 = [number, number, number];
+
+const HEADER_LUMPS = 19;
+const HEADER_SIZE = 4 + 4 + HEADER_LUMPS * 8;
+
+function allocBuffer(size: number): DataView {
+  return new DataView(new ArrayBuffer(size));
+}
+
+function writeVec3(view: DataView, offset: number, vec: Vec3): void {
+  view.setFloat32(offset, vec[0], true);
+  view.setFloat32(offset + 4, vec[1], true);
+  view.setFloat32(offset + 8, vec[2], true);
+}
+
+function encodePlanes(planes: BspPlane[]): Uint8Array {
+  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: Vec3[]): Uint8Array {
+  const view = allocBuffer(vertices.length * 12);
+  vertices.forEach((vertex, index) => writeVec3(view, index * 12, vertex));
+  return new Uint8Array(view.buffer);
+}
+
+function encodeNodes(nodes: BspNode[]): Uint8Array {
+  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: BspTexInfo[]): Uint8Array {
+  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: BspFace[]): Uint8Array {
+  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: BspLeaf[]): Uint8Array {
+  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: Array<[number, number]>): Uint8Array {
+  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: BspModel[]): Uint8Array {
+  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: BspBrush[]): Uint8Array {
+  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: BspBrushSide[]): Uint8Array {
+  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 encodeAreas(areas: { numAreaPortals: number; firstAreaPortal: number }[]): Uint8Array {
+  const view = allocBuffer(areas.length * 8);
+  areas.forEach((area, index) => {
+    const base = index * 8;
+    view.setInt32(base, area.numAreaPortals, true);
+    view.setInt32(base + 4, area.firstAreaPortal, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+
+function encodeAreaPortals(portals: { portalNumber: number; otherArea: number }[]): Uint8Array {
+  const view = allocBuffer(portals.length * 8);
+  portals.forEach((portal, index) => {
+    const base = index * 8;
+    view.setInt32(base, portal.portalNumber, true);
+    view.setInt32(base + 4, portal.otherArea, true);
+  });
+  return new Uint8Array(view.buffer);
+}
+
+function encodeVisibility(numClusters: number, pvsRows: Uint8Array[], phsRows?: Uint8Array[]): Uint8Array {
+  const headerBytes = 4 + numClusters * 8;
+  const header = allocBuffer(headerBytes);
+  header.setInt32(0, numClusters, true);
+  let cursor = headerBytes;
+  const payloads: Uint8Array[] = [];
+
+  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;
+}
+
+export interface BspFixtureOptions {
+  readonly entities?: string;
+  readonly planes?: BspPlane[];
+  readonly vertices?: Vec3[];
+  readonly nodes?: BspNode[];
+  readonly texInfo?: BspTexInfo[];
+  readonly faces?: BspFace[];
+  readonly lighting?: Uint8Array;
+  readonly leafs?: BspLeaf[];
+  readonly leafFaces?: Uint16Array;
+  readonly leafBrushes?: Uint16Array;
+  readonly edges?: Array<[number, number]>;
+  readonly surfEdges?: Int32Array;
+  readonly models?: BspModel[];
+  readonly brushes?: BspBrush[];
+  readonly brushSides?: BspBrushSide[];
+  readonly visibility?: Uint8Array;
+  readonly areas?: Uint8Array;
+  readonly areaPortals?: Uint8Array;
+}
+
+export function buildTestBsp(options: BspFixtureOptions): ArrayBuffer {
+  const lumps: Record<number, Uint8Array> = {};
+  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: { info: { offset: number; length: number }; data: Uint8Array }[] = [];
+  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, 0x49); // I
+  header.setUint8(1, 0x42); // B
+  header.setUint8(2, 0x53); // S
+  header.setUint8(3, 0x50); // P
+  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;
+}
+
+export function runLengthVisRow(values: number[]): Uint8Array {
+  return new Uint8Array(values);
+}
+
+export function encodedVisForClusters(numClusters: number, rows: number[][]): Uint8Array {
+  const rowBytes = Math.ceil(numClusters / 8);
+  const encodedRows = rows.map((row) => new Uint8Array(row));
+  return encodeVisibility(numClusters, encodedRows);
+}

package/src/engine/builders/md2Builder.ts

@@ -0,0 +1,156 @@
+import { Vec3 } from '@quake2ts/shared/math/vec3';
+
+export interface Md2FrameVertexInput {
+  readonly position: Vec3;
+  readonly normalIndex: number;
+}
+
+export interface Md2FrameInput {
+  readonly name: string;
+  readonly vertices: readonly Md2FrameVertexInput[];
+  readonly scale?: Vec3;
+  readonly translate?: Vec3;
+}
+
+export interface Md2GlCommandVertexInput {
+  readonly s: number;
+  readonly t: number;
+  readonly vertexIndex: number;
+}
+
+export interface Md2GlCommandInput {
+  readonly mode: 'strip' | 'fan';
+  readonly vertices: readonly Md2GlCommandVertexInput[];
+}
+
+export interface Md2BuilderOptions {
+  readonly skins?: readonly string[];
+  readonly texCoords: readonly { s: number; t: number }[];
+  readonly triangles: readonly { vertexIndices: [number, number, number]; texCoordIndices: [number, number, number] }[];
+  readonly frames: readonly Md2FrameInput[];
+  readonly glCommands?: readonly Md2GlCommandInput[];
+  readonly skinWidth?: number;
+  readonly skinHeight?: number;
+}
+
+function allocBuffer(size: number): DataView {
+  return new DataView(new ArrayBuffer(size));
+}
+
+function writeCString(view: DataView, offset: number, text: string, max: number): void {
+  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: readonly Md2FrameInput[], numVertices: number): Uint8Array {
+  const frameSize = 40 + numVertices * 4;
+  const view = allocBuffer(frames.length * frameSize);
+  frames.forEach((frame, frameIndex) => {
+    const base = frameIndex * frameSize;
+    const scale: Vec3 = frame.scale ?? { x: 1, y: 1, z: 1 };
+    const translate: Vec3 = 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: readonly Md2GlCommandInput[] | undefined): { data: Uint8Array; count: number } {
+  const bytes: number[] = [];
+  (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 };
+}
+
+export function buildMd2(options: Md2BuilderOptions): ArrayBuffer {
+  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 = allocBuffer(offsetEnd);
+  view.setInt32(0, 844121161, true); // IDP2
+  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 as ArrayBuffer;
+}

package/src/engine/builders/md3Builder.ts

@@ -0,0 +1,149 @@
+import { Vec3 } from '@quake2ts/shared';
+
+interface Md3SurfaceSpec {
+  readonly name: string;
+  readonly triangles: readonly [number, number, number][];
+  readonly texCoords: readonly { s: number; t: number }[];
+  readonly vertices: readonly (readonly { position: Vec3; latLng: number }[])[];
+  readonly shaders?: readonly { name: string; index: number }[];
+}
+
+interface Md3BuildOptions {
+  readonly name?: string;
+  readonly frames: readonly { min: Vec3; max: Vec3; origin: Vec3; radius: number; name: string }[];
+  readonly tags?: readonly { name: string; origin: Vec3; axis: readonly [Vec3, Vec3, Vec3] }[];
+  readonly surfaces: readonly Md3SurfaceSpec[];
+}
+
+const HEADER_SIZE = 108;
+const FRAME_SIZE = 56;
+const TAG_SIZE = 112;
+const SURFACE_HEADER_SIZE = 108;
+
+function writeString(target: DataView, offset: number, text: string, length: number): void {
+  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: ArrayBuffer, offset: number, surface: Md3SurfaceSpec, numFrames: number): number {
+  const view = new DataView(buffer);
+  writeString(view, offset + 4, surface.name, 64);
+  view.setInt32(offset, 0x33504449, 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;
+}
+
+export function buildMd3(options: Md3BuildOptions): ArrayBuffer {
+  const numFrames = options.frames.length;
+  const numTags = options.tags?.length ?? 0;
+  const numSurfaces = options.surfaces.length;
+
+  let size = HEADER_SIZE;
+  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, 0x33504449, 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_SIZE;
+  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;
+}

package/src/engine/builders/pakBuilder.ts

@@ -0,0 +1,50 @@
+export interface PakEntrySpec {
+  path: string;
+  data: Uint8Array;
+}
+
+const HEADER_SIZE = 12;
+const DIRECTORY_ENTRY_SIZE = 64;
+
+export function buildPak(entries: PakEntrySpec[]): ArrayBuffer {
+  let offset = HEADER_SIZE;
+  const fileBuffers: Uint8Array[] = [];
+  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_SIZE + 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([0x50, 0x41, 0x43, 0x4b]);
+  view.setInt32(4, directoryOffset, true);
+  view.setInt32(8, directoryLength, true);
+
+  let cursor = HEADER_SIZE;
+  for (const data of fileBuffers) {
+    writer.set(data, cursor);
+    cursor += data.byteLength;
+  }
+
+  writer.set(directory, directoryOffset);
+  return buffer;
+}
+
+export function textData(text: string): Uint8Array {
+  return new TextEncoder().encode(text);
+}