home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 2000 January / LCD_01_2000.iso / games / doom / pmdoom / src / video / svgalib.c next >
Encoding:
C/C++ Source or Header  |  1999-12-17  |  11.7 KB  |  486 lines
  1. /*
  2.  *    Svgalib functions
  3.  *    Keyboard routine inspired from Snes9x
  4.  *
  5.  *    Patrice Mandin
  6.  */
  7.  
  8. #include <stdlib.h>
  9.  
  10. #include <vga.h>
  11. #include <vgagl.h>
  12. #include <vgakeyboard.h>
  13.  
  14. #include "am_map.h"
  15. #include "d_main.h"
  16. #include "f_finale.h"
  17. #include "f_wipe.h"
  18. #include "r_draw.h"
  19. #include "v_video.h"
  20. #include "z_zone.h"
  21.  
  22. #include "i_system.h"
  23. #include "i_zoom.h"
  24. #include "i_video.h"
  25. #include "video/svgalib.h"
  26.  
  27. typedef struct
  28. {
  29.     int number;            /* Number of video mode */
  30.     vga_modeinfo *info;    /* Pointer for informations on the mode */
  31.     int depth;            /* bits per plane */
  32. } svgamode_t;
  33.  
  34. void *svgascreen[2];    /* double buffer screens */
  35. void *svgazoomscreen;    /* zoomed screen */
  36. /*int scr_width,scr_height;*/    /* size of screen */
  37. int svganummodes;        /* Number of video modes */
  38. int dstpos_x,dstpos_y;    /* Position in destination screen */
  39.  
  40. svgamode_t *svgamodelist;
  41.  
  42. static char prev_keystate [128] = "";
  43.  
  44. void I_ShutdownGraphics_svgalib(void)
  45. {
  46.     keyboard_close();
  47.  
  48.     vga_setmode(TEXT);    
  49. }
  50.  
  51. //
  52. // I_StartTic
  53. //
  54. void I_UpdateKeyboard_svgalib (void)
  55. {
  56.     event_t    event;
  57.  
  58.     // Taken from Snes9x
  59.  
  60.     char    *keystate;
  61.  
  62.     keyboard_update ();
  63.     keystate=keyboard_getstate();
  64.  
  65. #define KEY_DOWN(a) (keystate[a])
  66. #define KEY_PRESS(a) (keystate[a] && !prev_keystate[a])
  67. #define KEY_WASPRESSED(a) (prev_keystate[a] && !keystate[a])
  68. #define PROCESS_KEY(k,t)                    \
  69.     if (KEY_PRESS(k))                    \
  70.     {                            \
  71.             event.type = ev_keydown;        \
  72.             event.data1 = t;            \
  73.             D_PostEvent(&event);            \
  74.     }                            \
  75.     if (KEY_WASPRESSED(k))                    \
  76.     {                            \
  77.             event.type = ev_keyup;            \
  78.             event.data1 = t;            \
  79.             D_PostEvent(&event);            \
  80.     }
  81.  
  82.     PROCESS_KEY(SCANCODE_CURSORBLOCKRIGHT, KEY_RIGHTARROW);
  83.     PROCESS_KEY(SCANCODE_CURSORBLOCKLEFT, KEY_LEFTARROW);
  84.     PROCESS_KEY(SCANCODE_CURSORBLOCKDOWN, KEY_DOWNARROW);
  85.     PROCESS_KEY(SCANCODE_CURSORBLOCKUP, KEY_UPARROW);
  86.  
  87.     PROCESS_KEY(SCANCODE_ESCAPE, KEY_ESCAPE);
  88.     PROCESS_KEY(SCANCODE_ENTER, KEY_ENTER);
  89.     PROCESS_KEY(SCANCODE_KEYPADENTER, KEY_ENTER);
  90.     PROCESS_KEY(SCANCODE_TAB, KEY_TAB);
  91.     PROCESS_KEY(SCANCODE_SPACE, ' ');
  92.     PROCESS_KEY(SCANCODE_BREAK, KEY_PAUSE);
  93.     PROCESS_KEY(SCANCODE_BREAK_ALTERNATIVE, KEY_PAUSE);
  94.  
  95.     PROCESS_KEY(SCANCODE_F1, KEY_F1);
  96.     PROCESS_KEY(SCANCODE_F2, KEY_F2);
  97.     PROCESS_KEY(SCANCODE_F3, KEY_F3);
  98.     PROCESS_KEY(SCANCODE_F4, KEY_F4);
  99.     PROCESS_KEY(SCANCODE_F5, KEY_F5);
  100.     PROCESS_KEY(SCANCODE_F6, KEY_F6);
  101.     PROCESS_KEY(SCANCODE_F7, KEY_F7);
  102.     PROCESS_KEY(SCANCODE_F8, KEY_F8);
  103.     PROCESS_KEY(SCANCODE_F9, KEY_F9);
  104.     PROCESS_KEY(SCANCODE_F10, KEY_F10);
  105.     PROCESS_KEY(SCANCODE_F11, KEY_F11);
  106.     PROCESS_KEY(SCANCODE_F12, KEY_F12);
  107.         
  108.     PROCESS_KEY(SCANCODE_1, '1');
  109.     PROCESS_KEY(SCANCODE_2, '2');
  110.     PROCESS_KEY(SCANCODE_3, '3');
  111.     PROCESS_KEY(SCANCODE_4, '4');
  112.     PROCESS_KEY(SCANCODE_5, '5');
  113.     PROCESS_KEY(SCANCODE_6, '6');
  114.     PROCESS_KEY(SCANCODE_7, '7');
  115.     PROCESS_KEY(SCANCODE_8, '8');
  116.     PROCESS_KEY(SCANCODE_9, '9');
  117.     PROCESS_KEY(SCANCODE_0, '0');
  118.  
  119.     PROCESS_KEY(SCANCODE_MINUS, KEY_MINUS);
  120.     PROCESS_KEY(SCANCODE_KEYPADMINUS, KEY_MINUS);
  121.     PROCESS_KEY(SCANCODE_EQUAL, KEY_EQUALS);
  122.     PROCESS_KEY(SCANCODE_KEYPADPLUS, KEY_EQUALS);
  123.  
  124.     PROCESS_KEY(SCANCODE_BACKSPACE, KEY_BACKSPACE);
  125.     PROCESS_KEY(SCANCODE_REMOVE, KEY_BACKSPACE);
  126.  
  127.     PROCESS_KEY(SCANCODE_LEFTSHIFT, KEY_RSHIFT);
  128.     PROCESS_KEY(SCANCODE_RIGHTSHIFT, KEY_RSHIFT);
  129.     PROCESS_KEY(SCANCODE_LEFTCONTROL, KEY_RCTRL);
  130.     PROCESS_KEY(SCANCODE_RIGHTCONTROL, KEY_RCTRL);
  131.     PROCESS_KEY(SCANCODE_LEFTALT, KEY_RALT);
  132.     PROCESS_KEY(SCANCODE_RIGHTALT, KEY_RALT);
  133.  
  134.     PROCESS_KEY(SCANCODE_Q, 'q');
  135.     PROCESS_KEY(SCANCODE_W, 'w');
  136.     PROCESS_KEY(SCANCODE_E, 'e');
  137.     PROCESS_KEY(SCANCODE_R, 'r');
  138.     PROCESS_KEY(SCANCODE_T, 't');
  139.     PROCESS_KEY(SCANCODE_Y, 'y');
  140.     PROCESS_KEY(SCANCODE_U, 'u');
  141.     PROCESS_KEY(SCANCODE_I, 'i');
  142.     PROCESS_KEY(SCANCODE_O, 'o');
  143.     PROCESS_KEY(SCANCODE_P, 'p');
  144.  
  145.     PROCESS_KEY(SCANCODE_A, 'a');
  146.     PROCESS_KEY(SCANCODE_S, 's');
  147.     PROCESS_KEY(SCANCODE_D, 'd');
  148.     PROCESS_KEY(SCANCODE_F, 'f');
  149.     PROCESS_KEY(SCANCODE_G, 'g');
  150.     PROCESS_KEY(SCANCODE_H, 'h');
  151.     PROCESS_KEY(SCANCODE_J, 'j');
  152.     PROCESS_KEY(SCANCODE_K, 'k');
  153.     PROCESS_KEY(SCANCODE_L, 'l');
  154.  
  155.     PROCESS_KEY(SCANCODE_Z, 'z');
  156.     PROCESS_KEY(SCANCODE_X, 'x');
  157.     PROCESS_KEY(SCANCODE_C, 'c');
  158.     PROCESS_KEY(SCANCODE_V, 'v');
  159.     PROCESS_KEY(SCANCODE_B, 'b');
  160.     PROCESS_KEY(SCANCODE_N, 'n');
  161.     PROCESS_KEY(SCANCODE_M, 'm');
  162.  
  163.     memcpy (prev_keystate, keystate, sizeof (prev_keystate));
  164. }
  165.  
  166. void I_VidUpdate_svgalib (void)
  167. {
  168.     void *source;
  169.     int dstwidth,dstheight;
  170.  
  171.     if (dblbuffer)
  172.     {
  173.         if (zoomscreen)
  174.         {
  175.             I_Zoom(screens[0],svgascreen[fbnum]);
  176.         }
  177.  
  178.         vga_copytoplanar256(svgascreen[fbnum],videowidth,(fbnum<<17)>>2,80,videowidth,videoheight);
  179.         vga_setdisplaystart(fbnum<<17);
  180.         vga_waitretrace();    
  181.  
  182.         fbnum ^=1;
  183.         if (!zoomscreen)
  184.         {
  185.             screens[0]=svgascreen[fbnum]+videowidth*((videoheight-SCREENHEIGHT)>>1);
  186.             R_InitBuffer(scaledviewwidth,viewheight); /* mettre a jour ylookup */
  187.         }
  188.     }
  189.     else
  190.     {
  191.         if (zoomscreen)
  192.         {
  193.             /* Single buffer, zoom */
  194.             source=svgazoomscreen;
  195.  
  196.             I_Zoom(screens[0],svgazoomscreen);
  197.             dstwidth=videowidth;
  198.             dstheight=videoheight;
  199.         }
  200.         else
  201.         {
  202.             /* Single buffer, no zoom */
  203.             source=screens[0];
  204.             dstwidth=SCREENWIDTH;
  205.             dstheight=SCREENHEIGHT;
  206.         }
  207.  
  208.         if (videomode==G320x200x256)
  209.             memcpy(vga_getgraphmem(),source,SCREENWIDTH*SCREENHEIGHT*pixel_size);
  210.         else
  211.             gl_putbox(
  212.                 dstpos_x,dstpos_y,
  213.                 dstwidth,dstheight,
  214.                 source);
  215.     }
  216. }
  217.  
  218. void I_SetPalette256_svgalib (byte* palette)
  219. {
  220.     int i;
  221.  
  222.     for(i = 0; i < 256; i++)
  223.     {
  224.         byte r,v,b;
  225.  
  226.         r = gammatable[usegamma][*palette++]>>2;
  227.         v = gammatable[usegamma][*palette++]>>2;
  228.         b = gammatable[usegamma][*palette++]>>2;
  229.  
  230.         vga_setpalette(i,r,v,b);
  231.     }
  232. }
  233.  
  234. void I_InitGraphics_svgalib(void)
  235. {
  236.     static int        firsttime=1;
  237.     svgamode_t        *curmode;
  238.     vga_modeinfo    *curinfo;
  239.     int                screensize;
  240.  
  241.     if (!firsttime)
  242.         return;
  243.     firsttime = 0;
  244.  
  245.     if (videomode<0 || videomode>=svganummodes)
  246.     {
  247.         /* Standard mode */
  248.         videomode=G320x200x256;
  249.         bpp=8;
  250.     }
  251.     else
  252.     {
  253.         /* Init asked mode */
  254.         curmode=&svgamodelist[videomode];
  255.         videomode=curmode->number;
  256.         bpp=curmode->depth;
  257.     }
  258.  
  259.     curinfo=vga_getmodeinfo(videomode);
  260.     videowidth=curinfo->width;
  261.     videoheight=curinfo->height;
  262.     dblbuffer=false;
  263.  
  264.     switch (bpp)
  265.     {
  266.         case 8:
  267.             R_DrawColumn=R_DrawColumn8;
  268.             R_DrawColumnLow=R_DrawColumnLow8;
  269.             R_DrawFuzzColumn=R_DrawFuzzColumn8;
  270.             R_DrawFuzzColumnLow=R_DrawFuzzColumnLow8;
  271.             R_DrawTranslatedColumn=R_DrawTranslatedColumn8;
  272.             R_DrawTranslatedColumnLow=R_DrawTranslatedColumnLow8;
  273.             R_DrawSpan=R_DrawSpan8;
  274.             R_DrawSpanLow=R_DrawSpanLow8;
  275.             AM_DrawFline=AM_drawFline8;
  276.             wipe_doMelt=wipe_doMelt8;
  277.             V_DrawPatch=V_DrawPatch8;
  278.             V_DrawPatchFlipped=V_DrawPatchFlipped8;
  279.             F_DrawPatchCol=F_DrawPatchCol8;
  280.             I_Zoom=I_Zoom8;
  281.             pixel_size=1;
  282.             break;
  283.         case 15:
  284.             R_DrawColumn=R_DrawColumn16;
  285.             R_DrawColumnLow=R_DrawColumnLow16;
  286.             R_DrawFuzzColumn=R_DrawFuzzColumn16;
  287.             R_DrawFuzzColumnLow=R_DrawFuzzColumnLow16;
  288.             R_DrawTranslatedColumn=R_DrawTranslatedColumn16;
  289.             R_DrawTranslatedColumnLow=R_DrawTranslatedColumnLow16;
  290.             R_DrawSpan=R_DrawSpan16;
  291.             R_DrawSpanLow=R_DrawSpanLow16;
  292.             AM_DrawFline=AM_drawFline16;
  293.             wipe_doMelt=wipe_doMelt16;
  294.             V_DrawPatch=V_DrawPatch16;
  295.             V_DrawPatchFlipped=V_DrawPatchFlipped16;
  296.             F_DrawPatchCol=F_DrawPatchCol16;
  297.             I_Zoom=I_Zoom16;
  298.             pixel_size=2;
  299.             fuzzmask=0x3DEF3DEF;
  300.             break;
  301.         case 16:
  302.             R_DrawColumn=R_DrawColumn16;
  303.             R_DrawColumnLow=R_DrawColumnLow16;
  304.             R_DrawFuzzColumn=R_DrawFuzzColumn16;
  305.             R_DrawFuzzColumnLow=R_DrawFuzzColumnLow16;
  306.             R_DrawTranslatedColumn=R_DrawTranslatedColumn16;
  307.             R_DrawTranslatedColumnLow=R_DrawTranslatedColumnLow16;
  308.             R_DrawSpan=R_DrawSpan16;
  309.             R_DrawSpanLow=R_DrawSpanLow16;
  310.             AM_DrawFline=AM_drawFline16;
  311.             wipe_doMelt=wipe_doMelt16;
  312.             V_DrawPatch=V_DrawPatch16;
  313.             V_DrawPatchFlipped=V_DrawPatchFlipped16;
  314.             F_DrawPatchCol=F_DrawPatchCol16;
  315.             I_Zoom=I_Zoom16;
  316.             pixel_size=2;
  317.             fuzzmask=0x7BEF7BEF;
  318.             break;
  319.         case 24:
  320.             R_DrawColumn=R_DrawColumn24;
  321.             R_DrawColumnLow=R_DrawColumnLow24;
  322.             R_DrawFuzzColumn=R_DrawFuzzColumn24;
  323.             R_DrawFuzzColumnLow=R_DrawFuzzColumnLow24;
  324.             R_DrawTranslatedColumn=R_DrawTranslatedColumn24;
  325.             R_DrawTranslatedColumnLow=R_DrawTranslatedColumnLow24;
  326.             R_DrawSpan=R_DrawSpan24;
  327.             R_DrawSpanLow=R_DrawSpanLow24;
  328.             AM_DrawFline=AM_drawFline24;
  329.             wipe_doMelt=wipe_doMelt24;
  330.             V_DrawPatch=V_DrawPatch24;
  331.             V_DrawPatchFlipped=V_DrawPatchFlipped24;
  332.             F_DrawPatchCol=F_DrawPatchCol24;
  333.             I_Zoom=I_Zoom24;
  334.             pixel_size=3;
  335.             break;
  336.         case 32:
  337.             R_DrawColumn=R_DrawColumn32;
  338.             R_DrawColumnLow=R_DrawColumnLow32;
  339.             R_DrawFuzzColumn=R_DrawFuzzColumn32;
  340.             R_DrawFuzzColumnLow=R_DrawFuzzColumnLow32;
  341.             R_DrawTranslatedColumn=R_DrawTranslatedColumn32;
  342.             R_DrawTranslatedColumnLow=R_DrawTranslatedColumnLow32;
  343.             R_DrawSpan=R_DrawSpan32;
  344.             R_DrawSpanLow=R_DrawSpanLow32;
  345.             AM_DrawFline=AM_drawFline32;
  346.             wipe_doMelt=wipe_doMelt32;
  347.             V_DrawPatch=V_DrawPatch32;
  348.             V_DrawPatchFlipped=V_DrawPatchFlipped32;
  349.             F_DrawPatchCol=F_DrawPatchCol32;
  350.             I_Zoom=I_Zoom32;
  351.             pixel_size=4;
  352.             fuzzmask=0x007F7F7F;
  353.             break;
  354.         default:
  355.             I_Error("Unknown pixel size for screen\n");
  356.     }
  357.  
  358.     screensize=videowidth*videoheight*pixel_size;
  359.  
  360.     if (videomode == G320x240x256 ||
  361.         videomode == G320x400x256 )
  362.     {
  363.         svgascreen[0]=Z_Malloc(screensize, PU_STATIC, NULL);
  364.         if (!svgascreen[0])
  365.             I_Error("Not enough memory for double buffer screens\n");
  366.         svgascreen[1]=Z_Malloc(screensize, PU_STATIC, NULL);
  367.         if (!svgascreen[1])
  368.             I_Error("Not enough memory for double buffer screens\n");
  369.  
  370.         memset(svgascreen[0],0,screensize);
  371.         memset(svgascreen[1],0,screensize);
  372.  
  373.         dblbuffer=true;
  374.     }
  375.  
  376.     if (videomode==G320x200x256)
  377.         zoomscreen=false;
  378.  
  379.     if (zoomscreen)
  380.     {
  381.         /* Double buffer : can zoom directly in buffer */
  382.         if (videomode!=G320x240x256 && videomode!=G320x400x256)
  383.         {
  384.             svgazoomscreen=Z_Malloc(screensize, PU_STATIC, NULL);
  385.             if (!svgazoomscreen)
  386.                 I_Error("Not enough memory for zoom screen\n");
  387.         }
  388.         I_ZoomInit(videowidth,videoheight);
  389.     }
  390.  
  391.     /* Set destination position */
  392.     dstpos_x=0;
  393.     dstpos_y=0;
  394.  
  395.     if (!zoomscreen)
  396.     {
  397.         dstpos_x=(videowidth-SCREENWIDTH)>>1;
  398.         dstpos_y=(videoheight-SCREENHEIGHT)>>1;
  399.     }
  400.  
  401.     /* Set video mode */
  402.  
  403.     if (vga_setmode (videomode) < 0)
  404.         I_Error ( "Unable to switch to requested screen mode\n");
  405.  
  406.     gl_setcontextvga(videomode);
  407.  
  408.     keyboard_init();
  409.  
  410.     if (dblbuffer)
  411.             vga_setdisplaystart(1);
  412. }
  413.  
  414. void I_VidInit_svgalib(void)
  415. {
  416.     int countmode;
  417.     int i;
  418.     svgamode_t *curmode;
  419.     vga_modeinfo *curinfo;
  420.  
  421.     /* Start svgalib */
  422.  
  423.     vga_init();
  424.  
  425.     /* Count available modes */
  426.  
  427.     countmode=0;
  428.     for (i=1;i<vga_lastmodenumber();i++)
  429.     {
  430.         if (vga_hasmode(i))
  431.             countmode++;
  432.     }
  433.     if (!countmode)
  434.         I_Error("No available video modes\n");
  435.  
  436.     svgamodelist=malloc(countmode*sizeof(svgamode_t));    
  437.  
  438.     /* Now read informations for each mode */    
  439.     printf("Available Svgalib video modes:\n");
  440.  
  441.     svganummodes=0;
  442.     for (i=1;i<vga_lastmodenumber();i++)
  443.     {
  444.         if (!vga_hasmode(i))
  445.             continue;
  446.  
  447.         curmode=&svgamodelist[svganummodes];
  448.         curmode->number = i;
  449.         curinfo = vga_getmodeinfo(i);
  450.  
  451.         if (curinfo->colors < (1<<8))
  452.             continue;
  453.         if (i==G360x480x256)
  454.             continue;
  455.  
  456.         curmode->depth=0;
  457.         switch (curinfo->colors)
  458.         {
  459.             case 1<<8:
  460.                 curmode->depth=8;
  461.                 break;
  462.             case 1<<15:
  463.                 curmode->depth=15;
  464.                 break;
  465.             case 1<<16:
  466.                 curmode->depth=16;
  467.                 break;
  468.             case 1<<24:
  469.                 if (curinfo->bytesperpixel == 3)
  470.                     curmode->depth=24;
  471.                 else
  472.                     curmode->depth=32;
  473.                 break;
  474.         }
  475.  
  476.         printf("%d: %dx%d %d bits",svganummodes,curinfo->width,curinfo->height,curmode->depth);
  477.         if (i == G320x240x256 || i == G320x400x256 || i == G360x480x256)
  478.             printf(",Mode X");
  479.         printf("\n");
  480.  
  481.         svganummodes++;
  482.     }
  483.  
  484.     printf("\n"); /* end of list */
  485. }
  486.