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

Last change on this file since 1462 was 1462, checked in by Sam Hocevar, 13 years ago
  • Bwarf, typo in the no warranty clause.
  • Property svn:keywords set to Id
File size: 22.4 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 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
33enum action { PREPARE, INIT, UPDATE, RENDER, FREE };
34
35void transition(cucul_canvas_t *, int, int);
36void plasma(enum action, cucul_canvas_t *);
37void metaballs(enum action, cucul_canvas_t *);
38void moire(enum action, cucul_canvas_t *);
39void langton(enum action, cucul_canvas_t *);
40void matrix(enum action, cucul_canvas_t *);
41
42void (*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 */
65static int frame = 0;
66
67int 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++;
159paused:
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    }
182end:
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 */
196void 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)
261static uint8_t table[TABLEX * TABLEY];
262
263static void do_plasma(uint8_t *,
264                      double, double, double, double, double, double);
265
266void 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
340static 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 */
368static uint8_t metaball[METASIZE * METASIZE];
369
370static void create_ball(void);
371static void draw_ball(uint8_t *, unsigned int, unsigned int);
372
373void 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
477static 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
492static 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)
519static uint8_t disc[DISCSIZ * DISCSIZ];
520
521static void put_disc(uint8_t *, int, int);
522static void draw_line(int, int, char);
523
524void 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
605static 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
617static 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
635void 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
724void 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
Note: See TracBrowser for help on using the repository browser.