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

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