poppygl 0.0.31 → 0.0.32

package/dist/index.d.ts

@@ -177,6 +177,7 @@ declare class StudioLighting {
     private occlusion;
     private eye;
     private shadowDirections;
+    private diffuseCache;
     constructor(drawCalls: DrawCall[], camera: Camera);
     private bounceRadiance;
     shade(position: V3, n: V3, base: V3, material: Material, sampleIndex?: number): V3;

package/dist/index.js

@@ -1466,8 +1466,19 @@ var studio_environment_default = {
 // lib/render/RayOcclusion.ts
 import { vec3 as vec33 } from "gl-matrix";
 var RayOcclusion = class {
-  root;
+  bounds = new Float64Array(0);
+  escapes = new Uint32Array(0);
+  starts = new Uint32Array(0);
+  counts = new Uint8Array(0);
+  triangleData = new Float64Array(0);
+  triangles = [];
   bias;
+  inverse = [0, 0, 0];
+  parallelAxes = 0;
+  closest = {
+    hit: null,
+    limit: Infinity
+  };
   constructor(drawCalls) {
     const triangles = [];
     for (const dc of drawCalls) {
@@ -1491,10 +1502,19 @@ var RayOcclusion = class {
         const max = [0, 1, 2].map(
           (a) => Math.max(p[a], q[a], r[a])
         );
+        const e1 = q.map((v, a) => v - p[a]), e2 = r.map((v, a) => v - p[a]);
+        const normal = [
+          e1[1] * e2[2] - e1[2] * e2[1],
+          e1[2] * e2[0] - e1[0] * e2[2],
+          e1[0] * e2[1] - e1[1] * e2[0]
+        ];
+        const length = Math.hypot(...normal) || 1;
+        for (let a = 0; a < 3; a++) normal[a] /= length;
         triangles.push({
           p,
-          e1: q.map((v, a) => v - p[a]),
-          e2: r.map((v, a) => v - p[a]),
+          e1,
+          e2,
+          normal,
           min,
           max,
           center: min.map((v, a) => (v + max[a]) / 2),
@@ -1502,10 +1522,52 @@ var RayOcclusion = class {
         });
       }
     }
-    this.root = triangles.length ? this.build(triangles) : null;
-    const extent = this.root ? Math.hypot(...this.root.max.map((v, a) => v - this.root.min[a])) : 1;
+    const root = triangles.length ? this.build(triangles) : null;
+    if (root) this.flatten(root, triangles.length);
+    const extent = root ? Math.hypot(...root.max.map((v, a) => v - root.min[a])) : 1;
     this.bias = Math.max(1e-7, extent * 1e-5);
   }
+  /** Preorder bounds with subtree escape offsets retain the existing SAH
+   * primitive order, while avoiding recursive calls and pointer-heavy nodes
+   * during millions of ray queries. Float64 retains the original precision.
+   */
+  flatten(root, triangleCount) {
+    const nodes = [], escapes = [];
+    const visit = (node) => {
+      const index = nodes.length;
+      nodes.push(node);
+      escapes.push(0);
+      if (!node.triangles) {
+        visit(node.left);
+        visit(node.right);
+      }
+      escapes[index] = nodes.length;
+    };
+    visit(root);
+    this.bounds = new Float64Array(nodes.length * 6);
+    this.escapes = Uint32Array.from(escapes);
+    this.starts = new Uint32Array(nodes.length);
+    this.counts = new Uint8Array(nodes.length);
+    this.triangleData = new Float64Array(triangleCount * 9);
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      this.bounds.set(node.min, i * 6);
+      this.bounds.set(node.max, i * 6 + 3);
+      if (!node.triangles) continue;
+      this.starts[i] = this.triangles.length;
+      this.counts[i] = node.triangles.length;
+      for (const triangle of node.triangles) {
+        const offset = this.triangles.length * 9;
+        this.triangleData.set(triangle.p, offset);
+        this.triangleData.set(triangle.e1, offset + 3);
+        this.triangleData.set(triangle.e2, offset + 6);
+        this.triangles.push({
+          normal: triangle.normal,
+          material: triangle.material
+        });
+      }
+    }
+  }
   build(triangles) {
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
     for (const t of triangles)
@@ -1554,78 +1616,128 @@ var RayOcclusion = class {
       right: this.build(best.slice(middle))
     };
   }
+  prepareRay(direction) {
+    this.parallelAxes = 0;
+    for (let a = 0; a < 3; a++) {
+      this.inverse[a] = 1 / direction[a];
+      if (Math.abs(direction[a]) < 1e-12) this.parallelAxes |= 1 << a;
+    }
+  }
   occluded(origin, direction, maxDistance = Infinity) {
-    return this.root ? this.intersect(this.root, origin, direction, maxDistance) : false;
+    this.prepareRay(direction);
+    return this.intersect(origin, direction, maxDistance);
   }
   /** Closest opaque triangle for one-bounce reflections and diffuse fill. */
   trace(origin, direction, maxDistance = Infinity) {
-    const state = {
-      hit: null,
-      limit: maxDistance
+    this.prepareRay(direction);
+    const state = this.closest;
+    state.hit = null;
+    state.limit = maxDistance;
+    this.intersect(origin, direction, maxDistance, state);
+    if (!state.hit) return null;
+    const { normal, material } = state.hit;
+    const sign = dotNormal(normal, direction) > 0 ? -1 : 1;
+    return {
+      position: [
+        origin[0] + direction[0] * state.limit,
+        origin[1] + direction[1] * state.limit,
+        origin[2] + direction[2] * state.limit
+      ],
+      normal: [normal[0] * sign, normal[1] * sign, normal[2] * sign],
+      material,
+      distance: state.limit
     };
-    if (this.root)
-      this.intersect(this.root, origin, direction, maxDistance, state);
-    return state.hit;
   }
-  intersect(node, o, d, limit, state) {
-    if (state) limit = state.limit;
-    let near = 0, far = limit;
-    for (let a = 0; a < 3; a++) {
-      if (Math.abs(d[a]) < 1e-12) {
-        if (o[a] < node.min[a] || o[a] > node.max[a]) return false;
-        continue;
+  intersect(o, d, maxDistance, state) {
+    const ox = o[0], oy = o[1], oz = o[2], dx = d[0], dy = d[1], dz = d[2], ix = this.inverse[0], iy = this.inverse[1], iz = this.inverse[2], parallel = this.parallelAxes, bounds = this.bounds, data = this.triangleData;
+    let node = 0;
+    while (node < this.counts.length) {
+      const offset = node * 6;
+      let limit = state ? state.limit : maxDistance, near = 0, far = limit;
+      if (parallel & 2) {
+        if (oy < bounds[offset + 1] || oy > bounds[offset + 4]) {
+          node = this.escapes[node];
+          continue;
+        }
+      } else {
+        let t0 = (bounds[offset + 1] - oy) * iy, t1 = (bounds[offset + 4] - oy) * iy;
+        if (t0 > t1) {
+          const swap = t0;
+          t0 = t1;
+          t1 = swap;
+        }
+        if (t0 > near) near = t0;
+        if (t1 < far) far = t1;
+        if (far < near) {
+          node = this.escapes[node];
+          continue;
+        }
       }
-      const t0 = (node.min[a] - o[a]) / d[a], t1 = (node.max[a] - o[a]) / d[a];
-      near = Math.max(near, Math.min(t0, t1));
-      far = Math.min(far, Math.max(t0, t1));
-      if (far < near) return false;
-    }
-    if (node.triangles) {
-      for (const { p, e1, e2, material } of node.triangles) {
-        const px = d[1] * e2[2] - d[2] * e2[1], py = d[2] * e2[0] - d[0] * e2[2], pz = d[0] * e2[1] - d[1] * e2[0];
-        const det = e1[0] * px + e1[1] * py + e1[2] * pz;
+      if (parallel & 1) {
+        if (ox < bounds[offset + 0] || ox > bounds[offset + 3]) {
+          node = this.escapes[node];
+          continue;
+        }
+      } else {
+        let t0 = (bounds[offset + 0] - ox) * ix, t1 = (bounds[offset + 3] - ox) * ix;
+        if (t0 > t1) {
+          const swap = t0;
+          t0 = t1;
+          t1 = swap;
+        }
+        if (t0 > near) near = t0;
+        if (t1 < far) far = t1;
+        if (far < near) {
+          node = this.escapes[node];
+          continue;
+        }
+      }
+      if (parallel & 4) {
+        if (oz < bounds[offset + 2] || oz > bounds[offset + 5]) {
+          node = this.escapes[node];
+          continue;
+        }
+      } else {
+        let t0 = (bounds[offset + 2] - oz) * iz, t1 = (bounds[offset + 5] - oz) * iz;
+        if (t0 > t1) {
+          const swap = t0;
+          t0 = t1;
+          t1 = swap;
+        }
+        if (t0 > near) near = t0;
+        if (t1 < far) far = t1;
+        if (far < near) {
+          node = this.escapes[node];
+          continue;
+        }
+      }
+      const start = this.starts[node], end = start + this.counts[node];
+      for (let i = start; i < end; i++) {
+        const offset2 = i * 9, p0 = data[offset2], p1 = data[offset2 + 1], p2 = data[offset2 + 2], e10 = data[offset2 + 3], e11 = data[offset2 + 4], e12 = data[offset2 + 5], e20 = data[offset2 + 6], e21 = data[offset2 + 7], e22 = data[offset2 + 8];
+        const px = dy * e22 - dz * e21, py = dz * e20 - dx * e22, pz = dx * e21 - dy * e20;
+        const det = e10 * px + e11 * py + e12 * pz;
         if (Math.abs(det) < 1e-12) continue;
-        const inv = 1 / det, tx = o[0] - p[0], ty = o[1] - p[1], tz = o[2] - p[2];
+        const inv = 1 / det, tx = ox - p0, ty = oy - p1, tz = oz - p2;
         const u = (tx * px + ty * py + tz * pz) * inv;
         if (u < 0 || u > 1) continue;
-        const qx = ty * e1[2] - tz * e1[1], qy = tz * e1[0] - tx * e1[2], qz = tx * e1[1] - ty * e1[0];
-        const v = (d[0] * qx + d[1] * qy + d[2] * qz) * inv;
+        const qx = ty * e12 - tz * e11, qy = tz * e10 - tx * e12, qz = tx * e11 - ty * e10;
+        const v = (dx * qx + dy * qy + dz * qz) * inv;
         if (v < 0 || u + v > 1) continue;
-        const distance = (e2[0] * qx + e2[1] * qy + e2[2] * qz) * inv;
+        const distance = (e20 * qx + e21 * qy + e22 * qz) * inv;
         if (distance > this.bias * 0.25 && distance < limit) {
           if (!state) return true;
-          const normal = [
-            e1[1] * e2[2] - e1[2] * e2[1],
-            e1[2] * e2[0] - e1[0] * e2[2],
-            e1[0] * e2[1] - e1[1] * e2[0]
-          ];
-          const length = Math.hypot(...normal) || 1;
-          for (let a = 0; a < 3; a++) normal[a] /= length;
-          if (normal[0] * d[0] + normal[1] * d[1] + normal[2] * d[2] > 0)
-            for (let a = 0; a < 3; a++) normal[a] *= -1;
-          state.hit = {
-            position: [
-              o[0] + d[0] * distance,
-              o[1] + d[1] * distance,
-              o[2] + d[2] * distance
-            ],
-            normal,
-            material,
-            distance
-          };
+          state.hit = this.triangles[i];
           state.limit = limit = distance;
         }
       }
-      return false;
-    }
-    if (state) {
-      this.intersect(node.left, o, d, limit, state);
-      this.intersect(node.right, o, d, state.limit, state);
-      return state.hit !== null;
+      node++;
     }
-    return this.intersect(node.left, o, d, limit) || this.intersect(node.right, o, d, limit);
+    return state?.hit != null;
   }
 };
+function dotNormal(normal, direction) {
+  return normal[0] * direction[0] + normal[1] * direction[1] + normal[2] * direction[2];
+}
 
 // lib/render/StudioLighting.ts
 var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
@@ -1669,7 +1781,7 @@ function orient(x, y, z, n, t, b) {
     t[2] * x + b[2] * y + n[2] * z
   ];
 }
-function sampleTable(table, n) {
+function tableLookup(n) {
   const x = (Math.atan2(n[2], n[0]) / (2 * Math.PI) + 0.5) * W - 0.5;
   const y = Math.max(
     0,
@@ -1680,7 +1792,11 @@ function sampleTable(table, n) {
   );
   const ix = Math.floor(x), iy = Math.floor(y), fx = x - ix, fy = y - iy;
   const a = (ix % W + W) % W, b = (a + 1) % W, c = Math.min(H - 1, iy + 1);
-  return (table[iy * W + a] * (1 - fx) + table[iy * W + b] * fx) * (1 - fy) + (table[c * W + a] * (1 - fx) + table[c * W + b] * fx) * fy;
+  return [iy * W + a, iy * W + b, c * W + a, c * W + b, fx, fy];
+}
+function sampleTable(table, lookup) {
+  const [i00, i10, i01, i11, fx, fy] = lookup;
+  return (table[i00] * (1 - fx) + table[i10] * fx) * (1 - fy) + (table[i01] * (1 - fx) + table[i11] * fx) * fy;
 }
 var cachedTables;
 function getTables() {
@@ -1764,6 +1880,7 @@ var StudioLighting = class {
   occlusion;
   eye;
   shadowDirections;
+  diffuseCache = /* @__PURE__ */ new WeakMap();
   constructor(drawCalls, camera) {
     this.occlusion = new RayOcclusion(drawCalls);
     const world = mat46.invert(mat46.create(), camera.view);
@@ -1774,7 +1891,7 @@ var StudioLighting = class {
       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 orient(
+        const direction = orient(
           sin * Math.cos(phi),
           sin * Math.sin(phi),
           cos,
@@ -1782,16 +1899,36 @@ var StudioLighting = class {
           t,
           b
         );
+        const parallel = dot(direction, l.direction);
+        return {
+          parallel: l.direction.map((v) => v * parallel),
+          perpendicular: direction.map(
+            (v, k) => v - l.direction[k] * parallel
+          ),
+          cross: [
+            l.direction[1] * direction[2] - l.direction[2] * direction[1],
+            l.direction[2] * direction[0] - l.direction[0] * direction[2],
+            l.direction[0] * direction[1] - l.direction[1] * direction[0]
+          ]
+        };
       });
     });
   }
   bounceRadiance(hit, incoming) {
     const metal = Math.max(0, Math.min(1, hit.material.metallicFactor ?? 1));
-    const irradiance = [...studio_environment_default.ambient];
-    for (let j = 0; j < lobes.length; j++) {
-      const value = sampleTable(this.tables.diffuse[j], hit.normal);
-      for (let k = 0; k < 3; k++) irradiance[k] += value * lobes[j].color[k];
+    let cached = this.diffuseCache.get(hit.material);
+    if (!cached || cached.normal.some((v, k) => !Object.is(v, hit.normal[k]))) {
+      const irradiance2 = [...studio_environment_default.ambient];
+      const lookup = tableLookup(hit.normal);
+      for (let j = 0; j < lobes.length; j++) {
+        const value = sampleTable(this.tables.diffuse[j], lookup);
+        for (let k = 0; k < 3; k++)
+          irradiance2[k] += value * lobes[j].color[k];
+      }
+      cached = { normal: [...hit.normal], irradiance: irradiance2 };
+      this.diffuseCache.set(hit.material, cached);
     }
+    const irradiance = cached.irradiance;
     const base = hit.material.baseColorFactor;
     const rough = Math.max(0.04, Math.min(1, hit.material.roughnessFactor ?? 1));
     const nv = Math.max(1e-3, -dot(hit.normal, incoming));
@@ -1810,8 +1947,9 @@ var StudioLighting = class {
       (c, k) => c * base[k] * (1 - metal) * 0.96
     );
     const pref = [...studio_environment_default.ambient];
+    const reflectedLookup = tableLookup(reflected);
     for (let j = 0; j < lobes.length; j++) {
-      const value = sampleTable(this.tables.specular[level][j], reflected) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflected) * blend;
+      const value = 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++)
@@ -1855,27 +1993,23 @@ var StudioLighting = class {
     bits = Math.imul(bits ^ bits >>> 15, 2221713035);
     const hash = ((bits ^ bits >>> 16) >>> 0) / 4294967296;
     const phase = hash * 2 * Math.PI, cosPhase = Math.cos(phase), sinPhase = Math.sin(phase);
+    const normalLookup = tableLookup(n), reflectedLookup = tableLookup(reflected);
     for (let j = 0; j < lobes.length; j++) {
       const dirs = this.shadowDirections[j];
       let visible = 0, total = 0;
-      const axis = lobes[j].direction;
-      for (const direction of dirs) {
-        const parallel = dot(direction, axis);
-        const cross = [
-          axis[1] * direction[2] - axis[2] * direction[1],
-          axis[2] * direction[0] - axis[0] * direction[2],
-          axis[0] * direction[1] - axis[1] * direction[0]
+      for (const { parallel, perpendicular, cross } of dirs) {
+        const l = [
+          parallel[0] + perpendicular[0] * cosPhase + cross[0] * sinPhase,
+          parallel[1] + perpendicular[1] * cosPhase + cross[1] * sinPhase,
+          parallel[2] + perpendicular[2] * cosPhase + cross[2] * sinPhase
         ];
-        const l = direction.map(
-          (value, k) => axis[k] * parallel + (value - axis[k] * parallel) * cosPhase + cross[k] * sinPhase
-        );
         const weight = Math.max(0, dot(n, l));
         total += weight;
         if (weight > 0 && !this.occlusion.occluded(origin, l)) visible += weight;
       }
       const visibility = total > 0 ? visible / total : 1;
-      const diffuse = sampleTable(this.tables.diffuse[j], n) * visibility;
-      const specular = (sampleTable(this.tables.specular[level][j], reflected) * (1 - blend) + sampleTable(this.tables.specular[level + 1][j], reflected) * blend) * visibility;
+      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;
       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;
@@ -1883,7 +2017,7 @@ var StudioLighting = class {
     }
     const [t, b] = basis(n);
     let blocked = 0;
-    for (let i = 0; i < 4; i++) {
+    for (let i = 0; metal < 1 && i < 4; i++) {
       const phi = i * Math.PI / 2 + phase, l = orient(
         0.7 * Math.cos(phi),
         0.7 * Math.sin(phi),

package/package.json

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