source: libcaca/trunk/src/cacademo.c @ 1034

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