开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
i_video.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：23k
源码类别：

射击游戏

开发平台：

Visual C++

i_video.c：源码内容
  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 X11, UNIX.
  21. //
  22. //-----------------------------------------------------------------------------
  24. static const char
  25. rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
  27. #include <stdlib.h>
  28. //#include <unistd.h>
  29. //#include <sys/ipc.h>
  30. //#include <sys/shm.h>
  32. //#include <X11/Xlib.h>
  33. //#include <X11/Xutil.h>
  34. //#include <X11/keysym.h>
  36. //#include <X11/extensions/XShm.h>
  37. // Had to dig up XShm.c for this one.
  38. // It is in the libXext, but not in the XFree86 headers.
  39. #ifdef LINUX
  40. int XShmGetEventBase( Display* dpy ); // problems with g++?
  41. #endif
  43. #include <stdarg.h>
  44. #include <time.h>
  45. #include <sys/types.h>
  46. //#include <sys/socket.h>
  48. //#include <netinet/in.h>
  49. //#include <errnos.h>
  50. #include <signal.h>
  51. #include <ddraw.h>
  53. #include "doomstat.h"
  54. #include "i_system.h"
  55. #include "v_video.h"
  56. #include "m_argv.h"
  57. #include "d_main.h"
  59. #include "doomdef.h"
  61. #define POINTER_WARP_COUNTDOWN 1
  63. //FIXME
  64. void RenderScene(void);
  66. /*
  67. Display* X_display=0;
  68. Window X_mainWindow;
  69. Colormap X_cmap;
  70. Visual* X_visual;
  71. GC X_gc;
  72. XEvent X_event;
  73. int X_screen;
  74. XVisualInfo X_visualinfo;
  75. XImage* image;
  76. int X_width;
  77. int X_height;
  78. // MIT SHared Memory extension.
  79. boolean doShm;
  82. XShmSegmentInfo X_shminfo;
  83. int X_shmeventtype;
  85. int doPointerWarp = POINTER_WARP_COUNTDOWN;
  86. */
  87. // Fake mouse handling.
  88. // This cannot work properly w/o DGA.
  89. // Needs an invisible mouse cursor at least.
  90. boolean grabMouse;
  91. // Blocky mode,
  92. // replace each 320x200 pixel with multiply*multiply pixels.
  93. // According to Dave Taylor, it still is a bonehead thing
  94. // to use ....
  95. static int multiply=1;
  98. //
  99. //  Translates the key currently in X_event
  100. //
  102. int xlatekey(void)
  103. {
  104. /*
  105.     int rc;
  107.     switch(rc = XKeycodeToKeysym(X_display, X_event.xkey.keycode, 0))
  108.     {
  109.       case XK_Left: rc = KEY_LEFTARROW; break;
  110.       case XK_Right: rc = KEY_RIGHTARROW; break;
  111.       case XK_Down: rc = KEY_DOWNARROW; break;
  112.       case XK_Up: rc = KEY_UPARROW; break;
  113.       case XK_Escape: rc = KEY_ESCAPE; break;
  114.       case XK_Return: rc = KEY_ENTER; break;
  115.       case XK_Tab: rc = KEY_TAB; break;
  116.       case XK_F1: rc = KEY_F1; break;
  117.       case XK_F2: rc = KEY_F2; break;
  118.       case XK_F3: rc = KEY_F3; break;
  119.       case XK_F4: rc = KEY_F4; break;
  120.       case XK_F5: rc = KEY_F5; break;
  121.       case XK_F6: rc = KEY_F6; break;
  122.       case XK_F7: rc = KEY_F7; break;
  123.       case XK_F8: rc = KEY_F8; break;
  124.       case XK_F9: rc = KEY_F9; break;
  125.       case XK_F10: rc = KEY_F10; break;
  126.       case XK_F11: rc = KEY_F11; break;
  127.       case XK_F12: rc = KEY_F12; break;
  129.       case XK_BackSpace:
  130.       case XK_Delete: rc = KEY_BACKSPACE; break;
  132.       case XK_Pause: rc = KEY_PAUSE; break;
  134.       case XK_KP_Equal:
  135.       case XK_equal: rc = KEY_EQUALS; break;
  137.       case XK_KP_Subtract:
  138.       case XK_minus: rc = KEY_MINUS; break;
  140.       case XK_Shift_L:
  141.       case XK_Shift_R:
  142. rc = KEY_RSHIFT;
  143. break;
  145.       case XK_Control_L:
  146.       case XK_Control_R:
  147. rc = KEY_RCTRL;
  148. break;
  150.       case XK_Alt_L:
  151.       case XK_Meta_L:
  152.       case XK_Alt_R:
  153.       case XK_Meta_R:
  154. rc = KEY_RALT;
  155. break;
  157.       default:
  158. if (rc >= XK_space && rc <= XK_asciitilde)
  159.     rc = rc - XK_space + ' ';
  160. if (rc >= 'A' && rc <= 'Z')
  161.     rc = rc - 'A' + 'a';
  162. break;
  163.     }
  164.     return rc;
  165. */
  166.   return 0;
  168. }
  170. void I_ShutdownGraphics(void)
  171. {
  172. /*
  173.   // Detach from X server
  174.   if (!XShmDetach(X_display, &X_shminfo))
  175.     I_Error("XShmDetach() failed in I_ShutdownGraphics()");
  177.   // Release shared memory.
  178.   shmdt(X_shminfo.shmaddr);
  179.   shmctl(X_shminfo.shmid, IPC_RMID, 0);
  181.   // Paranoia.
  182.   image->data = NULL;
  183. */
  184. }
  188. //
  189. // I_StartFrame
  190. //
  191. void I_StartFrame (void)
  192. {
  193.     // er?
  195. }
  197. static int lastmousex = 0;
  198. static int lastmousey = 0;
  199. boolean mousemoved = false;
  200. boolean shmFinished;
  202. void I_GetEvent(void)
  203. {
  204. /*
  205.     event_t event;
  207.     // put event-grabbing stuff in here
  208.     XNextEvent(X_display, &X_event);
  209.     switch (X_event.type)
  210.     {
  211.       case KeyPress:
  212. event.type = ev_keydown;
  213. event.data1 = xlatekey();
  214. D_PostEvent(&event);
  215. // fprintf(stderr, "k");
  216. break;
  217.       case KeyRelease:
  218. event.type = ev_keyup;
  219. event.data1 = xlatekey();
  220. D_PostEvent(&event);
  221. // fprintf(stderr, "ku");
  222. break;
  223.       case ButtonPress:
  224. event.type = ev_mouse;
  225. event.data1 =
  226.     (X_event.xbutton.state & Button1Mask)
  227.     | (X_event.xbutton.state & Button2Mask ? 2 : 0)
  228.     | (X_event.xbutton.state & Button3Mask ? 4 : 0)
  229.     | (X_event.xbutton.button == Button1)
  230.     | (X_event.xbutton.button == Button2 ? 2 : 0)
  231.     | (X_event.xbutton.button == Button3 ? 4 : 0);
  232. event.data2 = event.data3 = 0;
  233. D_PostEvent(&event);
  234. // fprintf(stderr, "b");
  235. break;
  236.       case ButtonRelease:
  237. event.type = ev_mouse;
  238. event.data1 =
  239.     (X_event.xbutton.state & Button1Mask)
  240.     | (X_event.xbutton.state & Button2Mask ? 2 : 0)
  241.     | (X_event.xbutton.state & Button3Mask ? 4 : 0);
  242. // suggest parentheses around arithmetic in operand of |
  243. event.data1 =
  244.     event.data1
  245.     ^ (X_event.xbutton.button == Button1 ? 1 : 0)
  246.     ^ (X_event.xbutton.button == Button2 ? 2 : 0)
  247.     ^ (X_event.xbutton.button == Button3 ? 4 : 0);
  248. event.data2 = event.data3 = 0;
  249. D_PostEvent(&event);
  250. // fprintf(stderr, "bu");
  251. break;
  252.       case MotionNotify:
  253. event.type = ev_mouse;
  254. event.data1 =
  255.     (X_event.xmotion.state & Button1Mask)
  256.     | (X_event.xmotion.state & Button2Mask ? 2 : 0)
  257.     | (X_event.xmotion.state & Button3Mask ? 4 : 0);
  258. event.data2 = (X_event.xmotion.x - lastmousex) << 2;
  259. event.data3 = (lastmousey - X_event.xmotion.y) << 2;
  261. if (event.data2 || event.data3)
  262. {
  263.     lastmousex = X_event.xmotion.x;
  264.     lastmousey = X_event.xmotion.y;
  265.     if (X_event.xmotion.x != X_width/2 &&
  266. X_event.xmotion.y != X_height/2)
  267.     {
  268. D_PostEvent(&event);
  269. // fprintf(stderr, "m");
  270. mousemoved = false;
  271.     } else
  272.     {
  273. mousemoved = true;
  274.     }
  275. }
  276. break;
  278.       case Expose:
  279.       case ConfigureNotify:
  280. break;
  282.       default:
  283. if (doShm && X_event.type == X_shmeventtype) shmFinished = true;
  284. break;
  285.     }
  287. */
  288. }
  290. /*
  291. Cursor
  292. createnullcursor
  293. ( Display* display,
  294.   Window root )
  295. {
  296.     Pixmap cursormask;
  297.     XGCValues xgc;
  298.     GC gc;
  299.     XColor dummycolour;
  300.     Cursor cursor;
  302.     cursormask = XCreatePixmap(display, root, 1, 1, 1 ); // depth
  303.     xgc.function = GXclear;
  304.     gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
  305.     XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
  306.     dummycolour.pixel = 0;
  307.     dummycolour.red = 0;
  308.     dummycolour.flags = 04;
  309.     cursor = XCreatePixmapCursor(display, cursormask, cursormask,
  310.  &dummycolour,&dummycolour, 0,0);
  311.     XFreePixmap(display,cursormask);
  312.     XFreeGC(display,gc);
  313.     return cursor;
  314. }
  315. */
  317. //
  318. // I_StartTic
  319. //
  320. void I_StartTic (void)
  321. {
  322. /*
  323.     if (!X_display)
  324. return;
  325.     while (XPending(X_display))
  326. */
  327. I_GetEvent();
  329. /*
  330.     // Warp the pointer back to the middle of the window
  331.     //  or it will wander off - that is, the game will
  332.     //  loose input focus within X11.
  333.     if (grabMouse)
  334.     {
  335. if (!--doPointerWarp)
  336. {
  337.     XWarpPointer( X_display,
  338.   None,
  339.   X_mainWindow,
  340.   0, 0,
  341.   0, 0,
  342.   X_width/2, X_height/2);
  344.     doPointerWarp = POINTER_WARP_COUNTDOWN;
  345. }
  346.     }
  347. */
  349.     mousemoved = false;
  350. }
  353. //
  354. // I_UpdateNoBlit
  355. //
  356. void I_UpdateNoBlit (void)
  357. {
  358.     // what is this?
  359. }
  361. //
  362. // I_FinishUpdate
  363. //
  364. char MsgText[256];
  365. void WriteDebug(char *);
  367. void I_FinishUpdate(void)
  368. {
  369.     static int lasttic;
  370.     int tics;
  371.     int i;
  372.     // UNUSED static unsigned char *bigscreen=0;
  374.     // draws little dots on the bottom of the screen
  375.     if (devparm)
  376.     {
  377. i = I_GetTime();
  378. tics = i - lasttic;
  379. lasttic = i;
  380. if (tics > 20)
  381.        tics = 20;
  383. for (i = 0; i < tics*2; i += 2)
  384.     screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
  385. for ( ; i < 20*2; i += 2)
  386.     screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
  387.     }
  388.     RenderScene();
  389. /*
  391.     // scales the screen size before blitting it
  392.     if (multiply == 2)
  393.     {
  394. unsigned int *olineptrs[2];
  395. unsigned int *ilineptr;
  396. int x, y, i;
  397. unsigned int twoopixels;
  398. unsigned int twomoreopixels;
  399. unsigned int fouripixels;
  401. ilineptr = (unsigned int *) (screens[0]);
  402. for (i=0 ; i<2 ; i++)
  403.     olineptrs[i] = (unsigned int *) &image->data[i*X_width];
  405. y = SCREENHEIGHT;
  406. while (y--)
  407. {
  408.     x = SCREENWIDTH;
  409.     do
  410.     {
  411. fouripixels = *ilineptr++;
  412. twoopixels = (fouripixels & 0xff000000)
  413.     | ((fouripixels>>8) & 0xffff00)
  414.     | ((fouripixels>>16) & 0xff);
  415. twomoreopixels = ((fouripixels<<16) & 0xff000000)
  416.     | ((fouripixels<<8) & 0xffff00)
  417.     | (fouripixels & 0xff);
  418. #ifdef __BIG_ENDIAN__
  419. *olineptrs[0]++ = twoopixels;
  420. *olineptrs[1]++ = twoopixels;
  421. *olineptrs[0]++ = twomoreopixels;
  422. *olineptrs[1]++ = twomoreopixels;
  423. #else
  424. *olineptrs[0]++ = twomoreopixels;
  425. *olineptrs[1]++ = twomoreopixels;
  426. *olineptrs[0]++ = twoopixels;
  427. *olineptrs[1]++ = twoopixels;
  428. #endif
  429.     } while (x-=4);
  430.     olineptrs[0] += X_width/4;
  431.     olineptrs[1] += X_width/4;
  432. }
  434.     }
  435.     else if (multiply == 3)
  436.     {
  437. unsigned int *olineptrs[3];
  438. unsigned int *ilineptr;
  439. int x, y, i;
  440. unsigned int fouropixels[3];
  441. unsigned int fouripixels;
  443. ilineptr = (unsigned int *) (screens[0]);
  444. for (i=0 ; i<3 ; i++)
  445.     olineptrs[i] = (unsigned int *) &image->data[i*X_width];
  447. y = SCREENHEIGHT;
  448. while (y--)
  449. {
  450.     x = SCREENWIDTH;
  451.     do
  452.     {
  453. fouripixels = *ilineptr++;
  454. fouropixels[0] = (fouripixels & 0xff000000)
  455.     | ((fouripixels>>8) & 0xff0000)
  456.     | ((fouripixels>>16) & 0xffff);
  457. fouropixels[1] = ((fouripixels<<8) & 0xff000000)
  458.     | (fouripixels & 0xffff00)
  459.     | ((fouripixels>>8) & 0xff);
  460. fouropixels[2] = ((fouripixels<<16) & 0xffff0000)
  461.     | ((fouripixels<<8) & 0xff00)
  462.     | (fouripixels & 0xff);
  463. #ifdef __BIG_ENDIAN__
  464. *olineptrs[0]++ = fouropixels[0];
  465. *olineptrs[1]++ = fouropixels[0];
  466. *olineptrs[2]++ = fouropixels[0];
  467. *olineptrs[0]++ = fouropixels[1];
  468. *olineptrs[1]++ = fouropixels[1];
  469. *olineptrs[2]++ = fouropixels[1];
  470. *olineptrs[0]++ = fouropixels[2];
  471. *olineptrs[1]++ = fouropixels[2];
  472. *olineptrs[2]++ = fouropixels[2];
  473. #else
  474. *olineptrs[0]++ = fouropixels[2];
  475. *olineptrs[1]++ = fouropixels[2];
  476. *olineptrs[2]++ = fouropixels[2];
  477. *olineptrs[0]++ = fouropixels[1];
  478. *olineptrs[1]++ = fouropixels[1];
  479. *olineptrs[2]++ = fouropixels[1];
  480. *olineptrs[0]++ = fouropixels[0];
  481. *olineptrs[1]++ = fouropixels[0];
  482. *olineptrs[2]++ = fouropixels[0];
  483. #endif
  484.     } while (x-=4);
  485.     olineptrs[0] += 2*X_width/4;
  486.     olineptrs[1] += 2*X_width/4;
  487.     olineptrs[2] += 2*X_width/4;
  488. }
  490.     }
  491.     else if (multiply == 4)
  492.     {
  493. // Broken. Gotta fix this some day.
  494. void Expand4(unsigned *, double *);
  495.    Expand4 ((unsigned *)(screens[0]), (double *) (image->data));
  496.     }
  498.     if (doShm)
  499.     {
  501. if (!XShmPutImage( X_display,
  502. X_mainWindow,
  503. X_gc,
  504. image,
  505. 0, 0,
  506. 0, 0,
  507. X_width, X_height,
  508. True ))
  509.     I_Error("XShmPutImage() failedn");
  511. // wait for it to finish and processes all input events
  512. shmFinished = false;
  513. do
  514. {
  515.     I_GetEvent();
  516. } while (!shmFinished);
  518.     }
  519.     else
  520.     {
  522. // draw the image
  523. XPutImage( X_display,
  524. X_mainWindow,
  525. X_gc,
  526. image,
  527. 0, 0,
  528. 0, 0,
  529. X_width, X_height );
  531. // sync up with server
  532. XSync(X_display, False);
  534.     }
  535. */
  536. }
  539. //
  540. // I_ReadScreen
  541. //
  542. void I_ReadScreen (byte* scr)
  543. {
  544.     memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
  545. }
  547. extern LPDIRECTDRAWPALETTE lpPalette;
  549. //
  550. // Palette stuff.
  551. //
  552. //
  553. // I_SetPalette
  554. //
  555. void I_SetPalette(byte* palette)
  556.    {
  557.     PALETTEENTRY pe[256];
  558.     int i;
  560.     for (i = 0; i < 256; i++)
  561.        {
  562.         pe[i].peRed = gammatable[usegamma][*palette++];
  563.         pe[i].peGreen = gammatable[usegamma][*palette++];
  564.         pe[i].peBlue = gammatable[usegamma][*palette++];
  565.        }
  566.     if (lpPalette != 0)
  567.         lpPalette->lpVtbl->SetEntries(lpPalette, 0, 0, 256, pe);
  568. }
  570. /*
  571. //
  572. // This function is probably redundant,
  573. //  if XShmDetach works properly.
  574. // ddt never detached the XShm memory,
  575. //  thus there might have been stale
  576. //  handles accumulating.
  577. //
  578. void grabsharedmemory(int size)
  579. {
  581.   int key = ('d'<<24) | ('o'<<16) | ('o'<<8) | 'm';
  582.   struct shmid_ds shminfo;
  583.   int minsize = 320*200;
  584.   int id;
  585.   int rc;
  586.   // UNUSED int done=0;
  587.   int pollution=5;
  588.   
  589.   // try to use what was here before
  590.   do
  591.   {
  592.     id = shmget((key_t) key, minsize, 0777); // just get the id
  593.     if (id != -1)
  594.     {
  595.       rc=shmctl(id, IPC_STAT, &shminfo); // get stats on it
  596.       if (!rc) 
  597.       {
  598. if (shminfo.shm_nattch)
  599. {
  600.   fprintf(stderr, "User %d appears to be running "
  601.   "DOOM.  Is that wise?n", shminfo.shm_cpid);
  602.   key++;
  603. }
  604. else
  605. {
  606.   if (getuid() == shminfo.shm_perm.cuid)
  607.   {
  608.     rc = shmctl(id, IPC_RMID, 0);
  609.     if (!rc)
  610.       fprintf(stderr,
  611.       "Was able to kill my old shared memoryn");
  612.     else
  613.       I_Error("Was NOT able to kill my old shared memory");
  614.     
  615.     id = shmget((key_t)key, size, IPC_CREAT|0777);
  616.     if (id==-1)
  617.       I_Error("Could not get shared memory");
  618.     
  619.     rc=shmctl(id, IPC_STAT, &shminfo);
  620.     
  621.     break;
  622.     
  623.   }
  624.   if (size >= shminfo.shm_segsz)
  625.   {
  626.     fprintf(stderr,
  627.     "will use %d's stale shared memoryn",
  628.     shminfo.shm_cpid);
  629.     break;
  630.   }
  631.   else
  632.   {
  633.     fprintf(stderr,
  634.     "warning: can't use stale "
  635.     "shared memory belonging to id %d, "
  636.     "key=0x%xn",
  637.     shminfo.shm_cpid, key);
  638.     key++;
  639.   }
  640. }
  641.       }
  642.       else
  643.       {
  644. I_Error("could not get stats on key=%d", key);
  645.       }
  646.     }
  647.     else
  648.     {
  649.       id = shmget((key_t)key, size, IPC_CREAT|0777);
  650.       if (id==-1)
  651.       {
  652. extern int errno;
  653. fprintf(stderr, "errno=%dn", errno);
  654. I_Error("Could not get any shared memory");
  655.       }
  656.       break;
  657.     }
  658.   } while (--pollution);
  659.   
  660.   if (!pollution)
  661.   {
  662.     I_Error("Sorry, system too polluted with stale "
  663.     "shared memory segments.n");
  664.     }
  665.   
  666.   X_shminfo.shmid = id;
  667.   
  668.   // attach to the shared memory segment
  669.   image->data = X_shminfo.shmaddr = shmat(id, 0, 0);
  670.   
  671.   fprintf(stderr, "shared memory id=%d, addr=0x%xn", id,
  672.   (int) (image->data));
  673. }
  674. */
  675. void I_InitGraphics(void)
  676. {
  677.     char* displayname;
  678. //    char* d;
  679.     int n;
  680.     int pnum;
  681.     int x=0;
  682.     int y=0;
  683.     
  684.     // warning: char format, different type arg
  685.     char xsign=' ';
  686.     char ysign=' ';
  687.     
  688. //    int oktodraw;
  689. //    unsigned long attribmask;
  690.     //XSetWindowAttributes attribs;
  691.     //XGCValues xgcvalues;
  692. //    int valuemask;
  693.     static int firsttime=1;
  695.     if (!firsttime)
  696. return;
  697.     firsttime = 0;
  699.     //signal(SIGINT, (void (*)(int)) I_Quit);
  701.     if (M_CheckParm("-2"))
  702. multiply = 2;
  704.     if (M_CheckParm("-3"))
  705. multiply = 3;
  707.     if (M_CheckParm("-4"))
  708. multiply = 4;
  710.     //X_width = SCREENWIDTH * multiply;
  711.     //X_height = SCREENHEIGHT * multiply;
  713.     // check for command-line display name
  714.     if ( (pnum=M_CheckParm("-disp")) ) // suggest parentheses around assignment
  715. displayname = myargv[pnum+1];
  716.     else
  717. displayname = 0;
  719.     // check if the user wants to grab the mouse (quite unnice)
  720.     grabMouse = !!M_CheckParm("-grabmouse");
  722.     // check for command-line geometry
  723.     if ( (pnum=M_CheckParm("-geom")) ) // suggest parentheses around assignment
  724.     {
  725. // warning: char format, different type arg 3,5
  726. n = sscanf(myargv[pnum+1], "%c%d%c%d", &xsign, &x, &ysign, &y);
  728. if (n==2)
  729.     x = y = 0;
  730. else if (n==6)
  731. {
  732.     if (xsign == '-')
  733. x = -x;
  734.     if (ysign == '-')
  735. y = -y;
  736. }
  737. else
  738.     I_Error("bad -geom parameter");
  739.     }
  740. /*
  741.     // open the display
  742.     X_display = XOpenDisplay(displayname);
  743.     if (!X_display)
  744.     {
  745. if (displayname)
  746.     I_Error("Could not open display [%s]", displayname);
  747. else
  748.     I_Error("Could not open display (DISPLAY=[%s])", getenv("DISPLAY"));
  749.     }
  750.     // use the default visual 
  751. //    X_screen = DefaultScreen(X_display);
  752. //    if (!XMatchVisualInfo(X_display, X_screen, 8, PseudoColor, &X_visualinfo))
  753. // I_Error("xdoom currently only supports 256-color PseudoColor screens");
  754. //    X_visual = X_visualinfo.visual;
  756.     // check for the MITSHM extension
  757. //    doShm = XShmQueryExtension(X_display);
  759.     // even if it's available, make sure it's a local connection
  760.     if (doShm)
  761.     {
  762. if (!displayname) displayname = (char *) getenv("DISPLAY");
  763. if (displayname)
  764. {
  765.     d = displayname;
  766.     while (*d && (*d != ':')) d++;
  767.     if (*d) *d = 0;
  768.     if (!(!strcasecmp(displayname, "unix") || !*displayname)) doShm = false;
  769. }
  770.     }
  772.     fprintf(stderr, "Using MITSHM extensionn");
  774.     // create the colormap
  775.     X_cmap = XCreateColormap(X_display, RootWindow(X_display,
  776.    X_screen), X_visual, AllocAll);
  778.     // setup attributes for main window
  779.     attribmask = CWEventMask | CWColormap | CWBorderPixel;
  780.     attribs.event_mask =
  781. // KeyPressMask
  782. // | KeyReleaseMask
  783. | PointerMotionMask | ButtonPressMask | ButtonReleaseMask
  784. // | ExposureMask;
  786. //    attribs.colormap = X_cmap;
  787. //    attribs.border_pixel = 0;
  789.     // create the main window
  790.     X_mainWindow = XCreateWindow( X_display,
  791. RootWindow(X_display, X_screen),
  792. x, y,
  793. X_width, X_height,
  794. 0, // borderwidth
  795. 8, // depth
  796. InputOutput,
  797. X_visual,
  798. attribmask,
  799. &attribs );
  801.     XDefineCursor(X_display, X_mainWindow,
  802.   createnullcursor( X_display, X_mainWindow ) );
  804.     // create the GC
  805.     valuemask = GCGraphicsExposures;
  806.     xgcvalues.graphics_exposures = False;
  807.     X_gc = XCreateGC( X_display,
  808.    X_mainWindow,
  809.    valuemask,
  810.    &xgcvalues );
  812.     // map the window
  813.     XMapWindow(X_display, X_mainWindow);
  814.     // wait until it is OK to draw
  815.     oktodraw = 0;
  816.     while (!oktodraw)
  817.     {
  818. // XNextEvent(X_display, &X_event);
  819. // if (X_event.type == Expose
  820. //     && !X_event.xexpose.count)
  821. {
  822.     oktodraw = 1;
  823. }
  824.     }
  826.     // grabs the pointer so it is restricted to this window
  827.     if (grabMouse)
  828. XGrabPointer(X_display, X_mainWindow, True,
  829.      ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
  830.      GrabModeAsync, GrabModeAsync,
  831.      X_mainWindow, None, CurrentTime);
  833.     if (doShm)
  834.     {
  836. X_shmeventtype = XShmGetEventBase(X_display) + ShmCompletion;
  838. // create the image
  839. image = XShmCreateImage( X_display,
  840. X_visual,
  841. 8,
  842. ZPixmap,
  843. 0,
  844. &X_shminfo,
  845. X_width,
  846. X_height );
  848. grabsharedmemory(image->bytes_per_line * image->height);
  851. // UNUSED
  852. // create the shared memory segment
  853. // X_shminfo.shmid = shmget (IPC_PRIVATE,
  854. // image->bytes_per_line * image->height, IPC_CREAT | 0777);
  855. // if (X_shminfo.shmid < 0)
  856. // {
  857. // perror("");
  858. // I_Error("shmget() failed in InitGraphics()");
  859. // }
  860. // fprintf(stderr, "shared memory id=%dn", X_shminfo.shmid);
  861. // attach to the shared memory segment
  862. // image->data = X_shminfo.shmaddr = shmat(X_shminfo.shmid, 0, 0);
  865. if (!image->data)
  866. {
  867.     perror("");
  868.     I_Error("shmat() failed in InitGraphics()");
  869. }
  871. // get the X server to attach to it
  872. if (!XShmAttach(X_display, &X_shminfo))
  873.     I_Error("XShmAttach() failed in InitGraphics()");
  875.     }
  876.     else
  877.     {
  878. image = XCreateImage( X_display,
  879.      X_visual,
  880.      8,
  881.      ZPixmap,
  882.      0,
  883.      (char*)malloc(X_width * X_height),
  884.      X_width, X_height,
  885.      8,
  886.      X_width );
  888.     }
  890.     if (multiply == 1)
  891. screens[0] = (unsigned char *) (image->data);
  892.     else
  893. screens[0] = (unsigned char *) malloc (SCREENWIDTH * SCREENHEIGHT);
  894. */
  895. }
  898. unsigned exptable[256];
  900. void InitExpand (void)
  901. {
  902.     int i;
  904.     for (i=0 ; i<256 ; i++)
  905. exptable[i] = i | (i<<8) | (i<<16) | (i<<24);
  906. }
  908. double exptable2[256*256];
  910. void InitExpand2 (void)
  911. {
  912.     int i;
  913.     int j;
  914.     // UNUSED unsigned iexp, jexp;
  915.     double* exp;
  916.     union
  917.     {
  918. double  d;
  919. unsigned u[2];
  920.     } pixel;
  922.     printf ("building exptable2...n");
  923.     exp = exptable2;
  924.     for (i=0 ; i<256 ; i++)
  925.     {
  926. pixel.u[0] = i | (i<<8) | (i<<16) | (i<<24);
  927. for (j=0 ; j<256 ; j++)
  928. {
  929.     pixel.u[1] = j | (j<<8) | (j<<16) | (j<<24);
  930.     *exp++ = pixel.d;
  931. }
  932.     }
  933.     printf ("done.n");
  934. }
  936. int inited;
  938. void
  939. Expand4
  940. ( unsigned* lineptr,
  941.   double* xline )
  942. {
  943.     double dpixel;
  944.     unsigned x;
  945.     unsigned  y;
  946.     unsigned fourpixels;
  947.     unsigned step;
  948.     double* exp;
  950.     exp = exptable2;
  951.     if (!inited)
  952.     {
  953. inited = 1;
  954. InitExpand2 ();
  955.     }
  958.     step = 3*SCREENWIDTH/2;
  960.     y = SCREENHEIGHT-1;
  961.     do
  962.     {
  963. x = SCREENWIDTH;
  965. do
  966. {
  967.     fourpixels = lineptr[0];
  969.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff0000)>>13) );
  970.     xline[0] = dpixel;
  971.     xline[160] = dpixel;
  972.     xline[320] = dpixel;
  973.     xline[480] = dpixel;
  975.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff)<<3 ) );
  976.     xline[1] = dpixel;
  977.     xline[161] = dpixel;
  978.     xline[321] = dpixel;
  979.     xline[481] = dpixel;
  981.     fourpixels = lineptr[1];
  983.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff0000)>>13) );
  984.     xline[2] = dpixel;
  985.     xline[162] = dpixel;
  986.     xline[322] = dpixel;
  987.     xline[482] = dpixel;
  989.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff)<<3 ) );
  990.     xline[3] = dpixel;
  991.     xline[163] = dpixel;
  992.     xline[323] = dpixel;
  993.     xline[483] = dpixel;
  995.     fourpixels = lineptr[2];
  997.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff0000)>>13) );
  998.     xline[4] = dpixel;
  999.     xline[164] = dpixel;
  1000.     xline[324] = dpixel;
  1001.     xline[484] = dpixel;
  1003.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff)<<3 ) );
  1004.     xline[5] = dpixel;
  1005.     xline[165] = dpixel;
  1006.     xline[325] = dpixel;
  1007.     xline[485] = dpixel;
  1009.     fourpixels = lineptr[3];
  1011.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff0000)>>13) );
  1012.     xline[6] = dpixel;
  1013.     xline[166] = dpixel;
  1014.     xline[326] = dpixel;
  1015.     xline[486] = dpixel;
  1017.     dpixel = *(double *)( (int)exp + ( (fourpixels&0xffff)<<3 ) );
  1018.     xline[7] = dpixel;
  1019.     xline[167] = dpixel;
  1020.     xline[327] = dpixel;
  1021.     xline[487] = dpixel;
  1023.     lineptr+=4;
  1024.     xline+=8;
  1025. } while (x-=16);
  1026. xline += step;
  1027.     } while (y--);
  1028. }