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

Last change on this file since 1766 was 1766, checked in by Jean-Yves Lamoureux, 13 years ago
  • Added rotozoom (and its 1MB header file)
  • Property svn:keywords set to Id
File size: 26.6 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 1766 2007-06-24 07:46:18Z jylam $
9 *
10 *  This program is free software. It comes without any warranty, to
11 *  the extent permitted by applicable law. You can redistribute it
12 *  and/or modify it under the terms of the Do What The Fuck You Want
13 *  To Public License, Version 2, as published by Sam Hocevar. See
14 *  http://sam.zoy.org/wtfpl/COPYING for more details.
15 */
16
17#include "config.h"
18#include "common.h"
19
20#if !defined(__KERNEL__)
21#   include <stdio.h>
22#   include <stdlib.h>
23#   include <string.h>
24#   include <math.h>
25#   ifndef M_PI
26#       define M_PI 3.14159265358979323846
27#   endif
28#endif
29
30#include "cucul.h"
31#include "caca.h"
32
33enum action { PREPARE, INIT, UPDATE, RENDER, FREE };
34
35void transition(cucul_canvas_t *, int, int);
36void plasma(enum action, cucul_canvas_t *);
37void metaballs(enum action, cucul_canvas_t *);
38void moire(enum action, cucul_canvas_t *);
39void langton(enum action, cucul_canvas_t *);
40void matrix(enum action, cucul_canvas_t *);
41void rotozoom(enum action, cucul_canvas_t *);
42
43void (*fn[])(enum action, cucul_canvas_t *) =
44{
45    plasma,
46    metaballs,
47    moire,
48    /*langton,*/
49    matrix,
50    rotozoom,
51};
52#define DEMOS (sizeof(fn)/sizeof(*fn))
53
54#define DEMO_FRAMES cucul_rand(500, 1000)
55#define TRANSITION_FRAMES 40
56
57#define TRANSITION_COUNT  3
58#define TRANSITION_CIRCLE 0
59#define TRANSITION_STAR   1
60#define TRANSITION_SQUARE 2
61
62/* Common macros for dither-based demos */
63#define XSIZ 256
64#define YSIZ 256
65
66/* Global variables */
67static int frame = 0;
68
69int main(int argc, char **argv)
70{
71    static caca_display_t *dp;
72    static cucul_canvas_t *frontcv, *backcv, *mask;
73
74    int demo, next = -1, pause = 0, next_transition = DEMO_FRAMES;
75    unsigned int i;
76    int tmode = cucul_rand(0, TRANSITION_COUNT);
77
78    /* Set up two canvases, a mask, and attach a display to the front one */
79    frontcv = cucul_create_canvas(0, 0);
80    backcv = cucul_create_canvas(0, 0);
81    mask = cucul_create_canvas(0, 0);
82
83    dp = caca_create_display(frontcv);
84    if(!dp)
85        return 1;
86
87    cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
88                                  cucul_get_canvas_height(frontcv));
89    cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
90                                cucul_get_canvas_height(frontcv));
91
92    caca_set_display_time(dp, 20000);
93
94    /* Initialise all demos' lookup tables */
95    for(i = 0; i < DEMOS; i++)
96        fn[i](PREPARE, frontcv);
97
98    /* Choose a demo at random */
99    demo = cucul_rand(0, DEMOS);
100    fn[demo](INIT, frontcv);
101
102    for(;;)
103    {
104        /* Handle events */
105        caca_event_t ev;
106        while(caca_get_event(dp, CACA_EVENT_KEY_PRESS
107                                  | CACA_EVENT_QUIT, &ev, 0))
108        {
109            if(ev.type == CACA_EVENT_QUIT)
110                goto end;
111
112            switch(ev.data.key.ch)
113            {
114                case CACA_KEY_ESCAPE:
115                case CACA_KEY_CTRL_C:
116                case CACA_KEY_CTRL_Z:
117                    goto end;
118                case ' ':
119                    pause = !pause;
120                    break;
121                case '\r':
122                    if(next == -1)
123                        next_transition = frame;
124                    break;
125            }
126        }
127
128        /* Resize the spare canvas, just in case the main one changed */
129        cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
130                                      cucul_get_canvas_height(frontcv));
131        cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
132                                    cucul_get_canvas_height(frontcv));
133
134        if(pause)
135            goto paused;
136
137        /* Update demo's data */
138        fn[demo](UPDATE, frontcv);
139
140        /* Handle transitions */
141        if(frame == next_transition)
142        {
143            next = cucul_rand(0, DEMOS);
144            if(next == demo)
145                next = (next + 1) % DEMOS;
146            fn[next](INIT, backcv);
147        }
148        else if(frame == next_transition + TRANSITION_FRAMES)
149        {
150            fn[demo](FREE, frontcv);
151            demo = next;
152            next = -1;
153            next_transition = frame + DEMO_FRAMES;
154            tmode = cucul_rand(0, TRANSITION_COUNT);
155        }
156
157        if(next != -1)
158            fn[next](UPDATE, backcv);
159
160        frame++;
161paused:
162        /* Render main demo's canvas */
163        fn[demo](RENDER, frontcv);
164
165        /* If a transition is on its way, render it */
166        if(next != -1)
167        {
168            fn[next](RENDER, backcv);
169            cucul_set_color_ansi(mask, CUCUL_LIGHTGRAY, CUCUL_BLACK);
170            cucul_clear_canvas(mask);
171            cucul_set_color_ansi(mask, CUCUL_WHITE, CUCUL_WHITE);
172            transition(mask, tmode,
173                       100 * (frame - next_transition) / TRANSITION_FRAMES);
174            cucul_blit(frontcv, 0, 0, backcv, mask);
175        }
176
177        cucul_set_color_ansi(frontcv, CUCUL_WHITE, CUCUL_BLUE);
178        if(frame < 100)
179            cucul_put_str(frontcv, cucul_get_canvas_width(frontcv) - 30,
180                                   cucul_get_canvas_height(frontcv) - 2,
181                                   " -=[ Powered by libcaca ]=- ");
182        caca_refresh_display(dp);
183    }
184end:
185    if(next != -1)
186        fn[next](FREE, frontcv);
187    fn[demo](FREE, frontcv);
188
189    caca_free_display(dp);
190    cucul_free_canvas(mask);
191    cucul_free_canvas(backcv);
192    cucul_free_canvas(frontcv);
193
194    return 0;
195}
196
197/* Transitions */
198void transition(cucul_canvas_t *mask, int tmode, int completed)
199{
200    static float const star[] =
201    {
202         0.000000, -1.000000,
203         0.308000, -0.349000,
204         0.992000, -0.244000,
205         0.500000,  0.266000,
206         0.632000,  0.998000,
207         0.008000,  0.659000,
208        -0.601000,  0.995000,
209        -0.496000,  0.275000,
210        -0.997000, -0.244000,
211        -0.313000, -0.349000
212    };
213    static float star_rot[sizeof(star)/sizeof(*star)];
214
215
216    static float const square[] =
217    {
218        -1, -1,
219        1, -1,
220        1, 1,
221        -1, 1
222    };
223    static float square_rot[sizeof(square)/sizeof(*square)];
224
225    float mulx = 0.0075f * completed * cucul_get_canvas_width(mask);
226    float muly = 0.0075f * completed * cucul_get_canvas_height(mask);
227    int w2 = cucul_get_canvas_width(mask) / 2;
228    int h2 = cucul_get_canvas_height(mask) / 2;
229    float angle = (0.0075f * completed * 360) * 3.14 / 180, x, y;
230    unsigned int i;
231
232    switch(tmode)
233    {
234        case TRANSITION_SQUARE:
235            /* Compute rotated coordinates */
236            for(i = 0; i < (sizeof(square) / sizeof(*square)) / 2; i++)
237            {
238                x = square[i * 2];
239                y = square[i * 2 + 1];
240
241                square_rot[i * 2] = x * cos(angle) - y * sin(angle);
242                square_rot[i * 2 + 1] = y * cos(angle) + x * sin(angle);
243            }
244
245            mulx *= 1.8;
246            muly *= 1.8;
247            cucul_fill_triangle(mask,
248                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
249                                square_rot[1*2] * mulx + w2, square_rot[1*2+1] * muly + h2, \
250                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, '#');
251            cucul_fill_triangle(mask,
252                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
253                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, \
254                                square_rot[3*2] * mulx + w2, square_rot[3*2+1] * muly + h2, '#');
255            break;
256
257
258        case TRANSITION_STAR:
259            /* Compute rotated coordinates */
260            for(i = 0; i < (sizeof(star) / sizeof(*star)) / 2; i++)
261            {
262                x = star[i * 2];
263                y = star[i * 2 + 1];
264
265                star_rot[i * 2] = x * cos(angle) - y * sin(angle);
266                star_rot[i * 2 + 1] = y * cos(angle) + x * sin(angle);
267            }
268
269            mulx *= 1.8;
270            muly *= 1.8;
271
272#define DO_TRI(a, b, c) \
273    cucul_fill_triangle(mask, \
274        star_rot[(a)*2] * mulx + w2, star_rot[(a)*2+1] * muly + h2, \
275        star_rot[(b)*2] * mulx + w2, star_rot[(b)*2+1] * muly + h2, \
276        star_rot[(c)*2] * mulx + w2, star_rot[(c)*2+1] * muly + h2, '#')
277            DO_TRI(0, 1, 9);
278            DO_TRI(1, 2, 3);
279            DO_TRI(3, 4, 5);
280            DO_TRI(5, 6, 7);
281            DO_TRI(7, 8, 9);
282            DO_TRI(9, 1, 5);
283            DO_TRI(9, 5, 7);
284            DO_TRI(1, 3, 5);
285            break;
286
287        case TRANSITION_CIRCLE:
288            cucul_fill_ellipse(mask, w2, h2, mulx, muly, '#');
289            break;
290
291    }
292}
293
294/* The plasma effect */
295#define TABLEX (XSIZ * 2)
296#define TABLEY (YSIZ * 2)
297static uint8_t table[TABLEX * TABLEY];
298
299static void do_plasma(uint8_t *,
300                      double, double, double, double, double, double);
301
302void plasma(enum action action, cucul_canvas_t *cv)
303{
304    static cucul_dither_t *dither;
305    static uint8_t *screen;
306    static unsigned int red[256], green[256], blue[256], alpha[256];
307    static double r[3], R[6];
308
309    int i, x, y;
310
311    switch(action)
312    {
313    case PREPARE:
314        /* Fill various tables */
315        for(i = 0 ; i < 256; i++)
316            red[i] = green[i] = blue[i] = alpha[i] = 0;
317
318        for(i = 0; i < 3; i++)
319            r[i] = (double)(cucul_rand(1, 1000)) / 60000 * M_PI;
320
321        for(i = 0; i < 6; i++)
322            R[i] = (double)(cucul_rand(1, 1000)) / 10000;
323
324        for(y = 0 ; y < TABLEY ; y++)
325            for(x = 0 ; x < TABLEX ; x++)
326        {
327            double tmp = (((double)((x - (TABLEX / 2)) * (x - (TABLEX / 2))
328                                  + (y - (TABLEX / 2)) * (y - (TABLEX / 2))))
329                          * (M_PI / (TABLEX * TABLEX + TABLEY * TABLEY)));
330
331            table[x + y * TABLEX] = (1.0 + sin(12.0 * sqrt(tmp))) * 256 / 6;
332        }
333        break;
334
335    case INIT:
336        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
337        dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
338        break;
339
340    case UPDATE:
341        for(i = 0 ; i < 256; i++)
342        {
343            double z = ((double)i) / 256 * 6 * M_PI;
344
345            red[i] = (1.0 + sin(z + r[1] * frame)) / 2 * 0xfff;
346            blue[i] = (1.0 + cos(z + r[0] * (frame + 100))) / 2 * 0xfff;
347            green[i] = (1.0 + cos(z + r[2] * (frame + 200))) / 2 * 0xfff;
348        }
349
350        /* Set the palette */
351        cucul_set_dither_palette(dither, red, green, blue, alpha);
352
353        do_plasma(screen,
354                  (1.0 + sin(((double)frame) * R[0])) / 2,
355                  (1.0 + sin(((double)frame) * R[1])) / 2,
356                  (1.0 + sin(((double)frame) * R[2])) / 2,
357                  (1.0 + sin(((double)frame) * R[3])) / 2,
358                  (1.0 + sin(((double)frame) * R[4])) / 2,
359                  (1.0 + sin(((double)frame) * R[5])) / 2);
360        break;
361
362    case RENDER:
363        cucul_dither_bitmap(cv, 0, 0,
364                            cucul_get_canvas_width(cv),
365                            cucul_get_canvas_height(cv),
366                            dither, screen);
367        break;
368
369    case FREE:
370        free(screen);
371        cucul_free_dither(dither);
372        break;
373    }
374}
375
376static void do_plasma(uint8_t *pixels, double x_1, double y_1,
377                      double x_2, double y_2, double x_3, double y_3)
378{
379    unsigned int X1 = x_1 * (TABLEX / 2),
380                 Y1 = y_1 * (TABLEY / 2),
381                 X2 = x_2 * (TABLEX / 2),
382                 Y2 = y_2 * (TABLEY / 2),
383                 X3 = x_3 * (TABLEX / 2),
384                 Y3 = y_3 * (TABLEY / 2);
385    unsigned int y;
386    uint8_t * t1 = table + X1 + Y1 * TABLEX,
387            * t2 = table + X2 + Y2 * TABLEX,
388            * t3 = table + X3 + Y3 * TABLEX;
389
390    for(y = 0; y < YSIZ; y++)
391    {
392        unsigned int x;
393        uint8_t * tmp = pixels + y * YSIZ;
394        unsigned int ty = y * TABLEX, tmax = ty + XSIZ;
395        for(x = 0; ty < tmax; ty++, tmp++)
396            tmp[0] = t1[ty] + t2[ty] + t3[ty];
397    }
398}
399
400/* The metaball effect */
401#define METASIZE (XSIZ/2)
402#define METABALLS 12
403#define CROPBALL 200 /* Colour index where to crop balls */
404static uint8_t metaball[METASIZE * METASIZE];
405
406static void create_ball(void);
407static void draw_ball(uint8_t *, unsigned int, unsigned int);
408
409void metaballs(enum action action, cucul_canvas_t *cv)
410{
411    static cucul_dither_t *cucul_dither;
412    static uint8_t *screen;
413    static unsigned int r[256], g[256], b[256], a[256];
414    static float dd[METABALLS], di[METABALLS], dj[METABALLS], dk[METABALLS];
415    static unsigned int x[METABALLS], y[METABALLS];
416    static float i = 10.0, j = 17.0, k = 11.0;
417    static double offset[360 + 80];
418    static unsigned int angleoff;
419
420    int n, angle;
421
422    switch(action)
423    {
424    case PREPARE:
425        /* Make the palette eatable by libcaca */
426        for(n = 0; n < 256; n++)
427            r[n] = g[n] = b[n] = a[n] = 0x0;
428        r[255] = g[255] = b[255] = 0xfff;
429
430        /* Generate ball sprite */
431        create_ball();
432
433        for(n = 0; n < METABALLS; n++)
434        {
435            dd[n] = cucul_rand(0, 100);
436            di[n] = (float)cucul_rand(500, 4000) / 6000.0;
437            dj[n] = (float)cucul_rand(500, 4000) / 6000.0;
438            dk[n] = (float)cucul_rand(500, 4000) / 6000.0;
439        }
440
441        angleoff = cucul_rand(0, 360);
442
443        for(n = 0; n < 360 + 80; n++)
444            offset[n] = 1.0 + sin((double)(n * M_PI / 60));
445        break;
446
447    case INIT:
448        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
449        /* Create a libcucul dither smaller than our pixel buffer, so that we
450         * display only the interesting part of it */
451        cucul_dither = cucul_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE,
452                                           XSIZ, 0, 0, 0, 0);
453        break;
454
455    case UPDATE:
456        angle = (frame + angleoff) % 360;
457
458        /* Crop the palette */
459        for(n = CROPBALL; n < 255; n++)
460        {
461            int t1, t2, t3;
462            double c1 = offset[angle];
463            double c2 = offset[angle + 40];
464            double c3 = offset[angle + 80];
465
466            t1 = n < 0x40 ? 0 : n < 0xc0 ? (n - 0x40) * 0x20 : 0xfff;
467            t2 = n < 0xe0 ? 0 : (n - 0xe0) * 0x80;
468            t3 = n < 0x40 ? n * 0x40 : 0xfff;
469
470            r[n] = (c1 * t1 + c2 * t2 + c3 * t3) / 4;
471            g[n] = (c1 * t2 + c2 * t3 + c3 * t1) / 4;
472            b[n] = (c1 * t3 + c2 * t1 + c3 * t2) / 4;
473        }
474
475        /* Set the palette */
476        cucul_set_dither_palette(cucul_dither, r, g, b, a);
477
478        /* Silly paths for our balls */
479        for(n = 0; n < METABALLS; n++)
480        {
481            float u = di[n] * i + dj[n] * j + dk[n] * sin(di[n] * k);
482            float v = dd[n] + di[n] * j + dj[n] * k + dk[n] * sin(dk[n] * i);
483            u = sin(i + u * 2.1) * (1.0 + sin(u));
484            v = sin(j + v * 1.9) * (1.0 + sin(v));
485            x[n] = (XSIZ - METASIZE) / 2 + u * (XSIZ - METASIZE) / 4;
486            y[n] = (YSIZ - METASIZE) / 2 + v * (YSIZ - METASIZE) / 4;
487        }
488
489        i += 0.011;
490        j += 0.017;
491        k += 0.019;
492
493        memset(screen, 0, XSIZ * YSIZ);
494
495        for(n = 0; n < METABALLS; n++)
496            draw_ball(screen, x[n], y[n]);
497        break;
498
499    case RENDER:
500        cucul_dither_bitmap(cv, 0, 0,
501                          cucul_get_canvas_width(cv),
502                          cucul_get_canvas_height(cv),
503                          cucul_dither, screen + (METASIZE / 2) * (1 + XSIZ));
504        break;
505
506    case FREE:
507        free(screen);
508        cucul_free_dither(cucul_dither);
509        break;
510    }
511}
512
513static void create_ball(void)
514{
515    int x, y;
516    float distance;
517
518    for(y = 0; y < METASIZE; y++)
519        for(x = 0; x < METASIZE; x++)
520    {
521        distance = ((METASIZE/2) - x) * ((METASIZE/2) - x)
522                 + ((METASIZE/2) - y) * ((METASIZE/2) - y);
523        distance = sqrt(distance) * 64 / METASIZE;
524        metaball[x + y * METASIZE] = distance > 15 ? 0 : (255 - distance) * 15;
525    }
526}
527
528static void draw_ball(uint8_t *screen, unsigned int bx, unsigned int by)
529{
530    unsigned int color;
531    unsigned int i, e = 0;
532    unsigned int b = (by * XSIZ) + bx;
533
534    for(i = 0; i < METASIZE * METASIZE; i++)
535    {
536        color = screen[b] + metaball[i];
537
538        if(color > 255)
539            color = 255;
540
541        screen[b] = color;
542        if(e == METASIZE)
543        {
544            e = 0;
545            b += XSIZ - METASIZE;
546        }
547        b++;
548        e++;
549    }
550}
551
552/* The moiré effect */
553#define DISCSIZ (XSIZ*2)
554#define DISCTHICKNESS (XSIZ*15/40)
555static uint8_t disc[DISCSIZ * DISCSIZ];
556
557static void put_disc(uint8_t *, int, int);
558static void draw_line(int, int, char);
559
560void moire(enum action action, cucul_canvas_t *cv)
561{
562    static cucul_dither_t *dither;
563    static uint8_t *screen;
564    static float d[6];
565    static unsigned int red[256], green[256], blue[256], alpha[256];
566
567    int i, x, y;
568
569    switch(action)
570    {
571    case PREPARE:
572        /* Fill various tables */
573        for(i = 0 ; i < 256; i++)
574            red[i] = green[i] = blue[i] = alpha[i] = 0;
575
576        for(i = 0; i < 6; i++)
577            d[i] = ((float)cucul_rand(50, 70)) / 1000.0;
578
579        red[0] = green[0] = blue[0] = 0x777;
580        red[1] = green[1] = blue[1] = 0xfff;
581
582        /* Fill the circle */
583        for(i = DISCSIZ * 2; i > 0; i -= DISCTHICKNESS)
584        {
585            int t, dx, dy;
586
587            for(t = 0, dx = 0, dy = i; dx <= dy; dx++)
588            {
589                draw_line(dx / 3, dy / 3, (i / DISCTHICKNESS) % 2);
590                draw_line(dy / 3, dx / 3, (i / DISCTHICKNESS) % 2);
591
592                t += t > 0 ? dx - dy-- : dx;
593            }
594        }
595
596        break;
597
598    case INIT:
599        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
600        dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
601        break;
602
603    case UPDATE:
604        memset(screen, 0, XSIZ * YSIZ);
605
606        /* Set the palette */
607        red[0] = 0.5 * (1 + sin(d[0] * (frame + 1000))) * 0xfff;
608        green[0] = 0.5 * (1 + cos(d[1] * frame)) * 0xfff;
609        blue[0] = 0.5 * (1 + cos(d[2] * (frame + 3000))) * 0xfff;
610
611        red[1] = 0.5 * (1 + sin(d[3] * (frame + 2000))) * 0xfff;
612        green[1] = 0.5 * (1 + cos(d[4] * frame + 5.0)) * 0xfff;
613        blue[1] = 0.5 * (1 + cos(d[5] * (frame + 4000))) * 0xfff;
614
615        cucul_set_dither_palette(dither, red, green, blue, alpha);
616
617        /* Draw circles */
618        x = cos(d[0] * (frame + 1000)) * 128.0 + (XSIZ / 2);
619        y = sin(0.11 * frame) * 128.0 + (YSIZ / 2);
620        put_disc(screen, x, y);
621
622        x = cos(0.13 * frame + 2.0) * 64.0 + (XSIZ / 2);
623        y = sin(d[1] * (frame + 2000)) * 64.0 + (YSIZ / 2);
624        put_disc(screen, x, y);
625        break;
626
627    case RENDER:
628        cucul_dither_bitmap(cv, 0, 0,
629                            cucul_get_canvas_width(cv),
630                            cucul_get_canvas_height(cv),
631                            dither, screen);
632        break;
633
634    case FREE:
635        free(screen);
636        cucul_free_dither(dither);
637        break;
638    }
639}
640
641static void put_disc(uint8_t *screen, int x, int y)
642{
643    char *src = ((char*)disc) + (DISCSIZ / 2 - x) + (DISCSIZ / 2 - y) * DISCSIZ;
644    int i, j;
645
646    for(j = 0; j < YSIZ; j++)
647        for(i = 0; i < XSIZ; i++)
648    {
649        screen[i + XSIZ * j] ^= src[i + DISCSIZ * j];
650    }
651}
652
653static void draw_line(int x, int y, char color)
654{
655    if(x == 0 || y == 0 || y > DISCSIZ / 2)
656        return;
657
658    if(x > DISCSIZ / 2)
659        x = DISCSIZ / 2;
660
661    memset(disc + (DISCSIZ / 2) - x + DISCSIZ * ((DISCSIZ / 2) - y),
662           color, 2 * x - 1);
663    memset(disc + (DISCSIZ / 2) - x + DISCSIZ * ((DISCSIZ / 2) + y - 1),
664           color, 2 * x - 1);
665}
666
667/* Langton ant effect */
668#define ANTS 15
669#define ITER 2
670
671void langton(enum action action, cucul_canvas_t *cv)
672{
673    static char gradient[] =
674    {
675        ' ', ' ', '.', '.', ':', ':', 'x', 'x',
676        'X', 'X', '&', '&', 'W', 'W', '@', '@',
677    };
678    static int steps[][2] = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
679    static uint8_t *screen;
680    static int width, height;
681    static int ax[ANTS], ay[ANTS], dir[ANTS];
682
683    int i, a, x, y;
684
685    switch(action)
686    {
687    case PREPARE:
688        width = cucul_get_canvas_width(cv);
689        height = cucul_get_canvas_height(cv);
690        for(i = 0; i < ANTS; i++)
691        {
692            ax[i] = cucul_rand(0, width);
693            ay[i] = cucul_rand(0, height);
694            dir[i] = cucul_rand(0, 4);
695        }
696        break;
697
698    case INIT:
699        screen = malloc(width * height);
700        memset(screen, 0, width * height);
701        break;
702
703    case UPDATE:
704        for(i = 0; i < ITER; i++)
705        {
706            for(x = 0; x < width * height; x++)
707            {
708                uint8_t p = screen[x];
709                if((p & 0x0f) > 1)
710                    screen[x] = p - 1;
711            }
712
713            for(a = 0; a < ANTS; a++)
714            {
715                uint8_t p = screen[ax[a] + width * ay[a]];
716
717                if(p & 0x0f)
718                {
719                    dir[a] = (dir[a] + 1) % 4;
720                    screen[ax[a] + width * ay[a]] = a << 4;
721                }
722                else
723                {
724                    dir[a] = (dir[a] + 3) % 4;
725                    screen[ax[a] + width * ay[a]] = (a << 4) | 0x0f;
726                }
727                ax[a] = (width + ax[a] + steps[dir[a]][0]) % width;
728                ay[a] = (height + ay[a] + steps[dir[a]][1]) % height;
729            }
730        }
731        break;
732
733    case RENDER:
734        for(y = 0; y < height; y++)
735        {
736            for(x = 0; x < width; x++)
737            {
738                uint8_t p = screen[x + width * y];
739
740                if(p & 0x0f)
741                    cucul_set_color_ansi(cv, CUCUL_WHITE, p >> 4);
742                else
743                    cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
744                cucul_put_char(cv, x, y, gradient[p & 0x0f]);
745            }
746        }
747        break;
748
749    case FREE:
750        free(screen);
751        break;
752    }
753}
754
755/* Matrix effect */
756#define MAXDROPS 500
757#define MINLEN 15
758#define MAXLEN 30
759
760void matrix(enum action action, cucul_canvas_t *cv)
761{
762    static struct drop
763    {
764        int x, y, speed, len;
765        char str[MAXLEN];
766    }
767    drop[MAXDROPS];
768
769    int w, h, i, j;
770
771    switch(action)
772    {
773    case PREPARE:
774        for(i = 0; i < MAXDROPS; i++)
775        {
776            drop[i].x = cucul_rand(0, 1000);
777            drop[i].y = cucul_rand(0, 1000);
778            drop[i].speed = 5 + cucul_rand(0, 30);
779            drop[i].len = MINLEN + cucul_rand(0, (MAXLEN - MINLEN));
780            for(j = 0; j < MAXLEN; j++)
781                drop[i].str[j] = cucul_rand('0', 'z');
782        }
783        break;
784
785    case INIT:
786        break;
787
788    case UPDATE:
789        w = cucul_get_canvas_width(cv);
790        h = cucul_get_canvas_height(cv);
791
792        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
793        {
794            drop[i].y += drop[i].speed;
795            if(drop[i].y > 1000)
796            {
797                drop[i].y -= 1000;
798                drop[i].x = cucul_rand(0, 1000);
799            }
800        }
801        break;
802
803    case RENDER:
804        w = cucul_get_canvas_width(cv);
805        h = cucul_get_canvas_height(cv);
806
807        cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
808        cucul_clear_canvas(cv);
809
810        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
811        {
812            int x, y;
813
814            x = drop[i].x * w / 1000 / 2 * 2;
815            y = drop[i].y * (h + MAXLEN) / 1000;
816
817            for(j = 0; j < drop[i].len; j++)
818            {
819                unsigned int fg;
820
821                if(j < 2)
822                    fg = CUCUL_WHITE;
823                else if(j < drop[i].len / 4)
824                    fg = CUCUL_LIGHTGREEN;
825                else if(j < drop[i].len * 4 / 5)
826                    fg = CUCUL_GREEN;
827                else
828                    fg = CUCUL_DARKGRAY;
829                cucul_set_color_ansi(cv, fg, CUCUL_BLACK);
830
831                cucul_put_char(cv, x, y - j,
832                               drop[i].str[(y - j) % drop[i].len]);
833            }
834        }
835        break;
836
837    case FREE:
838        break;
839    }
840}
841
842
843#define TEXTURE_SIZE 256
844#define TABLE_SIZE 65536
845
846/* 24:8 Fixed point stuff */
847#define PRECISION 8
848
849#define FMUL(a, b) (((a)*(b))>>PRECISION)
850#define TOFIX(d)   ((int)( (d)*(double)(1<<PRECISION) ))
851#define TOINT(a)   (a>>PRECISION);
852
853
854#include "texture.h"
855
856void rotozoom(enum action action, cucul_canvas_t *canvas)
857{
858    static cucul_dither_t *dither;
859    static unsigned int *screen, *save;
860    static int alphaF, tF;
861    int scaleF;
862    static int *texture;
863    static int *cosTable;
864    static int *sinTable;
865    static int *yTable;
866
867
868
869    /* register is quite a bad idea on CISC, but not on RISC */
870    register unsigned int x, y;
871    register unsigned int xxF, yyF, uF, vF, uF_, vF_;
872    register unsigned int  vu, vv;
873
874    switch(action)
875    {
876    case INIT:
877
878        screen = (unsigned int*)malloc(4 * XSIZ * YSIZ
879                                       * sizeof(unsigned char));
880        dither = cucul_create_dither(32,
881                                     XSIZ, YSIZ,
882                                     XSIZ*4,
883                                     0x00FF0000,
884                                     0x0000FF00,
885                                     0x000000FF,
886                                     0x00000000);
887        save = screen;
888        texture = (int*) textureByte;
889
890        cosTable = malloc(TABLE_SIZE*sizeof(int));
891        sinTable = malloc(TABLE_SIZE*sizeof(int));
892        yTable = malloc(TEXTURE_SIZE*sizeof(int));
893
894        for(x=0; x<TABLE_SIZE; x++) {   /* Cos and Sin tables*/
895            cosTable[x] = TOFIX(cos(x*(360.0f/(float)TABLE_SIZE)));
896            sinTable[x] = TOFIX(sin(x*(360.0f/(float)TABLE_SIZE)));
897        }
898        for(x=0; x<TEXTURE_SIZE; x++) { /* start of lines offsets */
899            yTable[x] = x*TEXTURE_SIZE;
900        }
901
902        break;
903    case PREPARE:
904        break;
905    case UPDATE:
906
907        alphaF +=   4;
908        tF     +=   3;
909        scaleF =    (FMUL(sinTable[tF&0xFFFF], TOFIX(3)) + (TOFIX(5)));
910        xxF    =    FMUL(cosTable[(alphaF)&0xFFFF], scaleF);
911        yyF    =    FMUL(sinTable[(alphaF)&0xFFFF], scaleF);
912        uF  = vF  = 0;
913        uF_ = vF_ = 0;
914        screen = save;
915
916        y = YSIZ;
917        while(y--) {
918
919            x = XSIZ;
920            while(x--) {
921
922                uF+=xxF;
923                vF+=yyF;
924
925                vu = TOINT(uF);
926                vv = TOINT(vF);
927                vu&=0xFF;       /* ARM doesn't like    */
928                vv&=0xFF;       /* chars as local vars */
929
930                *screen++ = texture[vu+yTable[vv]];
931              }
932
933            uF = uF_ -= yyF;
934            vF = vF_ += xxF;
935        }
936
937        break;
938    case RENDER:
939        cucul_dither_bitmap(canvas, 0, 0,
940                            cucul_get_canvas_width(canvas),
941                            cucul_get_canvas_height(canvas),
942                            dither, save);
943        break;
944    case FREE:
945        free(cosTable);
946        free(sinTable);
947        free(save);
948        cucul_free_dither(dither);
949        break;
950    }
951
952}
Note: See TracBrowser for help on using the repository browser.