Glass Matcap

1// Shape-independent studio-glass lookup: lighting is camera-locked.
2import * as THREE from "three/webgpu";
3import { D } from "../dials/store";
4export function createGlassMatcap(environment: THREE.DataTexture, n = 1024) {
5  const out = new Float32Array(n * n * 4),
6    src = environment.image.data as Float32Array,
7    w = environment.image.width,
8    h = environment.image.height;
9  const I = D.ice,
10    ior = I.ior,
11    f0 = ((ior - 1) / (ior + 1)) ** 2,
12    color = new THREE.Color(I.attenuationColor),
13    colors = [color.r, color.g, color.b];
14  const sample = (x: number, y: number, z: number, c: number) => {
15    const u = (((Math.atan2(z, x) / (2 * Math.PI) + 0.5) % 1) + 1) % 1,
16      v = Math.asin(Math.max(-1, Math.min(1, y))) / Math.PI + 0.5;
17    const px = u * w - 0.5,
18      py = v * h - 0.5,
19      ix = Math.floor(px),
20      iy = Math.floor(py),
21      tx = px - ix,
22      ty = py - iy;
23    const a = (xx: number, yy: number) =>
24      src[(Math.max(0, Math.min(h - 1, yy)) * w + ((xx + w) % w)) * 4 + c];
25    return (
26      (a(ix, iy) * (1 - tx) + a(ix + 1, iy) * tx) * (1 - ty) +
27      (a(ix, iy + 1) * (1 - tx) + a(ix + 1, iy + 1) * tx) * ty
28    );
29  };
30  for (let y = 0; y < n; y++)
31    for (let x = 0; x < n; x++) {
32      let nx = ((x + 0.5) / n) * 2 - 1,
33        ny = ((y + 0.5) / n) * 2 - 1;
34      const rr = nx * nx + ny * ny;
35      if (rr >= 1) {
36        const m = 0.99999 / Math.sqrt(rr);
37        nx *= m;
38        ny *= m;
39      }
40      const nz = Math.sqrt(Math.max(1e-8, 1 - nx * nx - ny * ny));
41      const eta = 1 / ior,
42        k = eta * nz - Math.sqrt(1 - eta * eta * (1 - nz * nz));
43      const dx = k * nx,
44        dy = k * ny,
45        dz = -eta + k * nz,
46        chord = -2 * (nx * dx + ny * dy + nz * dz);
47      const ex = nx + dx * chord,
48        ey = ny + dy * chord,
49        ez = nz + dz * chord;
50      const dn = dx * ex + dy * ey + dz * ez,
51        k2 = 1 - ior * ior * (1 - dn * dn),
52        f = f0 + (1 - f0) * (1 - nz) ** 5;
53      const b = ior * dn - Math.sqrt(Math.max(0, k2)),
54        ox = ior * dx - b * ex,
55        oy = ior * dy - b * ey,
56        oz = ior * dz - b * ez;
57      for (let c = 0; c < 3; c++) {
58        const att = Math.pow(
59          colors[c],
60          (chord * I.thicknessScale) / Math.max(I.attenuationDistance, 0.01),
61        );
62        out[(x + y * n) * 4 + c] =
63          sample(2 * nz * nx, 2 * nz * ny, 2 * nz * nz - 1, c) * f +
64          sample(ox, oy, oz, c) * (1 - f) * (I.backlight ?? 0.4) * att;
65      }
66      out[(x + y * n) * 4 + 3] = 1;
67    }
68  const tex = new THREE.DataTexture(out, n, n, THREE.RGBAFormat, THREE.FloatType);
69  tex.colorSpace = THREE.LinearSRGBColorSpace;
70  tex.minFilter = tex.magFilter = THREE.LinearFilter;
71  tex.needsUpdate = true;
72  return tex;
73}