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

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