#include <X11/extensions/xf86dga.h>
#include <X11/extensions/xf86vmode.h>
-static Display *dpy = NULL;
+static Display *vidx11_display = NULL;
static int scrnum;
static Window win;
static GLXContext ctx = NULL;
static float old_mouse_x, old_mouse_y;
static int p_mouse_x, p_mouse_y;
-cvar_t vid_dga = {"vid_dga", "1", true};
-cvar_t vid_dga_mouseaccel = {"vid_dga_mouseaccel", "1", false};
-cvar_t m_filter = {"m_filter", "0"};
+cvar_t vid_dga = {CVAR_SAVE, "vid_dga", "1"};
+cvar_t vid_dga_mouseaccel = {0, "vid_dga_mouseaccel", "1"};
+cvar_t m_filter = {0, "m_filter", "0"};
qboolean vidmode_ext = false;
static int num_vidmodes;
static qboolean vidmode_active = false;
+static Visual *vidx11_visual;
+static Colormap vidx11_colormap;
+
/*-----------------------------------------------------------------------*/
float gldepthmin, gldepthmax;
XWindowAttributes attribs_1;
XSetWindowAttributes attribs_2;
- XGetWindowAttributes(dpy, win, &attribs_1);
+ XGetWindowAttributes(vidx11_display, win, &attribs_1);
attribs_2.event_mask = attribs_1.your_event_mask | KEY_MASK | MOUSE_MASK;
- XChangeWindowAttributes(dpy, win, CWEventMask, &attribs_2);
+ XChangeWindowAttributes(vidx11_display, win, CWEventMask, &attribs_2);
// inviso cursor
- XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
+ XDefineCursor(vidx11_display, win, CreateNullCursor(vidx11_display, win));
- XGrabPointer(dpy, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
+ XGrabPointer(vidx11_display, win, True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
- if (vid_dga.value)
+ if (vid_dga.integer)
{
int MajorVersion, MinorVersion;
- if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion))
+ if (!XF86DGAQueryVersion(vidx11_display, &MajorVersion, &MinorVersion))
{
// unable to query, probalby not supported
Con_Printf( "Failed to detect XF86DGA Mouse\n" );
- vid_dga.value = 0;
+ vid_dga.integer = 0;
}
else
{
- vid_dga.value = 1;
- XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
- XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
+ vid_dga.integer = 1;
+ XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), XF86DGADirectMouse);
+ XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
}
}
else
- XWarpPointer(dpy, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
+ XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, scr_width / 2, scr_height / 2);
- XGrabKeyboard(dpy, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
+ XGrabKeyboard(vidx11_display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
mouse_active = true;
mouse_x = mouse_y = 0;
-// XSync(dpy, True);
+// XSync(vidx11_display, True);
}
static void uninstall_grabs(void)
{
- if (!dpy || !win)
+ if (!vidx11_display || !win)
return;
- if (vid_dga.value == 1)
- XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
+ if (vid_dga.integer == 1)
+ XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), 0);
- XUngrabPointer(dpy, CurrentTime);
- XUngrabKeyboard(dpy, CurrentTime);
+ XUngrabPointer(vidx11_display, CurrentTime);
+ XUngrabKeyboard(vidx11_display, CurrentTime);
// inviso cursor
- XUndefineCursor(dpy, win);
+ XUndefineCursor(vidx11_display, win);
mouse_active = false;
}
// KeySym ks;
qboolean dowarp = false;
- if (!dpy)
+ if (!vidx11_display)
return;
- while (XPending(dpy))
+ while (XPending(vidx11_display))
{
- XNextEvent(dpy, &event);
+ XNextEvent(vidx11_display, &event);
switch (event.type)
{
case MotionNotify:
if (usingmouse)
{
- if (vid_dga.value == 1)
+ if (vid_dga.integer == 1)
{
mouse_x += event.xmotion.x_root * vid_dga_mouseaccel.value;
mouse_y += event.xmotion.y_root * vid_dga_mouseaccel.value;
{
if (!event.xmotion.send_event)
{
- mouse_x += (event.xmotion.x - p_mouse_x);
- mouse_y += (event.xmotion.y - p_mouse_y);
- if (abs(vid.width/2 - event.xmotion.x) > vid.width / 4 || abs(vid.height/2 - event.xmotion.y) > vid.height / 4)
+ mouse_x += event.xmotion.x - p_mouse_x;
+ mouse_y += event.xmotion.y - p_mouse_y;
+ if (abs(scr_width/2 - event.xmotion.x) > scr_width / 4 || abs(scr_height/2 - event.xmotion.y) > scr_height / 4)
dowarp = true;
}
}
p_mouse_y = event.xmotion.y;
}
}
+ else
+ ui_mouseupdate(event.xmotion.x, event.xmotion.y);
break;
case ButtonPress:
if (dowarp)
{
/* move the mouse to the window center again */
- p_mouse_x = vid.width / 2;
- p_mouse_y = vid.height / 2;
- XWarpPointer(dpy, None, win, 0, 0, 0, 0, p_mouse_x, p_mouse_y);
+ p_mouse_x = scr_width / 2;
+ p_mouse_y = scr_height / 2;
+ XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, p_mouse_x, p_mouse_y);
}
}
static void IN_DeactivateMouse( void )
{
- if (!mouse_avail || !dpy || !win)
+ if (!mouse_avail || !vidx11_display || !win)
return;
if (mouse_active)
static void IN_ActivateMouse( void )
{
- if (!mouse_avail || !dpy || !win)
+ if (!mouse_avail || !vidx11_display || !win)
return;
if (!mouse_active)
void VID_Shutdown(void)
{
- if (!ctx || !dpy)
+ if (!ctx || !vidx11_display)
return;
- if (dpy)
+ if (vidx11_display)
{
uninstall_grabs();
if (vidmode_active)
- XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
+ XF86VidModeSwitchToMode(vidx11_display, scrnum, vidmodes[0]);
/* Disabled, causes a segfault during shutdown.
if (ctx)
- glXDestroyContext(dpy, ctx);
+ glXDestroyContext(vidx11_display, ctx);
*/
if (win)
- XDestroyWindow(dpy, win);
- XCloseDisplay(dpy);
+ XDestroyWindow(vidx11_display, win);
+ XCloseDisplay(vidx11_display);
}
vidmode_active = false;
- dpy = NULL;
+ vidx11_display = NULL;
win = 0;
ctx = NULL;
}
signal(SIGTERM, signal_handler);
}
-void VID_CheckMultitexture(void)
-{
- void *prjobj;
- qglMTexCoord2f = NULL;
- qglSelectTexture = NULL;
- // Check to see if multitexture is disabled
- if (COM_CheckParm("-nomtex"))
- {
- Con_Printf("...multitexture disabled\n");
- return;
- }
- if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
- {
- Con_Printf("Unable to open symbol list for main program.\n");
- return;
- }
- // Test for ARB_multitexture
- if (!COM_CheckParm("-SGISmtex") && strstr(gl_extensions, "GL_ARB_multitexture "))
- {
- Con_Printf("...using GL_ARB_multitexture\n");
- qglMTexCoord2f = (void *) dlsym(prjobj, "glMultiTexCoord2fARB");
- qglSelectTexture = (void *) dlsym(prjobj, "glActiveTextureARB");
- gl_mtexable = true;
- gl_mtex_enum = GL_TEXTURE0_ARB;
- }
- else if (strstr(gl_extensions, "GL_SGIS_multitexture ")) // Test for SGIS_multitexture (if ARB_multitexture not found)
- {
- Con_Printf("...using GL_SGIS_multitexture\n");
- qglMTexCoord2f = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
- qglSelectTexture = (void *) dlsym(prjobj, "glSelectTextureSGIS");
- gl_mtexable = true;
- gl_mtex_enum = TEXTURE0_SGIS;
- }
- else
- Con_Printf("...multitexture disabled (not detected)\n");
- dlclose(prjobj);
-}
-
-void VID_CheckCVA(void)
-{
- void *prjobj;
- qglLockArraysEXT = NULL;
- qglUnlockArraysEXT = NULL;
- gl_supportslockarrays = false;
- if (COM_CheckParm("-nocva"))
- {
- Con_Printf("...compiled vertex arrays disabled\n");
- return;
- }
- if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL)
- {
- Con_Printf("Unable to open symbol list for main program.\n");
- return;
- }
- if (strstr(gl_extensions, "GL_EXT_compiled_vertex_array"))
- {
- Con_Printf("...using compiled vertex arrays\n");
- qglLockArraysEXT = (void *) dlsym(prjobj, "glLockArraysEXT");
- qglUnlockArraysEXT = (void *) dlsym(prjobj, "glUnlockArraysEXT");
- gl_supportslockarrays = true;
- }
- dlclose(prjobj);
-}
-
/*
=================
GL_BeginRendering
void GL_EndRendering (void)
{
int usemouse;
- if (!r_render.value)
+ if (!r_render.integer)
return;
glFlush();
- glXSwapBuffers(dpy, win);
+ glXSwapBuffers(vidx11_display, win);
// handle the mouse state when windowed if that's changed
usemouse = false;
- if (vid_mouse.value && key_dest == key_game)
+ if (vid_mouse.integer && key_dest == key_game)
usemouse = true;
if (vidmode_active)
usemouse = true;
}
}
+// LordHavoc: ported from SDL 1.2.2, this was far more difficult to port from
+// SDL than to simply use the XFree gamma ramp extension, but that affects the
+// whole screen even when the game window is inactive, this only affects the
+// screen while the window is active, very desirable behavior :)
int VID_SetGamma(float prescale, float gamma, float scale, float base)
{
+// LordHavoc: FIXME: finish this code, we need to allocate colors before we can store them
+#if 1
return FALSE;
+#else
+ int i, ncolors, c;
+ unsigned int Rmask, Gmask, Bmask, Rloss, Gloss, Bloss, Rshift, Gshift, Bshift, mask;
+ XColor xcmap[256];
+ unsigned short ramp[256];
+
+ if (COM_CheckParm("-nogamma"))
+ return FALSE;
+
+ if (vidx11_visual->class != DirectColor)
+ {
+ Con_Printf("X11 Visual class is %d, can only do gamma on %d\n", vidx11_visual->class, DirectColor);
+ return FALSE;
+ }
+
+ Rmask = vidx11_visual->red_mask;
+ Gmask = vidx11_visual->green_mask;
+ Bmask = vidx11_visual->blue_mask;
+
+ Rshift = 0;
+ Rloss = 8;
+ if ((mask = Rmask))
+ {
+ for (;!(mask & 1);mask >>= 1)
+ ++Rshift;
+ for (;(mask & 1);mask >>= 1)
+ --Rloss;
+ }
+ Gshift = 0;
+ Gloss = 8;
+ if ((mask = Gmask))
+ {
+ for (;!(mask & 1);mask >>= 1)
+ ++Gshift;
+ for (;(mask & 1);mask >>= 1)
+ --Gloss;
+ }
+ Bshift = 0;
+ Bloss = 8;
+ if ((mask = Bmask))
+ {
+ for (;!(mask & 1);mask >>= 1)
+ ++Bshift;
+ for (;(mask & 1);mask >>= 1)
+ --Bloss;
+ }
+
+ BuildGammaTable16(prescale, gamma, scale, base, ramp);
+
+ // convert gamma ramp to palette (yes this seems odd)
+ ncolors = vidx11_visual->map_entries;
+ for (i = 0;i < ncolors;i++)
+ {
+ c = (256 * i / ncolors);
+ xcmap[i].pixel = ((c >> Rloss) << Rshift) | ((c >> Gloss) << Gshift) | ((c >> Bloss) << Bshift);
+ xcmap[i].red = ramp[c];
+ xcmap[i].green = ramp[c];
+ xcmap[i].blue = ramp[c];
+ xcmap[i].flags = (DoRed|DoGreen|DoBlue);
+ }
+ XStoreColors(vidx11_display, vidx11_colormap, xcmap, ncolors);
+ XSync(vidx11_display, false);
+ // FIXME: should this check for BadAccess/BadColor/BadValue errors produced by XStoreColors before setting this true?
+ return TRUE;
+#endif
}
void VID_Init(void)
{
int i;
- int attrib[] =
+// LordHavoc: FIXME: finish this code, we need to allocate colors before we can store them
+#if 0
+ int gammaattrib[] =
+ {
+ GLX_RGBA,
+ GLX_RED_SIZE, 1,
+ GLX_GREEN_SIZE, 1,
+ GLX_BLUE_SIZE, 1,
+ GLX_DOUBLEBUFFER,
+ GLX_DEPTH_SIZE, 1,
+ GLX_X_VISUAL_TYPE, GLX_DIRECT_COLOR,
+ None
+ };
+#endif
+ int nogammaattrib[] =
{
GLX_RGBA,
GLX_RED_SIZE, 1,
XVisualInfo *visinfo;
qboolean fullscreen = true;
int MajorVersion, MinorVersion;
- int actualWidth, actualHeight;
Cvar_RegisterVariable (&vid_mouse);
Cvar_RegisterVariable (&vid_dga);
if (vid.conheight < 200)
vid.conheight = 200;
- if (!(dpy = XOpenDisplay(NULL)))
+ if (!(vidx11_display = XOpenDisplay(NULL)))
{
fprintf(stderr, "Error couldn't open the X display\n");
exit(1);
}
- scrnum = DefaultScreen(dpy);
- root = RootWindow(dpy, scrnum);
+ scrnum = DefaultScreen(vidx11_display);
+ root = RootWindow(vidx11_display, scrnum);
// Get video mode list
MajorVersion = MinorVersion = 0;
- if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion))
+ if (!XF86VidModeQueryVersion(vidx11_display, &MajorVersion, &MinorVersion))
vidmode_ext = false;
else
{
vidmode_ext = true;
}
- visinfo = glXChooseVisual(dpy, scrnum, attrib);
+ visinfo = NULL;
+// LordHavoc: FIXME: finish this code, we need to allocate colors before we can store them
+#if 0
+ if (!COM_CheckParm("-nogamma"))
+ visinfo = glXChooseVisual(vidx11_display, scrnum, gammaattrib);
+#endif
if (!visinfo)
{
- fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
- exit(1);
+ visinfo = glXChooseVisual(vidx11_display, scrnum, nogammaattrib);
+ if (!visinfo)
+ {
+ fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
+ exit(1);
+ }
}
if (vidmode_ext)
{
int best_fit, best_dist, dist, x, y;
- XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
+ XF86VidModeGetAllModeLines(vidx11_display, scrnum, &num_vidmodes, &vidmodes);
// Are we going fullscreen? If so, let's change video mode
if (fullscreen)
if (best_fit != -1)
{
- actualWidth = vidmodes[best_fit]->hdisplay;
- actualHeight = vidmodes[best_fit]->vdisplay;
+ // LordHavoc: changed from ActualWidth/ActualHeight =,
+ // to width/height =, so the window will take the full area of
+ // the mode chosen
+ width = vidmodes[best_fit]->hdisplay;
+ height = vidmodes[best_fit]->vdisplay;
// change to the mode
- XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
+ XF86VidModeSwitchToMode(vidx11_display, scrnum, vidmodes[best_fit]);
vidmode_active = true;
// Move the viewport to top left
- XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
+ XF86VidModeSetViewPort(vidx11_display, scrnum, 0, 0);
}
else
fullscreen = 0;
}
}
+ // LordHavoc: save the visual for use in gamma ramp settings later
+ vidx11_visual = visinfo->visual;
+
/* window attributes */
attr.background_pixel = 0;
attr.border_pixel = 0;
- attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
+ // LordHavoc: save the colormap for later, too
+ vidx11_colormap = attr.colormap = XCreateColormap(vidx11_display, root, visinfo->visual, AllocNone);
attr.event_mask = X_MASK;
if (vidmode_active)
{
else
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
- win = XCreateWindow(dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
- XStoreName(dpy, win, "DarkPlaces-GLX");
- XMapWindow(dpy, win);
+ win = XCreateWindow(vidx11_display, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
+ XStoreName(vidx11_display, win, gamename);
+ XMapWindow(vidx11_display, win);
if (vidmode_active)
{
- XMoveWindow(dpy, win, 0, 0);
- XRaiseWindow(dpy, win);
- XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
- XFlush(dpy);
+ XMoveWindow(vidx11_display, win, 0, 0);
+ XRaiseWindow(vidx11_display, win);
+ XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
+ XFlush(vidx11_display);
// Move the viewport to top left
- XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
+ XF86VidModeSetViewPort(vidx11_display, scrnum, 0, 0);
}
- XFlush(dpy);
+ XFlush(vidx11_display);
- ctx = glXCreateContext(dpy, visinfo, NULL, True);
+ ctx = glXCreateContext(vidx11_display, visinfo, NULL, True);
- glXMakeCurrent(dpy, win, ctx);
+ glXMakeCurrent(vidx11_display, win, ctx);
scr_width = width;
scr_height = height;
vid.conheight = height;
if (vid.conwidth > width)
vid.conwidth = width;
- vid.width = vid.conwidth;
- vid.height = vid.conheight;
InitSig(); // trap evil signals
Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
// force a surface cache flush
- vid.recalc_refdef = 1;
+// vid.recalc_refdef = 1;
}
void Sys_SendKeyEvents(void)
void IN_Init(void)
{
+ if (COM_CheckParm ("-nomouse"))
+ mouse_avail = false;
}
void IN_Shutdown(void)
if (!mouse_avail)
return;
- if (m_filter.value)
+ if (m_filter.integer)
{
mouse_x = (mouse_x + old_mouse_x) * 0.5;
mouse_y = (mouse_y + old_mouse_y) * 0.5;
if (/*freelook && */!(in_strafe.state & 1))
{
cl.viewangles[PITCH] += m_pitch.value * mouse_y;
- cl.viewangles[PITCH] = bound (-70, cl.viewangles[PITCH], 80);
+ cl.viewangles[PITCH] = bound (-90, cl.viewangles[PITCH], 90);
}
else
{
projects / xonotic / darkplaces.git / blobdiff