react-native-webrtc-kaleidoscope 2.6.1 → 2.7.1

package/dist/web-driver/shaders.generated.js

@@ -2,7 +2,7 @@
 // @generated by scripts/build-shaders.ts from shaders/. DO NOT EDIT.
 // Run `bun run build:shaders` to regenerate.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHADER_SOURCES = exports.CORPORATE_BLOBS_FRAG_SRC = exports.LIGHT_BEAMS_AND_MOTES_FRAG_SRC = exports.ANAMORPHIC_LENSFLARE_FRAG_SRC = exports.SIMIANLIGHTS_FRAG_SRC = exports.FIREFLIES_FRAG_SRC = exports.GODRAYS_FRAG_SRC = exports.NEBULA_FRAG_SRC = exports.CLOUDS_FRAG_SRC = exports.OUTRUN_GRID_FRAG_SRC = exports.AURORA_SILK_FRAG_SRC = exports.HALFTONE_WAVES_FRAG_SRC = exports.NEO_MEMPHIS_FRAG_SRC = exports.KALEIDOSCOPE_FRAG_SRC = exports.PLASMA_FRAG_SRC = exports.COMPOSITE_MASKED_FRAG_SRC = exports.COMPOSITE_SUBJECT_FRAG_SRC = exports.COMPOSITE_IMAGE_FRAG_SRC = exports.COMPOSITE_BLUR_FRAG_SRC = exports.COMPOSITE_CAMERA_FRAG_SRC = exports.PASSTHROUGH_VERT_SRC = void 0;
