poppygl 0.0.2 → 0.0.3

package/dist/index.js

@@ -10,14 +10,23 @@ function computeWorldAABB(drawCalls) {
   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.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]);
+      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 };
@@ -128,20 +137,31 @@ function computeSmoothNormals(positions, indices) {
       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 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];
-    normals[i0 * 3 + 0] += nx;
-    normals[i0 * 3 + 1] += ny;
-    normals[i0 * 3 + 2] += nz;
-    normals[i1 * 3 + 0] += nx;
-    normals[i1 * 3 + 1] += ny;
-    normals[i1 * 3 + 2] += nz;
-    normals[i2 * 3 + 0] += nx;
-    normals[i2 * 3 + 1] += ny;
-    normals[i2 * 3 + 2] += nz;
+    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];
@@ -218,11 +238,14 @@ var SoftwareRenderer = class {
     ];
   }
   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;
   }
@@ -276,9 +299,9 @@ var SoftwareRenderer = class {
       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];
@@ -291,9 +314,21 @@ var SoftwareRenderer = class {
       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.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 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]],
@@ -313,8 +348,9 @@ var SoftwareRenderer = class {
           const zndc = l0 * ndcZ[0] + l1 * ndcZ[1] + l2 * ndcZ[2];
           const z01 = zndc * 0.5 + 0.5;
           const di = y * this.width + x;
-          if (z01 >= this.depth[di]) continue;
-          this.depth[di] = z01;
+          const depth = this.depth;
+          if (z01 >= depth[di]) continue;
+          depth[di] = z01;
           let baseColor = [
             material.baseColorFactor[0],
             material.baseColorFactor[1],
@@ -330,9 +366,13 @@ 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 [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.ambient ?? DEFAULT_RENDER_OPTIONS.ambient,
@@ -467,6 +507,8 @@ function getBufferViewSlice(ctx, bufferViewIndex, byteOffset) {
   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}`);
@@ -500,6 +542,8 @@ function readAccessorAsFloat32(ctx, accessorIndex) {
       `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,
@@ -574,6 +618,8 @@ function readIndices(ctx, accessorIndex) {
     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,
@@ -630,9 +676,11 @@ function getMaterial(gltf, textures, images, materialIndex) {
   const factor = pbr.baseColorFactor || [1, 1, 1, 1];
   let texImg = null;
   if (pbr.baseColorTexture && Number.isInteger(pbr.baseColorTexture.index)) {
-    const tex = textures[pbr.baseColorTexture.index];
+    const texIndex = pbr.baseColorTexture.index;
+    const tex = textures[texIndex];
     if (tex && Number.isInteger(tex.source)) {
-      texImg = images[tex.source] || null;
+      const imageIndex = tex.source;
+      texImg = images[imageIndex] || null;
     }
   }
   return { baseColorFactor: factor, baseColorTexture: texImg };
@@ -695,7 +743,7 @@ function createSceneFromGLTF(gltf, resources) {
 
 // lib/gltf/resourceUtils.ts
 import { PassThrough } from "stream";
-import PImage from "pureimage";
+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)}...`);
@@ -872,12 +920,12 @@ async function loadGLTFWithResourcesFromURL(url, options = {}) {
 }
 
 // lib/image/pureImageFactory.ts
-import PImage2 from "pureimage";
+import * as PImage2 from "pureimage";
 var pureImageFactory = (width, height) => PImage2.make(width, height);
 
 // lib/image/encodePNGToBuffer.ts
 import { PassThrough as PassThrough2 } from "stream";
-import PImage3 from "pureimage";
+import * as PImage3 from "pureimage";
 async function encodePNGToBuffer(image) {
   const passThrough = new PassThrough2();
   const chunks = [];
@@ -911,7 +959,8 @@ async function renderGLTFToPNGBufferFromURL(url, options = {}) {
 function normalizeToArrayBuffer(source) {
   if (source instanceof ArrayBuffer) return source;
   const { buffer, byteOffset, byteLength } = source;
-  return buffer.slice(byteOffset, byteOffset + byteLength);
+  const viewBuffer = buffer;
+  return viewBuffer.slice(byteOffset, byteOffset + byteLength);
 }
 async function renderGLTFToPNGBufferFromGLBBuffer(glb, options = {}) {
   const arrayBuffer = normalizeToArrayBuffer(glb);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poppygl",
   "main": "dist/index.js",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/poppygl.git"