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

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