poppygl 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,12 +1,95 @@
-#!/usr/bin/env node
+// lib/camera/buildCamera.ts
+import { mat4, vec3 } from "gl-matrix";
 
-// lib/index.ts
-import * as fs from "fs";
-import * as path from "path";
-import { PassThrough } from "stream";
-import { pathToFileURL } from "url";
-import PImage from "pureimage";
-import { mat3, mat4, vec3, vec4 } from "gl-matrix";
+// lib/gltf/computeWorldAABB.ts
+import { vec4 } from "gl-matrix";
+function computeWorldAABB(drawCalls) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  const tmp = vec4.create();
+  for (const dc of drawCalls) {
+    const { positions, model } = dc;
+    for (let i = 0; i < positions.length; i += 3) {
+      vec4.set(
+        tmp,
+        positions[i],
+        positions[i + 1],
+        positions[i + 2],
+        1
+      );
+      vec4.transformMat4(tmp, tmp, model);
+      const x = tmp[0];
+      const y = tmp[1];
+      const z = tmp[2];
+      min[0] = Math.min(min[0], x);
+      min[1] = Math.min(min[1], y);
+      min[2] = Math.min(min[2], z);
+      max[0] = Math.max(max[0], x);
+      max[1] = Math.max(max[1], y);
+      max[2] = Math.max(max[2], z);
+    }
+  }
+  return { min, max };
+}
+
+// lib/utils/toRad.ts
+var toRad = (degrees) => degrees * Math.PI / 180;
+
+// lib/camera/buildCamera.ts
+function buildCamera(drawCalls, width, height, fovDeg, camPos, lookAt) {
+  const aspect = width / height;
+  const near = 0.01;
+  const far = 1e3;
+  const proj = mat4.create();
+  mat4.perspective(proj, toRad(fovDeg), aspect, near, far);
+  let eye;
+  let center;
+  if (camPos) {
+    eye = vec3.fromValues(camPos[0], camPos[1], camPos[2]);
+    if (lookAt) {
+      center = vec3.fromValues(lookAt[0], lookAt[1], lookAt[2]);
+    } else {
+      const aabb = computeWorldAABB(drawCalls);
+      center = vec3.fromValues(
+        0.5 * (aabb.min[0] + aabb.max[0]),
+        0.5 * (aabb.min[1] + aabb.max[1]),
+        0.5 * (aabb.min[2] + aabb.max[2])
+      );
+    }
+  } else {
+    const aabb = computeWorldAABB(drawCalls);
+    center = vec3.fromValues(
+      0.5 * (aabb.min[0] + aabb.max[0]),
+      0.5 * (aabb.min[1] + aabb.max[1]),
+      0.5 * (aabb.min[2] + aabb.max[2])
+    );
+    const diag = vec3.distance(
+      vec3.fromValues(aabb.min[0], aabb.min[1], aabb.min[2]),
+      vec3.fromValues(aabb.max[0], aabb.max[1], aabb.max[2])
+    );
+    const radius = diag * 0.5;
+    const fov = toRad(fovDeg);
+    const dist = radius / Math.tan(fov * 0.5) + radius * 0.5;
+    eye = vec3.fromValues(
+      center[0] + dist,
+      center[1] + dist * 0.3,
+      center[2] + dist
+    );
+  }
+  const up = vec3.fromValues(0, 1, 0);
+  const view = mat4.create();
+  mat4.lookAt(view, eye, center, up);
+  return { view, proj };
+}
+
+// lib/image/createUint8Bitmap.ts
+var createUint8Bitmap = (width, height) => ({
+  width,
+  height,
+  data: new Uint8ClampedArray(width * height * 4)
+});
+
+// lib/render/getDefaultRenderOptions.ts
 var DEFAULT_LIGHT_DIR = [-0.4, -0.9, -0.2];
 var DEFAULT_RENDER_OPTIONS = {
   width: 800,
@@ -19,359 +102,128 @@ var DEFAULT_RENDER_OPTIONS = {
   camPos: null,
   lookAt: null
 };
-var clamp = (x, a, b) => Math.max(a, Math.min(b, x));
-var toRad = (d) => d * Math.PI / 180;
-function bufferFromDataURI(uri) {
-  const m = uri.match(/^data:.*?;base64,(.*)$/);
-  if (!m) throw new Error(`Unsupported data URI: ${uri.slice(0, 64)}...`);
-  return Buffer.from(m[1], "base64");
+function getDefaultRenderOptions() {
+  return { ...DEFAULT_RENDER_OPTIONS };
 }
-function isPNG(filenameOrUri) {
-  return /\.png(\?|$)/i.test(filenameOrUri) || /image\/png/i.test(filenameOrUri);
-}
-function isJPG(filenameOrUri) {
-  return /\.(jpg|jpeg)(\?|$)/i.test(filenameOrUri) || /image\/jpe?g/i.test(filenameOrUri);
-}
-function bufferToStream(buf) {
-  const s = new PassThrough();
-  s.end(buf);
-  return s;
-}
-async function encodePNGToBuffer(image) {
-  const passThrough = new PassThrough();
-  const chunks = [];
-  passThrough.on("data", (chunk) => {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  });
-  const resultPromise = new Promise((resolve2, reject) => {
-    passThrough.on("end", () => resolve2(Buffer.concat(chunks)));
-    passThrough.on("error", reject);
-  });
-  await PImage.encodePNGToStream(image, passThrough);
-  return await resultPromise;
-}
-function srgbEncodeLinear01(x) {
-  if (x <= 31308e-7) return 12.92 * x;
-  return 1.055 * Math.pow(x, 1 / 2.4) - 0.055;
+
+// lib/render/SoftwareRenderer.ts
+import { mat3, mat4 as mat42, vec3 as vec32, vec4 as vec42 } from "gl-matrix";
+
+// lib/gltf/computeSmoothNormals.ts
+function computeSmoothNormals(positions, indices) {
+  const normals = new Float32Array(positions.length);
+  const vertexCount = positions.length / 3 | 0;
+  const indexArray = indices ?? (() => {
+    const arr = new Uint32Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) arr[i] = i;
+    return arr;
+  })();
+  for (let i = 0; i < indexArray.length; i += 3) {
+    const i0 = indexArray[i + 0];
+    const i1 = indexArray[i + 1];
+    const i2 = indexArray[i + 2];
+    const p0 = [
+      positions[i0 * 3 + 0],
+      positions[i0 * 3 + 1],
+      positions[i0 * 3 + 2]
+    ];
+    const p1 = [
+      positions[i1 * 3 + 0],
+      positions[i1 * 3 + 1],
+      positions[i1 * 3 + 2]
+    ];
+    const p2 = [
+      positions[i2 * 3 + 0],
+      positions[i2 * 3 + 1],
+      positions[i2 * 3 + 2]
+    ];
+    const v10 = [
+      p1[0] - p0[0],
+      p1[1] - p0[1],
+      p1[2] - p0[2]
+    ];
+    const v20 = [
+      p2[0] - p0[0],
+      p2[1] - p0[1],
+      p2[2] - p0[2]
+    ];
+    const nx = v10[1] * v20[2] - v10[2] * v20[1];
+    const ny = v10[2] * v20[0] - v10[0] * v20[2];
+    const nz = v10[0] * v20[1] - v10[1] * v20[0];
+    const base0 = i0 * 3;
+    const base1 = i1 * 3;
+    const base2 = i2 * 3;
+    normals[base0 + 0] = normals[base0 + 0] + nx;
+    normals[base0 + 1] = normals[base0 + 1] + ny;
+    normals[base0 + 2] = normals[base0 + 2] + nz;
+    normals[base1 + 0] = normals[base1 + 0] + nx;
+    normals[base1 + 1] = normals[base1 + 1] + ny;
+    normals[base1 + 2] = normals[base1 + 2] + nz;
+    normals[base2 + 0] = normals[base2 + 0] + nx;
+    normals[base2 + 1] = normals[base2 + 1] + ny;
+    normals[base2 + 2] = normals[base2 + 2] + nz;
+  }
+  for (let i = 0; i < vertexCount; i++) {
+    const nx = normals[i * 3 + 0];
+    const ny = normals[i * 3 + 1];
+    const nz = normals[i * 3 + 2];
+    const invLength = 1 / (Math.hypot(nx, ny, nz) || 1);
+    normals[i * 3 + 0] = nx * invLength;
+    normals[i * 3 + 1] = ny * invLength;
+    normals[i * 3 + 2] = nz * invLength;
+  }
+  return normals;
 }
+
+// lib/utils/mulColor.ts
 function mulColor(a, b) {
   return [a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3]];
 }
-async function loadGLTF(gltfPath) {
-  const baseDir = path.dirname(gltfPath);
-  const gltf = JSON.parse(fs.readFileSync(gltfPath, "utf8"));
-  const buffers = await Promise.all(
-    (gltf.buffers || []).map(async (b) => {
-      if (b.uri && b.uri.startsWith("data:")) {
-        return bufferFromDataURI(b.uri);
-      } else if (b.uri) {
-        const p = path.resolve(baseDir, decodeURIComponent(b.uri));
-        return fs.readFileSync(p);
-      } else {
-        throw new Error(
-          "Buffer without uri not supported in this lightweight loader."
-        );
-      }
-    })
-  );
-  function detectMimeTypeFromBuffer(buf, hint) {
-    if (hint) return hint;
-    if (buf.length >= 8 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10)
-      return "image/png";
-    if (buf.length >= 2 && buf[0] === 255 && buf[1] === 216)
-      return "image/jpeg";
-    return null;
-  }
-  async function decodeImageFromBuffer(buf, mimeType) {
-    const type = detectMimeTypeFromBuffer(buf, mimeType);
-    if (type === "image/png")
-      return PImage.decodePNGFromStream(bufferToStream(buf));
-    if (type === "image/jpeg" || type === "image/jpg")
-      return PImage.decodeJPEGFromStream(bufferToStream(buf));
-    throw new Error("Unsupported embedded image mimeType: " + (mimeType || "unknown"));
-  }
-  const images = await Promise.all(
-    (gltf.images || []).map(async (img) => {
-      if (img.uri) {
-        if (img.uri.startsWith("data:")) {
-          const buf = bufferFromDataURI(img.uri);
-          if (isPNG(img.uri))
-            return PImage.decodePNGFromStream(bufferToStream(buf));
-          if (isJPG(img.uri))
-            return PImage.decodeJPEGFromStream(bufferToStream(buf));
-          throw new Error(
-            `Unsupported data-URI image type for ${img.uri.slice(0, 32)}...`
-          );
-        }
-        const fpath = path.resolve(baseDir, decodeURIComponent(img.uri));
-        if (isPNG(img.uri))
-          return PImage.decodePNGFromStream(fs.createReadStream(fpath));
-        if (isJPG(img.uri))
-          return PImage.decodeJPEGFromStream(fs.createReadStream(fpath));
-        return PImage.decodePNGFromStream(fs.createReadStream(fpath)).catch(
-          () => PImage.decodeJPEGFromStream(fs.createReadStream(fpath))
-        );
-      }
-      if (typeof img.bufferView === "number") {
-        const bv = gltf.bufferViews[img.bufferView];
-        if (!bv) throw new Error(`Invalid image bufferView index ${img.bufferView}`);
-        const buffer = buffers[bv.buffer];
-        if (!buffer) throw new Error(`Missing buffer for image bufferView ${img.bufferView}`);
-        const byteOffset = bv.byteOffset || 0;
-        const byteLength = bv.byteLength;
-        if (typeof byteLength !== "number")
-          throw new Error(`bufferView ${img.bufferView} missing byteLength for image.`);
-        const slice = buffer.slice(byteOffset, byteOffset + byteLength);
-        return decodeImageFromBuffer(slice, img.mimeType);
-      }
-      throw new Error(
-        "images[*] entry missing uri or bufferView; unsupported in this lightweight loader."
-      );
-    })
-  );
-  const COMPONENT_INFO = {
-    5120: {
-      name: "BYTE",
-      size: 1,
-      array: Int8Array,
-      norm: (v) => Math.max(-1, v / 127)
-    },
-    5121: {
-      name: "UNSIGNED_BYTE",
-      size: 1,
-      array: Uint8Array,
-      norm: (v) => v / 255
-    },
-    5122: {
-      name: "SHORT",
-      size: 2,
-      array: Int16Array,
-      norm: (v) => Math.max(-1, v / 32767)
-    },
-    5123: {
-      name: "UNSIGNED_SHORT",
-      size: 2,
-      array: Uint16Array,
-      norm: (v) => v / 65535
-    },
-    5125: {
-      name: "UNSIGNED_INT",
-      size: 4,
-      array: Uint32Array,
-      norm: (v) => v / 4294967295
-    },
-    5126: { name: "FLOAT", size: 4, array: Float32Array, norm: (v) => v }
-  };
-  const NUM_COMP = {
-    SCALAR: 1,
-    VEC2: 2,
-    VEC3: 3,
-    VEC4: 4,
-    MAT2: 4,
-    MAT3: 9,
-    MAT4: 16
-  };
-  function readAccessorAsFloat32(accIndex) {
-    const acc = gltf.accessors[accIndex];
-    if (acc.sparse)
-      throw new Error("Sparse accessors not supported (lightweight).");
-    const bv = gltf.bufferViews[acc.bufferView];
-    const comp = COMPONENT_INFO[acc.componentType];
-    const ncomp = NUM_COMP[acc.type];
-    const stride = bv.byteStride || comp.size * ncomp;
-    const count = acc.count;
-    const buf = buffers[bv.buffer];
-    const base = (bv.byteOffset || 0) + (acc.byteOffset || 0);
-    const src = new Uint8Array(
-      buf.buffer,
-      buf.byteOffset + base,
-      bv.byteLength - (acc.byteOffset || 0)
-    );
-    const out = new Float32Array(count * ncomp);
-    const canUseTightView = stride === comp.size * ncomp && src.byteOffset % comp.size === 0;
-    if (canUseTightView) {
-      const Typed = comp.array;
-      const tarr = new Typed(src.buffer, src.byteOffset, count * ncomp);
-      if (comp.name === "FLOAT" && !acc.normalized)
-        return new Float32Array(tarr.buffer, tarr.byteOffset, tarr.length);
-      for (let i = 0; i < tarr.length; i++)
-        out[i] = acc.normalized ? comp.norm(tarr[i]) : tarr[i];
-      return out;
-    }
-    const dv = new DataView(src.buffer, src.byteOffset, src.byteLength);
-    let off = 0;
-    for (let i = 0; i < count; i++) {
-      let o = i * stride;
-      for (let c = 0; c < ncomp; c++) {
-        let v;
-        switch (acc.componentType) {
-          case 5120:
-            v = dv.getInt8(o + c * comp.size);
-            break;
-          case 5121:
-            v = dv.getUint8(o + c * comp.size);
-            break;
-          case 5122:
-            v = dv.getInt16(o + c * comp.size, true);
-            break;
-          case 5123:
-            v = dv.getUint16(o + c * comp.size, true);
-            break;
-          case 5125:
-            v = dv.getUint32(o + c * comp.size, true);
-            break;
-          case 5126:
-            v = dv.getFloat32(o + c * comp.size, true);
-            break;
-          default:
-            throw new Error("Unknown componentType");
-        }
-        out[off++] = acc.normalized ? COMPONENT_INFO[acc.componentType].norm(v) : v;
-      }
-    }
-    return out;
-  }
-  function readIndices(accIndex) {
-    const acc = gltf.accessors[accIndex];
-    if (acc.type !== "SCALAR")
-      throw new Error("Indices accessor must be SCALAR");
-    const bv = gltf.bufferViews[acc.bufferView];
-    const comp = COMPONENT_INFO[acc.componentType];
-    if (acc.componentType !== 5121 && acc.componentType !== 5123 && acc.componentType !== 5125) {
-      throw new Error("Index componentType must be UNSIGNED_BYTE/SHORT/INT");
-    }
-    const stride = bv.byteStride || comp.size;
-    const count = acc.count;
-    const buf = buffers[bv.buffer];
-    const base = (bv.byteOffset || 0) + (acc.byteOffset || 0);
-    const src = new Uint8Array(
-      buf.buffer,
-      buf.byteOffset + base,
-      bv.byteLength - (acc.byteOffset || 0)
-    );
-    const canUseTightView = stride === comp.size && src.byteOffset % comp.size === 0;
-    if (canUseTightView) {
-      const Typed = comp.array;
-      const tarr = new Typed(src.buffer, src.byteOffset, count);
-      return acc.componentType === 5125 ? new Uint32Array(tarr.buffer, tarr.byteOffset, tarr.length) : new Uint32Array(tarr);
-    }
-    const dv = new DataView(src.buffer, src.byteOffset, src.byteLength);
-    const out = new Uint32Array(count);
-    for (let i = 0; i < count; i++) {
-      const o = i * stride;
-      let v;
-      switch (acc.componentType) {
-        case 5121:
-          v = dv.getUint8(o);
-          break;
-        case 5123:
-          v = dv.getUint16(o, true);
-          break;
-        case 5125:
-          v = dv.getUint32(o, true);
-          break;
-      }
-      out[i] = v >>> 0;
-    }
-    return out;
-  }
-  const textures = gltf.textures || [];
-  function getMaterial(matIndex) {
-    const m = (gltf.materials || [])[matIndex] || {};
-    const pbr = m.pbrMetallicRoughness || {};
-    const factor = pbr.baseColorFactor || [1, 1, 1, 1];
-    let texImg = null;
-    if (pbr.baseColorTexture && Number.isInteger(pbr.baseColorTexture.index)) {
-      const t = textures[pbr.baseColorTexture.index];
-      if (t && Number.isInteger(t.source)) texImg = images[t.source] || null;
-    }
-    return { baseColorFactor: factor, baseColorTexture: texImg };
-  }
-  const nodes = gltf.nodes || [];
-  const meshes = gltf.meshes || [];
-  const scenes = gltf.scenes || [];
-  const sceneIndex = Number.isInteger(gltf.scene) ? gltf.scene : 0;
-  const scene = scenes[sceneIndex] || { nodes: [] };
-  const drawCalls = [];
-  function nodeLocalMatrix(n) {
-    if (n.matrix) {
-      const m2 = mat4.create();
-      for (let i = 0; i < 16; i++) m2[i] = n.matrix[i];
-      return m2;
-    }
-    const t = n.translation || [0, 0, 0];
-    const r = n.rotation || [0, 0, 0, 1];
-    const s = n.scale || [1, 1, 1];
-    const m = mat4.create();
-    const mq = mat4.create();
-    mat4.fromRotationTranslationScale(mq, r, t, s);
-    mat4.copy(m, mq);
-    return m;
-  }
-  function traverse(nodeIndex, parentMatrix) {
-    const n = nodes[nodeIndex];
-    const local = nodeLocalMatrix(n);
-    const world = mat4.create();
-    mat4.multiply(world, parentMatrix, local);
-    if (Number.isInteger(n.mesh)) {
-      const mesh = meshes[n.mesh];
-      for (const prim of mesh.primitives) {
-        if (prim.mode != null && prim.mode !== 4) continue;
-        const posAcc = prim.attributes.POSITION;
-        if (posAcc == null) continue;
-        const norAcc = prim.attributes.NORMAL;
-        const uvAcc = prim.attributes.TEXCOORD_0;
-        const positions = readAccessorAsFloat32(posAcc);
-        const normals = norAcc != null ? readAccessorAsFloat32(norAcc) : null;
-        const uvs = uvAcc != null ? readAccessorAsFloat32(uvAcc) : null;
-        const indices = prim.indices != null ? readIndices(prim.indices) : null;
-        const material = getMaterial(prim.material);
-        drawCalls.push({
-          positions,
-          normals,
-          uvs,
-          indices,
-          model: world,
-          material
-        });
-      }
-    }
-    for (const c of n.children || []) traverse(c, world);
-  }
-  const I = mat4.create();
-  for (const root of scene.nodes || []) traverse(root, I);
-  return { gltf, drawCalls };
+
+// lib/utils/srgbEncodeLinear01.ts
+function srgbEncodeLinear01(linear) {
+  if (linear <= 31308e-7) return 12.92 * linear;
+  return 1.055 * Math.pow(linear, 1 / 2.4) - 0.055;
 }
+
+// lib/utils/clamp.ts
+var clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+// lib/render/SoftwareRenderer.ts
 var SoftwareRenderer = class {
-  constructor(w, h, options = {}) {
-    this.w = w;
-    this.h = h;
-    this.img = PImage.make(w, h);
-    this.buf = this.img.data;
-    this.depth = new Float32Array(w * h);
-    this.options = options;
+  width;
+  height;
+  bitmap;
+  depth;
+  constructor(width, height, imageFactory = createUint8Bitmap) {
+    this.width = width;
+    this.height = height;
+    this.bitmap = imageFactory(width, height);
+    this.depth = new Float32Array(width * height);
     this.clear([0, 0, 0, 255]);
   }
+  get buffer() {
+    return this.bitmap.data;
+  }
   clear(colorRGBA = [0, 0, 0, 255]) {
     const [r, g, b, a] = colorRGBA;
-    for (let i = 0; i < this.w * this.h; i++) {
+    for (let i = 0; i < this.width * this.height; i++) {
       const j = i * 4;
-      this.buf[j + 0] = r;
-      this.buf[j + 1] = g;
-      this.buf[j + 2] = b;
-      this.buf[j + 3] = a;
+      this.buffer[j + 0] = r;
+      this.buffer[j + 1] = g;
+      this.buffer[j + 2] = b;
+      this.buffer[j + 3] = a;
       this.depth[i] = Infinity;
     }
   }
   setPixel(x, y, r, g, b, a) {
-    if (x < 0 || y < 0 || x >= this.w || y >= this.h) return;
-    const idx = (y * this.w + x) * 4;
-    this.buf[idx + 0] = r;
-    this.buf[idx + 1] = g;
-    this.buf[idx + 2] = b;
-    this.buf[idx + 3] = a;
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return;
+    const idx = (y * this.width + x) * 4;
+    this.buffer[idx + 0] = r;
+    this.buffer[idx + 1] = g;
+    this.buffer[idx + 2] = b;
+    this.buffer[idx + 3] = a;
   }
-  // Sample nearest from pureimage bitmap (u,v in [0,1])
   sampleTextureNearest(img, u, v) {
     if (!img) return [1, 1, 1, 1];
     const x = clamp(Math.floor(u * (img.width - 1)), 0, img.width - 1);
@@ -385,13 +237,15 @@ var SoftwareRenderer = class {
       d[idx + 3] / 255
     ];
   }
-  // p: screen-space barycentric weights; invW: per-vertex 1/w; attrs: array of VecN
   perspInterp(attrs, invWs, lambdas) {
-    const denom = lambdas[0] * invWs[0] + lambdas[1] * invWs[1] + lambdas[2] * invWs[2];
-    const n = attrs[0].length;
+    const [lambda0, lambda1, lambda2] = lambdas;
+    const [invW0, invW1, invW2] = invWs;
+    const [attr0, attr1, attr2] = attrs;
+    const denom = lambda0 * invW0 + lambda1 * invW1 + lambda2 * invW2;
+    const n = attr0.length;
     const out = new Array(n).fill(0);
     for (let j = 0; j < n; j++) {
-      out[j] = (lambdas[0] * attrs[0][j] * invWs[0] + lambdas[1] * attrs[1][j] * invWs[1] + lambdas[2] * attrs[2][j] * invWs[2]) / denom;
+      out[j] = (lambda0 * attr0[j] * invW0 + lambda1 * attr1[j] * invW1 + lambda2 * attr2[j] * invW2) / denom;
     }
     return out;
   }
@@ -399,68 +253,82 @@ var SoftwareRenderer = class {
     const { positions, normals, uvs, indices, model } = mesh;
     const view = camera.view;
     const proj = camera.proj;
-    const mvp = mat4.create();
-    mat4.multiply(mvp, proj, mat4.multiply(mat4.create(), view, model));
+    const mvp = mat42.create();
+    mat42.multiply(mvp, proj, mat42.multiply(mat42.create(), view, model));
     const normalMat = mat3.create();
     mat3.normalFromMat4(normalMat, model);
-    const vertCount = positions.length / 3 | 0;
-    const idx = indices || (() => {
-      const a = new Uint32Array(vertCount);
-      for (let i = 0; i < vertCount; i++) a[i] = i;
+    const vertexCount = positions.length / 3 | 0;
+    const idx = indices ?? (() => {
+      const a = new Uint32Array(vertexCount);
+      for (let i = 0; i < vertexCount; i++) a[i] = i;
       return a;
     })();
     let useNormals = normals;
     if (!useNormals) {
       useNormals = computeSmoothNormals(positions, idx);
     }
-    const vScreen = new Array(vertCount);
-    const vInvW = new Float32Array(vertCount);
-    const vNDCz = new Float32Array(vertCount);
-    const vWorldN = new Array(vertCount);
-    for (let i = 0; i < vertCount; i++) {
-      const p = vec4.fromValues(
+    const vScreen = new Array(vertexCount);
+    const vInvW = new Float32Array(vertexCount);
+    const vNDCz = new Float32Array(vertexCount);
+    const vWorldN = new Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+      const p = vec42.fromValues(
         positions[i * 3 + 0],
         positions[i * 3 + 1],
         positions[i * 3 + 2],
         1
       );
-      const c = vec4.create();
-      vec4.transformMat4(c, p, mvp);
+      const c = vec42.create();
+      vec42.transformMat4(c, p, mvp);
       const invW = 1 / c[3];
       const ndcX = c[0] * invW;
       const ndcY = c[1] * invW;
       const ndcZ = c[2] * invW;
-      const sx = Math.round((ndcX * 0.5 + 0.5) * (this.w - 1));
-      const sy = Math.round((1 - (ndcY * 0.5 + 0.5)) * (this.h - 1));
+      const sx = Math.round((ndcX * 0.5 + 0.5) * (this.width - 1));
+      const sy = Math.round((1 - (ndcY * 0.5 + 0.5)) * (this.height - 1));
       vScreen[i] = [sx, sy];
       vInvW[i] = invW;
       vNDCz[i] = ndcZ;
-      const n = vec3.fromValues(
+      const n = vec32.fromValues(
         useNormals[i * 3 + 0],
         useNormals[i * 3 + 1],
         useNormals[i * 3 + 2]
       );
-      const nw = vec3.create();
-      vec3.transformMat3(nw, n, normalMat);
-      vWorldN[i] = nw;
+      const nw = vec32.create();
+      vec32.transformMat3(nw, n, normalMat);
+      vWorldN[i] = [nw[0], nw[1], nw[2]];
     }
     for (let i = 0; i < idx.length; i += 3) {
-      const i0 = idx[i + 0] >>> 0;
-      const i1 = idx[i + 1] >>> 0;
-      const i2 = idx[i + 2] >>> 0;
+      const i0 = idx[i + 0];
+      const i1 = idx[i + 1];
+      const i2 = idx[i + 2];
       if (!(isFinite(vInvW[i0]) && isFinite(vInvW[i1]) && isFinite(vInvW[i2])))
         continue;
-      const v0 = vScreen[i0], v1 = vScreen[i1], v2 = vScreen[i2];
+      const v0 = vScreen[i0];
+      const v1 = vScreen[i1];
+      const v2 = vScreen[i2];
       const area = edge(v0, v1, v2);
       if (area === 0) continue;
       if (cullBackFaces && area < 0) continue;
       let minX = Math.max(0, Math.min(v0[0], v1[0], v2[0]) | 0);
-      let maxX = Math.min(this.w - 1, Math.max(v0[0], v1[0], v2[0]) | 0);
+      let maxX = Math.min(this.width - 1, Math.max(v0[0], v1[0], v2[0]) | 0);
       let minY = Math.max(0, Math.min(v0[1], v1[1], v2[1]) | 0);
-      let maxY = Math.min(this.h - 1, Math.max(v0[1], v1[1], v2[1]) | 0);
-      const invW = [vInvW[i0], vInvW[i1], vInvW[i2]];
-      const ndcZ = [vNDCz[i0], vNDCz[i1], vNDCz[i2]];
-      const nws = [vWorldN[i0], vWorldN[i1], vWorldN[i2]];
+      let maxY = Math.min(this.height - 1, Math.max(v0[1], v1[1], v2[1]) | 0);
+      const invW = [
+        vInvW[i0],
+        vInvW[i1],
+        vInvW[i2]
+      ];
+      const ndcZ = [
+        vNDCz[i0],
+        vNDCz[i1],
+        vNDCz[i2]
+      ];
+      const nws = [
+        vWorldN[i0],
+        vWorldN[i1],
+        vWorldN[i2]
+      ];
       const uv = uvs ? [
         [uvs[i0 * 2 + 0], uvs[i0 * 2 + 1]],
         [uvs[i1 * 2 + 0], uvs[i1 * 2 + 1]],
@@ -474,13 +342,21 @@ var SoftwareRenderer = class {
           const w2 = edge(v0, v1, p);
           if (w0 < 0 || w1 < 0 || w2 < 0) continue;
           const invArea = 1 / area;
-          const l0 = w0 * invArea, l1 = w1 * invArea, l2 = w2 * invArea;
+          const l0 = w0 * invArea;
+          const l1 = w1 * invArea;
+          const l2 = w2 * invArea;
           const zndc = l0 * ndcZ[0] + l1 * ndcZ[1] + l2 * ndcZ[2];
           const z01 = zndc * 0.5 + 0.5;
-          const di = y * this.w + x;
-          if (z01 >= this.depth[di]) continue;
-          this.depth[di] = z01;
-          let baseColor = material.baseColorFactor.slice(0, 4);
+          const di = y * this.width + x;
+          const depth = this.depth;
+          if (z01 >= depth[di]) continue;
+          depth[di] = z01;
+          let baseColor = [
+            material.baseColorFactor[0],
+            material.baseColorFactor[1],
+            material.baseColorFactor[2],
+            material.baseColorFactor[3]
+          ];
           if (uv && material.baseColorTexture) {
             const uvp = this.perspInterp(uv, invW, [l0, l1, l2]);
             const texel = this.sampleTextureNearest(
@@ -490,18 +366,22 @@ var SoftwareRenderer = class {
             );
             baseColor = mulColor(baseColor, texel);
           }
-          const np = this.perspInterp(nws, invW, [l0, l1, l2]);
-          const nlen = Math.hypot(np[0], np[1], np[2]) || 1;
-          const nrm = [np[0] / nlen, np[1] / nlen, np[2] / nlen];
-          const lightDir = light && light.dir ? light.dir : DEFAULT_LIGHT_DIR;
+          const [np0, np1, np2] = this.perspInterp(nws, invW, [l0, l1, l2]);
+          const nlen = Math.hypot(np0, np1, np2) || 1;
+          const nrm = [
+            np0 / nlen,
+            np1 / nlen,
+            np2 / nlen
+          ];
+          const lightDir = light.dir ?? DEFAULT_LIGHT_DIR;
           const ambient = clamp(
-            light && typeof light.ambient === "number" ? light.ambient : DEFAULT_RENDER_OPTIONS.ambient,
+            light.ambient ?? DEFAULT_RENDER_OPTIONS.ambient,
             0,
             1
           );
-          const L = vec3.normalize(
-            vec3.create(),
-            vec3.fromValues(lightDir[0], lightDir[1], lightDir[2])
+          const L = vec32.normalize(
+            vec32.create(),
+            vec32.fromValues(lightDir[0], lightDir[1], lightDir[2])
           );
           const ndotl = Math.max(
             0,
@@ -537,233 +417,640 @@ var SoftwareRenderer = class {
 function edge(a, b, p) {
   return (p[0] - a[0]) * (b[1] - a[1]) - (p[1] - a[1]) * (b[0] - a[0]);
 }
-function computeSmoothNormals(positions, indices) {
-  const n = new Float32Array(positions.length);
-  const vc = positions.length / 3 | 0;
-  const idx = indices || (() => {
-    const a = new Uint32Array(vc);
-    for (let i = 0; i < vc; i++) a[i] = i;
-    return a;
-  })();
-  for (let i = 0; i < idx.length; i += 3) {
-    const i0 = idx[i + 0], i1 = idx[i + 1], i2 = idx[i + 2];
-    const p0 = [
-      positions[i0 * 3 + 0],
-      positions[i0 * 3 + 1],
-      positions[i0 * 3 + 2]
-    ];
-    const p1 = [
-      positions[i1 * 3 + 0],
-      positions[i1 * 3 + 1],
-      positions[i1 * 3 + 2]
-    ];
-    const p2 = [
-      positions[i2 * 3 + 0],
-      positions[i2 * 3 + 1],
-      positions[i2 * 3 + 2]
-    ];
-    const v10 = [p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]];
-    const v20 = [p2[0] - p0[0], p2[1] - p0[1], p2[2] - p0[2]];
-    const nx = v10[1] * v20[2] - v10[2] * v20[1];
-    const ny = v10[2] * v20[0] - v10[0] * v20[2];
-    const nz = v10[0] * v20[1] - v10[1] * v20[0];
-    n[i0 * 3 + 0] += nx;
-    n[i0 * 3 + 1] += ny;
-    n[i0 * 3 + 2] += nz;
-    n[i1 * 3 + 0] += nx;
-    n[i1 * 3 + 1] += ny;
-    n[i1 * 3 + 2] += nz;
-    n[i2 * 3 + 0] += nx;
-    n[i2 * 3 + 1] += ny;
-    n[i2 * 3 + 2] += nz;
-  }
-  for (let i = 0; i < vc; i++) {
-    const nx = n[i * 3 + 0], ny = n[i * 3 + 1], nz = n[i * 3 + 2];
-    const inv = 1 / (Math.hypot(nx, ny, nz) || 1);
-    n[i * 3 + 0] = nx * inv;
-    n[i * 3 + 1] = ny * inv;
-    n[i * 3 + 2] = nz * inv;
-  }
-  return n;
-}
-function computeWorldAABB(drawCalls) {
-  const min = [Infinity, Infinity, Infinity];
-  const max = [-Infinity, -Infinity, -Infinity];
-  const tmp = vec4.create();
-  for (const dc of drawCalls) {
-    const { positions, model } = dc;
-    for (let i = 0; i < positions.length; i += 3) {
-      vec4.set(tmp, positions[i], positions[i + 1], positions[i + 2], 1);
-      vec4.transformMat4(tmp, tmp, model);
-      min[0] = Math.min(min[0], tmp[0]);
-      min[1] = Math.min(min[1], tmp[1]);
-      min[2] = Math.min(min[2], tmp[2]);
-      max[0] = Math.max(max[0], tmp[0]);
-      max[1] = Math.max(max[1], tmp[1]);
-      max[2] = Math.max(max[2], tmp[2]);
-    }
-  }
-  return { min, max };
-}
-function buildCamera(drawCalls, width, height, fovDeg, camPosOpt, lookAtOpt) {
-  const aspect = width / height;
-  const near = 0.01, far = 1e3;
-  const proj = mat4.create();
-  mat4.perspective(proj, toRad(fovDeg), aspect, near, far);
-  let eye, center;
-  if (camPosOpt) {
-    eye = vec3.fromValues(camPosOpt[0], camPosOpt[1], camPosOpt[2]);
-    if (lookAtOpt)
-      center = vec3.fromValues(lookAtOpt[0], lookAtOpt[1], lookAtOpt[2]);
-    else {
-      const aabb = computeWorldAABB(drawCalls);
-      center = vec3.fromValues(
-        0.5 * (aabb.min[0] + aabb.max[0]),
-        0.5 * (aabb.min[1] + aabb.max[1]),
-        0.5 * (aabb.min[2] + aabb.max[2])
-      );
-    }
-  } else {
-    const aabb = computeWorldAABB(drawCalls);
-    center = vec3.fromValues(
-      0.5 * (aabb.min[0] + aabb.max[0]),
-      0.5 * (aabb.min[1] + aabb.max[1]),
-      0.5 * (aabb.min[2] + aabb.max[2])
-    );
-    const diag = vec3.distance(
-      vec3.fromValues(aabb.min[0], aabb.min[1], aabb.min[2]),
-      vec3.fromValues(aabb.max[0], aabb.max[1], aabb.max[2])
-    );
-    const radius = diag * 0.5;
-    const fov = toRad(fovDeg);
-    const dist = radius / Math.tan(fov * 0.5) + radius * 0.5;
-    eye = vec3.fromValues(
-      center[0] + dist,
-      center[1] + dist * 0.3,
-      center[2] + dist
-    );
-  }
-  const up = vec3.fromValues(0, 1, 0);
-  const view = mat4.create();
-  mat4.lookAt(view, eye, center, up);
-  return { view, proj };
-}
-async function renderGLTFToPNGBuffer(gltfPath, options = {}) {
-  const merged = {
+
+// lib/render/resolveRenderOptions.ts
+function resolveRenderOptions(options = {}) {
+  return {
     ...DEFAULT_RENDER_OPTIONS,
     ...options,
     lightDir: options.lightDir != null ? options.lightDir : DEFAULT_RENDER_OPTIONS.lightDir,
     camPos: options.camPos !== void 0 ? options.camPos : DEFAULT_RENDER_OPTIONS.camPos,
     lookAt: options.lookAt !== void 0 ? options.lookAt : DEFAULT_RENDER_OPTIONS.lookAt
   };
-  const { drawCalls } = await loadGLTF(gltfPath);
+}
+
+// lib/render/renderDrawCalls.ts
+function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint8Bitmap) {
+  const options = resolveRenderOptions(optionsInput);
   const camera = buildCamera(
     drawCalls,
-    merged.width,
-    merged.height,
-    merged.fov,
-    merged.camPos ?? null,
-    merged.lookAt ?? null
+    options.width,
+    options.height,
+    options.fov,
+    options.camPos ?? null,
+    options.lookAt ?? null
+  );
+  const renderer = new SoftwareRenderer(
+    options.width,
+    options.height,
+    imageFactory
   );
-  const renderer = new SoftwareRenderer(merged.width, merged.height);
   for (const dc of drawCalls) {
     renderer.drawMesh(
       dc,
       camera,
-      { dir: merged.lightDir, ambient: merged.ambient },
+      { dir: options.lightDir, ambient: options.ambient },
       dc.material,
-      merged.cull,
-      merged.gamma
+      options.cull,
+      options.gamma
     );
   }
-  return await encodePNGToBuffer(renderer.img);
+  return { bitmap: renderer.bitmap, camera, options };
 }
-async function renderGLTFToPNGFile(gltfPath, outputPath, options = {}) {
-  const pngBuffer = await renderGLTFToPNGBuffer(gltfPath, options);
-  await fs.promises.writeFile(outputPath, pngBuffer);
-  return pngBuffer;
+
+// lib/gltf/createSceneFromGLTF.ts
+import { mat4 as mat43 } from "gl-matrix";
+var COMPONENT_INFO = {
+  5120: {
+    name: "BYTE",
+    size: 1,
+    array: Int8Array,
+    norm: (v) => Math.max(-1, v / 127)
+  },
+  5121: {
+    name: "UNSIGNED_BYTE",
+    size: 1,
+    array: Uint8Array,
+    norm: (v) => v / 255
+  },
+  5122: {
+    name: "SHORT",
+    size: 2,
+    array: Int16Array,
+    norm: (v) => Math.max(-1, v / 32767)
+  },
+  5123: {
+    name: "UNSIGNED_SHORT",
+    size: 2,
+    array: Uint16Array,
+    norm: (v) => v / 65535
+  },
+  5125: {
+    name: "UNSIGNED_INT",
+    size: 4,
+    array: Uint32Array,
+    norm: (v) => v / 4294967295
+  },
+  5126: { name: "FLOAT", size: 4, array: Float32Array, norm: (v) => v }
+};
+var NUM_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+function getBufferViewSlice(ctx, bufferViewIndex, byteOffset) {
+  const { gltf, buffers } = ctx;
+  const bufferView = gltf.bufferViews?.[bufferViewIndex];
+  if (!bufferView)
+    throw new Error(`Invalid bufferView index ${bufferViewIndex}`);
+  if (typeof bufferView.buffer !== "number")
+    throw new Error(`bufferView ${bufferViewIndex} missing buffer reference`);
+  const bufferIndex = bufferView.buffer;
+  const buffer = buffers[bufferIndex];
+  if (!buffer) throw new Error(`Missing buffer at index ${bufferIndex}`);
+  const viewOffset = bufferView.byteOffset ?? 0;
+  const totalByteLength = bufferView.byteLength ?? buffer.byteLength - viewOffset;
+  const baseOffset = buffer.byteOffset + viewOffset + byteOffset;
+  const viewArray = new Uint8Array(
+    buffer.buffer,
+    buffer.byteOffset + viewOffset,
+    totalByteLength
+  );
+  return {
+    array: new Uint8Array(
+      viewArray.buffer,
+      baseOffset,
+      totalByteLength - byteOffset
+    ),
+    stride: bufferView.byteStride ?? 0,
+    byteOffsetInView: baseOffset
+  };
 }
-function parseCliArgs(args) {
-  const out = { _: [] };
-  for (let i = 0; i < args.length; i++) {
-    const tok = args[i];
-    if (tok.startsWith("--")) {
-      const key = tok.slice(2);
-      const next = args[i + 1];
-      if (next && !next.startsWith("--")) {
-        out[key] = next;
-        i++;
-      } else out[key] = true;
-    } else {
-      out._.push(tok);
+function readAccessorAsFloat32(ctx, accessorIndex) {
+  const { gltf } = ctx;
+  const accessor = gltf.accessors?.[accessorIndex];
+  if (!accessor) throw new Error(`Invalid accessor index ${accessorIndex}`);
+  if (accessor.sparse) throw new Error("Sparse accessors are not supported.");
+  const compInfo = COMPONENT_INFO[accessor.componentType];
+  const numComponents = NUM_COMPONENTS[accessor.type];
+  if (!compInfo || !numComponents)
+    throw new Error(
+      `Unsupported accessor componentType ${accessor.componentType}`
+    );
+  const byteOffset = accessor.byteOffset ?? 0;
+  if (typeof accessor.bufferView !== "number")
+    throw new Error(`Accessor ${accessorIndex} missing bufferView`);
+  const {
+    array: src,
+    stride: bufferViewStride,
+    byteOffsetInView
+  } = getBufferViewSlice(ctx, accessor.bufferView, byteOffset);
+  const stride = bufferViewStride || compInfo.size * numComponents;
+  const count = accessor.count;
+  const out = new Float32Array(count * numComponents);
+  const absoluteByteOffset = byteOffsetInView;
+  const canUseTightView = stride === compInfo.size * numComponents && absoluteByteOffset % compInfo.size === 0;
+  if (canUseTightView) {
+    const TypedArrayCtor = compInfo.array;
+    const typed = new TypedArrayCtor(
+      src.buffer,
+      src.byteOffset,
+      count * numComponents
+    );
+    if (compInfo.name === "FLOAT" && !accessor.normalized) {
+      return new Float32Array(typed.buffer, typed.byteOffset, typed.length);
+    }
+    for (let i = 0; i < typed.length; i++) {
+      out[i] = accessor.normalized ? compInfo.norm(typed[i]) : typed[i];
+    }
+    return out;
+  }
+  const dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  let outIndex = 0;
+  for (let i = 0; i < count; i++) {
+    const elementOffset = i * stride;
+    for (let c = 0; c < numComponents; c++) {
+      const componentOffset = elementOffset + c * compInfo.size;
+      let value;
+      switch (accessor.componentType) {
+        case 5120:
+          value = dataView.getInt8(componentOffset);
+          break;
+        case 5121:
+          value = dataView.getUint8(componentOffset);
+          break;
+        case 5122:
+          value = dataView.getInt16(componentOffset, true);
+          break;
+        case 5123:
+          value = dataView.getUint16(componentOffset, true);
+          break;
+        case 5125:
+          value = dataView.getUint32(componentOffset, true);
+          break;
+        case 5126:
+          value = dataView.getFloat32(componentOffset, true);
+          break;
+        default:
+          throw new Error(`Unknown componentType ${accessor.componentType}`);
+      }
+      out[outIndex++] = accessor.normalized ? compInfo.norm(value) : value;
+    }
+  }
+  return out;
+}
+function readIndices(ctx, accessorIndex) {
+  const { gltf } = ctx;
+  const accessor = gltf.accessors?.[accessorIndex];
+  if (!accessor) throw new Error(`Invalid accessor index ${accessorIndex}`);
+  if (accessor.type !== "SCALAR")
+    throw new Error("Index accessor must be SCALAR");
+  const compInfo = COMPONENT_INFO[accessor.componentType];
+  if (!compInfo)
+    throw new Error(
+      `Unsupported index component type ${accessor.componentType}`
+    );
+  if (accessor.componentType !== 5121 && accessor.componentType !== 5123 && accessor.componentType !== 5125) {
+    throw new Error("Index componentType must be UNSIGNED_BYTE/SHORT/INT");
+  }
+  const byteOffset = accessor.byteOffset ?? 0;
+  if (typeof accessor.bufferView !== "number")
+    throw new Error(`Index accessor ${accessorIndex} missing bufferView`);
+  const {
+    array: src,
+    stride: bufferViewStride,
+    byteOffsetInView
+  } = getBufferViewSlice(ctx, accessor.bufferView, byteOffset);
+  const stride = bufferViewStride || compInfo.size;
+  const count = accessor.count;
+  const absoluteByteOffset = byteOffsetInView;
+  const canUseTightView = stride === compInfo.size && absoluteByteOffset % compInfo.size === 0;
+  if (canUseTightView) {
+    const TypedArrayCtor = compInfo.array;
+    const typed = new TypedArrayCtor(src.buffer, src.byteOffset, count);
+    if (accessor.componentType === 5125) {
+      return new Uint32Array(typed.buffer, typed.byteOffset, typed.length);
+    }
+    return new Uint32Array(typed);
+  }
+  const dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+  const out = new Uint32Array(count);
+  for (let i = 0; i < count; i++) {
+    const elementOffset = i * stride;
+    switch (accessor.componentType) {
+      case 5121:
+        out[i] = dataView.getUint8(elementOffset);
+        break;
+      case 5123:
+        out[i] = dataView.getUint16(elementOffset, true);
+        break;
+      case 5125:
+        out[i] = dataView.getUint32(elementOffset, true);
+        break;
     }
   }
   return out;
 }
-function parseVec3(value) {
-  if (typeof value !== "string") return null;
-  const parts = value.split(",").map(Number);
-  if (parts.length !== 3 || parts.some((n) => Number.isNaN(n))) return null;
-  return [parts[0], parts[1], parts[2]];
+function nodeLocalMatrix(node) {
+  if (node.matrix) {
+    const m2 = mat43.create();
+    for (let i = 0; i < 16; i++) m2[i] = node.matrix[i];
+    return m2;
+  }
+  const translation = node.translation || [0, 0, 0];
+  const rotation = node.rotation || [0, 0, 0, 1];
+  const scale = node.scale || [1, 1, 1];
+  const m = mat43.create();
+  const tmp = mat43.create();
+  mat43.fromRotationTranslationScale(tmp, rotation, translation, scale);
+  mat43.copy(m, tmp);
+  return m;
 }
-function isMainModule(meta) {
-  if (meta && typeof meta.main === "boolean") return !!meta.main;
-  if (!process.argv[1]) return false;
-  try {
-    const entryHref = pathToFileURL(process.argv[1]).href;
-    return entryHref === meta.url;
-  } catch {
-    return false;
+function getMaterial(gltf, textures, images, materialIndex) {
+  const material = (gltf.materials || [])[materialIndex ?? -1] || {};
+  const pbr = material.pbrMetallicRoughness || {};
+  const factor = pbr.baseColorFactor || [1, 1, 1, 1];
+  let texImg = null;
+  if (pbr.baseColorTexture && Number.isInteger(pbr.baseColorTexture.index)) {
+    const texIndex = pbr.baseColorTexture.index;
+    const tex = textures[texIndex];
+    if (tex && Number.isInteger(tex.source)) {
+      const imageIndex = tex.source;
+      texImg = images[imageIndex] || null;
+    }
   }
+  return { baseColorFactor: factor, baseColorTexture: texImg };
 }
-async function runCLI() {
-  const argv = parseCliArgs(process.argv.slice(2));
-  if (argv._.length === 0) {
-    console.error(
-      "Usage: node render_gltf_soft.js model.gltf [--out out.png] [--w 960] [--h 540] [--fov 60]"
+function createSceneFromGLTF(gltf, resources) {
+  const ctx = { gltf, buffers: resources.buffers };
+  const textures = gltf.textures || [];
+  const nodes = gltf.nodes || [];
+  const meshes = gltf.meshes || [];
+  const scenes = gltf.scenes || [];
+  const sceneIndex = Number.isInteger(gltf.scene) ? gltf.scene : 0;
+  const scene = scenes[sceneIndex] || { nodes: [] };
+  const drawCalls = [];
+  function traverse(nodeIndex, parentMatrix) {
+    const node = nodes[nodeIndex];
+    if (!node) return;
+    const local = nodeLocalMatrix(node);
+    const world = mat43.create();
+    mat43.multiply(world, parentMatrix, local);
+    if (Number.isInteger(node.mesh)) {
+      const mesh = meshes[node.mesh];
+      if (mesh) {
+        for (const primitive of mesh.primitives || []) {
+          if (primitive.mode != null && primitive.mode !== 4) continue;
+          const posAcc = primitive.attributes?.POSITION;
+          if (posAcc == null) continue;
+          const normalsAcc = primitive.attributes?.NORMAL;
+          const uvAcc = primitive.attributes?.TEXCOORD_0;
+          const positions = readAccessorAsFloat32(ctx, posAcc);
+          const normals = normalsAcc != null ? readAccessorAsFloat32(ctx, normalsAcc) : null;
+          const uvs = uvAcc != null ? readAccessorAsFloat32(ctx, uvAcc) : null;
+          const indices = primitive.indices != null ? readIndices(ctx, primitive.indices) : null;
+          const material = getMaterial(
+            gltf,
+            textures,
+            resources.images,
+            primitive.material
+          );
+          drawCalls.push({
+            positions,
+            normals,
+            uvs,
+            indices,
+            model: world,
+            material
+          });
+        }
+      }
+    }
+    for (const childIndex of node.children || []) {
+      traverse(childIndex, world);
+    }
+  }
+  const identity = mat43.create();
+  for (const rootIndex of scene.nodes || []) {
+    traverse(rootIndex, identity);
+  }
+  return { gltf, drawCalls };
+}
+
+// lib/gltf/resourceUtils.ts
+import { PassThrough } from "stream";
+import * as PImage from "pureimage";
+function bufferFromDataURI(uri) {
+  const match = uri.match(/^data:.*?;base64,(.*)$/);
+  if (!match) throw new Error(`Unsupported data URI: ${uri.slice(0, 64)}...`);
+  return Buffer.from(match[1], "base64");
+}
+function isPNG(filenameOrUri) {
+  return /\.png(\?|$)/i.test(filenameOrUri) || /image\/png/i.test(filenameOrUri);
+}
+function isJPG(filenameOrUri) {
+  return /(\.jpe?g(\?|$)|image\/jpe?g)/i.test(filenameOrUri);
+}
+function detectMimeTypeFromBuffer(buf, hint) {
+  if (hint) return hint;
+  if (buf.length >= 8 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10)
+    return "image/png";
+  if (buf.length >= 2 && buf[0] === 255 && buf[1] === 216) return "image/jpeg";
+  return null;
+}
+function bufferToStream(buf) {
+  const stream = new PassThrough();
+  stream.end(Buffer.from(buf));
+  return stream;
+}
+async function decodeImageFromBuffer(buf, mimeType) {
+  const type = detectMimeTypeFromBuffer(buf, mimeType);
+  if (type === "image/png")
+    return PImage.decodePNGFromStream(bufferToStream(buf));
+  if (type === "image/jpeg" || type === "image/jpg")
+    return PImage.decodeJPEGFromStream(bufferToStream(buf));
+  throw new Error(`Unsupported embedded image mimeType: ${mimeType ?? "unknown"}`);
+}
+
+// lib/gltf/parseGLB.ts
+var MAGIC = 1179937895;
+var JSON_CHUNK_TYPE = 1313821514;
+var BIN_CHUNK_TYPE = 5130562;
+function parseGLB(arrayBuffer) {
+  const view = new DataView(arrayBuffer);
+  const magic = view.getUint32(0, true);
+  if (magic !== MAGIC) throw new Error("Invalid GLB header magic.");
+  const version = view.getUint32(4, true);
+  if (version !== 2) throw new Error(`Unsupported GLB version ${version}.`);
+  const length = view.getUint32(8, true);
+  const decoder = new TextDecoder();
+  let json = null;
+  let binaryChunk = null;
+  const chunks = [];
+  let offset = 12;
+  while (offset < length) {
+    if (offset + 8 > length) throw new Error("Truncated GLB chunk header.");
+    const chunkLength = view.getUint32(offset, true);
+    const chunkType = view.getUint32(offset + 4, true);
+    offset += 8;
+    if (offset + chunkLength > length) throw new Error("Truncated GLB chunk data.");
+    const chunkData = new Uint8Array(arrayBuffer, offset, chunkLength);
+    offset += chunkLength;
+    if (chunkType === JSON_CHUNK_TYPE) {
+      json = JSON.parse(decoder.decode(chunkData));
+    } else if (chunkType === BIN_CHUNK_TYPE) {
+      binaryChunk = chunkData;
+    } else {
+      chunks.push({ type: chunkType, data: chunkData });
+    }
+  }
+  if (!json) throw new Error("GLB file is missing JSON chunk.");
+  return { gltf: json, binaryChunk, chunks };
+}
+
+// lib/gltf/loadGLTFWithResourcesFromURL.ts
+function ensureFetch(fetchImpl) {
+  const impl = fetchImpl ?? globalThis.fetch;
+  if (!impl) throw new Error("Global fetch API is not available; provide fetchImpl.");
+  return impl;
+}
+async function fetchBinary(fetchImpl, url) {
+  const res = await fetchImpl(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+  }
+  const buf = await res.arrayBuffer();
+  return new Uint8Array(buf);
+}
+async function loadGLTFWithResourcesFromURL(url, options = {}) {
+  const fetchImpl = ensureFetch(options.fetchImpl);
+  const response = await fetchImpl(url);
+  if (!response.ok)
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  const resolvedURL = new URL(response.url || url);
+  const baseURL = resolvedURL;
+  const sourceBuffer = await response.arrayBuffer();
+  const header = sourceBuffer.byteLength >= 4 ? new DataView(sourceBuffer, 0, 4) : null;
+  const isGLB = header?.getUint32(0, true) === 1179937895;
+  let gltf;
+  const totalBuffers = () => Array.isArray(gltf?.buffers) ? gltf.buffers.length : 0;
+  let buffers = [];
+  if (isGLB) {
+    const parsed = parseGLB(sourceBuffer);
+    gltf = parsed.gltf;
+    buffers = new Array(totalBuffers()).fill(null);
+    if (parsed.binaryChunk) buffers[0] = parsed.binaryChunk;
+  } else {
+    const text = new TextDecoder().decode(new Uint8Array(sourceBuffer));
+    gltf = JSON.parse(text);
+    buffers = new Array(totalBuffers()).fill(null);
+  }
+  async function resolveBuffer(index, entry) {
+    if (buffers[index]) return buffers[index];
+    if (entry?.uri) {
+      if (entry.uri.startsWith("data:")) {
+        const buf2 = bufferFromDataURI(entry.uri);
+        buffers[index] = buf2;
+        return buf2;
+      }
+      const resourceURL = new URL(
+        decodeURIComponent(entry.uri),
+        baseURL
+      ).toString();
+      const buf = await fetchBinary(fetchImpl, resourceURL);
+      buffers[index] = buf;
+      return buf;
+    }
+    throw new Error(`Buffer ${index} is missing a uri and no GLB chunk was provided.`);
+  }
+  await Promise.all(
+    (gltf.buffers || []).map(async (entry, idx) => {
+      await resolveBuffer(idx, entry);
+    })
+  );
+  async function resolveImage(img) {
+    if (img.uri) {
+      if (img.uri.startsWith("data:")) {
+        const buf2 = bufferFromDataURI(img.uri);
+        return decodeImageFromBuffer(buf2, img.mimeType);
+      }
+      const resourceURL = new URL(
+        decodeURIComponent(img.uri),
+        baseURL
+      ).toString();
+      const hintedMime = img.mimeType ? img.mimeType : isPNG(img.uri) ? "image/png" : isJPG(img.uri) ? "image/jpeg" : null;
+      const buf = await fetchBinary(fetchImpl, resourceURL);
+      return decodeImageFromBuffer(buf, hintedMime);
+    }
+    if (typeof img.bufferView === "number") {
+      const bufferView = gltf.bufferViews?.[img.bufferView];
+      if (!bufferView)
+        throw new Error(`Invalid image bufferView index ${img.bufferView}`);
+      const buffer = await resolveBuffer(bufferView.buffer, gltf.buffers?.[bufferView.buffer]);
+      if (!buffer)
+        throw new Error(`Missing buffer for image bufferView ${img.bufferView}`);
+      const byteOffset = bufferView.byteOffset ?? 0;
+      const byteLength = bufferView.byteLength;
+      if (typeof byteLength !== "number") {
+        throw new Error(
+          `bufferView ${img.bufferView} missing byteLength for image.`
+        );
+      }
+      const slice = buffer.subarray(byteOffset, byteOffset + byteLength);
+      return decodeImageFromBuffer(slice, img.mimeType);
+    }
+    throw new Error(
+      "images[*] entry missing uri or bufferView; unsupported in this loader."
     );
-    process.exit(1);
   }
-  const gltfPath = argv._[0];
-  const outPath = typeof argv.out === "string" ? argv.out : "out.png";
-  const width = parseInt(typeof argv.w === "string" ? argv.w : `${DEFAULT_RENDER_OPTIONS.width}`, 10);
-  const height = parseInt(typeof argv.h === "string" ? argv.h : `${DEFAULT_RENDER_OPTIONS.height}`, 10);
-  const fov = parseFloat(typeof argv.fov === "string" ? argv.fov : `${DEFAULT_RENDER_OPTIONS.fov}`);
-  const ambient = clamp(
-    parseFloat(typeof argv.ambient === "string" ? argv.ambient : `${DEFAULT_RENDER_OPTIONS.ambient}`),
-    0,
-    1
+  const images = await Promise.all(
+    (gltf.images || []).map((img) => resolveImage(img))
   );
-  const lightDir = parseVec3(argv.light) ?? DEFAULT_LIGHT_DIR;
-  const camPos = parseVec3(argv.cam);
-  const lookAt = parseVec3(argv.look);
-  const cull = argv.noCull ? false : true;
-  const gamma = argv.noGamma ? false : true;
-  await renderGLTFToPNGFile(gltfPath, outPath, {
-    width,
-    height,
-    fov,
-    ambient,
-    lightDir,
-    camPos,
-    lookAt,
-    cull,
-    gamma
+  return {
+    gltf,
+    resources: {
+      buffers,
+      images
+    }
+  };
+}
+
+// lib/image/pureImageFactory.ts
+import * as PImage2 from "pureimage";
+var pureImageFactory = (width, height) => PImage2.make(width, height);
+
+// lib/image/encodePNGToBuffer.ts
+import { PassThrough as PassThrough2 } from "stream";
+import * as PImage3 from "pureimage";
+async function encodePNGToBuffer(image) {
+  const passThrough = new PassThrough2();
+  const chunks = [];
+  passThrough.on("data", (chunk) => {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   });
-  console.log(`Wrote ${outPath} (${width}x${height})`);
+  const resultPromise = new Promise((resolve, reject) => {
+    passThrough.on("end", () => resolve(Buffer.concat(chunks)));
+    passThrough.on("error", reject);
+  });
+  await PImage3.encodePNGToStream(image, passThrough);
+  return await resultPromise;
 }
-if (isMainModule(import.meta)) {
-  runCLI().catch((err) => {
-    console.error(err);
-    process.exit(1);
+
+// lib/render/renderGLTFToPNGBufferFromURL.ts
+async function renderGLTFToPNGBufferFromURL(url, options = {}) {
+  const { fetchImpl, ...renderOptions } = options;
+  const { gltf, resources } = await loadGLTFWithResourcesFromURL(url, {
+    fetchImpl
   });
+  const scene = createSceneFromGLTF(gltf, resources);
+  const { bitmap } = renderDrawCalls(
+    scene.drawCalls,
+    renderOptions,
+    pureImageFactory
+  );
+  return encodePNGToBuffer(bitmap);
+}
+
+// lib/render/renderGLTFToPNGBufferFromGLBBuffer.ts
+function normalizeToArrayBuffer(source) {
+  if (source instanceof ArrayBuffer) return source;
+  const { buffer, byteOffset, byteLength } = source;
+  const viewBuffer = buffer;
+  return viewBuffer.slice(byteOffset, byteOffset + byteLength);
+}
+async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
+  const arrayBuffer = normalizeToArrayBuffer(glb);
+  const { gltf, binaryChunk } = parseGLB(arrayBuffer);
+  const totalBuffers = Array.isArray(gltf.buffers) ? gltf.buffers.length : 0;
+  const buffers = new Array(totalBuffers);
+  for (let index = 0; index < totalBuffers; index++) {
+    const entry = gltf.buffers[index];
+    if (entry?.uri) {
+      if (!entry.uri.startsWith("data:")) {
+        throw new Error(
+          `Buffer ${index} references external resource ${entry.uri}. Use renderGLTFToPNGBufferFromURL for GLBs with external buffer URIs.`
+        );
+      }
+      buffers[index] = bufferFromDataURI(entry.uri);
+      continue;
+    }
+    if (!binaryChunk) {
+      throw new Error(`GLB is missing the binary chunk required for buffer ${index}.`);
+    }
+    buffers[index] = binaryChunk;
+  }
+  const resolveBufferViewSlice = (bufferViewIndex) => {
+    const bufferView = gltf.bufferViews?.[bufferViewIndex];
+    if (!bufferView) {
+      throw new Error(`Invalid bufferView index ${bufferViewIndex}.`);
+    }
+    const bufferIndex = bufferView.buffer;
+    const buffer = buffers[bufferIndex];
+    if (!buffer) {
+      throw new Error(
+        `Missing buffer data for bufferView ${bufferViewIndex} (buffer ${bufferIndex}).`
+      );
+    }
+    const byteOffset = bufferView.byteOffset ?? 0;
+    const byteLength = bufferView.byteLength;
+    if (typeof byteLength !== "number") {
+      throw new Error(`bufferView ${bufferViewIndex} is missing byteLength.`);
+    }
+    return buffer.subarray(byteOffset, byteOffset + byteLength);
+  };
+  const images = await Promise.all(
+    (gltf.images ?? []).map(async (image, imageIndex) => {
+      if (image.uri) {
+        if (!image.uri.startsWith("data:")) {
+          throw new Error(
+            `Image ${imageIndex} references external resource ${image.uri}. Embed textures or load via renderGLTFToPNGBufferFromURL.`
+          );
+        }
+        const data = bufferFromDataURI(image.uri);
+        return decodeImageFromBuffer(data, image.mimeType);
+      }
+      if (typeof image.bufferView === "number") {
+        const slice = resolveBufferViewSlice(image.bufferView);
+        return decodeImageFromBuffer(slice, image.mimeType);
+      }
+      throw new Error(
+        `Image ${imageIndex} must supply a data URI or bufferView for GLB rendering.`
+      );
+    })
+  );
+  const scene = createSceneFromGLTF(gltf, { buffers, images });
+  const { bitmap } = renderDrawCalls(scene.drawCalls, options, pureImageFactory);
+  return encodePNGToBuffer(bitmap);
+}
+
+// lib/index.ts
+function renderSceneFromGLTF(scene, options, imageFactory) {
+  return renderDrawCalls(scene.drawCalls, options, imageFactory);
 }
 export {
   DEFAULT_LIGHT_DIR,
   DEFAULT_RENDER_OPTIONS,
   SoftwareRenderer,
+  bufferFromDataURI,
   buildCamera,
-  loadGLTF,
-  renderGLTFToPNGBuffer,
-  renderGLTFToPNGFile
+  computeSmoothNormals,
+  computeWorldAABB,
+  createSceneFromGLTF,
+  createUint8Bitmap,
+  decodeImageFromBuffer,
+  encodePNGToBuffer,
+  getDefaultRenderOptions,
+  isJPG,
+  isPNG,
+  loadGLTFWithResourcesFromURL,
+  pureImageFactory,
+  renderDrawCalls,
+  renderGLTFToPNGBufferFromGLBBuffer,
+  renderGLTFToPNGBufferFromURL,
+  renderSceneFromGLTF,
+  resolveRenderOptions
 };