+exports.SHADER_SOURCES = exports.DATA_MESH_FRAG_SRC = exports.CORPORATE_BLOBS_FRAG_SRC = exports.LIGHT_BEAMS_AND_MOTES_FRAG_SRC = exports.ANAMORPHIC_LENSFLARE_FRAG_SRC = exports.SIMIANLIGHTS_FRAG_SRC = exports.FIREFLIES_FRAG_SRC = exports.GODRAYS_FRAG_SRC = exports.NEBULA_FRAG_SRC = exports.CLOUDS_FRAG_SRC = exports.OUTRUN_GRID_FRAG_SRC = exports.AURORA_SILK_FRAG_SRC = exports.HALFTONE_WAVES_FRAG_SRC = exports.NEO_MEMPHIS_FRAG_SRC = exports.KALEIDOSCOPE_FRAG_SRC = exports.PLASMA_FRAG_SRC = exports.COMPOSITE_MASKED_FRAG_SRC = exports.COMPOSITE_SUBJECT_FRAG_SRC = exports.COMPOSITE_IMAGE_FRAG_SRC = exports.COMPOSITE_BLUR_FRAG_SRC = exports.COMPOSITE_CAMERA_FRAG_SRC = exports.PASSTHROUGH_VERT_SRC = void 0;
 exports.PASSTHROUGH_VERT_SRC = `#version 300 es
 precision highp float;
 out highp vec2 vUv;
@@ -537,34 +537,38 @@ void main() {
 
     col = mix(col, sunCol, sunBody);
   } else {
-    // --- FLOOR --- perspective grid. Guard the divide; shade only below horizon.
-    float depth = 1.0 / max(h - fy, 1.5e-3); // large near the horizon
-    float depthMin = 1.0 / h;                // depth at the very front (fy = 0)
-
-    // Grid coordinates: x widens with depth (perspective); uGridDensity sets the
-    // cell count; the scroll is in cell units so its rate is density-independent.
-    vec2 g = vec2(fx * depth, depth) * uGridDensity;
-    g.y += uTime * uSpeed * 2.0;
-    vec2 cell = abs(fract(g) - 0.5); // 0 on a line .. 0.5 mid-cell, per axis
-
-    // Per-axis, depth-scaled line half-width: the rungs (g.y) compress toward the
-    // horizon as depth^2 and the verticals (g.x) ~linearly, so widening each axis'
-    // line band at its own compression rate holds the on-screen line width roughly
-    // constant. Far lines fuse into a band instead of a sub-pixel sheet that
-    // shimmers as it scrolls; near lines stay crisp. Written 1 - smoothstep(0, w, .)
-    // (NOT the reversed-edge smoothstep(w, 0, .), which is undefined on GLSL ES /
-    // Metal) and derivative-free, so it is portable and mobile-precision safe.
-    vec2 w = max(vec2(depth, depth * depth * 0.2) * uGridDensity * 0.0013, vec2(1e-4));
-    vec2 core = 1.0 - smoothstep(vec2(0.0), w, cell);
-    vec2 halo = (1.0 - smoothstep(vec2(0.0), w * 6.0, cell)) * (0.5 * uGridGlow);
-    float gridVal = clamp(core.x + core.y + halo.x + halo.y, 0.0, 1.5);
-
-    // Distance fog: fade the grid out toward the horizon for the converging look.
-    float fog = clamp(1.0 - (depth - depthMin) / (depthMin * 10.0), 0.0, 1.0);
-    fog *= fog;
-
-    vec3 floorBase = mix(vec3(0.0), uSkyHorizon * 0.16, fog * 0.6);
-    col = floorBase + uGridColor * gridVal * fog * calm;
+    // --- FLOOR --- perspective grid, a faithful port of a known-good community
+    // outrun grid (prior versions read as a too-dense, flickering sheet). Work in
+    // the reference's centered frame: cx is full-width centered x, dy is the
+    // centered distance BELOW the horizon. The additive offset caps the depth at
+    // the horizon, and putting big cells in the near field (low min depth) is what
+    // keeps the line spacing above a pixel, so it neither sheets nor shimmers.
+    float cx = 2.0 * fx;            // = (2*vUv.x - 1) * aspect
+    float dy = 2.0 * (h - fy);      // centered distance below the horizon (> 0)
+
+    // Cell count: uGridDensity 4 -> numerator 1.0 (sparse, big near cells). x
+    // widens with depth (the 0.7 factor); scroll is a slow drift toward the viewer.
+    float num = uGridDensity * 0.25;
+    float depth = num / (dy + 0.05);
+    vec2 g = vec2(cx * depth * 0.7, depth);
+    g.y += uTime * uSpeed * 0.3;
+    vec2 e = abs(fract(g) - 0.5);
+
+    // PIXEL-CALIBRATED line width: each line core is a fixed ~px wide in SCREEN
+    // PIXELS (via uResolution), the same at every depth and every resolution. The
+    // old depth^2*const width was constant in theory but landed sub-pixel, so
+    // discrete sampling rendered some rungs thick and others thin -> the uneven
+    // rungs that read as flicker. Solving sz so screen thickness == px: the rungs
+    // (g.y, compression ~depth^2/num) need sz.y = depth^2 * pf / num; the verticals
+    // (g.x) need sz.x = depth * 0.7 * pf. uGridGlow sets px (0.5 -> 2 px).
+    float pf = (uGridGlow * 4.0) / uResolution.y;
+    vec2 sz = vec2(depth * 0.7 * pf, depth * depth * pf / num);
+    vec2 lines = 1.0 - smoothstep(vec2(0.0), sz, e);
+    lines += (1.0 - smoothstep(vec2(0.0), sz * 4.0, e)) * 0.5;
+    float gridVal = clamp(lines.x + lines.y, 0.0, 1.0);
+
+    vec3 floorBase = uSkyHorizon * 0.06;
+    col = mix(floorBase, uGridColor, gridVal * calm);
   }
 
   // Glowing horizon seam where floor meets sky.
@@ -710,9 +714,11 @@ const float MIN_DIVIDE = 64.0;
 const float MAX_DIVIDE = 0.01;
 // Number of stacked starfield layers. Compile-time constant so the layer
 // loop has a fixed integer bound (cross-compile-safe; no float loop counter).
-// 8 (was 12) for low-end-mobile cost (issue #39); the work is linear in the
-// count and dimByDensity rebalances per-star brightness automatically.
-const int STARFIELD_LAYERS_COUNT = 8;
+// 7 (was 8 #74, was 12 #39) for cost; the work is linear in the count and
+// dimByDensity rebalances per-star brightness automatically. 7 keeps the dense
+// look essentially intact (6 was visibly sparser at some animation phases);
+// paired with the empty-cell early-out below it lands ~34% under the old 8.
+const int STARFIELD_LAYERS_COUNT = 7;
 
 mat2 Rotate(float angle) {
   float s = sin(angle);
@@ -780,6 +786,12 @@ vec3 StarFieldLayer(vec2 uv, float rotAngle) {
       float size = fract(randomN * 1356.33);
       float flareSwitch = smoothstep(0.9, 1.0, size);
       float star = Star(randomPosition, flareSwitch, rotAngle, randomN);
+      // The per-cell color below is multiplied by \`star\` at the end, so for any
+      // cell whose star is 0 (Star() returns exactly 0 for d >= 1.0, i.e. the
+      // empty-sky majority of the 8x9 = 72 cells/pixel) the whole term is 0.
+      // Skipping the sin(vec3) color work for those cells is output-identical and
+      // is the bulk of the win (issue #74).
+      if (star <= 0.0) continue;
 
       // fract trick: random colors
       float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;
@@ -1643,6 +1655,166 @@ void main() {
     oColor = vec4(blobCol * uColor, blobAlpha);
 }
 `;
