home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / demos / scrolltest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-27  |  5.9 KB  |  298 lines
  1. /*
  2.     Animation/smooth scrolling demo, uses Mode X/page flipping and
  3.     linear virtual screen in system memory.
  4.  
  5.     First method copies window to page-flipped Mode X-style video memory
  6.     for scrolling.
  7.     Linear addressing, and page flipping (no shearing) and triple
  8.     buffering, but relatively slow.
  9.  
  10.     Second method uses Mode X-style hardware scrolling.
  11.     Limited logical screen size, page flipping if no scrolling, tricky and
  12.     slow animation, scrolling fast (page flipping with scrolling is very
  13.     tricky).
  14.  
  15.     Third method copies window to linear "Mode 13h" video memory.
  16.     Linear addressing, no page flipping (scrolling looks bad), speed
  17.     depends    on bus (fast on a good ISA card; very fast on VLB).
  18.     Some SVGA cards can support page-flipping in linear 320x200x256.
  19.  
  20.     Adding animated objects is trivial with the virtual screen methods (1
  21.     and 3).
  22. */
  23.  
  24.  
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. #include <time.h>
  28. #include <vga.h>
  29. #include <vgagl.h>
  30.  
  31.  
  32. /* Virtual screen size. */
  33. /* Limited to 256K by hardware scrolling method (automatically clipped). */
  34. /* Width must be multiple of 8. */
  35. #define VWIDTH 640
  36. #define VHEIGHT 400
  37.  
  38. /* Scrolling window size for system memory virtual screen demo. */
  39. #define WINWIDTH 320
  40. #define WINHEIGHT 200
  41.  
  42. /* Define this to use triple-buffering in first method. */
  43. /* #define TRIPLEBUFFERING */
  44.  
  45.  
  46. unsigned char *vbuf;
  47.  
  48.  
  49. void boxes() {
  50.     int x, y;
  51.     for (x = 0; x <= VWIDTH - 8; x += 8)
  52.         for (y = 0; y <= VHEIGHT - 8; y += 8) {
  53.             int r, g, b;
  54.             /* Draw red tiles. */
  55.             r = rand() & 255;
  56.             b = 0;
  57.             g = 0;
  58.             if ((rand() & 15) == 15) {    /* Add occasional */
  59.                 r = 0;            /* blue specks. */
  60.                 b = rand() & 127;
  61.             }
  62.             gl_fillbox(x, y, 7, 7, gl_rgbcolor(r, g, b));
  63.         }
  64. }
  65.  
  66.  
  67. void demo1() {
  68.     int x, y;
  69.     int targetx, targety;
  70.     int pageoffset[3] = {
  71.         0,
  72.         320 * 240 / 4,
  73.         2 * 320 * 240 / 4
  74.     };
  75.     int writepage;
  76.     int count, startclock;
  77.  
  78.     /* Window coordinate initially at center. */
  79.     x = VWIDTH / 2 - WINWIDTH / 2;
  80.     y = VHEIGHT / 2 - WINHEIGHT / 2;
  81.     targetx = x;
  82.     targety = y;
  83.  
  84.     /* Page flipping initialization. */
  85.     vga_setdisplaystart(0);        /* Display page 0, write to page 1. */
  86.     writepage = 1;
  87.  
  88.     count = 0;
  89.     startclock = clock();
  90.  
  91.     for (;;) {
  92.         /* Copy window to screen. */
  93.         vga_copytoplanar256(vbuf + y * WIDTH + x, WIDTH,
  94.             pageoffset[writepage], 80, WINWIDTH, WINHEIGHT);
  95.  
  96.         /* Flip pages. */
  97.         vga_setdisplaystart(pageoffset[writepage] * 4);
  98.  
  99.         #ifndef TRIPLEBUFFERING
  100.         /* Conventional double-buffering (page-flipping). */
  101.         vga_waitretrace();
  102.         writepage ^= 1;
  103.         #else
  104.         /* Triple buffering; no need to wait for vertical retrace. */
  105.         writepage = (writepage + 1) % 3;
  106.         #endif
  107.  
  108.         if (x == targetx && y == targety) {
  109.             /* Create new target. */
  110.             targetx = rand() % (VWIDTH - WINWIDTH);
  111.             targety = rand() % (VHEIGHT - WINHEIGHT);
  112.         }
  113.  
  114.         /* Move towards target. */
  115.         if (x < targetx)
  116.             x++;
  117.         if (x > targetx)
  118.             x--;
  119.         if (y < targety)
  120.             y++;
  121.         if (y > targety)
  122.             y--;
  123.  
  124.         /* Boundary checks. */
  125.         if (x < 0)
  126.             x = 0;
  127.         if (x > VWIDTH - WINWIDTH)
  128.             x = VWIDTH - WINWIDTH;
  129.         if (y < 0)
  130.             y = 0;
  131.         if (y > VHEIGHT - WINHEIGHT)
  132.             y = VHEIGHT - WINHEIGHT;
  133.         
  134.         if (vga_getkey())
  135.             break;
  136.             
  137.         count++;
  138.     }
  139.     
  140.     printf("Method 1: frame rate %d\n", count * 1000
  141.         / (clock() - startclock));
  142. }
  143.  
  144.  
  145. void demo2() {
  146.     int x, y;
  147.     int targetx, targety;
  148.     int vwidth, vheight;
  149.  
  150.     /* Make sure window fits in video memory. */
  151.     vwidth = VWIDTH;
  152.     if (vwidth > 640)
  153.         vwidth = 640;
  154.     vheight = VHEIGHT;
  155.     if (vheight > 400)
  156.         vheight = 400;
  157.  
  158.     vga_setlogicalwidth(vwidth);
  159.  
  160.     /* Copy virtual screen to logical screen in video memory. */
  161.     vga_copytoplanar256(vbuf, VWIDTH, 0, vwidth / 4,
  162.         vwidth, VHEIGHT);
  163.  
  164.     /* Window coordinates initially at center. */
  165.     x = vwidth / 2 - WINWIDTH / 2;
  166.     y = vheight / 2 - WINHEIGHT / 2;
  167.     targetx = x;
  168.     targety = y;
  169.  
  170.     for (;;) {
  171.         /* Set video memory window. */
  172.         vga_setdisplaystart((y * vwidth / 4) * 4 + x);
  173.         vga_waitretrace();
  174.  
  175.         if (x == targetx && y == targety) {
  176.             /* Create new target. */
  177.             targetx = rand() % (vwidth - WINWIDTH);
  178.             targety = rand() % (vheight - WINHEIGHT);
  179.         }
  180.  
  181.         /* Move towards target. */
  182.         if (x < targetx)
  183.             x++;
  184.         if (x > targetx)
  185.             x--;
  186.         if (y < targety)
  187.             y++;
  188.         if (y > targety)
  189.             y--;
  190.  
  191.         /* Boundary checks. */
  192.         if (x < 0)
  193.             x = 0;
  194.         if (x > vwidth - WINWIDTH)
  195.             x = vwidth - WINWIDTH;
  196.         if (y < 0)
  197.             y = 0;
  198.         if (y > vheight - WINHEIGHT)
  199.             y = vheight - WINHEIGHT;
  200.         
  201.         if (vga_getkey())
  202.             break;
  203.     }
  204. }
  205.  
  206.  
  207. void demo3() {
  208.     int x, y;
  209.     int targetx, targety;
  210.     int count, startclock;
  211.     GraphicsContext *virtualscreen;
  212.     GraphicsContext *physicalscreen;
  213.  
  214.     /* Window coordinate initially at center. */
  215.     x = VWIDTH / 2 - WINWIDTH / 2;
  216.     y = VHEIGHT / 2 - WINHEIGHT / 2;
  217.     targetx = x;
  218.     targety = y;
  219.  
  220.     virtualscreen = gl_allocatecontext();
  221.     gl_getcontext(virtualscreen);
  222.     gl_setcontextvga(G320x200x256);
  223.     physicalscreen = gl_allocatecontext();
  224.     gl_getcontext(physicalscreen);
  225.     gl_setcontext(virtualscreen);
  226.  
  227.     count = 0;
  228.     startclock = clock();
  229.  
  230.     for (;;) {
  231.         /* Copy window to screen. */
  232.         gl_copyboxtocontext(x, y, WINWIDTH, WINHEIGHT, physicalscreen,
  233.             0, 0);
  234.  
  235.         if (x == targetx && y == targety) {
  236.             /* Create new target. */
  237.             targetx = rand() % (VWIDTH - WINWIDTH);
  238.             targety = rand() % (VHEIGHT - WINHEIGHT);
  239.         }
  240.         
  241.         /* Move towards target. */
  242.         if (x < targetx)
  243.             x++;
  244.         if (x > targetx)
  245.             x--;
  246.         if (y < targety)
  247.             y++;
  248.         if (y > targety)
  249.             y--;
  250.  
  251.         /* Boundary checks. */
  252.         if (x < 0)
  253.             x = 0;
  254.         if (x > VWIDTH - WINWIDTH)
  255.             x = VWIDTH - WINWIDTH;
  256.         if (y < 0)
  257.             y = 0;
  258.         if (y > VHEIGHT - WINHEIGHT)
  259.             y = VHEIGHT - WINHEIGHT;
  260.         
  261.         if (vga_getkey())
  262.             break;
  263.             
  264.         count++;
  265.     }
  266.     
  267.     printf("Method 3: frame rate %d\n", count * 1000
  268.         / (clock() - startclock));
  269. }
  270.  
  271.  
  272. void main() {
  273.     vga_init();
  274.  
  275.     /* Create virtual screen. */
  276.     vbuf = malloc(VWIDTH * VHEIGHT);
  277.     gl_setcontextvirtual(VWIDTH, VHEIGHT, 1, 8, vbuf);
  278.  
  279.     /* Set Mode X-style 320x240x256. */
  280.     vga_setmode(G320x240x256);
  281.     gl_setrgbpalette();
  282.     vga_clear();
  283.  
  284.     boxes();
  285.  
  286.     demo1();
  287.     
  288.     demo2();
  289.     
  290.     vga_setmode(G320x200x256);    /* Set linear 320x200x256. */
  291.     gl_setrgbpalette();
  292.  
  293.     demo3();
  294.  
  295.     vga_setmode(TEXT);
  296.     exit(0);
  297. }
  298.