vireglass 2.3.1 → 3.0.0

package/dist/web/index.cjs

@@ -23,7 +23,48 @@ var RIM = {
    * The dark edge along the whole silhouette, as a multiplicative darkening. iOS 27 made it a
    * layer of its own, and it does not rule out the highlight sitting on top of it (§2).
    */
-  darkEdge: 0.22};
+  darkEdge: 0.22,
+  /**
+   * How strongly the line is drawn, by the lightness around the element. The rim is a reflection
+   * of the surroundings, so it is faint over a dark one and plain over a bright one, not white at
+   * full strength everywhere (§2, §6).
+   *
+   * MEASURED off the controls of A 2:17 (over dark video), M 2:52 (over sky) and A 2:18 (over
+   * grass), as the brightest rim bin's OKLab lightness over the surround's: 0.24 to 0.27 over dark,
+   * 0.25 over sky, 0.37 over grass. Through the DOM path onto the same backdrops these land within
+   * 0.08 of the smooth rows (docs/dom.md); a line white at full strength reads 0.70 to 0.80 over the
+   * dark frames.
+   */
+  strengthDark: 0.37,
+  strengthLight: 0.95,
+  /**
+   * The surround lightness between which the strength moves from one to the other. UNMEASURED: the
+   * two ends are, and the controls in between were not looked for.
+   */
+  ambientFrom: 0.15,
+  ambientTo: 0.45,
+  /**
+   * The share of the line's width, from the silhouette inward, that the light line leaves to the
+   * dark edge. UNMEASURED: without it the line covers the dark edge and an element over a bright
+   * flat backdrop loses the one mark that holds it there.
+   */
+  lineInset: 0.3,
+  /**
+   * The share of the peak that the line keeps along the whole contour, away from the key light.
+   * MEASURED: the reference line goes all the way round. Its dimmest bin sits 0.06 to 0.12 of
+   * lightness over the surround on the dark frames, against a peak of 0.24 to 0.27 (A 2:17).
+   */
+  contour: 0.3,
+  /** How far the line's colour is lifted from the surroundings' toward white. UNMEASURED: the
+   *  lens always had 0.75 here, and this is that figure with a name. */
+  whiteShare: 0.75,
+  /**
+   * The reflectance (`fresnelStrength`) at which the line is drawn at the strengths above: that
+   * of ordinary glass, index 1.5. A denser medium does not draw it brighter than they say; a
+   * thinner one draws it fainter. UNMEASURED.
+   */
+  reflectanceRef: 0.7
+};
 var BODY = {
   /** Lightness ceiling for the body when legibility is loose. */
   capLoose: 0.62,
@@ -36,12 +77,30 @@ var BODY = {
   busyEdge: 0.75,
   /** Fine texture the body has to stop being a window for. */
   groundSpan: 0.06,
-  /** Where the tint flips direction, by the element's AVERAGE lightness — a local threshold cuts
-   *  a diagonal step across the body on a gradient. */
-  darkSideFrom: 0.42,
-  darkSideTo: 0.58,
+  /**
+   * The spread under the element at which the ink's legibility requirement starts to bind, and the
+   * spread where it binds fully. Over a flat backdrop polarity flips before the ink drowns, so
+   * the body does not darken under a light glyph there; over texture it does. UNMEASURED: the
+   * reference shows a lighter body under a white glyph over sky, nothing about texture.
+   */
+  inkBusyFrom: 0.02,
+  inkBusyTo: 0.12,
   /** Ceiling on any single demand, so one requirement cannot make the glass opaque on its own. */
-  maxDemand: 0.92};
+  maxDemand: 0.92,
+  /**
+   * And a tighter one for presence specifically. It is a FLOOR on visibility, not a licence to go
+   * opaque: wherever the body's tint sits close to the backdrop, the density that would deliver the
+   * separation is the ceiling, and glass at `maxDemand` has stopped being a window. Better to
+   * separate as far as transparency allows and no further. UNMEASURED.
+   */
+  presenceDemand: 0.5,
+  /**
+   * The density at which the body is wholly the ink's own pole. Between `presenceDemand` and this
+   * the body moves from the light a thin body carries to the pole: a density no presence floor
+   * reaches is one the ink's legibility, or a system setting, has asked for. UNMEASURED.
+   */
+  inkPoleTo: 0.8
+};
 var DISPERSION = {
   /** Red bends less than the base index, blue more — and not symmetrically. */
   redShift: -0.4,
@@ -718,7 +777,11 @@ half4 main(float2 xy) {
   float rimKey = u_specular * (pow(max(rimFacing, 0.0), ${RIM.lobeExponent}.0) + ${RIM.opposingArc} * pow(max(-rimFacing, 0.0), ${RIM.lobeExponent}.0));
   // Wherever the key light doesn't fall, the face reflects its shaded surroundings \u2014 hence the
   // dark outline.
-  float3 env = refl * (0.55 + 0.45 * min(key, 1.0)) + float3(1.2 * key);
+  // The key light's glint is a reflection of the surroundings too: it is scaled by the same
+  // ambient strength as the rim line, so it is not white at full strength over a dark backdrop.
+  float rimStrength = mix(${RIM.strengthDark}, ${RIM.strengthLight},
+    smoothstep(${RIM.ambientFrom}, ${RIM.ambientTo}, vgLuma(ambient)));
+  float3 env = refl * (0.55 + 0.45 * min(key, 1.0)) + float3(1.2 * key * rimStrength / ${RIM.strengthLight});
 
   // Interference and diffraction live in the reflected ray at a grazing angle \u2014 a single hue
   // multiplier applied to the reflection, no extra samples.
@@ -794,12 +857,10 @@ half4 main(float2 xy) {
   // transparent glass by the model.
   float demand = clamp(u_legibility * 4.0, 0.0, 1.0);
 
-  // Where there's no ink, the glass tints away from the backdrop. The direction is chosen by the
-  // average lightness under the element, not the local spot's lightness: otherwise on a gradient
-  // the threshold cuts across the body as a diagonal step.
-  float darkSide = smoothstep(${BODY.darkSideFrom}, ${BODY.darkSideTo}, mean);
-  float away = mix(VG_TINT_LIGHT, VG_TINT_DARK, darkSide);
-  float tintLuma = mix(away, mix(VG_TINT_LIGHT, VG_TINT_DARK, pol), demand);
+  // The body is lighter than its surroundings whatever the glyph on it is: glass concentrates
+  // light (M 2:29), and the reference keeps a lighter body under a white glyph over sky as much as
+  // over dark. Only a requirement of the ink pulls it to the ink's own pole, below.
+  float inkPole = mix(VG_TINT_LIGHT, VG_TINT_DARK, pol);
 
   // How much medium it takes to push lightness under the ink past the threshold \u2014 locally.
   // Computed from whichever edge of the backdrop's spread is closer to the ink: a light ink
@@ -814,32 +875,22 @@ half4 main(float2 xy) {
   float needForDark = inkLo < floorDark
     ? clamp((floorDark - inkLo) / max(VG_TINT_LIGHT - inkLo, 1e-4), 0.0, ${BODY.maxDemand})
     : 0.0;
-  float needForInk = mix(needForDark, needForLight, pol) * demand;
+  // Over a flat backdrop the ink asks for nothing: polarity flips before it drowns. It is spread
+  // under the ink that the body has to answer.
+  float structured = smoothstep(${BODY.inkBusyFrom}, ${BODY.inkBusyTo}, busy);
+  float needForInk = mix(needForDark, needForLight, pol) * demand * structured;
 
   float ground = structure * u_legibility * VG_GROUND_SPAN;
   float density = max(max(u_bodyDensity, ground), needForInk);
 
   // PRESENCE (\xA73). Over a uniform backdrop there is nothing to refract, and an element that is
-  // only a rim honestly disappears \u2014 right for a piece of background, wrong for a control.
-  //
-  // This used to live on the rim line alone, as lit = max(rimKey, u_presence x 2), while the
-  // DOM path has always implemented it as a floor on the BODY. Two renderers, one field, two
-  // meanings. Measured on Apple's own control over a flat page (frames/verify/m-707), the body
-  // carries 16 levels of separation there and the rim 11.6 \u2014 so the body is where it belongs,
-  // and the rim's reading was the wrong one.
-  // The separation asked for is capped by the range that is left: over a backdrop at 0.96 there
-  // is no room to go 0.05 lighter. And what it is DIVIDED by is the distance to the tint's own
-  // end, not to the tint the body currently sits at \u2014 dividing by the latter explodes wherever
-  // the two are close, which is how the first version of this drove density to its ceiling at
-  // both extremes and took the window down to 7%.
-  bool lighter = local < 0.5;
-  float target = lighter ? min(local + u_presence, 1.0) : max(local - u_presence, 0.0);
-  float separation = abs(target - local);
-  float reached = abs(tintLuma - local) * density;
-  if (u_presence > 0.0 && reached < separation) {
-    float toEnd = abs((lighter ? VG_TINT_LIGHT : VG_TINT_DARK) - local);
-    density = max(density, min(separation / max(toEnd, 1e-4), ${BODY.maxDemand}));
+  // only a rim honestly disappears \u2014 right for a piece of background, wrong for a control. A floor
+  // on the density, toward light: the lift it gives is presence times the room left under the
+  // light pole, so it fades out as the room does and has no step anywhere on the scale.
+  if (u_presence > 0.0) {
+    density = max(density, min(u_presence / VG_TINT_LIGHT, ${BODY.presenceDemand}));
   }
+  float tintLuma = mix(VG_TINT_LIGHT, inkPole, max(clamp(needForInk / max(density, 1e-4), 0.0, 1.0), smoothstep(${BODY.presenceDemand}, ${BODY.inkPoleTo}, density)));
 
   // Glass has no color of its own \u2014 only the color of what's beneath it (HIG "Color").
   float3 tintHue = mix(float3(1.0), vgHue(wide * 0.5 + ambient * 0.5), u_colorPickup);
@@ -879,17 +930,18 @@ half4 main(float2 xy) {
   }
 
   // RIM LIGHT \u2014 a separate layer, a line about 1 pt wide along the silhouette (M 2:36, 11:04):
-  // brighter where the face faces the key light, weaker opposite it; where no light falls, a
-  // dark outline. This line is what holds the element's presence, not a fill on the body: over a
-  // flat backdrop a control is visible along its whole silhouette because of it.
-  float line = (1.0 - smoothstep(0.0, lineW, e)) * lens;
+  // brighter where the face faces the key light, weaker opposite it, and never absent: the line
+  // runs the whole contour. It is a reflection of the surroundings, so it is faint over a dark
+  // one and plain over a bright one (\xA72, \xA76).
+  float line = smoothstep(0.0, lineW * ${RIM.lineInset}, e) * (1.0 - smoothstep(lineW * ${RIM.lineInset}, lineW, e)) * lens;
   float outline = (1.0 - smoothstep(0.0, lineW * 0.6, e)) * lens;
-  float lit = clamp(max(rimKey * 1.4, u_presence * 2.0), 0.0, 1.0);
+  float reflectN = min(u_fresnel / ${RIM.reflectanceRef}, 1.0);
+  float lit = clamp(rimStrength * reflectN * (${RIM.contour} + (1.0 - ${RIM.contour}) * rimKey / max(u_fresnel, 0.001)), 0.0, 1.0);
   // The dark rim is its own layer around the whole silhouette, and the highlight sits ON TOP of
   // it (iOS 27). While the outline used to fade via a (1 \u2212 lit) multiplier, the silhouette read
   // as a single arc: highlight OR shadow.
   rgb *= 1.0 - ${RIM.darkEdge} * outline;
-  rgb = mix(rgb, mix(refl, float3(1.0), 0.75), line * lit);
+  rgb = mix(rgb, mix(refl, float3(1.0), ${RIM.whiteShare}), line * lit);
 
   if (u_debug > 9.5 && u_debug < 10.5) { rgb = spectral * 0.5; }
   if (u_debug > 10.5 && u_debug < 11.5) { rgb = float3(density, needForInk, structure); }