+exports.DATA_MESH_FRAG_SRC = `#version 300 es
+precision highp float;
+
+uniform float uTime;        // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;   // framebuffer size in pixels; both components > 0
+uniform vec3 uBgTop;        // background gradient color at the top of frame
+uniform vec3 uBgBottom;     // background gradient color at the bottom of frame
+uniform vec3 uLineColor;    // mid wireframe-line tint (the trough/body color)
+uniform vec3 uCrestColor;   // crest highlight color (brightest along the peaks)
+uniform vec3 uHazeColor;    // atmospheric haze tint on the far rows
+uniform vec3 uAccentColor;  // the one restrained accent (e.g. enterprise red)
+uniform float uWaveScale;   // wave-field spatial frequency; lower = looser, broader hills
+uniform float uWaveAmp;     // vertical wave displacement amount (near rows)
+uniform float uWaveSpeed;   // animation rate; 0 freezes the surface
+uniform float uGridX;       // column-grid density across the surface; keep loose
+uniform float uHorizon;     // horizon height in uv.y units (rows converge toward it)
+uniform float uFarScale;    // perspective scale of the farthest row, 0.05..0.5 (>0)
+uniform float uSlant;       // diagonal tilt; raises the right side for corner composition
+uniform float uLineWidth;   // wireframe line half-width (smaller = finer, sharper)
+uniform float uNodeMix;     // 0..1 emphasis of glowing intersection nodes (dot reading)
+uniform float uStrutMix;    // 0..1 emphasis of vertical struts (wireframe reading)
+uniform float uGlow;        // overall additive mesh-glow / bloom strength
+uniform float uHaze;        // atmospheric far-haze strength
+uniform float uParticles;   // floating-particle intensity; 0 disables the field
+uniform float uAccent;      // lone accent-mote intensity; 0 disables it
+uniform float uCalm;        // 0..1 eases the additive glow at frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+// ROWS / PARTICLES must stay compile-time constants (GLSL ES loop bounds). ROWS is
+// kept modest on purpose (loose mesh); perspective bunching toward the horizon
+// makes it read as far more lines than it costs.
+#define ROWS                18
+#define PARTICLES           10
+#define WAVE_DEPTH_SPAN     4.5   // world-depth the eased row range maps across
+#define COL_SHARP           48.0  // column-stripe sharpness in cell-phase units
+#define Y_NEAR             (-0.62) // nearest row baseline (just below the bottom edge)
+
+// Cheap stable hash for the particle field (highp; the 43758.5453 multiplier
+// bands under mediump, same note as clouds/nebula).
+float hash11(float n) {
+  return fract(sin(n * 12.9898) * 43758.5453123);
+}
+
+// The shared surface. x is perspective world-x, z is eased world-depth, t is time.
+// A small sum of sines whose x/z cross terms produce the hills, valleys, and
+// saddles; bounded to roughly [-1.6, 1.6].
+float waveField(float x, float z, float t) {
+  float h = 0.0;
+  h += sin(x * 1.00 + z * 0.55 + t) * 0.60;
+  h += sin(x * 0.55 - z * 0.95 - t * 0.70) * 0.45;
+  h += sin((x + z) * 0.45 + t * 0.40 + 1.7) * 0.40; // diagonal ridges -> saddles
+  h += sin(x * 1.70 - z * 0.30 + t * 1.20) * 0.16;  // fine ripple
+  return h;
+}
+
+void main() {
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y; // centered, aspect-correct
+
+  // Background: smooth vertical gradient, no texture. g = 0 bottom .. 1 top.
+  float g = clamp(uv.y + 0.5, 0.0, 1.0);
+  vec3 col = mix(uBgBottom, uBgTop, g);
+
+  // Ease additive glow near the frame center (the subject's face sits there).
+  float calm = 1.0 - uCalm * (1.0 - smoothstep(0.18, 0.62, length(uv)));
+
+  float t = uTime * uWaveSpeed;
+  float horizon = clamp(uHorizon, -0.2, 0.45);
+
+  // Line-glow widths from the half-width. The core line keeps the one exp() (its
+  // sharp gaussian is the wireframe signature); the bloom halo and the vertical
+  // strut use rational falloffs (1/(1+k·dy^2)) instead of more exp() calls, which
+  // are ~8x-weighted transcendentals on the hot per-row path. The node reuses the
+  // core exp directly. Net: 2 exp/row (core + column), down from 5.
+  float coreSharp = 1.0 / max(uLineWidth * uLineWidth, 1e-5);
+  float haloK = coreSharp * 0.14;  // rational-bloom width (matches the old halo half-width)
+  float strutK = coreSharp * 0.14; // rational vertical-bridge width
+
+  vec3 mesh = vec3(0.0);
+  vec3 haze = vec3(0.0);
+
+  for (int i = 0; i < ROWS; i++) {
+    float rowT = float(i) / float(ROWS - 1);     // 0 near .. 1 far
+    float om = 1.0 - rowT;
+    float f = 1.0 - om * om;                      // eased depth: rows bunch toward horizon
+    float persp = mix(1.0, uFarScale, f);
+    persp = max(persp, uFarScale);                // guard the divide (uFarScale > 0)
+
+    // Row baseline in screen-y, with a diagonal tilt for corner composition.
+    float baseY = mix(Y_NEAR, horizon, f) + uv.x * uSlant * persp;
+
+    // Early-out: skip the sines for any row that cannot reach this pixel. Margin
+    // covers the max wave displacement plus the strut's vertical bridge.
+    float reach = persp * uWaveAmp * 1.7 + uLineWidth * 3.0 + 0.06;
+    if (abs(uv.y - baseY) > reach) continue;
+
+    float worldX = uv.x / persp;
+    float h = waveField(worldX * uWaveScale, f * WAVE_DEPTH_SPAN, t);
+    float surfY = baseY + persp * uWaveAmp * h;
+    float dy = uv.y - surfY;
+
+    // Crest factor: peaks of the field glow white, troughs stay the line tint.
+    float crest = smoothstep(0.2, 1.4, h);
+
+    // Horizontal ribbon: sharp gaussian core (the line) + rational bloom halo.
+    float dy2 = dy * dy;
+    float core = exp(-dy2 * coreSharp);
+    float ribbon = core + 0.22 / (1.0 + dy2 * haloK);
+
+    // Column grid: one bright stripe per cell of worldX. cph = 0 at the stripe.
+    float cph = fract(worldX * uGridX) - 0.5;
+    float colLine = exp(-cph * cph * COL_SHARP);
+
+    // Vertical strut (rational falloff in y so it bridges toward neighbors, gated
+    // by the column) and the intersection node (core line x column -> a glowing
+    // dot; reuses the core exp, no extra transcendental).
+    float strut = colLine / (1.0 + dy2 * strutK);
+    float node = core * colLine;
+
+    // Atmospheric fade: far rows dim and tint toward the haze color.
+    float fade = om * om;                          // 1 near .. 0 far
+    float lit = ribbon + uStrutMix * strut + uNodeMix * node * 2.0;
+    vec3 lineCol = mix(uLineColor, uCrestColor, crest);
+
+    // Crest-dominant brightness: troughs stay dim, peaks carry the illumination.
+    mesh += lineCol * lit * fade * (0.35 + 1.0 * crest);
+    haze += uHazeColor * ribbon * (1.0 - fade) * crest;
+  }
+
+  col += mesh * uGlow * calm;
+  col += haze * uHaze * calm;
+
+  // Sparse floating particles; index 0 is the lone accent mote (independent of
+  // uParticles so an accent can show with the particle field off).
+  if (uParticles > 0.0 || uAccent > 0.0) {
+    vec3 motes = vec3(0.0);
+    for (int p = 0; p < PARTICLES; p++) {
+      float fp = float(p);
+      vec2 seed = vec2(hash11(fp * 1.7 + 0.3), hash11(fp * 3.1 + 1.9));
+      vec2 ppos = (seed * 2.0 - 1.0) * vec2(0.92, 0.46);
+      ppos.x += sin(uTime * 0.07 + fp * 2.3) * 0.03;
+      ppos.y += cos(uTime * 0.05 + fp * 1.7) * 0.03;
+      float twinkle = 0.5 + 0.5 * sin(uTime * (0.6 + hash11(fp * 5.0)) + fp * 4.0);
+      float pd = length(uv - ppos);
+      float glint = exp(-pd * pd * 2300.0) * twinkle;
+      vec3 pcol = (p == 0) ? uAccentColor * uAccent : uCrestColor * uParticles;
+      motes += pcol * glint;
+    }
+    col += motes * calm;
+  }
+
+  // Soft highlight rolloff: fold the additive foreground pile-up into clean white
+  // crests instead of a clipped slab; leaves the dark gradient essentially intact.
+  col = vec3(1.0) - exp(-col);
+
+  oColor = vec4(col, 1.0);
+}
+`;
 // Generative background shaders, by name. The generic shader processor and the
 // dispatch iterate this; adding a generative .frag adds an entry here.
 exports.SHADER_SOURCES = {
@@ -1660,5 +1832,6 @@ exports.SHADER_SOURCES = {
     'anamorphic-lensflare': exports.ANAMORPHIC_LENSFLARE_FRAG_SRC,
     'light-beams-and-motes': exports.LIGHT_BEAMS_AND_MOTES_FRAG_SRC,
     'corporate-blobs': exports.CORPORATE_BLOBS_FRAG_SRC,
+    'data-mesh': exports.DATA_MESH_FRAG_SRC,
 };
 //# sourceMappingURL=shaders.generated.js.map