tawasuyu/brahman

1//! Fuentes GLSL ES 3.00 para GioSer.
2//!
3//! Cada `const &str` es un shader completo listo para `gl.shaderSource()`.
4//! Convención: precision `highp float`, atributo `a_pos`, varying `v_*`,
5//! uniforms `u_*`.
6
7#![no_std]
8
9/// Vertex shader para quads en clip-space `[-1, 1]²`.
10pub const VS_FULLSCREEN: &str = "#version 300 es
11precision highp float;
12in vec2 a_pos;
13out vec2 v_clip;
14out vec2 v_uv;
15void main() {
16    v_clip = a_pos;
17    v_uv = a_pos * 0.5 + 0.5;
18    gl_Position = vec4(a_pos, 0.0, 1.0);
19}
20";
21
22/// Fragment del fondo cósmico: nubes FBM en 3 capas con drift visible,
23/// 3 estratos de estrellas con titilación independiente, viñeta radial,
24/// 4 meteoros procedurales con vida cíclica.
25pub const FS_COSMOS: &str = "#version 300 es
26precision highp float;
27in vec2 v_clip;
28in vec2 v_uv;
29out vec4 fragColor;
30uniform vec2  u_resolution;
31uniform float u_time;
32uniform vec2  u_parallax;
33uniform vec3  u_void;
34uniform vec3  u_nebula_a;
35uniform vec3  u_nebula_b;
36uniform vec3  u_stardust;
37
38float hash21(vec2 p) {
39    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
40}
41float hash11(float n) {
42    return fract(sin(n * 78.233) * 43758.5453);
43}
44float vnoise(vec2 p) {
45    vec2 i = floor(p);
46    vec2 f = fract(p);
47    f = f * f * (3.0 - 2.0 * f);
48    float a = hash21(i);
49    float b = hash21(i + vec2(1.0, 0.0));
50    float c = hash21(i + vec2(0.0, 1.0));
51    float d = hash21(i + vec2(1.0, 1.0));
52    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
53}
54float fbm(vec2 p) {
55    float v = 0.0;
56    float a = 0.55;
57    for (int i = 0; i < 5; i++) {
58        v += a * vnoise(p);
59        p = p * 2.07 + vec2(11.3, 7.7);
60        a *= 0.55;
61    }
62    return v;
63}
64
65float meteor(vec2 uv, float seed) {
66    float period = 6.5 + 4.0 * hash11(seed * 17.0);
67    float t_seeded = u_time + seed * 19.0;
68    float phase = mod(t_seeded, period);
69    float life = 1.6;
70    if (phase > life) return 0.0;
71    float t = phase / life;
72
73    float epoch = floor(t_seeded / period);
74    vec2 origin = vec2(
75        hash21(vec2(seed, epoch)) * 2.6 - 1.3,
76        0.55 + hash21(vec2(seed + 5.0, epoch)) * 0.55
77    );
78    vec2 dir = normalize(vec2(
79        hash21(vec2(seed + 1.0, epoch)) * 1.6 - 0.8,
80        -0.7 - hash21(vec2(seed + 2.0, epoch)) * 0.6
81    ));
82    vec2 head = origin + dir * t * 2.1;
83    vec2 tail = head - dir * 0.24;
84    vec2 pa = uv - tail;
85    vec2 ba = head - tail;
86    float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0);
87    float dist = length(pa - ba * h);
88    float perpGlow = exp(-dist * 420.0);
89    float trailFalloff = smoothstep(0.0, 1.0, h);
90    float headPulse = exp(-dist * 900.0);
91    float lifeFade = sin(t * 3.14159);
92    return (perpGlow * trailFalloff + headPulse * 1.4) * lifeFade;
93}
94
95void main() {
96    float aspect = u_resolution.x / max(u_resolution.y, 1.0);
97    vec2 uv = v_clip;
98    uv.x *= aspect;
99
100    vec2 d1 = vec2( u_time * 0.055,  u_time * 0.022) + u_parallax * 0.10;
101    vec2 d2 = vec2(-u_time * 0.085,  u_time * 0.058) + u_parallax * 0.22;
102    vec2 d3 = vec2( u_time * 0.130, -u_time * 0.095) + u_parallax * 0.40;
103    float n1 = fbm(uv * 0.85 + d1);
104    float n2 = fbm(uv * 2.05 + d2);
105    float n3 = fbm(uv * 4.40 + d3);
106
107    vec3 color = u_void;
108    color = mix(color, u_nebula_a, pow(n1, 1.5) * 0.80);
109    color = mix(color, u_nebula_b, pow(n2, 1.85) * 0.62);
110    color += u_nebula_a * pow(n3, 3.0) * 0.28;
111
112    float r = length(v_clip);
113    color *= 1.0 - smoothstep(0.55, 1.40, r) * 0.85;
114
115    {
116        vec2 sgrid = uv * 75.0;
117        vec2 sid = floor(sgrid);
118        float sh = hash21(sid);
119        float tw = 0.45 + 0.55 * sin(u_time * 2.6 + sh * 41.0);
120        float mask = smoothstep(0.9935, 0.999, sh);
121        color += u_stardust * mask * tw * 1.15;
122    }
123    {
124        vec2 sgrid = uv * 135.0 + vec2(7.0, 11.0);
125        vec2 sid = floor(sgrid);
126        float sh = hash21(sid);
127        float tw = 0.55 + 0.45 * sin(u_time * 1.1 + sh * 28.0);
128        float mask = smoothstep(0.987, 0.994, sh);
129        color += u_stardust * mask * tw * 0.75;
130    }
131    {
132        vec2 sgrid = uv * 260.0 + vec2(13.0, 3.0);
133        vec2 sid = floor(sgrid);
134        float sh = hash21(sid);
135        float tw = 0.7 + 0.3 * sin(u_time * 0.5 + sh * 15.0);
136        float mask = smoothstep(0.982, 0.989, sh);
137        color += u_stardust * mask * tw * 0.40;
138    }
139
140    float meteors = 0.0;
141    meteors += meteor(uv, 0.31);
142    meteors += meteor(uv, 1.73);
143    meteors += meteor(uv, 4.29);
144    meteors += meteor(uv, 7.11);
145    color += vec3(1.0, 0.94, 0.78) * meteors * 1.1;
146
147    fragColor = vec4(color, 1.0);
148}
149";
150
151/// Vertex de la chacana: aplica MVP y pasa la posición de mundo al fragment.
152pub const VS_CHACANA: &str = "#version 300 es
153precision highp float;
154in vec2 a_pos;
155out vec2 v_world;
156uniform mat4 u_mvp;
157void main() {
158    v_world = a_pos;
159    gl_Position = u_mvp * vec4(a_pos, 0.0, 1.0);
160}
161";
162
163/// Fragment de la chacana mística (estética dorada del logo GioSer):
164/// 1. **Sol detrás**: halo gauss + corona, visible SÓLO dentro de la superficie
165///    de la chacana (clip por SDF), apenas asomando por las junturas de los pasos.
166/// 2. **Doble outline**: dos líneas paralelas en dorado/ámbar — la chacana se
167///    siente "grabada" sobre el cielo.
168/// 3. **Interior**: niebla oscura translúcida con sutiles rayos radiales
169///    desde el centro (el sol los proyecta a través de la superficie).
170/// 4. **Aro doble exterior**: ring fino + ring grueso (este último con marcas
171///    cardinales de 3 puntos cada una, como en el logo).
172///
173/// Uniforms:
174///   `u_time`, `u_thickness` (s), `u_center_half` (c), `u_arm_extent` (L),
175///   `u_line_color` (gold rim), `u_rim_color` (gold rim oscuro),
176///   `u_sun_color`, `u_sun_pulse`, `u_dark_color` (interior fill).
177pub const FS_CHACANA: &str = "#version 300 es
178precision highp float;
179in vec2 v_world;
180out vec4 fragColor;
181uniform float u_time;
182uniform float u_thickness;
183uniform float u_center_half;
184uniform float u_arm_extent;
185uniform vec3  u_line_color;
186uniform vec3  u_rim_color;
187uniform vec3  u_sun_color;
188uniform vec3  u_dark_color;
189uniform float u_sun_pulse;
190
191const float PI = 3.14159265;
192
193float sdBox(vec2 p, vec2 b) {
194    vec2 d = abs(p) - b;
195    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
196}
197
198// Chacana de 2 escalones (mística clásica de Tiwanaku).
199float sdChacana(vec2 p, float s, float c) {
200    float d = sdBox(p, vec2(c, c));
201    float hd = 0.5 * s;
202    float mid1 = c + 0.5 * s;
203    float hw1 = 2.0 * s;
204    d = min(d, sdBox(p - vec2(0.0,  mid1), vec2(hw1, hd)));
205    d = min(d, sdBox(p - vec2(0.0, -mid1), vec2(hw1, hd)));
206    d = min(d, sdBox(p - vec2( mid1, 0.0), vec2(hd, hw1)));
207    d = min(d, sdBox(p - vec2(-mid1, 0.0), vec2(hd, hw1)));
208    float mid2 = c + 1.5 * s;
209    float hw2 = 1.0 * s;
210    d = min(d, sdBox(p - vec2(0.0,  mid2), vec2(hw2, hd)));
211    d = min(d, sdBox(p - vec2(0.0, -mid2), vec2(hw2, hd)));
212    d = min(d, sdBox(p - vec2( mid2, 0.0), vec2(hd, hw2)));
213    d = min(d, sdBox(p - vec2(-mid2, 0.0), vec2(hd, hw2)));
214    return d;
215}
216
217// 3 puntos pequeños en cada uno de los 4 cardinales sobre el aro grueso.
218float cardinal_dots(vec2 p, float ringR, float dotSize) {
219    float r = length(p);
220    float ang = atan(p.y, p.x);
221    // Acercamiento al aro (gauss tight en r=ringR).
222    float on_ring = exp(-((r - ringR) * (r - ringR)) / (2.0 * dotSize * dotSize));
223    float dots = 0.0;
224    // 4 cardinales en ángulos 0, π/2, π, -π/2.
225    for (int i = 0; i < 4; i++) {
226        float base = float(i) * (PI * 0.5);
227        // 3 puntos por cardinal, offset angular pequeño.
228        for (int j = -1; j <= 1; j++) {
229            float a = base + float(j) * 0.075;
230            float da = ang - a;
231            da = da - 2.0 * PI * floor((da + PI) / (2.0 * PI));
232            dots += exp(-(da * da) / (2.0 * 0.012 * 0.012));
233        }
234    }
235    return on_ring * dots;
236}
237
238void main() {
239    vec2 p = v_world;
240    float d = sdChacana(p, u_thickness, u_center_half);
241    float r = length(p);
242
243    // === SOL DETRÁS ===
244    // Halo grande, sólo visible dentro de la superficie de la chacana.
245    float inside = 1.0 - smoothstep(-0.004, 0.004, d);
246    float sunR = u_thickness * 0.42;
247    float sun = exp(-(r * r) / (2.0 * sunR * sunR));
248    float corR = u_center_half * 0.75;
249    float corona = exp(-(r * r) / (2.0 * corR * corR));
250    float halo = sun * (1.15 + 0.20 * u_sun_pulse) + corona * (0.55 + 0.15 * u_sun_pulse);
251
252    // Rayos radiales sutiles desde el centro, sólo visibles donde la superficie
253    // de la chacana los recibe.
254    float ang = atan(p.y, p.x);
255    float radial = pow(abs(cos(ang * 4.0 + sin(u_time * 0.3) * 0.2)), 8.0)
256                 * smoothstep(0.0, u_center_half * 0.8, r)
257                 * (1.0 - smoothstep(u_center_half * 0.85, u_center_half * 1.2, r))
258                 * 0.30;
259
260    // === DOBLE OUTLINE ===
261    // Línea interior (sobre la SDF=0).
262    float lineW1 = 0.0085;
263    float line_in = exp(-(d * d) / (2.0 * lineW1 * lineW1));
264    // Línea exterior paralela, offset 0.018 hacia afuera.
265    float dOff = d - 0.020;
266    float lineW2 = 0.005;
267    float line_out = exp(-(dOff * dOff) / (2.0 * lineW2 * lineW2));
268    float line = line_in * 1.0 + line_out * 0.65;
269
270    // Glow exterior leve.
271    float glow = exp(-max(d, 0.0) * 14.0) * 0.30;
272
273    // === AROS EXTERIORES ===
274    float ringR_main = u_arm_extent * 1.45;
275    float ringD_main = abs(r - ringR_main);
276    float ring_main = exp(-(ringD_main * ringD_main) / (2.0 * 0.005 * 0.005));
277
278    float ringR_inner = u_arm_extent * 1.30;
279    float ringD_inner = abs(r - ringR_inner);
280    float ring_inner = exp(-(ringD_inner * ringD_inner) / (2.0 * 0.003 * 0.003)) * 0.40;
281
282    // 4 grupos de 3 puntos cardinales sobre el aro principal.
283    float dots = cardinal_dots(p, ringR_main, 0.008) * 1.10;
284
285    // === COMPOSICIÓN ===
286    vec3 col = vec3(0.0);
287    // Sol detrás (clip a interior).
288    col += u_sun_color * halo * inside * 1.55;
289    col += u_line_color * radial * inside * 0.6;
290    // Niebla oscura translúcida en el interior para profundidad.
291    col += u_dark_color * inside * 0.20;
292    // Líneas y aros.
293    col += u_line_color * line * 1.70;
294    col += u_line_color * glow * 0.95;
295    col += u_line_color * ring_main * 1.45;
296    col += u_rim_color  * ring_inner * 1.05;
297    col += u_line_color * dots * 1.85;
298
299    float alpha = clamp(
300        halo * inside + line + glow + ring_main + ring_inner + dots + inside * 0.12,
301        0.0, 1.0);
302    fragColor = vec4(col, alpha);
303}
304";
305
306/// Geometría del quad fullscreen: dos triángulos en clip-space.
307pub const FULLSCREEN_QUAD: [f32; 12] = [
308    -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0,
309];
310
311/// Quad ligeramente mayor que la chacana + aros + glow.
312pub fn chacana_quad(arm_extent: f32) -> [f32; 12] {
313    // Aro principal vive a 1.45 * arm_extent; sumamos margen para el glow.
314    let e = arm_extent * 1.70;
315    [-e, -e, e, -e, e, e, -e, -e, e, e, -e, e]
316}