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

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