home *** CD-ROM | disk | FTP | other *** search
/ Best Objectech Shareware Selections / UNTITLED.iso / boss / grap / util / 015 / svga32kc.c < prev    next >
C/C++ Source or Header  |  1993-03-07  |  7KB  |  238 lines
  1. /****************************************************************************
  2. *
  3. *                           SuperVGA Test Library
  4. *
  5. *                   Copyright (C) 1993 Kendall Bennett.
  6. *                            All rights reserved.
  7. *
  8. * Filename:        $RCSfile: svga32kc.c $
  9. * Version:        $Revision: 1.2 $
  10. *
  11. * Language:        ANSI C
  12. * Environment:    IBM PC (MSDOS)
  13. *
  14. * Description:    Simple library to collect together the functions in the
  15. *                SuperVGA test library for use in other C programs. The
  16. *                support is reasonably low level, so you can do what you
  17. *                want.
  18. *
  19. *                MUST be compiled in the large model.
  20. *
  21. * $Id: svga32kc.c 1.2 1993/03/07 04:06:11 kjb Exp $
  22. *
  23. * Revision History:
  24. * -----------------
  25. *
  26. * $Log: svga32kc.c $
  27. * Revision 1.2  1993/03/07  04:06:11  kjb
  28. * Bug fixes.
  29. *
  30. * Revision 1.1  1993/03/03  10:29:27  kjb
  31. * Initial revision
  32. *
  33. ****************************************************************************/
  34.  
  35. #include "svga32k.h"
  36.  
  37. /*-------------------------- Internal Functions --------------------------*/
  38.  
  39. /* In svga32k.asm */
  40.  
  41. int _initSuperVGA(int driver,int chipID,int mode,int memory);
  42. int _setSuperVGAMode(void);
  43. void _getVideoInfo(int *xres,int *yres,int *bytesperline,int *maxpage);
  44.  
  45. /* Global variables */
  46.  
  47. PUBLIC    int        _grResult;
  48. PUBLIC    int        maxx,maxy;
  49. PUBLIC    int        maxpage,bytesperline;
  50. PUBLIC    bool    twobanks,extendedflipping;
  51. PUBLIC    int        far *modeList;
  52. PUBLIC    int        _VESAFirst = false;
  53. PUBLIC    int        _ignoreSVGA = false;
  54. PRIVATE    int        _driver,_chipID,_memory;
  55.  
  56. /*----------------------------- Implementation ----------------------------*/
  57.  
  58. PUBLIC void initSuperVGA(int *driver,int *chipID,int *memory,int *dac)
  59. /****************************************************************************
  60. *
  61. * Function:        initSuperVGA
  62. * Parameters:    driver    - Place to store the SuperVGA driver ID
  63. *                chipID    - Place to store the SuperVGA chip ID
  64. *                memory    - Place to store the amount of memory
  65. *                dac        - Place to store the Video DAC type
  66. *
  67. * Description:    Detects the installed SuperVGA and initialises the library,
  68. *                if the value in 'driver' is grDETECT. You can force the
  69. *                library to work with any values you like, by simply
  70. *                passing valid values as parameters.
  71. *
  72. ****************************************************************************/
  73. {
  74.     int        i,mode;
  75.  
  76.     if (*driver == grDETECT) {
  77.         /* Auto detect the installed graphics adapter */
  78.  
  79.         MGL_detectGraph(driver,chipID,memory,dac,&mode);
  80.         }
  81.     modeList = MGL_availableModes(*driver,*memory);
  82.  
  83.     /* Check to see if at least one mode is available before we
  84.      * initialise the SuperVGA.
  85.      */
  86.  
  87.     i = 0;
  88.     mode = -1;
  89.     while (modeList[i] != -1) {
  90.         switch(modeList[i]) {
  91.             case grSVGA_320x200x32k:
  92.             case grSVGA_640x350x32k:
  93.             case grSVGA_640x400x32k:
  94.             case grSVGA_640x480x32k:
  95.             case grSVGA_800x600x32k:
  96.             case grSVGA_1024x768x32k:
  97.             case grSVGA_1280x1024x32k:
  98.                 mode = modeList[i];        /* Found a valid mode    */
  99.                 break;
  100.             }
  101.         if (mode != -1)
  102.             break;
  103.         i++;
  104.         }
  105.     if (mode != -1) {
  106.         mode = _initSuperVGA(*driver,*chipID,mode,*memory);
  107.         extendedflipping = (mode & 1);
  108.         twobanks = (mode & 2);
  109.         _driver = *driver;
  110.         _chipID = *chipID;
  111.         _memory = *memory;
  112.         }
  113. }
  114.  
  115. PUBLIC bool setSuperVGAMode(int mode)
  116. /****************************************************************************
  117. *
  118. * Function:        setSuperVGAMode
  119. * Parameters:    mode    - SuperVGA video mode to set.
  120. * Returns:        True if the mode was set, false if not.
  121. *
  122. * Description:    Attempts to set the specified video mode. This routine
  123. *                assumes that the library and SuperVGA have been initialised
  124. *                with the initSuperVGA() routine first.
  125. *
  126. ****************************************************************************/
  127. {
  128.     if (_initSuperVGA(_driver,_chipID,mode,_memory) == -1)
  129.         return -1;
  130.     if (_setSuperVGAMode()) {
  131.         _getVideoInfo(&maxx,&maxy,&bytesperline,&maxpage);
  132.         return true;
  133.         }
  134.     return false;
  135. }
  136.  
  137. PUBLIC void line(int x1,int y1,int x2,int y2,uint color)
  138. /****************************************************************************
  139. *
  140. * Function:        line
  141. * Parameters:    x1,y1        - First endpoint of line
  142. *                x2,y2        - Second endpoint of line
  143. *
  144. * Description:    Scan convert a line segment using the MidPoint Digital
  145. *                Differential Analyser algorithm.
  146. *
  147. ****************************************************************************/
  148. {
  149.     int        d;                        /* Decision variable                */
  150.     int        dx,dy;                    /* Dx and Dy values for the line    */
  151.     int        Eincr,NEincr;            /* Decision variable increments        */
  152.     int        yincr;                    /* Increment for y values            */
  153.     int        t;                        /* Counters etc.                    */
  154.  
  155.     dx = ABS(x2 - x1);
  156.     dy = ABS(y2 - y1);
  157.  
  158.     if (dy <= dx) {
  159.  
  160.         /* We have a line with a slope between -1 and 1
  161.          *
  162.          * Ensure that we are always scan converting the line from left to
  163.          * right to ensure that we produce the same line from P1 to P0 as the
  164.          * line from P0 to P1.
  165.          */
  166.  
  167.         if (x2 < x1) {
  168.             t = x2; x2 = x1; x1 = t;    /* Swap X coordinates            */
  169.             t = y2; y2 = y1; y1 = t;    /* Swap Y coordinates            */
  170.             }
  171.  
  172.         if (y2 > y1)
  173.             yincr = 1;
  174.         else
  175.             yincr = -1;
  176.  
  177.         d = 2*dy - dx;                /* Initial decision variable value    */
  178.         Eincr = 2*dy;                /* Increment to move to E pixel        */
  179.         NEincr = 2*(dy - dx);        /* Increment to move to NE pixel    */
  180.  
  181.         putPixel(x1,y1,color);        /* Draw the first point at (x1,y1)    */
  182.  
  183.         /* Incrementally determine the positions of the remaining pixels
  184.          */
  185.  
  186.         for (x1++; x1 <= x2; x1++) {
  187.             if (d < 0) {
  188.                 d += Eincr;            /* Choose the Eastern Pixel            */
  189.                 }
  190.             else {
  191.                 d += NEincr;        /* Choose the North Eastern Pixel    */
  192.                 y1 += yincr;        /* (or SE pixel for dx/dy < 0!)        */
  193.                 }
  194.             putPixel(x1,y1,color);    /* Draw the point                    */
  195.             }
  196.         }
  197.     else {
  198.  
  199.         /* We have a line with a slope between -1 and 1 (ie: includes
  200.          * vertical lines). We must swap our x and y coordinates for this.
  201.          *
  202.          * Ensure that we are always scan converting the line from left to
  203.          * right to ensure that we produce the same line from P1 to P0 as the
  204.          * line from P0 to P1.
  205.          */
  206.  
  207.         if (y2 < y1) {
  208.             t = x2; x2 = x1; x1 = t;    /* Swap X coordinates            */
  209.             t = y2; y2 = y1; y1 = t;    /* Swap Y coordinates            */
  210.             }
  211.  
  212.         if (x2 > x1)
  213.             yincr = 1;
  214.         else
  215.             yincr = -1;
  216.  
  217.         d = 2*dx - dy;                /* Initial decision variable value    */
  218.         Eincr = 2*dx;                /* Increment to move to E pixel        */
  219.         NEincr = 2*(dx - dy);        /* Increment to move to NE pixel    */
  220.  
  221.         putPixel(x1,y1,color);        /* Draw the first point at (x1,y1)    */
  222.  
  223.         /* Incrementally determine the positions of the remaining pixels
  224.          */
  225.  
  226.         for (y1++; y1 <= y2; y1++) {
  227.             if (d < 0) {
  228.                 d += Eincr;            /* Choose the Eastern Pixel            */
  229.                 }
  230.             else {
  231.                 d += NEincr;        /* Choose the North Eastern Pixel    */
  232.                 x1 += yincr;        /* (or SE pixel for dx/dy < 0!)        */
  233.                 }
  234.             putPixel(x1,y1,color);    /* Draw the point                    */
  235.             }
  236.         }
  237. }
  238.