void Sys_Init( void ) {
// make sure the timer is high precision, otherwise
// NT gets 18ms resolution
timeBeginPeriod( 1 );
Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
if (!GetVersionEx (&g_wv.osversion))
Sys_Error ("Couldn't get OS info");
if (g_wv.osversion.dwMajorVersion < 4)
Sys_Error ("This game requires Windows version 4 or greater");
if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
Sys_Error ("This game doesn't run on Win32s");
Cvar_Set( "arch", OS_STRING " " ARCH_STRING );
// save out a couple things in rom cvars for the renderer to access
Cvar_Get( "win_hinstance", va("%p", g_wv.hInstance), CVAR_ROM );
Cvar_Get( "win_wndproc", va("%p", MainWndProc), CVAR_ROM );
Cvar_Set( "username", Sys_GetCurrentUser() );
IN_Init(); // FIXME: not in dedicated?
}
void HUD_Init( void )
{
g_engfuncs.pfnAddCommand ("noclip", NULL, "enable or disable no clipping mode" );
g_engfuncs.pfnAddCommand ("notarget", NULL, "notarget mode (monsters do not see you)" );
g_engfuncs.pfnAddCommand ("fullupdate", NULL, "re-init HUD on start demo recording" );
g_engfuncs.pfnAddCommand ("give", NULL, "give specified item or weapon" );
g_engfuncs.pfnAddCommand ("drop", NULL, "drop current/specified item or weapon" );
g_engfuncs.pfnAddCommand ("intermission", NULL, "go to intermission" );
g_engfuncs.pfnAddCommand ("spectate", NULL, "enable spectator mode" );
g_engfuncs.pfnAddCommand ("gametitle", NULL, "show game logo" );
g_engfuncs.pfnAddCommand ("god", NULL, "classic cheat" );
g_engfuncs.pfnAddCommand ("fov", NULL, "set client field of view" );
g_engfuncs.pfnAddCommand ("fly", NULL, "fly mode (flight)" );
HUD_ShutdownEffects ();
g_pParticleSystems = new ParticleSystemManager();
g_pViewRenderBeams = new CViewRenderBeams();
g_pParticles = new CParticleSystem();
g_pTempEnts = new CTempEnts();
InitRain(); // init weather system
gHUD.Init();
IN_Init ();
// link all events
EV_HookEvents ();
}
/*
** GLW_CreateWindow
**
** Responsible for creating the Alchemy window and initializing the OpenGL driver.
*/
static qboolean GLW_CreateWindow( int width, int height, int colorbits, qboolean cdsFullscreen )
{
GLW_Init(width, height, colorbits, cdsFullscreen);
IN_Init();
return qtrue;
}
/**
* @brief This routine is responsible for initializing the OS specific portions of OpenGL
* @param[in,out] glConfig
* @param[in] context
*/
void GLimp_Init(glconfig_t *glConfig, windowContext_t *context)
{
SDL_version compiled;
SDL_version linked;
SDL_VERSION(&compiled);
SDL_GetVersion(&linked);
Com_Printf("SDL build version %d.%d.%d - link version %d.%d.%d.\n", compiled.major, compiled.minor, compiled.patch, linked.major, linked.minor, linked.patch);
GLimp_InitCvars();
if (Cvar_VariableIntegerValue("com_abnormalExit"))
{
Cvar_Set("r_mode", va("%d", R_MODE_FALLBACK));
Cvar_Set("r_fullscreen", "0");
Cvar_Set("r_centerWindow", "0");
Cvar_Set("com_abnormalExit", "0");
}
Sys_GLimpInit();
// Create the window and set up the context
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, (qboolean) !!r_noBorder->integer, context))
{
goto success;
}
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit();
if (GLimp_StartDriverAndSetMode(glConfig, r_mode->integer, (qboolean) !!r_fullscreen->integer, qfalse, context))
{
goto success;
}
// Finally, try the default screen resolution
if (r_mode->integer != R_MODE_FALLBACK)
{
Com_Printf("Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK);
if (GLimp_StartDriverAndSetMode(glConfig, R_MODE_FALLBACK, qfalse, qfalse, context))
{
goto success;
}
}
// Nothing worked, give up
Com_Error(ERR_VID_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n");
success:
// Only using SDL_SetWindowBrightness to determine if hardware gamma is supported
glConfig->deviceSupportsGamma = !r_ignorehwgamma->integer && SDL_SetWindowBrightness(main_window, 1.0f) >= 0;
re.InitOpenGL();
Cvar_Get("r_availableModes", "", CVAR_ROM);
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init();
}
void Sys_Init (void) {
Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
Cvar_Set( "arch", "rim" );
Cvar_Set( "username", Sys_GetCurrentUser() );
IN_Init();
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
//r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
Sys_GLimpInit( );
#ifdef SDL_VIDEO_DRIVER_X11
XInitThreads( );
#endif
// create the window and set up the context
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit( );
if( GLimp_StartDriverAndSetMode( ) )
goto success;
// Finally, try the default screen resolution
//if( GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer ) )
// goto success;
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (SDL_SetWindowBrightness( window, 1.0f ) == 0)?1:0;//FIXME: Use SDL_SetWindowGammaRamp with NULL instead?
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
//glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// 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 ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
void Sys_Init( void ) {
Cmd_AddCommand( "in_restart", Sys_In_Restart_f );
#if defined __linux__
#if defined __i386__
Cvar_Set( "arch", "linux i386" );
#elif defined __alpha__
Cvar_Set( "arch", "linux alpha" );
#elif defined __sparc__
Cvar_Set( "arch", "linux sparc" );
#elif defined __FreeBSD__
#if defined __i386__ // FreeBSD
Cvar_Set( "arch", "freebsd i386" );
#elif defined __alpha__
Cvar_Set( "arch", "freebsd alpha" );
#else
Cvar_Set( "arch", "freebsd unknown" );
#endif // FreeBSD
#elif defined __OpenBSD__
#if defined __i386__ // OpenBSD
Cvar_Set( "arch", "openbsd i386" );
#elif defined __amd64__
Cvar_Set( "arch", "openbsd amd64" );
#else
Cvar_Set( "arch", "openbsd unknown" );
#endif // OpenBSD
#else
Cvar_Set( "arch", "linux unknown" );
#endif
#elif defined __sun__
#if defined __i386__
Cvar_Set( "arch", "solaris x86" );
#elif defined __sparc__
Cvar_Set( "arch", "solaris sparc" );
#else
Cvar_Set( "arch", "solaris unknown" );
#endif
#elif defined __sgi__
#if defined __mips__
Cvar_Set( "arch", "sgi mips" );
#else
Cvar_Set( "arch", "sgi unknown" );
#endif
#else
Cvar_Set( "arch", "unknown" );
#endif
Cvar_Set( "username", Sys_GetCurrentUser() );
IN_Init();
}
void Sys_Init( void ) {
// make sure the timer is high precision, otherwise
// NT gets 18ms resolution
timeBeginPeriod( 1 );
Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
#if MEM_DEBUG
SH_Register();
#endif
g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
if (!GetVersionEx (&g_wv.osversion))
Sys_Error ("Couldn't get OS info");
if (Sys_IsExpired()) {
g_wv.osversion.dwMajorVersion = 0;
}
if (g_wv.osversion.dwMajorVersion < 4)
Sys_Error ("This game requires Windows version 4 or greater");
if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
Sys_Error ("This game doesn't run on Win32s");
if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
Cvar_Set( "arch", "winnt" );
}
else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
{
if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
{
Cvar_Set( "arch", "win98" );
}
else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
{
Cvar_Set( "arch", "win95 osr2.x" );
}
else
{
Cvar_Set( "arch", "win95" );
}
}
else
{
Cvar_Set( "arch", "unknown Windows variant" );
}
// save out a couple things in rom cvars for the renderer to access
Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
Cvar_Set( "username", Sys_GetCurrentUser() );
IN_Init(); // FIXME: not in dedicated?
}
void IN_Restart_f(void)
{
qbool old_mouse_active = mouse_active;
IN_Shutdown();
IN_Init();
// if mouse was active before restart, try to re-activate it
if (old_mouse_active)
IN_ActivateMouse();
}
void IN_Restart_f(void)
{
if (!host_initialized)
{
// Sanity
Com_Printf("Can't do %s yet\n", Cmd_Argv(0));
return;
}
IN_Shutdown();
IN_Init();
}
void GLimp_Init(void)
{
ri.Printf(PRINT_ALL, "Initializing OpenGL subsystem\n");
bzero(&glConfig, sizeof(glConfig));
glConfig.isFullscreen = r_fullscreen->integer;
glConfig.vidWidth = screen_width;
glConfig.vidHeight = screen_height;
glConfig.windowAspect = (float)glConfig.vidWidth / glConfig.vidHeight;
// FIXME
glConfig.colorBits = 32;
glConfig.stencilBits = 8;
glConfig.depthBits = 16;
glConfig.textureCompression = TC_NONE;
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
Q_strncpyz(glConfig.vendor_string,
(const char *)qglGetString(GL_VENDOR),
sizeof(glConfig.vendor_string));
Q_strncpyz(glConfig.renderer_string,
(const char *)qglGetString(GL_RENDERER),
sizeof(glConfig.renderer_string));
const char *ptr = Q_stristr( glConfig.renderer_string, "Mali-" );
if (ptr != NULL)
malimode=1;
Q_strncpyz(glConfig.version_string,
(const char *)qglGetString(GL_VERSION),
sizeof(glConfig.version_string));
Q_strncpyz(glConfig.extensions_string,
(const char *)qglGetString(GL_EXTENSIONS),
sizeof(glConfig.extensions_string));
qglLockArraysEXT = qglLockArrays;
qglUnlockArraysEXT = qglUnlockArrays;
GLimp_InitExtensions();
IN_Init( );
ri.Printf(PRINT_ALL, "------------------\n");
}
void
CL_Init(void)
{
if (dedicated->value)
{
return; /* nothing running on the client */
}
/* all archived variables will now be loaded */
Con_Init();
S_Init();
SCR_Init();
VID_Init();
IN_Init();
V_Init();
net_message.data = net_message_buffer;
net_message.maxsize = sizeof(net_message_buffer);
M_Init();
cls.disable_screen = true; /* don't draw yet */
#ifdef CDA
CDAudio_Init();
#endif
CL_InitLocal();
FS_ExecAutoexec();
Cbuf_Execute();
Key_ReadConsoleHistory();
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
qboolean success = qtrue;
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
Sys_GLimpInit( );
// create the window and set up the context
if( !GLimp_StartDriverAndSetMode( qfalse, r_fullscreen->integer ) )
{
if( !GLimp_StartDriverAndSetMode( qtrue, r_fullscreen->integer ) )
success = qfalse;
}
if( !success )
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = !!( SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0 );
// 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 ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
void Sys_Init(void)
{
Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
#if id386
Sys_SetFPCW();
#endif
#if defined __linux__
#if defined __i386__
Cvar_Set( "arch", "linux i386" );
#elif defined __alpha__
Cvar_Set( "arch", "linux alpha" );
#elif defined __sparc__
Cvar_Set( "arch", "linux sparc" );
#else
Cvar_Set( "arch", "linux unknown" );
#endif
#elif defined __sun__
#if defined __i386__
Cvar_Set( "arch", "solaris x86" );
#elif defined __sparc__
Cvar_Set( "arch", "solaris sparc" );
#else
Cvar_Set( "arch", "solaris unknown" );
#endif
#elif defined __sgi__
#if defined __mips__
Cvar_Set( "arch", "sgi mips" );
#else
Cvar_Set( "arch", "sgi unknown" );
#endif
#else
Cvar_Set( "arch", "unknown" );
#endif
IN_Init();
}
void GLimp_Init( void ) {
if (SDLvidscreen)
return;
if( !GLimp_StartDriverAndSetMode( r_mode->integer, r_fullscreen->integer , qfalse) )
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
// Hardware gamma is not supported in recent Linux/SDL.
glConfig.deviceSupportsGamma = qfalse;
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));
glConfig.extensions_string = (char *)qglGetString(GL_EXTENSIONS);
GLimp_InitExtensions();
glConfig.stereoEnabled = qfalse;
IN_Init();
return;
}
/*
====================
Host_Init
====================
*/
void Host_Init (quakeparms_t *parms)
{
if (standard_quake)
minimum_memory = MINIMUM_MEMORY;
else
minimum_memory = MINIMUM_MEMORY_LEVELPAK;
if (COM_CheckParm ("-minmemory"))
parms->memsize = minimum_memory;
host_parms = *parms;
if (parms->memsize < minimum_memory)
Sys_Error ("Only %4.1f megs of memory available, can't execute game", parms->memsize / (float)0x100000);
com_argc = parms->argc;
com_argv = parms->argv;
Memory_Init (parms->membase, parms->memsize);
Cbuf_Init ();
Cmd_Init ();
V_Init ();
// jkrige - removed chase
//Chase_Init ();
// jkrige - removed chase
Host_InitVCR (parms);
COM_Init (parms->basedir);
Host_InitLocal ();
W_LoadWadFile ("gfx.wad");
Key_Init ();
Con_Init ();
M_Init ();
PR_Init ();
Mod_Init ();
NET_Init ();
SV_Init ();
Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
Con_Printf ("%4.1f megabyte heap\n",parms->memsize/ (1024*1024.0));
R_InitTextures (); // needed even for dedicated servers
if (cls.state != ca_dedicated)
{
host_basepal = (byte *)COM_LoadHunkFile ("gfx/palette.lmp");
if (!host_basepal)
Sys_Error ("Couldn't load gfx/palette.lmp");
host_colormap = (byte *)COM_LoadHunkFile ("gfx/colormap.lmp");
if (!host_colormap)
Sys_Error ("Couldn't load gfx/colormap.lmp");
#ifndef _WIN32 // on non win32, mouse comes before video for security reasons
IN_Init ();
#endif
VID_Init (host_basepal);
Draw_Init ();
SCR_Init ();
R_Init ();
#ifndef _WIN32
// on Win32, sound initialization has to come before video initialization, so we
// can put up a popup if the sound hardware is in use
S_Init ();
// jkrige - fmod sound system (system)
FMOD_Init();
// jkrige - fmod sound system (system)
#else
#ifdef GLQUAKE
// FIXME: doesn't use the new one-window approach yet
S_Init ();
// jkrige - fmod sound system (system)
FMOD_Init();
// jkrige - fmod sound system (system)
#endif
#endif // _WIN32
// jkrige - fmod sound system (music)
//CDAudio_Init ();
// jkrige - fmod sound system (music)
Sbar_Init ();
CL_Init ();
#ifdef _WIN32 // on non win32, mouse comes before video for security reasons
IN_Init ();
#endif
}
Cbuf_InsertText ("exec quake.rc\n");
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
host_initialized = true;
Sys_Printf ("========Quake Initialized=========\n");
}
void IN_Restart(void)
{
IN_Init();
}
window_t WIN_Init( const windowDesc_t *windowDesc, glconfig_t *glConfig )
{
Cmd_AddCommand("modelist", R_ModeList_f);
Cmd_AddCommand("minimize", GLimp_Minimize);
r_sdlDriver = Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
// Window cvars
r_fullscreen = Cvar_Get( "r_fullscreen", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_noborder = Cvar_Get( "r_noborder", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_centerWindow = Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_customwidth = Cvar_Get( "r_customwidth", "1600", CVAR_ARCHIVE|CVAR_LATCH );
r_customheight = Cvar_Get( "r_customheight", "1024", CVAR_ARCHIVE|CVAR_LATCH );
r_swapInterval = Cvar_Get( "r_swapInterval", "0", CVAR_ARCHIVE );
r_stereo = Cvar_Get( "r_stereo", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_mode = Cvar_Get( "r_mode", "4", CVAR_ARCHIVE|CVAR_LATCH );
r_displayRefresh = Cvar_Get( "r_displayRefresh", "0", CVAR_LATCH );
Cvar_CheckRange( r_displayRefresh, 0, 240, qtrue );
// Window render surface cvars
r_stencilbits = Cvar_Get( "r_stencilbits", "8", CVAR_ARCHIVE|CVAR_LATCH );
r_depthbits = Cvar_Get( "r_depthbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_colorbits = Cvar_Get( "r_colorbits", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE|CVAR_LATCH );
r_ext_multisample = Cvar_Get( "r_ext_multisample", "0", CVAR_ARCHIVE|CVAR_LATCH );
// Create the window and set up the context
if(!GLimp_StartDriverAndSetMode( glConfig, windowDesc, r_mode->integer,
(qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer ))
{
if( r_mode->integer != R_MODE_FALLBACK )
{
Com_Printf( "Setting r_mode %d failed, falling back on r_mode %d\n", r_mode->integer, R_MODE_FALLBACK );
if (!GLimp_StartDriverAndSetMode( glConfig, windowDesc, R_MODE_FALLBACK, qfalse, qfalse ))
{
// Nothing worked, give up
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
}
}
}
glConfig->deviceSupportsGamma =
(qboolean)(!r_ignorehwgamma->integer && SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( screen );
// window_t is only really useful for Windows if the renderer wants to create a D3D context.
window_t window = {};
window.api = windowDesc->api;
#if defined(_WIN32)
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
if ( SDL_GetWindowWMInfo(screen, &info) )
{
switch(info.subsystem) {
case SDL_SYSWM_WINDOWS:
window.handle = info.info.win.window;
break;
default:
break;
}
}
#endif
return window;
}
bool
Host_Init(quakeparms_t *parms)
{
if (standard_quake)
minimum_memory = MINIMUM_MEMORY;
else
minimum_memory = MINIMUM_MEMORY_LEVELPAK;
if (COM_CheckParm("-minmemory"))
parms->memsize = minimum_memory;
host_parms = *parms;
if (parms->memsize < minimum_memory)
return Sys_Error("Only %4.1f megs of memory reported, can't execute game",
parms->memsize / (float)0x100000);
com_argc = parms->argc;
com_argv = parms->argv;
Memory_Init(parms->membase, parms->memsize);
Cbuf_Init();
Cmd_Init();
V_Init();
Chase_Init();
COM_Init();
Host_InitLocal();
if (!W_LoadWadFile("gfx.wad"))
return false;
Key_Init();
Con_Init();
M_Init();
PR_Init();
Mod_Init(R_ModelLoader());
NET_Init();
SV_Init();
Con_Printf("Exe: " __TIME__ " " __DATE__ "\n");
Con_Printf("%4.1f megabyte heap\n", parms->memsize / (1024 * 1024.0));
R_InitTextures(); // needed even for dedicated servers
if (cls.state != ca_dedicated) {
host_basepal = (byte*)COM_LoadHunkFile("gfx/palette.lmp");
if (!host_basepal)
return Sys_Error("Couldn't load gfx/palette.lmp");
host_colormap = (byte*)COM_LoadHunkFile("gfx/colormap.lmp");
if (!host_colormap)
return Sys_Error("Couldn't load gfx/colormap.lmp");
if (coloredlights)
host_fullbrights = 256-host_colormap[16384]; // leilei - variable our fullbright counts if available
VID_Init(host_basepal);
Draw_Init();
SCR_Init();
R_Init();
S_Init();
CDAudio_Init();
BGM_Init();
Sbar_Init();
CL_Init();
IN_Init();
}
Hunk_AllocName(0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark();
host_initialized = true;
Sys_Printf("========Quake Initialized=========\n");
/* In case exec of quake.rc fails */
if (!setjmp(host_abort)) {
Cbuf_InsertText("exec quake.rc\n");
Cbuf_Execute();
}
return true;
}
void Sys_Init( void ) {
int cpuid;
// make sure the timer is high precision, otherwise
// NT gets 18ms resolution
timeBeginPeriod( 1 );
Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
#if MEM_DEBUG
SH_Register();
#endif
g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
if (!GetVersionEx (&g_wv.osversion))
Sys_Error ("Couldn't get OS info");
if (Sys_IsExpired()) {
g_wv.osversion.dwMajorVersion = 0;
}
if (g_wv.osversion.dwMajorVersion < 4)
Sys_Error ("This game requires Windows version 4 or greater");
if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
Sys_Error ("This game doesn't run on Win32s");
if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
{
Cvar_Set( "arch", "winnt" );
}
else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
{
if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
{
Cvar_Set( "arch", "win98" );
}
else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
{
Cvar_Set( "arch", "win95 osr2.x" );
}
else
{
Cvar_Set( "arch", "win95" );
}
}
else
{
Cvar_Set( "arch", "unknown Windows variant" );
}
// save out a couple things in rom cvars for the renderer to access
Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
//
// figure out our CPU
//
Cvar_Get( "sys_cpustring", "detect", 0 );
if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring"), "detect" ) )
{
Com_Printf( "...detecting CPU, found " );
cpuid = Sys_GetProcessorId();
switch ( cpuid )
{
case CPUID_GENERIC:
Cvar_Set( "sys_cpustring", "generic" );
break;
case CPUID_INTEL_UNSUPPORTED:
Cvar_Set( "sys_cpustring", "x86 (pre-Pentium)" );
break;
case CPUID_INTEL_PENTIUM:
Cvar_Set( "sys_cpustring", "x86 (P5/PPro, non-MMX)" );
break;
case CPUID_INTEL_MMX:
Cvar_Set( "sys_cpustring", "x86 (P5/Pentium2, MMX)" );
break;
case CPUID_INTEL_KATMAI:
Cvar_Set( "sys_cpustring", "Intel Pentium III" );
break;
case CPUID_INTEL_WILLIAMETTE:
Cvar_Set( "sys_cpustring", "Intel Pentium IV" );
break;
case CPUID_AMD_3DNOW:
Cvar_Set( "sys_cpustring", "AMD w/ 3DNow!" );
break;
case CPUID_AXP:
Cvar_Set( "sys_cpustring", "Alpha AXP" );
break;
default:
Com_Error( ERR_FATAL, "Unknown cpu type %d\n", cpuid );
break;
}
}
else
{
Com_Printf( "...forcing CPU type to " );
if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "generic" ) )
{
cpuid = CPUID_GENERIC;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "x87" ) )
{
cpuid = CPUID_INTEL_PENTIUM;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "mmx" ) )
{
cpuid = CPUID_INTEL_MMX;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "3dnow" ) )
{
cpuid = CPUID_AMD_3DNOW;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIII" ) )
{
cpuid = CPUID_INTEL_KATMAI;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIV" ) )
{
cpuid = CPUID_INTEL_WILLIAMETTE;
}
else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "axp" ) )
{
cpuid = CPUID_AXP;
}
else
{
Com_Printf( "WARNING: unknown sys_cpustring '%s'\n", Cvar_VariableString( "sys_cpustring" ) );
cpuid = CPUID_GENERIC;
}
}
Cvar_SetValue( "sys_cpuid", cpuid );
Com_Printf( "%s\n", Cvar_VariableString( "sys_cpustring" ) );
Cvar_Set( "username", Sys_GetCurrentUser() );
IN_Init(); // FIXME: not in dedicated?
}
/*
===============
IN_Restart
===============
*/
void IN_Restart()
{
IN_ShutdownJoystick();
IN_Init( window );
}
/*
** 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 );
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 );
}
//
// 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 ) );
//
// 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(); // not clear why this is at begin & end of function
return;
}
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
char cwd[ MAX_OSPATH ];
int startTime, endTime;
// should never get a previous instance in Win32
if ( hPrevInstance )
{
return 0;
}
#ifdef EXCEPTION_HANDLER
WinSetExceptionVersion( Q3_VERSION );
#endif
g_wv.hInstance = hInstance;
Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
// done before Com/Sys_Init since we need this for error output
Sys_CreateConsole();
// no abort/retry/fail errors
SetErrorMode( SEM_FAILCRITICALERRORS );
// get the initial time base
Sys_Milliseconds();
//Sys_InitStreamThread();
Com_Init( sys_cmdline );
NET_Init();
#if !defined(DEDICATED) && !defined(BUILD_TTY_CLIENT)
IN_Init(); // fretn - directinput must be inited after video etc
#endif
_getcwd( cwd, sizeof( cwd ) );
Com_Printf( "Working directory: %s\n", cwd );
// hide the early console since we've reached the point where we
// have a working graphics subsystems
if ( !com_dedicated->integer && !com_viewlog->integer )
{
Sys_ShowConsole( 0, qfalse );
}
SetFocus( g_wv.hWnd );
// main game loop
while ( 1 )
{
// if not running as a game client, sleep a bit
if ( g_wv.isMinimized || ( com_dedicated && com_dedicated->integer ) )
{
Sleep( 5 );
}
// set low precision every frame, because some system calls
// reset it arbitrarily
// _controlfp( _PC_24, _MCW_PC );
// _controlfp( -1, _MCW_EM ); // no exceptions, even if some crappy
// syscall turns them back on!
startTime = Sys_Milliseconds();
// make sure mouse and joystick are only called once a frame
IN_Frame();
// Com_FrameExt();
Com_Frame();
endTime = Sys_Milliseconds();
totalMsec += endTime - startTime;
countMsec++;
}
// never gets here
}
/*
===============
GLimp_Init
This routine is responsible for initializing the OS specific portions
of OpenGL
===============
*/
void GLimp_Init( void )
{
r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri.Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri.Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
r_centerWindow = ri.Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE );
if( Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
ri.Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
ri.Cvar_Set( "r_fullscreen", "0" );
ri.Cvar_Set( "r_centerWindow", "0" );
ri.Cvar_Set( "com_abnormalExit", "0" );
ri.Cvar_Set( "r_postprocess", "none");
ri.Cvar_Set( "r_ext_vertex_shader", "0");
}
Sys_SetEnv( "SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "" );
Sys_GLimpInit( );
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, r_noborder->integer))
goto success;
// Try again, this time in a platform specific "safe mode"
Sys_GLimpSafeInit( );
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse))
goto success;
// Finally, try the default screen resolution
if( r_mode->integer != R_MODE_FALLBACK )
{
ri.Printf( PRINT_ALL, "Setting r_mode %d failed, falling back on r_mode %d\n",
r_mode->integer, R_MODE_FALLBACK );
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse))
goto success;
}
// Nothing worked, give up
ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
success:
// This values force the UI to disable driver selection
glConfig.driverType = GLDRV_ICD;
glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// Mysteriously, if you use an NVidia graphics card and multiple monitors,
// SDL_SetGamma will incorrectly return false... the first time; ask
// again and you get the correct answer. This is a suspected driver bug, see
// http://bugzilla.icculus.org/show_bug.cgi?id=4316
glConfig.deviceSupportsGamma = SDL_SetGamma( 1.0f, 1.0f, 1.0f ) >= 0;
// 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 ) );
// initialize extensions
GLimp_InitExtensions( );
ri.Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
IN_Init( );
}
void IN_Restart(void)
{
//IN_ShutdownJoystick();
IN_Init();
}
/*
====================
Host_Init
====================
*/
void Host_Init (void)
{
if (standard_quake)
minimum_memory = MINIMUM_MEMORY;
else minimum_memory = MINIMUM_MEMORY_LEVELPAK;
if (COM_CheckParm ("-minmemory"))
host_parms->memsize = minimum_memory;
if (host_parms->memsize < minimum_memory)
Sys_Error ("Only %4.1f megs of memory available, can't execute game", host_parms->memsize / (float)0x100000);
com_argc = host_parms->argc;
com_argv = host_parms->argv;
Memory_Init (host_parms->membase, host_parms->memsize);
Cbuf_Init ();
Cmd_Init ();
LOG_Init (host_parms);
Cvar_Init (); //johnfitz
COM_Init ();
COM_InitFilesystem ();
Host_InitLocal ();
W_LoadWadFile (); //johnfitz -- filename is now hard-coded for honesty
if (cls.state != ca_dedicated)
{
Key_Init ();
Con_Init ();
}
PR_Init ();
Mod_Init ();
NET_Init ();
SV_Init ();
Con_Printf ("Exe: "__TIME__" "__DATE__"\n");
Con_Printf ("%4.1f megabyte heap\n", host_parms->memsize/ (1024*1024.0));
if (cls.state != ca_dedicated)
{
host_colormap = (byte *)COM_LoadHunkFile ("gfx/colormap.lmp", NULL);
if (!host_colormap)
Sys_Error ("Couldn't load gfx/colormap.lmp");
V_Init ();
Chase_Init ();
M_Init ();
ExtraMaps_Init (); //johnfitz
Modlist_Init (); //johnfitz
DemoList_Init (); //ericw
VID_Init ();
IN_Init ();
TexMgr_Init (); //johnfitz
Draw_Init ();
SCR_Init ();
R_Init ();
S_Init ();
CDAudio_Init ();
BGM_Init();
Sbar_Init ();
CL_Init ();
}
Hunk_AllocName (0, "-HOST_HUNKLEVEL-");
host_hunklevel = Hunk_LowMark ();
host_initialized = true;
Con_Printf ("\n========= Quake Initialized =========\n\n");
if (cls.state != ca_dedicated)
{
Cbuf_InsertText ("exec quake.rc\n");
// johnfitz -- in case the vid mode was locked during vid_init, we can unlock it now.
// note: two leading newlines because the command buffer swallows one of them.
Cbuf_AddText ("\n\nvid_unlock\n");
}
if (cls.state == ca_dedicated)
{
Cbuf_AddText ("exec autoexec.cfg\n");
Cbuf_AddText ("stuffcmds");
Cbuf_Execute ();
if (!sv.active)
Cbuf_AddText ("map start\n");
}
}
/*
=================
Sys_In_Restart_f
Restart the input subsystem
=================
*/
void Sys_In_Restart_f( void )
{
IN_Shutdown();
IN_Init();
}
============
*/
void InitInput (void)
{
gEngfuncs.pfnAddCommand ("+moveup",IN_UpDown);
gEngfuncs.pfnAddCommand ("-moveup",IN_UpUp);
gEngfuncs.pfnAddCommand ("+movedown",IN_DownDown);
gEngfuncs.pfnAddCommand ("-movedown",IN_DownUp);
gEngfuncs.pfnAddCommand ("+left",IN_LeftDown);
gEngfuncs.pfnAddCommand ("-left",IN_LeftUp);
gEngfuncs.pfnAddCommand ("+right",IN_RightDown);
gEngfuncs.pfnAddCommand ("-right",IN_RightUp);
gEngfuncs.pfnAddCommand ("+forward",IN_ForwardDown);
gEngfuncs.pfnAddCommand ("-forward",IN_ForwardUp);
gEngfuncs.pfnAddCommand ("+back",IN_BackDown);
gEngfuncs.pfnAddCommand ("-back",IN_BackUp);
gEngfuncs.pfnAddCommand ("+lookup", IN_LookupDown);
gEngfuncs.pfnAddCommand ("-lookup", IN_LookupUp);
gEngfuncs.pfnAddCommand ("+lookdown", IN_LookdownDown);
gEngfuncs.pfnAddCommand ("-lookdown", IN_LookdownUp);
gEngfuncs.pfnAddCommand ("+strafe", IN_StrafeDown);
gEngfuncs.pfnAddCommand ("-strafe", IN_StrafeUp);
gEngfuncs.pfnAddCommand ("+moveleft", IN_MoveleftDown);
gEngfuncs.pfnAddCommand ("-moveleft", IN_MoveleftUp);
gEngfuncs.pfnAddCommand ("+moveright", IN_MoverightDown);
gEngfuncs.pfnAddCommand ("-moveright", IN_MoverightUp);
gEngfuncs.pfnAddCommand ("+speed", IN_SpeedDown);
gEngfuncs.pfnAddCommand ("-speed", IN_SpeedUp);
gEngfuncs.pfnAddCommand ("+attack", IN_AttackDown);
gEngfuncs.pfnAddCommand ("-attack", IN_AttackUp);
gEngfuncs.pfnAddCommand ("+attack2", IN_Attack2Down);
gEngfuncs.pfnAddCommand ("-attack2", IN_Attack2Up);
gEngfuncs.pfnAddCommand ("+use", IN_UseDown);
gEngfuncs.pfnAddCommand ("-use", IN_UseUp);
gEngfuncs.pfnAddCommand ("+jump", IN_JumpDown);
gEngfuncs.pfnAddCommand ("-jump", IN_JumpUp);
gEngfuncs.pfnAddCommand ("impulse", IN_Impulse);
gEngfuncs.pfnAddCommand ("+klook", IN_KLookDown);
gEngfuncs.pfnAddCommand ("-klook", IN_KLookUp);
gEngfuncs.pfnAddCommand ("+mlook", IN_MLookDown);
gEngfuncs.pfnAddCommand ("-mlook", IN_MLookUp);
gEngfuncs.pfnAddCommand ("+jlook", IN_JLookDown);
gEngfuncs.pfnAddCommand ("-jlook", IN_JLookUp);
gEngfuncs.pfnAddCommand ("+duck", IN_DuckDown);
gEngfuncs.pfnAddCommand ("-duck", IN_DuckUp);
gEngfuncs.pfnAddCommand ("+reload", IN_ReloadDown);
gEngfuncs.pfnAddCommand ("-reload", IN_ReloadUp);
gEngfuncs.pfnAddCommand ("+alt1", IN_Alt1Down);
gEngfuncs.pfnAddCommand ("-alt1", IN_Alt1Up);
gEngfuncs.pfnAddCommand ("+score", IN_ScoreDown);
gEngfuncs.pfnAddCommand ("-score", IN_ScoreUp);
gEngfuncs.pfnAddCommand ("+showscores", IN_ScoreDown);
gEngfuncs.pfnAddCommand ("-showscores", IN_ScoreUp);
gEngfuncs.pfnAddCommand ("+graph", IN_GraphDown);
gEngfuncs.pfnAddCommand ("-graph", IN_GraphUp);
gEngfuncs.pfnAddCommand ("+break",IN_BreakDown);
gEngfuncs.pfnAddCommand ("-break",IN_BreakUp);
lookstrafe = gEngfuncs.pfnRegisterVariable ( "lookstrafe", "0", FCVAR_ARCHIVE );
lookspring = gEngfuncs.pfnRegisterVariable ( "lookspring", "0", FCVAR_ARCHIVE );
cl_anglespeedkey = gEngfuncs.pfnRegisterVariable ( "cl_anglespeedkey", "0.67", 0 );
cl_yawspeed = gEngfuncs.pfnRegisterVariable ( "cl_yawspeed", "210", 0 );
cl_pitchspeed = gEngfuncs.pfnRegisterVariable ( "cl_pitchspeed", "225", 0 );
cl_upspeed = gEngfuncs.pfnRegisterVariable ( "cl_upspeed", "320", 0 );
cl_forwardspeed = gEngfuncs.pfnRegisterVariable ( "cl_forwardspeed", "400", FCVAR_ARCHIVE );
cl_backspeed = gEngfuncs.pfnRegisterVariable ( "cl_backspeed", "400", FCVAR_ARCHIVE );
cl_sidespeed = gEngfuncs.pfnRegisterVariable ( "cl_sidespeed", "400", 0 );
cl_movespeedkey = gEngfuncs.pfnRegisterVariable ( "cl_movespeedkey", "0.3", 0 );
cl_pitchup = gEngfuncs.pfnRegisterVariable ( "cl_pitchup", "89", 0 );
cl_pitchdown = gEngfuncs.pfnRegisterVariable ( "cl_pitchdown", "89", 0 );
cl_vsmoothing = gEngfuncs.pfnRegisterVariable ( "cl_vsmoothing", "0.05", FCVAR_ARCHIVE );
m_pitch = gEngfuncs.pfnRegisterVariable ( "m_pitch","0.022", FCVAR_ARCHIVE );
m_yaw = gEngfuncs.pfnRegisterVariable ( "m_yaw","0.022", FCVAR_ARCHIVE );
m_forward = gEngfuncs.pfnRegisterVariable ( "m_forward","1", FCVAR_ARCHIVE );
m_side = gEngfuncs.pfnRegisterVariable ( "m_side","0.8", FCVAR_ARCHIVE );
// Initialize third person camera controls.
CAM_Init();
// Initialize inputs
IN_Init();
// Initialize keyboard
KB_Init();
// Initialize view system
/*
* CL_InitInput
*/
void CL_InitInput( void )
{
if( in_initialized )
return;
Cmd_AddCommand( "in_restart", IN_Restart );
IN_Init();
Cmd_AddCommand( "centerview", IN_CenterView );
Cmd_AddCommand( "+moveup", IN_UpDown );
Cmd_AddCommand( "-moveup", IN_UpUp );
Cmd_AddCommand( "+movedown", IN_DownDown );
Cmd_AddCommand( "-movedown", IN_DownUp );
Cmd_AddCommand( "+left", IN_LeftDown );
Cmd_AddCommand( "-left", IN_LeftUp );
Cmd_AddCommand( "+right", IN_RightDown );
Cmd_AddCommand( "-right", IN_RightUp );
Cmd_AddCommand( "+forward", IN_ForwardDown );
Cmd_AddCommand( "-forward", IN_ForwardUp );
Cmd_AddCommand( "+back", IN_BackDown );
Cmd_AddCommand( "-back", IN_BackUp );
Cmd_AddCommand( "+lookup", IN_LookupDown );
Cmd_AddCommand( "-lookup", IN_LookupUp );
Cmd_AddCommand( "+lookdown", IN_LookdownDown );
Cmd_AddCommand( "-lookdown", IN_LookdownUp );
Cmd_AddCommand( "+strafe", IN_StrafeDown );
Cmd_AddCommand( "-strafe", IN_StrafeUp );
Cmd_AddCommand( "+moveleft", IN_MoveleftDown );
Cmd_AddCommand( "-moveleft", IN_MoveleftUp );
Cmd_AddCommand( "+moveright", IN_MoverightDown );
Cmd_AddCommand( "-moveright", IN_MoverightUp );
Cmd_AddCommand( "+speed", IN_SpeedDown );
Cmd_AddCommand( "-speed", IN_SpeedUp );
Cmd_AddCommand( "+attack", IN_AttackDown );
Cmd_AddCommand( "-attack", IN_AttackUp );
Cmd_AddCommand( "+use", IN_UseDown );
Cmd_AddCommand( "-use", IN_UseUp );
Cmd_AddCommand( "+klook", IN_KLookDown );
Cmd_AddCommand( "-klook", IN_KLookUp );
// wsw
Cmd_AddCommand( "+special", IN_SpecialDown );
Cmd_AddCommand( "-special", IN_SpecialUp );
Cmd_AddCommand( "+zoom", IN_ZoomDown );
Cmd_AddCommand( "-zoom", IN_ZoomUp );
cl_ucmdMaxResend = Cvar_Get( "cl_ucmdMaxResend", "3", CVAR_ARCHIVE );
cl_ucmdFPS = Cvar_Get( "cl_ucmdFPS", "62", CVAR_DEVELOPER );
#ifdef UCMDTIMENUDGE
cl_ucmdTimeNudge = Cvar_Get( "cl_ucmdTimeNudge", "0", CVAR_USERINFO|CVAR_DEVELOPER );
if( abs( cl_ucmdTimeNudge->integer ) > MAX_UCMD_TIMENUDGE )
{
if( cl_ucmdTimeNudge->integer < -MAX_UCMD_TIMENUDGE )
Cvar_SetValue( "cl_ucmdTimeNudge", -MAX_UCMD_TIMENUDGE );
else if( cl_ucmdTimeNudge->integer > MAX_UCMD_TIMENUDGE )
Cvar_SetValue( "cl_ucmdTimeNudge", MAX_UCMD_TIMENUDGE );
}
#endif
in_initialized = true;
}
/*
===============
IN_Restart
===============
*/
void IN_Restart( void )
{
IN_ShutdownJoystick( );
IN_Init( SDL_window );
}