Ignore:
Timestamp:
Sep 27, 2008, 3:12:46 PM (12 years ago)
Author:
Sam Hocevar
Message:

Starting refactoring to get rid of libcucul. The initial reason for the
split is rendered moot by the plugin system: when enabled, binaries do
not link directly with libX11 or libGL. I hope this is a step towards
more consisteny and clarity.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/src/cacademo.c

    r2399 r2821  
    2727#endif
    2828
    29 #include "cucul.h"
    3029#include "caca.h"
    3130
    3231enum action { PREPARE, INIT, UPDATE, RENDER, FREE };
    3332
    34 void transition(cucul_canvas_t *, int, int);
    35 void plasma(enum action, cucul_canvas_t *);
    36 void metaballs(enum action, cucul_canvas_t *);
    37 void moire(enum action, cucul_canvas_t *);
    38 void langton(enum action, cucul_canvas_t *);
    39 void matrix(enum action, cucul_canvas_t *);
    40 void rotozoom(enum action, cucul_canvas_t *);
    41 
    42 void (*fn[])(enum action, cucul_canvas_t *) =
     33void transition(caca_canvas_t *, int, int);
     34void plasma(enum action, caca_canvas_t *);
     35void metaballs(enum action, caca_canvas_t *);
     36void moire(enum action, caca_canvas_t *);
     37void langton(enum action, caca_canvas_t *);
     38void matrix(enum action, caca_canvas_t *);
     39void rotozoom(enum action, caca_canvas_t *);
     40
     41void (*fn[])(enum action, caca_canvas_t *) =
    4342{
    4443    plasma,
     
    5150#define DEMOS (sizeof(fn)/sizeof(*fn))
    5251
    53 #define DEMO_FRAMES cucul_rand(500, 1000)
     52#define DEMO_FRAMES caca_rand(500, 1000)
    5453#define TRANSITION_FRAMES 40
    5554
     
    7170{
    7271    static caca_display_t *dp;
    73     static cucul_canvas_t *frontcv, *backcv, *mask;
     72    static caca_canvas_t *frontcv, *backcv, *mask;
    7473
    7574    int demo, next = -1, paused = 0, next_transition = DEMO_FRAMES;
    7675    unsigned int i;
    77     int tmode = cucul_rand(0, TRANSITION_COUNT);
     76    int tmode = caca_rand(0, TRANSITION_COUNT);
    7877
    7978    /* Set up two canvases, a mask, and attach a display to the front one */
    80     frontcv = cucul_create_canvas(0, 0);
    81     backcv = cucul_create_canvas(0, 0);
    82     mask = cucul_create_canvas(0, 0);
     79    frontcv = caca_create_canvas(0, 0);
     80    backcv = caca_create_canvas(0, 0);
     81    mask = caca_create_canvas(0, 0);
    8382
    8483    dp = caca_create_display(frontcv);
     
    8685        return 1;
    8786
    88     cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
    89                                   cucul_get_canvas_height(frontcv));
    90     cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
    91                                 cucul_get_canvas_height(frontcv));
     87    caca_set_canvas_size(backcv, caca_get_canvas_width(frontcv),
     88                                  caca_get_canvas_height(frontcv));
     89    caca_set_canvas_size(mask, caca_get_canvas_width(frontcv),
     90                                caca_get_canvas_height(frontcv));
    9291
    9392    caca_set_display_time(dp, 20000);
     
    9897
    9998    /* Choose a demo at random */
    100     demo = cucul_rand(0, DEMOS);
     99    demo = caca_rand(0, DEMOS);
    101100    fn[demo](INIT, frontcv);
    102101
     
    128127
    129128        /* Resize the spare canvas, just in case the main one changed */
    130         cucul_set_canvas_size(backcv, cucul_get_canvas_width(frontcv),
    131                                       cucul_get_canvas_height(frontcv));
    132         cucul_set_canvas_size(mask, cucul_get_canvas_width(frontcv),
    133                                     cucul_get_canvas_height(frontcv));
     129        caca_set_canvas_size(backcv, caca_get_canvas_width(frontcv),
     130                                      caca_get_canvas_height(frontcv));
     131        caca_set_canvas_size(mask, caca_get_canvas_width(frontcv),
     132                                    caca_get_canvas_height(frontcv));
    134133
    135134        if(paused)
     
    142141        if(frame == next_transition)
    143142        {
    144             next = cucul_rand(0, DEMOS);
     143            next = caca_rand(0, DEMOS);
    145144            if(next == demo)
    146145                next = (next + 1) % DEMOS;
     
    153152            next = -1;
    154153            next_transition = frame + DEMO_FRAMES;
    155             tmode = cucul_rand(0, TRANSITION_COUNT);
     154            tmode = caca_rand(0, TRANSITION_COUNT);
    156155        }
    157156
     
    168167        {
    169168            fn[next](RENDER, backcv);
    170             cucul_set_color_ansi(mask, CUCUL_LIGHTGRAY, CUCUL_BLACK);
    171             cucul_clear_canvas(mask);
    172             cucul_set_color_ansi(mask, CUCUL_WHITE, CUCUL_WHITE);
     169            caca_set_color_ansi(mask, CACA_LIGHTGRAY, CACA_BLACK);
     170            caca_clear_canvas(mask);
     171            caca_set_color_ansi(mask, CACA_WHITE, CACA_WHITE);
    173172            transition(mask, tmode,
    174173                       100 * (frame - next_transition) / TRANSITION_FRAMES);
    175             cucul_blit(frontcv, 0, 0, backcv, mask);
    176         }
    177 
    178         cucul_set_color_ansi(frontcv, CUCUL_WHITE, CUCUL_BLUE);
     174            caca_blit(frontcv, 0, 0, backcv, mask);
     175        }
     176
     177        caca_set_color_ansi(frontcv, CACA_WHITE, CACA_BLUE);
    179178        if(frame < 100)
    180             cucul_put_str(frontcv, cucul_get_canvas_width(frontcv) - 30,
    181                                    cucul_get_canvas_height(frontcv) - 2,
     179            caca_put_str(frontcv, caca_get_canvas_width(frontcv) - 30,
     180                                   caca_get_canvas_height(frontcv) - 2,
    182181                                   " -=[ Powered by libcaca ]=- ");
    183182        caca_refresh_display(dp);
     
    189188
    190189    caca_free_display(dp);
    191     cucul_free_canvas(mask);
    192     cucul_free_canvas(backcv);
    193     cucul_free_canvas(frontcv);
     190    caca_free_canvas(mask);
     191    caca_free_canvas(backcv);
     192    caca_free_canvas(frontcv);
    194193
    195194    return 0;
     
    197196
    198197/* Transitions */
    199 void transition(cucul_canvas_t *mask, int tmode, int completed)
     198void transition(caca_canvas_t *mask, int tmode, int completed)
    200199{
    201200    static float const star[] =
     
    224223    static float square_rot[sizeof(square)/sizeof(*square)];
    225224
    226     float mulx = 0.0075f * completed * cucul_get_canvas_width(mask);
    227     float muly = 0.0075f * completed * cucul_get_canvas_height(mask);
    228     int w2 = cucul_get_canvas_width(mask) / 2;
    229     int h2 = cucul_get_canvas_height(mask) / 2;
     225    float mulx = 0.0075f * completed * caca_get_canvas_width(mask);
     226    float muly = 0.0075f * completed * caca_get_canvas_height(mask);
     227    int w2 = caca_get_canvas_width(mask) / 2;
     228    int h2 = caca_get_canvas_height(mask) / 2;
    230229    float angle = (0.0075f * completed * 360) * 3.14 / 180, x, y;
    231230    unsigned int i;
    232     int w = cucul_get_canvas_width(mask);
    233     int h = cucul_get_canvas_height(mask);
     231    int w = caca_get_canvas_width(mask);
     232    int h = caca_get_canvas_height(mask);
    234233
    235234    switch(tmode)
     
    248247            mulx *= 1.8;
    249248            muly *= 1.8;
    250             cucul_fill_triangle(mask,
     249            caca_fill_triangle(mask,
    251250                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
    252251                                square_rot[1*2] * mulx + w2, square_rot[1*2+1] * muly + h2, \
    253252                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, '#');
    254             cucul_fill_triangle(mask,
     253            caca_fill_triangle(mask,
    255254                                square_rot[0*2] * mulx + w2, square_rot[0*2+1] * muly + h2, \
    256255                                square_rot[2*2] * mulx + w2, square_rot[2*2+1] * muly + h2, \
     
    274273
    275274#define DO_TRI(a, b, c) \
    276     cucul_fill_triangle(mask, \
     275    caca_fill_triangle(mask, \
    277276        star_rot[(a)*2] * mulx + w2, star_rot[(a)*2+1] * muly + h2, \
    278277        star_rot[(b)*2] * mulx + w2, star_rot[(b)*2+1] * muly + h2, \
     
    289288
    290289        case TRANSITION_CIRCLE:
    291             cucul_fill_ellipse(mask, w2, h2, mulx, muly, '#');
     290            caca_fill_ellipse(mask, w2, h2, mulx, muly, '#');
    292291            break;
    293292
     
    296295            {
    297296                int z = ((i & 1) ? w : (-w)/2) * (100 - completed) / 100;
    298                 cucul_fill_box(mask, i * w / 8, z ,  (w / 8) + 1, z + h, '#');
     297                caca_fill_box(mask, i * w / 8, z ,  (w / 8) + 1, z + h, '#');
    299298            }
    300299            break;
     
    305304            {
    306305                int z = ((i & 1) ? w : (-w)/2) * (100 - completed) / 100;
    307                 cucul_fill_box(mask, z, i * h / 6, z + w, (h / 6) + 1, '#');
     306                caca_fill_box(mask, z, i * h / 6, z + w, (h / 6) + 1, '#');
    308307            }
    309308            break;
     
    319318                      double, double, double, double, double, double);
    320319
    321 void plasma(enum action action, cucul_canvas_t *cv)
    322 {
    323     static cucul_dither_t *dither;
     320void plasma(enum action action, caca_canvas_t *cv)
     321{
     322    static caca_dither_t *dither;
    324323    static uint8_t *screen;
    325324    static uint32_t red[256], green[256], blue[256], alpha[256];
     
    336335
    337336        for(i = 0; i < 3; i++)
    338             r[i] = (double)(cucul_rand(1, 1000)) / 60000 * M_PI;
     337            r[i] = (double)(caca_rand(1, 1000)) / 60000 * M_PI;
    339338
    340339        for(i = 0; i < 6; i++)
    341             R[i] = (double)(cucul_rand(1, 1000)) / 10000;
     340            R[i] = (double)(caca_rand(1, 1000)) / 10000;
    342341
    343342        for(y = 0 ; y < TABLEY ; y++)
     
    354353    case INIT:
    355354        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    356         dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
     355        dither = caca_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
    357356        break;
    358357
     
    368367
    369368        /* Set the palette */
    370         cucul_set_dither_palette(dither, red, green, blue, alpha);
     369        caca_set_dither_palette(dither, red, green, blue, alpha);
    371370
    372371        do_plasma(screen,
     
    380379
    381380    case RENDER:
    382         cucul_dither_bitmap(cv, 0, 0,
    383                             cucul_get_canvas_width(cv),
    384                             cucul_get_canvas_height(cv),
     381        caca_dither_bitmap(cv, 0, 0,
     382                            caca_get_canvas_width(cv),
     383                            caca_get_canvas_height(cv),
    385384                            dither, screen);
    386385        break;
     
    388387    case FREE:
    389388        free(screen);
    390         cucul_free_dither(dither);
     389        caca_free_dither(dither);
    391390        break;
    392391    }
     
    426425static void draw_ball(uint8_t *, unsigned int, unsigned int);
    427426
    428 void metaballs(enum action action, cucul_canvas_t *cv)
    429 {
    430     static cucul_dither_t *cucul_dither;
     427void metaballs(enum action action, caca_canvas_t *cv)
     428{
     429    static caca_dither_t *caca_dither;
    431430    static uint8_t *screen;
    432431    static uint32_t r[256], g[256], b[256], a[256];
     
    452451        for(n = 0; n < METABALLS; n++)
    453452        {
    454             dd[n] = cucul_rand(0, 100);
    455             di[n] = (float)cucul_rand(500, 4000) / 6000.0;
    456             dj[n] = (float)cucul_rand(500, 4000) / 6000.0;
    457             dk[n] = (float)cucul_rand(500, 4000) / 6000.0;
    458         }
    459 
    460         angleoff = cucul_rand(0, 360);
     453            dd[n] = caca_rand(0, 100);
     454            di[n] = (float)caca_rand(500, 4000) / 6000.0;
     455            dj[n] = (float)caca_rand(500, 4000) / 6000.0;
     456            dk[n] = (float)caca_rand(500, 4000) / 6000.0;
     457        }
     458
     459        angleoff = caca_rand(0, 360);
    461460
    462461        for(n = 0; n < 360 + 80; n++)
     
    466465    case INIT:
    467466        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    468         /* Create a libcucul dither smaller than our pixel buffer, so that we
     467        /* Create a libcaca dither smaller than our pixel buffer, so that we
    469468         * display only the interesting part of it */
    470         cucul_dither = cucul_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE,
     469        caca_dither = caca_create_dither(8, XSIZ - METASIZE, YSIZ - METASIZE,
    471470                                           XSIZ, 0, 0, 0, 0);
    472471        break;
     
    493492
    494493        /* Set the palette */
    495         cucul_set_dither_palette(cucul_dither, r, g, b, a);
     494        caca_set_dither_palette(caca_dither, r, g, b, a);
    496495
    497496        /* Silly paths for our balls */
     
    517516
    518517    case RENDER:
    519         cucul_dither_bitmap(cv, 0, 0,
    520                           cucul_get_canvas_width(cv),
    521                           cucul_get_canvas_height(cv),
    522                           cucul_dither, screen + (METASIZE / 2) * (1 + XSIZ));
     518        caca_dither_bitmap(cv, 0, 0,
     519                          caca_get_canvas_width(cv),
     520                          caca_get_canvas_height(cv),
     521                          caca_dither, screen + (METASIZE / 2) * (1 + XSIZ));
    523522        break;
    524523
    525524    case FREE:
    526525        free(screen);
    527         cucul_free_dither(cucul_dither);
     526        caca_free_dither(caca_dither);
    528527        break;
    529528    }
     
    577576static void draw_line(int, int, char);
    578577
    579 void moire(enum action action, cucul_canvas_t *cv)
    580 {
    581     static cucul_dither_t *dither;
     578void moire(enum action action, caca_canvas_t *cv)
     579{
     580    static caca_dither_t *dither;
    582581    static uint8_t *screen;
    583582    static float d[6];
     
    594593
    595594        for(i = 0; i < 6; i++)
    596             d[i] = ((float)cucul_rand(50, 70)) / 1000.0;
     595            d[i] = ((float)caca_rand(50, 70)) / 1000.0;
    597596
    598597        red[0] = green[0] = blue[0] = 0x777;
     
    617616    case INIT:
    618617        screen = malloc(XSIZ * YSIZ * sizeof(uint8_t));
    619         dither = cucul_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
     618        dither = caca_create_dither(8, XSIZ, YSIZ, XSIZ, 0, 0, 0, 0);
    620619        break;
    621620
     
    632631        blue[1] = 0.5 * (1 + cos(d[5] * (frame + 4000))) * 0xfff;
    633632
    634         cucul_set_dither_palette(dither, red, green, blue, alpha);
     633        caca_set_dither_palette(dither, red, green, blue, alpha);
    635634
    636635        /* Draw circles */
     
    645644
    646645    case RENDER:
    647         cucul_dither_bitmap(cv, 0, 0,
    648                             cucul_get_canvas_width(cv),
    649                             cucul_get_canvas_height(cv),
     646        caca_dither_bitmap(cv, 0, 0,
     647                            caca_get_canvas_width(cv),
     648                            caca_get_canvas_height(cv),
    650649                            dither, screen);
    651650        break;
     
    653652    case FREE:
    654653        free(screen);
    655         cucul_free_dither(dither);
     654        caca_free_dither(dither);
    656655        break;
    657656    }
     
    688687#define ITER 2
    689688
    690 void langton(enum action action, cucul_canvas_t *cv)
     689void langton(enum action action, caca_canvas_t *cv)
    691690{
    692691    static char gradient[] =
     
    705704    {
    706705    case PREPARE:
    707         width = cucul_get_canvas_width(cv);
    708         height = cucul_get_canvas_height(cv);
     706        width = caca_get_canvas_width(cv);
     707        height = caca_get_canvas_height(cv);
    709708        for(i = 0; i < ANTS; i++)
    710709        {
    711             ax[i] = cucul_rand(0, width);
    712             ay[i] = cucul_rand(0, height);
    713             dir[i] = cucul_rand(0, 4);
     710            ax[i] = caca_rand(0, width);
     711            ay[i] = caca_rand(0, height);
     712            dir[i] = caca_rand(0, 4);
    714713        }
    715714        break;
     
    758757
    759758                if(p & 0x0f)
    760                     cucul_set_color_ansi(cv, CUCUL_WHITE, p >> 4);
     759                    caca_set_color_ansi(cv, CACA_WHITE, p >> 4);
    761760                else
    762                     cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
    763                 cucul_put_char(cv, x, y, gradient[p & 0x0f]);
     761                    caca_set_color_ansi(cv, CACA_BLACK, CACA_BLACK);
     762                caca_put_char(cv, x, y, gradient[p & 0x0f]);
    764763            }
    765764        }
     
    777776#define MAXLEN 30
    778777
    779 void matrix(enum action action, cucul_canvas_t *cv)
     778void matrix(enum action action, caca_canvas_t *cv)
    780779{
    781780    static struct drop
     
    793792        for(i = 0; i < MAXDROPS; i++)
    794793        {
    795             drop[i].x = cucul_rand(0, 1000);
    796             drop[i].y = cucul_rand(0, 1000);
    797             drop[i].speed = 5 + cucul_rand(0, 30);
    798             drop[i].len = MINLEN + cucul_rand(0, (MAXLEN - MINLEN));
     794            drop[i].x = caca_rand(0, 1000);
     795            drop[i].y = caca_rand(0, 1000);
     796            drop[i].speed = 5 + caca_rand(0, 30);
     797            drop[i].len = MINLEN + caca_rand(0, (MAXLEN - MINLEN));
    799798            for(j = 0; j < MAXLEN; j++)
    800                 drop[i].str[j] = cucul_rand('0', 'z');
     799                drop[i].str[j] = caca_rand('0', 'z');
    801800        }
    802801        break;
     
    806805
    807806    case UPDATE:
    808         w = cucul_get_canvas_width(cv);
    809         h = cucul_get_canvas_height(cv);
     807        w = caca_get_canvas_width(cv);
     808        h = caca_get_canvas_height(cv);
    810809
    811810        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
     
    815814            {
    816815                drop[i].y -= 1000;
    817                 drop[i].x = cucul_rand(0, 1000);
     816                drop[i].x = caca_rand(0, 1000);
    818817            }
    819818        }
     
    821820
    822821    case RENDER:
    823         w = cucul_get_canvas_width(cv);
    824         h = cucul_get_canvas_height(cv);
    825 
    826         cucul_set_color_ansi(cv, CUCUL_BLACK, CUCUL_BLACK);
    827         cucul_clear_canvas(cv);
     822        w = caca_get_canvas_width(cv);
     823        h = caca_get_canvas_height(cv);
     824
     825        caca_set_color_ansi(cv, CACA_BLACK, CACA_BLACK);
     826        caca_clear_canvas(cv);
    828827
    829828        for(i = 0; i < MAXDROPS && i < (w * h / 32); i++)
     
    839838
    840839                if(j < 2)
    841                     fg = CUCUL_WHITE;
     840                    fg = CACA_WHITE;
    842841                else if(j < drop[i].len / 4)
    843                     fg = CUCUL_LIGHTGREEN;
     842                    fg = CACA_LIGHTGREEN;
    844843                else if(j < drop[i].len * 4 / 5)
    845                     fg = CUCUL_GREEN;
     844                    fg = CACA_GREEN;
    846845                else
    847                     fg = CUCUL_DARKGRAY;
    848                 cucul_set_color_ansi(cv, fg, CUCUL_BLACK);
    849 
    850                 cucul_put_char(cv, x, y - j,
     846                    fg = CACA_DARKGRAY;
     847                caca_set_color_ansi(cv, fg, CACA_BLACK);
     848
     849                caca_put_char(cv, x, y - j,
    851850                               drop[i].str[(y - j) % drop[i].len]);
    852851            }
     
    872871#include "texture.h"
    873872
    874 void rotozoom(enum action action, cucul_canvas_t *canvas)
     873void rotozoom(enum action action, caca_canvas_t *canvas)
    875874{
    876875    static uint32_t screen[XSIZ * YSIZ];
     
    878877    static int y_tab[TEXTURE_SIZE];
    879878
    880     static cucul_dither_t *dither;
     879    static caca_dither_t *dither;
    881880    static uint32_t *texture;
    882881    uint32_t *p;
     
    904903
    905904    case INIT:
    906         dither = cucul_create_dither(32, XSIZ, YSIZ, XSIZ * 4,
     905        dither = caca_create_dither(32, XSIZ, YSIZ, XSIZ * 4,
    907906                                     0x00FF0000,
    908907                                     0x0000FF00,
     
    942941
    943942    case RENDER:
    944         cucul_dither_bitmap(canvas, 0, 0,
    945                             cucul_get_canvas_width(canvas),
    946                             cucul_get_canvas_height(canvas),
     943        caca_dither_bitmap(canvas, 0, 0,
     944                            caca_get_canvas_width(canvas),
     945                            caca_get_canvas_height(canvas),
    947946                            dither, screen);
    948947        break;
    949948
    950949    case FREE:
    951         cucul_free_dither(dither);
    952         break;
    953     }
    954 }
    955 
     950        caca_free_dither(dither);
     951        break;
     952    }
     953}
     954
Note: See TracChangeset for help on using the changeset viewer.