poppygl 0.0.33 → 0.0.34

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
 

package/dist/index.d.ts

@@ -181,9 +181,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 {
@@ -212,7 +216,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

@@ -598,14 +598,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 +619,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,40 +628,54 @@ 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)
+            if (ids[neighbor] !== id) continue;
+            if (Math.abs(distance - this.distance[neighbor]) > distance * 0.02)
               continue;
-            if (n[k] * n[p] + n[k + 1] * n[p + 1] + n[k + 2] * n[p + 2] < 0.98)
+            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;
-            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)
-              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);
+          }
+        }
+    }
   }
 };
 
@@ -835,9 +855,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 +890,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 +923,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 +1001,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 +1044,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 +1056,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 +1148,7 @@ var SoftwareRenderer = class {
         }
       }
     }
+    return idx.length / 3;
   }
 };
 function edge(a, b, p) {
@@ -1502,15 +1534,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 +1619,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 +1844,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 +1979,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 +2003,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 +2062,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 +2103,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 +2131,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 +2140,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 +2154,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,8 +2282,29 @@ 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);
       } else {
@@ -2182,12 +2315,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);

package/package.json

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