vireglass 2.2.0 → 2.3.1

package/dist/chunk-2XJJO7SC.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/surface-shader.ts","../src/targets/glsl.ts"],"names":[],"mappings":"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","file":"chunk-2XJJO7SC.js","sourcesContent":["import { INK, MEDIUM, SHADOW_GAP } from './law';\nimport { VG_FALLOFF, VG_SDF } from './sdf';\n\n/** Order matches `DEBUG_MODES` in `material.ts`: the index goes straight into `u_debug`. */\nexport const SURFACE_SHADER = `\nuniform shader u_icon;\n/** App-colored content ON the glass — cover art, a thumbnail. A separate layer from the ink\n *  mask: that one is single-channel and colored by polarity, this one carries its own color\n *  as-is. */\nuniform shader u_overlay;\n\nuniform float2 u_center;\nuniform float2 u_halfSize;\nuniform float  u_corner;\nuniform float  u_bevel;\nuniform float  u_thickness;\nuniform float2 u_morphOffset;\nuniform float2 u_morphHalf;\nuniform float  u_morphCorner;\nuniform float  u_morphK;\nuniform float2 u_morph2Offset;\nuniform float2 u_morph2Half;\nuniform float  u_morph2Corner;\n\nuniform float  u_press;\nuniform float  u_active;\n/* 0 — the element sinks in under the finger, 1 — it rises into glass (reference §5). */\nuniform float  u_lift;\n\nuniform float  u_edgeDensity;\nuniform float  u_dispersion;\nuniform float  u_refraction;\nuniform float4 u_tint;\nuniform float  u_shadow;\nuniform float  u_shadowReach;\nuniform float3 u_ambient;\nuniform float  u_presence;\nuniform float  u_progress;\nuniform float  u_appear;\nuniform float  u_debug;\n\nuniform float  u_iconOn;\nuniform float  u_overlayOn;\nuniform float  u_iconScale;\nuniform float4 u_inkIdle;\nuniform float4 u_inkActive;\nuniform float2 u_touch;\nuniform float2 u_pull;\nuniform float  u_touchPress;\nuniform float  u_touchRadius;\nuniform float2 u_wave;\n\n${VG_SDF}\n\nconst float VG_FALLOFF = ${VG_FALLOFF};\n\n// Tint density in the flat middle; at the bevel it's multiplied by u_edgeDensity.\nconst float VG_BODY_DENSITY = ${MEDIUM.bodyDensityFlat};\n/* Fraction of the ambient hue in the shadow. The shadow has to stay a shadow, not a colored\n *  blob. */\nconst float VG_SHADOW_TINT = ${SHADOW_GAP.tint}.0;\n// How much weaker the shadow is right at the outline than under the middle of the gap, and what\n// fraction of the offset it takes to reach full depth. In the reference the shadow's minimum\n// sits below the rim, not right at it.\nconst float VG_GAP_LIGHT = ${SHADOW_GAP.light};\nconst float VG_GAP_REACH = ${SHADOW_GAP.reach};\n/* Depth of the ink beneath the surface, dp. The normal displaces it by exactly this much right\n *  at the rim. */\nconst float VG_INK_DEPTH = ${INK.depth}.0;\n/* Ink defocus under the finger (reference §6): a glyph loses its edge and drowns in milk. Given\n * as a FRACTION of the touch blob, not a number: the blob already arrives in device units, so\n * the radius automatically follows both screen density and the element's size. At rest it's\n * zero, and the sample stays a single one. */\nconst float VG_INK_DEFOCUS = ${INK.defocus};\n\nhalf4 vgPack(half3 c, float a) { return half4(c * half(a), half(a)); }\n\n// What bleeds into the shadow is the COLOR of the surroundings, not its brightness: the hue's own\n// lightness is subtracted out of it, otherwise the shadow pales and loses depth instead of\n// warming up. Strength is set by how much light there is around: over a nearly black backdrop\n// there's nothing to bleed into the shadow.\n// JS twin in shadow-tint.ts, which the DOM renderer reads: same derivation, same reason.\nfloat3 vgShadowTint(float3 ambient) {\n  float peak = max(max(ambient.r, ambient.g), max(ambient.b, 0.001));\n  float3 hue = ambient / peak;\n  float lumaWeights = dot(ambient, float3(0.2126, 0.7152, 0.0722));\n  return (hue - dot(hue, float3(0.2126, 0.7152, 0.0722))) * lumaWeights;\n}\n\nhalf3 vgHeat(float v) {\n  float x = clamp(v, 0.0, 1.0);\n  return half3(half(clamp(x * 2.2 - 0.2, 0.0, 1.0)),\n               half(clamp(1.0 - abs(x - 0.5) * 2.2, 0.0, 1.0)),\n               half(clamp(1.2 - x * 2.4, 0.0, 1.0)));\n}\n\nhalf4 main(float2 xy) {\n  float2 p = vgTouchWarp(xy - u_center, u_touch, u_pull, u_touchPress, u_touchRadius, u_wave.x, u_wave.y);\n\n  // Inverse deformation: stretch A along the pull vector, compression 1/sqrt(A) across it. This\n  // exact law mirrors the transform of the live backdrop under the canvas, otherwise the two\n  // would drift apart. There's NO motion geometry here — no pull, no press-driven bulge. All of\n  // that is done by a single wrapper transform, the same one that carries the native lens: the\n  // shader doesn't touch it, and two pipelines driving one motion would drift apart by a frame,\n  // making the layers visible as separate.\n\n  float halfMin = max(min(u_halfSize.x, u_halfSize.y), 1.0);\n  float bevel = max(u_bevel, 1.0);\n\n  float sd = vgScene(p, u_halfSize, u_corner, u_morphOffset, u_morphHalf, u_morphCorner, u_morphK,\n                u_morph2Offset, u_morph2Half, u_morph2Corner);\n  float t = vgBevelT(sd, bevel);\n  float2 n = vgSceneNormal(p, u_halfSize, u_corner, u_morphOffset, u_morphHalf, u_morphCorner, u_morphK,\n                u_morph2Offset, u_morph2Half, u_morph2Corner);\n  float3 N = normalize(float3(n * vgBevelSlope(t), 1.0));\n\n  // Progress is an active state turned into a field: the played fraction shines and glows\n  // exactly as much as an active element shines whole. This does NOT touch ink: recoloring text\n  // as the track advances would mean changing it mid-word.\n  float lit = max(u_active, vgProgress(p, u_halfSize, u_progress));\n\n  // The highlight and the rim are computed by the lens: reflection is a function of the\n  // surroundings, and only the lens can see them.\n\n  if (u_debug > 0.5) {\n    float inMask = 1.0 - smoothstep(-1.0, 1.0, sd);\n    if (u_debug < 1.5) {\n      float band = abs(fract(sd / (halfMin * 0.22)) - 0.5) * 2.0;\n      half3 c = sd < 0.0 ? half3(0.20, 0.62, 1.0) : half3(1.0, 0.42, 0.22);\n      return vgPack(c * half(0.25 + band * 0.75), 1.0);\n    }\n    if (u_debug < 2.5) { return vgPack(half3(1.0), inMask); }\n    if (u_debug < 3.5) { return vgPack(vgHeat(t), inMask); }\n    // Fresnel now lives in the lens; here we show its SHAPE — how grazing the view is.\n    if (u_debug < 4.5) { return vgPack(vgHeat(1.0 - clamp(N.z, 0.0, 1.0)), inMask); }\n    if (u_debug < 5.5) {\n      float push = pow(t, VG_FALLOFF) * u_refraction;\n      return vgPack(vgHeat(push), inMask);\n    }\n    if (u_debug < 6.5) { return half4(0.0); }\n    if (u_debug < 7.5) { return half4(0.0); }\n    // Dispersion is computed by the lens; here is the field it grows along.\n    if (u_debug < 8.5) { return vgPack(vgHeat(u_dispersion * t * t), inMask); }\n    if (u_debug < 9.5) { return vgPack(half3(N * 0.5 + 0.5), inMask); }\n    // spectral and adapt are shown by the LENS — the surface has to get out of the way.\n    return half4(0.0);\n  }\n\n  // The shadow and the halo live OUTSIDE the shape: inside, their place is taken by the glass\n  // itself. Separation from the content rests entirely on the shadow — without it the surface\n  // would sit ON the picture, not above it. The shadow only lives at the rim and outside it: at\n  // sd < −1 the outside multiplier is already zero. Computing it deep inside the shape would be\n  // a wasted FULL SDF evaluation for every such pixel, and the body covers almost the whole\n  // area. The branch here is on the coordinate, but only the threads right at the rim actually\n  // diverge.\n  float shade = 0.0;\n  float halo = 0.0;\n  if (sd > -1.0) {\n    float outside = smoothstep(-1.0, 1.0, sd);\n    // Under the finger a button moves TOWARD the backdrop, and the shadow tightens: it's exactly\n    // the gap between the two. A control rising into glass (a switch knob, a slider handle —\n    // reference §5) moves AWAY from it, and then the shadow spreads out instead. Only the app\n    // knows which one applies, so the direction arrives as a fraction: 0 is sinking in, the way\n    // every element behaved before this rule existed.\n    float reach = u_shadowReach * (1.0 + mix(-0.25, 0.55, u_lift) * u_press);\n    // The shadow is soft and wide, shifted downward (M 11:58): it's what holds the element's\n    // separation from the content.\n    float sdDrop = vgScene(p - float2(0.0, reach * 0.35), u_halfSize, u_corner,\n                           u_morphOffset, u_morphHalf, u_morphCorner, u_morphK,\n                u_morph2Offset, u_morph2Half, u_morph2Corner);\n    float amb = 1.0 - smoothstep(-reach * 0.3, reach, sdDrop);\n    // THE GAP UNDER A RAISED ELEMENT IS LIT: right at the outline the shadow is WEAKER than\n    // further down. Otherwise the minimum sits right against the silhouette — both parts of the\n    // shadow are monotonic in distance.\n    float gap = smoothstep(0.0, max(reach * VG_GAP_REACH, 1.0), max(sd, 0.0));\n    shade = amb * amb * 0.13 * mix(VG_GAP_LIGHT, 1.0, gap) * outside * u_shadow * u_appear;\n    halo = 1.0 - smoothstep(0.0, reach * 0.30, max(sd, 0.0));\n    halo = halo * halo * lit * 0.10 * outside * u_appear;\n  }\n\n  if (sd > 1.0) {\n    // Ambient light bleeds into the shadow (219 @8:22): it isn't a black hole, it's tinted by\n    // whatever lies nearby. Otherwise an element over colored content would hang over a gray\n    // blob.\n    half3 spill = max(half3(half(halo)) + half3(vgShadowTint(u_ambient)) * half(VG_SHADOW_TINT * shade * (1.0 - halo)), half3(0.0));\n    return half4(spill, half(halo + shade * (1.0 - halo)));\n  }\n\n  float density = u_tint.w;\n  float inner = clamp(-sd / halfMin, 0.0, 1.0);\n  half3 col = half3(u_tint.rgb);\n\n  // The tint is LIGHT and weak, not dark: dark glass over dark content disappears, and has to be\n  // held together with a heavy rim — which makes the surface read as a chrome bead. Tint density\n  // at the bevel is a separate value: physically the bevel bends light harder, but it doesn't\n  // get hazier. Coupled together, the two produced a milky ring around the whole outline.\n  float body = mix(VG_BODY_DENSITY, VG_BODY_DENSITY * u_edgeDensity, smoothstep(0.10, 0.62, t)) * density;\n  float vignette = smoothstep(0.15, 1.0, inner) * 0.19 * density;\n  // There's NO density boost on press here. It was meant as \"the element stands out more under\n  // the finger,\" but it pulls the body toward the tint, and the tint depends on polarity: over a\n  // light backdrop (dark polarity) press ended up DARKENING the element. Presence is shown\n  // instead by the vgTouchWarp field's deformation and the highlight blooming below — neither\n  // cares about the sign of polarity.\n  float a = max(body, vignette);\n\n  // Active state does NOT touch the body's color. Mixing in a fixed gray here flipped the\n  // effect's sign depending on the backdrop: over dark the element lightened, over light it\n  // darkened, for the exact same state. Active state is shown instead by the highlight and rim\n  // lighting above: neither cares about the backdrop.\n\n  // THE ICON SITS BENEATH THE SURFACE, it isn't stuck on top of it: it used to be mixed in last,\n  // over the highlight, and read as a flat sticker on volumetric glass. At the rim the normal\n  // displaces it, like everything seen through the glass, while the highlight sits ON TOP — it\n  // lives on the surface itself.\n  //\n  // There is NO shadow under the icon here. It used to be made from the difference of two offset\n  // mask samples and produced a second outline along the edge — the icon's borders looked\n  // ragged.\n  // THE INK'S SHIFT IS SET BY ITS OWN DEPTH, NOT BY BEVEL WIDTH. The ink sits right at the\n  // surface, and it's displaced by exactly the thin layer of glass above it — not by how wide a\n  // bevel this particular piece of glass happens to have. It used to be a fraction of the bevel:\n  // on thin glass the shift came out to 4 dp and everything lined up, but on thick glass it was\n  // 8, and cover art inset from the edge by 6 stretched toward the rim and spilled past its\n  // bounds. The ceiling is absolute: ink has one depth regardless of the glass.\n  float2 inkShift = n * (min(u_bevel * 0.5, VG_INK_DEPTH) * t);\n  float2 inkUv = u_center + p - inkShift;\n\n  // INK LOSES SHARPNESS UNDER THE FINGER (reference §6): in the reference, a glyph under\n  // pressure drowns in milk rather than simply getting lighter. This branch is uniform across\n  // the whole element: press arrives as a uniform, so defocus costs nothing while the element\n  // isn't being touched.\n  float defocus = VG_INK_DEFOCUS * u_touchRadius * u_touchPress;\n  float2 inkDx = float2(defocus, 0.0);\n  float2 inkDy = float2(0.0, defocus);\n\n  half4 ink;\n  half4 over;\n  if (defocus > 0.01) {\n    // A cross around the center with double weight in the middle: the ink mask is\n    // high-contrast, and four samples are enough for a stroke to stop holding its edge.\n    ink = (u_icon.eval((inkUv - inkDx) * u_iconScale)\n         + u_icon.eval((inkUv + inkDx) * u_iconScale)\n         + u_icon.eval((inkUv - inkDy) * u_iconScale)\n         + u_icon.eval((inkUv + inkDy) * u_iconScale)\n         + u_icon.eval(inkUv * u_iconScale) * 2.0) * half(u_iconOn / 6.0);\n    // Colored content lives in the same plane as the ink and blurs together with it: different\n    // sharpness for two layers in one plane would read as a defect, not a press.\n    over = (u_overlay.eval((inkUv - inkDx) * u_iconScale)\n          + u_overlay.eval((inkUv + inkDx) * u_iconScale)\n          + u_overlay.eval((inkUv - inkDy) * u_iconScale)\n          + u_overlay.eval((inkUv + inkDy) * u_iconScale)\n          + u_overlay.eval(inkUv * u_iconScale) * 2.0) * half(u_overlayOn * u_appear / 6.0);\n  } else {\n    ink = u_icon.eval(inkUv * u_iconScale) * half(u_iconOn);\n    over = u_overlay.eval(inkUv * u_iconScale) * half(u_overlayOn * u_appear);\n  }\n\n  // The backing under the ink is held by the LENS (body density from the probe), not the\n  // surface: legibility is a property of the material, and computing it here a second time\n  // would give two different answers to one question.\n\n  // Layers are composited premultiplied-over: in straight alpha, a nearly transparent dark body\n  // used to pull the color of semi-transparent ink and the finger's light toward itself — letter\n  // edges grayed out, pressing darkened things.\n  half3 pm = col * half(a);\n  half inkA = ink.g * half(mix(0.82, 1.0, u_active) * u_appear);\n  half3 inkCol = mix(half3(u_inkIdle.rgb), half3(u_inkActive.rgb), half(u_active));\n  pm = pm * (1.0 - inkA) + inkCol * inkA;\n  a = a + float(inkA) * (1.0 - a);\n\n  // COLORED CONTENT LIVES IN THE SAME PLACE AS THE INK — inside the material, at the same\n  // coordinate. Otherwise deformation would carry them apart: on press, the title and artist\n  // name would shake together with the surface while the cover art stayed put, because it used\n  // to be a separate layer on top of the glass. Polarity doesn't touch it — it has its own\n  // color, and there's nothing to swap it for.\n  pm = pm * (1.0 - over.a) + over.rgb * over.a;\n  a = a + float(over.a) * (1.0 - a);\n\n  // Light from the finger is gathered by the LENS: it's a concentration of the surroundings, not\n  // the glass's own whiteness. The surface is left with only what the glass spills outward — the\n  // halo above.\n\n  float mask = 1.0 - smoothstep(-1.0, 1.0, sd);\n  pm = clamp(pm, half3(0.0), half3(1.0)) * half(mask);\n  a *= mask;\n  pm = max(pm + half3(vgShadowTint(u_ambient)) * half(VG_SHADOW_TINT * shade * (1.0 - a)), half3(0.0));\n  return half4(pm, half(a + shade * (1.0 - a)));\n}\n`;\n","// WebGL2 target. Translates the same AGSL text (SDF + body, see `targets/agsl.ts`) into GLSL\n// ES 3.0. Each conversion rule is its own function with its own test in\n// `__tests__/targets.test.ts`. Three spots are NOT mechanical: the coordinate origin, units of\n// measure (settled in the web renderer's own setup, not here), and sampler filtering (also the\n// renderer's concern). What's here is text conversion only.\n\n/**\n * The sampler-size uniform's name, for translating `NAME.eval(coord)` → `texture(NAME, coord / SIZE)`.\n * A new uniform — there's no equivalent in AGSL: `.eval()` has the size implicitly known to the\n * shader, while GLSL's `texture()` needs a normalized coordinate. One per `uniform shader`/\n * `uniform sampler2D`, its name derived from the sampler's name rather than hardcoded.\n */\nfunction sizeUniformName(sampler: string): string {\n  return sampler.startsWith('u_') ? `${sampler}Size` : `u_${sampler}Size`;\n}\n\n/** float2/float3/float4 → vec2/vec3/vec4. */\nexport function convertVecTypes(src: string): string {\n  return src.replace(/\\bfloat([234])\\b/g, 'vec$1');\n}\n\n/** half/half2/half3/half4 → float/vec2/vec3/vec4, including half(x) → float(x) casts. */\nexport function convertHalfTypes(src: string): string {\n  return src.replace(/\\bhalf([234])\\b/g, 'vec$1').replace(/\\bhalf\\b/g, 'float');\n}\n\n/** `uniform shader NAME;` → `uniform sampler2D NAME;` + a new `uniform vec2 <sizeUniform>;`. */\nexport function convertShaderUniforms(src: string): string {\n  return src.replace(/uniform\\s+shader\\s+(\\w+)\\s*;/g, (_match, name: string) => {\n    return `uniform sampler2D ${name};\\nuniform vec2 ${sizeUniformName(name)};`;\n  });\n}\n\n/**\n * `NAME.eval(coord)` → `texture(NAME, (coord) / <sizeUniform>)` for each declared\n * `uniform sampler2D`. The bounds of `coord` are found by scanning parens, not with a regex: the\n * arguments are nested calls (`content.eval(vgInContent(s + dR - e))`) with commas and\n * parentheses inside.\n */\nexport function convertEvalCalls(src: string): string {\n  const samplers = new Set<string>();\n  const declRe = /uniform\\s+sampler2D\\s+(\\w+)\\s*;/g;\n  for (let m = declRe.exec(src); m; m = declRe.exec(src)) samplers.add(m[1]);\n  if (samplers.size === 0) return src;\n\n  const callRe = /(\\w+)\\.eval\\(/g;\n  let out = '';\n  let cursor = 0;\n  for (let m = callRe.exec(src); m; m = callRe.exec(src)) {\n    const name = m[1];\n    if (!samplers.has(name)) continue;\n    const argStart = m.index + m[0].length;\n    let depth = 1;\n    let i = argStart;\n    while (i < src.length && depth > 0) {\n      if (src[i] === '(') depth += 1;\n      else if (src[i] === ')') depth -= 1;\n      i += 1;\n    }\n    const args = src.slice(argStart, i - 1);\n    out += src.slice(cursor, m.index);\n    out += `texture(${name}, (${args}) / ${sizeUniformName(name)})`;\n    cursor = i;\n    callRe.lastIndex = i;\n  }\n  out += src.slice(cursor);\n  return out;\n}\n\n/**\n * Early `return <expression>;` inside `main` → `fragColor = <expression>; return;`. Takes ONLY\n * the body of main (see `convertEntryPoint`) — ordinary `return`s in helper functions live\n * outside this text and are untouched. Expressions never contain a `;` of their own (shaders have\n * none — the only `;` lives inside `for(...)`, which isn't a return), so `[^;]+` is safe.\n */\nexport function convertReturns(mainBody: string): string {\n  return mainBody.replace(/\\breturn\\s+([^;]+);/g, 'fragColor = $1; return;');\n}\n\nconst ENTRY_RE = /half4\\s+main\\s*\\(\\s*float2\\s+(\\w+)\\s*\\)\\s*\\{/;\n\n/**\n * `half4 main(float2 xy) { ... }` → `void main() { vec2 xy = <Y-flipped coordinate>; ...; }`.\n * AGSL gives `xy` in screen pixels, top-left origin, y down; `gl_FragCoord` is bottom-left\n * origin, y up. The flip via `u_resolution.y - gl_FragCoord.y` restores the original convention\n * (both coordinate systems center the pixel at `+0.5`, so no X shift or constant is needed).\n * `out vec4 fragColor` and `uniform vec2 u_resolution` are declared in the prologue (`addPrologue`).\n */\nexport function convertEntryPoint(src: string): string {\n  const match = ENTRY_RE.exec(src);\n  if (!match) {\n    throw new Error('vireglass/targets/glsl: entry point \"half4 main(float2 xy)\" not found');\n  }\n  const bodyStart = match.index + match[0].length;\n  let depth = 1;\n  let i = bodyStart;\n  while (i < src.length && depth > 0) {\n    if (src[i] === '{') depth += 1;\n    else if (src[i] === '}') depth -= 1;\n    i += 1;\n  }\n  const bodyEnd = i - 1;\n  const param = match[1];\n  const body = convertReturns(src.slice(bodyStart, bodyEnd));\n  const head = src.slice(0, match.index);\n  const tail = src.slice(i);\n  return (\n    `${head}void main() {\\n` +\n    `  vec2 ${param} = vec2(gl_FragCoord.x, u_resolution.y - gl_FragCoord.y);\\n` +\n    `${body}}${tail}`\n  );\n}\n\n/** `#version 300 es` + `precision highp float;` — no equivalent in AGSL, WebGL2 requires them as\n *  the file's first lines. `out vec4 fragColor` and `uniform vec2 u_resolution` ride along here\n *  too: both new, with no counterpart in the source, needed by exactly one entry point\n *  (`convertEntryPoint`). */\nexport function addPrologue(src: string): string {\n  return (\n    '#version 300 es\\n' +\n    'precision highp float;\\n\\n' +\n    'out vec4 fragColor;\\n' +\n    'uniform vec2 u_resolution;\\n\\n' +\n    src\n  );\n}\n\n/** Full translation AGSL/SkSL → GLSL ES 3.0. Order matters: the entry point is found by its\n *  literal AGSL signature BEFORE type conversion, otherwise `half4 main(float2 xy)` can't be\n *  found. */\nexport function toGLSL(shaderSource: string): string {\n  let out = shaderSource;\n  out = convertEntryPoint(out);\n  out = convertShaderUniforms(out);\n  out = convertEvalCalls(out);\n  out = convertVecTypes(out);\n  out = convertHalfTypes(out);\n  out = addPrologue(out);\n  return out;\n}\n"]}