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

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