/*
===========
IN_Init
===========
*/
void IN_Init (void)
{
int MajorVersion = 0, MinorVersion = 0;
qboolean DGA = false;
Cvar_RegisterVariable (&m_filter, NULL);
Cmd_AddCommand ("force_centerview", Force_CenterView_f);
if (COM_CheckParm ("-nomouse"))
mouse_available = false;
else
mouse_available = true;
mouse_grab_active = false;
dga_mouse_available = false;
dga_mouse_active = false;
/* if (COM_CheckParm ("-nokeyb"))
keyboard_available = false;
else
*/ keyboard_available = true;
keyboard_grab_active = false;
dga_keyboard_available = false;
dga_keyboard_active = false;
if (x_disp == NULL)
Sys_Error ("IN_Init: x_disp not initialised before input...");
DGA = XF86DGAQueryVersion(x_disp, &MajorVersion, &MinorVersion);
if(COM_CheckParm("-nodga"))
{
Con_Warning ("XFree86 DGA extension disabled at command line\n");
}
else if (DGA)
{
Con_Printf ("XFree86 DGA extension version %d.%d found\n", MajorVersion, MinorVersion);
if (COM_CheckParm("-nodgamouse"))
Con_Warning ("XFree86 DGA Mouse disabled at command line\n");
else
dga_mouse_available = true;
if (COM_CheckParm("-nodgakeyb"))
Con_Warning ("XFree86 DGA Keyboard disabled at command line\n");
else
dga_keyboard_available = true;
}
else
{
Con_Warning ("XFree86 DGA extension not supported\n");
}
IN_GrabMouse(); // grab mouse first!
IN_GrabKeyboard();
}
static void install_grabs(void)
{
// inviso cursor
XWarpPointer(dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2);
XSync(dpy, False);
XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
XGrabPointer(dpy, win, // bk010108 - do this earlier?
False,
MOUSE_MASK,
GrabModeAsync, GrabModeAsync,
win,
None,
CurrentTime);
XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
&mouse_threshold);
XChangePointerControl(dpy, True, True, 1, 1, 0);
XSync(dpy, False);
mouseResetTime = Sys_Milliseconds ();
#ifdef HAVE_XF86DGA
if (in_dgamouse->value)
{
int MajorVersion, MinorVersion;
if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion))
{
// unable to query, probalby not supported, force the setting to 0
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else
{
XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
}
} else
#endif /* HAVE_XF86DGA */
{
mwx = glConfig.vidWidth / 2;
mwy = glConfig.vidHeight / 2;
mx = my = 0;
}
XGrabKeyboard(dpy, win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
XSync(dpy, False);
}
static void install_grabs(void)
{
// inviso cursor
XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
XGrabPointer(dpy, win,
False,
MOUSE_MASK,
GrabModeAsync, GrabModeAsync,
win,
None,
CurrentTime);
XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
&mouse_threshold);
XChangePointerControl(dpy, qtrue, qtrue, 2, 1, 0);
if (in_dgamouse->value) {
int MajorVersion, MinorVersion;
if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) {
// unable to query, probalby not supported
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else {
dgamouse = qtrue;
XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
}
} else {
XWarpPointer(dpy, None, win,
0, 0, 0, 0,
glConfig.vidWidth / 2, glConfig.vidHeight / 2);
}
XGrabKeyboard(dpy, win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
// XSync(dpy, True);
}
static int dga_available (void)
{
#ifdef USE_DGA_EXTENSION
int MajorVersion, MinorVersion;
int EventBase, ErrorBase;
if (! XF86DGAQueryVersion (display, &MajorVersion, &MinorVersion)) {
write_log ("Unable to query video extension version\n");
return 0;
}
if (! XF86DGAQueryExtension (display, &EventBase, &ErrorBase)) {
write_log ("Unable to query video extension information\n");
return 0;
}
/* Fail if the extension version in the server is too old */
if (MajorVersion < DGA_MINMAJOR
|| (MajorVersion == DGA_MINMAJOR && MinorVersion < DGA_MINMINOR))
{
write_log (
"Xserver is running an old XFree86-DGA version"
" (%d.%d)\n", MajorVersion, MinorVersion);
write_log ("Minimum required version is %d.%d\n",
DGA_MINMAJOR, DGA_MINMINOR);
return 0;
}
if (geteuid () != 0) {
write_log ("UAE is not running as root, DGA extension disabled.\n");
return 0;
}
if (! XF86DGAGetVideo (display, screen, &fb_addr, &fb_width, &fb_bank, &fb_mem)
|| fb_bank < fb_mem)
{
write_log ("Problems with DGA - disabling DGA extension.\n");
return 0;
}
write_log ("DGA extension: addr:%X, width %d, bank size %d mem size %d\n",
fb_addr, fb_width, fb_bank, fb_mem);
return 1;
#else
return 0;
#endif
}
/*
GLX_TestDGA
Check for DGA - update in_dgamouse if needed
*/
void GLX_TestDGA() {
int dga_MajorVersion = 0, dga_MinorVersion = 0;
assert( dpy );
#if defined( ID_ENABLE_DGA )
if ( !XF86DGAQueryVersion( dpy, &dga_MajorVersion, &dga_MinorVersion ) ) {
// unable to query, probalby not supported
common->Printf( "Failed to detect DGA DirectVideo Mouse\n" );
cvarSystem->SetCVarBool( "in_dgamouse", false );
dga_found = false;
} else {
common->Printf( "DGA DirectVideo Mouse (Version %d.%d) initialized\n",
dga_MajorVersion, dga_MinorVersion );
dga_found = true;
}
#else
dga_found = false;
#endif
}
void
IN_Init(void)
{
#ifdef USE_XF86DGA
int MajorVersion, MinorVersion;
#endif
keyboard_grab_active = false;
mouse_grab_active = false;
// FIXME - do proper detection?
// - Also, look at other vid_*.c files for clues
mouse_available = (COM_CheckParm("-nomouse")) ? false : true;
if (x_disp == NULL)
Sys_Error("x_disp not initialised before input...");
#ifdef USE_XF86DGA
dga_mouse_active = false;
if (!XF86DGAQueryVersion(x_disp, &MajorVersion, &MinorVersion)) {
Con_Printf("Failed to detect XF86DGA Mouse\n");
in_dgamouse.value = 0;
dga_available = false;
} else {
dga_available = true;
}
#endif
// Need to grab the input focus at startup, just in case...
// FIXME - must be viewable or get BadMatch
XSetInputFocus(x_disp, x_win, RevertToParent, CurrentTime);
IN_InitCvars();
if (VID_IsFullScreen()) {
if (!mouse_grab_active)
IN_GrabMouse();
if (!keyboard_grab_active)
IN_GrabKeyboard();
}
}
static void install_grabs(void)
{
int MajorVersion, MinorVersion;
input_grabbed = true;
// don't show mouse cursor icon
XDefineCursor(x_disp, x_win, CreateNullCursor(x_disp, x_win));
XGrabPointer(x_disp, x_win,
True,
0,
GrabModeAsync, GrabModeAsync,
x_win,
None,
CurrentTime);
#ifdef USE_DGA
if (!COM_CheckParm("-nodga") &&
XF86DGAQueryVersion(x_disp, &MajorVersion, &MinorVersion)) {
// let us hope XF86DGADirectMouse will work
XF86DGADirectVideo(x_disp, DefaultScreen(x_disp), XF86DGADirectMouse);
dgamouse = true;
XWarpPointer(x_disp, None, x_win, 0, 0, 0, 0, 0, 0); // oldman: this should be here really
}
else
#endif
XWarpPointer(x_disp, None, x_win,
0, 0, 0, 0,
vid.width / 2, vid.height / 2);
XGrabKeyboard(x_disp, x_win,
False,
GrabModeAsync, GrabModeAsync,
CurrentTime);
}
/*
** GLW_SetMode
*/
int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen ) {
#ifdef HAVE_GLES
glConfig.vidWidth = 800;
glConfig.vidHeight = 480;
// glConfig.windowAspect = 800.0 / 480.0;
long event_mask=X_MASK;
dpy = XOpenDisplay(0);
if(!dpy)
{
ri.Printf( PRINT_ALL, "couldn't open display\n");
return qfalse;
}
scrnum = DefaultScreen(dpy);
ri.Printf( PRINT_ALL, "using default screen %d\n", scrnum);
ri.Printf( PRINT_ALL, "setting up EGL window\n");
XSetWindowAttributes attr = { 0 };
attr.event_mask = event_mask;
// attr.colormap = colormap;
attr.override_redirect = qtrue;
win = XCreateWindow(dpy, RootWindow(dpy, scrnum),
0, 0, glConfig.vidWidth, glConfig.vidHeight, 0,
CopyFromParent, InputOutput,
CopyFromParent, CWEventMask, &attr);
if(!win) {
return qfalse;
}
Atom wmState = XInternAtom(dpy, "_NET_WM_STATE", False);
Atom wmFullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
XChangeProperty(dpy, win, wmState, XA_ATOM, 32, PropModeReplace, (unsigned char *)&wmFullscreen, 1);
XMapRaised(dpy, win);
g_EGLWindow = (NativeWindowType)win;
#ifdef PANDORA
g_EGLDisplay = eglGetDisplay((EGLNativeDisplayType)EGL_DEFAULT_DISPLAY);
#else
g_EGLDisplay = eglGetDisplay((EGLNativeDisplayType)dpy);
#endif
if(g_EGLDisplay == EGL_NO_DISPLAY) {
ri.Printf( PRINT_ALL, "error getting EGL display\n");
return qfalse;
}
if(!eglInitialize(g_EGLDisplay, NULL, NULL)) {
ri.Printf( PRINT_ALL, "error initializing EGL");
return 0;
}
const EGLint attribs[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_ALPHA_SIZE, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT,
EGL_DEPTH_SIZE, 16,
EGL_NONE, 0,
};
EGLint configs = 0;
eglChooseConfig(g_EGLDisplay, attribs, &g_EGLConfig, 1, &configs);
if(!configs) {
static const EGLint eglAttrWinLowColor[] = {
EGL_NONE
};
ri.Printf( PRINT_ALL, "falling back to lowest color config\n");
eglChooseConfig(g_EGLDisplay, eglAttrWinLowColor, &g_EGLConfig, 1, &configs);
if(!configs) {
ri.Printf( PRINT_ALL, "no valid EGL configs found\n");
return qfalse;
}
}
#ifdef PANDORA
g_EGLWindowSurface = eglCreateWindowSurface(g_EGLDisplay, g_EGLConfig,
NULL, NULL);
#else
g_EGLWindowSurface = eglCreateWindowSurface(g_EGLDisplay, g_EGLConfig,
g_EGLWindow, NULL);
#endif
if(g_EGLWindowSurface == EGL_NO_SURFACE) {
ri.Printf( PRINT_ALL, "error creating window surface: 0x%X\n", (int)eglGetError());
return qfalse;
}
EGLint ctxAttr[] = {
EGL_CONTEXT_CLIENT_VERSION, 1,
EGL_NONE
};
g_EGLContext = eglCreateContext(g_EGLDisplay, g_EGLConfig, EGL_NO_CONTEXT, ctxAttr);
if(g_EGLContext == EGL_NO_CONTEXT) {
ri.Printf( PRINT_ALL, "error creating context: 0x%X\n", (int)eglGetError());
return qfalse;
}
eglMakeCurrent(g_EGLDisplay, g_EGLWindowSurface, g_EGLWindowSurface, g_EGLContext);
{
EGLint width, height, color, depth, stencil;
eglQuerySurface(g_EGLDisplay, g_EGLWindowSurface, EGL_WIDTH, &width);
eglQuerySurface(g_EGLDisplay, g_EGLWindowSurface, EGL_HEIGHT, &height);
ri.Printf(PRINT_ALL, "Window size: %dx%d\n", width, height);
eglGetConfigAttrib(g_EGLDisplay, g_EGLConfig, EGL_BUFFER_SIZE, &color);
eglGetConfigAttrib(g_EGLDisplay, g_EGLConfig, EGL_DEPTH_SIZE, &depth);
eglGetConfigAttrib(g_EGLDisplay, g_EGLConfig, EGL_STENCIL_SIZE, &stencil);
/* glConfig.vidWidth = width;
glConfig.vidHeight = height;*/
glConfig.colorBits = color;
glConfig.depthBits = depth;
glConfig.stencilBits = stencil;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
#else
int attrib[] = {
GLX_RGBA, // 0
GLX_RED_SIZE, 4, // 1, 2
GLX_GREEN_SIZE, 4, // 3, 4
GLX_BLUE_SIZE, 4, // 5, 6
GLX_DOUBLEBUFFER, // 7
GLX_DEPTH_SIZE, 1, // 8, 9
GLX_STENCIL_SIZE, 1, // 10, 11
None
};
// these match in the array
#define ATTR_RED_IDX 2
#define ATTR_GREEN_IDX 4
#define ATTR_BLUE_IDX 6
#define ATTR_DEPTH_IDX 9
#define ATTR_STENCIL_IDX 11
Window root;
XVisualInfo *visinfo;
XSetWindowAttributes attr;
unsigned long mask;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int dga_MajorVersion, dga_MinorVersion;
int actualWidth, actualHeight;
int i;
const char* glstring; // bk001130 - from cvs1.17 (mkv)
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n" );
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) ) {
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight );
if ( !( dpy = XOpenDisplay( NULL ) ) ) {
fprintf( stderr, "Error couldn't open the X display\n" );
return RSERR_INVALID_MODE;
}
scrnum = DefaultScreen( dpy );
root = RootWindow( dpy, scrnum );
actualWidth = glConfig.vidWidth;
actualHeight = glConfig.vidHeight;
// Get video mode list
if ( !XF86VidModeQueryVersion( dpy, &vidmode_MajorVersion, &vidmode_MinorVersion ) ) {
vidmode_ext = qfalse;
} else
{
ri.Printf( PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n",
vidmode_MajorVersion, vidmode_MinorVersion );
vidmode_ext = qtrue;
}
// Check for DGA
dga_MajorVersion = 0, dga_MinorVersion = 0;
if ( in_dgamouse->value ) {
if ( !XF86DGAQueryVersion( dpy, &dga_MajorVersion, &dga_MinorVersion ) ) {
// unable to query, probalby not supported
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else
{
ri.Printf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n",
dga_MajorVersion, dga_MinorVersion );
}
}
if ( vidmode_ext ) {
int best_fit, best_dist, dist, x, y;
XF86VidModeGetAllModeLines( dpy, scrnum, &num_vidmodes, &vidmodes );
// Are we going fullscreen? If so, let's change video mode
if ( fullscreen ) {
best_dist = 9999999;
best_fit = -1;
for ( i = 0; i < num_vidmodes; i++ )
{
if ( glConfig.vidWidth > vidmodes[i]->hdisplay ||
glConfig.vidHeight > vidmodes[i]->vdisplay ) {
continue;
}
x = glConfig.vidWidth - vidmodes[i]->hdisplay;
y = glConfig.vidHeight - vidmodes[i]->vdisplay;
dist = ( x * x ) + ( y * y );
if ( dist < best_dist ) {
best_dist = dist;
best_fit = i;
}
}
if ( best_fit != -1 ) {
actualWidth = vidmodes[best_fit]->hdisplay;
actualHeight = vidmodes[best_fit]->vdisplay;
// change to the mode
XF86VidModeSwitchToMode( dpy, scrnum, vidmodes[best_fit] );
vidmode_active = qtrue;
// Move the viewport to top left
XF86VidModeSetViewPort( dpy, scrnum, 0, 0 );
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension Activated at %dx%d\n",
actualWidth, actualHeight );
} else
{
fullscreen = 0;
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension: No acceptable modes found\n" );
}
} else
{
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension: Ignored on non-fullscreen/Voodoo\n" );
}
}
if ( !r_colorbits->value ) {
colorbits = 24;
} else {
colorbits = r_colorbits->value;
}
if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) ) {
colorbits = 16;
}
if ( !r_depthbits->value ) {
depthbits = 24;
} else {
depthbits = r_depthbits->value;
}
stencilbits = r_stencilbits->value;
for ( i = 0; i < 16; i++ )
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i ) {
// one pass, reduce
switch ( i / 4 )
{
case 2:
if ( colorbits == 24 ) {
colorbits = 16;
}
break;
case 1:
if ( depthbits == 24 ) {
depthbits = 16;
} else if ( depthbits == 16 ) {
depthbits = 8;
}
case 3:
if ( stencilbits == 24 ) {
stencilbits = 16;
} else if ( stencilbits == 16 ) {
stencilbits = 8;
}
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ( ( i % 4 ) == 3 ) { // reduce colorbits
if ( tcolorbits == 24 ) {
tcolorbits = 16;
}
}
if ( ( i % 4 ) == 2 ) { // reduce depthbits
if ( tdepthbits == 24 ) {
tdepthbits = 16;
} else if ( tdepthbits == 16 ) {
tdepthbits = 8;
}
}
if ( ( i % 4 ) == 1 ) { // reduce stencilbits
if ( tstencilbits == 24 ) {
tstencilbits = 16;
} else if ( tstencilbits == 16 ) {
tstencilbits = 8;
} else {
tstencilbits = 0;
}
}
if ( tcolorbits == 24 ) {
attrib[ATTR_RED_IDX] = 8;
attrib[ATTR_GREEN_IDX] = 8;
attrib[ATTR_BLUE_IDX] = 8;
} else
{
// must be 16 bit
attrib[ATTR_RED_IDX] = 4;
attrib[ATTR_GREEN_IDX] = 4;
attrib[ATTR_BLUE_IDX] = 4;
}
attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth
attrib[ATTR_STENCIL_IDX] = tstencilbits;
visinfo = qglXChooseVisual( dpy, scrnum, attrib );
if ( !visinfo ) {
continue;
}
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX] );
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
if ( !visinfo ) {
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
/* window attributes */
attr.background_pixel = BlackPixel( dpy, scrnum );
attr.border_pixel = 0;
attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone );
attr.event_mask = X_MASK;
if ( vidmode_active ) {
mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore |
CWEventMask | CWOverrideRedirect;
attr.override_redirect = True;
attr.backing_store = NotUseful;
attr.save_under = False;
} else {
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
}
win = XCreateWindow( dpy, root, 0, 0,
actualWidth, actualHeight,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr );
XStoreName( dpy, win, WINDOW_CLASS_NAME );
XMapWindow( dpy, win );
if ( vidmode_active ) {
XMoveWindow( dpy, win, 0, 0 );
}
XFlush( dpy );
XSync( dpy,False ); // bk001130 - from cvs1.17 (mkv)
ctx = qglXCreateContext( dpy, visinfo, NULL, True );
XSync( dpy,False ); // bk001130 - from cvs1.17 (mkv)
qglXMakeCurrent( dpy, win, ctx );
// bk001130 - from cvs1.17 (mkv)
glstring = qglGetString( GL_RENDERER );
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
// bk010122 - new software token (Indirect)
if ( !Q_stricmp( glstring, "Mesa X11" )
|| !Q_stricmp( glstring, "Mesa GLX Indirect" ) ) {
if ( !r_allowSoftwareGL->integer ) {
ri.Printf( PRINT_ALL, "\n\n***********************************************************\n" );
ri.Printf( PRINT_ALL, " You are using software Mesa (no hardware acceleration)! \n" );
ri.Printf( PRINT_ALL, " Driver DLL used: %s\n", drivername );
ri.Printf( PRINT_ALL, " If this is intentional, add\n" );
ri.Printf( PRINT_ALL, " \"+set r_allowSoftwareGL 1\"\n" );
ri.Printf( PRINT_ALL, " to the command line when starting the game.\n" );
ri.Printf( PRINT_ALL, "***********************************************************\n" );
GLimp_Shutdown();
return RSERR_INVALID_MODE;
} else
{
ri.Printf( PRINT_ALL, "...using software Mesa (r_allowSoftwareGL==1).\n" );
}
}
#endif //HAVE_GLES
return RSERR_OK;
}
void UXViewport::CaptureInputs()
{
guard(UXViewport::CaptureInputs);
// Check keyboard state.
XKeyboardState KeyState;
XGetKeyboardControl(XDisplay, &KeyState);
if( KeyState.global_auto_repeat == AutoRepeatModeOn )
{
RestoreAutoRepeat = true;
XAutoRepeatOff( XDisplay );
}
// Examine root window.
Window RootRoot;
int r_x, r_y;
unsigned int r_width, r_height, r_border, r_depth;
XGetGeometry(
XDisplay, DefaultRootWindow(XDisplay), &RootRoot,
&r_x, &r_y, &r_width, &r_height, &r_border, &r_depth
);
XWarpPointer(XDisplay, None, XWindow,
0, 0, 0, 0, r_width/2, r_height/2);
XSync(XDisplay, False);
//XDefineCursor(XDisplay, XWindow, GetNullCursor());
// Capture the pointer.
XGrabPointer(XDisplay, XWindow, False,
ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | ButtonMotionMask,
GrabModeAsync, GrabModeAsync, XWindow, None, CurrentTime );
// Control acceleration.
XChangePointerControl(XDisplay, True, True, 2, 1, 0);
XSync(XDisplay, False);
// Query DGA capabilities.
UXClient* C = GetOuterUXClient();
if (C->DGAMouseEnabled)
{
INT VersionMajor, VersionMinor;
if (!XF86DGAQueryVersion(XDisplay, &VersionMajor, &VersionMinor))
{
debugf( TEXT("XF86DGA disabled.") );
UseDGA = false;
} else {
debugf( TEXT("XF86DGA enabled.") );
UseDGA = true;
XF86DGADirectVideo(XDisplay, DefaultScreen(XDisplay), XF86DGADirectMouse);
XWarpPointer(XDisplay, None, XWindow, 0, 0, 0, 0, 0, 0);
}
} else
UseDGA = false;
XGrabKeyboard(XDisplay, XWindow, False, GrabModeAsync, GrabModeAsync, CurrentTime);
XSync(XDisplay, False);
unguard;
}
/*
** GLW_SetMode
*/
int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen )
{
int attrib[] = {
GLX_RGBA, // 0
GLX_RED_SIZE, 4, // 1, 2
GLX_GREEN_SIZE, 4, // 3, 4
GLX_BLUE_SIZE, 4, // 5, 6
GLX_DOUBLEBUFFER, // 7
GLX_DEPTH_SIZE, 1, // 8, 9
GLX_STENCIL_SIZE, 1, // 10, 11
None
};
// these match in the array
#define ATTR_RED_IDX 2
#define ATTR_GREEN_IDX 4
#define ATTR_BLUE_IDX 6
#define ATTR_DEPTH_IDX 9
#define ATTR_STENCIL_IDX 11
Window root;
XVisualInfo *visinfo;
XSetWindowAttributes attr;
unsigned long mask;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int MajorVersion, MinorVersion;
int actualWidth, actualHeight;
int i;
r_fakeFullscreen = ri.Cvar_Get( "r_fakeFullscreen", "0", CVAR_ARCHIVE);
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
ri.Printf (PRINT_ALL, "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
{
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
if (!(dpy = XOpenDisplay(NULL))) {
fprintf(stderr, "Error couldn't open the X display\n");
return RSERR_INVALID_MODE;
}
scrnum = DefaultScreen(dpy);
root = RootWindow(dpy, scrnum);
actualWidth = glConfig.vidWidth;
actualHeight = glConfig.vidHeight;
// Get video mode list
MajorVersion = MinorVersion = 0;
if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) {
vidmode_ext = qfalse;
} else {
ri.Printf(PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n",
MajorVersion, MinorVersion);
vidmode_ext = qtrue;
}
if (vidmode_ext) {
int best_fit, best_dist, dist, x, y;
XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
// Are we going fullscreen? If so, let's change video mode
if (fullscreen && !r_fakeFullscreen->integer) {
best_dist = 9999999;
best_fit = -1;
for (i = 0; i < num_vidmodes; i++) {
if (glConfig.vidWidth > vidmodes[i]->hdisplay ||
glConfig.vidHeight > vidmodes[i]->vdisplay)
continue;
x = glConfig.vidWidth - vidmodes[i]->hdisplay;
y = glConfig.vidHeight - vidmodes[i]->vdisplay;
dist = (x * x) + (y * y);
if (dist < best_dist) {
best_dist = dist;
best_fit = i;
}
}
if (best_fit != -1) {
actualWidth = vidmodes[best_fit]->hdisplay;
actualHeight = vidmodes[best_fit]->vdisplay;
// change to the mode
XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
vidmode_active = qtrue;
// Move the viewport to top left
XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
} else
fullscreen = 0;
}
}
if (!r_colorbits->value)
colorbits = 24;
else
colorbits = r_colorbits->value;
if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
colorbits = 16;
if (!r_depthbits->value)
depthbits = 24;
else
depthbits = r_depthbits->value;
stencilbits = r_stencilbits->value;
for (i = 0; i < 16; i++) {
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ((i % 4) == 0 && i) {
// one pass, reduce
switch (i / 4) {
case 2 :
if (colorbits == 24)
colorbits = 16;
break;
case 1 :
if (depthbits == 24)
depthbits = 16;
else if (depthbits == 16)
depthbits = 8;
case 3 :
if (stencilbits == 24)
stencilbits = 16;
else if (stencilbits == 16)
stencilbits = 8;
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ((i % 4) == 3) { // reduce colorbits
if (tcolorbits == 24)
tcolorbits = 16;
}
if ((i % 4) == 2) { // reduce depthbits
if (tdepthbits == 24)
tdepthbits = 16;
else if (tdepthbits == 16)
tdepthbits = 8;
}
if ((i % 4) == 1) { // reduce stencilbits
if (tstencilbits == 24)
tstencilbits = 16;
else if (tstencilbits == 16)
tstencilbits = 8;
else
tstencilbits = 0;
}
if (tcolorbits == 24) {
attrib[ATTR_RED_IDX] = 8;
attrib[ATTR_GREEN_IDX] = 8;
attrib[ATTR_BLUE_IDX] = 8;
} else {
// must be 16 bit
attrib[ATTR_RED_IDX] = 4;
attrib[ATTR_GREEN_IDX] = 4;
attrib[ATTR_BLUE_IDX] = 4;
}
attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth
attrib[ATTR_STENCIL_IDX] = tstencilbits;
#if 0
ri.Printf( PRINT_DEVELOPER, "Attempting %d/%d/%d Color bits, %d depth, %d stencil display...",
attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]);
#endif
visinfo = qglXChooseVisual(dpy, scrnum, attrib);
if (!visinfo) {
#if 0
ri.Printf( PRINT_DEVELOPER, "failed\n");
#endif
continue;
}
#if 0
ri.Printf( PRINT_DEVELOPER, "Successful\n");
#endif
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
if (!visinfo) {
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
/* window attributes */
attr.background_pixel = BlackPixel(dpy, scrnum);
attr.border_pixel = 0;
attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
attr.event_mask = X_MASK;
if (vidmode_active) {
mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore |
CWEventMask | CWOverrideRedirect;
attr.override_redirect = True;
attr.backing_store = NotUseful;
attr.save_under = False;
} else
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
win = XCreateWindow(dpy, root, 0, 0,
actualWidth, actualHeight,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr);
XMapWindow(dpy, win);
if (vidmode_active)
XMoveWindow(dpy, win, 0, 0);
// Check for DGA
if (in_dgamouse->value) {
if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) {
// unable to query, probalby not supported
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else
ri.Printf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n",
MajorVersion, MinorVersion);
}
XFlush(dpy);
ctx = qglXCreateContext(dpy, visinfo, NULL, True);
qglXMakeCurrent(dpy, win, ctx);
return RSERR_OK;
}
/*
** GLW_SetMode
*/
int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen ) {
int attrib[] = {
GLX_RGBA, // 0
GLX_RED_SIZE, 4, // 1, 2
GLX_GREEN_SIZE, 4, // 3, 4
GLX_BLUE_SIZE, 4, // 5, 6
GLX_DOUBLEBUFFER, // 7
GLX_DEPTH_SIZE, 1, // 8, 9
GLX_STENCIL_SIZE, 1, // 10, 11
None
};
// these match in the array
#define ATTR_RED_IDX 2
#define ATTR_GREEN_IDX 4
#define ATTR_BLUE_IDX 6
#define ATTR_DEPTH_IDX 9
#define ATTR_STENCIL_IDX 11
Window root;
XVisualInfo *visinfo;
XSetWindowAttributes attr;
XSizeHints sizehints;
unsigned long mask;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int dga_MajorVersion, dga_MinorVersion;
int actualWidth, actualHeight;
int i;
const char* glstring; // bk001130 - from cvs1.17 (mkv)
ri.Printf( PRINT_ALL, "Initializing OpenGL display\n" );
ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) ) {
ri.Printf( PRINT_ALL, " invalid mode\n" );
return RSERR_INVALID_MODE;
}
ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight );
if ( !( dpy = XOpenDisplay( NULL ) ) ) {
fprintf( stderr, "Error couldn't open the X display\n" );
return RSERR_INVALID_MODE;
}
scrnum = DefaultScreen( dpy );
root = RootWindow( dpy, scrnum );
actualWidth = glConfig.vidWidth;
actualHeight = glConfig.vidHeight;
// Get video mode list
if ( !XF86VidModeQueryVersion( dpy, &vidmode_MajorVersion, &vidmode_MinorVersion ) ) {
vidmode_ext = qfalse;
} else
{
ri.Printf( PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n",
vidmode_MajorVersion, vidmode_MinorVersion );
vidmode_ext = qtrue;
}
// Check for DGA
dga_MajorVersion = 0, dga_MinorVersion = 0;
if ( in_dgamouse->value ) {
if ( !XF86DGAQueryVersion( dpy, &dga_MajorVersion, &dga_MinorVersion ) ) {
// unable to query, probalby not supported
ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
ri.Cvar_Set( "in_dgamouse", "0" );
} else
{
ri.Printf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n",
dga_MajorVersion, dga_MinorVersion );
}
}
if ( vidmode_ext ) {
int best_fit, best_dist, dist, x, y;
XF86VidModeGetAllModeLines( dpy, scrnum, &num_vidmodes, &vidmodes );
// Are we going fullscreen? If so, let's change video mode
if ( fullscreen ) {
best_dist = 9999999;
best_fit = -1;
for ( i = 0; i < num_vidmodes; i++ )
{
if ( glConfig.vidWidth > vidmodes[i]->hdisplay ||
glConfig.vidHeight > vidmodes[i]->vdisplay ) {
continue;
}
x = glConfig.vidWidth - vidmodes[i]->hdisplay;
y = glConfig.vidHeight - vidmodes[i]->vdisplay;
dist = ( x * x ) + ( y * y );
if ( dist < best_dist ) {
best_dist = dist;
best_fit = i;
}
}
if ( best_fit != -1 ) {
actualWidth = vidmodes[best_fit]->hdisplay;
actualHeight = vidmodes[best_fit]->vdisplay;
// change to the mode
XF86VidModeSwitchToMode( dpy, scrnum, vidmodes[best_fit] );
vidmode_active = qtrue;
// Move the viewport to top left
XF86VidModeSetViewPort( dpy, scrnum, 0, 0 );
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension Activated at %dx%d\n",
actualWidth, actualHeight );
} else
{
fullscreen = 0;
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension: No acceptable modes found\n" );
}
} else
{
ri.Printf( PRINT_ALL, "XFree86-VidModeExtension: Ignored on non-fullscreen/Voodoo\n" );
}
}
if ( !r_colorbits->value ) {
colorbits = 24;
} else {
colorbits = r_colorbits->value;
}
if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) ) {
colorbits = 16;
}
if ( !r_depthbits->value ) {
depthbits = 24;
} else {
depthbits = r_depthbits->value;
}
stencilbits = r_stencilbits->value;
for ( i = 0; i < 16; i++ )
{
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i ) {
// one pass, reduce
switch ( i / 4 )
{
case 2:
if ( colorbits == 24 ) {
colorbits = 16;
}
break;
case 1:
if ( depthbits == 24 ) {
depthbits = 16;
} else if ( depthbits == 16 ) {
depthbits = 8;
}
case 3:
if ( stencilbits == 24 ) {
stencilbits = 16;
} else if ( stencilbits == 16 ) {
stencilbits = 8;
}
}
}
tcolorbits = colorbits;
tdepthbits = depthbits;
tstencilbits = stencilbits;
if ( ( i % 4 ) == 3 ) { // reduce colorbits
if ( tcolorbits == 24 ) {
tcolorbits = 16;
}
}
if ( ( i % 4 ) == 2 ) { // reduce depthbits
if ( tdepthbits == 24 ) {
tdepthbits = 16;
} else if ( tdepthbits == 16 ) {
tdepthbits = 8;
}
}
if ( ( i % 4 ) == 1 ) { // reduce stencilbits
if ( tstencilbits == 24 ) {
tstencilbits = 16;
} else if ( tstencilbits == 16 ) {
tstencilbits = 8;
} else {
tstencilbits = 0;
}
}
if ( tcolorbits == 24 ) {
attrib[ATTR_RED_IDX] = 8;
attrib[ATTR_GREEN_IDX] = 8;
attrib[ATTR_BLUE_IDX] = 8;
} else
{
// must be 16 bit
attrib[ATTR_RED_IDX] = 4;
attrib[ATTR_GREEN_IDX] = 4;
attrib[ATTR_BLUE_IDX] = 4;
}
attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth
attrib[ATTR_STENCIL_IDX] = tstencilbits;
visinfo = qglXChooseVisual( dpy, scrnum, attrib );
if ( !visinfo ) {
continue;
}
ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX] );
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
if ( !visinfo ) {
ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
/* window attributes */
attr.background_pixel = BlackPixel( dpy, scrnum );
attr.border_pixel = 0;
attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone );
attr.event_mask = X_MASK;
if ( vidmode_active ) {
mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore |
CWEventMask | CWOverrideRedirect;
attr.override_redirect = True;
attr.backing_store = NotUseful;
attr.save_under = False;
} else {
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
}
win = XCreateWindow( dpy, root, 0, 0,
actualWidth, actualHeight,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr );
XStoreName( dpy, win, WINDOW_CLASS_NAME );
/* GH: Don't let the window be resized */
sizehints.flags = PMinSize | PMaxSize;
sizehints.min_width = sizehints.max_width = actualWidth;
sizehints.min_height = sizehints.max_height = actualHeight;
XSetWMNormalHints( dpy, win, &sizehints );
XMapWindow( dpy, win );
if ( vidmode_active ) {
XMoveWindow( dpy, win, 0, 0 );
}
XFlush( dpy );
XSync( dpy,False ); // bk001130 - from cvs1.17 (mkv)
ctx = qglXCreateContext( dpy, visinfo, NULL, True );
XSync( dpy,False ); // bk001130 - from cvs1.17 (mkv)
/* GH: Free the visinfo after we're done with it */
XFree( visinfo );
qglXMakeCurrent( dpy, win, ctx );
// bk001130 - from cvs1.17 (mkv)
glstring = qglGetString( GL_RENDERER );
ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
// bk010122 - new software token (Indirect)
if ( !Q_stricmp( glstring, "Mesa X11" )
|| !Q_stricmp( glstring, "Mesa GLX Indirect" ) ) {
if ( !r_allowSoftwareGL->integer ) {
ri.Printf( PRINT_ALL, "\n\n***********************************************************\n" );
ri.Printf( PRINT_ALL, " You are using software Mesa (no hardware acceleration)! \n" );
ri.Printf( PRINT_ALL, " Driver DLL used: %s\n", drivername );
ri.Printf( PRINT_ALL, " If this is intentional, add\n" );
ri.Printf( PRINT_ALL, " \"+set r_allowSoftwareGL 1\"\n" );
ri.Printf( PRINT_ALL, " to the command line when starting the game.\n" );
ri.Printf( PRINT_ALL, "***********************************************************\n" );
GLimp_Shutdown();
return RSERR_INVALID_MODE;
} else
{
ri.Printf( PRINT_ALL, "...using software Mesa (r_allowSoftwareGL==1).\n" );
}
}
return RSERR_OK;
}
rserr_t GLimp_SetMode( int mode, int colorbits, bool fullscreen ) {
if ( !XInitThreads() ) {
common->Printf( "...XInitThreads() failed, disabling r_smp\n" );
Cvar_Set( "r_smp", "0" );
}
// set up our custom error handler for X failures
XSetErrorHandler( &qXErrorHandler );
if ( fullscreen && in_nograb->value ) {
common->Printf( "Fullscreen not allowed with in_nograb 1\n" );
Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = false;
fullscreen = false;
}
common->Printf( "...setting mode %d:", mode );
if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) ) {
common->Printf( " invalid mode\n" );
return RSERR_INVALID_MODE;
}
common->Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight );
// open the display
if ( !( dpy = XOpenDisplay( NULL ) ) ) {
fprintf( stderr, "Error couldn't open the X display\n" );
return RSERR_INVALID_MODE;
}
scrnum = DefaultScreen( dpy );
Window root = RootWindow( dpy, scrnum );
// Get video mode list
if ( !XF86VidModeQueryVersion( dpy, &vidmode_MajorVersion, &vidmode_MinorVersion ) ) {
vidmode_ext = false;
} else {
common->Printf( "Using XFree86-VidModeExtension Version %d.%d\n", vidmode_MajorVersion, vidmode_MinorVersion );
vidmode_ext = true;
}
// Check for DGA
int dga_MajorVersion = 0;
int dga_MinorVersion = 0;
if ( in_dgamouse->value ) {
if ( !XF86DGAQueryVersion( dpy, &dga_MajorVersion, &dga_MinorVersion ) ) {
// unable to query, probalby not supported
common->Printf( "Failed to detect XF86DGA Mouse\n" );
Cvar_Set( "in_dgamouse", "0" );
} else {
common->Printf( "XF86DGA Mouse (Version %d.%d) initialized\n", dga_MajorVersion, dga_MinorVersion );
}
}
int actualWidth = glConfig.vidWidth;
int actualHeight = glConfig.vidHeight;
if ( vidmode_ext ) {
int best_fit, best_dist, dist, x, y;
XF86VidModeGetAllModeLines( dpy, scrnum, &num_vidmodes, &vidmodes );
// Are we going fullscreen? If so, let's change video mode
if ( fullscreen ) {
best_dist = 9999999;
best_fit = -1;
for ( int i = 0; i < num_vidmodes; i++ ) {
if ( glConfig.vidWidth > vidmodes[ i ]->hdisplay ||
glConfig.vidHeight > vidmodes[ i ]->vdisplay ) {
continue;
}
x = glConfig.vidWidth - vidmodes[ i ]->hdisplay;
y = glConfig.vidHeight - vidmodes[ i ]->vdisplay;
dist = ( x * x ) + ( y * y );
if ( dist < best_dist ) {
best_dist = dist;
best_fit = i;
}
}
if ( best_fit != -1 ) {
actualWidth = vidmodes[ best_fit ]->hdisplay;
actualHeight = vidmodes[ best_fit ]->vdisplay;
// change to the mode
XF86VidModeSwitchToMode( dpy, scrnum, vidmodes[ best_fit ] );
vidmode_active = true;
// Move the viewport to top left
XF86VidModeSetViewPort( dpy, scrnum, 0, 0 );
common->Printf( "XFree86-VidModeExtension Activated at %dx%d\n",
actualWidth, actualHeight );
} else {
fullscreen = 0;
common->Printf( "XFree86-VidModeExtension: No acceptable modes found\n" );
}
} else {
common->Printf( "XFree86-VidModeExtension: Ignored on non-fullscreen\n" );
}
}
if ( !colorbits ) {
colorbits = !r_colorbits->value ? 24 : r_colorbits->value;
}
int depthbits = !r_depthbits->value ? 24 : r_depthbits->value;
int stencilbits = r_stencilbits->value;
XVisualInfo* visinfo = NULL;
for ( int i = 0; i < 16; i++ ) {
// 0 - default
// 1 - minus colorbits
// 2 - minus depthbits
// 3 - minus stencil
if ( ( i % 4 ) == 0 && i ) {
// one pass, reduce
switch ( i / 4 ) {
case 2:
if ( colorbits == 24 ) {
colorbits = 16;
}
break;
case 1:
if ( depthbits == 24 ) {
depthbits = 16;
} else if ( depthbits == 16 ) {
depthbits = 8;
}
break;
case 3:
if ( stencilbits == 24 ) {
stencilbits = 16;
} else if ( stencilbits == 16 ) {
stencilbits = 8;
}
break;
}
}
int tcolorbits = colorbits;
int tdepthbits = depthbits;
int tstencilbits = stencilbits;
if ( ( i % 4 ) == 3 ) {
// reduce colorbits
if ( tcolorbits == 24 ) {
tcolorbits = 16;
}
}
if ( ( i % 4 ) == 2 ) {
// reduce depthbits
if ( tdepthbits == 24 ) {
tdepthbits = 16;
} else if ( tdepthbits == 16 ) {
tdepthbits = 8;
}
}
if ( ( i % 4 ) == 1 ) {
// reduce stencilbits
if ( tstencilbits == 24 ) {
tstencilbits = 16;
} else if ( tstencilbits == 16 ) {
tstencilbits = 8;
} else {
tstencilbits = 0;
}
}
int attrib[] =
{
GLX_RGBA, // 0
GLX_RED_SIZE, 4, // 1, 2
GLX_GREEN_SIZE, 4, // 3, 4
GLX_BLUE_SIZE, 4, // 5, 6
GLX_DOUBLEBUFFER, // 7
GLX_DEPTH_SIZE, 1, // 8, 9
GLX_STENCIL_SIZE, 1, // 10, 11
//GLX_SAMPLES_SGIS, 4, /* for better AA */
None
};
// these match in the array
enum
{
ATTR_RED_IDX = 2,
ATTR_GREEN_IDX = 4,
ATTR_BLUE_IDX = 6,
ATTR_DEPTH_IDX = 9,
ATTR_STENCIL_IDX = 11
};
if ( tcolorbits == 24 ) {
attrib[ ATTR_RED_IDX ] = 8;
attrib[ ATTR_GREEN_IDX ] = 8;
attrib[ ATTR_BLUE_IDX ] = 8;
} else {
// must be 16 bit
attrib[ ATTR_RED_IDX ] = 4;
attrib[ ATTR_GREEN_IDX ] = 4;
attrib[ ATTR_BLUE_IDX ] = 4;
}
attrib[ ATTR_DEPTH_IDX ] = tdepthbits; // default to 24 depth
attrib[ ATTR_STENCIL_IDX ] = tstencilbits;
visinfo = glXChooseVisual( dpy, scrnum, attrib );
if ( !visinfo ) {
continue;
}
common->Printf( "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
attrib[ ATTR_RED_IDX ], attrib[ ATTR_GREEN_IDX ], attrib[ ATTR_BLUE_IDX ],
attrib[ ATTR_DEPTH_IDX ], attrib[ ATTR_STENCIL_IDX ] );
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
if ( !visinfo ) {
common->Printf( "Couldn't get a visual\n" );
return RSERR_INVALID_MODE;
}
// Window attributes
XSetWindowAttributes attr;
unsigned long mask;
attr.background_pixel = BlackPixel( dpy, scrnum );
attr.border_pixel = 0;
attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone );
attr.event_mask = X_MASK;
if ( vidmode_active ) {
mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore |
CWEventMask | CWOverrideRedirect;
attr.override_redirect = True;
attr.backing_store = NotUseful;
attr.save_under = False;
} else {
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
}
win = XCreateWindow( dpy, root, 0, 0,
actualWidth, actualHeight,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr );
XStoreName( dpy, win, R_GetTitleForWindow() );
/* GH: Don't let the window be resized */
XSizeHints sizehints;
sizehints.flags = PMinSize | PMaxSize;
sizehints.min_width = sizehints.max_width = actualWidth;
sizehints.min_height = sizehints.max_height = actualHeight;
XSetWMNormalHints( dpy, win, &sizehints );
XMapWindow( dpy, win );
if ( vidmode_active ) {
XMoveWindow( dpy, win, 0, 0 );
//XRaiseWindow(dpy, win);
//XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
//XFlush(dpy);
// Move the viewport to top left
//XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
}
// hook to window close
wm_protocols = XInternAtom( dpy, "WM_PROTOCOLS", False );
wm_delete_window = XInternAtom( dpy, "WM_DELETE_WINDOW", False );
XSetWMProtocols( dpy, win, &wm_delete_window, 1 );
XFlush( dpy );
XSync( dpy, False ); // bk001130 - from cvs1.17 (mkv)
ctx = glXCreateContext( dpy, visinfo, NULL, True );
XSync( dpy, False ); // bk001130 - from cvs1.17 (mkv)
/* GH: Free the visinfo after we're done with it */
XFree( visinfo );
glXMakeCurrent( dpy, win, ctx );
glConfig.deviceSupportsGamma = false;
if ( vidmode_ext ) {
if ( vidmode_MajorVersion < GAMMA_MINMAJOR ||
( vidmode_MajorVersion == GAMMA_MINMAJOR && vidmode_MinorVersion < GAMMA_MINMINOR ) ) {
common->Printf( "XF86 Gamma extension not supported in this version\n" );
} else {
XF86VidModeGetGamma( dpy, scrnum, &vidmode_InitialGamma );
common->Printf( "XF86 Gamma extension initialized\n" );
glConfig.deviceSupportsGamma = true;
}
}
// Check for software GL implementation.
const char* glstring = ( char* )glGetString( GL_RENDERER );
if ( !String::ICmp( glstring, "Mesa X11" ) ||
!String::ICmp( glstring, "Mesa GLX Indirect" ) ) {
if ( !r_allowSoftwareGL->integer ) {
common->Printf( "\n\n***********************************************************\n" );
common->Printf( " You are using software Mesa (no hardware acceleration)!\n" );
common->Printf( " If this is intentional, add\n" );
common->Printf( " \"+set r_allowSoftwareGL 1\"\n" );
common->Printf( " to the command line when starting the game.\n" );
common->Printf( "***********************************************************\n" );
GLimp_Shutdown();
return RSERR_INVALID_MODE;
} else {
common->Printf( "...using software Mesa (r_allowSoftwareGL==1).\n" );
}
}
GLW_GenDefaultLists();
return RSERR_OK;
}
static void install_grabs( void )
{
int res;
int fevent;
assert( x11display.dpy && x11display.win );
if( !x11display.features.wmStateFullscreen )
{
res = XGrabKeyboard( x11display.dpy, x11display.win, False, GrabModeAsync, GrabModeAsync, CurrentTime );
if( res != GrabSuccess )
{
Com_Printf( "Warning: XGrabKeyboard failed\n" );
return;
}
}
XDefineCursor( x11display.dpy, x11display.win, CreateNullCursor( x11display.dpy, x11display.win ) );
res = XGrabPointer( x11display.dpy, x11display.win, True, 0, GrabModeAsync, GrabModeAsync, x11display.win, None, CurrentTime );
if( res != GrabSuccess )
{
// TODO: Find a solution to Pointer Grabs at focus changes, which sometimes result
// in Grabbing Errors. Like switches from Windowed/Fullscreen to Hidden State.
//Com_Printf( "Warning: XGrabPointer failed\n" );
XUngrabKeyboard( x11display.dpy, CurrentTime );
XUndefineCursor( x11display.dpy, x11display.win );
return;
}
if( in_dgamouse->integer )
{
int MajorVersion, MinorVersion;
if( XF86DGAQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) )
{
XF86DGADirectVideo( x11display.dpy, x11display.scr, XF86DGADirectMouse );
XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0,
x11display.win_width/2, x11display.win_height/2 );
dgamouse = qtrue;
}
else
{
// unable to query, probalby not supported
Com_Printf( "Failed to detect XF86DGA Mouse\n" );
Cvar_Set( "in_dgamouse", "0" );
dgamouse = qfalse;
}
}
else
{
XWarpPointer( x11display.dpy, None, x11display.win, 0, 0, 0, 0,
x11display.win_width/2, x11display.win_height/2 );
}
ignore_one = qtrue; // first mouse update after install_grabs is ignored
mx = my = 0;
mouse_active = qtrue;
in_dgamouse->modified = qfalse;
input_active = qtrue;
// init X Input method, needed by Xutf8LookupString
x11display.im = XOpenIM( x11display.dpy, NULL, NULL, NULL );
x11display.ic = XCreateIC( x11display.im,
XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, x11display.win,
NULL );
if ( x11display.ic )
{
XGetICValues( x11display.ic, XNFilterEvents, &fevent, NULL );
XSelectInput( x11display.dpy, x11display.win, fevent | x11display.wa.event_mask );
}
}
