cacalabs
/
libcaca
kopia lustrzana https://github.com/cacalabs/libcaca.git
1
0
Forkuj 0
Kod Zgłoszenia 0 Wydania 7 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
85 Commity
1 Gałąź
284 MiB
 
 
 
 
 
 
Drzewo: b858ff9f50
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z 'b858ff9f50'
${ noResults }
libcaca/test/demo.c

433 wiersze
10 KiB
Czysty Wina Historia 

  1. /*

  2.  *   demo          demo using libee

  3.  *   Copyright (c) 2003 Sam Hocevar <sam@zoy.org>

  4.  *                 All Rights Reserved

  5.  *

  6.  *   $Id$

  7.  *

  8.  *   This program is free software; you can redistribute it and/or modify

  9.  *   it under the terms of the GNU General Public License as published by

  10.  *   the Free Software Foundation; either version 2 of the License, or

  11.  *   (at your option) any later version.

  12.  *

  13.  *   This program is distributed in the hope that it will be useful,

  14.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  16.  *   GNU General Public License for more details.

  17.  *

  18.  *   You should have received a copy of the GNU General Public License

  19.  *   along with this program; if not, write to the Free Software

  20.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  21.  */

  22. 

  23. #include "config.h"

  24. 

  25. #include <math.h>

  26. #include <string.h>

  27. #include <stdio.h>

  28. 

  29. #include "ee.h"

  30. 

  31. static void display_menu(void);

  32. 

  33. static void demo_all(void);

  34. 

  35. static void demo_color(void);

  36. static void demo_dots(void);

  37. static void demo_lines(void);

  38. static void demo_boxes(void);

  39. static void demo_ellipses(void);

  40. static void demo_triangles(void);

  41. static void demo_sprites(void);

  42. 

  43. int force_clipping = 0;

  44. int outline = 0;

  45. int thin = 0;

  46. struct ee_sprite *sprite = NULL;

  47. 

  48. int main(int argc, char **argv)

  49. {

  50.     void (*demo)(void) = NULL;

  51.     int quit = 0;

  52. 

  53.     if(ee_init())

  54.     {

  55.         return 1;

  56.     }

  57. 

  58.     ee_set_delay(40000);

  59. 

  60.     /* Initialize data */

  61.     sprite = ee_load_sprite("data/barboss.txt");

  62. 

  63.     /* Main menu */

  64.     display_menu();

  65. 

  66.     /* Go ! */

  67.     while(!quit)

  68.     {

  69.         char key = ee_get_key();

  70.         if(key && demo)

  71.         {

  72.             display_menu();

  73.             demo = NULL;

  74.         }

  75.         else if(key)

  76.         {

  77.             switch(key)

  78.             {

  79.             case 'q':

  80.                 demo = NULL;

  81.                 quit = 1;

  82.                 break;

  83.             case 'c':

  84.                 ee_clear();

  85.                 demo = demo_color;

  86.                 break;

  87.             case '0':

  88.                 ee_clear();

  89.                 demo = demo_all;

  90.                 break;

  91.             case '1':

  92.                 ee_clear();

  93.                 demo = demo_dots;

  94.                 break;

  95.             case '2':

  96.                 ee_clear();

  97.                 demo = demo_lines;

  98.                 thin = 0;

  99.                 break;

  100.             case '3':

  101.                 ee_clear();

  102.                 demo = demo_lines;

  103.                 thin = 1;

  104.                 break;

  105.             case '4':

  106.                 ee_clear();

  107.                 demo = demo_boxes;

  108.                 outline = 0;

  109.                 break;

  110.             case '5':

  111.                 ee_clear();

  112.                 demo = demo_boxes;

  113.                 outline = 1;

  114.                 break;

  115.             case '6':

  116.                 ee_clear();

  117.                 demo = demo_ellipses;

  118.                 break;

  119.             case '7':

  120.                 ee_clear();

  121.                 demo = demo_triangles;

  122.                 outline = 0;

  123.                 break;

  124.             case '8':

  125.                 ee_clear();

  126.                 demo = demo_triangles;

  127.                 outline = 1;

  128.                 break;

  129.             case '9':

  130.                 ee_clear();

  131.                 demo = demo_sprites;

  132.                 break;

  133.             }

  134.         }

  135. 

  136.         if(demo)

  137.             demo();

  138.     }

  139. 

  140.     /* Clean up */

  141.     ee_free_sprite(sprite);

  142.     ee_end();

  143. 

  144.     return 0;

  145. }

  146. 

  147. static void display_menu(void)

  148. {

  149.     int xo = ee_get_width() - 2;

  150.     int yo = ee_get_height() - 2;

  151. 

  152.     ee_clear();

  153.     ee_set_color(EE_WHITE);

  154.     ee_draw_thin_box(1, 1, xo, yo);

  155. 

  156.     ee_putstr((xo - strlen("libee demo")) / 2, 3, "libee demo");

  157.     ee_putstr((xo - strlen("============")) / 2, 4, "============");

  158. 

  159.     ee_putstr(4, 6, "0: complete demo");

  160.     ee_putstr(4, 7, "1: dots demo");

  161.     ee_putstr(4, 8, "2: lines demo");

  162.     ee_putstr(4, 9, "3: thin lines demo");

  163.     ee_putstr(4, 10, "4: boxes demo");

  164.     ee_putstr(4, 11, "5: outlined boxes demo");

  165.     ee_putstr(4, 12, "6: ellipses demo");

  166.     ee_putstr(4, 13, "7: triangles demo");

  167.     ee_putstr(4, 14, "8: outlined triangles demo");

  168.     ee_putstr(4, 15, "9: sprites demo");

  169. 

  170.     ee_putstr(4, yo - 2, "q: quit");

  171. 

  172.     ee_refresh();

  173. }

  174. 

  175. static void demo_all(void)

  176. {

  177.     static int i = 0;

  178. 

  179.     int j, xo, yo, xa, ya, xb, yb, xc, yc;

  180. 

  181.     i++;

  182. 

  183.     ee_clear();

  184. 

  185.     /* Draw the sun */

  186.     ee_set_color(EE_YELLOW);

  187.     xo = ee_get_width() / 4;

  188.     yo = ee_get_height() / 4 + 5 * sin(0.03*i);

  189. 

  190.     for(j = 0; j < 16; j++)

  191.     {

  192.         xa = xo - (30 + sin(0.03*i) * 8) * sin(0.03*i + M_PI*j/8);

  193.         ya = yo + (15 + sin(0.03*i) * 4) * cos(0.03*i + M_PI*j/8);

  194.         ee_draw_thin_line(xo, yo, xa, ya);

  195.     }

  196. 

  197.     j = 15 + sin(0.03*i) * 8;

  198.     ee_set_color(EE_WHITE);

  199.     ee_fill_ellipse(xo, yo, j, j / 2, '#');

  200.     ee_set_color(EE_YELLOW);

  201.     ee_draw_ellipse(xo, yo, j, j / 2, '#');

  202. 

  203.     /* Draw the pyramid */

  204.     xo = ee_get_width() * 5 / 8;

  205.     yo = 2;

  206. 

  207.     xa = ee_get_width() / 8 + sin(0.03*i) * 5;

  208.     ya = ee_get_height() / 2 + cos(0.03*i) * 5;

  209. 

  210.     xb = ee_get_width() - 10 - cos(0.02*i) * 10;

  211.     yb = ee_get_height() * 3 / 4 - 5 + sin(0.02*i) * 5;

  212. 

  213.     xc = ee_get_width() / 4 - sin(0.02*i) * 5;

  214.     yc = ee_get_height() * 3 / 4 + cos(0.02*i) * 5;

  215. 

  216.     ee_set_color(EE_GREEN);

  217.     ee_fill_triangle(xo, yo, xb, yb, xa, ya, '%');

  218.     ee_set_color(EE_YELLOW);

  219.     ee_draw_thin_triangle(xo, yo, xb, yb, xa, ya);

  220. 

  221.     ee_set_color(EE_RED);

  222.     ee_fill_triangle(xa, ya, xb, yb, xc, yc, '#');

  223.     ee_set_color(EE_YELLOW);

  224.     ee_draw_thin_triangle(xa, ya, xb, yb, xc, yc);

  225. 

  226.     ee_set_color(EE_BLUE);

  227.     ee_fill_triangle(xo, yo, xb, yb, xc, yc, '%');

  228.     ee_set_color(EE_YELLOW);

  229.     ee_draw_thin_triangle(xo, yo, xb, yb, xc, yc);

  230. 

  231.     /* Draw a background triangle */

  232.     xa = 2;

  233.     ya = 2;

  234. 

  235.     xb = ee_get_width() - 3;

  236.     yb = ee_get_height() / 2;

  237. 

  238.     xc = ee_get_width() / 3;

  239.     yc = ee_get_height() - 3;

  240. 

  241.     ee_set_color(EE_CYAN);

  242.     ee_draw_thin_triangle(xa, ya, xb, yb, xc, yc);

  243. 

  244.     xo = ee_get_width() / 2 + cos(0.027*i) * ee_get_width() / 3;

  245.     yo = ee_get_height() / 2 - sin(0.027*i) * ee_get_height() / 2;

  246. 

  247.     ee_draw_thin_line(xa, ya, xo, yo);

  248.     ee_draw_thin_line(xb, yb, xo, yo);

  249.     ee_draw_thin_line(xc, yc, xo, yo);

  250. 

  251.     /* Draw a sprite on the pyramid */

  252.     ee_draw_sprite(xo, yo, sprite, 0);

  253. 

  254.     /* Draw a trail behind the foreground sprite */

  255.     for(j = i - 60; j < i; j++)

  256.     {

  257.         int delta = ee_rand(-5, 5);

  258.         ee_set_color(ee_rand(0, 15));

  259.         ee_putchar(ee_get_width() / 2

  260.                     + cos(0.02*j) * (delta + ee_get_width() / 4),

  261.                    ee_get_height() / 2

  262.                     + sin(0.02*j) * (delta + ee_get_height() / 3),

  263.                    '#');

  264.     }

  265. 

  266.     /* Draw foreground sprite */

  267.     ee_draw_sprite(ee_get_width() / 2 + cos(0.02*i) * ee_get_width() / 4,

  268.                    ee_get_height() / 2 + sin(0.02*i) * ee_get_height() / 3,

  269.                    sprite, 0);

  270. 

  271.     ee_refresh();

  272. }

  273. 

  274. static void demo_dots(void)

  275. {

  276.     int xmax = ee_get_width() - 1;

  277.     int ymax = ee_get_height() - 1;

  278.     int i;

  279. 

  280.     for(i = 1000; i--;)

  281.     {

  282.         /* Putpixel */

  283.         ee_set_color(ee_rand(0, 15));

  284.         ee_putchar(ee_rand(0, xmax), ee_rand(0, ymax), '#');

  285.     }

  286.     ee_refresh();

  287. }

  288. 

  289. static void demo_color(void)

  290. {

  291.     int i;

  292.     char buf[BUFSIZ];

  293. 

  294.     ee_clear();

  295.     for(i = 0; i < 16; i++)

  296.     {

  297.         sprintf(buf, "'%c': %i (%s)", 'a' + i, i, ee_color_names[i]);

  298.         ee_set_color(EE_WHITE);

  299.         ee_putstr(4, i + 3, buf);

  300.         ee_set_color(i);

  301.         ee_putstr(40, i + 3, "XXXXXXXXXX-XX--X----------");

  302.     }

  303.     ee_refresh();

  304. }

  305. 

  306. static void demo_lines(void)

  307. {

  308.     int w = ee_get_width();

  309.     int h = ee_get_height();

  310.     int xa, ya, xb, yb;

  311. 

  312.     if(force_clipping)

  313.     {

  314.         xa = ee_rand(- w, 2 * w); ya = ee_rand(- h, 2 * h);

  315.         xb = ee_rand(- w, 2 * w); yb = ee_rand(- h, 2 * h);

  316.     }

  317.     else

  318.     {

  319.         xa = ee_rand(0, w - 1); ya = ee_rand(0, h - 1);

  320.         xb = ee_rand(0, w - 1); yb = ee_rand(0, h - 1);

  321.     }

  322. 

  323.     ee_set_color(ee_rand(0, 15));

  324.     if(thin)

  325.         ee_draw_thin_line(xa, ya, xb, yb);

  326.     else

  327.         ee_draw_line(xa, ya, xb, yb, '#');

  328. 

  329.     ee_refresh();

  330. }

  331. 

  332. static void demo_boxes(void)

  333. {

  334.     int w = ee_get_width();

  335.     int h = ee_get_height();

  336.     int xa, ya, xb, yb;

  337. 

  338.     if(force_clipping)

  339.     {

  340.         xa = ee_rand(- w, 2 * w); ya = ee_rand(- h, 2 * h);

  341.         xb = ee_rand(- w, 2 * w); yb = ee_rand(- h, 2 * h);

  342.     }

  343.     else

  344.     {

  345.         xa = ee_rand(0, w - 1); ya = ee_rand(0, h - 1);

  346.         xb = ee_rand(0, w - 1); yb = ee_rand(0, h - 1);

  347.     }

  348. 

  349.     ee_set_color(ee_rand(0, 15));

  350.     ee_fill_box(xa, ya, xb, yb, '#');

  351. 

  352.     if(outline)

  353.     {

  354.         ee_set_color(ee_rand(0, 15));

  355.         ee_draw_thin_box(xa, ya, xb, yb);

  356.     }

  357. 

  358.     ee_refresh();

  359. }

  360. 

  361. static void demo_ellipses(void)

  362. {

  363.     int w = ee_get_width();

  364.     int h = ee_get_height();

  365.     int x, y, a, b;

  366. 

  367.     if(force_clipping)

  368.     {

  369.         x = ee_rand(- w, 2 * w); y = ee_rand(- h, 2 * h);

  370.         a = ee_rand(0, w); b = ee_rand(0, h);

  371.     }

  372.     else

  373.     {

  374.         do

  375.         {

  376.             x = ee_rand(0, w); y = ee_rand(0, h);

  377.             a = ee_rand(0, w); b = ee_rand(0, h);

  378. 

  379.         } while(x - a < 0 || x + a >= w || y - b < 0 || y + b >= h);

  380.     }

  381. 

  382.     ee_set_color(ee_rand(0, 15));

  383.     ee_fill_ellipse(x, y, a, b, '#');

  384. 

  385.     if(outline)

  386.     {

  387.         ee_set_color(ee_rand(0, 15));

  388.         ee_draw_thin_ellipse(x, y, a, b);

  389.     }

  390. 

  391.     ee_refresh();

  392. }

  393. 

  394. static void demo_triangles(void)

  395. {

  396.     int w = ee_get_width();

  397.     int h = ee_get_height();

  398.     int xa, ya, xb, yb, xc, yc;

  399. 

  400.     if(force_clipping)

  401.     {

  402.         xa = ee_rand(- w, 2 * w); ya = ee_rand(- h, 2 * h);

  403.         xb = ee_rand(- w, 2 * w); yb = ee_rand(- h, 2 * h);

  404.         xc = ee_rand(- w, 2 * w); yc = ee_rand(- h, 2 * h);

  405.     }

  406.     else

  407.     {

  408. 

  409.         xa = ee_rand(0, w - 1); ya = ee_rand(0, h - 1);

  410.         xb = ee_rand(0, w - 1); yb = ee_rand(0, h - 1);

  411.         xc = ee_rand(0, w - 1); yc = ee_rand(0, h - 1);

  412.     }

  413. 

  414.     ee_set_color(ee_rand(0, 15));

  415.     ee_fill_triangle(xa, ya, xb, yb, xc, yc, '#');

  416. 

  417.     if(outline)

  418.     {

  419.         ee_set_color(ee_rand(0, 15));

  420.         ee_draw_thin_triangle(xa, ya, xb, yb, xc, yc);

  421.     }

  422. 

  423.     ee_refresh();

  424. }

  425. 

  426. static void demo_sprites(void)

  427. {

  428.     ee_draw_sprite(ee_rand(0, ee_get_width() - 1),

  429.                    ee_rand(0, ee_get_height() - 1), sprite, 0);

  430.     ee_refresh();

  431. }