1 | /* |
---|
2 | * cacademo various demo effects for libcaca |
---|
3 | * Copyright (c) 1998 Michele Bini <mibin@tin.it> |
---|
4 | * 2003-2006 Jean-Yves Lamoureux <jylam@lnxscene.org> |
---|
5 | * 2004-2006 Sam Hocevar <sam@zoy.org> |
---|
6 | * All Rights Reserved |
---|
7 | * |
---|
8 | * $Id: cacademo.c 1462 2006-12-12 01:53:54Z sam $ |
---|
9 | * |
---|
10 | * This program is free software. It comes without any warranty, to |
---|
11 | * the extent permitted by applicable law. You can redistribute it |
---|
12 | * and/or modify it under the terms of the Do What The Fuck You Want |
---|
13 | * To Public License, Version 2, as published by Sam Hocevar. See |
---|
14 | * http://sam.zoy.org/wtfpl/COPYING for more details. |
---|
15 | */ |
---|
16 | |
---|
17 | #include "config.h" |
---|
18 | #include "common.h" |
---|
19 | |
---|
20 | #if !defined(__KERNEL__) |
---|
21 | # include <stdio.h> |
---|
22 | # include <stdlib.h> |
---|
23 | # include <string.h> |
---|
24 | # include <math.h> |
---|
25 | # ifndef M_PI |
---|
26 | # define M_PI 3.14159265358979323846 |
---|
27 | # endif |
---|
28 | #endif |
---|
29 | |
---|
30 | #include "cucul.h" |
---|
31 | #include "caca.h" |
---|
32 | |
---|
33 | enum action { PREPARE, INIT, UPDATE, RENDER, FREE }; |
---|
34 | |
---|
35 | void transition(cucul_canvas_t *, int, int); |
---|
36 | void plasma(enum action, cucul_canvas_t *); |
---|
37 | void metaballs(enum action, cucul_canvas_t *); |
---|
38 | void moire(enum action, cucul_canvas_t *); |
---|
39 | void langton(enum action, cucul_canvas_t *); |
---|
40 | void matrix(enum action, cucul_canvas_t *); |
---|
41 | |
---|
42 | void (*fn[])(enum action, cucul_canvas_t *) = |
---|
43 | { |
---|
44 | plasma, |
---|
45 | metaballs, |
---|
46 | moire, |
---|
47 | //langton, |
---|
48 | matrix, |
---|
49 | }; |
---|
50 | #define DEMOS (sizeof(fn)/sizeof(*fn)) |
---|
51 | |
---|
52 | #define DEMO_FRAMES cucul_rand(500, 1000) |
---|
53 | #define TRANSITION_FRAMES 40 |
---|
54 | |
---|
55 | #define TRANSITION_COUNT 2 |
---|
56 | #define TRANSITION_CIRCLE 0 |
---|
57 | #define TRANSITION_STAR 1 |
---|
58 | |
---|
59 | |
---|
60 | /* Common macros for dither-based demos */ |
---|
61 | #define XSIZ 256 |
---|
62 | #define YSIZ 256 |
---|
63 | |
---|
64 | /* Global variables */ |
---|
65 | static int frame = 0; |
---|
66 | |
---|
67 | int main(int argc, char **argv) |
---|
68 | { |
---|
69 | static caca_display_t *dp; |
---|
70 | static cucul_canvas_t *frontcv, *backcv, *mask; |
---|
71 | |
---|
72 | int demo, next = -1, pause = 0, next_transition = DEMO_FRAMES; |
---|
73 | unsigned int i; |
---|
74 | int tmode = cucul_rand(0, TRANSITION_COUNT); |
---|
75 | |
---|
76 | /* Set up two canvases, a mask, and attach a display to the front one */ |
---|
77 | frontcv = cucul_create_canvas(0, 0); |
---|
78 | backcv = cucul_create_canvas(0, 0); |
---|
79 | mask = cucul_create_canvas(0, 0); |
---|
80 | |
---|
81 | dp = caca_create_display(frontcv); |
---|
82 | if(!dp) |
---|
83 | return 1; |
---|
84 | |
---|
85 | cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv), |
---|
86 | cucul_get_canvas_height(frontcv)); |
---|
87 | cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv), |
---|
88 | cucul_get_canvas_height(frontcv)); |
---|
89 | |
---|
90 | caca_set_display_time(dp, 20000); |
---|
91 | |
---|
92 | /* Initialise all demos' lookup tables */ |
---|
93 | for(i = 0; i < DEMOS; i++) |
---|
94 | fn[i](PREPARE, frontcv); |
---|
95 | |
---|
96 | /* Choose a demo at random */ |
---|
97 | demo = cucul_rand(0, DEMOS); |
---|
98 | fn[demo](INIT, frontcv); |
---|
99 | |
---|
100 | for(;;) |
---|
101 | { |
---|
102 | /* Handle events */ |
---|
103 | caca_event_t ev; |
---|
104 | while(caca_get_event(dp, CACA_EVENT_KEY_PRESS |
---|
105 | | CACA_EVENT_QUIT, &ev, 0)) |
---|
106 | { |
---|
107 | if(ev.type == CACA_EVENT_QUIT) |
---|
108 | goto end; |
---|
109 | |
---|
110 | switch(ev.data.key.ch) |
---|
111 | { |
---|
112 | case CACA_KEY_ESCAPE: |
---|
113 | case CACA_KEY_CTRL_C: |
---|
114 | case CACA_KEY_CTRL_Z: |
---|
115 | goto end; |
---|
116 | case ' ': |
---|
117 | pause = !pause; |
---|
118 | break; |
---|
119 | case '\r': |
---|
120 | if(next == -1) |
---|
121 | next_transition = frame; |
---|
122 | break; |
---|
123 | } |
---|
124 | } |
---|
125 | |
---|
126 | /* Resize the spare canvas, just in case the main one changed */ |
---|
127 | cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv), |
---|
128 | cucul_get_canvas_height(frontcv)); |
---|
129 | cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv), |
---|
130 | cucul_get_canvas_height(frontcv)); |
---|
131 | |
---|
132 | if(pause) |
---|
133 | goto paused; |
---|
134 | |
---|
135 | /* Update demo's data */ |
---|
136 | fn[demo](UPDATE, frontcv); |
---|
137 | |
---|
138 | /* Handle transitions */ |
---|
139 | if(frame == next_transition) |
---|
140 | { |
---|
141 | next = cucul_rand(0, DEMOS); |
---|
142 | if(next == demo) |
---|
143 | next = (next + 1) % DEMOS; |
---|
144 | fn[next](INIT, backcv); |
---|
145 | } |
---|
146 | else if(frame == next_transition + TRANSITION_FRAMES) |
---|
147 | { |
---|
148 | fn[demo](FREE, frontcv); |
---|
149 | demo = next; |
---|
150 | next = -1; |
---|
151 | next_transition = frame + DEMO_FRAMES; |
---|
152 | tmode = cucul_rand(0, TRANSITION_COUNT); |
---|
153 | } |
---|
154 | |
---|
155 | if(next != -1) |
---|
156 | fn[next](UPDATE, backcv); |
---|
157 | |
---|
158 | frame++; |
---|
159 | paused: |
---|
160 | /* Render main demo's canvas */ |
---|
161 | fn[demo](RENDER, frontcv); |
---|
162 | |
---|
163 | /* If a transition is on its way, render it */ |
---|
164 | if(next != -1) |
---|
165 | { |
---|
166 | fn[next](RENDER, backcv); |
---|
167 | cucul_set_color_ansi(mask, CUCUL_LIGHTGRAY, CUCUL_BLACK); |
---|
168 | cucul_clear_canvas(mask); |
---|
169 | cucul_set_color_ansi(mask, CUCUL_WHITE, CUCUL_WHITE); |
---|
170 | transition(mask, tmode, |
---|
171 | 100 * (frame - next_transition) / TRANSITION_FRAMES); |
---|
172 | cucul_blit(frontcv, 0, 0, backcv, mask); |
---|
173 | } |
---|
174 | |
---|
175 | cucul_set_color_ansi(frontcv, CUCUL_WHITE, CUCUL_BLUE); |
---|
176 | if(frame < 100) |
---|
177 | cucul_put_str(frontcv, cucul_get_canvas_width(frontcv) - 30, |
---|
178 | cucul_get_canvas_height(frontcv) - 2, |
---|
179 | " -=[ Powered by libcaca ]=- "); |
---|
180 | caca_refresh_display(dp); |
---|
181 | } |
---|
182 | end: |
---|
183 | if(next != -1) |
---|
184 | fn[next](FREE, frontcv); |
---|
185 | fn[demo](FREE, frontcv); |
---|
186 | |
---|
187 | caca_free_display(dp); |
---|
188 | cucul_free_canvas(mask); |
---|
189 | cucul_free_canvas(backcv); |
---|
190 | cucul_free_canvas(frontcv); |
---|
191 | |
---|
192 | return 0; |
---|
193 | } |
---|
194 | |
---|
195 | /* Transitions */ |
---|
196 | void transition(cucul_canvas_t *mask, int tmode, int completed) |
---|
197 | { |
---|
198 | static float const star[] = |
---|
199 | { |
---|
200 | 0.000000, -1.000000, |
---|
201 | 0.308000, -0.349000, |
---|
202 | 0.992000, -0.244000, |
---|
203 | 0.500000, 0.266000, |
---|
204 | 0.632000, 0.998000, |
---|
205 | 0.008000, 0.659000, |
---|
206 | -0.601000, 0.995000, |
---|
207 | -0.496000, 0.275000, |
---|
208 | -0.997000, -0.244000, |
---|
209 | -0.313000, -0.349000 |
---|
210 | }; |
---|
211 | static float star_rot[sizeof(star)/sizeof(*star)]; |
---|
212 | |
---|
213 | float mulx = 0.0075f * completed * cucul_get_canvas_width(mask); |
---|
214 | float muly = 0.0075f * completed * cucul_get_canvas_height(mask); |
---|
215 | int w2 = cucul_get_canvas_width(mask) / 2; |
---|
216 | int h2 = cucul_get_canvas_height(mask) / 2; |
---|
217 | float angle = (0.0075f * completed * 360) * 3.14 / 180, x, y; |
---|
218 | unsigned int i; |
---|
219 | |
---|
220 | switch(tmode) |
---|
221 | { |
---|
222 | case TRANSITION_STAR: |
---|
223 | /* Compute rotated coordinates */ |
---|
224 | for(i = 0; i < (sizeof(star) / sizeof(*star)) / 2; i++) |
---|
225 | { |
---|
226 | x = star[i * 2]; |
---|
227 | y = star[i * 2 + 1]; |
---|
228 | |
---|
229 | star_rot[i * 2] = x * cos(angle) - y * sin(angle); |
---|
230 | star_rot[i * 2 + 1] = y * cos(angle) + x * sin(angle); |
---|
231 | } |
---|
232 | |
---|
233 | mulx *= 1.8; |
---|
234 | muly *= 1.8; |
---|
235 | |
---|
236 | #define DO_TRI(a, b, c) \ |
---|
237 | cucul_fill_triangle(mask, \ |
---|
238 | star_rot[(a)*2] * mulx + w2, star_rot[(a)*2+1] * muly + h2, \ |
---|
239 | star_rot[(b)*2] * mulx + w2, star_rot[(b)*2+1] * muly + h2, \ |
---|
240 | star_rot[(c)*2] * mulx + w2, star_rot[(c)*2+1] * muly + h2, '#') |
---|
241 | DO_TRI(0, 1, 9); |
---|
242 | DO_TRI(1, 2, 3); |
---|
243 | DO_TRI(3, 4, 5); |
---|
244 | DO_TRI(5, 6, 7); |
---|
245 | DO_TRI(7, 8, 9); |
---|
246 | DO_TRI(9, 1, 5); |
---|
247 | DO_TRI(9, 5, 7); |
---|
248 | DO_TRI(1, 3, 5); |
---|
249 | break; |
---|
250 | |
---|
251 | case TRANSITION_CIRCLE: |
---|
252 | cucul_fill_ellipse(mask, w2, h2, mulx, muly, '#'); |
---|
253 | break; |
---|
254 | |
---|
255 | } |
---|
256 | } |
---|
257 | |
---|
258 | /* The plasma effect */ |
---|
259 | #define TABLEX (XSIZ * 2) |
---|
260 | #define TABLEY (YSIZ * 2) |
---|
261 | static uint8_t table[TABLEX * TABLEY]; |
---|
262 | |
---|
263 | static void do_plasma(uint8_t *, |
---|
264 | double, double, double, double, double, double); |
---|
265 | |
---|
266 | void plasma(enum action action, cucul_canvas_t *cv) |
---|
267 | { |
---|
268 | static cucul_dither_t *dither; |
---|
269 | static uint8_t *screen; |
---|
270 | static unsigned int red[256], green[256], blue[256], alpha[256]; |
---|
271 | static double r[3], R[6]; |
---|
272 | |
---|
273 | int i, x, y; |
---|
274 | |
---|
275 | switch(action) |
---|
276 | { |
---|
277 | case PREPARE: |
---|
278 | /* Fill various tables */ |
---|
279 | for(i = 0 ; i < 256; i++) |
---|
280 | red[i] = green[i] = blue[i] = alpha[i] = 0; |
---|
281 | |
---|
282 | for(i = 0; i < 3; i++) |
---|
283 | r[i] = (double)(cucul_rand(1, 1000)) / 60000 * M_PI; |
---|
284 | |
---|
285 | for(i = 0; i < 6; i++) |
---|
286 | R[i] = (double)(cucul_rand(1, 1000)) / 10000; |
---|
287 | |
---|
288 | for(y = 0 ; y < TABLEY ; y++) |
---|
289 | for(x = 0 ; x < TABLEX ; x++) |
---|
290 | { |
---|
291 | double tmp = (((double)((x - (TABLEX / 2)) * (x - (TABLEX / 2)) |
---|
292 | + (y - (TABLEX / 2)) * (y - (TABLEX / 2)))) |
---|
293 | * (M_PI / (TABLEX * TABLEX + TABLEY * TABLEY))); |
---|
294 | |
---|
295 | table[x + y * TABLEX] = (1.0 + sin(12.0 * sqrt(tmp))) * 256 / 6; |
---|
296 | } |
---|
297 | break; |
---|
298 | |
---|
299 | case INIT: |
---|
300 | screen = malloc(XSIZ * YSIZ * sizeof(uint8_t)); |
---|
301 | dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0); |
---|
302 | break; |
---|
303 | |
---|
304 | case UPDATE: |
---|
305 | for(i = 0 ; i < 256; i++) |
---|
306 | { |
---|
307 | double z = ((double)i) / 256 * 6 * M_PI; |
---|
308 | |
---|
309 | red[i] = (1.0 + sin(z + r[1] * frame)) / 2 * 0xfff; |
---|
310 | blue[i] = (1.0 + cos(z + r[0] * (frame + 100))) / 2 * 0xfff; |
---|
311 | green[i] = (1.0 + cos(z + r[2] * (frame + 200))) / 2 * 0xfff; |
---|
312 | } |
---|
313 | |
---|
314 | /* Set the palette */ |
---|
315 | cucul_set_dither_palette(dither, red, green, blue, alpha); |
---|
316 | |
---|
317 | do_plasma(screen, |
---|
318 | (1.0 + sin(((double)frame) * R[0])) / 2, |
---|
319 | (1.0 + sin(((double)frame) * R[1])) / 2, |
---|
320 | (1.0 + sin(((double)frame) * R[2])) / 2, |
---|
321 | (1.0 + sin(((double)frame) * R[3])) / 2, |
---|
322 | (1.0 + sin(((double)frame) * R[4])) / 2, |
---|
323 | (1.0 + sin(((double)frame) * R[5])) / 2); |
---|
324 | break; |
---|
325 | |
---|
326 | case RENDER: |
---|
327 | cucul_dither_bitmap(cv, 0, 0, |
---|
328 | cucul_get_canvas_width(cv), |
---|
329 | cucul_get_canvas_height(cv), |
---|
330 | dither, screen); |
---|
331 | break; |
---|
332 | |
---|
333 | case FREE: |
---|
334 | free(screen); |
---|
335 | cucul_free_dither(dither); |
---|
336 | break; |
---|
337 | } |
---|
338 | } |
---|
339 | |
---|
340 | static void do_plasma(uint8_t *pixels, double x_1, double y_1, |
---|
341 | double x_2, double y_2, double x_3, double y_3) |
---|
342 | { |
---|
343 | unsigned int X1 = x_1 * (TABLEX / 2), |
---|
344 | Y1 = y_1 * (TABLEY / 2), |
---|
345 | X2 = x_2 * (TABLEX / 2), |
---|
346 | Y2 = y_2 * (TABLEY / 2), |
---|
347 | X3 = x_3 * (TABLEX / 2), |
---|
348 | Y3 = y_3 * (TABLEY / 2); |
---|
349 | unsigned int y; |
---|
350 | uint8_t * t1 = table + X1 + Y1 * TABLEX, |
---|
351 | * t2 = table + X2 + Y2 * TABLEX, |
---|
352 | * t3 = table + X3 + Y3 * TABLEX; |
---|
353 | |
---|
354 | for(y = 0; y < YSIZ; y++) |
---|
355 | { |
---|
356 | unsigned int x; |
---|
357 | uint8_t * tmp = pixels + y * YSIZ; |
---|
358 | unsigned int ty = y * TABLEX, tmax = ty + XSIZ; |
---|
359 | for(x = 0; ty < tmax; ty++, tmp++) |
---|
360 | tmp[0] = t1[ty] + t2[ty] + t3[ty]; |
---|
361 | } |
---|
362 | } |
---|
363 | |
---|
364 | /* The metaball effect */ |
---|
365 | #define METASIZE (XSIZ/2) |
---|
366 | #define METABALLS 12 |
---|
367 | #define CROPBALL 200 /* Colour index where to crop balls */ |
---|
368 | static uint8_t metaball[METASIZE * METASIZE]; |
---|
369 | |
---|
370 | static void create_ball(void); |
---|
371 | static void draw_ball(uint8_t *, unsigned int, unsigned int); |
---|
372 | |
---|
373 | void metaballs(enum action action, cucul_canvas_t *cv) |
---|
374 | { |
---|
375 | static cucul_dither_t *cucul_dither; |
---|
376 | static uint8_t *screen; |
---|
377 | static unsigned int r[256], g[256], b[256], a[256]; |
---|
378 | static float dd[METABALLS], di[METABALLS], dj[METABALLS], dk[METABALLS]; |
---|
379 | static unsigned int x[METABALLS], y[METABALLS]; |
---|
380 | static float i = 10.0, j = 17.0, k = 11.0; |
---|
381 | static double offset[360 + 80]; |
---|
382 | static unsigned int angleoff; |
---|
383 | |
---|
384 | int n, angle; |
---|
385 | |
---|
386 | switch(action) |
---|
387 | { |
---|
388 | case PREPARE: |
---|
389 | /* Make the palette eatable by libcaca */ |
---|
390 | for(n = 0; n < 256; n++) |
---|
391 | r[n] = g[n] = b[n] = a[n] = 0x0; |
---|
392 | r[255] = g[255] = b[255] = 0xfff; |
---|
393 | |
---|
394 | /* Generate ball sprite */ |
---|
395 | create_ball(); |
---|
396 | |
---|
397 | for(n = 0; n < METABALLS; n++) |
---|
398 | { |
---|
399 | dd[n] = cucul_rand(0, 100); |
---|
400 | di[n] = (float)cucul_rand(500, 4000) / 6000.0; |
---|
401 | dj[n] = (float)cucul_rand(500, 4000) / 6000.0; |
---|
402 | dk[n] = (float)cucul_rand(500, 4000) / 6000.0; |
---|
403 | } |
---|
404 | |
---|
405 | angleoff = cucul_rand(0, 360); |
---|
406 | |
---|
407 | for(n = 0; n < 360 + 80; n++) |
---|
408 | offset[n] = 1.0 + sin((double)(n * M_PI / 60)); |
---|
409 | break; |
---|
410 | |
---|
411 | case INIT: |
---|
412 | screen = malloc(XSIZ * YSIZ * sizeof(uint8_t)); |
---|
413 | /* Create a libcucul dither smaller than our pixel buffer, so that we |
---|
414 | * display only the interesting part of it */ |
---|
415 | cucul_dither = cucul_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE, |
---|
416 | XSIZ, 0, 0, 0, 0); |
---|
417 | break; |
---|
418 | |
---|
419 | case UPDATE: |
---|
420 | angle = (frame + angleoff) % 360; |
---|
421 | |
---|
422 | /* Crop the palette */ |
---|
423 | for(n = CROPBALL; n < 255; n++) |
---|
424 | { |
---|
425 | int t1, t2, t3; |
---|
426 | double c1 = offset[angle]; |
---|
427 | double c2 = offset[angle + 40]; |
---|
428 | double c3 = offset[angle + 80]; |
---|
429 | |
---|
430 | t1 = n < 0x40 ? 0 : n < 0xc0 ? (n - 0x40) * 0x20 : 0xfff; |
---|
431 | t2 = n < 0xe0 ? 0 : (n - 0xe0) * 0x80; |
---|
432 | t3 = n < 0x40 ? n * 0x40 : 0xfff; |
---|
433 | |
---|
434 | r[n] = (c1 * t1 + c2 * t2 + c3 * t3) / 4; |
---|
435 | g[n] = (c1 * t2 + c2 * t3 + c3 * t1) / 4; |
---|
436 | b[n] = (c1 * t3 + c2 * t1 + c3 * t2) / 4; |
---|
437 | } |
---|
438 | |
---|
439 | /* Set the palette */ |
---|
440 | cucul_set_dither_palette(cucul_dither, r, g, b, a); |
---|
441 | |
---|
442 | /* Silly paths for our balls */ |
---|
443 | for(n = 0; n < METABALLS; n++) |
---|
444 | { |
---|
445 | float u = di[n] * i + dj[n] * j + dk[n] * sin(di[n] * k); |
---|
446 | float v = dd[n] + di[n] * j + dj[n] * k + dk[n] * sin(dk[n] * i); |
---|
447 | u = sin(i + u * 2.1) * (1.0 + sin(u)); |
---|
448 | v = sin(j + v * 1.9) * (1.0 + sin(v)); |
---|
449 | x[n] = (XSIZ - METASIZE) / 2 + u * (XSIZ - METASIZE) / 4; |
---|
450 | y[n] = (YSIZ - METASIZE) / 2 + v * (YSIZ - METASIZE) / 4; |
---|
451 | } |
---|
452 | |
---|
453 | i += 0.011; |
---|
454 | j += 0.017; |
---|
455 | k += 0.019; |
---|
456 | |
---|
457 | memset(screen, 0, XSIZ * YSIZ); |
---|
458 | |
---|
459 | for(n = 0; n < METABALLS; n++) |
---|
460 | draw_ball(screen, x[n], y[n]); |
---|
461 | break; |
---|
462 | |
---|
463 | case RENDER: |
---|
464 | cucul_dither_bitmap(cv, 0, 0, |
---|
465 | cucul_get_canvas_width(cv), |
---|
466 | cucul_get_canvas_height(cv), |
---|
467 | cucul_dither, screen + (METASIZE / 2) * (1 + XSIZ)); |
---|
468 | break; |
---|
469 | |
---|
470 | case FREE: |
---|
471 | free(screen); |
---|
472 | cucul_free_dither(cucul_dither); |
---|
473 | break; |
---|
474 | } |
---|
475 | } |
---|
476 | |
---|
477 | static void create_ball(void) |
---|
478 | { |
---|
479 | int x, y; |
---|
480 | float distance; |
---|
481 | |
---|
482 | for(y = 0; y < METASIZE; y++) |
---|
483 | for(x = 0; x < METASIZE; x++) |
---|
484 | { |
---|
485 | distance = ((METASIZE/2) - x) * ((METASIZE/2) - x) |
---|
486 | + ((METASIZE/2) - y) * ((METASIZE/2) - y); |
---|
487 | distance = sqrt(distance) * 64 / METASIZE; |
---|
488 | metaball[x + y * METASIZE] = distance > 15 ? 0 : (255 - distance) * 15; |
---|
489 | } |
---|
490 | } |
---|
491 | |
---|
492 | static void draw_ball(uint8_t *screen, unsigned int bx, unsigned int by) |
---|
493 | { |
---|
494 | unsigned int color; |
---|
495 | unsigned int i, e = 0; |
---|
496 | unsigned int b = (by * XSIZ) + bx; |
---|
497 | |
---|
498 | for(i = 0; i < METASIZE * METASIZE; i++) |
---|
499 | { |
---|
500 | color = screen[b] + metaball[i]; |
---|
501 | |
---|
502 | if(color > 255) |
---|
503 | color = 255; |
---|
504 | |
---|
505 | screen[b] = color; |
---|
506 | if(e == METASIZE) |
---|
507 | { |
---|
508 | e = 0; |
---|
509 | b += XSIZ - METASIZE; |
---|
510 | } |
---|
511 | b++; |
---|
512 | e++; |
---|
513 | } |
---|
514 | } |
---|
515 | |
---|
516 | /* The moiré effect */ |
---|
517 | #define DISCSIZ (XSIZ*2) |
---|
518 | #define DISCTHICKNESS (XSIZ*15/40) |
---|
519 | static uint8_t disc[DISCSIZ * DISCSIZ]; |
---|
520 | |
---|
521 | static void put_disc(uint8_t *, int, int); |
---|
522 | static void draw_line(int, int, char); |
---|
523 | |
---|
524 | void moire(enum action action, cucul_canvas_t *cv) |
---|
525 | { |
---|
526 | static cucul_dither_t *dither; |
---|
527 | static uint8_t *screen; |
---|
528 | static float d[6]; |
---|
529 | static unsigned int red[256], green[256], blue[256], alpha[256]; |
---|
530 | |
---|
531 | int i, x, y; |
---|
532 | |
---|
533 | switch(action) |
---|
534 | { |
---|
535 | case PREPARE: |
---|
536 | /* Fill various tables */ |
---|
537 | for(i = 0 ; i < 256; i++) |
---|
538 | red[i] = green[i] = blue[i] = alpha[i] = 0; |
---|
539 | |
---|
540 | for(i = 0; i < 6; i++) |
---|
541 | d[i] = ((float)cucul_rand(50, 70)) / 1000.0; |
---|
542 | |
---|
543 | red[0] = green[0] = blue[0] = 0x777; |
---|
544 | red[1] = green[1] = blue[1] = 0xfff; |
---|
545 | |
---|
546 | /* Fill the circle */ |
---|
547 | for(i = DISCSIZ * 2; i > 0; i -= DISCTHICKNESS) |
---|
548 | { |
---|
549 | int t, dx, dy; |
---|
550 | |
---|
551 | for(t = 0, dx = 0, dy = i; dx <= dy; dx++) |
---|
552 | { |
---|
553 | draw_line(dx / 3, dy / 3, (i / DISCTHICKNESS) % 2); |
---|
554 | draw_line(dy / 3, dx / 3, (i / DISCTHICKNESS) % 2); |
---|
555 | |
---|
556 | t += t > 0 ? dx - dy-- : dx; |
---|
557 | } |
---|
558 | } |
---|
559 | |
---|
560 | break; |
---|
561 | |
---|
562 | case INIT: |
---|
563 | screen = malloc(XSIZ * YSIZ * sizeof(uint8_t)); |
---|
564 | dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0); |
---|
565 | break; |
---|
566 | |
---|
567 | case UPDATE: |
---|
568 | memset(screen, 0, XSIZ * YSIZ); |
---|
569 | |
---|
570 | /* Set the palette */ |
---|
571 | red[0] = 0.5 * (1 + sin(d[0] * (frame + 1000))) * 0xfff; |
---|
572 | green[0] = 0.5 * (1 + cos(d[1] * frame)) * 0xfff; |
---|
573 | blue[0] = 0.5 * (1 + cos(d[2] * (frame + 3000))) * 0xfff; |
---|
574 | |
---|
575 | red[1] = 0.5 * (1 + sin(d[3] * (frame + 2000))) * 0xfff; |
---|
576 | green[1] = 0.5 * (1 + cos(d[4] * frame + 5.0)) * 0xfff; |
---|
577 | blue[1] = 0.5 * (1 + cos(d[5] * (frame + 4000))) * 0xfff; |
---|
578 | |
---|
579 | cucul_set_dither_palette(dither, red, green, blue, alpha); |
---|
580 | |
---|
581 | /* Draw circles */ |
---|
582 | x = cos(d[0] * (frame + 1000)) * 128.0 + (XSIZ / 2); |
---|
583 | y = sin(0.11 * frame) * 128.0 + (YSIZ / 2); |
---|
584 | put_disc(screen, x, y); |
---|
585 | |
---|
586 | x = cos(0.13 * frame + 2.0) * 64.0 + (XSIZ / 2); |
---|
587 | y = sin(d[1] * (frame + 2000)) * 64.0 + (YSIZ / 2); |
---|
588 | put_disc(screen, x, y); |
---|
589 | break; |
---|
590 | |
---|
591 | case RENDER: |
---|
592 | cucul_dither_bitmap(cv, 0, 0, |
---|
593 | cucul_get_canvas_width(cv), |
---|
594 | cucul_get_canvas_height(cv), |
---|
595 | dither, screen); |
---|
596 | break; |
---|
597 | |
---|
598 | case FREE: |
---|
599 | free(screen); |
---|
600 | cucul_free_dither(dither); |
---|
601 | break; |
---|
602 | } |
---|
603 | } |
---|
604 | |
---|
605 | static void put_disc(uint8_t *screen, int x, int y) |
---|
606 | { |
---|
607 | char *src = ((char*)disc) + (DISCSIZ / 2 - x) + (DISCSIZ / 2 - y) * DISCSIZ; |
---|
608 | int i, j; |
---|
609 | |
---|
610 | for(j = 0; j < YSIZ; j++) |
---|
611 | for(i = 0; i < XSIZ; i++) |
---|
612 | { |
---|
613 | screen[i + XSIZ * j] ^= src[i + DISCSIZ * j]; |
---|
614 | } |
---|
615 | } |
---|
616 | |
---|
617 | static void draw_line(int x, int y, char color) |
---|
618 | { |
---|
619 | if(x == 0 || y == 0 || y > DISCSIZ / 2) |
---|
620 | return; |
---|
621 | |
---|
622 | if(x > DISCSIZ / 2) |
---|
623 | x = DISCSIZ / 2; |
---|
624 | |
---|
625 | memset(disc + (DISCSIZ / 2) - x + DISCSIZ * ((DISCSIZ / 2) - y), |
---|
626 | color, 2 * x - 1); |
---|
627 | memset(disc + (DISCSIZ / 2) - x + DISCSIZ * ((DISCSIZ / 2) + y - 1), |
---|
628 | color, 2 * x - 1); |
---|
629 | } |
---|
630 | |
---|
631 | /* Langton ant effect */ |
---|
632 | #define ANTS 15 |
---|
633 | #define ITER 2 |
---|
634 | |
---|
635 | void langton(enum action action, cucul_canvas_t *cv) |
---|
636 | { |
---|
637 | static char gradient[] = |
---|
638 | { |
---|
639 | ' ', ' ', '.', '.', ':', ':', 'x', 'x', |
---|
640 | 'X', 'X', '&', '&', 'W', 'W', '@', '@', |
---|
641 | }; |
---|
642 | static int steps[][2] = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } }; |
---|
643 | static uint8_t *screen; |
---|
644 | static int width, height; |
---|
645 | static int ax[ANTS], ay[ANTS], dir[ANTS]; |
---|
646 | |
---|
647 | int i, a, x, y; |
---|
648 | |
---|
649 | switch(action) |
---|
650 | { |
---|
651 | case PREPARE: |
---|
652 | width = cucul_get_canvas_width(cv); |
---|
653 | height = cucul_get_canvas_height(cv); |
---|
654 | for(i = 0; i < ANTS; i++) |
---|
655 | { |
---|
656 | ax[i] = cucul_rand(0, width); |
---|
657 | ay[i] = cucul_rand(0, height); |
---|
658 | dir[i] = cucul_rand(0, 4); |
---|
659 | } |
---|
660 | break; |
---|
661 | |
---|
662 | case INIT: |
---|
663 | screen = malloc(width * height); |
---|
664 | memset(screen, 0, width * height); |
---|
665 | break; |
---|
666 | |
---|
667 | case UPDATE: |
---|
668 | for(i = 0; i < ITER; i++) |
---|
669 | { |
---|
670 | for(x = 0; x < width * height; x++) |
---|
671 | { |
---|
672 | uint8_t p = screen[x]; |
---|
673 | if((p & 0x0f) > 1) |
---|
674 | screen[x] = p - 1; |
---|
675 | } |
---|
676 | |
---|
677 | for(a = 0; a < ANTS; a++) |
---|
678 | { |
---|
679 | uint8_t p = screen[ax[a] + width * ay[a]]; |
---|
680 | |
---|
681 | if(p & 0x0f) |
---|
682 | { |
---|
683 | dir[a] = (dir[a] + 1) % 4; |
---|
684 | screen[ax[a] + width * ay[a]] = a << 4; |
---|
685 | } |
---|
686 | else |
---|
687 | { |
---|
688 | dir[a] = (dir[a] + 3) % 4; |
---|
689 | screen[ax[a] + width * ay[a]] = (a << 4) | 0x0f; |
---|
690 | } |
---|
691 | ax[a] = (width + ax[a] + steps[dir[a]][0]) % width; |
---|
692 | ay[a] = (height + ay[a] + steps[dir[a]][1]) % height; |
---|
693 | } |
---|
694 | } |
---|
695 | break; |
---|
696 | |
---|
697 | case RENDER: |
---|
698 | for(y = 0; y < height; y++) |
---|
699 | { |
---|
700 | for(x = 0; x < width; x++) |
---|
701 | { |
---|
702 | uint8_t p = screen[x + width * y]; |
---|
703 | |
---|
704 | if(p & 0x0f) |
---|
705 | cucul_set_color_ansi(cv, CUCUL_WHITE, p >> 4); |
---|
706 | else |
---|
707 | cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK); |
---|
708 | cucul_put_char(cv, x, y, gradient[p & 0x0f]); |
---|
709 | } |
---|
710 | } |
---|
711 | break; |
---|
712 | |
---|
713 | case FREE: |
---|
714 | free(screen); |
---|
715 | break; |
---|
716 | } |
---|
717 | } |
---|
718 | |
---|
719 | /* Matrix effect */ |
---|
720 | #define MAXDROPS 500 |
---|
721 | #define MINLEN 15 |
---|
722 | #define MAXLEN 30 |
---|
723 | |
---|
724 | void matrix(enum action action, cucul_canvas_t *cv) |
---|
725 | { |
---|
726 | static struct drop |
---|
727 | { |
---|
728 | int x, y, speed, len; |
---|
729 | char str[MAXLEN]; |
---|
730 | } |
---|
731 | drop[MAXDROPS]; |
---|
732 | |
---|
733 | int w, h, i, j; |
---|
734 | |
---|
735 | switch(action) |
---|
736 | { |
---|
737 | case PREPARE: |
---|
738 | for(i = 0; i < MAXDROPS; i++) |
---|
739 | { |
---|
740 | drop[i].x = cucul_rand(0, 1000); |
---|
741 | drop[i].y = cucul_rand(0, 1000); |
---|
742 | drop[i].speed = 5 + cucul_rand(0, 30); |
---|
743 | drop[i].len = MINLEN + cucul_rand(0, (MAXLEN - MINLEN)); |
---|
744 | for(j = 0; j < MAXLEN; j++) |
---|
745 | drop[i].str[j] = cucul_rand('0', 'z'); |
---|
746 | } |
---|
747 | break; |
---|
748 | |
---|
749 | case INIT: |
---|
750 | break; |
---|
751 | |
---|
752 | case UPDATE: |
---|
753 | w = cucul_get_canvas_width(cv); |
---|
754 | h = cucul_get_canvas_height(cv); |
---|
755 | |
---|
756 | for(i = 0; i < MAXDROPS && i < (w * h / 32); i++) |
---|
757 | { |
---|
758 | drop[i].y += drop[i].speed; |
---|
759 | if(drop[i].y > 1000) |
---|
760 | { |
---|
761 | drop[i].y -= 1000; |
---|
762 | drop[i].x = cucul_rand(0, 1000); |
---|
763 | } |
---|
764 | } |
---|
765 | break; |
---|
766 | |
---|
767 | case RENDER: |
---|
768 | w = cucul_get_canvas_width(cv); |
---|
769 | h = cucul_get_canvas_height(cv); |
---|
770 | |
---|
771 | cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK); |
---|
772 | cucul_clear_canvas(cv); |
---|
773 | |
---|
774 | for(i = 0; i < MAXDROPS && i < (w * h / 32); i++) |
---|
775 | { |
---|
776 | int x, y; |
---|
777 | |
---|
778 | x = drop[i].x * w / 1000 / 2 * 2; |
---|
779 | y = drop[i].y * (h + MAXLEN) / 1000; |
---|
780 | |
---|
781 | for(j = 0; j < drop[i].len; j++) |
---|
782 | { |
---|
783 | unsigned int fg; |
---|
784 | |
---|
785 | if(j < 2) |
---|
786 | fg = CUCUL_WHITE; |
---|
787 | else if(j < drop[i].len / 4) |
---|
788 | fg = CUCUL_LIGHTGREEN; |
---|
789 | else if(j < drop[i].len * 4 / 5) |
---|
790 | fg = CUCUL_GREEN; |
---|
791 | else |
---|
792 | fg = CUCUL_DARKGRAY; |
---|
793 | cucul_set_color_ansi(cv, fg, CUCUL_BLACK); |
---|
794 | |
---|
795 | cucul_put_char(cv, x, y - j, |
---|
796 | drop[i].str[(y - j) % drop[i].len]); |
---|
797 | } |
---|
798 | } |
---|
799 | break; |
---|
800 | |
---|
801 | case FREE: |
---|
802 | break; |
---|
803 | } |
---|
804 | } |
---|
805 | |
---|
806 | |
---|