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

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