ACMX Vulkan Shader Library
GLSL 4.50 shader effects for ACMX's Vulkan renderer
Loading...
Searching...
No Matches
frac_shader02_dmd_mandella.frag
Go to the documentation of this file.
1#version 450
2
3/**
4 * @file frac_shader02_dmd_mandella.frag
5 * @brief Vulkan fragment shader: frac shader02 dmd mandella.
6 */
7layout(set = 0, binding = 1, std140) uniform SpriteExtended {
8 vec4 mouse;
9 vec4 u0;
10 vec4 u1;
11 vec4 u2;
12 vec4 u3;
13 vec4 custom_uniforms[16];
14 vec4 audio_bands;
15 vec4 audio_history;
17#define amp ext.u1.y
18#define amp_high ext.audio_bands.z
19#define amp_low ext.audio_bands.x
20#define amp_mid ext.audio_bands.y
21#define amp_peak ext.u2.w
22#define amp_rms ext.u3.z
23#define amp_smooth ext.u3.w
24#define iMouse ext.mouse
25#define iResolution ext.u0.zw
26#define iamp ext.u1.z
27#define seed ext.custom_uniforms[2].z
28#define time_f ext.u2.y
29#define uamp ext.u1.y
30
31layout(location = 0) in vec2 tc;
32layout(location = 0) out vec4 color;
33layout(set = 0, binding = 0) uniform sampler2D samp;
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48const float PI = 3.1415926535897932384626433832795;
49
50/**
51 * @brief Evaluates pingPong for this shader effect.
52 * @param x Input value for the calculation.
53 * @param length Input value for the calculation.
54 * @return Computed float value.
55 */
56float pingPong(float x, float length) {
57 float m = mod(x, length * 2.0);
58 return m <= length ? m : length * 2.0 - m;
59}
60
61/**
62 * @brief Evaluates hsv2rgb for this shader effect.
63 * @param c Input value for the calculation.
64 * @return Computed vec3 value.
65 */
66vec3 hsv2rgb(vec3 c) {
67 vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
68 vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
69 return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
70}
71
72/**
73 * @brief Evaluates rotateUV for this shader effect.
74 * @param uv Input value for the calculation.
75 * @param angle Input value for the calculation.
76 * @param c Input value for the calculation.
77 * @param aspect Input value for the calculation.
78 * @return Computed vec2 value.
79 */
80vec2 rotateUV(vec2 uv, float angle, vec2 c, float aspect) {
81 float s = sin(angle), cc = cos(angle);
82 vec2 p = uv - c;
83 p.x *= aspect;
84 p = mat2(cc, -s, s, cc) * p;
85 p.x /= aspect;
86 return p + c;
87}
88
89/**
90 * @brief Evaluates reflectUV for this shader effect.
91 * @param uv Input value for the calculation.
92 * @param segments Input value for the calculation.
93 * @param c Input value for the calculation.
94 * @param aspect Input value for the calculation.
95 * @return Computed vec2 value.
96 */
97vec2 reflectUV(vec2 uv, float segments, vec2 c, float aspect) {
98 vec2 p = uv - c;
99 p.x *= aspect;
100 float ang = atan(p.y, p.x);
101 float rad = length(p);
102 float stepA = 6.28318530718 / segments;
103 ang = mod(ang, stepA);
104 ang = abs(ang - stepA * 0.5);
105 vec2 r = vec2(cos(ang), sin(ang)) * rad;
106 r.x /= aspect;
107 return r + c;
108}
109
110/**
111 * @brief Evaluates fractalFold for this shader effect.
112 * @param uv Input value for the calculation.
113 * @param zoom Input value for the calculation.
114 * @param t Input value for the calculation.
115 * @param c Input value for the calculation.
116 * @param aspect Input value for the calculation.
117 * @return Computed vec2 value.
118 */
119vec2 fractalFold(vec2 uv, float zoom, float t, vec2 c, float aspect) {
120 vec2 p = uv;
121 for (int i = 0; i < 6; i++) {
122 p = abs((p - c) * (zoom + 0.15 * sin(t * (0.35 + amp_low * 0.2) + float(i)))) - 0.5 + c;
123 p = rotateUV(p, t * 0.12 + float(i) * 0.07, c, aspect);
124 }
125 return p;
126}
127
128/**
129 * @brief Evaluates neonPalette for this shader effect.
130 * @param t Input value for the calculation.
131 * @return Computed vec3 value.
132 */
133vec3 neonPalette(float t) {
134 vec3 pink = vec3(1.0, 0.15, 0.75);
135 vec3 blue = vec3(0.10, 0.55, 1.0);
136 vec3 green = vec3(0.10, 1.00, 0.45);
137 float ph = fract(t * 0.08);
138 vec3 k1 = mix(pink, blue, smoothstep(0.00, 0.33, ph));
139 vec3 k2 = mix(blue, green, smoothstep(0.33, 0.66, ph));
140 vec3 k3 = mix(green, pink, smoothstep(0.66, 1.00, ph));
141 float a = step(ph, 0.33);
142 float b = step(0.33, ph) * step(ph, 0.66);
143 float c = step(0.66, ph);
144 return normalize(a * k1 + b * k2 + c * k3) * 1.05;
145}
146
147/**
148 * @brief Evaluates softTone for this shader effect.
149 * @param c Input value for the calculation.
150 * @return Computed vec3 value.
151 */
152vec3 softTone(vec3 c) {
153 c = pow(max(c, 0.0), vec3(0.95));
154 float l = dot(c, vec3(0.299, 0.587, 0.114));
155 c = mix(vec3(l), c, 0.9);
156 return clamp(c, 0.0, 1.0);
157}
158
159/**
160 * @brief Evaluates tentBlur3 for this shader effect.
161 * @param img Input value for the calculation.
162 * @param uv Input value for the calculation.
163 * @param res Input value for the calculation.
164 * @return Computed vec3 value.
165 */
166vec3 tentBlur3(sampler2D img, vec2 uv, vec2 res) {
167 vec2 ts = 1.0 / res;
168 vec3 s00 = textureGrad(img, uv + ts * vec2(-1.0, -1.0), dFdx(uv), dFdy(uv)).rgb;
169 vec3 s10 = textureGrad(img, uv + ts * vec2(0.0, -1.0), dFdx(uv), dFdy(uv)).rgb;
170 vec3 s20 = textureGrad(img, uv + ts * vec2(1.0, -1.0), dFdx(uv), dFdy(uv)).rgb;
171 vec3 s01 = textureGrad(img, uv + ts * vec2(-1.0, 0.0), dFdx(uv), dFdy(uv)).rgb;
172 vec3 s11 = textureGrad(img, uv, dFdx(uv), dFdy(uv)).rgb;
173 vec3 s21 = textureGrad(img, uv + ts * vec2(1.0, 0.0), dFdx(uv), dFdy(uv)).rgb;
174 vec3 s02 = textureGrad(img, uv + ts * vec2(-1.0, 1.0), dFdx(uv), dFdy(uv)).rgb;
175 vec3 s12 = textureGrad(img, uv + ts * vec2(0.0, 1.0), dFdx(uv), dFdy(uv)).rgb;
176 vec3 s22 = textureGrad(img, uv + ts * vec2(1.0, 1.0), dFdx(uv), dFdy(uv)).rgb;
177 return (s00 + 2.0 * s10 + s20 + 2.0 * s01 + 4.0 * s11 + 2.0 * s21 + s02 + 2.0 * s12 + s22) / 16.0;
178}
179
180/**
181 * @brief Evaluates preBlendColor for this shader effect.
182 * @param uv Input value for the calculation.
183 * @param tSlow Input value for the calculation.
184 * @param tFast Input value for the calculation.
185 * @param aspect Input value for the calculation.
186 * @return Computed vec3 value.
187 */
188vec3 preBlendColor(vec2 uv, float tSlow, float tFast, float aspect) {
189 vec3 tex = tentBlur3(samp, uv, iResolution);
190 vec2 gdir = normalize(vec2(cos(tSlow * 0.27), sin(tSlow * 0.31)));
191 float s = dot((uv - 0.5) * vec2(aspect, 1.0), gdir);
192 float w = max(fwidth(s) * 4.0, 0.002);
193 float band = smoothstep(-0.5 - w, -0.5 + w, sin(s * 2.2 + tFast * 0.9));
194 vec3 neon = neonPalette(tFast);
195 vec3 grad = mix(tex, mix(tex, neon, 0.6), 0.35 + 0.25 * band);
196 grad = mix(grad, tex, 0.10);
197 grad = softTone(grad);
198 return grad;
199}
200
201/**
202 * @brief Evaluates diamondRadius for this shader effect.
203 * @param p Input value for the calculation.
204 * @return Computed float value.
205 */
206float diamondRadius(vec2 p) {
207 p = sin(abs(p));
208 return max(p.x, p.y);
209}
210
211/**
212 * @brief Evaluates diamondFold for this shader effect.
213 * @param uv Input value for the calculation.
214 * @param c Input value for the calculation.
215 * @param aspect Input value for the calculation.
216 * @return Computed vec2 value.
217 */
218vec2 diamondFold(vec2 uv, vec2 c, float aspect) {
219 vec2 p = (uv - c) * vec2(aspect, 1.0);
220 p = abs(p);
221 if (p.y > p.x) p = p.yx;
222 p.x /= aspect;
223 return p + c;
224}
225
226/**
227 * @brief Evaluates rot2 for this shader effect.
228 * @param v Input value for the calculation.
229 * @param a Input value for the calculation.
230 * @return Computed vec2 value.
231 */
232vec2 rot2(vec2 v, float a) {
233 float c = cos(a), s = sin(a);
234 return vec2(c * v.x - s * v.y, s * v.x + c * v.y);
235}
236
237/**
238 * @brief Evaluates h2 for this shader effect.
239 * @param p Input value for the calculation.
240 * @return Computed vec2 value.
241 */
242vec2 h2(vec2 p) {
243 return fract(sin(vec2(dot(p, vec2(127.1, 311.7)),
244 dot(p, vec2(269.5, 183.3)))) * 43758.5453);
245}
246
247/**
248 * @brief Evaluates limitHighlights for this shader effect.
249 * @param c Input value for the calculation.
250 * @return Computed vec3 value.
251 */
252vec3 limitHighlights(vec3 c) {
253 float m = max(c.r, max(c.g, c.b));
254 if (m > 0.9) c *= 0.9 / m;
255 return c;
256}
257
258// Spiral / sector warp from the extra shader, amplitude–aware.
259/**
260 * @brief Evaluates spiralWarp for this shader effect.
261 * @param tcIn Input value for the calculation.
262 * @param tBase Input value for the calculation.
263 * @param a01 Input value for the calculation.
264 * @param[out] ringMirrorOut Output value produced by the calculation.
265 * @return Computed vec2 value.
266 */
267vec2 spiralWarp(vec2 tcIn, float tBase, float a01, out float ringMirrorOut) {
268 float loopDuration = 25.0;
269 float t = mod(tBase * (0.6 + 1.8 * a01), loopDuration);
270 vec2 aspect2 = vec2(iResolution.x / iResolution.y, 1.0);
271
272 vec2 nc = (tcIn * 2.0 - 1.0) * aspect2;
273 nc.x = abs(nc.x);
274 float d = length(nc);
275 float a = atan(nc.y, nc.x);
276
277 float spiralSpeed = 5.0 * (0.7 + 1.5 * a01);
278 float inward = (t / loopDuration) * (0.5 + 0.5 * a01);
279
280 a += (1.0 - smoothstep(0.0, 8.0, d)) * t * spiralSpeed;
281 d *= 1.0 - inward;
282
283 vec2 spiral = vec2(cos(a), sin(a)) * tan(d);
284 vec2 uv0 = (spiral / aspect2 + 1.0) * 0.5;
285
286 vec2 p = (uv0 * 2.0 - 1.0) * aspect2;
287 float r = length(p);
288 float ang = atan(p.y, p.x);
289
290 float N = mix(8.0, 16.0, a01);
291 float tau = 6.28318530718;
292 float sector = tau / N;
293 ang = mod(ang + 0.5 * sector, sector);
294 ang = abs(ang - 0.5 * sector);
295
296 float ringFreq = 6.0 + 4.0 * a01;
297 float ring = fract(r * ringFreq + 0.15 * sin(tBase * 0.5));
298 float ringMirror = abs(ring - 0.5) * 2.0;
299
300 float swirl = 0.25 * sin(tBase * 0.3) * (0.5 + 1.0 * a01);
301 ang += swirl * r;
302
303 float zoom = 0.85 + 0.1 * sin(tBase * 0.27) + 0.08 * a01;
304 vec2 m = vec2(cos(ang), sin(ang)) * (r * zoom * (0.85 + 0.15 * ringMirror));
305
306 vec2 uv = (m / aspect2 + 1.0) * 0.5;
307 ringMirrorOut = ringMirror;
308 return uv;
309}
310
311/**
312 * @brief Executes the fragment shader entry point.
313 */
314void main(void) {
315 float a = clamp(amp, 0.0, 1.0);
316 float ua = clamp(uamp, 0.0, 1.0);
317 float aMix = clamp(amp * 0.7 + uamp * 1.3, 0.0, 4.0);
318 float a01 = clamp(aMix / 2.5, 0.0, 1.0);
319
320 float aspect = iResolution.x / iResolution.y;
321 vec2 ar = vec2(aspect, 1.0);
322
323 float tBase = time_f;
324 float tSlow = tBase * mix(0.2, 0.9, a01);
325 float tFast = tBase * mix(0.7, 3.5, a01);
326
327 vec2 m = (iMouse.z > 0.5) ? (iMouse.xy / iResolution)
328 : fract(vec2(0.37 + 0.11 * sin(tSlow * 0.63 + seed),
329 0.42 + 0.13 * cos(tSlow * 0.57 + seed * 2.0)));
330
331 // Base coordinates from original screen
332 vec2 tc0 = tc;
333 vec2 center = vec2(0.5, 0.5);
334 float radius = length(tc0 - center);
335
336 // Ripple + twist (driven by amplitude)
337 float rippleSpeed = 5.0 * (1.0 + 2.0 * a01);
338 float rippleAmplitude = 0.03 * (0.5 + 1.5 * a01);
339 float rippleWavelength = 10.0;
340 float twistStrength = 1.0 + 4.0 * a01;
341
342 float ripple = sin(tc0.x * rippleWavelength + tFast * rippleSpeed) * rippleAmplitude;
343 ripple += sin(tc0.y * rippleWavelength + tFast * rippleSpeed) * rippleAmplitude;
344 vec2 rippleTC = tc0 + vec2(ripple, ripple);
345
346 float angleTwist = twistStrength * (radius - 1.0) + tSlow;
347 float cosA = cos(angleTwist);
348 float sinA = sin(angleTwist);
349 mat2 rotationMatrix = mat2(cosA, -sinA, sinA, cosA);
350 vec2 twistedTC = rotationMatrix * (tc0 - center) + center;
351
352 float mixRT = 0.5 + 0.35 * a01;
353 vec2 tcRT = mix(rippleTC, twistedTC, mixRT);
354
355 // Spiral warp on top of ripple+twist
356 float ringMirrorSpiral;
357 vec2 spiralTC = spiralWarp(tcRT, tBase, a01, ringMirrorSpiral);
358
359 vec4 baseTex = texture(samp, spiralTC);
360
361 // Glow radius based on spiral coordinates
362 vec2 uvForGlow = spiralTC * 2.0 - 1.0;
363 uvForGlow.x *= aspect;
364 float rGlow = pingPong(sin(length(uvForGlow) * tSlow), 5.0);
365 float radiusMax = sqrt(aspect * aspect + 1.0) + 0.5;
366 float glow = smoothstep(radiusMax, radiusMax - 0.25, rGlow);
367 glow *= (0.8 + 0.4 * ringMirrorSpiral);
368
369 // Use spiral output as main UV for chroma air + kaleido
370 vec2 uv = spiralTC;
371 float speedScale = 1.0 + 2.0 * a01 + 3.0 * ua;
372
373 float speedR = 5.0 * speedScale;
374 float speedG = 6.5 * speedScale;
375 float speedB = 4.0 * speedScale;
376 float ampR = 0.03 * (0.7 + 0.6 * a01);
377 float ampG = 0.025 * (0.7 + 0.6 * a01);
378 float ampB = 0.035 * (0.7 + 0.6 * a01);
379 float waveR = 10.0;
380 float waveG = 12.0;
381 float waveB = 8.0;
382
383 float rR = sin(uv.x * waveR + tFast * speedR) * ampR
384 + sin(uv.y * waveR * 0.8 + tFast * speedR * 1.2) * ampR;
385 float rG = sin(uv.x * waveG * 1.5 + tFast * speedG) * ampG
386 + sin(uv.y * waveG * 0.3 + tFast * speedG * 0.7) * ampG;
387 float rB = sin(uv.x * waveB * 0.5 + tFast * speedB) * ampB
388 + sin(uv.y * waveB * 1.7 + tFast * speedB * 1.3) * ampB;
389
390 vec2 tcR = uv + vec2(rR, rR);
391 vec2 tcG = uv + vec2(rG, -0.5 * rG);
392 vec2 tcB = uv + vec2(0.3 * rB, rB);
393
394 vec3 pats[4] = vec3[](vec3(1,0,1), vec3(0,1,0), vec3(1,0,0), vec3(0,0,1));
395 float pspd = 4.0;
396 int pidx = int(mod(floor(tBase * pspd + seed * 4.0), 4.0));
397 vec3 mir = pats[pidx];
398
399 vec2 dR = tcR - m;
400 vec2 dG = tcG - m;
401 vec2 dB = tcB - m;
402
403 float fallR = smoothstep(0.55, 0.0, length(dR));
404 float fallG = smoothstep(0.55, 0.0, length(dG));
405 float fallB = smoothstep(0.55, 0.0, length(dB));
406
407 float sw = (0.12 + 0.38 * ua + 0.25 * a);
408 vec2 tangR = rot2(normalize(dR + 1e-4), 1.5707963);
409 vec2 tangG = rot2(normalize(dG + 1e-4), 1.5707963);
410 vec2 tangB = rot2(normalize(dB + 1e-4), 1.5707963);
411
412 vec2 airR = tangR * sw * fallR * (0.06 + 0.22 * a) * (0.6 + 0.4 * cos(uv.y * 40.0 + tFast * 3.0 + seed));
413 vec2 airG = tangG * sw * fallG * (0.06 + 0.22 * a) * (0.6 + 0.4 * cos(uv.y * 38.0 + tFast * 3.3 + seed * 1.7));
414 vec2 airB = tangB * sw * fallB * (0.06 + 0.22 * a) * (0.6 + 0.4 * cos(uv.y * 42.0 + tFast * 2.9 + seed * 0.9));
415
416 vec2 jit = (h2(uv * vec2(233.3, 341.9) + tFast + seed) - 0.5)
417 * (0.0006 + 0.004 * ua);
418
419 tcR += airR + jit;
420 tcG += airG + jit;
421 tcB += airB + jit;
422
423 vec2 fR = vec2(mir.r > 0.5 ? 1.0 - tcR.x : tcR.x, tcR.y);
424 vec2 fG = vec2(mir.g > 0.5 ? 1.0 - tcG.x : tcG.x, tcG.y);
425 vec2 fB = vec2(mir.b > 0.5 ? 1.0 - tcB.x : tcB.x, tcB.y);
426
427 float seg = 4.0 + 2.0 * sin(tSlow * 0.33 + a01 * 2.0);
428 vec2 kUV = reflectUV(spiralTC, seg, m, aspect);
429 kUV = diamondFold(kUV, m, aspect);
430 float foldZoom = 1.45 + 0.55 * sin(tSlow * 0.42 + a01 * 3.0);
431 kUV = fractalFold(kUV, foldZoom, tFast, m, aspect);
432 kUV = rotateUV(kUV, tSlow * 0.23 + a01 * 1.1, m, aspect);
433 kUV = diamondFold(kUV, m, aspect);
434
435 vec2 p = (kUV - m) * ar;
436 vec2 q = abs(p);
437 if (q.y > q.x) q = q.yx;
438
439 float base = 1.82 + 0.18 * pingPong(sin(tSlow * 0.2) * (PI * tSlow), 5.0);
440 float period = log(base) * pingPong(tSlow * PI, 5.0);
441 float tz = tSlow * 0.65;
442 float rD = diamondRadius(p) + 1e-6;
443
444 float ang = atan(q.y, q.x) + tz * 0.35
445 + 0.35 * sin(rD * 18.0 + tFast * 0.6);
446 float k = fract((log(rD) - tz) / period);
447 float rw = exp(k * period);
448 vec2 pwrap = vec2(cos(ang), sin(ang)) * rw;
449
450 vec2 u0 = fract(pwrap / ar + m);
451 vec2 u1 = fract((pwrap * 1.045) / ar + m);
452 vec2 u2 = fract((pwrap * 0.955) / ar + m);
453
454 vec2 dirK = normalize(pwrap + 1e-6);
455 vec2 off = dirK * (0.0015 + 0.001 * sin(tFast * 1.3)) * vec2(1.0, 1.0 / aspect);
456
457 float vign = 1.0 - smoothstep(0.75, 1.2, length((spiralTC - m) * ar));
458 vign = mix(0.9, (1.15 + amp_smooth * 0.2), vign) * (0.8 + 0.3 * ringMirrorSpiral);
459
460 vec2 sR = mix(u0, fR, 0.6);
461 vec2 sG = mix(u1, fG, 0.6);
462 vec2 sB = mix(u2, fB, 0.6);
463
464 vec3 rC = preBlendColor(sR + off, tSlow, tFast, aspect);
465 vec3 gC = preBlendColor(sG, tSlow, tFast, aspect);
466 vec3 bC = preBlendColor(sB - off, tSlow, tFast, aspect);
467
468 vec3 kaleidoRGB = vec3(rC.r, gC.g, bC.b);
469
470 float ring = smoothstep(0.0, 0.7, sin(log(rD + 1e-3) * 9.5 + tFast * 1.2));
471 ring = ring * pingPong(tSlow * PI, 5.0) * (0.7 + 0.5 * ringMirrorSpiral);
472 float pulse = 0.5 + 0.5 * sin(tFast * 2.0 + rD * 28.0 + k * 12.0);
473 pulse *= mix(0.4, 1.4, a01);
474
475 vec3 outCol = kaleidoRGB;
476 outCol *= (0.75 + 0.25 * ring) * (0.85 + 0.15 * pulse) * vign;
477
478 vec3 bloom = outCol * outCol * 0.10
479 + pow(max(outCol - 0.6, 0.0), vec3(2.0)) * 0.06;
480
481 float pulseAdd = 0.004 * (0.5 + 0.5 * sin(tFast * 3.7 + seed));
482 outCol += bloom;
483 outCol += pulseAdd * ua;
484
485 outCol = clamp(outCol, vec3(0.0), vec3(1.0));
486 outCol = limitHighlights(outCol);
487
488 vec3 finalRGB = mix(baseTex.rgb, outCol, pingPong(glow * PI, 5.0) * (0.6 + 0.3 * a01));
489 finalRGB = limitHighlights(finalRGB);
490 finalRGB = clamp(finalRGB, 0.0, 1.0);
491
492
493 // --- Audio Reactivity: direct output modulation ---
494 float _ab = clamp(amp_peak, 0.0, 1.0);
495 float _abass = clamp(amp_low, 0.0, 1.0);
496 finalRGB *= 1.0 + _ab * 0.6;
497 finalRGB = mix(finalRGB, finalRGB * vec3(1.0 + _abass * 0.3, 1.0 - _abass * 0.15, 1.0 + clamp(amp_high, 0.0, 1.0) * 0.25), _ab);
498 // --- End Audio Reactivity ---
499
500 color = vec4(finalRGB, baseTex.a);
501}
layout(set=0, binding=1, std140) uniform SpriteExtended
Definition 3high.frag:7
#define iMouse
Definition 3high.frag:17
ext
Definition 3high.frag:16
void main(void)
Executes the fragment shader entry point.
Definition 3high.frag:47
#define iResolution
Definition 3high.frag:18
#define time_f
Definition 3high.frag:19
vec3 limitHighlights(vec3 c)
Evaluates limitHighlights for this shader effect.
#define uamp
Definition abc.frag:21
#define amp
Definition abc.frag:17
#define amp_smooth
#define amp_low
#define amp_high
#define amp_peak
vec3 ripple(ivec2 p, ivec2 size)
Evaluates ripple for this shader effect.
float pingPong(float x, float length)
Evaluates pingPong for this shader effect.
Definition af_scale.frag:32
vec2 h2(vec2 p)
Evaluates h2 for this shader effect.
Definition air-bowl.frag:45
#define seed
Definition air-bowl.frag:20
vec2 rot2(vec2 p, float a)
Evaluates rot2 for this shader effect.
vec2 fractalFold(vec2 p, float zoom, float t, int i)
Evaluates fractalFold for this shader effect.
vec2 mir(vec2 v)
Evaluates mir for this shader effect.
vec3 neon(float t)
Evaluates neon for this shader effect.
vec3 bloom(float t)
Evaluates bloom for this shader effect.
vec2 diamondFold(vec2 p)
Evaluates diamondFold for this shader effect.
vec2 swirl(vec2 uv, float centerRadius, float swirlAmount)
Evaluates swirl for this shader effect.
vec2 rotateUV(vec2 uv, float angle, vec2 c, float aspect)
Evaluates rotateUV for this shader effect.
Definition aura2.frag:59
vec3 tentBlur3(sampler2D img, vec2 uv, vec2 res)
Evaluates tentBlur3 for this shader effect.
Definition aura2.frag:145
vec3 neonPalette(float t)
Evaluates neonPalette for this shader effect.
Definition aura2.frag:112
vec2 reflectUV(vec2 uv, float segments, vec2 c, float aspect)
Evaluates reflectUV for this shader effect.
Definition aura2.frag:76
vec3 softTone(vec3 c)
Evaluates softTone for this shader effect.
Definition aura2.frag:131
float diamondRadius(vec2 p)
Evaluates diamondRadius for this shader effect.
Definition aura2.frag:182
vec3 preBlendColor(vec2 uv)
Evaluates preBlendColor for this shader effect.
Definition aura2.frag:164
vec3 hsv2rgb(vec3 c)
Evaluates hsv2rgb for this shader effect.
Definition aura.frag:43
float N(vec2 p)
Evaluates N for this shader effect.
#define PI
vec2 spiralWarp(vec2 tcIn, float tBase, float a01, out float ringMirrorOut)
Evaluates spiralWarp for this shader effect.