poppygl 0.0.33 → 0.0.35

package/README.md

@@ -86,10 +86,12 @@ Realistic mode supports base-color textures and scalar glTF metallic/roughness
 values. Normal maps, metallic/roughness textures, and custom HDR environments
 are not yet supported. Transparent and alpha-cutout surfaces do not cast shadows.
 
-Use realistic mode for saved images. At 600×600 with 2× supersampling, example
-models took 21–39 seconds to render, compared with 0.6–1.6 seconds in regular
-mode on the same machine. Reduce resolution or supersampling for faster output;
-render times vary with model complexity and hardware.
+Use realistic mode for saved images. At 600×600 with 2× supersampling, the RP2040
+motor-controller benchmark takes 2.26–5.49 seconds per warm render across three
+views, a 2.11–2.76× speedup over the previous realistic renderer on the same
+machine. Blender comparison error increases by at most 0.47%. See
+[benchmark results and reproduction steps](BENCHMARK.md#rp2040-motor-controller-500-sample-blender-baseline-and-2-gate).
+Render times vary with model complexity and hardware.
 
 ### Camera and background
 
@@ -131,10 +133,43 @@ const png = await renderGLTFToPNGFromGLB(glb, {
 - `cull`: enable back-face culling (default `true`).
 - `backgroundColor`: a hex string such as `"#e5e7eb"`, or an RGB tuple with values from 0 to 1.
 - `grid`: show a ground grid (default `false`), or provide grid options.
+- `showEdges`: draw visible boundary and crease edges on all triangle meshes (default `false`).
+- `showHiddenEdges`: draw visible edges plus faint dashed occluded edges on all meshes. Omit it or use `null` to preserve each model's flag; `false` disables those flags.
+- `edgeWidth`: width of both visible and hidden mesh edges in output pixels (default `1`).
+- `lineWidth`: width of glTF `LINES` and finite grid lines in output pixels (default `1`).
+- `hiddenEdgeOpacity`: opacity of dashed occluded mesh edges, from `0` to `1` (default `0.35`).
 - `fetchImpl`: optional override for resource loading (must match the `fetch` signature).
 
 You can inspect the defaults via `getDefaultRenderOptions()` or reuse the internal merge logic with `resolveRenderOptions()`.
 
+### Thicker edges and hidden geometry
+
+Enable edges directly when rendering an ordinary glTF or GLB, without editing its metadata:
+
+```ts
+const png = await renderGLTFToPNGFromGLB(glb, {
+  showHiddenEdges: true,
+  edgeWidth: 2.5,
+  hiddenEdgeOpacity: 0.35,
+  supersampling: 2,
+  backgroundColor: "#ffffff",
+})
+```
+
+Use `showEdges: true` for solid visible edges alone. Hidden segments use the
+scene depth buffer and appear dashed; edge overlays never replace geometry depth.
+Boundary and crease edges are extracted from the original triangle geometry,
+excluding coplanar triangulation diagonals. Smooth curved silhouettes are not
+additional extracted edges.
+
+Widths stay constant in the final image when supersampling changes. Positive,
+finite fractional widths are supported; invalid widths fall back to one pixel.
+Wider strokes use antialiased screen-space coverage with round caps in the
+software renderer. They are clipped before the perspective divide and remain
+depth tested across their full width. No GPU or shader runtime is required.
+`lineWidth` also applies to ordinary glTF line primitives and finite grid lines;
+the procedural infinite grid keeps its existing independent styling.
+
 ### Hidden edges for selected sub-models
 
 Set `showHiddenEdges` in a glTF node's `extras` to render that node with solid

package/dist/index.d.ts

@@ -31,6 +31,8 @@ interface DrawCall {
     colors?: Float32Array | null;
     mode?: number;
     showHiddenEdges?: boolean;
+    /** Source triangle third vertices for each extracted edge segment. */
+    edgeAdjacentVertices?: number[][];
 }
 interface GridOptions {
     size?: number | readonly [number, number, number];
@@ -100,6 +102,16 @@ interface RenderOptions {
     debugFontSize?: number | null;
     debugPointColor?: readonly [number, number, number] | null;
     debugLabelColor?: readonly [number, number, number] | null;
+    /** Draw visible boundary and crease edges on every triangle mesh. */
+    showEdges: boolean;
+    /** Override model showHiddenEdges flags; null preserves each model's flag. */
+    showHiddenEdges: boolean | null;
+    /** Width of visible and hidden mesh edges in output pixels. */
+    edgeWidth: number;
+    /** Width of glTF LINES and finite grid lines in output pixels. */
+    lineWidth: number;
+    /** Opacity of dashed, occluded mesh edges, from 0 to 1. */
+    hiddenEdgeOpacity: number;
 }
 type RenderOptionsInput = Partial<RenderOptions>;
 declare const DEFAULT_RENDER_OPTIONS: RenderOptions;
@@ -181,9 +193,13 @@ declare class StudioLighting {
     private eye;
     private shadowDirections;
     private diffuseCache;
+    private reflectionSamples;
+    private normalDiffuseCache;
+    private specularCache;
+    private blendedSpecular;
     constructor(drawCalls: DrawCall[], camera: Camera);
     private bounceRadiance;
-    shade(position: V3, n: V3, base: V3, material: Material, sampleIndex?: number): V3;
+    shade(position: V3, n: V3, base: V3, material: Material, pixelX?: number, pixelY?: number): V3;
 }
 
 interface LightSettings {
@@ -191,6 +207,8 @@ interface LightSettings {
     ambient: number;
 }
 interface LineRenderOptions {
+    /** Stroke width in this renderer's raster pixels. Defaults to one. */
+    width?: number;
     depthCompare?: "less" | "less-equal" | "greater";
     depthWrite?: boolean;
     depthBias?: number;
@@ -212,7 +230,11 @@ declare class SoftwareRenderer {
     drawLines(mesh: DrawCall, camera: Camera, gammaOut?: boolean, options?: LineRenderOptions): void;
     sampleTextureNearest(img: BitmapLike | null, u: number, v: number): MutableRGBA;
     perspInterp(attrs: number[][], invWs: number[], lambdas: number[]): number[];
-    drawMesh(mesh: DrawCall, camera: Camera, light: LightSettings, material: Material, cullBackFaces?: boolean, gammaOut?: boolean, studio?: StudioLighting): void;
+    drawMesh(mesh: DrawCall, camera: Camera, light: LightSettings, material: Material, cullBackFaces?: boolean, gammaOut?: boolean, studio?: StudioLighting, visibility?: {
+        winners: Int32Array;
+        triangleOffset: number;
+        depthOnly: boolean;
+    }): number;
 }
 
 /**

package/dist/index.js

@@ -271,7 +271,7 @@ function triangleNormal(positions, i0, i1, i2) {
   if (length === 0) return null;
   return [nx / length, ny / length, nz / length];
 }
-function addEdge(edges, positions, i0, i1, normal) {
+function addEdge(edges, positions, i0, i1, thirdVertex, normal) {
   const key0 = positionKey(positions, i0);
   const key1 = positionKey(positions, i1);
   const isForward = key0 < key1;
@@ -280,8 +280,13 @@ function addEdge(edges, positions, i0, i1, normal) {
   const existing = edges.get(key);
   if (existing) {
     if (normal) existing.normals.push(normal);
+    existing.adjacentVertices.push(thirdVertex);
   } else {
-    edges.set(key, { indices, normals: normal ? [normal] : [] });
+    edges.set(key, {
+      indices,
+      normals: normal ? [normal] : [],
+      adjacentVertices: [thirdVertex]
+    });
   }
 }
 function hasCrease(normals, minimumDot) {
@@ -307,15 +312,17 @@ function createEdgeDrawCall(mesh, creaseAngleDegrees = DEFAULT_CREASE_ANGLE_DEGR
     const i1 = triangleIndices[i + 1];
     const i2 = triangleIndices[i + 2];
     const normal = triangleNormal(mesh.positions, i0, i1, i2);
-    addEdge(edges, mesh.positions, i0, i1, normal);
-    addEdge(edges, mesh.positions, i1, i2, normal);
-    addEdge(edges, mesh.positions, i2, i0, normal);
+    addEdge(edges, mesh.positions, i0, i1, i2, normal);
+    addEdge(edges, mesh.positions, i1, i2, i0, normal);
+    addEdge(edges, mesh.positions, i2, i0, i1, normal);
   }
   const minimumDot = Math.cos(creaseAngleDegrees * Math.PI / 180);
   const edgeIndices = [];
+  const edgeAdjacentVertices = [];
   for (const edge2 of edges.values()) {
     if (!hasCrease(edge2.normals, minimumDot)) continue;
     edgeIndices.push(edge2.indices[0], edge2.indices[1]);
+    edgeAdjacentVertices.push(edge2.adjacentVertices);
   }
   if (edgeIndices.length === 0) return null;
   return {
@@ -329,7 +336,8 @@ function createEdgeDrawCall(mesh, creaseAngleDegrees = DEFAULT_CREASE_ANGLE_DEGR
       baseColorTexture: null,
       alphaMode: "BLEND"
     },
-    mode: 1
+    mode: 1,
+    edgeAdjacentVertices
   };
 }
 
@@ -490,7 +498,12 @@ var DEFAULT_RENDER_OPTIONS = {
   debugPoints: null,
   debugFontSize: null,
   debugPointColor: null,
-  debugLabelColor: null
+  debugLabelColor: null,
+  showEdges: false,
+  showHiddenEdges: null,
+  edgeWidth: 1,
+  lineWidth: 1,
+  hiddenEdgeOpacity: 0.35
 };
 function getDefaultRenderOptions() {
   return { ...DEFAULT_RENDER_OPTIONS };
@@ -598,14 +611,18 @@ var GeometryDenoiser = class {
     this.albedo = new Float32Array(count * 3);
     this.radiance = new Float32Array(count * 3);
     this.distance = new Float32Array(count);
+    this.horizontal = new Float32Array(count * 3);
   }
   ids;
   normals;
   albedo;
   radiance;
   distance;
+  horizontal;
   materials = /* @__PURE__ */ new WeakMap();
   nextId = 1;
+  first = Infinity;
+  last = -1;
   materialId(material) {
     let id = this.materials.get(material);
     if (!id) {
@@ -615,6 +632,8 @@ var GeometryDenoiser = class {
     return id;
   }
   record(index, id, n, albedo, radiance, distance) {
+    if (index < this.first) this.first = index;
+    if (index > this.last) this.last = index;
     this.ids[index] = id;
     this.normals.set(n, index * 3);
     this.albedo.set(albedo, index * 3);
@@ -622,43 +641,149 @@ var GeometryDenoiser = class {
     this.distance[index] = distance;
   }
   apply(output, gamma) {
-    const kernel = [1, 4, 6, 4, 1];
-    for (let y = 0; y < this.height; y++)
-      for (let x = 0; x < this.width; x++) {
-        const index = y * this.width + x, id = this.ids[index];
-        if (id === 0) continue;
-        const k = index * 3, n = this.normals, a = this.albedo;
-        let r = 0, g = 0, b = 0, total = 0;
-        for (let dy = -2; dy <= 2; dy++)
-          for (let dx = -2; dx <= 2; dx++) {
-            const px = x + dx, py = y + dy;
+    const kernel = [1, 8, 28, 56, 70, 56, 28, 8, 1];
+    const radius = 4;
+    const n = this.normals, a = this.albedo, ids = this.ids;
+    const firstRow = Math.floor(this.first / this.width);
+    const lastRow = Math.floor(this.last / this.width);
+    for (let pass = 0; pass < 2; pass++) {
+      const source = pass === 0 ? this.radiance : this.horizontal;
+      for (let y = firstRow; y <= lastRow; y++)
+        for (let x = 0; x < this.width; x++) {
+          const index = y * this.width + x, id = ids[index];
+          if (id === 0) continue;
+          const k = index * 3, distance = this.distance[index];
+          const nx = n[k], ny = n[k + 1], nz = n[k + 2];
+          const ar = a[k], ag = a[k + 1], ab = a[k + 2];
+          let r = 0, g = 0, b = 0, total = 0;
+          for (let delta = -radius; delta <= radius; delta++) {
+            const px = pass === 0 ? x + delta : x, py = pass === 0 ? y : y + delta;
             if (px < 0 || py < 0 || px >= this.width || py >= this.height)
               continue;
             const neighbor = py * this.width + px, p = neighbor * 3;
-            if (this.ids[neighbor] !== id) continue;
-            if (Math.abs(this.distance[index] - this.distance[neighbor]) > this.distance[index] * 0.02)
-              continue;
-            if (n[k] * n[p] + n[k + 1] * n[p + 1] + n[k + 2] * n[p + 2] < 0.98)
+            if (ids[neighbor] !== id) continue;
+            if (Math.abs(distance - this.distance[neighbor]) > distance * 0.02)
               continue;
-            if (Math.abs(a[k] - a[p]) + Math.abs(a[k + 1] - a[p + 1]) + Math.abs(a[k + 2] - a[p + 2]) > 0.03)
+            if (nx * n[p] + ny * n[p + 1] + nz * n[p + 2] < 0.98) continue;
+            if (Math.abs(ar - a[p]) + Math.abs(ag - a[p + 1]) + Math.abs(ab - a[p + 2]) > 0.03)
               continue;
-            const weight = kernel[dy + 2] * kernel[dx + 2];
+            const weight = kernel[delta + radius];
             total += weight;
-            r += this.radiance[p] * weight;
-            g += this.radiance[p + 1] * weight;
-            b += this.radiance[p + 2] * weight;
+            r += source[p] * weight;
+            g += source[p + 1] * weight;
+            b += source[p + 2] * weight;
           }
-        if (!total) continue;
-        const encode2 = (value) => Math.floor(
-          255 * (gamma ? srgbEncodeLinear01(Math.max(0, Math.min(1, value / total))) : Math.max(0, Math.min(1, value / total)))
-        );
-        output[index * 4] = encode2(r);
-        output[index * 4 + 1] = encode2(g);
-        output[index * 4 + 2] = encode2(b);
-      }
+          if (pass === 0) {
+            this.horizontal[k] = r / total;
+            this.horizontal[k + 1] = g / total;
+            this.horizontal[k + 2] = b / total;
+          } else {
+            const encode2 = (value) => Math.floor(
+              255 * (gamma ? srgbEncodeLinear01(
+                Math.max(0, Math.min(1, value / total))
+              ) : Math.max(0, Math.min(1, value / total)))
+            );
+            output[index * 4] = encode2(r);
+            output[index * 4 + 1] = encode2(g);
+            output[index * 4 + 2] = encode2(b);
+          }
+        }
+    }
   }
 };
 
+// lib/render/rasterizeWideLine.ts
+function clipLine(start, end, marginX, marginY) {
+  if (![...start, ...end].every(Number.isFinite)) return null;
+  const distances = (p) => [
+    p[3] * (1 + marginX) + p[0],
+    p[3] * (1 + marginX) - p[0],
+    p[3] * (1 + marginY) + p[1],
+    p[3] * (1 + marginY) - p[1],
+    p[3] + p[2],
+    p[3] - p[2]
+  ];
+  const a = distances(start);
+  const b = distances(end);
+  let from = 0;
+  let to = 1;
+  for (let plane = 0; plane < 6; plane++) {
+    if (a[plane] < 0 && b[plane] < 0) return null;
+    if (a[plane] < 0 !== b[plane] < 0) {
+      const t = a[plane] / (a[plane] - b[plane]);
+      if (a[plane] < 0) from = Math.max(from, t);
+      else to = Math.min(to, t);
+    }
+  }
+  if (from > to) return null;
+  return [from, to].map(
+    (t) => Array.from(start, (value, axis) => value + t * (end[axis] - value))
+  );
+}
+function rasterizeWideLine(start, end, width, height, strokeWidth, dashed, dashLength, fragment) {
+  const radius = strokeWidth / 2;
+  const padding = radius + 0.5;
+  const clipped = clipLine(
+    start,
+    end,
+    2 * padding / Math.max(1, width - 1),
+    2 * padding / Math.max(1, height - 1)
+  );
+  if (!clipped) return;
+  const project = (p) => [
+    (p[0] / p[3] * 0.5 + 0.5) * (width - 1),
+    (0.5 - p[1] / p[3] * 0.5) * (height - 1),
+    // Clipping guarantees this range; absorb near/far-plane roundoff so an
+    // endpoint's round cap is not discarded at z = -epsilon.
+    Math.max(0, Math.min(1, p[2] / p[3] * 0.5 + 0.5))
+  ];
+  const a = project(clipped[0]);
+  const b = project(clipped[1]);
+  if (![...a, ...b].every(Number.isFinite)) return;
+  const [x0, y0, z0] = a;
+  const [x1, y1, z1] = b;
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const lengthSquared = dx * dx + dy * dy;
+  const length = Math.sqrt(lengthSquared);
+  const original = start[3] > 0 ? project(start) : a;
+  const phase = Math.hypot(x0 - original[0], y0 - original[1]);
+  const drawPixel = (x, y) => {
+    const t = lengthSquared === 0 ? 0 : Math.max(
+      0,
+      Math.min(1, ((x - x0) * dx + (y - y0) * dy) / lengthSquared)
+    );
+    if (dashed && Math.floor((phase + t * length) / dashLength) % 2 === 1)
+      return;
+    const distance = Math.hypot(x - (x0 + t * dx), y - (y0 + t * dy));
+    const coverage = Math.min(1, padding - distance);
+    if (coverage > 0) fragment(x, y, z0 + t * (z1 - z0), coverage);
+  };
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    const band = length === 0 ? padding : padding * length / Math.abs(dx);
+    const first = Math.max(0, Math.ceil(Math.min(x0, x1) - padding));
+    const last = Math.min(width - 1, Math.floor(Math.max(x0, x1) + padding));
+    for (let x = first; x <= last; x++) {
+      const t = dx === 0 ? 0 : Math.max(0, Math.min(1, (x - x0) / dx));
+      const centerY = y0 + t * dy;
+      const top = Math.max(0, Math.ceil(centerY - band));
+      const bottom = Math.min(height - 1, Math.floor(centerY + band));
+      for (let y = top; y <= bottom; y++) drawPixel(x, y);
+    }
+  } else {
+    const band = padding * length / Math.abs(dy);
+    const first = Math.max(0, Math.ceil(Math.min(y0, y1) - padding));
+    const last = Math.min(height - 1, Math.floor(Math.max(y0, y1) + padding));
+    for (let y = first; y <= last; y++) {
+      const t = Math.max(0, Math.min(1, (y - y0) / dy));
+      const centerX = x0 + t * dx;
+      const left = Math.max(0, Math.ceil(centerX - band));
+      const right = Math.min(width - 1, Math.floor(centerX + band));
+      for (let x = left; x <= right; x++) drawPixel(x, y);
+    }
+  }
+}
+
 // lib/render/SoftwareRenderer.ts
 var SoftwareRenderer = class {
   width;
@@ -711,6 +836,7 @@ var SoftwareRenderer = class {
     const vScreen = new Array(vertexCount);
     const vInvW = new Float32Array(vertexCount);
     const vNDCz = new Float32Array(vertexCount);
+    const clipVertices = [];
     for (let i = 0; i < vertexCount; i++) {
       const p = vec42.fromValues(
         positions[i * 3 + 0],
@@ -720,6 +846,7 @@ var SoftwareRenderer = class {
       );
       const c = vec42.create();
       vec42.transformMat4(c, p, mvp);
+      clipVertices.push(c);
       const invW = 1 / c[3];
       vInvW[i] = invW;
       if (!isFinite(invW)) {
@@ -754,9 +881,76 @@ var SoftwareRenderer = class {
     const depthWrite = options.depthWrite ?? true;
     const depthBias = options.depthBias ?? 0;
     const dashLength = Math.max(1, options.dashLength ?? 4);
+    const strokeWidth = typeof options.width === "number" && Number.isFinite(options.width) && options.width > 0 ? options.width : 1;
+    const drawFragment = (xi, yi, z, coverage = 1) => {
+      if (z < 0 || z > 1) return;
+      const di = yi * this.width + xi;
+      const currentDepth = this.depth[di];
+      const passesDepth = depthCompare === "greater" ? z > currentDepth + depthBias : depthCompare === "less-equal" ? z <= currentDepth + depthBias : z < currentDepth - depthBias;
+      if (!passesDepth) return;
+      if (depthWrite) this.depth[di] = z;
+      const pixelIndex = di * 4;
+      const destinationAlpha = this.buffer[pixelIndex + 3] / 255;
+      const alpha = sourceAlpha * coverage;
+      const oneMinusSourceAlpha = 1 - alpha;
+      const outAlpha = alpha + destinationAlpha * oneMinusSourceAlpha;
+      const blend = (channel, offset) => outAlpha === 0 ? 0 : (channel * alpha + this.buffer[pixelIndex + offset] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
+      this.setPixel(
+        xi,
+        yi,
+        blend(r255, 0),
+        blend(g255, 1),
+        blend(b255, 2),
+        outAlpha * 255
+      );
+    };
     for (let i = 0; i < indices.length; i += 2) {
       const i0 = indices[i + 0];
       const i1 = indices[i + 1];
+      if (strokeWidth !== 1) {
+        const sourceFaces = (mesh.edgeAdjacentVertices?.[i / 2] ?? []).flatMap(
+          (third) => {
+            if (clipVertices[i0][3] <= 0 || clipVertices[i1][3] <= 0 || clipVertices[third][3] <= 0)
+              return [];
+            const a2 = vScreen[i0];
+            const b2 = vScreen[i1];
+            const c = vScreen[third];
+            const area = edge(a2, b2, c);
+            if (!Number.isFinite(area) || area === 0) return [];
+            return [{ a: a2, b: b2, c, inverseArea: 1 / area, third }];
+          }
+        );
+        rasterizeWideLine(
+          clipVertices[i0],
+          clipVertices[i1],
+          this.width,
+          this.height,
+          strokeWidth,
+          options.dashed ?? false,
+          dashLength,
+          sourceFaces.length === 0 ? drawFragment : (x2, y2, z2, coverage) => {
+            let surfaceDepth = Infinity;
+            const sample = [x2 + 0.5, y2 + 0.5];
+            for (const face of sourceFaces) {
+              const l0 = edge(face.b, face.c, sample) * face.inverseArea;
+              const l1 = edge(face.c, face.a, sample) * face.inverseArea;
+              const l2 = 1 - l0 - l1;
+              if (l0 < -1e-6 || l1 < -1e-6 || l2 < -1e-6) continue;
+              const depth = (l0 * vNDCz[i0] + l1 * vNDCz[i1] + l2 * vNDCz[face.third]) * 0.5 + 0.5;
+              if (depth >= 0 && depth <= 1) {
+                surfaceDepth = Math.min(surfaceDepth, depth);
+              }
+            }
+            drawFragment(
+              x2,
+              y2,
+              surfaceDepth === Infinity ? z2 : surfaceDepth,
+              coverage
+            );
+          }
+        );
+        continue;
+      }
       const v0s = vScreen[i0];
       const v1s = vScreen[i1];
       const z0_ndc = vNDCz[i0];
@@ -789,20 +983,7 @@ var SoftwareRenderer = class {
         const xi = Math.round(x);
         const yi = Math.round(y);
         if (xi >= 0 && xi < this.width && yi >= 0 && yi < this.height && z >= 0 && z <= 1) {
-          const di = yi * this.width + xi;
-          const currentDepth = this.depth[di];
-          const passesDepth = depthCompare === "greater" ? z > currentDepth + depthBias : depthCompare === "less-equal" ? z <= currentDepth + depthBias : z < currentDepth - depthBias;
-          if (passesDepth) {
-            if (depthWrite) this.depth[di] = z;
-            const pixelIndex = di * 4;
-            const destinationAlpha = this.buffer[pixelIndex + 3] / 255;
-            const oneMinusSourceAlpha = 1 - sourceAlpha;
-            const outAlpha = sourceAlpha + destinationAlpha * oneMinusSourceAlpha;
-            const outR = outAlpha === 0 ? 0 : (r255 * sourceAlpha + this.buffer[pixelIndex + 0] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            const outG = outAlpha === 0 ? 0 : (g255 * sourceAlpha + this.buffer[pixelIndex + 1] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            const outB = outAlpha === 0 ? 0 : (b255 * sourceAlpha + this.buffer[pixelIndex + 2] * destinationAlpha * oneMinusSourceAlpha) / outAlpha;
-            this.setPixel(xi, yi, outR, outG, outB, outAlpha * 255);
-          }
+          drawFragment(xi, yi, z);
         }
         x += xinc;
         y += yinc;
@@ -835,9 +1016,15 @@ var SoftwareRenderer = class {
     }
     return out;
   }
-  drawMesh(mesh, camera, light, material, cullBackFaces = true, gammaOut = true, studio) {
+  drawMesh(mesh, camera, light, material, cullBackFaces = true, gammaOut = true, studio, visibility) {
     let { positions, normals, uvs, indices, model, colors } = mesh;
     const materialId = this.denoiser?.materialId(material) ?? 0;
+    const lightDir = light.dir ?? DEFAULT_LIGHT_DIR;
+    const ambient = clamp(light.ambient ?? DEFAULT_RENDER_OPTIONS.ambient, 0, 1);
+    const L = studio ? null : vec32.normalize(
+      vec32.create(),
+      vec32.fromValues(lightDir[0], lightDir[1], lightDir[2])
+    );
     const view = camera.view;
     const proj = camera.proj;
     const mvp = mat43.create();
@@ -864,12 +1051,17 @@ var SoftwareRenderer = class {
     colors = clipped.colors;
     idx = clipped.indices;
     vertexCount = positions.length / 3;
+    const depthOnly = visibility?.depthOnly ?? false;
     const vScreen = new Array(vertexCount);
     const vInvW = new Float32Array(vertexCount);
     const vNDCz = new Float32Array(vertexCount);
-    const vWorldN = new Array(vertexCount);
-    const vWorldP = studio ? new Array(vertexCount) : null;
-    const vColor = new Array(vertexCount);
+    const vWorldN = new Array(
+      depthOnly ? 0 : vertexCount
+    );
+    const vWorldP = studio && !depthOnly ? new Array(vertexCount) : null;
+    const vColor = new Array(
+      depthOnly ? 0 : vertexCount
+    );
     for (let i = 0; i < vertexCount; i++) {
       const p = vec42.fromValues(
         positions[i * 3 + 0],
@@ -892,6 +1084,7 @@ var SoftwareRenderer = class {
       vScreen[i] = [sx, sy];
       vInvW[i] = invW;
       vNDCz[i] = ndcZ;
+      if (depthOnly) continue;
       const n = vec32.fromValues(
         useNormals[i * 3 + 0],
         useNormals[i * 3 + 1],
@@ -969,9 +1162,15 @@ var SoftwareRenderer = class {
           const z01 = zndc * 0.5 + 0.5;
           if (z01 < 0 || z01 > 1) continue;
           const di = y * this.width + x;
+          if (visibility && !visibility.depthOnly && visibility.winners[di] !== visibility.triangleOffset + i / 3)
+            continue;
           const depth = this.depth;
           if (z01 >= depth[di]) continue;
           depth[di] = z01;
+          if (visibility?.depthOnly) {
+            visibility.winners[di] = visibility.triangleOffset + i / 3;
+            continue;
+          }
           let baseColor = [
             material.baseColorFactor[0],
             material.baseColorFactor[1],
@@ -1006,24 +1205,7 @@ var SoftwareRenderer = class {
             np1 / nlen,
             np2 / nlen
           ];
-          const lightDir = light.dir ?? DEFAULT_LIGHT_DIR;
-          const ambient = clamp(
-            light.ambient ?? DEFAULT_RENDER_OPTIONS.ambient,
-            0,
-            1
-          );
-          const L = vec32.normalize(
-            vec32.create(),
-            vec32.fromValues(lightDir[0], lightDir[1], lightDir[2])
-          );
-          const ndotl = Math.max(
-            0,
-            nrm[0] * -L[0] + nrm[1] * -L[1] + nrm[2] * -L[2]
-          );
-          const lit = ambient + (1 - ambient) * ndotl;
-          let r = baseColor[0] * lit;
-          let g = baseColor[1] * lit;
-          let b = baseColor[2] * lit;
+          let r = 0, g = 0, b = 0;
           if (studio && worldPositions) {
             const position = this.perspInterp(worldPositions, invW, [
               l0,
@@ -1035,8 +1217,18 @@ var SoftwareRenderer = class {
               nrm,
               [baseColor[0], baseColor[1], baseColor[2]],
               material,
-              di
+              x,
+              y
             );
+          } else {
+            const ndotl = Math.max(
+              0,
+              nrm[0] * -L[0] + nrm[1] * -L[1] + nrm[2] * -L[2]
+            );
+            const lit = ambient + (1 - ambient) * ndotl;
+            r = baseColor[0] * lit;
+            g = baseColor[1] * lit;
+            b = baseColor[2] * lit;
           }
           const emission = material.emissiveFactor ?? [0, 0, 0];
           const strength = material.emissiveStrength ?? 1;
@@ -1117,6 +1309,7 @@ var SoftwareRenderer = class {
         }
       }
     }
+    return idx.length / 3;
   }
 };
 function edge(a, b, p) {
@@ -1463,9 +1656,17 @@ function resolveRenderOptions(options = {}) {
     camPos: options.camPos !== void 0 ? options.camPos : DEFAULT_RENDER_OPTIONS.camPos,
     lookAt: options.lookAt !== void 0 ? options.lookAt : DEFAULT_RENDER_OPTIONS.lookAt,
     up: resolveCameraUp(options.up),
-    cameraRotation: resolveCameraRotation(options.cameraRotation)
+    cameraRotation: resolveCameraRotation(options.cameraRotation),
+    showEdges: options.showEdges === true,
+    showHiddenEdges: typeof options.showHiddenEdges === "boolean" ? options.showHiddenEdges : null,
+    edgeWidth: resolveWidth(options.edgeWidth),
+    lineWidth: resolveWidth(options.lineWidth),
+    hiddenEdgeOpacity: typeof options.hiddenEdgeOpacity === "number" && Number.isFinite(options.hiddenEdgeOpacity) ? Math.max(0, Math.min(1, options.hiddenEdgeOpacity)) : DEFAULT_RENDER_OPTIONS.hiddenEdgeOpacity
   };
 }
+function resolveWidth(width) {
+  return typeof width === "number" && Number.isFinite(width) && width > 0 ? width : 1;
+}
 
 // lib/render/StudioLighting.ts
 import { mat4 as mat46 } from "gl-matrix";
@@ -1502,15 +1703,16 @@ var RayOcclusion = class {
       if ((dc.mode ?? 4) !== 4 || dc.material.alphaMode === "BLEND") continue;
       if (dc.material.alphaMode === "MASK") continue;
       const count = dc.indices?.length ?? dc.positions.length / 3;
-      const vertex = (index) => {
-        const i = (dc.indices?.[index] ?? index) * 3;
+      const worldVertices = [];
+      for (let i = 0; i < dc.positions.length; i += 3) {
         const p = vec33.transformMat4(
           vec33.create(),
           [dc.positions[i], dc.positions[i + 1], dc.positions[i + 2]],
           dc.model
         );
-        return [p[0], p[1], p[2]];
-      };
+        worldVertices.push([p[0], p[1], p[2]]);
+      }
+      const vertex = (index) => worldVertices[dc.indices?.[index] ?? index];
       for (let i = 0; i < count; i += 3) {
         const p = vertex(i), q = vertex(i + 1), r = vertex(i + 2);
         const min = [0, 1, 2].map(
@@ -1586,52 +1788,97 @@ var RayOcclusion = class {
     }
   }
   build(triangles) {
-    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity], centerMin = [Infinity, Infinity, Infinity], centerMax = [-Infinity, -Infinity, -Infinity];
     for (const t of triangles)
       for (let a = 0; a < 3; a++) {
         min[a] = Math.min(min[a], t.min[a]);
         max[a] = Math.max(max[a], t.max[a]);
+        centerMin[a] = Math.min(centerMin[a], t.center[a]);
+        centerMax[a] = Math.max(centerMax[a], t.center[a]);
       }
     if (triangles.length <= 8) return { min, max, triangles };
+    const binCount = 16;
     const area = (lo, hi) => {
       const x = hi[0] - lo[0], y = hi[1] - lo[1], z = hi[2] - lo[2];
       return 2 * (x * y + y * z + z * x);
     };
-    let bestCost = Infinity, middle = triangles.length >> 1, best = triangles;
+    let bestCost = Infinity, bestAxis = -1, bestSplit = 0, bestMin = 0, bestScale = 0;
+    let longestAxis = 0;
+    for (let a = 1; a < 3; a++)
+      if (centerMax[a] - centerMin[a] > centerMax[longestAxis] - centerMin[longestAxis])
+        longestAxis = a;
     for (let axis = 0; axis < 3; axis++) {
-      const sorted = triangles.slice().sort((a, b) => a.center[axis] - b.center[axis]);
-      const suffix = new Float64Array(sorted.length);
-      let lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
-      for (let i = sorted.length - 1; i >= 0; i--) {
+      if (triangles.length <= 4096 && axis !== longestAxis) continue;
+      const loCenter = centerMin[axis], hiCenter = centerMax[axis];
+      if (loCenter === hiCenter) continue;
+      const scale = binCount / (hiCenter - loCenter);
+      const counts = new Uint32Array(binCount);
+      const bounds = new Float64Array(binCount * 6);
+      for (let i = 0; i < binCount; i++) {
+        bounds.fill(Infinity, i * 6, i * 6 + 3);
+        bounds.fill(-Infinity, i * 6 + 3, i * 6 + 6);
+      }
+      for (const t of triangles) {
+        const bin = Math.min(
+          binCount - 1,
+          Math.floor((t.center[axis] - loCenter) * scale)
+        );
+        counts[bin]++;
+        const offset = bin * 6;
         for (let a = 0; a < 3; a++) {
-          lo[a] = Math.min(lo[a], sorted[i].min[a]);
-          hi[a] = Math.max(hi[a], sorted[i].max[a]);
+          bounds[offset + a] = Math.min(bounds[offset + a], t.min[a]);
+          bounds[offset + a + 3] = Math.max(bounds[offset + a + 3], t.max[a]);
         }
-        suffix[i] = area(lo, hi);
+      }
+      const suffixCost = new Float64Array(binCount);
+      let lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity], count = 0;
+      for (let i = binCount - 1; i >= 0; i--) {
+        count += counts[i];
+        if (counts[i])
+          for (let a = 0; a < 3; a++) {
+            lo[a] = Math.min(lo[a], bounds[i * 6 + a]);
+            hi[a] = Math.max(hi[a], bounds[i * 6 + a + 3]);
+          }
+        suffixCost[i] = count ? area(lo, hi) * count : 0;
       }
       lo = [Infinity, Infinity, Infinity];
       hi = [-Infinity, -Infinity, -Infinity];
-      for (let i = 1; i < sorted.length; i++) {
-        const triangle = sorted[i - 1];
-        for (let a = 0; a < 3; a++) {
-          lo[a] = Math.min(lo[a], triangle.min[a]);
-          hi[a] = Math.max(hi[a], triangle.max[a]);
-        }
-        if (triangle.center[axis] === sorted[i].center[axis]) continue;
-        const cost = area(lo, hi) * i + suffix[i] * (sorted.length - i);
+      count = 0;
+      for (let i = 0; i < binCount - 1; i++) {
+        count += counts[i];
+        if (counts[i])
+          for (let a = 0; a < 3; a++) {
+            lo[a] = Math.min(lo[a], bounds[i * 6 + a]);
+            hi[a] = Math.max(hi[a], bounds[i * 6 + a + 3]);
+          }
+        if (!count || count === triangles.length) continue;
+        const cost = area(lo, hi) * count + suffixCost[i + 1];
         if (cost < bestCost) {
           bestCost = cost;
-          middle = i;
-          best = sorted;
+          bestAxis = axis;
+          bestSplit = i;
+          bestMin = loCenter;
+          bestScale = scale;
         }
       }
     }
-    return {
-      min,
-      max,
-      left: this.build(best.slice(0, middle)),
-      right: this.build(best.slice(middle))
-    };
+    let left, right;
+    if (bestAxis < 0) {
+      const middle = triangles.length >> 1;
+      left = triangles.slice(0, middle);
+      right = triangles.slice(middle);
+    } else {
+      left = [];
+      right = [];
+      for (const t of triangles) {
+        const bin = Math.min(
+          binCount - 1,
+          Math.floor((t.center[bestAxis] - bestMin) * bestScale)
+        );
+        (bin <= bestSplit ? left : right).push(t);
+      }
+    }
+    return { min, max, left: this.build(left), right: this.build(right) };
   }
   prepareRay(direction) {
     this.parallelAxes = 0;
@@ -1766,6 +2013,9 @@ var W = 96;
 var H = 48;
 var SAMPLES = 128;
 var ROUGHNESSES = [0.04, 0.1, 0.18, 0.28, 0.4, 0.55, 0.7, 0.85, 1];
+var SHADOW_SAMPLES = 4;
+var REFLECTION_SAMPLES = 4;
+var DIFFUSE_SAMPLES = 2;
 var lobes = studio_environment_default.lobes.map((l) => ({
   ...l,
   direction: normalize(l.direction),
@@ -1898,6 +2148,22 @@ var StudioLighting = class {
   eye;
   shadowDirections;
   diffuseCache = /* @__PURE__ */ new WeakMap();
+  reflectionSamples = /* @__PURE__ */ new Map();
+  normalDiffuseCache = /* @__PURE__ */ new WeakMap();
+  specularCache = /* @__PURE__ */ new Map();
+  blendedSpecular(rough, level, blend) {
+    const cached = this.specularCache.get(rough);
+    if (cached) return cached;
+    if (this.specularCache.size >= 16) return null;
+    const tables = lobes.map((_, j) => {
+      const lo = this.tables.specular[level][j], hi = this.tables.specular[level + 1][j], table = new Float64Array(W * H);
+      for (let i = 0; i < table.length; i++)
+        table[i] = lo[i] * (1 - blend) + hi[i] * blend;
+      return table;
+    });
+    this.specularCache.set(rough, tables);
+    return tables;
+  }
   constructor(drawCalls, camera) {
     this.occlusion = new RayOcclusion(drawCalls);
     const world = mat46.invert(mat46.create(), camera.view);
@@ -1906,8 +2172,8 @@ var StudioLighting = class {
     this.eye = [world[12], world[13], world[14]];
     this.shadowDirections = lobes.map((l) => {
       const [t, b] = basis(l.direction);
-      return Array.from({ length: 8 }, (_, i) => {
-        const u = (i + 0.5) / 8, cos = 1 + Math.log(1 - u) / l.sharpness, sin = Math.sqrt(Math.max(0, 1 - cos * cos)), phi = 2 * Math.PI * radicalInverse(i);
+      return Array.from({ length: SHADOW_SAMPLES }, (_, i) => {
+        const u = (i + 0.5) / SHADOW_SAMPLES, cos = 1 + Math.log(1 - u) / l.sharpness, sin = Math.sqrt(Math.max(0, 1 - cos * cos)), phi = 2 * Math.PI * radicalInverse(i);
         const direction = orient(
           sin * Math.cos(phi),
           sin * Math.sin(phi),
@@ -1965,15 +2231,16 @@ var StudioLighting = class {
     );
     const pref = [...studio_environment_default.ambient];
     const reflectedLookup = tableLookup(reflected);
+    const specularTables = this.blendedSpecular(rough, level, blend);
     for (let j = 0; j < lobes.length; j++) {
-      const value = sampleTable(this.tables.specular[level][j], reflectedLookup) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflectedLookup) * blend;
+      const value = specularTables ? sampleTable(specularTables[j], reflectedLookup) : sampleTable(this.tables.specular[level][j], reflectedLookup) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflectedLookup) * blend;
       for (let k = 0; k < 3; k++) pref[k] += value * lobes[j].color[k];
     }
     for (let k = 0; k < 3; k++)
       radiance[k] += pref[k] * ((0.04 * (1 - metal) + base[k] * metal) * A + B);
     return radiance;
   }
-  shade(position, n, base, material, sampleIndex = 0) {
+  shade(position, n, base, material, pixelX = 0, pixelY = 0) {
     const v = normalize([
       this.eye[0] - position[0],
       this.eye[1] - position[1],
@@ -2005,12 +2272,20 @@ var StudioLighting = class {
     const specColor = f0.map(
       (c, j) => studio_environment_default.ambient[j] * (c * A + B)
     );
-    let bits = sampleIndex + 1;
-    bits = Math.imul(bits ^ bits >>> 16, 2146121005);
-    bits = Math.imul(bits ^ bits >>> 15, 2221713035);
-    const hash = ((bits ^ bits >>> 16) >>> 0) / 4294967296;
+    const gradient = (0.06711056 * pixelX + 583715e-8 * pixelY) % 1;
+    const hash = 52.9829189 * gradient % 1;
     const phase = hash * 2 * Math.PI, cosPhase = Math.cos(phase), sinPhase = Math.sin(phase);
-    const normalLookup = tableLookup(n), reflectedLookup = tableLookup(reflected);
+    let normalDiffuse = this.normalDiffuseCache.get(material);
+    if (!normalDiffuse || normalDiffuse.normal.some((value, k) => !Object.is(value, n[k]))) {
+      const lookup = tableLookup(n);
+      normalDiffuse = {
+        normal: [...n],
+        values: this.tables.diffuse.map((table) => sampleTable(table, lookup))
+      };
+      this.normalDiffuseCache.set(material, normalDiffuse);
+    }
+    const reflectedLookup = tableLookup(reflected);
+    const specularTables = this.blendedSpecular(rough, level, blend);
     for (let j = 0; j < lobes.length; j++) {
       const dirs = this.shadowDirections[j];
       let visible = 0, total = 0;
@@ -2025,8 +2300,8 @@ var StudioLighting = class {
         if (weight > 0 && !this.occlusion.occluded(origin, l)) visible += weight;
       }
       const visibility = total > 0 ? visible / total : 1;
-      const diffuse = sampleTable(this.tables.diffuse[j], normalLookup) * visibility;
-      const specular = (sampleTable(this.tables.specular[level][j], reflectedLookup) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflectedLookup) * blend) * visibility;
+      const diffuse = normalDiffuse.values[j] * visibility;
+      const specular = (specularTables ? sampleTable(specularTables[j], reflectedLookup) : sampleTable(this.tables.specular[level][j], reflectedLookup) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflectedLookup) * blend) * visibility;
       for (let k = 0; k < 3; k++) {
         color[k] += lobes[j].color[k] * base[k] * (1 - metal) * 0.96 * diffuse;
         specColor[k] += lobes[j].color[k] * (f0[k] * A + B) * specular;
@@ -2034,8 +2309,8 @@ var StudioLighting = class {
     }
     const [t, b] = basis(n);
     let blocked = 0;
-    for (let i = 0; metal < 1 && i < 4; i++) {
-      const phi = i * Math.PI / 2 + phase, l = orient(
+    for (let i = 0; metal < 1 && i < DIFFUSE_SAMPLES; i++) {
+      const phi = i * 2 * Math.PI / DIFFUSE_SAMPLES + phase, l = orient(
         0.7 * Math.cos(phi),
         0.7 * Math.sin(phi),
         Math.sqrt(0.51),
@@ -2048,20 +2323,26 @@ var StudioLighting = class {
         blocked++;
         const bounce2 = this.bounceRadiance(hit, l);
         for (let k = 0; k < 3; k++)
-          color[k] += bounce2[k] * base[k] * (1 - metal) * 0.96 / 4;
+          color[k] += bounce2[k] * base[k] * (1 - metal) * 0.96 / DIFFUSE_SAMPLES;
       }
     }
-    const ao = 1 - blocked / 4;
+    const ao = 1 - blocked / DIFFUSE_SAMPLES;
     for (let k = 0; k < 3; k++)
       color[k] -= studio_environment_default.ambient[k] * (1 - ao) * base[k] * (1 - metal) * 0.96;
     const [rt, rb] = basis(reflected), bounce = [0, 0, 0];
     let hitWeight = 0, totalWeight = 0;
-    for (let i = 0; i < 8; i++) {
-      const u = (i + 0.5) / 8, phi = 2 * Math.PI * radicalInverse(i) + phase, a = rough * rough;
-      const nh = Math.sqrt((1 - u) / (1 + (a * a - 1) * u)), sin = Math.sqrt(1 - nh * nh);
+    let samples = this.reflectionSamples.get(rough);
+    if (!samples) {
+      samples = Array.from({ length: REFLECTION_SAMPLES }, (_, i) => {
+        const u = (i + 0.5) / REFLECTION_SAMPLES, phi = 2 * Math.PI * radicalInverse(i), a = rough * rough, nh = Math.sqrt((1 - u) / (1 + (a * a - 1) * u)), sin = Math.sqrt(1 - nh * nh);
+        return [sin * Math.cos(phi), sin * Math.sin(phi), nh];
+      });
+      this.reflectionSamples.set(rough, samples);
+    }
+    for (const [sx, sy, nh] of samples) {
       const h = orient(
-        sin * Math.cos(phi),
-        sin * Math.sin(phi),
+        sx * cosPhase - sy * sinPhase,
+        sx * sinPhase + sy * cosPhase,
         nh,
         reflected,
         rt,
@@ -2170,10 +2451,33 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
     (dc) => (dc.material.alphaMode ?? "OPAQUE") === "BLEND"
   );
   const studio = options.realistic ? new StudioLighting(allDrawCalls, camera) : void 0;
-  const renderGroup = (dcs) => {
-    for (const dc of dcs) {
+  let winners;
+  const triangleOffsets = [];
+  if (studio && opaqueDraws.length > 1 && opaqueDraws.every((dc) => dc.mode !== 1)) {
+    winners = new Int32Array(renderWidth * renderHeight).fill(-1);
+    let triangleOffset = 0;
+    for (const dc of opaqueDraws) {
+      triangleOffsets.push(triangleOffset);
+      triangleOffset += renderer.drawMesh(
+        dc,
+        camera,
+        { dir: options.lightDir, ambient: options.ambient },
+        dc.material,
+        options.cull,
+        options.gamma,
+        studio,
+        { winners, triangleOffset, depthOnly: true }
+      );
+    }
+    renderer.depth.fill(Infinity);
+  }
+  const renderGroup = (dcs, opaque = false) => {
+    for (let i = 0; i < dcs.length; i++) {
+      const dc = dcs[i];
       if (dc.mode === 1) {
-        renderer.drawLines(dc, camera, options.gamma);
+        renderer.drawLines(dc, camera, options.gamma, {
+          width: options.lineWidth * options.supersampling
+        });
       } else {
         renderer.drawMesh(
           dc,
@@ -2182,12 +2486,13 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
           dc.material,
           options.cull,
           options.gamma,
-          studio
+          studio,
+          opaque && winners ? { winners, triangleOffset: triangleOffsets[i], depthOnly: false } : void 0
         );
       }
     }
   };
-  renderGroup(opaqueDraws);
+  renderGroup(opaqueDraws, true);
   renderGroup(maskDraws);
   if (infiniteGridOptions) {
     const aabb = computeWorldAABB(drawCalls);
@@ -2208,21 +2513,25 @@ function renderDrawCalls(drawCalls, optionsInput = {}, imageFactory = createUint
   renderGroup(blendDraws);
   renderer.denoise(options.gamma);
   for (const dc of drawCalls) {
-    if (!dc.showHiddenEdges) continue;
+    const showHiddenEdges = options.showHiddenEdges ?? dc.showHiddenEdges;
+    if (!options.showEdges && !showHiddenEdges) continue;
     const edgeDrawCall = createEdgeDrawCall(dc);
     if (!edgeDrawCall) continue;
     renderer.drawLines(edgeDrawCall, camera, options.gamma, {
       depthCompare: "less-equal",
       depthWrite: false,
-      depthBias: 1e-4
+      depthBias: 1e-4,
+      width: options.edgeWidth * options.supersampling
     });
+    if (!showHiddenEdges) continue;
     renderer.drawLines(edgeDrawCall, camera, options.gamma, {
       depthCompare: "greater",
       depthWrite: false,
       depthBias: 1e-4,
       dashed: true,
       dashLength: 4 * options.supersampling,
-      opacity: 0.35
+      opacity: options.hiddenEdgeOpacity,
+      width: options.edgeWidth * options.supersampling
     });
   }
   if (options.debugPoints?.length) {

package/package.json

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