hermitworks
/
st
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
st/code/unix/sdl_glimp.c

877 lines
22 KiB
C
Raw Blame History

#ifdef _MSC_VER
#pragma warning(disable : 4206)
#endif
#ifdef USE_SDL_VIDEO
/*
* SDL implementation for Quake 3: Arena's GPL source release.
*
* I wrote such a beast originally for Loki's port of Heavy Metal: FAKK2,
* and then wrote it again for the Linux client of Medal of Honor: Allied
* Assault. Third time's a charm, so I'm rewriting this once more for the
* GPL release of Quake 3.
*
* Written by Ryan C. Gordon (icculus@icculus.org). Please refer to
* http://icculus.org/quake3/ for the latest version of this code.
*
* Patches and comments are welcome at the above address.
*
* I cut-and-pasted this from linux_glimp.c, and moved it to SDL line-by-line.
* There is probably some cruft that could be removed here.
*
* You should define USE_SDL=1 and then add this to the makefile.
* USE_SDL will disable the X11 target.
*/
/*
Original copyright on Q3A sources:
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
/*
** GLW_IMP.C
**
** This file contains ALL Linux specific stuff having to do with the
** OpenGL refresh. When a port is being made the following functions
** must be implemented by the port:
**
** GLimp_EndFrame
** GLimp_Init
** GLimp_Shutdown
** GLimp_SwitchFullscreen
** GLimp_SetGamma
**
*/
#include <SDL/SDL.h>
#include <SDL/SDL_syswm.h>
#ifdef SMP
#include "SDL_thread.h"
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef _MSC_VER
#include <dlfcn.h>
#endif
#include "../render-base/tr_local.h"
#ifndef _MSC_VER
#include "linux_local.h" // bk001130
#include "unix_glw.h"
#else
#include "../win32/glw_win.h"
#include "../win32/win_local.h"
#endif
/* Just hack it for now. */
#ifdef MACOS_X
#include <OpenGL/OpenGL.h>
typedef CGLContextObj QGLContext;
#define GLimp_GetCurrentContext() CGLGetCurrentContext()
#define GLimp_SetCurrentContext(ctx) CGLSetCurrentContext(ctx)
#else
typedef void *QGLContext;
#define GLimp_GetCurrentContext() (NULL)
#define GLimp_SetCurrentContext(ctx)
#endif
static QGLContext opengl_context;
#define WINDOW_CLASS_NAME "SpaceTrader"
#define WINDOW_CLASS_NAME_BRIEF "st"
//not implemented this side yet. Force it to false restores old behavior
bool glimp_suspendRender = false;
//#define KBD_DBG
typedef enum
{
RSERR_OK,
RSERR_INVALID_FULLSCREEN,
RSERR_INVALID_MODE,
RSERR_UNKNOWN
} rserr_t;
glwstate_t glw_state;
cvar_t *in_nograb; // this is strictly for developers
cvar_t *r_allowSoftwareGL; // don't abort out if the pixelformat claims software
cvar_t *r_previousglDriver;
void IN_StartupJoystick( void );
void IN_JoyMove( void );
qboolean GLimp_sdl_init_video(void)
{
if (!SDL_WasInit(SDL_INIT_VIDEO))
{
ri.Printf( PRINT_ALL, "Calling SDL_Init(SDL_INIT_VIDEO)...\n");
if (SDL_Init(SDL_INIT_VIDEO) == -1)
{
ri.Printf( PRINT_ALL, "SDL_Init(SDL_INIT_VIDEO) failed: %s\n", SDL_GetError());
return qfalse;
}
ri.Printf( PRINT_ALL, "SDL_Init(SDL_INIT_VIDEO) passed.\n");
}
return qtrue;
}
// NOTE TTimo for the tty console input, we didn't rely on those ..
// it's not very surprising actually cause they are not used otherwise
void KBD_Init(void)
{}
void KBD_Close(void)
{}
/*****************************************************************************/
/*
** GLimp_SetGamma
**
** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
*/
void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] )
{
// NOTE TTimo we get the gamma value from cvar, because we can't work with the s_gammatable
// the API wasn't changed to avoid breaking other OSes
float g;
if ( r_ignorehwgamma->integer )
return;
g = ri.Cvar_Get("r_gamma", "1.0", 0)->value;
SDL_SetGamma(g, g, g);
}
/*
** GLimp_Shutdown
**
** This routine does all OS specific shutdown procedures for the OpenGL
** subsystem. Under OpenGL this means NULLing out the current DC and
** HGLRC, deleting the rendering context, and releasing the DC acquired
** for the window. The state structure is also nulled out.
**
*/
void GLimp_Shutdown( void )
{
// R_BloomKill();
// R_CgKill();
R_StateKill();
SDL_QuitSubSystem(SDL_INIT_VIDEO);
((WinVars_t *)ri.PlatformGetVars())->screen = NULL;
memset(&glConfig, 0, sizeof(glConfig));
}
/*
** GLimp_LogComment
*/
#ifdef _DEBUG
void GLimp_LogComment( int level, char *comment, ... )
{
if ( glw_state.log_fp )
{
fprintf( glw_state.log_fp, "%s", comment );
}
}
#endif
/*
** GLW_StartDriverAndSetMode
*/
// bk001204 - prototype needed
static rserr_t GLW_SetMode( const char *drivername, int mode, qboolean fullscreen );
static qboolean GLW_StartDriverAndSetMode( const char *drivername,
int mode,
qboolean fullscreen )
{
rserr_t err;
if (GLimp_sdl_init_video() == qfalse)
return qfalse;
in_nograb = ri.Cvar_Get("in_nograb", "0", 0);
if (fullscreen && in_nograb->integer)
{
ri.Printf( PRINT_ALL, "Fullscreen should not be used with in_nograb 1\n");
/*ri.Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = qfalse;
fullscreen = qfalse;*/
}
err = GLW_SetMode( drivername, mode, fullscreen );
switch ( err )
{
case RSERR_INVALID_FULLSCREEN:
ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
return qfalse;
case RSERR_INVALID_MODE:
ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
return qfalse;
default:
break;
}
return qtrue;
}
/*
** GLW_SetMode
*/
static rserr_t GLW_SetMode(const char *drivername, int mode, qboolean fullscreen)
{
const char *glstring; // bk001130 - from cvs1.17 (mkv)
int sdlcolorbits = 4;
int colorbits, depthbits, stencilbits;
int tcolorbits, tdepthbits, tstencilbits;
int fsaabits;
int fullNoBorder=qfalse;
int i = 0;
SDL_Surface *vidscreen = NULL;
Uint32 flags;
ri.Printf(PRINT_ALL, "Initializing OpenGL display\n");
ri.Printf(PRINT_ALL, "...setting mode %d:", mode);
if (mode < -1 )
{
mode *=-1;
fullNoBorder = qtrue;
}
if(!R_GetModeInfo(&glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode))
{
ri.Printf(PRINT_ALL, " invalid mode\n");
return RSERR_INVALID_MODE;
}
if (g_wv.hWnd) {
int width, height, x_return, y_return, border_width_return, depth_return;
Window w;
g_wv.display = XOpenDisplay(NULL);
XGetGeometry( g_wv.display, g_wv.hWnd, &w, &x_return, &y_return, &width, &height, &border_width_return, &depth_return);
glConfig.vidWidth = width;
glConfig.vidHeight = height;
}
glConfig.xscale = glConfig.vidWidth / 640.0f;
glConfig.yscale = glConfig.vidHeight / 480.0f;
if ( glConfig.vidWidth * 480 > glConfig.vidHeight * 640 ) {
// wide screen
glConfig.xscale = glConfig.yscale;
glConfig.xbias = ((float)glConfig.vidWidth - (640.0f * glConfig.xscale)) * 0.5f;
}
else {
// no wide screen
glConfig.xbias = 0.0f;
}
ri.Printf(PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
flags = SDL_OPENGL;
if(fullscreen)
{
if (fullNoBorder)
{
flags |= SDL_NOFRAME;
}
else
{
flags |= SDL_FULLSCREEN;
}
}
if(!r_colorbits->value)
colorbits = 24;
else
colorbits = r_colorbits->value;
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;
}
sdlcolorbits = 4;
if(tcolorbits == 24)
sdlcolorbits = 8;
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, sdlcolorbits);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, tdepthbits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, tstencilbits);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if( r_fsaa->integer )
{
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, r_fsaa->integer);
}
SDL_WM_SetCaption(WINDOW_CLASS_NAME, WINDOW_CLASS_NAME_BRIEF);
SDL_ShowCursor(0);
SDL_EnableUNICODE(1);
//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
((WinVars_t *)ri.PlatformGetVars())->sdlrepeatenabled = qtrue;
if((vidscreen = SDL_SetVideoMode(glConfig.vidWidth, glConfig.vidHeight, colorbits, flags)) == NULL)
{
fprintf(stderr, "SDL_SetVideoMode failed: %s\n", SDL_GetError());
continue;
}
//Safe to get this info now.
SDL_GetWMInfo(&g_wv.wmInfo);
if( glewInit() == GLEW_OK )
{
R_StateKill();
R_StateInit();
//Setup CG
// R_CgKill(); //sanity check
// R_CgInit();
// R_BloomInit();
ri.Printf(PRINT_ALL, "GLEW Loaded\n");
}
if (g_wv.hWnd) {
int result;
/*for ( ; ; ) {
result = XGrabPointer(g_wv.wmInfo.info.x11.display, g_wv.wmInfo.info.x11.window, True, 0, GrabModeAsync, GrabModeAsync, g_wv.wmInfo.info.x11.window, None, CurrentTime);
if ( result == GrabSuccess ) {
break;
}
SDL_Delay(100);
}*/
//asm("int $3");
//result = XGrabKeyboard(g_wv.wmInfo.info.x11.display, g_wv.wmInfo.info.x11.window, True, GrabModeAsync, GrabModeAsync, CurrentTime);
//XRaiseWindow(g_wv.wmInfo.info.x11.display, g_wv.wmInfo.info.x11.window);
SDL_WM_GrabInput(SDL_GRAB_ON);
//XReparentWindow(g_wv.wmInfo.info.x11.display, g_wv.wmInfo.info.x11.window, (Window)g_wv.hWnd, 0, 0);
//XReparentWindow(g_wv.wmInfo
}
opengl_context = GLimp_GetCurrentContext();
// SDL_VERSION(&g_wv.wmInfo.version);
// SDL_GetWMInfo(&g_wv.wmInfo);
ri.Printf(PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n",
sdlcolorbits, sdlcolorbits, sdlcolorbits, tdepthbits, tstencilbits);
glConfig.colorBits = tcolorbits;
glConfig.depthBits = tdepthbits;
glConfig.stencilBits = tstencilbits;
break;
}
if(r_fsaa->integer)
{
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &fsaabits);
ri.Printf(PRINT_ALL, "SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", fsaabits);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &fsaabits);
ri.Printf(PRINT_ALL, "SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", r_fsaa->integer, fsaabits);
}
if(!vidscreen)
{
ri.Printf(PRINT_ALL, "Couldn't get a visual\n");
return RSERR_INVALID_MODE;
}
((WinVars_t *)ri.PlatformGetVars())->screen = vidscreen;
// bk001130 - from cvs1.17 (mkv)
glstring = (char *) glGetString(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;
}
/*
** GLW_InitExtensions
*/
static void GLW_InitExtensions( void )
{
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = qfalse;
if ( GLEW_EXT_texture_env_add )
{
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
}
static void GLW_InitGamma( void )
{
glConfig.deviceSupportsGamma = qtrue;
}
/*
** GLW_LoadOpenGL
**
** GLimp_win.c internal function that that attempts to load and use
** a specific OpenGL DLL.
*/
static qboolean GLW_LoadOpenGL( const char *name )
{
qboolean fullscreen;
ri.Printf( PRINT_ALL, "...loading %s:\n", name );
// disable the 3Dfx splash screen and set gamma
// we do this all the time, but it shouldn't hurt anything
// on non-3Dfx stuff
putenv("FX_GLIDE_NO_SPLASH=0");
// Mesa VooDoo hacks
putenv("MESA_GLX_FX=fullscreen\n");
// load the QGL layer
fullscreen = r_fullscreen->integer?qtrue:qfalse;
// create the window and set up the context
if ( !GLW_StartDriverAndSetMode( name, r_fullscreen->integer ? r_fsmode->integer : r_mode->integer, fullscreen ) )
{
if (r_mode->integer != 3)
{
if ( !GLW_StartDriverAndSetMode( name, 3, fullscreen ) )
{
goto fail;
}
}
else
goto fail;
}
return qtrue;
fail:
return qfalse;
}
/*
** GLimp_Init
**
** This routine is responsible for initializing the OS specific portions
** of OpenGL.
*/
void GLimp_Init( void )
{
cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_previousglDriver = ri.Cvar_Get( "r_previousglDriver", "", CVAR_ROM );
// 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 );
}
//
// load and initialize the specific OpenGL driver
//
GLW_LoadOpenGL( OPENGL_DRIVER_NAME );
// get our config strings
Q_strncpyz( glConfig.vendor_string, (const char*)glGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
Q_strncpyz( glConfig.renderer_string, (const char*)glGetString (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, (const char*)glGetString (GL_VERSION), sizeof( glConfig.version_string ) );
Q_strncpyz( glConfig.extensions_string, (const char*)glGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
//
// 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_LINEAR" );
ri.Cvar_Set( "r_picmip", "1" );
}
ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
// initialize extensions
GLW_InitExtensions();
GLW_InitGamma();
return;
}
/*
** GLimp_EndFrame
**
** Responsible for doing a swapbuffers and possibly for other stuff
** as yet to be determined. Probably better not to make this a GLimp
** function and instead do a call to GLimp_SwapBuffers.
*/
void GLimp_EndFrame (void)
{
SDL_GL_SwapBuffers();
if( r_fullscreen->modified )
{
qboolean fullscreen;
qboolean sdlToggled = qfalse;
SDL_Surface *s = SDL_GetVideoSurface( );
if( s )
{
// Find out the current state
if( s->flags & SDL_FULLSCREEN )
fullscreen = qtrue;
else
fullscreen = qfalse;
// Is the state we want different from the current state?
if( !!r_fullscreen->integer != fullscreen )
sdlToggled = SDL_WM_ToggleFullScreen( s ) ? qtrue : qfalse;
else
sdlToggled = qtrue;
}
r_fullscreen->modified = qfalse;
}
}
#ifdef SMP
/*
===========================================================
SMP acceleration
===========================================================
*/
/*
* I have no idea if this will even work...most platforms don't offer
* thread-safe OpenGL libraries, and it looks like the original Linux
* code counted on each thread claiming the GL context with glXMakeCurrent(),
* which you can't currently do in SDL. We'll just have to hope for the best.
*/
static SDL_mutex *smpMutex = NULL;
static SDL_cond *renderCommandsEvent = NULL;
static SDL_cond *renderCompletedEvent = NULL;
static void (*glimpRenderThread)( void ) = NULL;
static SDL_Thread *renderThread = NULL;
static void GLimp_ShutdownRenderThread(void)
{
if (smpMutex != NULL)
{
SDL_DestroyMutex(smpMutex);
smpMutex = NULL;
}
if (renderCommandsEvent != NULL)
{
SDL_DestroyCond(renderCommandsEvent);
renderCommandsEvent = NULL;
}
if (renderCompletedEvent != NULL)
{
SDL_DestroyCond(renderCompletedEvent);
renderCompletedEvent = NULL;
}
glimpRenderThread = NULL;
}
static int GLimp_RenderThreadWrapper( void *arg )
{
Com_Printf( "Render thread starting\n" );
glimpRenderThread();
GLimp_SetCurrentContext(NULL);
Com_Printf( "Render thread terminating\n" );
return 0;
}
qboolean GLimp_SpawnRenderThread( void (*function)( void ) )
{
static qboolean warned = qfalse;
if (!warned)
{
Com_Printf("WARNING: You enable r_smp at your own risk!\n");
warned = qtrue;
}
#ifndef MACOS_X
return qfalse; /* better safe than sorry for now. */
#endif
if (renderThread != NULL) /* hopefully just a zombie at this point... */
{
Com_Printf("Already a render thread? Trying to clean it up...\n");
SDL_WaitThread(renderThread, NULL);
renderThread = NULL;
GLimp_ShutdownRenderThread();
}
smpMutex = SDL_CreateMutex();
if (smpMutex == NULL)
{
Com_Printf( "smpMutex creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
renderCommandsEvent = SDL_CreateCond();
if (renderCommandsEvent == NULL)
{
Com_Printf( "renderCommandsEvent creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
renderCompletedEvent = SDL_CreateCond();
if (renderCompletedEvent == NULL)
{
Com_Printf( "renderCompletedEvent creation failed: %s\n", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
glimpRenderThread = function;
renderThread = SDL_CreateThread(GLimp_RenderThreadWrapper, NULL);
if ( renderThread == NULL )
{
ri.Printf( PRINT_ALL, "SDL_CreateThread() returned %s", SDL_GetError() );
GLimp_ShutdownRenderThread();
return qfalse;
}
else
{
// !!! FIXME: No detach API available in SDL!
//ret = pthread_detach( renderThread );
//if ( ret ) {
//ri.Printf( PRINT_ALL, "pthread_detach returned %d: %s", ret, strerror( ret ) );
//}
}
return qtrue;
}
static volatile void *smpData = NULL;
static volatile qboolean smpDataReady;
void *GLimp_RendererSleep( void )
{
void *data = NULL;
GLimp_SetCurrentContext(NULL);
SDL_LockMutex(smpMutex);
{
smpData = NULL;
smpDataReady = qfalse;
// after this, the front end can exit GLimp_FrontEndSleep
SDL_CondSignal(renderCompletedEvent);
while ( !smpDataReady )
{
SDL_CondWait(renderCommandsEvent, smpMutex);
}
data = (void *)smpData;
}
SDL_UnlockMutex(smpMutex);
GLimp_SetCurrentContext(opengl_context);
return data;
}
void GLimp_FrontEndSleep( void )
{
SDL_LockMutex(smpMutex);
{
while ( smpData )
{
SDL_CondWait(renderCompletedEvent, smpMutex);
}
}
SDL_UnlockMutex(smpMutex);
GLimp_SetCurrentContext(opengl_context);
}
void GLimp_WakeRenderer( void *data )
{
GLimp_SetCurrentContext(NULL);
SDL_LockMutex(smpMutex);
{
assert( smpData == NULL );
smpData = data;
smpDataReady = qtrue;
// after this, the renderer can continue through GLimp_RendererSleep
SDL_CondSignal(renderCommandsEvent);
}
SDL_UnlockMutex(smpMutex);
}
#else
void GLimp_RenderThreadWrapper( void *stub ) {}
qboolean GLimp_SpawnRenderThread( void (*function)( void ) )
{
ri.Printf( PRINT_WARNING, "ERROR: SMP support was disabled at compile time\n");
return qfalse;
}
void *GLimp_RendererSleep( void )
{
return NULL;
}
void GLimp_FrontEndSleep( void ) {}
void GLimp_WakeRenderer( void *data ) {}
#endif
// bk001130 - cvs1.17 joystick code (mkv) was here, no linux_joystick.c
// (moved this back in here from linux_joystick.c, so it's all in one place...
// --ryan.
#endif // USE_SDL_VIDEO
// end sdl_glimp.c ...
Reference in New Issue View Git Blame Copy Permalink