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

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