ACMX Vulkan Shader Library
GLSL 4.50 shader effects for ACMX's Vulkan renderer
Loading...
Searching...
No Matches
pilot_effect_ant_bloom.frag
Go to the documentation of this file.
1#version 450
2
3layout(set = 0, binding = 1, std140) uniform SpriteExtended {
4 vec4 mouse;
5 vec4 u0;
6 vec4 u1;
7 vec4 u2;
8 vec4 u3;
9 vec4 custom_uniforms[16];
10 vec4 audio_bands;
11 vec4 audio_history;
13#define amp ext.u1.y
14#define amp_high ext.audio_bands.z
15#define amp_low ext.audio_bands.x
16#define amp_mid ext.audio_bands.y
17#define amp_peak ext.u2.w
18#define amp_rms ext.u3.z
19#define amp_smooth ext.u3.w
20#define iResolution ext.u0.zw
21#define iamp ext.u1.z
22#define time_f ext.u2.y
23
24/**
25 * @file pilot_effect_ant_bloom.frag
26 * @brief Vulkan fragment shader: pilot effect ant bloom.
27 */
28// pilot_effect_ant_bloom.glsl
29// Diversified pilot shader: frac/mirror/gem/ant + library-inspired prism/ripple/glitch/VHS/grid behaviors.
30// Inspired motif source: 3high.glsl
31// Random donor shader: material_strange.glsl
32layout(location = 0) in vec2 tc;
33layout(location = 0) out vec4 color;
34layout(set = 0, binding = 0) uniform sampler2D samp;
35layout(set = 0, binding = 3) uniform sampler1D spectrum;
36
37
38
39
40
41
42
43
44
45
46
47const float PI = 3.14159265359;
48const float TAU = 6.28318530718;
49const int FAMILY = 6;
50const float SEED_A = 0.8300;
51const float SEED_B = 1.4900;
52const float SEED_C = 2.1700;
53const vec3 BASE_TINT = vec3(0.7660, 0.9050, 0.7705);
54const float INSP_1 = 0.4692;
55const float INSP_2 = 0.7732;
56const float INSP_3 = 0.9257;
57const float INSP_MODE = 0.0000;
58const int CAT_ID = 0;
59const int VAR_ID = 0;
60const float CAT_SPIN = 0.0909;
61const float CAT_WARP = 0.0909;
62const float CAT_SAT = 0.3500;
63const float VAR_PULSE = 0.2000;
64const float VAR_GRID = 0.6862;
65const float VAR_STYLE = 0.8759;
66const float DONOR_A = 0.1307;
67const float DONOR_B = 0.3252;
68const float DONOR_C = 0.3062;
69const float DONOR_D = 0.5167;
70const float DONOR_MODE = 0.9333;
71
72/**
73 * @brief Evaluates hash11 for this shader effect.
74 * @param p Input value for the calculation.
75 * @return Computed float value.
76 */
77float hash11(float p) {
78 p = fract(p * 0.1031);
79 p *= p + 33.33;
80 p *= p + p;
81 return fract(p);
82}
83
84/**
85 * @brief Evaluates hash21 for this shader effect.
86 * @param p Input value for the calculation.
87 * @return Computed float value.
88 */
89float hash21(vec2 p) {
90 vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.11369, 0.13787));
91 p3 += dot(p3, p3.yzx + 19.19);
92 return fract((p3.x + p3.y) * p3.z);
93}
94
95/**
96 * @brief Evaluates rot for this shader effect.
97 * @param a Input value for the calculation.
98 * @return Computed mat2 value.
99 */
100mat2 rot(float a) {
101 float c = cos(a), s = sin(a);
102 return mat2(c, -s, s, c);
103}
104
105/**
106 * @brief Evaluates mirrorTile for this shader effect.
107 * @param uv Input value for the calculation.
108 * @return Computed vec2 value.
109 */
110vec2 mirrorTile(vec2 uv) {
111 // Mirror with 2.0-period so folds occur at integer boundaries, not at 0.5.
112 vec2 m = mod(uv, 2.0);
113 vec2 tri = 1.0 - abs(m - 1.0);
114 vec2 px = 1.0 / max(iResolution, vec2(1.0));
115 return clamp(tri, px * 1.5, 1.0 - px * 1.5);
116}
117
118/**
119 * @brief Evaluates kaleido for this shader effect.
120 * @param p Input value for the calculation.
121 * @param seg Input value for the calculation.
122 * @return Computed vec2 value.
123 */
124vec2 kaleido(vec2 p, float seg) {
125 seg = max(seg, 2.0);
126 float a = atan(p.y, p.x);
127 float r = length(p);
128 float k = TAU / seg;
129 a = mod(a, k);
130 a = abs(a - 0.5 * k);
131 return vec2(cos(a), sin(a)) * r;
132}
133
134/**
135 * @brief Evaluates palette for this shader effect.
136 * @param t Input value for the calculation.
137 * @return Computed vec3 value.
138 */
139vec3 palette(float t) {
140 vec3 a = vec3(0.5);
141 vec3 b = vec3(0.5);
142 vec3 c = vec3(1.0);
143 vec3 d = vec3(SEED_A, SEED_B, SEED_C);
144 return a + b * cos(TAU * (c * t + d));
145}
146
147/**
148 * @brief Evaluates safeSpec for this shader effect.
149 * @param x Input value for the calculation.
150 * @param fallback Input value for the calculation.
151 * @param reactive Input value for the calculation.
152 * @return Computed float value.
153 */
154float safeSpec(float x, float fallback, float reactive) {
155 if (reactive < 0.5) return fallback;
156 return texture(spectrum, clamp(x, 0.0, 1.0)).r;
157}
158
159/**
160 * @brief Evaluates chromaSplit for this shader effect.
161 * @param uv Input value for the calculation.
162 * @param dir Input value for the calculation.
163 * @param amt Input value for the calculation.
164 * @return Computed vec3 value.
165 */
166vec3 chromaSplit(vec2 uv, vec2 dir, float amt) {
167 vec2 o = dir * amt;
168 vec2 u0 = mirrorTile(uv + o);
169 vec2 u1 = mirrorTile(uv);
170 vec2 u2 = mirrorTile(uv - o);
171 float r = texture(samp, u0).r;
172 float g = texture(samp, u1).g;
173 float b = texture(samp, u2).b;
174 return vec3(r, g, b);
175}
176
177/**
178 * @brief Executes the fragment shader entry point.
179 */
180void main(void) {
181 float sense = clamp(amp_peak + amp_rms + amp_smooth + amp_low + amp_mid + amp_high + abs(iamp) * 0.001, 0.0, 1.0);
182 float reactive = step(0.002, sense);
183
184 float a = mix(0.15, clamp(amp, 0.0, 1.0), reactive);
185 float aPk = mix(0.12, clamp(amp_peak, 0.0, 1.0), reactive);
186 float aRms = mix(0.14, clamp(amp_rms, 0.0, 1.0), reactive);
187 float aSm = mix(0.18, clamp(amp_smooth, 0.0, 1.0), reactive);
188 float aLo = mix(0.16, clamp(amp_low, 0.0, 1.0), reactive);
189 float aMi = mix(0.14, clamp(amp_mid, 0.0, 1.0), reactive);
190 float aHi = mix(0.12, clamp(amp_high, 0.0, 1.0), reactive);
191
192 float sBass = safeSpec(0.04, 0.17 + 0.09 * sin(time_f * 0.7 + SEED_A), reactive);
193 float sLo = safeSpec(0.13, 0.15 + 0.10 * sin(time_f * 0.9 + SEED_B), reactive);
194 float sMi = safeSpec(0.30, 0.14 + 0.10 * sin(time_f * 1.1 + SEED_C), reactive);
195 float sHi = safeSpec(0.62, 0.13 + 0.09 * sin(time_f * 1.3 + SEED_B), reactive);
196 float sAir = safeSpec(0.86, 0.11 + 0.08 * sin(time_f * 1.5 + SEED_A), reactive);
197
198 float aspect = iResolution.x / max(iResolution.y, 1.0);
199 vec2 uv = tc;
200 vec2 p = (tc - 0.5) * vec2(aspect, 1.0);
201 float r = max(length(p), 1e-4);
202 float ang = atan(p.y, p.x);
203 float t = time_f;
204 float t2 = t * (0.85 + 0.45 * INSP_1) + TAU * INSP_2;
205
206 // Category profile warp: gives each theme a distinct spatial signature.
207 vec2 pWarp = p;
208 pWarp = rot((0.18 + 0.55 * CAT_SPIN) * t2 + CAT_WARP * TAU * 0.15) * pWarp;
209 pWarp += vec2(
210 sin((p.y + CAT_WARP) * (3.0 + 7.0 * VAR_PULSE) + t2 * (0.5 + CAT_SPIN)),
211 cos((p.x - CAT_WARP) * (3.5 + 8.0 * VAR_GRID) - t2 * (0.45 + CAT_SPIN))
212 ) * (0.01 + 0.03 * CAT_WARP);
213 p = mix(p, pWarp, 0.30 + 0.45 * INSP_3);
214 r = max(length(p), 1e-4);
215 ang = atan(p.y, p.x);
216
217 vec2 uvFx = uv;
218 vec3 fxCol = texture(samp, uv).rgb;
219 float fxGlow = 0.0;
220
221 if (FAMILY == 0) {
222 // Fractal mirror pulse tunnel
223 vec2 q = p;
224 q = kaleido(q, 5.0 + 8.0 * sMi + 3.0 * aMi);
225 for (int i = 0; i < 5; i++) {
226 float fi = float(i);
227 q = rot(t * (0.2 + 0.07 * fi) + fi + sHi * 2.0) * q;
228 q = abs(q * (1.35 + 0.1 * fi + 0.45 * sLo)) - (0.55 + 0.08 * sin(t2 + fi));
229 }
230 uvFx = mirrorTile(0.5 + q / vec2(aspect, 1.0));
231 fxCol = chromaSplit(uvFx, normalize(q + 1e-4), 0.003 + 0.02 * sHi + 0.01 * aPk);
232 fxGlow = exp(-1.8 * length(q)) * (0.25 + 0.8 * sBass);
233 } else if (FAMILY == 1) {
234 // Prism glass split
235 vec2 q = p;
236 q = rot(0.4 * t + sMi) * q;
237 float tri = max(abs(q.x), abs(q.y * 1.2 + q.x * 0.35));
238 vec2 dir = normalize(q + vec2(0.001));
239 float disp = 0.008 + 0.05 * sHi + 0.02 * aPk;
240 uvFx = mirrorTile(uv + dir * (tri * 0.06 + 0.03 * aMi));
241 fxCol = chromaSplit(uvFx, dir, disp);
242 fxCol += palette(tri * 2.3 + t * 0.2 + sAir) * (0.08 + 0.2 * (1.0 - smoothstep(0.15, 0.8, tri)));
243 fxGlow = (0.1 + 0.5 * aSm) * exp(-2.5 * tri);
244 } else if (FAMILY == 2) {
245 // Ripple amp fluid
246 vec2 q = p;
247 float w1 = sin(r * (26.0 + 20.0 * sBass) - t * (4.0 + 3.0 * aLo));
248 float w2 = cos((q.x + q.y) * (16.0 + 10.0 * sMi) + t * (3.0 + 2.0 * aHi));
249 vec2 off = vec2(w1, w2) * (0.015 + 0.03 * aMi + 0.02 * sLo);
250 uvFx = mirrorTile(uv + off);
251 fxCol = texture(samp, uvFx).rgb;
252 fxCol = mix(fxCol, fxCol.brg, 0.2 + 0.45 * sHi);
253 fxGlow = 0.15 + 0.35 * smoothstep(0.0, 1.0, 0.5 + 0.5 * w1);
254 } else if (FAMILY == 3) {
255 // VHS + glitch damage
256 vec2 q = uv;
257 float line = floor(q.y * iResolution.y * 0.35);
258 float n = hash21(vec2(line, floor(t * 18.0 + SEED_A)));
259 q.x += (n - 0.5) * (0.02 + 0.07 * aPk);
260 q.y += sin(t2 * 2.0 + q.x * 25.0) * (0.004 + 0.02 * aLo);
261 vec3 split = chromaSplit(mirrorTile(q), vec2(1.0, 0.0), 0.002 + 0.01 * sHi);
262 float scan = 0.95 - 0.16 * sin(uv.y * iResolution.y * 1.35);
263 float drop = step(0.992, hash21(vec2(floor(uv.y * 180.0), floor(t * 0.8 + SEED_B))));
264 fxCol = split * scan + drop * vec3(0.2, 0.07, 0.05);
265 fxGlow = 0.07 + 0.18 * aRms;
266 } else if (FAMILY == 4) {
267 // Grid neon / moire
268 vec2 q = p * (2.0 + 2.5 * sMi);
269 q = rot(0.25 * t + 0.8 * aSm) * q;
270 vec2 g = abs(fract(q) - 0.5);
271 float grid = smoothstep(0.08, 0.0, min(g.x, g.y));
272 float moire = 0.5 + 0.5 * sin((q.x * q.y) * (6.0 + 4.0 * sAir) + t * 2.5);
273 uvFx = mirrorTile(uv + vec2(moire, grid) * (0.01 + 0.03 * aMi));
274 fxCol = texture(samp, uvFx).rgb;
275 fxCol += palette(moire + t * 0.12) * grid * (0.25 + 0.4 * aPk);
276 fxGlow = grid * (0.2 + 0.4 * sHi);
277 } else if (FAMILY == 5) {
278 // Diamond shatter facets
279 vec2 q = p;
280 q = abs(q);
281 if (q.y > q.x) q = q.yx;
282 float facet = q.x + q.y * 0.35;
283 float crack = sin(facet * (30.0 + 20.0 * sHi) - t * (4.0 + 3.0 * aPk));
284 vec2 dir = normalize(vec2(q.x + 1e-3, q.y + 1e-3));
285 uvFx = mirrorTile(uv + dir * crack * (0.015 + 0.02 * aMi));
286 fxCol = chromaSplit(uvFx, dir, 0.002 + 0.02 * sHi);
287 fxCol = mix(fxCol, palette(facet * 1.6 + t * 0.15), 0.22 + 0.35 * aSm);
288 fxGlow = (0.12 + 0.35 * sBass) * smoothstep(0.8, 0.1, facet);
289 } else if (FAMILY == 6) {
290 // Bubble fisheye lens
291 vec2 q = p;
292 float lens = 1.0 / (1.0 + (1.7 + 2.0 * sBass) * dot(q, q));
293 q *= (1.2 - 0.7 * lens);
294 q += 0.08 * vec2(sin(t * 1.4 + q.y * 8.0), cos(t * 1.2 + q.x * 8.0)) * (0.4 + aLo);
295 uvFx = mirrorTile(0.5 + q / vec2(aspect, 1.0));
296 fxCol = texture(samp, uvFx).rgb;
297 fxCol += palette(lens + t * 0.1 + sAir) * (0.1 + 0.3 * lens * aSm);
298 fxGlow = lens * (0.2 + 0.5 * aPk);
299 } else if (FAMILY == 7) {
300 // Vortex / log-polar tunnel
301 float lp = log(r + 1e-3);
302 float spin = ang + t * (0.8 + 1.8 * aSm) + sin(lp * 5.0 + t) * (0.4 + sMi);
303 float rr = fract(lp * (1.1 + 0.8 * sBass) - t * (0.2 + 0.6 * aLo));
304 vec2 q = vec2(cos(spin), sin(spin)) * rr;
305 uvFx = mirrorTile(0.5 + q * vec2(0.8, 1.0));
306 fxCol = chromaSplit(uvFx, normalize(q + 1e-4), 0.002 + 0.015 * sHi);
307 fxGlow = (0.1 + 0.5 * sBass) * smoothstep(1.0, 0.0, rr);
308 } else if (FAMILY == 8) {
309 // Mosaic + pseudo pixel-sort drift
310 float px = 90.0 + 280.0 * (0.2 + aLo);
311 vec2 cell = floor(uv * px) / px;
312 float drift = hash21(vec2(cell.y * 300.0, floor(t * (6.0 + 10.0 * aPk)))) - 0.5;
313 cell.x += drift * (0.02 + 0.06 * aMi);
314 vec3 c0 = texture(samp, mirrorTile(cell)).rgb;
315 vec3 c1 = texture(samp, mirrorTile(cell + vec2(0.002 + 0.01 * sHi, 0.0))).rgb;
316 float gate = smoothstep(0.35, 0.75, c0.g + sMi * 0.35);
317 fxCol = mix(c0, c1.bgr, gate);
318 fxGlow = gate * (0.08 + 0.28 * aRms);
319 } else if (FAMILY == 9) {
320 // Plasma xor / synth math blend
321 vec2 q = p * (2.2 + 1.8 * sLo);
322 float a1 = sin(q.x * 7.0 + t * 1.7 + sBass * 5.0);
323 float a2 = cos(q.y * 8.0 - t * 1.3 + sMi * 4.0);
324 float a3 = sin((q.x + q.y) * 6.0 + t * 2.1);
325 float m = 0.5 + 0.5 * sin((a1 + a2 + a3) * (2.0 + aHi * 3.0));
326 uvFx = mirrorTile(uv + vec2(a1, a2) * (0.01 + 0.03 * aMi));
327 fxCol = mix(texture(samp, uvFx).rgb, palette(m + t * 0.07), 0.35 + 0.35 * aSm);
328 fxGlow = 0.1 + 0.4 * m * aPk;
329 } else if (FAMILY == 10) {
330 // Echo trails (multi-tap)
331 vec2 q = p;
332 vec2 dir = normalize(vec2(cos(ang + t), sin(ang - t)) + 1e-4);
333 vec3 acc = vec3(0.0);
334 float wsum = 0.0;
335 for (int i = 0; i < 5; i++) {
336 float fi = float(i);
337 float w = 1.0 / (1.0 + fi * 0.9);
338 vec2 u = mirrorTile(uv + dir * (0.006 + 0.02 * aSm) * fi + vec2(0.0, sin(t2 + fi) * 0.002));
339 acc += texture(samp, u).rgb * w;
340 wsum += w;
341 }
342 fxCol = acc / max(wsum, 1e-4);
343 fxCol = mix(fxCol, palette(r * 1.8 + t * 0.1), 0.18 + 0.32 * sAir);
344 fxGlow = 0.1 + 0.25 * aRms;
345 } else {
346 // Ant web / gem spoke hybrid
347 vec2 q = p;
348 float spokeCount = max(1.0, floor(10.0 + 8.0 * sHi + 0.5));
349 float spoke = sin(ang * spokeCount + t * (2.0 + 2.5 * aHi));
350 float web = sin((q.x + q.y) * (24.0 + 16.0 * sLo) - t * (3.0 + 2.0 * aLo));
351 float fold = sin((abs(q.x) - abs(q.y)) * (15.0 + 12.0 * sMi) + t * 1.8);
352 vec2 off = vec2(spoke + fold, web - fold) * (0.01 + 0.03 * aMi);
353 uvFx = mirrorTile(uv + off);
354 fxCol = texture(samp, uvFx).rgb;
355 fxCol += palette(spoke * 0.5 + web * 0.35 + t * 0.1) * (0.12 + 0.35 * aPk);
356 fxGlow = 0.1 + 0.4 * smoothstep(0.2, 1.0, abs(spoke * web));
357 }
358
359 vec3 col = fxCol * BASE_TINT;
360 vec3 accent = palette(r * 1.7 + (0.5 + 0.5 * sin(ang)) * 0.3 + t * 0.08 + sAir);
361 col = mix(col, col.brg, 0.15 + 0.35 * sHi);
362 col += accent * (0.05 + 0.18 * aSm + 0.2 * fxGlow);
363
364 // Per-shader inspiration blend adds variation while staying seam-safe.
365 vec2 inspOff = vec2(
366 sin((uv.y + INSP_1) * (8.0 + 12.0 * INSP_2) + t2 * (0.6 + INSP_3)),
367 cos((uv.x + INSP_2) * (7.0 + 11.0 * INSP_1) - t2 * (0.5 + INSP_2))
368 ) * (0.004 + 0.02 * aSm + 0.01 * sHi);
369 vec3 inspTex = texture(samp, mirrorTile(uv + inspOff)).rgb;
370 float inspMix = 0.12 + 0.32 * INSP_3 + 0.18 * aRms;
371 if (INSP_MODE < 0.33) {
372 col = mix(col, inspTex.bgr, inspMix);
373 } else if (INSP_MODE < 0.66) {
374 vec3 inspWarp = mix(inspTex.gbr, inspTex.rgb, 0.5 + 0.5 * sin(t2 + INSP_2 * TAU));
375 col = mix(col, inspWarp, inspMix * (0.8 + 0.2 * sAir));
376 } else {
377 col += (inspTex - vec3(0.5)) * (0.18 + 0.35 * inspMix);
378 }
379
380 int ringCount = 2 + int(mod(float(VAR_ID + CAT_ID), 7.0));
381 float angWave = 0.5 + 0.5 * sin(float(ringCount) * ang + t2 * (0.25 + 0.9 * CAT_SPIN));
382 vec3 catTone = palette(CAT_WARP + angWave * (0.25 + 0.45 * VAR_PULSE) + t2 * (0.04 + 0.08 * CAT_SAT));
383 col = mix(col, catTone, 0.10 + 0.30 * CAT_SAT * (0.35 + 0.65 * fxGlow));
384
385 if (VAR_STYLE < 0.33) {
386 col = mix(col, col.gbr, 0.08 + 0.22 * VAR_GRID);
387 } else if (VAR_STYLE < 0.66) {
388 float stripe = 0.5 + 0.5 * sin((p.x - p.y) * (8.0 + 22.0 * VAR_GRID) + t2);
389 col *= 0.88 + 0.22 * stripe;
390 } else {
391 float halo = exp(-(2.0 + 3.0 * VAR_PULSE) * r);
392 col += catTone * (0.06 + 0.24 * halo);
393 }
394
395 // Random donor fusion: this pilot blends with one random external shader signature.
396 vec2 donorUV = uv + vec2(
397 sin((uv.y + DONOR_A) * (5.0 + 18.0 * DONOR_B) + t2 * (0.7 + DONOR_C)),
398 cos((uv.x + DONOR_C) * (6.0 + 16.0 * DONOR_D) - t2 * (0.6 + DONOR_A))
399 ) * (0.004 + 0.022 * aSm + 0.015 * aPk);
400 donorUV = mirrorTile(donorUV);
401 vec3 donorCol = texture(samp, donorUV).rgb;
402 float donorMask = 0.5 + 0.5 * sin((p.x + p.y) * (8.0 + 20.0 * DONOR_B) + t2 * (0.8 + DONOR_D));
403 if (DONOR_MODE < 0.25) {
404 col = mix(col, donorCol, (0.08 + 0.30 * DONOR_A) * donorMask);
405 } else if (DONOR_MODE < 0.50) {
406 col += (donorCol - vec3(0.5)) * (0.10 + 0.28 * DONOR_C) * (0.7 + 0.3 * donorMask);
407 } else if (DONOR_MODE < 0.75) {
408 vec3 donorShift = vec3(donorCol.r, donorCol.b, donorCol.g);
409 col = mix(col, donorShift, (0.10 + 0.24 * DONOR_D) * (0.6 + 0.4 * donorMask));
410 } else {
411 float donorHalo = exp(-(2.0 + 4.0 * DONOR_A) * r);
412 col = mix(col, col * donorCol * 1.8, (0.10 + 0.20 * DONOR_B) * (0.5 + 0.5 * donorHalo));
413 }
414
415 float vign = 1.0 - smoothstep(0.55, 1.25, length(p));
416 col *= mix(0.72, 1.18, vign);
417
418 col *= 1.0 + 0.35 * aPk + 0.25 * sBass;
419 col = pow(max(col, 0.0), vec3(0.96 - 0.2 * aSm));
420 col = clamp(col, 0.0, 1.0);
421
422 color = vec4(col, 1.0);
423}
layout(set=0, binding=1, std140) uniform SpriteExtended
Definition 3high.frag:7
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
float tri(float x)
Evaluates tri for this shader effect.
#define amp
Definition abc.frag:17
#define amp_smooth
#define amp_mid
vec3 palette(float phase)
Evaluates palette for this shader effect.
#define amp_low
#define amp_high
#define amp_peak
float hash11(float value)
Evaluates hash11 for this shader effect.
vec2 rot(vec2 v, float a)
Evaluates rot for this shader effect.
Definition air-bowl.frag:52
vec2 kaleido(vec2 p, float seg)
Evaluates kaleido for this shader effect.
#define amp_rms
Definition breathe.frag:21
#define iamp
Definition breathe.frag:24
float hash21(vec2 p)
Evaluates hash21 for this shader effect.
vec2 mirrorTile(vec2 uv)
Evaluates mirrorTile for this shader effect.
float n(vec2 p)
Evaluates n for this shader effect.
vec2 lens(vec2 p, float z)
Evaluates lens for this shader effect.
vec2 cell(vec2 p)
Evaluates cell for this shader effect.
#define TAU
#define PI
vec2 fold(vec2 uv, float zoom, float t, vec2 c, float aspect)
Evaluates fold for this shader effect.
vec3 spectrum(float t)
Evaluates spectrum for this shader effect.
const float SEED_A
const float CAT_SAT
const float SEED_C
const int VAR_ID
const float VAR_PULSE
const float VAR_STYLE
const float CAT_WARP
const float DONOR_A
vec3 chromaSplit(vec2 uv, vec2 dir, float amt)
Evaluates chromaSplit for this shader effect.
const float INSP_3
const float VAR_GRID
const float INSP_1
const float INSP_2
const float CAT_SPIN
float safeSpec(float x, float fallback, float reactive)
Evaluates safeSpec for this shader effect.
const float INSP_MODE
const int FAMILY
const int CAT_ID
const float SEED_B
const float DONOR_B
const float DONOR_MODE
const vec3 BASE_TINT
const float DONOR_D
const float DONOR_C
vec2 spin(vec2 p, float a)
Evaluates spin for this shader effect.