quake2ts 0.0.44 → 0.0.46

package/packages/engine/dist/cjs/index.cjs

@@ -49,19 +49,28 @@ __export(index_exports, {
   MAX_SOUND_CHANNELS: () => MAX_SOUND_CHANNELS,
   MD2_FRAGMENT_SHADER: () => MD2_FRAGMENT_SHADER,
   MD2_VERTEX_SHADER: () => MD2_VERTEX_SHADER,
+  MD3_FRAGMENT_SHADER: () => MD3_FRAGMENT_SHADER,
+  MD3_VERTEX_SHADER: () => MD3_VERTEX_SHADER,
   Md2Loader: () => Md2Loader,
   Md2MeshBuffers: () => Md2MeshBuffers,
   Md2ParseError: () => Md2ParseError,
   Md2Pipeline: () => Md2Pipeline,
   Md3Loader: () => Md3Loader,
+  Md3ModelMesh: () => Md3ModelMesh,
   Md3ParseError: () => Md3ParseError,
+  Md3Pipeline: () => Md3Pipeline,
+  Md3SurfaceMesh: () => Md3SurfaceMesh,
   MusicSystem: () => MusicSystem,
+  PARTICLE_FRAGMENT_SHADER: () => PARTICLE_FRAGMENT_SHADER,
+  PARTICLE_VERTEX_SHADER: () => PARTICLE_VERTEX_SHADER,
   PakArchive: () => PakArchive,
   PakIndexStore: () => PakIndexStore,
   PakIngestionError: () => PakIngestionError,
   PakParseError: () => PakParseError,
   PakValidationError: () => PakValidationError,
   PakValidator: () => PakValidator,
+  ParticleRenderer: () => ParticleRenderer,
+  ParticleSystem: () => ParticleSystem,
   RERELEASE_KNOWN_PAKS: () => RERELEASE_KNOWN_PAKS,
   SKYBOX_FRAGMENT_SHADER: () => SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER: () => SKYBOX_VERTEX_SHADER,
@@ -85,6 +94,8 @@ __export(index_exports, {
   buildBspGeometry: () => buildBspGeometry,
   buildMd2Geometry: () => buildMd2Geometry,
   buildMd2VertexData: () => buildMd2VertexData,
+  buildMd3SurfaceGeometry: () => buildMd3SurfaceGeometry,
+  buildMd3VertexData: () => buildMd3VertexData,
   calculateMaxAudibleDistance: () => calculateMaxAudibleDistance,
   calculatePakChecksum: () => calculatePakChecksum,
   computeFrameBlend: () => computeFrameBlend,
@@ -105,6 +116,7 @@ __export(index_exports, {
   groupMd2Animations: () => groupMd2Animations,
   ingestPakFiles: () => ingestPakFiles,
   ingestPaks: () => ingestPaks,
+  interpolateMd3Tag: () => interpolateMd3Tag,
   interpolateVec3: () => interpolateVec3,
   parseMd2: () => parseMd2,
   parseMd3: () => parseMd3,
@@ -118,6 +130,12 @@ __export(index_exports, {
   removeViewTranslation: () => removeViewTranslation,
   resolveLightStyles: () => resolveLightStyles,
   spatializeOrigin: () => spatializeOrigin,
+  spawnBlood: () => spawnBlood,
+  spawnBulletImpact: () => spawnBulletImpact,
+  spawnExplosion: () => spawnExplosion,
+  spawnMuzzleFlash: () => spawnMuzzleFlash,
+  spawnTeleportFlash: () => spawnTeleportFlash,
+  spawnTrail: () => spawnTrail,
   walToRgba: () => walToRgba,
   wireDropTarget: () => wireDropTarget,
   wireFileInput: () => wireFileInput
@@ -279,6 +297,52 @@ function normalizeVec3(a) {
 }
 var DEG2RAD_FACTOR = Math.PI / 180;
 var RAD2DEG_FACTOR = 180 / Math.PI;
+function createMat4Identity() {
+  return new Float32Array([
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function transformPointMat4(mat, point) {
+  const x = point.x;
+  const y = point.y;
+  const z = point.z;
+  return {
+    x: mat[0] * x + mat[4] * y + mat[8] * z + mat[12],
+    y: mat[1] * x + mat[5] * y + mat[9] * z + mat[13],
+    z: mat[2] * x + mat[6] * y + mat[10] * z + mat[14]
+  };
+}
+function mat4FromBasis(origin, axis) {
+  const out = createMat4Identity();
+  out[0] = axis[0].x;
+  out[1] = axis[0].y;
+  out[2] = axis[0].z;
+  out[4] = axis[1].x;
+  out[5] = axis[1].y;
+  out[6] = axis[1].z;
+  out[8] = axis[2].x;
+  out[9] = axis[2].y;
+  out[10] = axis[2].z;
+  out[12] = origin.x;
+  out[13] = origin.y;
+  out[14] = origin.z;
+  return out;
+}
 var CONTENTS_SOLID = 1 << 0;
 var CONTENTS_WINDOW = 1 << 1;
 var CONTENTS_AUX = 1 << 2;
@@ -1740,8 +1804,8 @@ function computeFrameBlend(state) {
   const baseFrame = Math.floor(normalizedPosition);
   const frame = state.sequence.start + baseFrame;
   const nextFrame = baseFrame + 1 >= totalFrames ? loop ? state.sequence.start : state.sequence.end : frame + 1;
-  const lerp2 = !loop && baseFrame >= totalFrames - 1 ? 0 : normalizedPosition - baseFrame;
-  return { frame, nextFrame, lerp: lerp2 };
+  const lerp3 = !loop && baseFrame >= totalFrames - 1 ? 0 : normalizedPosition - baseFrame;
+  return { frame, nextFrame, lerp: lerp3 };
 }
 function createAnimationState(sequence) {
   return { sequence, time: 0 };
@@ -4015,7 +4079,7 @@ function buildMd2Geometry(model) {
   return { vertices, indices: new Uint16Array(indices) };
 }
 function buildMd2VertexData(model, geometry, blend) {
-  const { currentFrame, nextFrame, lerp: lerp2 } = blend;
+  const { currentFrame, nextFrame, lerp: lerp3 } = blend;
   const frameA = model.frames[currentFrame];
   const frameB = model.frames[nextFrame];
   if (!frameA || !frameB) {
@@ -4028,8 +4092,8 @@ function buildMd2VertexData(model, geometry, blend) {
     if (!vA || !vB) {
       throw new Error("MD2 vertex index out of range for frame");
     }
-    const position = lerpVec3(vA.position, vB.position, lerp2);
-    const normal = normalizeVec32(lerpVec3(vA.normal, vB.normal, lerp2));
+    const position = lerpVec3(vA.position, vB.position, lerp3);
+    const normal = normalizeVec32(lerpVec3(vA.normal, vB.normal, lerp3));
     const base = index * 8;
     data[base] = position.x;
     data[base + 1] = position.y;
@@ -4109,6 +4173,700 @@ var Md2Pipeline = class {
   }
 };
 
+// src/render/md3Pipeline.ts
+var DEFAULT_AMBIENT = [0.2, 0.2, 0.2];
+var DEFAULT_DIRECTION = { x: 0, y: 0, z: 1 };
+var DEFAULT_DIRECTION_COLOR = [0.8, 0.8, 0.8];
+function lerp2(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpVec32(a, b, t) {
+  return { x: lerp2(a.x, b.x, t), y: lerp2(a.y, b.y, t), z: lerp2(a.z, b.z, t) };
+}
+function clamp012(v) {
+  if (v < 0) return 0;
+  if (v > 1) return 1;
+  return v;
+}
+function buildMd3SurfaceGeometry(surface) {
+  const vertices = [];
+  const indices = [];
+  for (const tri of surface.triangles) {
+    const base = vertices.length;
+    const [a, b, c] = tri.indices;
+    const texA = surface.texCoords[a];
+    const texB = surface.texCoords[b];
+    const texC = surface.texCoords[c];
+    if (!texA || !texB || !texC) {
+      throw new Error(`Missing texCoord for triangle in surface ${surface.name}`);
+    }
+    vertices.push(
+      { vertexIndex: a, texCoord: [texA.s, 1 - texA.t] },
+      { vertexIndex: b, texCoord: [texB.s, 1 - texB.t] },
+      { vertexIndex: c, texCoord: [texC.s, 1 - texC.t] }
+    );
+    indices.push(base, base + 1, base + 2);
+  }
+  return { vertices, indices: new Uint16Array(indices) };
+}
+function evaluateLighting(normal, position, lighting) {
+  const ambient = lighting?.ambient ?? DEFAULT_AMBIENT;
+  const directional = lighting?.directional ?? { direction: DEFAULT_DIRECTION, color: DEFAULT_DIRECTION_COLOR };
+  const n = normalizeVec3(normal);
+  const l = normalizeVec3(directional.direction);
+  const ndotl = clamp012(n.x * l.x + n.y * l.y + n.z * l.z);
+  let r = ambient[0] + directional.color[0] * ndotl;
+  let g = ambient[1] + directional.color[1] * ndotl;
+  let b = ambient[2] + directional.color[2] * ndotl;
+  if (lighting?.dynamicLights) {
+    const worldPos = lighting.modelMatrix ? transformPointMat4(lighting.modelMatrix, position) : position;
+    for (const light of lighting.dynamicLights) {
+      const dx = worldPos.x - light.origin.x;
+      const dy = worldPos.y - light.origin.y;
+      const dz = worldPos.z - light.origin.z;
+      const distSq = dx * dx + dy * dy + dz * dz;
+      const radiusSq = light.radius * light.radius;
+      if (distSq < radiusSq && radiusSq > 0) {
+        const attenuation = 1 - Math.sqrt(distSq) / light.radius;
+        const amount = clamp012(attenuation * ndotl);
+        r += light.color[0] * amount;
+        g += light.color[1] * amount;
+        b += light.color[2] * amount;
+      }
+    }
+  }
+  return [clamp012(r), clamp012(g), clamp012(b)];
+}
+function buildMd3VertexData(surface, geometry, blend, lighting) {
+  const frameA = surface.vertices[blend.currentFrame];
+  const frameB = surface.vertices[blend.nextFrame];
+  if (!frameA || !frameB) {
+    throw new Error("Requested MD3 frames are out of range");
+  }
+  const data = new Float32Array(geometry.vertices.length * 12);
+  geometry.vertices.forEach((vertex, index) => {
+    const vA = frameA[vertex.vertexIndex];
+    const vB = frameB[vertex.vertexIndex];
+    if (!vA || !vB) {
+      throw new Error(`Vertex index ${vertex.vertexIndex} missing for frame`);
+    }
+    const position = lerpVec32(vA.position, vB.position, blend.lerp);
+    const normal = normalizeVec3(lerpVec32(vA.normal, vB.normal, blend.lerp));
+    const color = evaluateLighting(normal, position, lighting);
+    const base = index * 12;
+    data[base] = position.x;
+    data[base + 1] = position.y;
+    data[base + 2] = position.z;
+    data[base + 3] = normal.x;
+    data[base + 4] = normal.y;
+    data[base + 5] = normal.z;
+    data[base + 6] = vertex.texCoord[0];
+    data[base + 7] = vertex.texCoord[1];
+    data[base + 8] = color[0];
+    data[base + 9] = color[1];
+    data[base + 10] = color[2];
+    data[base + 11] = 1;
+  });
+  return data;
+}
+function interpolateMd3Tag(model, blend, tagName) {
+  const firstFrameTags = model.tags[0];
+  if (!firstFrameTags) {
+    return null;
+  }
+  const tagIndex = firstFrameTags.findIndex((tag) => tag.name === tagName);
+  if (tagIndex === -1) {
+    return null;
+  }
+  const tagA = model.tags[blend.currentFrame]?.[tagIndex];
+  const tagB = model.tags[blend.nextFrame]?.[tagIndex];
+  if (!tagA || !tagB) {
+    throw new Error(`Tag ${tagName} is missing for one of the interpolated frames`);
+  }
+  const origin = lerpVec32(tagA.origin, tagB.origin, blend.lerp);
+  const axis0 = normalizeVec3(lerpVec32(tagA.axis[0], tagB.axis[0], blend.lerp));
+  const axis1 = normalizeVec3(lerpVec32(tagA.axis[1], tagB.axis[1], blend.lerp));
+  const axis2 = normalizeVec3(lerpVec32(tagA.axis[2], tagB.axis[2], blend.lerp));
+  const corrected0 = axis0;
+  const corrected1 = normalizeVec3({
+    x: axis1.x - corrected0.x * (corrected0.x * axis1.x + corrected0.y * axis1.y + corrected0.z * axis1.z),
+    y: axis1.y - corrected0.y * (corrected0.x * axis1.x + corrected0.y * axis1.y + corrected0.z * axis1.z),
+    z: axis1.z - corrected0.z * (corrected0.x * axis1.x + corrected0.y * axis1.y + corrected0.z * axis1.z)
+  });
+  const corrected2 = normalizeVec3({
+    x: corrected0.y * corrected1.z - corrected0.z * corrected1.y,
+    y: corrected0.z * corrected1.x - corrected0.x * corrected1.z,
+    z: corrected0.x * corrected1.y - corrected0.y * corrected1.x
+  });
+  const axis = [corrected0, corrected1, corrected2];
+  return { origin, axis, matrix: mat4FromBasis(origin, axis) };
+}
+var MD3_VERTEX_SHADER = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec3 a_normal;
+layout(location = 2) in vec2 a_texCoord;
+layout(location = 3) in vec4 a_color;
+
+uniform mat4 u_modelViewProjection;
+
+out vec2 v_texCoord;
+out vec4 v_color;
+
+void main() {
+  v_texCoord = a_texCoord;
+  v_color = a_color;
+  gl_Position = u_modelViewProjection * vec4(a_position, 1.0);
+}`;
+var MD3_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 v_texCoord;
+in vec4 v_color;
+
+uniform sampler2D u_diffuseMap;
+uniform vec4 u_tint;
+
+out vec4 o_color;
+
+void main() {
+  vec4 albedo = texture(u_diffuseMap, v_texCoord) * u_tint;
+  o_color = vec4(albedo.rgb * v_color.rgb, albedo.a * v_color.a);
+}`;
+var Md3SurfaceMesh = class {
+  constructor(gl, surface, blend, lighting) {
+    this.gl = gl;
+    this.geometry = buildMd3SurfaceGeometry(surface);
+    this.vertexBuffer = new VertexBuffer(gl, gl.STATIC_DRAW);
+    this.indexBuffer = new IndexBuffer(gl, gl.STATIC_DRAW);
+    this.vertexArray = new VertexArray(gl);
+    this.indexCount = this.geometry.indices.length;
+    this.vertexArray.configureAttributes(
+      [
+        { index: 0, size: 3, type: gl.FLOAT, stride: 48, offset: 0 },
+        { index: 1, size: 3, type: gl.FLOAT, stride: 48, offset: 12 },
+        { index: 2, size: 2, type: gl.FLOAT, stride: 48, offset: 24 },
+        { index: 3, size: 4, type: gl.FLOAT, stride: 48, offset: 32 }
+      ],
+      this.vertexBuffer
+    );
+    this.vertexArray.bind();
+    this.indexBuffer.bind();
+    this.indexBuffer.upload(this.geometry.indices, gl.STATIC_DRAW);
+    this.update(surface, blend, lighting);
+  }
+  update(surface, blend, lighting) {
+    const data = buildMd3VertexData(surface, this.geometry, blend, lighting);
+    this.vertexBuffer.upload(data, this.gl.STATIC_DRAW);
+  }
+  bind() {
+    this.vertexArray.bind();
+    this.indexBuffer.bind();
+  }
+  dispose() {
+    this.vertexBuffer.dispose();
+    this.indexBuffer.dispose();
+    this.vertexArray.dispose();
+  }
+};
+var Md3ModelMesh = class {
+  constructor(gl, model, blend, lighting) {
+    this.surfaces = /* @__PURE__ */ new Map();
+    this.gl = gl;
+    this.model = model;
+    this.blend = blend;
+    this.lighting = lighting;
+    model.surfaces.forEach((surface) => {
+      this.surfaces.set(surface.name, new Md3SurfaceMesh(gl, surface, blend, lighting));
+    });
+  }
+  update(blend, lighting) {
+    this.blend = blend;
+    this.lighting = lighting ?? this.lighting;
+    for (const surface of this.model.surfaces) {
+      const mesh = this.surfaces.get(surface.name);
+      mesh?.update(surface, blend, this.lighting);
+    }
+  }
+  dispose() {
+    for (const mesh of this.surfaces.values()) {
+      mesh.dispose();
+    }
+    this.surfaces.clear();
+  }
+};
+var Md3Pipeline = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.program = ShaderProgram.create(
+      gl,
+      { vertex: MD3_VERTEX_SHADER, fragment: MD3_FRAGMENT_SHADER },
+      { a_position: 0, a_normal: 1, a_texCoord: 2, a_color: 3 }
+    );
+    this.uniformMvp = this.program.getUniformLocation("u_modelViewProjection");
+    this.uniformTint = this.program.getUniformLocation("u_tint");
+    this.uniformDiffuse = this.program.getUniformLocation("u_diffuseMap");
+  }
+  bind(modelViewProjection, tint = [1, 1, 1, 1], sampler = 0) {
+    this.program.use();
+    this.gl.uniformMatrix4fv(this.uniformMvp, false, modelViewProjection);
+    this.gl.uniform4fv(this.uniformTint, new Float32Array(tint));
+    this.gl.uniform1i(this.uniformDiffuse, sampler);
+  }
+  drawSurface(mesh, material) {
+    const sampler = material?.diffuseSampler ?? 0;
+    const tint = material?.tint ?? [1, 1, 1, 1];
+    this.gl.uniform4fv(this.uniformTint, new Float32Array(tint));
+    this.gl.uniform1i(this.uniformDiffuse, sampler);
+    mesh.bind();
+    this.gl.drawElements(this.gl.TRIANGLES, mesh.indexCount, this.gl.UNSIGNED_SHORT, 0);
+  }
+  dispose() {
+    this.program.dispose();
+  }
+};
+
+// src/render/particleSystem.ts
+var DEFAULT_COLOR = [1, 1, 1, 1];
+var ParticleSystem = class {
+  // 0 alpha, 1 additive
+  constructor(maxParticles, random = Math.random) {
+    this.maxParticles = maxParticles;
+    this.random = random;
+    this.alive = new Uint8Array(maxParticles);
+    this.positionX = new Float32Array(maxParticles);
+    this.positionY = new Float32Array(maxParticles);
+    this.positionZ = new Float32Array(maxParticles);
+    this.velocityX = new Float32Array(maxParticles);
+    this.velocityY = new Float32Array(maxParticles);
+    this.velocityZ = new Float32Array(maxParticles);
+    this.colorR = new Float32Array(maxParticles);
+    this.colorG = new Float32Array(maxParticles);
+    this.colorB = new Float32Array(maxParticles);
+    this.colorA = new Float32Array(maxParticles);
+    this.size = new Float32Array(maxParticles);
+    this.lifetime = new Float32Array(maxParticles);
+    this.remaining = new Float32Array(maxParticles);
+    this.gravity = new Float32Array(maxParticles);
+    this.damping = new Float32Array(maxParticles);
+    this.bounce = new Float32Array(maxParticles);
+    this.fade = new Uint8Array(maxParticles);
+    this.blendMode = new Uint8Array(maxParticles);
+  }
+  spawn(options) {
+    const index = this.findFreeSlot();
+    if (index === -1) {
+      return null;
+    }
+    const color = options.color ?? DEFAULT_COLOR;
+    const velocity = options.velocity ?? { x: 0, y: 0, z: 0 };
+    this.alive[index] = 1;
+    this.positionX[index] = options.position.x;
+    this.positionY[index] = options.position.y;
+    this.positionZ[index] = options.position.z;
+    this.velocityX[index] = velocity.x;
+    this.velocityY[index] = velocity.y;
+    this.velocityZ[index] = velocity.z;
+    this.colorR[index] = color[0];
+    this.colorG[index] = color[1];
+    this.colorB[index] = color[2];
+    this.colorA[index] = color[3];
+    this.size[index] = options.size ?? 2.5;
+    this.lifetime[index] = options.lifetime;
+    this.remaining[index] = options.lifetime;
+    this.gravity[index] = options.gravity ?? 800;
+    this.damping[index] = options.damping ?? 0;
+    this.bounce[index] = options.bounce ?? 0.25;
+    this.fade[index] = options.fade ? 1 : 0;
+    this.blendMode[index] = options.blendMode === "additive" ? 1 : 0;
+    return index;
+  }
+  update(dt, options = {}) {
+    const floorZ = options.floorZ ?? -Infinity;
+    for (let i = 0; i < this.maxParticles; i += 1) {
+      if (!this.alive[i]) {
+        continue;
+      }
+      this.remaining[i] -= dt;
+      if (this.remaining[i] <= 0) {
+        this.alive[i] = 0;
+        continue;
+      }
+      const damping = Math.max(0, 1 - this.damping[i] * dt);
+      this.velocityX[i] *= damping;
+      this.velocityY[i] *= damping;
+      this.velocityZ[i] = this.velocityZ[i] * damping - this.gravity[i] * dt;
+      this.positionX[i] += this.velocityX[i] * dt;
+      this.positionY[i] += this.velocityY[i] * dt;
+      this.positionZ[i] += this.velocityZ[i] * dt;
+      if (this.positionZ[i] < floorZ) {
+        this.positionZ[i] = floorZ;
+        this.velocityZ[i] = -this.velocityZ[i] * this.bounce[i];
+        this.velocityX[i] *= 0.7;
+        this.velocityY[i] *= 0.7;
+      }
+    }
+  }
+  killAll() {
+    this.alive.fill(0);
+  }
+  aliveCount() {
+    let count = 0;
+    for (let i = 0; i < this.maxParticles; i += 1) {
+      if (this.alive[i]) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  getState(index) {
+    return {
+      alive: this.alive[index] === 1,
+      position: {
+        x: this.positionX[index],
+        y: this.positionY[index],
+        z: this.positionZ[index]
+      },
+      velocity: {
+        x: this.velocityX[index],
+        y: this.velocityY[index],
+        z: this.velocityZ[index]
+      },
+      remaining: this.remaining[index],
+      color: [this.colorR[index], this.colorG[index], this.colorB[index], this.colorA[index]],
+      size: this.size[index],
+      blendMode: this.blendMode[index] === 1 ? "additive" : "alpha"
+    };
+  }
+  buildMesh(viewRight, viewUp) {
+    const vertices = [];
+    const indices = [];
+    const batches = [];
+    const buildBatch = (mode) => {
+      const startIndex = indices.length;
+      let particleCount = 0;
+      for (let i = 0; i < this.maxParticles; i += 1) {
+        if (!this.alive[i]) {
+          continue;
+        }
+        if ((mode === "additive" ? 1 : 0) !== this.blendMode[i]) {
+          continue;
+        }
+        particleCount += 1;
+        const baseVertex = vertices.length / 9;
+        const size = this.size[i] * 0.5;
+        const fade = this.fade[i] ? Math.max(this.remaining[i] / this.lifetime[i], 0) : 1;
+        const colorScale = this.blendMode[i] === 1 ? 1.2 : 1;
+        const cR = this.colorR[i] * colorScale;
+        const cG = this.colorG[i] * colorScale;
+        const cB = this.colorB[i] * colorScale;
+        const cA = this.colorA[i] * fade;
+        const px = this.positionX[i];
+        const py = this.positionY[i];
+        const pz = this.positionZ[i];
+        const rightX = viewRight.x * size;
+        const rightY = viewRight.y * size;
+        const rightZ = viewRight.z * size;
+        const upX = viewUp.x * size;
+        const upY = viewUp.y * size;
+        const upZ = viewUp.z * size;
+        const corners = [
+          { x: px - rightX - upX, y: py - rightY - upY, z: pz - rightZ - upZ },
+          { x: px + rightX - upX, y: py + rightY - upY, z: pz + rightZ - upZ },
+          { x: px - rightX + upX, y: py - rightY + upY, z: pz - rightZ + upZ },
+          { x: px + rightX + upX, y: py + rightY + upY, z: pz + rightZ + upZ }
+        ];
+        const uvs = [
+          [0, 1],
+          [1, 1],
+          [0, 0],
+          [1, 0]
+        ];
+        corners.forEach((corner, cornerIndex) => {
+          vertices.push(
+            corner.x,
+            corner.y,
+            corner.z,
+            uvs[cornerIndex]?.[0] ?? 0,
+            uvs[cornerIndex]?.[1] ?? 0,
+            cR,
+            cG,
+            cB,
+            cA
+          );
+        });
+        indices.push(baseVertex, baseVertex + 1, baseVertex + 2, baseVertex + 2, baseVertex + 1, baseVertex + 3);
+      }
+      if (particleCount > 0) {
+        batches.push({ blendMode: mode, start: startIndex, count: indices.length - startIndex });
+      }
+    };
+    buildBatch("alpha");
+    buildBatch("additive");
+    return { vertices: new Float32Array(vertices), indices: new Uint16Array(indices), batches };
+  }
+  findFreeSlot() {
+    for (let i = 0; i < this.maxParticles; i += 1) {
+      if (!this.alive[i]) {
+        return i;
+      }
+    }
+    return -1;
+  }
+};
+var PARTICLE_VERTEX_SHADER = `#version 300 es
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+layout(location = 1) in vec2 a_uv;
+layout(location = 2) in vec4 a_color;
+
+uniform mat4 u_viewProjection;
+
+out vec2 v_uv;
+out vec4 v_color;
+
+void main() {
+  v_uv = a_uv;
+  v_color = a_color;
+  gl_Position = u_viewProjection * vec4(a_position, 1.0);
+}`;
+var PARTICLE_FRAGMENT_SHADER = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+in vec4 v_color;
+
+out vec4 o_color;
+
+void main() {
+  float dist = distance(v_uv, vec2(0.5));
+  float alpha = v_color.a * (1.0 - smoothstep(0.35, 0.5, dist));
+  o_color = vec4(v_color.rgb, alpha);
+}`;
+var ParticleRenderer = class {
+  constructor(gl, system) {
+    this.vertexCapacity = 0;
+    this.indexCapacity = 0;
+    this.gl = gl;
+    this.system = system;
+    this.program = ShaderProgram.create(gl, { vertex: PARTICLE_VERTEX_SHADER, fragment: PARTICLE_FRAGMENT_SHADER });
+    this.vertexBuffer = new VertexBuffer(gl, gl.DYNAMIC_DRAW);
+    this.indexBuffer = new IndexBuffer(gl, gl.DYNAMIC_DRAW);
+    this.vertexArray = new VertexArray(gl);
+    this.vertexArray.configureAttributes(
+      [
+        { index: 0, size: 3, type: gl.FLOAT, stride: 36, offset: 0 },
+        { index: 1, size: 2, type: gl.FLOAT, stride: 36, offset: 12 },
+        { index: 2, size: 4, type: gl.FLOAT, stride: 36, offset: 20 }
+      ],
+      this.vertexBuffer
+    );
+  }
+  render(options) {
+    const mesh = this.system.buildMesh(options.viewRight, options.viewUp);
+    if (mesh.indices.length === 0) {
+      return;
+    }
+    const vertexData = mesh.vertices;
+    if (mesh.vertices.byteLength > this.vertexCapacity) {
+      this.vertexCapacity = mesh.vertices.byteLength;
+      this.vertexBuffer.upload(vertexData, this.gl.DYNAMIC_DRAW);
+    } else {
+      this.vertexBuffer.update(vertexData);
+    }
+    const indexData = mesh.indices;
+    if (mesh.indices.byteLength > this.indexCapacity) {
+      this.indexCapacity = mesh.indices.byteLength;
+      this.indexBuffer.upload(indexData, this.gl.DYNAMIC_DRAW);
+    } else {
+      this.indexBuffer.update(indexData);
+    }
+    this.gl.depthMask(false);
+    this.program.use();
+    const vp = this.program.getUniformLocation("u_viewProjection");
+    this.gl.uniformMatrix4fv(vp, false, options.viewProjection);
+    this.vertexArray.bind();
+    for (const batch of mesh.batches) {
+      if (batch.blendMode === "additive") {
+        this.gl.blendFunc(this.gl.SRC_ALPHA, this.gl.ONE);
+      } else {
+        this.gl.blendFuncSeparate(
+          this.gl.SRC_ALPHA,
+          this.gl.ONE_MINUS_SRC_ALPHA,
+          this.gl.ONE,
+          this.gl.ONE_MINUS_SRC_ALPHA
+        );
+      }
+      this.gl.drawElements(this.gl.TRIANGLES, batch.count, this.gl.UNSIGNED_SHORT, batch.start * 2);
+    }
+    this.gl.depthMask(true);
+  }
+  dispose() {
+    this.program.dispose();
+    this.vertexBuffer.dispose();
+    this.indexBuffer.dispose();
+    this.vertexArray.dispose();
+  }
+};
+function spawnBulletImpact(context) {
+  const { system, origin, normal = { x: 0, y: 0, z: 1 } } = context;
+  for (let i = 0; i < 12; i += 1) {
+    const speed = 200 + system.random() * 180;
+    const spread = system.random() * 0.35;
+    system.spawn({
+      position: origin,
+      velocity: {
+        x: normal.x * speed + (system.random() - 0.5) * 80,
+        y: normal.y * speed + (system.random() - 0.5) * 80,
+        z: Math.max(normal.z * speed, 120) + spread * 80
+      },
+      color: [1, 0.8, 0.4, 1],
+      size: 2.5,
+      lifetime: 0.45 + system.random() * 0.1,
+      gravity: 600,
+      damping: 2,
+      bounce: 0.45,
+      blendMode: "additive",
+      fade: true
+    });
+  }
+  for (let i = 0; i < 8; i += 1) {
+    system.spawn({
+      position: origin,
+      velocity: { x: (system.random() - 0.5) * 40, y: (system.random() - 0.5) * 40, z: 80 + system.random() * 40 },
+      color: [0.45, 0.45, 0.45, 0.75],
+      size: 6,
+      lifetime: 0.6,
+      gravity: 200,
+      damping: 4,
+      bounce: 0.15,
+      blendMode: "alpha",
+      fade: true
+    });
+  }
+}
+function spawnExplosion(context) {
+  const { system, origin } = context;
+  for (let i = 0; i < 40; i += 1) {
+    const theta = system.random() * Math.PI * 2;
+    const phi = Math.acos(2 * system.random() - 1);
+    const speed = 220 + system.random() * 260;
+    const dir = {
+      x: Math.sin(phi) * Math.cos(theta),
+      y: Math.sin(phi) * Math.sin(theta),
+      z: Math.cos(phi)
+    };
+    system.spawn({
+      position: origin,
+      velocity: { x: dir.x * speed, y: dir.y * speed, z: dir.z * speed },
+      color: [1, 0.6, 0.2, 1],
+      size: 5,
+      lifetime: 0.9,
+      gravity: 700,
+      damping: 1,
+      bounce: 0.35,
+      blendMode: "additive",
+      fade: true
+    });
+  }
+  for (let i = 0; i < 16; i += 1) {
+    system.spawn({
+      position: origin,
+      velocity: { x: (system.random() - 0.5) * 30, y: (system.random() - 0.5) * 30, z: 120 + system.random() * 120 },
+      color: [0.25, 0.25, 0.25, 0.9],
+      size: 12,
+      lifetime: 1.2,
+      gravity: 300,
+      damping: 3,
+      blendMode: "alpha",
+      fade: true
+    });
+  }
+}
+function spawnBlood(context) {
+  const { system, origin, direction = { x: 0, y: 0, z: 1 } } = context;
+  for (let i = 0; i < 24; i += 1) {
+    const speed = 120 + system.random() * 180;
+    system.spawn({
+      position: origin,
+      velocity: {
+        x: direction.x * speed + (system.random() - 0.5) * 70,
+        y: direction.y * speed + (system.random() - 0.5) * 70,
+        z: direction.z * speed + system.random() * 80
+      },
+      color: [0.6, 0, 0, 0.95],
+      size: 3,
+      lifetime: 0.8,
+      gravity: 900,
+      damping: 1,
+      bounce: 0.2,
+      blendMode: "alpha",
+      fade: true
+    });
+  }
+}
+function spawnTeleportFlash(context) {
+  const { system, origin } = context;
+  for (let i = 0; i < 30; i += 1) {
+    const angle = system.random() * Math.PI * 2;
+    const radius = 8 + system.random() * 8;
+    system.spawn({
+      position: origin,
+      velocity: { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius, z: 100 + system.random() * 80 },
+      color: [0.4, 0.6, 1, 0.9],
+      size: 4,
+      lifetime: 0.5,
+      gravity: 300,
+      damping: 2,
+      blendMode: "additive",
+      fade: true
+    });
+  }
+}
+function spawnMuzzleFlash(context) {
+  const { system, origin, direction = { x: 1, y: 0, z: 0 } } = context;
+  for (let i = 0; i < 10; i += 1) {
+    const speed = 350 + system.random() * 100;
+    system.spawn({
+      position: origin,
+      velocity: {
+        x: direction.x * speed + (system.random() - 0.5) * 30,
+        y: direction.y * speed + (system.random() - 0.5) * 30,
+        z: direction.z * speed + (system.random() - 0.5) * 30
+      },
+      color: [1, 0.8, 0.3, 1],
+      size: 3,
+      lifetime: 0.25,
+      gravity: 200,
+      damping: 1,
+      blendMode: "additive",
+      fade: true
+    });
+  }
+}
+function spawnTrail(context) {
+  const { system, origin, direction = { x: 0, y: 0, z: 0 } } = context;
+  for (let i = 0; i < 6; i += 1) {
+    system.spawn({
+      position: {
+        x: origin.x + direction.x * i * 2,
+        y: origin.y + direction.y * i * 2,
+        z: origin.z + direction.z * i * 2
+      },
+      velocity: { x: (system.random() - 0.5) * 15, y: (system.random() - 0.5) * 15, z: 20 + system.random() * 15 },
+      color: [0.6, 0.6, 0.6, 0.8],
+      size: 2.2,
+      lifetime: 0.6,
+      gravity: 200,
+      damping: 1.5,
+      blendMode: "alpha",
+      fade: true
+    });
+  }
+}
+
 // src/index.ts
 function createEngine(imports) {
   return {
@@ -4153,19 +4911,28 @@ function createEngine(imports) {
   MAX_SOUND_CHANNELS,
   MD2_FRAGMENT_SHADER,
   MD2_VERTEX_SHADER,
+  MD3_FRAGMENT_SHADER,
+  MD3_VERTEX_SHADER,
   Md2Loader,
   Md2MeshBuffers,
   Md2ParseError,
   Md2Pipeline,
   Md3Loader,
+  Md3ModelMesh,
   Md3ParseError,
+  Md3Pipeline,
+  Md3SurfaceMesh,
   MusicSystem,
+  PARTICLE_FRAGMENT_SHADER,
+  PARTICLE_VERTEX_SHADER,
   PakArchive,
   PakIndexStore,
   PakIngestionError,
   PakParseError,
   PakValidationError,
   PakValidator,
+  ParticleRenderer,
+  ParticleSystem,
   RERELEASE_KNOWN_PAKS,
   SKYBOX_FRAGMENT_SHADER,
   SKYBOX_VERTEX_SHADER,
@@ -4189,6 +4956,8 @@ function createEngine(imports) {
   buildBspGeometry,
   buildMd2Geometry,
   buildMd2VertexData,
+  buildMd3SurfaceGeometry,
+  buildMd3VertexData,
   calculateMaxAudibleDistance,
   calculatePakChecksum,
   computeFrameBlend,
@@ -4209,6 +4978,7 @@ function createEngine(imports) {
   groupMd2Animations,
   ingestPakFiles,
   ingestPaks,
+  interpolateMd3Tag,
   interpolateVec3,
   parseMd2,
   parseMd3,
@@ -4222,6 +4992,12 @@ function createEngine(imports) {
   removeViewTranslation,
   resolveLightStyles,
   spatializeOrigin,
+  spawnBlood,
+  spawnBulletImpact,
+  spawnExplosion,
+  spawnMuzzleFlash,
+  spawnTeleportFlash,
+  spawnTrail,
   walToRgba,
   wireDropTarget,
   wireFileInput