1 /* 2 Copyright (C) 1996-1997 Id Software, Inc. 3 4 This program is free software; you can redistribute it and/or 5 modify it under the terms of the GNU General Public License 6 as published by the Free Software Foundation; either version 2 7 of the License, or (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 12 13 See the GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 19 */ 20 // vid_sunxil.c -- uses X to setup windows and XIL to copy images (scaled as needed) 21 // to screen 22 23 #define _BSD 24 #define BYTE_DEFINED 1 25 26 #include <sys/time.h> 27 #include <sys/types.h> 28 #include <errno.h> 29 #include <thread.h> 30 #include <unistd.h> 31 #include <signal.h> 32 #include <stdlib.h> 33 #include <stdio.h> 34 #include <string.h> 35 #include <sys/ipc.h> 36 #include <sys/shm.h> 37 #include <X11/Xlib.h> 38 #include <X11/Xutil.h> 39 #include <X11/Xatom.h> 40 #include <X11/keysym.h> 41 #include <xil/xil.h> 42 43 #include "quakedef.h" 44 #include "d_local.h" 45 46 #define MIN_WIDTH 320 47 #define MIN_HEIGHT 200 48 49 cvar_t _windowed_mouse = {"_windowed_mouse","0", true}; 50 cvar_t m_filter = {"m_filter","0", true}; 51 float old_windowed_mouse; 52 53 // The following X property format is defined in Motif 1.1's 54 // Xm/MwmUtils.h, but QUAKE should not depend on that header 55 // file. Note: Motif 1.2 expanded this structure with 56 // uninteresting fields (to QUAKE) so just stick with the 57 // smaller Motif 1.1 structure. 58 59 #define MWM_HINTS_DECORATIONS 2 60 typedef struct 61 { 62 long flags; 63 long functions; 64 long decorations; 65 long input_mode; 66 } MotifWmHints; 67 68 #define MAX_COLUMN_SIZE 11 69 70 #define MAX_MODEDESCS (MAX_COLUMN_SIZE*3) 71 72 typedef struct 73 { 74 int modenum; 75 int iscur; 76 char desc[256]; 77 } modedesc_t; 78 79 extern void M_Menu_Options_f (void); 80 extern void M_Print (int cx, int cy, char *str); 81 extern void M_PrintWhite (int cx, int cy, char *str); 82 extern void M_DrawCharacter (int cx, int line, int num); 83 extern void M_DrawTransPic (int x, int y, qpic_t *pic); 84 extern void M_DrawPic (int x, int y, qpic_t *pic); 85 86 extern int sb_updates; 87 88 qboolean mouse_avail; 89 int mouse_buttons=3; 90 int mouse_oldbuttonstate; 91 int mouse_buttonstate; 92 float mouse_x, mouse_y; 93 float old_mouse_x, old_mouse_y; 94 int p_mouse_x; 95 int p_mouse_y; 96 97 typedef struct 98 { 99 int input; 100 int output; 101 } keymap_t; 102 103 viddef_t vid; // global video state 104 unsigned short d_8to16table[256]; 105 106 int num_shades=32; 107 108 int d_con_indirect = 0; 109 110 int vid_buffersize; 111 112 #define STD_EVENT_MASK \ 113 ( \ 114 StructureNotifyMask | \ 115 KeyPressMask | \ 116 KeyReleaseMask | \ 117 ButtonPressMask | \ 118 ButtonReleaseMask | \ 119 ExposureMask | \ 120 PointerMotionMask | \ 121 FocusChangeMask \ 122 ) 123 124 int VGA_width, VGA_height, VGA_rowbytes, VGA_bufferrowbytes, VGA_planar; 125 byte *VGA_pagebase; 126 127 qboolean x_fullscreen = true; 128 Display *x_disp = NULL; 129 int x_screen, x_screen_width, x_screen_height; 130 int x_center_width, x_center_height; 131 int x_std_event_mask = STD_EVENT_MASK; 132 Window x_win, x_root_win; 133 qboolean x_focus = true; 134 int global_dx, global_dy; 135 136 137 static Colormap x_cmap; 138 static GC x_gc; 139 static Visual *x_vis; 140 static XVisualInfo *x_visinfo; 141 static Atom aHints = NULL; 142 static Atom aWMDelete = NULL; 143 144 static qboolean oktodraw = false; 145 static qboolean X11_active = false; 146 147 148 static int verbose=1; 149 150 static byte current_palette[768]; 151 152 cvar_t pixel_multiply = {"pixel_multiply", "2", true}; 153 int current_pixel_multiply = 2; 154 155 #define PM(a) (int)((current_pixel_multiply)?((a)*current_pixel_multiply):(a)) 156 #define MP(a) (int)((current_pixel_multiply)?((a)/current_pixel_multiply):(a)) 157 158 static int render_pipeline[2]; 159 static XilSystemState state; 160 static XilImage display_image = NULL; 161 static XilImage quake_image = NULL; 162 static int use_mt = 0; 163 static int count_frames = 0; 164 165 /* 166 ================ 167 D_BeginDirectRect 168 ================ 169 */ 170 void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height) 171 { 172 // direct drawing of the "accessing disk" icon isn't supported under Nextstep 173 } 174 175 176 /* 177 ================ 178 D_EndDirectRect 179 ================ 180 */ 181 void D_EndDirectRect (int x, int y, int width, int height) 182 { 183 // direct drawing of the "accessing disk" icon isnt supported under Nextstep 184 } 185 186 187 /* 188 ================= 189 VID_Gamma_f 190 191 Keybinding command 192 ================= 193 */ 194 195 byte vid_gamma[256]; 196 197 void VID_Gamma_f (void) 198 { 199 200 float g, f, inf; 201 int i; 202 203 if (Cmd_Argc () == 2) { 204 g = Q_atof (Cmd_Argv(1)); 205 206 for (i=0 ; i<255 ; i++) { 207 f = pow ((i+1)/256.0, g); 208 inf = f*255 + 0.5; 209 if (inf < 0) 210 inf = 0; 211 if (inf > 255) 212 inf = 255; 213 vid_gamma[i] = inf; 214 } 215 216 VID_SetPalette (current_palette); 217 218 vid.recalc_refdef = 1; // force a surface cache flush 219 } 220 221 } 222 223 qboolean CheckPixelMultiply (void) 224 { 225 int m; 226 int w, h; 227 XWindowAttributes wattr; 228 XWindowChanges chg; 229 unsigned int value_mask; 230 int old_pixel; 231 232 if ((m = (int)pixel_multiply.value) != current_pixel_multiply) { 233 if (m < 1) 234 m = 1; 235 if (m > 4) 236 m = 4; 237 238 old_pixel = current_pixel_multiply; 239 current_pixel_multiply = m; 240 Cvar_SetValue("pixel_multiply", m); 241 242 if(XGetWindowAttributes(x_disp, x_win, & wattr) == 0) 243 return true; // ??? 244 245 memset(&chg, 0, sizeof(chg)); 246 chg.width = wattr.width/old_pixel * current_pixel_multiply; 247 chg.height = wattr.height/old_pixel * current_pixel_multiply; 248 249 if (chg.width < MIN_WIDTH*current_pixel_multiply) 250 chg.width = MIN_WIDTH*current_pixel_multiply; 251 if (chg.height < MIN_HEIGHT*current_pixel_multiply) 252 chg.height = MIN_HEIGHT*current_pixel_multiply; 253 254 XConfigureWindow(x_disp, x_win, CWWidth | CWHeight, &chg); 255 256 vid.width = MP(wattr.width) & ~3; 257 vid.height = MP(wattr.height); 258 259 if (vid.width < 320) 260 vid.width = 320; 261 if (vid.height < 200) 262 vid.height = 200; 263 VID_ResetFramebuffer(); 264 265 return true; 266 } 267 return false; 268 } 269 270 // ======================================================================== 271 // Tragic death handler 272 // ======================================================================== 273 274 void TragicDeath(int signal_num) 275 { 276 //XAutoRepeatOn(x_disp); 277 XCloseDisplay(x_disp); 278 Sys_Error("This death brought to you by the number %d\n", signal_num); 279 } 280 281 // ======================================================================== 282 // makes a null cursor 283 // ======================================================================== 284 285 static Cursor CreateNullCursor(Display *display, Window root) 286 { 287 Pixmap cursormask; 288 XGCValues xgc; 289 GC gc; 290 XColor dummycolour; 291 Cursor cursor; 292 293 cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/); 294 xgc.function = GXclear; 295 gc = XCreateGC(display, cursormask, GCFunction, &xgc); 296 XFillRectangle(display, cursormask, gc, 0, 0, 1, 1); 297 dummycolour.pixel = 0; 298 dummycolour.red = 0; 299 dummycolour.flags = 04; 300 cursor = XCreatePixmapCursor(display, cursormask, cursormask, 301 &dummycolour,&dummycolour, 0,0); 302 XFreePixmap(display,cursormask); 303 XFreeGC(display,gc); 304 return cursor; 305 } 306 307 308 void VID_MenuDraw( void ) 309 { 310 qpic_t *p; 311 char *ptr; 312 int i, j, column, row, dup; 313 char temp[100]; 314 315 p = Draw_CachePic ("gfx/vidmodes.lmp"); 316 M_DrawPic ( (320-p->width)/2, 4, p); 317 M_Print (4*8, 36 + MAX_COLUMN_SIZE * 8 + 8, "Video mode switching unavailable"); 318 M_Print (9*8, 36 + MAX_COLUMN_SIZE * 8 + 8*6, "Press any key..."); 319 } 320 321 void VID_MenuKey( int key ) { M_Menu_Options_f (); } 322 323 // Called at startup to set up translation tables, takes 256 8 bit RGB values 324 // the palette data will go away after the call, so it must be copied off if 325 // the video driver will need it again 326 327 byte surfcache[1024*1024]; 328 329 // 330 // VID_SetWindowTitle - set the window and icon titles 331 // 332 333 void VID_SetWindowTitle( Window win, char *pszName ) 334 { 335 XTextProperty textprop; 336 XWMHints *wmHints; 337 338 // Setup ICCCM properties 339 textprop.value = (unsigned char *)pszName; 340 textprop.encoding = XA_STRING; 341 textprop.format = 8; 342 textprop.nitems = strlen(pszName); 343 wmHints = XAllocWMHints(); 344 wmHints->initial_state = NormalState; 345 wmHints->flags = StateHint; 346 XSetWMProperties( x_disp, win, &textprop, &textprop, 347 // Only put WM_COMMAND property on first window. 348 com_argv, com_argc, NULL, NULL, NULL ); 349 XFree( wmHints ); 350 351 aWMDelete = XInternAtom( x_disp, "WM_DELETE_WINDOW", False ); 352 XSetWMProtocols( x_disp, win, &aWMDelete, 1 ); 353 } 354 355 // 356 // VID_FullScreen - open the window in full screen mode 357 // 358 359 qboolean VID_FullScreen( Window win ) 360 { 361 MotifWmHints hints; 362 XWindowChanges changes; 363 364 aHints = XInternAtom( x_disp, "_MOTIF_WM_HINTS", 0 ); 365 if (aHints == None) { 366 Con_Printf( "Could not intern X atom for _MOTIF_WM_HINTS." ); 367 return( false ); 368 } 369 370 hints.flags = MWM_HINTS_DECORATIONS; 371 hints.decorations = 0; // Absolutely no decorations. 372 XChangeProperty( x_disp, win, aHints, aHints, 32, PropModeReplace, (unsigned char *)&hints, 4 ); 373 374 changes.x = 0; 375 changes.y = 0; 376 changes.width = x_screen_width; 377 changes.height = x_screen_height; 378 changes.stack_mode = TopIf; 379 XConfigureWindow( x_disp, win, CWX | CWY | CWWidth | CWHeight | CWStackMode, &changes); 380 return( true ); 381 } 382 383 void VID_Init (unsigned char *palette) 384 { 385 386 int pnum, i; 387 XVisualInfo template; 388 int num_visuals; 389 int template_mask; 390 int w, h; 391 392 int desired_width=320, desired_height=200; 393 394 Cmd_AddCommand ("gamma", VID_Gamma_f); 395 396 Cvar_RegisterVariable (&pixel_multiply); 397 398 if (pipe(render_pipeline) < 0) 399 Sys_Error("VID_Init: pipe"); 400 401 for (i=0 ; i<256 ; i++) 402 vid_gamma[i] = i; 403 404 vid.width = 320; 405 vid.height = 200; 406 vid.aspect = 1.0; 407 vid.numpages = 2; 408 vid.colormap = host_colormap; 409 vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048)); 410 //vid.cbits = VID_CBITS; 411 //vid.grades = VID_GRADES; 412 413 srandom(getpid()); 414 415 verbose = COM_CheckParm("-verbose"); 416 count_frames = COM_CheckParm("-count_frames"); 417 418 // 419 // open the display 420 // 421 x_disp = XOpenDisplay(0); 422 423 if (!x_disp) { 424 if (getenv("DISPLAY")) 425 Sys_Error("VID: Could not open display [%s]\n", 426 getenv("DISPLAY")); 427 else 428 Sys_Error("VID: Could not open local display\n"); 429 } 430 431 x_screen = DefaultScreen( x_disp ); 432 x_screen_width = WidthOfScreen( ScreenOfDisplay( x_disp, x_screen ) ); 433 x_screen_height = HeightOfScreen( ScreenOfDisplay( x_disp, x_screen ) ); 434 435 x_center_width = x_screen_width/2; 436 437 x_center_height = x_screen_height/2; 438 439 Con_Printf( "Using screen %d: %dx%d\n", x_screen, x_screen_width, x_screen_height ); 440 441 x_root_win = DefaultRootWindow( x_disp); 442 443 //XAutoRepeatOff(x_disp); 444 445 // for debugging only 446 if (verbose) 447 XSynchronize(x_disp, True); 448 449 // 450 // check for command-line window size 451 // 452 if ((pnum=COM_CheckParm("-winsize"))) { 453 if (pnum >= com_argc-2) 454 Sys_Error("VID: -winsize <width> <height>\n"); 455 desired_width = Q_atoi(com_argv[pnum+1]); 456 desired_height = Q_atoi(com_argv[pnum+2]); 457 if (desired_width < 1 || desired_height < 1) 458 Sys_Error("VID: Bad window width/height\n"); 459 } 460 461 template_mask = VisualScreenMask; // make sure we get the right one 462 template.screen = x_screen; 463 // 464 // specify a visual id 465 // 466 if ((pnum=COM_CheckParm("-visualid"))) { 467 if (pnum >= com_argc-1) 468 Sys_Error("VID: -visualid <id#>\n"); 469 template.visualid = Q_atoi(com_argv[pnum+1]); 470 template_mask |= VisualIDMask; 471 } else { 472 // If not specified, find an 8 bit visual since others don't work 473 // template.depth = 8; 474 // template_mask |= VisualDepthMask; 475 int screen; 476 screen = XDefaultScreen(x_disp); 477 template.visualid = 478 XVisualIDFromVisual(XDefaultVisual(x_disp, screen)); 479 template_mask = VisualIDMask; 480 } 481 // 482 // pick a visual- warn if more than one was available 483 // 484 x_visinfo = XGetVisualInfo(x_disp, template_mask, &template, &num_visuals); 485 if (num_visuals > 1) { 486 printf("Found more than one visual id at depth %d:\n", template.depth); 487 for (i=0 ; i<num_visuals ; i++) 488 printf(" -visualid %d\n", (int)(x_visinfo[i].visualid)); 489 } 490 else if (num_visuals == 0) { 491 if (template_mask == VisualIDMask) 492 Sys_Error("VID: Bad visual id %d\n", template.visualid); 493 else 494 Sys_Error("VID: No visuals at depth %d\n", template.depth); 495 } 496 497 if (verbose) { 498 printf("Using visualid %d:\n", (int)(x_visinfo->visualid)); 499 printf(" screen %d\n", x_visinfo->screen); 500 printf(" red_mask 0x%x\n", (int)(x_visinfo->red_mask)); 501 printf(" green_mask 0x%x\n", (int)(x_visinfo->green_mask)); 502 printf(" blue_mask 0x%x\n", (int)(x_visinfo->blue_mask)); 503 printf(" colormap_size %d\n", x_visinfo->colormap_size); 504 printf(" bits_per_rgb %d\n", x_visinfo->bits_per_rgb); 505 } 506 507 x_vis = x_visinfo->visual; 508 // 509 // See if we're going to do pixel multiply 510 // 511 if (pixel_multiply.value < 1 || pixel_multiply.value > 4) 512 Cvar_SetValue("pixel_multiply", 2); 513 current_pixel_multiply = pixel_multiply.value; 514 515 w = 320*current_pixel_multiply; // minimum width 516 h = 200*current_pixel_multiply; // minimum height 517 if (desired_width < w) 518 desired_width = w; 519 if (desired_height < h) 520 desired_height = h; 521 522 vid.width = MP(desired_width); 523 vid.height = MP(desired_height); 524 525 // 526 // patch things up so game doesn't fail if window is too small 527 // 528 529 if (vid.width < 320) 530 vid.width = 320; 531 if (vid.height < 200) 532 vid.height = 200; 533 534 // 535 // see if we're going to use threads 536 // 537 if(((sysconf(_SC_NPROCESSORS_ONLN) > 1) || COM_CheckParm("-mt")) && 538 (COM_CheckParm("-no_mt") == 0)) { 539 use_mt = 1; 540 printf("VID: Using multiple threads!\n"); 541 } 542 543 // setup attributes for main window 544 { 545 int attribmask = CWEventMask | CWColormap | CWBorderPixel; 546 XSetWindowAttributes attribs; 547 Colormap tmpcmap; 548 549 tmpcmap = XCreateColormap(x_disp, XRootWindow(x_disp, 550 x_visinfo->screen), x_vis, AllocNone); 551 552 attribs.event_mask = x_std_event_mask; 553 attribs.border_pixel = 0; 554 attribs.colormap = tmpcmap; 555 556 // create the main window 557 x_win = XCreateWindow( x_disp, 558 XRootWindow(x_disp, x_visinfo->screen), 559 0, 0, // x, y 560 desired_width, desired_height, 561 0, // borderwidth 562 x_visinfo->depth, 563 InputOutput, 564 x_vis, 565 attribmask, 566 &attribs ); 567 568 if (x_visinfo->class != TrueColor) 569 XFreeColormap(x_disp, tmpcmap); 570 571 } 572 573 if (x_visinfo->depth == 8) { 574 575 // create and upload the palette 576 if (x_visinfo->class == PseudoColor) { 577 x_cmap = XCreateColormap(x_disp, x_win, x_vis, AllocAll); 578 VID_SetPalette(palette); 579 XSetWindowColormap(x_disp, x_win, x_cmap); 580 } 581 582 } 583 584 VID_SetWindowTitle( x_win, "Quake" ); 585 586 // inviso cursor 587 XDefineCursor(x_disp, x_win, CreateNullCursor(x_disp, x_win)); 588 589 // create the GC 590 { 591 XGCValues xgcvalues; 592 int valuemask = GCGraphicsExposures; 593 xgcvalues.graphics_exposures = False; 594 x_gc = XCreateGC(x_disp, x_win, valuemask, &xgcvalues ); 595 } 596 597 // map the window 598 XMapWindow(x_disp, x_win); 599 XSync(x_disp, True) ; /* wait for map */ 600 // 601 // wait for first exposure event 602 // 603 { 604 XEvent event; 605 do{ 606 XNextEvent(x_disp, &event); 607 if (event.type == Expose && !event.xexpose.count) 608 oktodraw = true; 609 } while (!oktodraw); 610 } 611 // 612 // initialize XIL 613 // 614 615 state = xil_open(); 616 617 if(state == NULL) { 618 // 619 // XIL's default error handler will print an error msg on stderr 620 // 621 Sys_Error("xil_open failed\n"); 622 } 623 624 X11_active = true; 625 626 VID_ResetFramebuffer(); 627 628 D_InitCaches (surfcache, sizeof(surfcache)); 629 630 vid_menudrawfn = VID_MenuDraw; 631 vid_menukeyfn = VID_MenuKey; 632 } 633 634 VID_ResetFramebuffer() 635 { 636 XilMemoryStorage storage; 637 638 if (use_mt) { 639 VID_ResetFramebuffer_MT(); 640 return; 641 } 642 643 //printf("VID_ResetFramebuffer: vid.width %d, vid.height %d\n", vid.width, vid.height); 644 645 xil_destroy(display_image); 646 647 xil_destroy(quake_image); 648 649 display_image = xil_create_from_window(state, x_disp, x_win); 650 quake_image = xil_create(state, vid.width, vid.height, 1, XIL_BYTE); 651 652 xil_export(quake_image); 653 654 if (xil_get_memory_storage(quake_image, &storage) == FALSE) 655 Sys_Error("xil_get_memory_storage"); 656 657 xil_import(quake_image, TRUE); 658 xil_export(quake_image); 659 660 if (xil_get_memory_storage(quake_image, &storage) == FALSE) 661 Sys_Error("xil_get_memory_storage"); 662 663 vid.rowbytes = storage.byte.scanline_stride; 664 vid.buffer = storage.byte.data; 665 vid.conbuffer = vid.buffer; 666 vid.conrowbytes = vid.rowbytes; 667 vid.conwidth = vid.width; 668 vid.conheight = vid.height; 669 670 vid.maxwarpwidth = WARP_WIDTH; 671 vid.maxwarpheight = WARP_HEIGHT; 672 vid.recalc_refdef = 1; // force a surface cache flush 673 674 free(d_pzbuffer); 675 676 d_pzbuffer = malloc(PM(vid.width)*PM(vid.height)*sizeof(*d_pzbuffer)); 677 //Hunk_HighAllocName(PM(vid.width)*PM(vid.height)*sizeof(*d_pzbuffer),"zbuff"); 678 } 679 680 VID_ResetFramebuffer_MT() 681 { 682 XilMemoryStorage storage; 683 XilImage drain_renderpipeline(); 684 XilImage old_display_image; 685 686 void * update_thread(); 687 688 printf("VID_ResetFramebuffer: vid.width %d, vid.height %d\n", vid.width, vid.height); 689 690 old_display_image = display_image; 691 692 display_image = xil_create_from_window(state, x_disp, x_win); 693 694 if (quake_image == NULL) 695 if (thr_create(NULL, NULL, update_thread, NULL, THR_NEW_LWP, NULL) != 0) 696 Sys_Error("VID: thr_create"); 697 698 quake_image = drain_renderpipeline(quake_image); 699 700 xil_destroy(old_display_image); 701 702 free(d_pzbuffer); 703 704 d_pzbuffer = malloc(PM(vid.width)*PM(vid.height)*sizeof(*d_pzbuffer)); 705 } 706 707 void VID_ShiftPalette(unsigned char *p) 708 { 709 VID_SetPalette(p); 710 } 711 712 void VID_SetPalette(unsigned char *palette) 713 { 714 715 int i; 716 XColor colors[256]; 717 718 if (x_visinfo->class == PseudoColor && x_visinfo->depth == 8) { 719 if (palette != current_palette) 720 memcpy(current_palette, palette, 768); 721 for (i=0 ; i<256 ; i++) 722 { 723 colors[i].pixel = i; 724 colors[i].flags = DoRed|DoGreen|DoBlue; 725 colors[i].red = vid_gamma[palette[i*3]] * 257; 726 colors[i].green = vid_gamma[palette[i*3+1]] * 257; 727 colors[i].blue = vid_gamma[palette[i*3+2]] * 257; 728 } 729 XStoreColors(x_disp, x_cmap, colors, 256); 730 } 731 732 } 733 734 // Called at shutdown 735 736 void VID_Shutdown (void) 737 { 738 X11_active = false; 739 Con_Printf("VID_Shutdown\n"); 740 //XAutoRepeatOn(x_disp); 741 xil_destroy(display_image); 742 xil_destroy(quake_image); 743 display_image = NULL; 744 quake_image = NULL; 745 XCloseDisplay(x_disp); 746 } 747 748 int XLateKey(XKeyEvent *ev) 749 { 750 751 int key; 752 char buf[64]; 753 KeySym keysym; 754 755 XLookupString(ev, buf, sizeof buf, &keysym, 0); 756 757 switch(keysym) { 758 case XK_Page_Up: key = K_PGUP; break; 759 case XK_Page_Down: key = K_PGDN; break; 760 case XK_Home: key = K_HOME; break; 761 case XK_End: key = K_END; break; 762 case XK_Left: key = K_LEFTARROW; break; 763 case XK_Right: key = K_RIGHTARROW; break; 764 case XK_Down: key = K_DOWNARROW; break; 765 case XK_Up: key = K_UPARROW; break; 766 case XK_Escape: key = K_ESCAPE; break; 767 case XK_Return: key = K_ENTER; break; 768 case XK_Tab: key = K_TAB; break; 769 case XK_Help: 770 case XK_F1: key = K_F1; break; 771 case XK_F2: key = K_F2; break; 772 case XK_F3: key = K_F3; break; 773 case XK_F4: key = K_F4; break; 774 case XK_F5: key = K_F5; break; 775 case XK_F6: key = K_F6; break; 776 case XK_F7: key = K_F7; break; 777 case XK_F8: key = K_F8; break; 778 case XK_F9: key = K_F9; break; 779 case XK_F10: key = K_F10; break; 780 case XK_F11: key = K_F11; break; 781 case XK_F12: key = K_F12; break; 782 case XK_BackSpace: 783 case XK_Delete: key = K_BACKSPACE; break; 784 case XK_Pause: key = K_PAUSE; break; 785 case XK_Shift_L: 786 case XK_Shift_R: key = K_SHIFT; break; 787 case XK_Control_L: 788 case XK_Control_R: key = K_CTRL; break; 789 case XK_Alt_L: 790 case XK_Meta_L: 791 case XK_Alt_R: 792 case XK_Meta_R: key = K_ALT; break; 793 // various other keys on the keyboard 794 case XK_F27: key = K_HOME; break; 795 case XK_F29: key = K_PGUP; break; 796 case XK_F33: key = K_END; break; 797 case XK_F35: key = K_PGDN; break; 798 case XK_Insert: 799 case XK_KP_Insert: key = K_INS; break; 800 case XK_F24: key = '-'; break; 801 case XK_KP_Add: key = '+'; break; 802 case XK_KP_Subtract: key = '-'; break; 803 case XK_F25: key = '/'; break; 804 case XK_F26: key = '*'; break; 805 806 default: 807 key = (unsigned char)*buf; 808 break; 809 } 810 811 return key; 812 813 } 814 815 struct { 816 int key; 817 int down; 818 } keyq[64]; 819 820 int keyq_head=0; 821 int keyq_tail=0; 822 823 int config_notify=0; 824 int config_notify_width; 825 int config_notify_height; 826 827 void GetEvent(void) 828 { 829 XEvent x_event; 830 int b; 831 832 XNextEvent(x_disp, &x_event); 833 switch(x_event.type) { 834 case KeyPress: 835 Key_Event(XLateKey(&x_event.xkey), true); 836 break; 837 case KeyRelease: 838 Key_Event(XLateKey(&x_event.xkey), false); 839 break; 840 841 case MotionNotify: 842 843 if (_windowed_mouse.value) { 844 mouse_x = (float) ((int)x_event.xmotion.x - (int)(vid.width/2)); 845 mouse_y = (float) ((int)x_event.xmotion.y - (int)(vid.height/2)); 846 //printf("m: x=%d,y=%d, mx=%3.2f,my=%3.2f\n", 847 // x_event.xmotion.x, x_event.xmotion.y, mouse_x, mouse_y); 848 849 /* move the mouse to the window center again */ 850 XSelectInput( x_disp, x_win, x_std_event_mask & ~PointerMotionMask ); 851 XWarpPointer(x_disp,None,x_win,0,0,0,0, 852 (vid.width/2),(vid.height/2)); 853 XSelectInput( x_disp, x_win, x_std_event_mask ); 854 } else { 855 mouse_x = (float) (x_event.xmotion.x-p_mouse_x); 856 mouse_y = (float) (x_event.xmotion.y-p_mouse_y); 857 p_mouse_x=x_event.xmotion.x; 858 p_mouse_y=x_event.xmotion.y; 859 } 860 break; 861 862 case ButtonPress: 863 b=-1; 864 if (x_event.xbutton.button == 1) 865 b = 0; 866 else if (x_event.xbutton.button == 2) 867 b = 2; 868 else if (x_event.xbutton.button == 3) 869 b = 1; 870 if (b>=0) 871 mouse_buttonstate |= 1<<b; 872 break; 873 874 case ButtonRelease: 875 b=-1; 876 if (x_event.xbutton.button == 1) 877 b = 0; 878 else if (x_event.xbutton.button == 2) 879 b = 2; 880 else if (x_event.xbutton.button == 3) 881 b = 1; 882 if (b>=0) 883 mouse_buttonstate &= ~(1<<b); 884 break; 885 886 case ConfigureNotify: 887 // printf("config notify\n"); 888 config_notify_width = x_event.xconfigure.width; 889 config_notify_height = x_event.xconfigure.height; 890 config_notify = 1; 891 sb_updates = 0; 892 break; 893 case Expose: 894 sb_updates = 0; 895 break; 896 case ClientMessage: 897 if (x_event.xclient.data.l[0] == aWMDelete) Host_Quit_f(); 898 break; 899 #if 0 900 case FocusIn: 901 printf("FocusIn...\n"); 902 x_focus = true; 903 break; 904 case FocusOut: 905 printf("FocusOut...\n"); 906 x_focus = false; 907 break; 908 #endif 909 } 910 911 if (old_windowed_mouse != _windowed_mouse.value) { 912 old_windowed_mouse = _windowed_mouse.value; 913 914 if (!_windowed_mouse.value) { 915 /* ungrab the pointer */ 916 XUngrabPointer(x_disp,CurrentTime); 917 } else { 918 /* grab the pointer */ 919 XGrabPointer(x_disp,x_win,True,0,GrabModeAsync, 920 GrabModeAsync,x_win,None,CurrentTime); 921 } 922 } 923 } 924 925 // flushes the given rectangles from the view buffer to the screen 926 927 void 928 VID_Update (vrect_t *rects) 929 { 930 void VID_Update_MT(vrect_t *); 931 932 933 if (count_frames) { 934 static int count; 935 static long long s; 936 long long gethrtime(); 937 938 if (count == 0) 939 s = gethrtime(); 940 941 if (count++ == 200) { 942 long long n = gethrtime(); 943 count = 1; 944 printf("%lf frames/secs\n", 200.0/((double)(n-s) / 1e9)); 945 s = n; 946 } 947 } 948 949 if (use_mt) { 950 VID_Update_MT(rects); 951 return; 952 } 953 954 // if the window changes dimension, skip this frame 955 956 if (config_notify) { 957 int w, h; 958 XWindowChanges chg; 959 unsigned int value_mask; 960 961 w = 320*current_pixel_multiply; // minimum width 962 h = 200*current_pixel_multiply; // minimum height 963 964 if (config_notify_width < w || config_notify_height < h) { 965 // We must resize the window 966 memset(&chg, 0, sizeof(chg)); 967 value_mask = 0; 968 if (config_notify_width < w) { 969 config_notify_width = chg.width = w; 970 value_mask |= CWWidth; 971 } 972 if (config_notify_height < h) { 973 config_notify_height = chg.height = h; 974 value_mask |= CWHeight; 975 } 976 if (value_mask) 977 XConfigureWindow(x_disp, x_win, value_mask, &chg); 978 } 979 980 config_notify = 0; 981 982 vid.width = MP(config_notify_width) & ~3; 983 vid.height = MP(config_notify_height); 984 985 if (vid.width < 320) 986 vid.width = 320; 987 if (vid.height < 200) 988 vid.height = 200; 989 990 VID_ResetFramebuffer(); 991 992 return; 993 } 994 // if pixel multiply changed, skip this frame 995 if (CheckPixelMultiply()) 996 return; 997 998 while (rects) { // I've never seen more than one rect? 999 XilMemoryStorage storage; 1000 1001 xil_import(quake_image, TRUE); // let xil control the image 1002 1003 if (current_pixel_multiply < 2) 1004 xil_copy(quake_image, display_image); 1005 else 1006 xil_scale(quake_image, display_image, "nearest", 1007 (float)current_pixel_multiply, (float)current_pixel_multiply); 1008 1009 xil_export(quake_image); // back to quake 1010 1011 if (xil_get_memory_storage(quake_image, &storage) == FALSE) 1012 Sys_Error("xil_get_memory_storage"); 1013 1014 vid.buffer = storage.byte.data; 1015 vid.conbuffer = vid.buffer; 1016 1017 rects = rects->pnext; 1018 } 1019 } 1020 1021 void 1022 VID_Update_MT (vrect_t *rects) 1023 { 1024 XilImage sched_update(); 1025 1026 // if the window changes dimension, skip this frame 1027 1028 if (config_notify) { 1029 int w, h; 1030 XWindowChanges chg; 1031 unsigned int value_mask; 1032 1033 w = 320*current_pixel_multiply; // minimum width 1034 h = 200*current_pixel_multiply; // minimum height 1035 1036 if (config_notify_width < w || config_notify_height < h) { 1037 // We must resize the window 1038 memset(&chg, 0, sizeof(chg)); 1039 value_mask = 0; 1040 if (config_notify_width < w) { 1041 config_notify_width = chg.width = w; 1042 value_mask |= CWWidth; 1043 } 1044 if (config_notify_height < h) { 1045 config_notify_height = chg.height = h; 1046 value_mask |= CWHeight; 1047 } 1048 if (value_mask) 1049 XConfigureWindow(x_disp, x_win, value_mask, &chg); 1050 } 1051 1052 config_notify = 0; 1053 1054 vid.width = MP(config_notify_width) & ~3; 1055 vid.height = MP(config_notify_height); 1056 1057 if (vid.width < 320) 1058 vid.width = 320; 1059 if (vid.height < 200) 1060 vid.height = 200; 1061 1062 VID_ResetFramebuffer_MT(); 1063 1064 return; 1065 } 1066 // if pixel multiply changed, skip this frame 1067 if (CheckPixelMultiply()) 1068 return; 1069 1070 quake_image = sched_update(quake_image); 1071 } 1072 1073 XilImage 1074 drain_renderpipeline(XilImage old) 1075 { 1076 XilImage new; 1077 1078 XilMemoryStorage storage; 1079 1080 if (old) 1081 if (read(render_pipeline[1], &new, sizeof(new)) != sizeof (new)) { 1082 Sys_Error("drain_renderpipeline: read"); 1083 xil_destroy(new); 1084 } 1085 1086 xil_destroy(old); 1087 1088 1089 new = xil_create(state, vid.width, vid.height, 1, XIL_BYTE); 1090 1091 if (write(render_pipeline[0], &new, sizeof (new)) != sizeof(new)) 1092 Sys_Error("drain_renderpipeline: write"); 1093 1094 new = xil_create(state, vid.width, vid.height, 1, XIL_BYTE); 1095 1096 xil_export(new); 1097 1098 if (xil_get_memory_storage(new, &storage) == FALSE) 1099 Sys_Error("xil_get_memory_storage"); 1100 1101 vid.rowbytes = storage.byte.scanline_stride; 1102 vid.buffer = storage.byte.data; 1103 vid.conbuffer = vid.buffer; 1104 vid.conrowbytes = vid.rowbytes; 1105 vid.conwidth = vid.width; 1106 vid.conheight = vid.height; 1107 1108 vid.maxwarpwidth = WARP_WIDTH; 1109 vid.maxwarpheight = WARP_HEIGHT; 1110 vid.recalc_refdef = 1; // force a surface cache flush 1111 1112 return(new); 1113 1114 } 1115 1116 XilImage 1117 sched_update(XilImage image) 1118 { 1119 XilImage new; 1120 XilMemoryStorage storage; 1121 1122 if (write(render_pipeline[1], &image, sizeof(image)) != sizeof (image)) 1123 Sys_Error("sched_update:write"); 1124 1125 if (read(render_pipeline[1], &new, sizeof(new)) != sizeof (new)) 1126 Sys_Error("sched_update:read"); 1127 1128 xil_export(new); 1129 1130 if (xil_get_memory_storage(new, &storage) == FALSE) 1131 Sys_Error("xil_get_memory_storage"); 1132 1133 vid.buffer = storage.byte.data; 1134 vid.conbuffer = vid.buffer; 1135 1136 return (new); 1137 } 1138 1139 void *update_thread() 1140 { 1141 XilImage image; 1142 1143 if (!X11_active) 1144 return; 1145 1146 while (read(render_pipeline[0], &image, sizeof (image)) == sizeof(image)) { 1147 1148 xil_import(image, TRUE); // let xil control the image 1149 1150 if (!display_image) 1151 return; 1152 1153 if (current_pixel_multiply < 2) 1154 xil_copy(image, display_image); 1155 else 1156 xil_scale(image, display_image, "nearest", 1157 (float)current_pixel_multiply, (float)current_pixel_multiply); 1158 1159 if (write(render_pipeline[0], &image, sizeof (image)) != sizeof(image)) 1160 Sys_Error("update_thread: write"); 1161 } 1162 } 1163 1164 1165 static int dither; 1166 1167 void VID_DitherOn(void) 1168 { 1169 if (dither == 0) { 1170 vid.recalc_refdef = 1; 1171 dither = 1; 1172 } 1173 } 1174 1175 void VID_DitherOff(void) 1176 { 1177 if (dither) { 1178 vid.recalc_refdef = 1; 1179 dither = 0; 1180 } 1181 } 1182 1183 void VID_SetDefaultMode( void ) 1184 { 1185 } 1186 1187 int I_OpenWindow(void) 1188 { 1189 return 0; 1190 } 1191 1192 void I_EraseWindow(int window) 1193 { 1194 1195 } 1196 1197 void I_DrawCircle(int window, int x, int y, int r) 1198 { 1199 } 1200 1201 void I_DisplayWindow(int window) 1202 { 1203 } 1204 1205 void Sys_SendKeyEvents(void) 1206 { 1207 // get events from x server 1208 if (x_disp) { 1209 while (XPending(x_disp)) GetEvent(); 1210 while (keyq_head != keyq_tail) { 1211 Key_Event(keyq[keyq_tail].key, keyq[keyq_tail].down); 1212 keyq_tail = (keyq_tail + 1) & 63; 1213 } 1214 } 1215 } 1216 1217 void IN_Init (void) 1218 { 1219 Cvar_RegisterVariable (&_windowed_mouse); 1220 Cvar_RegisterVariable (&m_filter); 1221 if ( COM_CheckParm ("-nomouse") ) 1222 return; 1223 mouse_x = mouse_y = 0.0; 1224 mouse_avail = 1; 1225 } 1226 1227 void IN_Shutdown (void) 1228 { 1229 mouse_avail = 0; 1230 } 1231 1232 void IN_Commands (void) 1233 { 1234 int i; 1235 1236 if (!mouse_avail) return; 1237 1238 for (i=0 ; i<mouse_buttons ; i++) { 1239 if ( (mouse_buttonstate & (1<<i)) && !(mouse_oldbuttonstate & (1<<i)) ) 1240 Key_Event (K_MOUSE1 + i, true); 1241 1242 if ( !(mouse_buttonstate & (1<<i)) && (mouse_oldbuttonstate & (1<<i)) ) 1243 Key_Event (K_MOUSE1 + i, false); 1244 } 1245 mouse_oldbuttonstate = mouse_buttonstate; 1246 } 1247 1248 void IN_Move (usercmd_t *cmd) 1249 { 1250 if (!mouse_avail) 1251 return; 1252 1253 if (m_filter.value) { 1254 mouse_x = (mouse_x + old_mouse_x) * 0.5; 1255 mouse_y = (mouse_y + old_mouse_y) * 0.5; 1256 } 1257 1258 old_mouse_x = mouse_x; 1259 old_mouse_y = mouse_y; 1260 1261 mouse_x *= sensitivity.value; 1262 mouse_y *= sensitivity.value; 1263 1264 if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) )) 1265 cmd->sidemove += m_side.value * mouse_x; 1266 else 1267 cl.viewangles[YAW] -= m_yaw.value * mouse_x; 1268 if (in_mlook.state & 1) 1269 V_StopPitchDrift (); 1270 1271 if ( (in_mlook.state & 1) && !(in_strafe.state & 1)) { 1272 cl.viewangles[PITCH] += m_pitch.value * mouse_y; 1273 if (cl.viewangles[PITCH] > 80) 1274 cl.viewangles[PITCH] = 80; 1275 if (cl.viewangles[PITCH] < -70) 1276 cl.viewangles[PITCH] = -70; 1277 } else { 1278 if ((in_strafe.state & 1) && noclip_anglehack) 1279 cmd->upmove -= m_forward.value * mouse_y; 1280 else 1281 cmd->forwardmove -= m_forward.value * mouse_y; 1282 } 1283 mouse_x = mouse_y = 0.0; 1284 } 1285 1286 //void VID_UnlockBuffer(void) { } 1287 //void VID_LockBuffer(void) { } 1288 1289
