int main ( int argc, char* argv[] )
#endif // IPHONE
{
// int oldtime, newtime; // bk001204 - unused
int len, i;
char *cmdline;
char *cdpath, *sep;
void Sys_SetDefaultCDPath(const char *path);
// go back to real user for config loads
saved_euid = geteuid();
seteuid(getuid());
Sys_ParseArgs( argc, argv ); // bk010104 - added this for support
// Can't use CopyString() or Z_Free() yet:
cdpath = strdup(argv[0]);
if ((sep = Q_strrchr(cdpath, '/')))
*sep = '\0';
Sys_SetDefaultCDPath(cdpath);
free(cdpath);
// merge the command line, this is kinda silly
for (len = 1, i = 1; i < argc; i++)
len += strlen(argv[i]) + 1;
cmdline = malloc(len);
*cmdline = 0;
for (i = 1; i < argc; i++)
{
if (i > 1)
strcat(cmdline, " ");
strcat(cmdline, argv[i]);
}
// bk000306 - clear queues
memset( &eventQue[0], 0, MAX_QUED_EVENTS*sizeof(sysEvent_t) );
memset( &sys_packetReceived[0], 0, MAX_MSGLEN*sizeof(qbyte) );
Com_Init(cmdline);
NET_Init();
Sys_ConsoleInputInit();
fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
#ifdef DEDICATED
// init here for dedicated, as we don't have GLimp_Init
InitSig();
#endif
#ifndef IPHONE
while (1)
{
#ifdef __linux__
Sys_ConfigureFPU();
#endif
Com_Frame ();
}
#endif // !IPHONE
}
void I_PreInitGraphics(void)
{
// Initialize SDL
unsigned int flags = 0;
/* Vladimir
if (!(M_CheckParm("-nodraw") && M_CheckParm("-nosound")))
flags = SDL_INIT_VIDEO;
*/
jni_printf("SDL Init with flags %d" , flags);
#ifdef _DEBUG
flags |= SDL_INIT_NOPARACHUTE;
#endif
// Vladimir (Bypass on OpenGL)
//#ifndef GL_DOOM
if ( SDL_Init(flags) < 0 ) {
I_Error("Could not initialize SDL [%s]", SDL_GetError());
}
//#endif
jni_printf ("Initializing evil signal catcher");
InitSig();
atexit(I_ShutdownSDL);
}
void VID_Init(void)
{
InitSig(); // trap evil signals
Cvar_RegisterVariable(&apple_multithreadedgl);
Cvar_RegisterVariable(&apple_mouse_noaccel);
// COMMANDLINEOPTION: Input: -nomouse disables mouse support (see also vid_mouse cvar)
if (COM_CheckParm ("-nomouse"))
mouse_avail = false;
}
int main( int argc, char* argv[] ) {
// int oldtime, newtime; // bk001204 - unused
int len, i;
char *cmdline;
void Sys_SetDefaultCDPath( const char *path );
// go back to real user for config loads
saved_euid = geteuid();
seteuid( getuid() );
Sys_ParseArgs( argc, argv ); // bk010104 - added this for support
// TTimo: no CD path
Sys_SetDefaultCDPath( "" );
// merge the command line, this is kinda silly
for ( len = 1, i = 1; i < argc; i++ )
len += strlen( argv[i] ) + 1;
cmdline = malloc( len );
*cmdline = 0;
for ( i = 1; i < argc; i++ )
{
if ( i > 1 ) {
strcat( cmdline, " " );
}
strcat( cmdline, argv[i] );
}
// bk000306 - clear queues
memset( &eventQue[0], 0, MAX_QUED_EVENTS * sizeof( sysEvent_t ) );
memset( &sys_packetReceived[0], 0, MAX_MSGLEN * sizeof( byte ) );
Com_Init( cmdline );
NET_Init();
Sys_ConsoleInputInit();
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | FNDELAY );
#ifdef DEDICATED
// init here for dedicated, as we don't have GLimp_Init
InitSig();
#endif
while ( 1 )
{
#ifdef __linux__
Sys_ConfigureFPU();
#endif
Com_Frame();
}
}
int main( int argc, char **argv )
{
unsigned int oldtime, newtime, time;
InitSig();
#if defined ( __MACOSX__ ) && !defined (DEDICATED_ONLY)
char resourcesPath[MAXPATHLEN];
CFURLGetFileSystemRepresentation(CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()), 1, (UInt8 *)resourcesPath, MAXPATHLEN);
chdir(resourcesPath);
SDL_Init( SDL_INIT_VIDEO );
#endif
Qcommon_Init( argc, argv );
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | O_NONBLOCK );
nostdout = Cvar_Get( "nostdout", "0", 0 );
if( !nostdout->integer )
{
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | O_NONBLOCK );
}
oldtime = Sys_Milliseconds();
while( true )
{
// find time spent rendering last frame
do
{
newtime = Sys_Milliseconds();
time = newtime - oldtime;
if( time > 0 )
break;
#ifdef PUTCPU2SLEEP
Sys_Sleep( 0 );
#endif
}
while( 1 );
oldtime = newtime;
Qcommon_Frame( time );
}
#if defined ( __MACOSX__ ) && !defined (DEDICATED_ONLY)
SDL_Quit();
#endif
}
int main( int argc, char **argv )
{
unsigned int oldtime, newtime, time;
InitSig();
#if defined ( __MACOSX__ ) && !defined (DEDICATED_ONLY)
SDL_Init( 0 );
SDL_EnableUNICODE( SDL_ENABLE );
#endif
Qcommon_Init( argc, argv );
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | FNDELAY );
nostdout = Cvar_Get( "nostdout", "0", 0 );
if( !nostdout->integer )
{
fcntl( 0, F_SETFL, fcntl( 0, F_GETFL, 0 ) | FNDELAY );
}
oldtime = Sys_Milliseconds();
while( qtrue )
{
// find time spent rendering last frame
do
{
newtime = Sys_Milliseconds();
time = newtime - oldtime;
if( time > 0 )
break;
#ifdef PUTCPU2SLEEP
Sys_Sleep( 0 );
#endif
}
while( 1 );
oldtime = newtime;
Qcommon_Frame( time );
}
#if defined ( __MACOSX__ ) && !defined (DEDICATED_ONLY)
SDL_Quit();
#endif
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
void GLimp_Init( void ) {
qboolean attemptedlibGL = qfalse;
qboolean attempted3Dfx = qfalse;
qboolean success = qfalse;
char buf[1024];
cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
// cvar_t *cv; // bk001204 - unused
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_previousglDriver = ri.Cvar_Get( "r_previousglDriver", "", CVAR_ROM );
InitSig();
// Hack here so that if the UI
if ( *r_previousglDriver->string ) {
// The UI changed it on us, hack it back
// This means the renderer can't be changed on the fly
ri.Cvar_Set( "r_glDriver", r_previousglDriver->string );
}
// set up our custom error handler for X failures
XSetErrorHandler( &qXErrorHandler );
//
// load and initialize the specific OpenGL driver
//
if ( !GLW_LoadOpenGL( r_glDriver->string ) ) {
if ( !Q_stricmp( r_glDriver->string, OPENGL_DRIVER_NAME ) ) {
attemptedlibGL = qtrue;
} else if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) ) {
attempted3Dfx = qtrue;
}
#if 0
// show_bug.cgi?id=455
// removing outdated Voodoo GL loading
if ( !attempted3Dfx && !success ) {
attempted3Dfx = qtrue;
if ( GLW_LoadOpenGL( _3DFX_DRIVER_NAME ) ) {
ri.Cvar_Set( "r_glDriver", _3DFX_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
#endif
// try ICD before trying 3Dfx standalone driver
if ( !attemptedlibGL && !success ) {
attemptedlibGL = qtrue;
if ( GLW_LoadOpenGL( OPENGL_DRIVER_NAME ) ) {
ri.Cvar_Set( "r_glDriver", OPENGL_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
if ( !success ) {
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
}
}
// Save it in case the UI stomps it
ri.Cvar_Set( "r_previousglDriver", r_glDriver->string );
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
// get our config strings
Q_strncpyz( glConfig.vendor_string, qglGetString( GL_VENDOR ), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, qglGetString( GL_RENDERER ), sizeof( glConfig.renderer_string ) );
if ( *glConfig.renderer_string && glConfig.renderer_string[strlen( glConfig.renderer_string ) - 1] == '\n' ) {
glConfig.renderer_string[strlen( glConfig.renderer_string ) - 1] = 0;
}
Q_strncpyz( glConfig.version_string, qglGetString( GL_VERSION ), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, qglGetString( GL_EXTENSIONS ), sizeof( glConfig.extensions_string ) );
//
// chipset specific configuration
//
strcpy( buf, glConfig.renderer_string );
strlwr( buf );
//
// NOTE: if changing cvars, do it within this block. This allows them
// to be overridden when testing driver fixes, etc. but only sets
// them to their default state when the hardware is first installed/run.
//
if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) ) {
glConfig.hardwareType = GLHW_GENERIC;
ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
// VOODOO GRAPHICS w/ 2MB
if ( Q_stristr( buf, "voodoo graphics/1 tmu/2 mb" ) ) {
ri.Cvar_Set( "r_picmip", "2" );
ri.Cvar_Get( "r_picmip", "1", CVAR_ARCHIVE | CVAR_LATCH );
} else
{
ri.Cvar_Set( "r_picmip", "1" );
if ( Q_stristr( buf, "rage 128" ) || Q_stristr( buf, "rage128" ) ) {
ri.Cvar_Set( "r_finish", "0" );
}
// Savage3D and Savage4 should always have trilinear enabled
else if ( Q_stristr( buf, "savage3d" ) || Q_stristr( buf, "s3 savage4" ) ) {
ri.Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
}
}
}
//
// this is where hardware specific workarounds that should be
// detected/initialized every startup should go.
//
if ( Q_stristr( buf, "banshee" ) || Q_stristr( buf, "Voodoo_Graphics" ) ) {
glConfig.hardwareType = GLHW_3DFX_2D3D;
} else if ( Q_stristr( buf, "rage pro" ) || Q_stristr( buf, "RagePro" ) ) {
glConfig.hardwareType = GLHW_RAGEPRO;
} else if ( Q_stristr( buf, "permedia2" ) ) {
glConfig.hardwareType = GLHW_PERMEDIA2;
} else if ( Q_stristr( buf, "riva 128" ) ) {
glConfig.hardwareType = GLHW_RIVA128;
} else if ( Q_stristr( buf, "riva tnt " ) ) {
}
ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
// initialize extensions
GLW_InitExtensions();
GLW_InitGamma();
InitSig();
return;
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
int GLimp_Init( void *hinstance, void *wndproc )
{
InitSig();
return true;
}
void VID_Init(void)
{
InitSig(); // trap evil signals
}
/*
** GLimp_Init
**
** This is the platform specific OpenGL initialization function. It
** is responsible for loading OpenGL, initializing it, setting
** extensions, creating a window of the appropriate size, doing
** fullscreen manipulations, etc. Its overall responsibility is
** to make sure that a functional OpenGL subsystem is operating
** when it returns to the ref.
*/
void GLimp_Init( void )
{
char buf[1024];
cvar_t *lastValidRenderer = Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
cvar_t *cv;
VID_Printf( PRINT_ALL, "Initializing OpenGL subsystem\n" );
//glConfig.deviceSupportsGamma = qfalse;
InitSig();
//r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
// load appropriate DLL and initialize subsystem
GLW_StartOpenGL();
// get our config strings
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
{
Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
}
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 1024;
}
//
// chipset specific configuration
//
strcpy( buf, glConfig.renderer_string );
strlwr( buf );
//
// NOTE: if changing cvars, do it within this block. This allows them
// to be overridden when testing driver fixes, etc. but only sets
// them to their default state when the hardware is first installed/run.
//
if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
{
//reset to defaults
Cvar_Set( "r_picmip", "1" );
if ( strstr( buf, "matrox" )) {
Cvar_Set( "r_allowExtensions", "0");
}
Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
if ( strstr( buf, "intel" ) )
{
// disable dynamic glow as default
Cvar_Set( "r_DynamicGlow","0" );
}
if ( strstr( buf, "kyro" ) )
{
Cvar_Set( "r_ext_texture_filter_anisotropic", "0"); //KYROs have it avail, but suck at it!
Cvar_Set( "r_ext_preferred_tc_method", "1"); //(Use DXT1 instead of DXT5 - same quality but much better performance on KYRO)
}
GLW_InitExtensions();
//this must be a really sucky card!
if ( (glConfig.textureCompression == TC_NONE) || (glConfig.maxActiveTextures < 2) || (glConfig.maxTextureSize <= 512) )
{
Cvar_Set( "r_picmip", "2");
Cvar_Set( "r_colorbits", "16");
Cvar_Set( "r_texturebits", "16");
Cvar_Set( "r_mode", "3"); //force 640
Cmd_ExecuteString ("exec low.cfg\n"); //get the rest which can be pulled in after init
}
}
Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
LOGI("Force PICMIP");
Cvar_Set( "r_picmip", "2"); //Force to 2
GLW_InitExtensions();
//InitSig();
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
void GLimp_Init( void )
{
qboolean attemptedlibGL = qfalse;
qboolean attempted3Dfx = qfalse;
qboolean success = qfalse;
char buf[1024];
cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
cvar_t *cv;
glConfig.deviceSupportsGamma = qfalse;
InitSig();
//
// load and initialize the specific OpenGL driver
//
if ( !GLW_LoadOpenGL( r_glDriver->string ) )
{
if ( !Q_stricmp( r_glDriver->string, OPENGL_DRIVER_NAME ) )
{
attemptedlibGL = qtrue;
}
else if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
{
attempted3Dfx = qtrue;
}
if ( !attempted3Dfx && !success )
{
attempted3Dfx = qtrue;
if ( GLW_LoadOpenGL( _3DFX_DRIVER_NAME ) )
{
ri.Cvar_Set( "r_glDriver", _3DFX_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
// try ICD before trying 3Dfx standalone driver
if ( !attemptedlibGL && !success )
{
attemptedlibGL = qtrue;
if ( GLW_LoadOpenGL( OPENGL_DRIVER_NAME ) )
{
ri.Cvar_Set( "r_glDriver", OPENGL_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
if (!success)
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
}
// get our config strings
Q_strncpyz( glConfig.vendor_string, qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
Q_strncpyz( glConfig.version_string, qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
//
// chipset specific configuration
//
strcpy( buf, glConfig.renderer_string );
strlwr( buf );
if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
{
ri.Cvar_Set( "r_picmip", "1" );
ri.Cvar_Set( "r_twopartfog", "0" );
ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
//
// voodoo issues
//
if ( strstr( buf, "voodoo" ) && !strstr( buf, "banshee" ) )
{
ri.Cvar_Set( "r_fakeFullscreen", "1");
}
//
// Riva128 issues
//
if ( strstr( buf, "riva 128" ) )
{
ri.Cvar_Set( "r_twopartfog", "1" );
}
//
// Rage Pro issues
//
if ( strstr( buf, "rage pro" ) )
{
ri.Cvar_Set( "r_mode", "2" );
ri.Cvar_Set( "r_twopartfog", "1" );
}
//
// Permedia2 issues
//
if ( strstr( buf, "permedia2" ) )
{
ri.Cvar_Set( "r_vertexLight", "1" );
}
//
// Riva TNT issues
//
if ( strstr( buf, "riva tnt " ) )
{
if ( r_texturebits->integer == 32 ||
( ( r_texturebits->integer == 0 ) && glConfig.colorBits > 16 ) )
{
ri.Cvar_Set( "r_picmip", "1" );
}
}
ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
}
// initialize extensions
GLW_InitExtensions();
InitSig();
return;
}
static void VID_SDL_Init(void)
{
SDL_Surface *icon_surface;
extern void InitSig(void);
SDL_DisplayMode display_mode;
int flags;
if (glConfig.initialized == true)
return;
flags = SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS | SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_SHOWN;
#ifdef SDL_WINDOW_ALLOW_HIGHDPI
flags |= SDL_WINDOW_ALLOW_HIGHDPI;
#endif
if (r_fullscreen.integer <= 0) {
flags &= ~SDL_WINDOW_FULLSCREEN;
if (vid_win_borderless.integer <= 0)
flags &= ~SDL_WINDOW_BORDERLESS;
}
#if defined(__linux__)
InitSig();
#endif
VID_SDL_InitSubSystem();
VID_SDL_GL_SetupAttributes();
VID_SetupResolution();
sdl_window = SDL_CreateWindow(WINDOW_CLASS_NAME, vid_xpos.integer, vid_ypos.integer, glConfig.vidWidth, glConfig.vidHeight, flags);
icon_surface = SDL_CreateRGBSurfaceFrom((void *)ezquake_icon.pixel_data, ezquake_icon.width, ezquake_icon.height, ezquake_icon.bytes_per_pixel * 8,
ezquake_icon.width * ezquake_icon.bytes_per_pixel,
0x000000FF,0x0000FF00,0x00FF0000,0xFF000000);
if (icon_surface) {
SDL_SetWindowIcon(sdl_window, icon_surface);
SDL_FreeSurface(icon_surface);
}
SDL_SetWindowMinimumSize(sdl_window, 320, 240);
sdl_context = SDL_GL_CreateContext(sdl_window);
if (!sdl_context) {
Com_Printf("Couldn't create OpenGL context: %s\n", SDL_GetError());
return;
}
r_swapInterval.modified = true;
if (!SDL_GetWindowDisplayMode(sdl_window, &display_mode))
glConfig.displayFrequency = display_mode.refresh_rate;
else
glConfig.displayFrequency = 0;
glConfig.colorBits = 24; // FIXME
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &glConfig.depthBits);
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &glConfig.stencilBits);
glConfig.vendor_string = glGetString(GL_VENDOR);
glConfig.renderer_string = glGetString(GL_RENDERER);
glConfig.version_string = glGetString(GL_VERSION);
glConfig.extensions_string = glGetString(GL_EXTENSIONS);
glConfig.initialized = true;
#if defined(__linux__)
InitSig(); // not clear why this is at begin & end of function
#endif
}
void VID_Init(unsigned char *palette)
{
int i;
int attrib[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
GLX_DEPTH_SIZE, 1,
None
};
int width = 640, height = 480;
XSetWindowAttributes attr;
unsigned long mask;
Window root;
XVisualInfo *visinfo;
#ifdef USE_VMODE
qbool fullscreen = true;
int MajorVersion, MinorVersion;
int actualWidth, actualHeight;
#endif
Cvar_Register (&vid_ref);
Cvar_Register (&vid_mode);
Cvar_Register (&vid_hwgammacontrol);
Cvar_Register (&_windowed_mouse);
Cvar_Register (&m_filter);
vid.colormap = host_colormap;
// interpret command-line params
// fullscreen cmdline check
#ifdef USE_VMODE
if (COM_CheckParm("-window"))
fullscreen = false;
#endif
// set vid parameters
if ((i = COM_CheckParm("-width")) != 0)
width = atoi(com_argv[i+1]);
if ((i = COM_CheckParm("-height")) != 0)
height = atoi(com_argv[i+1]);
if ((i = COM_CheckParm("-conwidth")) != 0)
vid.width = Q_atoi(com_argv[i+1]);
else
vid.width = 640;
vid.width &= 0xfff8; // make it a multiple of eight
if (vid.width < 320)
vid.width = 320;
// pick a conheight that matches with correct aspect
vid.height = vid.width*3 / 4;
if ((i = COM_CheckParm("-conheight")) != 0)
vid.height = Q_atoi(com_argv[i+1]);
if (vid.height < 200)
vid.height = 200;
if (!(x_disp = XOpenDisplay(NULL)))
{
fprintf(stderr, "Error couldn't open the X display\n");
exit(1);
}
scrnum = DefaultScreen(x_disp);
root = RootWindow(x_disp, scrnum);
#ifdef USE_VMODE
// check vmode extensions supported
// Get video mode list
MajorVersion = MinorVersion = 0;
if (!XF86VidModeQueryVersion(x_disp, &MajorVersion, &MinorVersion))
{
vidmode_ext = false;
}
else
{
Com_Printf("Using XFree86-VidModeExtension Version %d.%d\n", MajorVersion, MinorVersion);
vidmode_ext = true;
}
#endif
visinfo = glXChooseVisual(x_disp, scrnum, attrib);
if (!visinfo)
{
fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
exit(1);
}
// setup fullscreen size to fit display -->
#ifdef USE_VMODE
if (vidmode_ext)
{
int best_fit, best_dist, dist, x, y;
XF86VidModeGetAllModeLines(x_disp, 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 (width > vidmodes[i]->hdisplay || height > vidmodes[i]->vdisplay)
continue;
x = width - vidmodes[i]->hdisplay;
y = height - 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(x_disp, scrnum, vidmodes[best_fit]);
vidmode_active = true;
// Move the viewport to top left
XF86VidModeSetViewPort(x_disp, scrnum, 0, 0);
}
else
{
fullscreen = 0;
}
}
}
#endif
/* window attributes */
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(x_disp, root, visinfo->visual, AllocNone);
attr.event_mask = X_MASK;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
// if fullscreen disable window manager decoration
#ifdef USE_VMODE
if (vidmode_active)
{
mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore |
CWEventMask | CWOverrideRedirect;
attr.override_redirect = True;
attr.backing_store = NotUseful;
attr.save_under = False;
}
#endif
x_win = XCreateWindow(x_disp, root, 0, 0, width, height,
0, visinfo->depth, InputOutput,
visinfo->visual, mask, &attr);
XStoreName(x_disp, x_win, PROGRAM);
XMapWindow(x_disp, x_win);
#ifdef USE_VMODE
if (vidmode_active)
{
XRaiseWindow(x_disp, x_win);
XWarpPointer(x_disp, None, x_win, 0, 0, 0, 0, 0, 0);
XFlush(x_disp);
// Move the viewport to top left
XF86VidModeSetViewPort(x_disp, scrnum, 0, 0);
}
#endif
XFlush(x_disp);
ctx = glXCreateContext(x_disp, visinfo, NULL, True);
glXMakeCurrent(x_disp, x_win, ctx);
vid.realwidth = width;
vid.realheight = height;
if (vid.height > height)
vid.height = height;
if (vid.width > width)
vid.width = width;
vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
vid.numpages = 2;
InitSig(); // trap evil signals
GL_Init();
Check_Gamma(palette);
VID_SetPalette(palette);
InitHWGamma();
Com_Printf ("Video mode %dx%d initialized.\n", width, height);
SCR_InvalidateScreen ();
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
void GLimp_Init( void )
{
qboolean attemptedlibGL = qfalse;
qboolean attempted3Dfx = qfalse;
qboolean success = qfalse;
char buf[1024];
cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
// cvar_t *cv; // bk001204 - unused
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_previousglDriver = ri.Cvar_Get( "r_previousglDriver", "", CVAR_ROM );
glConfig.deviceSupportsGamma = qfalse;
InitSig();
//
// load and initialize the specific OpenGL driver
//
GLW_StartOpenGL();
// get our config strings
const char* glstring;
glstring = (const char *)qglGetString (GL_VENDOR);
if (!glstring) {
glstring = "invalid driver";
}
Q_strncpyz( glConfig.vendor_string, glstring, sizeof( glConfig.vendor_string ) );
glstring = (const char *)qglGetString (GL_RENDERER);
if (!glstring) {
glstring = "invalid driver";
}
Q_strncpyz( glConfig.renderer_string, glstring, sizeof( glConfig.renderer_string ) );
glstring = (const char *)qglGetString (GL_VERSION);
if (!glstring) {
glstring = "invalid driver";
}
Q_strncpyz( glConfig.version_string, glstring, sizeof( glConfig.version_string ) );
glstring = (const char *)qglGetString (GL_EXTENSIONS);
if (!glstring) {
glstring = "invalid driver";
}
Q_strncpyz( glConfig.extensions_string, glstring, sizeof( glConfig.extensions_string ) );
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
//
// chipset specific configuration
//
strcpy( buf, glConfig.renderer_string );
Q_strlwr( buf );
//
// NOTE: if changing cvars, do it within this block. This allows them
// to be overridden when testing driver fixes, etc. but only sets
// them to their default state when the hardware is first installed/run.
//
if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
{
ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
ri.Cvar_Set( "r_picmip", "1" );
}
ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
// initialize extensions
GLW_InitExtensions();
InitSig();
return;
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
void GLimp_Init( void )
{
qboolean attemptedlibGL = qfalse;
qboolean attempted3Dfx = qfalse;
qboolean success = qfalse;
// guarded, as this is only relevant to SMP renderer thread
#ifdef SMP
if (!XInitThreads())
{
Com_Printf("GLimp_Init() - XInitThreads() failed, disabling r_smp\n");
ri.Cvar_Set( "r_smp", "0" );
}
#endif
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_previousglDriver = ri.Cvar_Get( "r_previousglDriver", "", CVAR_ROM );
InitSig();
IN_Init(); // rcg08312005 moved into glimp.
// Hack here so that if the UI
if ( *r_previousglDriver->string )
{
// The UI changed it on us, hack it back
// This means the renderer can't be changed on the fly
ri.Cvar_Set( "r_glDriver", r_previousglDriver->string );
}
// set up our custom error handler for X failures
XSetErrorHandler(&qXErrorHandler);
//
// load and initialize the specific OpenGL driver
//
if ( !GLW_LoadOpenGL( r_glDriver->string ) )
{
if ( !Q_stricmp( r_glDriver->string, OPENGL_DRIVER_NAME ) )
{
attemptedlibGL = qtrue;
} else if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
{
attempted3Dfx = qtrue;
}
#if 0
// TTimo
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=455
// old legacy load code, was confusing people who had a bad OpenGL setup
if ( !attempted3Dfx && !success )
{
attempted3Dfx = qtrue;
if ( GLW_LoadOpenGL( _3DFX_DRIVER_NAME ) )
{
ri.Cvar_Set( "r_glDriver", _3DFX_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
#endif
// try ICD before trying 3Dfx standalone driver
if ( !attemptedlibGL && !success )
{
attemptedlibGL = qtrue;
if ( GLW_LoadOpenGL( OPENGL_DRIVER_NAME ) )
{
ri.Cvar_Set( "r_glDriver", OPENGL_DRIVER_NAME );
r_glDriver->modified = qfalse;
success = qtrue;
}
}
if (!success)
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
}
// Save it in case the UI stomps it
ri.Cvar_Set( "r_previousglDriver", r_glDriver->string );
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
// get our config strings
Q_strncpyz( glConfig.vendor_string, (char *)qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (char *)qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
Q_strncpyz( glConfig.version_string, (char *)qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (char *)qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
GL_ResolveHardwareType( );
ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
// initialize extensions
GLW_InitExtensions();
GLW_InitGamma();
InitSig(); // not clear why this is at begin & end of function
return;
}
