Subversion Repositories Kolibri OS

Rev

Rev 298 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. // Emacs style mode select   -*- C++ -*-
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //      DOOM graphics stuff for SDL library
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24. static const char
  25. rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
  26.  
  27. #include <stdlib.h>
  28.  
  29. //#include "SDL.h"
  30.  
  31. //#include "m_swap.h"
  32. #include "doomstat.h"
  33. #include "i_system.h"
  34. #include "v_video.h"
  35. #include "m_argv.h"
  36. #include "d_main.h"
  37.  
  38. #include "doomdef.h"
  39. #define WIN32_LEAN_AND_MEAN
  40. #include <windows.h>
  41.  
  42. typedef struct SURFACE
  43. {
  44.         int w, h;              
  45.         int pitch;             
  46.         unsigned char *pixels; 
  47.         int offset;            
  48. } SURFACE;
  49.  
  50. SURFACE screen;
  51.  
  52. // Fake mouse handling.
  53. boolean         grabMouse;
  54.  
  55. // Blocky mode,
  56. // replace each 320x200 pixel with multiply*multiply pixels.
  57. // According to Dave Taylor, it still is a bonehead thing
  58. // to use ....
  59. static int      multiply=2;
  60.  
  61. void WinError(char *msg);
  62.  
  63.  
  64. int BPP;
  65. byte *hicolortable;
  66. short hicolortransmask1,hicolortransmask2;
  67. int             X_width;
  68. int             X_height;
  69. static int disableVerticalMouse = 0;
  70. static int closed=0;
  71. static int windowActive = 0;
  72.  
  73. HWND win;
  74. static HINSTANCE inst;
  75. static HDC dibDC;
  76. static LOGPALETTE *palette;
  77. static HPALETTE dibPal;
  78. BITMAPINFO *bminfo;
  79. static unsigned char *dibData;
  80. static int bits8;
  81. int palette_color[256];
  82.  
  83.  
  84. static int      lastmousex = 0;
  85. static int      lastmousey = 0;
  86. boolean         mousemoved = false;
  87. boolean         shmFinished;
  88.  
  89.  
  90.  
  91. //
  92. //  Translates the key
  93. //
  94.  
  95. /*******
  96. int xlatekey(SDL_keysym *key)
  97. {
  98.  
  99.     int rc;
  100.  
  101.     switch(key->sym)
  102.     {
  103.       case SDLK_LEFT:   rc = KEY_LEFTARROW;     break;
  104.       case SDLK_RIGHT:  rc = KEY_RIGHTARROW;    break;
  105.       case SDLK_DOWN:   rc = KEY_DOWNARROW;     break;
  106.       case SDLK_UP:     rc = KEY_UPARROW;       break;
  107.       case SDLK_ESCAPE: rc = KEY_ESCAPE;        break;
  108.       case SDLK_RETURN: rc = KEY_ENTER;         break;
  109.       case SDLK_TAB:    rc = KEY_TAB;           break;
  110.       case SDLK_F1:     rc = KEY_F1;            break;
  111.       case SDLK_F2:     rc = KEY_F2;            break;
  112.       case SDLK_F3:     rc = KEY_F3;            break;
  113.       case SDLK_F4:     rc = KEY_F4;            break;
  114.       case SDLK_F5:     rc = KEY_F5;            break;
  115.       case SDLK_F6:     rc = KEY_F6;            break;
  116.       case SDLK_F7:     rc = KEY_F7;            break;
  117.       case SDLK_F8:     rc = KEY_F8;            break;
  118.       case SDLK_F9:     rc = KEY_F9;            break;
  119.       case SDLK_F10:    rc = KEY_F10;           break;
  120.       case SDLK_F11:    rc = KEY_F11;           break;
  121.       case SDLK_F12:    rc = KEY_F12;           break;
  122.        
  123.       case SDLK_BACKSPACE:
  124.       case SDLK_DELETE: rc = KEY_BACKSPACE;     break;
  125.  
  126.       case SDLK_PAUSE:  rc = KEY_PAUSE;         break;
  127.  
  128.       case SDLK_EQUALS: rc = KEY_EQUALS;        break;
  129.  
  130.       case SDLK_KP_MINUS:
  131.       case SDLK_MINUS:  rc = KEY_MINUS;         break;
  132.  
  133.       case SDLK_LSHIFT:
  134.       case SDLK_RSHIFT:
  135.         rc = KEY_RSHIFT;
  136.         break;
  137.        
  138.       case 'z':
  139.       case SDLK_LCTRL:
  140.       case SDLK_RCTRL:
  141.         rc = KEY_RCTRL;
  142.         break;
  143.        
  144.       case SDLK_LALT:
  145.       case SDLK_LMETA:
  146.       case SDLK_RALT:
  147.       case SDLK_RMETA:
  148.         rc = KEY_RALT;
  149.         break;
  150.        
  151.       default:
  152.         rc = key->sym;
  153.         break;
  154.     }
  155.  
  156.     return rc;
  157.  
  158. }
  159. **********/
  160.  
  161. void I_ShutdownGraphics(void)
  162. {
  163.  // SDL_Quit();
  164. }
  165.  
  166.  
  167.  
  168. //
  169. // I_StartFrame
  170. //
  171. void I_StartFrame (void)
  172. {
  173.     // er?
  174.  
  175. }
  176.  
  177. /* This processes SDL events */
  178. /*****
  179. void I_GetEvent(SDL_Event *Event)
  180. {
  181.     Uint8 buttonstate;
  182.     event_t event;
  183.  
  184.     switch (Event->type)
  185.     {
  186.       case SDL_KEYDOWN:
  187.         event.type = ev_keydown;
  188.         event.data1 = xlatekey(&Event->key.keysym);
  189.         D_PostEvent(&event);
  190.         break;
  191.       case SDL_KEYUP:
  192.         event.type = ev_keyup;
  193.         event.data1 = xlatekey(&Event->key.keysym);
  194.         D_PostEvent(&event);
  195.         break;
  196.       case SDL_QUIT:
  197.         I_Quit();
  198.         break;
  199.     }
  200. }
  201.  
  202. *******/
  203.  
  204.  
  205.  
  206.  
  207. void I_GetEvent(void)
  208. {
  209.     MSG msg;
  210.     POINT point;
  211.     static LONG prevX, prevY;
  212.     static int hadMouse = 0;
  213.     event_t event;
  214.     RECT rect;
  215.     int lb, rb;
  216.     static int prevlb = 0, prevrb = 0;
  217.    
  218.     /* Dispatch all messages: */
  219.     while ( PeekMessage(&msg, NULL, 0, 0xFFFFFFFF, PM_REMOVE) )
  220.     {
  221.         TranslateMessage (&msg) ;
  222.         DispatchMessage (&msg) ;
  223.     }
  224.  
  225.     /* Check mouse and generate events if necessary: */
  226.     if ( !GetCursorPos(&point) )
  227.         WinError("GetCursorPos() failed");
  228.     if ( hadMouse && windowActive)
  229.     {
  230.         lb = (GetAsyncKeyState(VK_LBUTTON) < 0);
  231.         rb = (GetAsyncKeyState(VK_RBUTTON) < 0);
  232.            
  233.         if ( (prevX != point.x) || (prevY != point.y) ||
  234.              (prevlb != lb) || (prevrb != rb) )
  235.         {
  236.             event.type = ev_mouse;
  237.             event.data1 = lb | (rb << 1);
  238.             event.data2 = (point.x - prevX)*9;
  239.             if ( disableVerticalMouse )
  240.                 event.data3 = 0;
  241.             else
  242.                 event.data3 = (prevY - point.y)*9;
  243.             prevX = point.x;
  244.             prevY = point.y;
  245.             prevlb = lb;
  246.             prevrb = rb;
  247.             D_PostEvent(&event);
  248.         }
  249.  
  250.         if ( grabMouse )
  251.         {
  252.             GetWindowRect(win, &rect);
  253.             if ( !SetCursorPos((rect.left + rect.right) / 2,
  254.                                (rect.top + rect.bottom) / 2) )
  255.                 WinError("SetCursorPos() failed");
  256.             prevX = (rect.left + rect.right) / 2;
  257.             prevY = (rect.top + rect.bottom) / 2;
  258.         }
  259.     }
  260.     else
  261.     {
  262.         prevX = point.x;
  263.         prevY = point.y;
  264.         hadMouse = 1;
  265.     }        
  266. }
  267.  
  268.  
  269.  
  270. //
  271. // I_StartTic
  272. //
  273. void I_StartTic (void)
  274. {
  275. //    SDL_Event Event;
  276.  
  277. //    while ( SDL_PollEvent(&Event) )
  278. //      I_GetEvent(&Event);
  279.     I_GetEvent();
  280.  
  281. }
  282.  
  283.  
  284. //
  285. // I_UpdateNoBlit
  286. //
  287. void I_UpdateNoBlit (void)
  288. {
  289.     // what is this?
  290. }
  291.  
  292. //
  293. // I_ReadScreen
  294. //
  295. void I_ReadScreen (byte* scr)
  296. {
  297.     memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
  298. }
  299.  
  300.  
  301. //
  302. // I_SetPalette
  303. //
  304.  
  305. typedef struct SDL_Color
  306. {
  307.         byte r;
  308.         byte g;
  309.         byte b;
  310.         byte unused;
  311. } SDL_Color;
  312.  
  313. SDL_Color colors[256];
  314.  
  315. void I_SetPalette (byte* palette)
  316. {
  317.     int i;
  318.     RGBQUAD *rgb;
  319.  
  320. //
  321. //    for ( i=0; i<256; ++i ) {
  322. //      colors[i].r = gammatable[usegamma][*palette++];
  323. //      colors[i].g = gammatable[usegamma][*palette++];
  324. //      colors[i].b = gammatable[usegamma][*palette++];
  325. //      colors[i].unused = 0;
  326. //    }
  327. //    SDL_SetColors(screen, colors, 0, 256);
  328.  
  329.     rgb = bminfo->bmiColors;
  330.     for ( i = 0; i < 256; i++ )
  331.     {
  332.       rgb->rgbRed = gammatable[usegamma][*palette++];
  333.       rgb->rgbGreen = gammatable[usegamma][*palette++];
  334.       rgb->rgbBlue = gammatable[usegamma][*palette++];
  335.       rgb->rgbReserved = 0;
  336.       rgb++;
  337.     };
  338.  
  339.  
  340. }
  341.  
  342.  
  343.  
  344. int makecol(int r, int g, int b)
  345. {
  346.   //  assert(BPP==2);
  347.     return (b >> 3) | ((g >> 3) << 5) | ((r >> 3) << 10);
  348. }
  349.  
  350. int TranslateKey(unsigned k)
  351. {
  352. /*wtf?    if ( (k >= VK_0) && (k <= VK_9) )*/
  353.     if ( (k >= 0x30) && (k <= 0x39) )
  354.         return (k - 0x30 + '0');
  355.     if ( (k >= 0x41) && (k <= 0x5a) )
  356.         return (k - 0x41 + 'a');
  357.  
  358. #define K(a,b) case a: return b;    
  359.     switch ( k )
  360.     {
  361.         K(VK_LEFT, KEY_LEFTARROW);
  362.         K(VK_RIGHT, KEY_RIGHTARROW);
  363.         K(VK_UP, KEY_UPARROW);
  364.         K(VK_DOWN, KEY_DOWNARROW);
  365.         K(VK_BACK, KEY_BACKSPACE);
  366.         K(VK_TAB, KEY_TAB);
  367.         K(VK_RETURN, KEY_ENTER);
  368.         K(VK_SHIFT, KEY_RSHIFT);
  369.         K(VK_CONTROL, KEY_RCTRL);
  370.         K(VK_MENU, KEY_RALT);
  371.         K(VK_PAUSE, KEY_PAUSE);
  372.         K(VK_ESCAPE, KEY_ESCAPE);
  373.         K(VK_SPACE, ' ');
  374.         K(VK_DELETE, KEY_BACKSPACE);
  375.         K(VK_ADD, '+');
  376.         K(VK_SUBTRACT, KEY_MINUS);
  377.         K(0xBC, ',');
  378.         K(0xBE, '.');
  379.         K(VK_F1, KEY_F1);
  380.         K(VK_F2, KEY_F2);
  381.         K(VK_F3, KEY_F3);
  382.         K(VK_F4, KEY_F4);
  383.         K(VK_F5, KEY_F5);
  384.         K(VK_F6, KEY_F6);
  385.         K(VK_F7, KEY_F7);
  386.         K(VK_F8, KEY_F8);
  387.         K(VK_F9, KEY_F9);
  388.         K(VK_F10, KEY_F10);
  389.         K(VK_F11, KEY_F11);
  390.         K(VK_F12, KEY_F12);
  391.     }
  392.  
  393.     return 0;
  394. }
  395.  
  396. void WinError(char *msg)
  397. {
  398.     printf("Windows Error: %s, GetLastError(): %u\n", msg, GetLastError());
  399.     exit(EXIT_FAILURE);
  400. }
  401.  
  402. static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
  403.                                 WPARAM wparam, LPARAM lparam);
  404.  
  405. void BlitDIB(void)
  406. {
  407.     RECT rect;
  408.  
  409.     GetClientRect(win, &rect);
  410.     if ( StretchDIBits(dibDC, rect.left, rect.top, rect.right-rect.left,
  411.                        rect.bottom-rect.top, 0, 0, SCREENWIDTH*2,
  412.                        SCREENHEIGHT*2, dibData, bminfo, DIB_RGB_COLORS,
  413.                          SRCCOPY)
  414.              == GDI_ERROR )
  415.           WinError("StrecthDIBits failed");
  416.        
  417.     GdiFlush();    
  418. }
  419.  
  420.  
  421. void I_InitGraphics(void)
  422. {
  423.     static int firsttime=1;
  424.    
  425.     WNDCLASS wc;
  426.     unsigned i, x, y, j;
  427.     WORD *d;
  428.     unsigned char *b;
  429.     int bits;
  430.     int frameX, frameY, capY;
  431.     RECT rect;
  432.     int width, height;
  433.     RGBQUAD *rgb;
  434.     int retval;
  435.  
  436.     if (!firsttime)
  437.         return;
  438.     firsttime = 0;
  439.  
  440.     if (M_CheckParm("-2"))
  441.         multiply = 2;
  442.  
  443.     if (M_CheckParm("-3"))
  444.         multiply = 3;
  445.  
  446.     if (M_CheckParm("-4"))
  447.         multiply = 4;
  448.  
  449.     X_width = SCREENWIDTH * multiply;
  450.     X_height = SCREENHEIGHT * multiply;
  451.  
  452.     // check if the user wants to grab the mouse (quite unnice)
  453.     grabMouse = !!M_CheckParm("-grabmouse");
  454.  
  455.     /* [Petteri] New: Option to disable mouse vertical movement - useful
  456.        for players used to Quake: */
  457.     disableVerticalMouse = !!M_CheckParm("-novertmouse");
  458.  
  459.     /* Build and initialize the window: */
  460.    
  461.     inst = (HINSTANCE) GetModuleHandle(NULL);
  462.  
  463.     frameX = GetSystemMetrics(SM_CXFRAME);
  464.     frameY = GetSystemMetrics(SM_CYFRAME);
  465.     capY = GetSystemMetrics(SM_CYCAPTION);
  466.  
  467.     wc.style = CS_HREDRAW | CS_VREDRAW;
  468.     wc.lpfnWndProc = WndProc;
  469.     wc.cbClsExtra = 0;
  470.     wc.cbWndExtra = 0;
  471.     wc.hInstance = inst;
  472.     wc.hIcon = NULL;
  473.     if ( grabMouse )
  474.         wc.hCursor = LoadCursor( 0, IDC_ARROW );
  475.     else
  476.         wc.hCursor = LoadCursor( 0, IDC_ARROW );
  477.     /*wc.hbrBackground = GetStockObject( WHITE_BRUSH );*/
  478.     wc.hbrBackground = NULL;    
  479.     wc.lpszMenuName = NULL;
  480.     wc.lpszClassName = "DoomWindowClass";
  481.  
  482.     retval= RegisterClass(&wc);
  483.  
  484.     width = X_width + 2*frameX;
  485.     height = X_height + 2*frameY + capY;
  486.  
  487.     win = CreateWindow("DoomWindowClass", "NTDOOM",
  488.                        WS_OVERLAPPEDWINDOW | WS_VISIBLE, 200, 200, width, height,
  489.                        NULL, NULL, inst, NULL);
  490.  
  491.     /* Display the window: */
  492.     ShowWindow(win, SW_SHOW);
  493.     UpdateWindow(win);
  494.  
  495.     GetClientRect(win, &rect);
  496.     printf("I_InitGraphics: Client area: %ux%u\n",
  497.             rect.right-rect.left, rect.bottom-rect.top);
  498.  
  499.     if ( (rect.right-rect.left) != X_width )
  500.     {
  501.         printf("I_InitGraphics: Fixing width\n");
  502.         width += X_width - (rect.right-rect.left);
  503.         MoveWindow(win, 0, 0, width, height, TRUE);
  504.     }
  505.     if ( (rect.bottom-rect.top) != X_height )
  506.     {
  507.         printf("I_InitGraphics: Fixing height\n");
  508.         height += X_height - (rect.bottom-rect.top);
  509.         MoveWindow(win, 0, 0, width, height, TRUE);
  510.     }
  511.  
  512.     GetClientRect(win, &rect);
  513.     printf("I_InitGraphics: Client area: %ux%u\n",
  514.             rect.right-rect.left, rect.bottom-rect.top);    
  515.        
  516.     dibDC = GetDC(win);
  517.     BPP=1;
  518.     bits = 8; //GetDeviceCaps(dibDC, BITSPIXEL);
  519.     printf("I_InitGraphics: %i bpp screen\n", bits);
  520.  
  521.     if ( BPP == 1 )
  522.         bminfo = malloc(sizeof(BITMAPINFOHEADER) + 4*256);
  523.     else
  524.         bminfo = malloc(sizeof(BITMAPINFOHEADER));
  525.        
  526.  
  527.     if ( BPP == 1 )
  528.     {
  529.        rgb = bminfo->bmiColors;
  530.        for ( i = 0; i < 256; i++ )
  531.        {
  532.           rgb->rgbRed = i;
  533.           rgb->rgbGreen = i;
  534.           rgb->rgbBlue = i;
  535.           rgb->rgbReserved = 0;
  536.           rgb++;
  537.        }
  538.     }
  539.    
  540.     bminfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  541.     bminfo->bmiHeader.biWidth = 640; X_width;
  542.     bminfo->bmiHeader.biHeight = -400 ;X_height;
  543.     bminfo->bmiHeader.biPlanes = 1;
  544.     if ( BPP == 1 )
  545.         bminfo->bmiHeader.biBitCount = 8;
  546.     else
  547.         bminfo->bmiHeader.biBitCount = 16;
  548.     bminfo->bmiHeader.biCompression = BI_RGB;
  549.     bminfo->bmiHeader.biSizeImage = 0;
  550.     bminfo->bmiHeader.biXPelsPerMeter = 0;
  551.     bminfo->bmiHeader.biYPelsPerMeter = 0;
  552.     bminfo->bmiHeader.biClrUsed = 0;
  553.     bminfo->bmiHeader.biClrImportant = 0;
  554.    
  555.     dibData = malloc(640*400*BPP);
  556.  
  557. //    BlitDIB();
  558.  
  559.     screen.pixels=(unsigned char *) (dibData);
  560.     screen.h=400;
  561.     screen.w=640;
  562.     screen.pitch=640;
  563.        
  564.   //  screens[0] = malloc(320*200);
  565.  
  566.     /* Build magic highcolor table: */
  567.     if (BPP==2)
  568.     {
  569.         byte *tempptr, *tempptr2;
  570.  
  571.         tempptr=hicolortable=(byte *)malloc(256*32*9);
  572.        
  573.         for (i=0;i<32;i++)
  574.         {
  575.             for (j=0;j<256;j++)
  576.             {
  577.                 *tempptr=j*gammatable[3][i*(256/32)]/256;
  578.                 tempptr++;
  579.             }
  580.         }
  581.         for (i=1;i<=8;i++)
  582.         {
  583.             tempptr2=hicolortable;
  584.             for (j=0;j<(256*32);j++)
  585.             {
  586.                 *tempptr=(byte)(((int)(*tempptr2))*(8-i)/8);
  587.                 tempptr++; tempptr2++;
  588.             }
  589.         }
  590.         hicolortransmask1=makecol(127,127,127);
  591.         hicolortransmask2=makecol(63,63,63);
  592.     }    
  593. }
  594.  
  595. static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
  596.                                 WPARAM wparam, LPARAM lparam)
  597. {
  598.     event_t event;
  599.     RECT rect;
  600.    
  601.     switch ( message )
  602.     {        
  603.         case WM_DESTROY:
  604.             if ( grabMouse )
  605.             {
  606.                 ClipCursor(NULL);
  607.                 ShowCursor(TRUE);
  608.             }
  609.             printf("WM_DESTROY\n");
  610.             PostQuitMessage(0);
  611.             closed = 1;
  612.             break;
  613.  
  614.         case WM_MOVE:
  615.             GetWindowRect(win, &rect);
  616.             printf("%u,%u - %u, %u\n",
  617.                     rect.left,rect.top,rect.right,rect.bottom);
  618.             ClipCursor(&rect);
  619.             break;
  620.  
  621.         case WM_ACTIVATE:
  622.             printf("WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
  623.             if ( LOWORD(wparam) )
  624.             {
  625.                 if ( !windowActive )
  626.                 {
  627.                     if ( grabMouse )
  628.                     {
  629.                         ClipCursor(NULL); /* helps with Win95? */
  630.                         GetWindowRect(win, &rect);
  631.                         printf("%u,%u - %u, %u\n",
  632.                                 rect.left,rect.top,rect.right,rect.bottom);
  633.                         ClipCursor(&rect);
  634.                         ShowCursor(FALSE);
  635.                     }                    
  636.                 }
  637.                 windowActive = 1;
  638.                 if ( bits8 )
  639.                 {
  640.                     if ( SetPaletteEntries(dibPal, 0, 256, palette->palPalEntry) != 256 )
  641.                         WinError("SetPaletteEntries failed");
  642.                     if ( !UnrealizeObject(dibPal) )
  643.                         WinError("UnrealizeObject failed");
  644.                     if ( SelectPalette(dibDC, dibPal, FALSE) == NULL )
  645.                         WinError("SelectPalette failed");
  646.                 }
  647.             }
  648.             else
  649.             {
  650.                 if ( grabMouse )
  651.                 {
  652.                     ClipCursor(NULL);
  653.                     ShowCursor(TRUE);
  654.                 }
  655.                 windowActive = 0;
  656.             }
  657.             return DefWindowProc(hwnd, message, wparam, lparam);
  658.  
  659.         case WM_KEYDOWN:
  660.             event.type = ev_keydown;
  661.             event.data1 = TranslateKey(wparam);
  662.             if ( event.data1 != 0 )
  663.                 D_PostEvent(&event);
  664.             break;
  665.  
  666.         case WM_KEYUP:
  667.             event.type = ev_keyup;
  668.             event.data1 = TranslateKey(wparam);
  669.             if ( event.data1 != 0 )
  670.                 D_PostEvent(&event);
  671.             break;            
  672.            
  673.         default:
  674.             return(DefWindowProc(hwnd, message, wparam, lparam));
  675.     }
  676.  
  677.     return 0;
  678. }
  679.  
  680. //
  681. // I_FinishUpdate
  682. //
  683. void I_FinishUpdate (void)
  684. {
  685.  
  686.     static int  lasttic;
  687.     int         tics;
  688.     int         i;
  689.  
  690.     // draws little dots on the bottom of the screen
  691.     if (devparm)
  692.     { i = I_GetTime();
  693.        
  694.           tics = i - lasttic;
  695.           lasttic = i;
  696.           if (tics > 20)
  697.             tics = 20;
  698.  
  699.           for (i=0 ; i<tics*2 ; i+=2)
  700.             screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
  701.           for ( ; i<20*2 ; i+=2)
  702.             screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
  703.     }
  704.  
  705.     // scales the screen size before blitting it
  706.     if (multiply == 1)
  707.     {
  708.           unsigned char *olineptr;
  709.           unsigned char *ilineptr;
  710.           int y;
  711.  
  712.           ilineptr = (unsigned char *) screens[0];
  713.           olineptr = (unsigned char *) screen.pixels;
  714.  
  715.           y = SCREENHEIGHT;
  716.           while (y--)
  717.           {
  718.             memcpy(olineptr, ilineptr, screen.w);
  719.             ilineptr += SCREENWIDTH;
  720.             olineptr += screen.pitch;
  721.           }
  722.     }
  723.     else if (multiply == 2)
  724.     {
  725.         unsigned int *olineptrs[2];
  726.         unsigned int *ilineptr;
  727.         int x, y, i;
  728.         unsigned int twoopixels;
  729.         unsigned int twomoreopixels;
  730.         unsigned int fouripixels;
  731.  
  732.         ilineptr = (unsigned int *) (screens[0]);
  733.         for (i=0 ; i<2 ; i++) {
  734.             olineptrs[i] =
  735.                 (unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
  736.         }
  737.  
  738.         y = SCREENHEIGHT;
  739.         while (y--)
  740.         {
  741.             x = SCREENWIDTH;
  742.             do
  743.             {
  744.                 fouripixels = *ilineptr++;
  745.                 twoopixels =    (fouripixels & 0xff000000)
  746.                     |   ((fouripixels>>8) & 0xffff00)
  747.                     |   ((fouripixels>>16) & 0xff);
  748.                 twomoreopixels =        ((fouripixels<<16) & 0xff000000)
  749.                     |   ((fouripixels<<8) & 0xffff00)
  750.                     |   (fouripixels & 0xff);
  751.                 *olineptrs[0]++ = twomoreopixels;
  752.                 *olineptrs[1]++ = twomoreopixels;
  753.                 *olineptrs[0]++ = twoopixels;
  754.                 *olineptrs[1]++ = twoopixels;
  755.             } while (x-=4);
  756.             olineptrs[0] += screen.pitch/4;
  757.             olineptrs[1] += screen.pitch/4;
  758.         }
  759.  
  760.     }
  761.     else if (multiply == 3)
  762.     {
  763.         unsigned int *olineptrs[3];
  764.         unsigned int *ilineptr;
  765.         int x, y, i;
  766.         unsigned int fouropixels[3];
  767.         unsigned int fouripixels;
  768.  
  769.         ilineptr = (unsigned int *) (screens[0]);
  770.         for (i=0 ; i<3 ; i++) {
  771.             olineptrs[i] =
  772.                 (unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
  773.         }
  774.  
  775.         y = SCREENHEIGHT;
  776.         while (y--)
  777.         {
  778.             x = SCREENWIDTH;
  779.             do
  780.             {
  781.                 fouripixels = *ilineptr++;
  782.                 fouropixels[0] = (fouripixels & 0xff000000)
  783.                     |   ((fouripixels>>8) & 0xff0000)
  784.                     |   ((fouripixels>>16) & 0xffff);
  785.                 fouropixels[1] = ((fouripixels<<8) & 0xff000000)
  786.                     |   (fouripixels & 0xffff00)
  787.                     |   ((fouripixels>>8) & 0xff);
  788.                 fouropixels[2] = ((fouripixels<<16) & 0xffff0000)
  789.                     |   ((fouripixels<<8) & 0xff00)
  790.                     |   (fouripixels & 0xff);
  791.                 *olineptrs[0]++ = fouropixels[2];
  792.                 *olineptrs[1]++ = fouropixels[2];
  793.                 *olineptrs[2]++ = fouropixels[2];
  794.                 *olineptrs[0]++ = fouropixels[1];
  795.                 *olineptrs[1]++ = fouropixels[1];
  796.                 *olineptrs[2]++ = fouropixels[1];
  797.                 *olineptrs[0]++ = fouropixels[0];
  798.                 *olineptrs[1]++ = fouropixels[0];
  799.                 *olineptrs[2]++ = fouropixels[0];
  800.             } while (x-=4);
  801.             olineptrs[0] += 2*screen.pitch/4;
  802.             olineptrs[1] += 2*screen.pitch/4;
  803.             olineptrs[2] += 2*screen.pitch/4;
  804.         }
  805.  
  806.     }
  807.    BlitDIB();
  808. }
  809.  
  810.  
  811.  
  812.  
  813. /**
  814. void I_InitGraphics(void)
  815. {
  816.  
  817.     static int  firsttime=1;
  818.     int video_w, video_h, w, h;
  819.     byte video_bpp;
  820.     unsigned int video_flags;
  821.  
  822.     if (!firsttime)
  823.         return;
  824.     firsttime = 0;
  825.  
  826.     video_flags = (SDL_SWSURFACE|SDL_HWPALETTE);
  827.     if (!!M_CheckParm("-fullscreen"))
  828.         video_flags |= SDL_FULLSCREEN;
  829.  
  830.     if (M_CheckParm("-2"))
  831.         multiply = 2;
  832.  
  833.     if (M_CheckParm("-3"))
  834.         multiply = 3;
  835.  
  836.     // check if the user wants to grab the mouse (quite unnice)
  837.     grabMouse = !!M_CheckParm("-grabmouse");
  838.  
  839.     video_w = w = SCREENWIDTH * multiply;
  840.     video_h = h = SCREENHEIGHT * multiply;
  841.     video_bpp = 8;
  842.  
  843.  
  844.     if ( multiply > 3 ) {
  845.         I_Error("Smallest available mode (%dx%d) is too large!",
  846.                                                 video_w, video_h);
  847.     }
  848.     screen = SDL_SetVideoMode(video_w, video_h, 8, video_flags);
  849.     if ( screen == NULL ) {
  850.         I_Error("Could not set %dx%d video mode: %s", video_w, video_h,
  851.                                                         SDL_GetError());
  852.     }
  853.     SDL_ShowCursor(0);
  854.     SDL_WM_SetCaption("MenuetOS-DOOM", "doom");
  855.  
  856.      w = SCREENWIDTH * multiply;
  857.     h = SCREENHEIGHT * multiply;
  858.     if (multiply == 1 && !SDL_MUSTLOCK(screen) ) {
  859.         screens[0] = (unsigned char *) screen->pixels;
  860.     } else {
  861.         screens[0] = (unsigned char *) malloc (SCREENWIDTH * SCREENHEIGHT);
  862.         if ( screens[0] == NULL )
  863.             I_Error("Couldn't allocate screen memory");
  864.     }
  865. }
  866. *****/