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

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