/* ================= Qcommon_Init ================= */ void Qcommon_Init (int argc, char **argv) { static const char *apVersion = APPLICATION " v" VERSION " " CPUSTRING " " __DATE__ " " BUILDSTRING; if (setjmp (abortframe) ) Sys_Error ("Error during initialization"); z_chain.next = z_chain.prev = &z_chain; // prepare enough of the subsystems to handle // cvar and command buffer management COM_InitArgv (argc, argv); Swap_Init (); Cbuf_Init (); Cmd_Init (); Cvar_Init (); Key_Init (); // we need to add the early commands twice, because // a basedir or cddir needs to be set before execing // config files, but we want other parms to override // the settings of the config files Cbuf_AddEarlyCommands (false); Cbuf_Execute(); FS_InitFilesystem (); Cbuf_AddText ("exec default.cfg\n"); Cbuf_Execute(); Cbuf_AddText ("exec aprconfig.cfg\n"); Cbuf_Execute(); FS_ExecConfig("autoexec.cfg"); Cbuf_Execute(); Cbuf_AddEarlyCommands (true); Cbuf_Execute(); Cmd_AddCommand ("echo", Cmd_Echo_f); // init commands and vars Cmd_AddCommand ("z_stats", Z_Stats_f); Cmd_AddCommand( "z_check", Z_Check ); host_speeds = Cvar_Get ("host_speeds", "0", 0); developer = Cvar_Get ("developer", "0", 0); timescale = Cvar_Get ("timescale", "1", CVAR_CHEAT); fixedtime = Cvar_Get ("fixedtime", "0", CVAR_CHEAT); logfile_active = Cvar_Get ("logfile", "0", 0); showtrace = Cvar_Get ("showtrace", "0", 0); #ifdef DEDICATED_ONLY dedicated = Cvar_Get ("dedicated", "1", CVAR_ROM); #else dedicated = Cvar_Get ("dedicated", "0", CVAR_NOSET); #endif timescale->OnChange = OnChange_Timescale; OnChange_Timescale(timescale, timescale->resetString); Cvar_Get ("version", apVersion, CVAR_SERVERINFO|CVAR_ROM); Cmd_AddMacro( "date", Com_Date_m ); Cmd_AddMacro( "time", Com_Time_m ); if (dedicated->integer) Cmd_AddCommand ("quit", Com_Quit); #ifndef NDEBUG Cmd_AddCommand( "error", Com_Error_f ); Cmd_AddCommand( "errordrop", Com_ErrorDrop_f ); Cmd_AddCommand( "freeze", Com_Freeze_f ); Cmd_AddCommand( "crash", Com_Crash_f ); #endif Sys_Init (); srand(Sys_Milliseconds()); NET_Init (); Netchan_Init (); SV_Init (); CL_Init (); ComInitialized = true; Cbuf_InsertFromDefer(); //Execute commands which was initialized after loading autoexec (ignore, highlight etc) FS_ExecConfig ("postinit.cfg"); Cbuf_Execute(); // add + commands from command line if (!Cbuf_AddLateCommands ()) { // if the user didn't give any commands, run default action if (!dedicated->integer) Cbuf_AddText ("toggleconsole\n"); else Cbuf_AddText ("dedicated_start\n"); Cbuf_Execute(); } else { // the user asked for something explicit // so drop the loading plaque SCR_EndLoadingPlaque(); } Com_Printf ("====== " APPLICATION " Initialized ======\n\n"); }
/** * @brief CM_TraceThroughPatchCollide * @param[in,out] tw * @param[in] pc */ void CM_TraceThroughPatchCollide(traceWork_t *tw, const struct patchCollide_s *pc) { unsigned int i; int j, hit, hitnum; float offset, enterFrac, leaveFrac, t; patchPlane_t *planes; facet_t *facet; float plane[4], bestplane[4] = { 0 }; vec3_t startp, endp; static cvar_t *cv; if (tw->isPoint) { CM_TracePointThroughPatchCollide(tw, pc); return; } #ifndef ADDBEVELS CM_TracePointThroughPatchCollide(tw, pc); return; #endif facet = pc->facets; for (i = 0 ; i < pc->numFacets ; i++, facet++) { enterFrac = -1.0; leaveFrac = 1.0; hitnum = -1; planes = &pc->planes[facet->surfacePlane]; VectorCopy(planes->plane, plane); plane[3] = planes->plane[3]; if (tw->sphere.use) { // adjust the plane distance apropriately for radius plane[3] += tw->sphere.radius; // find the closest point on the capsule to the plane t = DotProduct(plane, tw->sphere.offset); if (t > 0.0f) { VectorSubtract(tw->start, tw->sphere.offset, startp); VectorSubtract(tw->end, tw->sphere.offset, endp); } else { VectorAdd(tw->start, tw->sphere.offset, startp); VectorAdd(tw->end, tw->sphere.offset, endp); } } else { offset = DotProduct(tw->offsets[planes->signbits], plane); plane[3] -= offset; VectorCopy(tw->start, startp); VectorCopy(tw->end, endp); } if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) { continue; } if (hit) { Vector4Copy(plane, bestplane); } for (j = 0 ; j < facet->numBorders ; j++) { planes = &pc->planes[facet->borderPlanes[j]]; if (facet->borderInward[j]) { VectorNegate(planes->plane, plane); plane[3] = -planes->plane[3]; } else { VectorCopy(planes->plane, plane); plane[3] = planes->plane[3]; } if (tw->sphere.use) { // adjust the plane distance apropriately for radius plane[3] += tw->sphere.radius; // find the closest point on the capsule to the plane t = DotProduct(plane, tw->sphere.offset); if (t > 0.0f) { VectorSubtract(tw->start, tw->sphere.offset, startp); VectorSubtract(tw->end, tw->sphere.offset, endp); } else { VectorAdd(tw->start, tw->sphere.offset, startp); VectorAdd(tw->end, tw->sphere.offset, endp); } } else { // NOTE: this works even though the plane might be flipped because the bbox is centered offset = DotProduct(tw->offsets[planes->signbits], plane); plane[3] += Q_fabs(offset); VectorCopy(tw->start, startp); VectorCopy(tw->end, endp); } if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) { break; } if (hit) { hitnum = j; Vector4Copy(plane, bestplane); } } if (j < facet->numBorders) { continue; } // never clip against the back side if (hitnum == facet->numBorders - 1) { continue; } if (enterFrac < leaveFrac && enterFrac >= 0) { if (enterFrac < tw->trace.fraction) { if (enterFrac < 0) { enterFrac = 0; } if (!cv) { cv = Cvar_Get("r_debugSurfaceUpdate", "1", 0); } if (cv && cv->integer) { debugPatchCollide = pc; debugFacet = facet; } tw->trace.fraction = enterFrac; VectorCopy(bestplane, tw->trace.plane.normal); tw->trace.plane.dist = bestplane[3]; } } } }
/* * 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 = qtrue; }
/* ================ Sys_Init ================ */ void Sys_Init(void) { OSVERSIONINFO vinfo; #ifndef _WIN64 HMODULE module; BOOL (WINAPI * pSetProcessDEPPolicy)(DWORD); #endif cvar_t *var = NULL; // check windows version vinfo.dwOSVersionInfoSize = sizeof(vinfo); if (!GetVersionEx(&vinfo)) { Sys_Error("Couldn't get OS info"); } if (vinfo.dwPlatformId != VER_PLATFORM_WIN32_NT) { Sys_Error(PRODUCT " requires Windows NT"); } if (vinfo.dwMajorVersion < 5) { Sys_Error(PRODUCT " requires Windows 2000 or greater"); } if (!QueryPerformanceFrequency(&timer_freq)) Sys_Error("QueryPerformanceFrequency failed"); // basedir <path> // allows the game to run from outside the data tree sys_basedir = Cvar_Get("basedir", currentDirectory, CVAR_NOSET); sys_libdir = Cvar_Get("libdir", currentDirectory, CVAR_NOSET); // homedir <path> // specifies per-user writable directory for demos, screenshots, etc sys_homedir = Cvar_Get("homedir", "", CVAR_NOSET); sys_forcegamelib = Cvar_Get("sys_forcegamelib", "", CVAR_NOSET); #if USE_WINSVC Cmd_AddCommand("installservice", Sys_InstallService_f); Cmd_AddCommand("deleteservice", Sys_DeleteService_f); #endif #if USE_SYSCON houtput = GetStdHandle(STD_OUTPUT_HANDLE); #if USE_CLIENT sys_viewlog = Cvar_Get("sys_viewlog", "0", CVAR_NOSET); if (dedicated->integer || sys_viewlog->integer) #endif Sys_ConsoleInit(); #endif // USE_SYSCON #if USE_DBGHELP var = Cvar_Get("sys_disablecrashdump", "0", CVAR_NOSET); // install our exception filter if (!var->integer) { mainProcessThread = GetCurrentThread(); prevExceptionFilter = SetUnhandledExceptionFilter( Sys_ExceptionFilter); } #endif #ifndef _WIN64 module = GetModuleHandle("kernel32.dll"); if (module) { pSetProcessDEPPolicy = (PVOID)GetProcAddress(module, "SetProcessDEPPolicy"); if (pSetProcessDEPPolicy) { var = Cvar_Get("sys_disabledep", "0", CVAR_NOSET); // opt-in or opt-out for DEP if (!var->integer) { pSetProcessDEPPolicy( PROCESS_DEP_ENABLE | PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION); } else if (var->integer == 2) { pSetProcessDEPPolicy(0); } } } #endif }
/* ============ CL_InitInput ============ */ void CL_InitInput( void ) { 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_Button0Down); Cmd_AddCommand ("-attack", IN_Button0Up); Cmd_AddCommand ("+button0", IN_Button0Down); Cmd_AddCommand ("-button0", IN_Button0Up); Cmd_AddCommand ("+button1", IN_Button1Down); Cmd_AddCommand ("-button1", IN_Button1Up); Cmd_AddCommand ("+button2", IN_Button2Down); Cmd_AddCommand ("-button2", IN_Button2Up); Cmd_AddCommand ("+button3", IN_Button3Down); Cmd_AddCommand ("-button3", IN_Button3Up); Cmd_AddCommand ("+button4", IN_Button4Down); Cmd_AddCommand ("-button4", IN_Button4Up); Cmd_AddCommand ("+button5", IN_Button5Down); Cmd_AddCommand ("-button5", IN_Button5Up); Cmd_AddCommand ("+button6", IN_Button6Down); Cmd_AddCommand ("-button6", IN_Button6Up); Cmd_AddCommand ("+button7", IN_Button7Down); Cmd_AddCommand ("-button7", IN_Button7Up); Cmd_AddCommand ("+button8", IN_Button8Down); Cmd_AddCommand ("-button8", IN_Button8Up); Cmd_AddCommand ("+button9", IN_Button9Down); Cmd_AddCommand ("-button9", IN_Button9Up); Cmd_AddCommand ("+button10", IN_Button10Down); Cmd_AddCommand ("-button10", IN_Button10Up); Cmd_AddCommand ("+button11", IN_Button11Down); Cmd_AddCommand ("-button11", IN_Button11Up); Cmd_AddCommand ("+button12", IN_Button12Down); Cmd_AddCommand ("-button12", IN_Button12Up); Cmd_AddCommand ("+button13", IN_Button13Down); Cmd_AddCommand ("-button13", IN_Button13Up); Cmd_AddCommand ("+button14", IN_Button14Down); Cmd_AddCommand ("-button14", IN_Button14Up); Cmd_AddCommand ("+mlook", IN_MLookDown); Cmd_AddCommand ("-mlook", IN_MLookUp); cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0); cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0); }
/* ================ S_Init ================ */ qboolean S_Base_Init( soundInterface_t *si ) { qboolean r; if( !si ) { return qfalse; } #ifndef NO_DMAHD s_khz = Cvar_Get ("s_khz", "44", CVAR_ARCHIVE); #else s_khz = Cvar_Get ("s_khz", "22", CVAR_ARCHIVE); #endif s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE); s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE); s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT); s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT); s_dev = Cvar_Get ("s_dev", "", CVAR_ARCHIVE); s_alttabmute = Cvar_Get ("s_alttabmute", "1", CVAR_ARCHIVE); Cmd_AddCommand( "s_devlist", S_dmaHD_devlist ); r = SNDDMA_Init(); if ( r ) { s_soundStarted = 1; s_soundMuted = 1; // s_numSfx = 0; Com_Memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH); s_soundtime = 0; s_paintedtime = 0; S_Base_StopAllSounds( ); } else { return qfalse; } si->Shutdown = S_Base_Shutdown; si->StartSound = S_Base_StartSound; si->StartLocalSound = S_Base_StartLocalSound; si->StartBackgroundTrack = S_Base_StartBackgroundTrack; si->StopBackgroundTrack = S_Base_StopBackgroundTrack; si->RawSamples = S_Base_RawSamples; si->StopAllSounds = S_Base_StopAllSounds; si->ClearLoopingSounds = S_Base_ClearLoopingSounds; si->AddLoopingSound = S_Base_AddLoopingSound; si->AddRealLoopingSound = S_Base_AddRealLoopingSound; si->StopLoopingSound = S_Base_StopLoopingSound; si->Respatialize = S_Base_Respatialize; si->UpdateEntityPosition = S_Base_UpdateEntityPosition; si->Update = S_Base_Update; si->DisableSounds = S_Base_DisableSounds; si->BeginRegistration = S_Base_BeginRegistration; si->RegisterSound = S_Base_RegisterSound; si->ClearSoundBuffer = S_Base_ClearSoundBuffer; si->SoundInfo = S_Base_SoundInfo; si->SoundList = S_Base_SoundList; #ifndef NO_DMAHD if (dmaHD_Enabled()) return dmaHD_Init(si); #endif return qtrue; }
/* ================== CL_SystemInfoChanged The systeminfo configstring has been changed, so parse new information out of it. This will happen at every gamestate, and possibly during gameplay. ================== */ void CL_SystemInfoChanged( void ) { char *systemInfo; const char *s, *t; char key[BIG_INFO_KEY]; char value[BIG_INFO_VALUE]; qboolean gameSet; systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SYSTEMINFO ]; // NOTE TTimo: // when the serverId changes, any further messages we send to the server will use this new serverId // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=475 // in some cases, outdated cp commands might get sent with this news serverId cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) ); #ifdef USE_VOIP #ifdef LEGACY_PROTOCOL if(clc.compat) clc.voipEnabled = qfalse; else #endif { s = Info_ValueForKey( systemInfo, "sv_voip" ); clc.voipEnabled = atoi(s); } #endif // don't set any vars when playing a demo if ( clc.demoplaying ) { return; } s = Info_ValueForKey( systemInfo, "sv_cheats" ); cl_connectedToCheatServer = atoi( s ); if ( !cl_connectedToCheatServer ) { Cvar_SetCheatState(); } // check pure server string s = Info_ValueForKey( systemInfo, "sv_paks" ); t = Info_ValueForKey( systemInfo, "sv_pakNames" ); FS_PureServerSetLoadedPaks( s, t ); s = Info_ValueForKey( systemInfo, "sv_referencedPaks" ); t = Info_ValueForKey( systemInfo, "sv_referencedPakNames" ); FS_PureServerSetReferencedPaks( s, t ); gameSet = qfalse; // scan through all the variables in the systeminfo and locally set cvars to match s = systemInfo; while ( s ) { int cvar_flags; Info_NextPair( &s, key, value ); if ( !key[0] ) { break; } // ehw! if (!Q_stricmp(key, "fs_game")) { if(FS_CheckDirTraversal(value)) { Com_Printf(S_COLOR_YELLOW "WARNING: Server sent invalid fs_game value %s\n", value); continue; } gameSet = qtrue; } if((cvar_flags = Cvar_Flags(key)) == CVAR_NONEXISTENT) Cvar_Get(key, value, CVAR_SERVER_CREATED | CVAR_ROM); else { // If this cvar may not be modified by a server discard the value. // I have added exceptions for sv_fps, pmove_fixed and pmove_msec. These should relly be corrected in the game logic code, // but they are required for a lot of mods and not all can be changed. // vq3 uses pmove_fixed, pmove_msec and g_synchronousClients. Most unlagged mods uses sv_fps too. if(!(cvar_flags & (CVAR_SYSTEMINFO | CVAR_SERVER_CREATED)) && Q_stricmp(key, "sv_fps") && Q_stricmp(key, "pmove_fixed") &&\ Q_stricmp(key, "pmove_msec") && Q_stricmp(key, "g_synchronousClients")) { #ifndef STANDALONE if(Q_stricmp(key, "g_synchronousClients") && Q_stricmp(key, "pmove_fixed") && Q_stricmp(key, "pmove_msec")) #endif { Com_Printf(S_COLOR_YELLOW "WARNING: server is not allowed to set %s=%s\n", key, value); continue; } } Cvar_SetSafe(key, value); } } // if game folder should not be set and it is set at the client side if ( !gameSet && *Cvar_VariableString("fs_game") ) { Cvar_Set( "fs_game", "" ); } cl_connectedToPureServer = Cvar_VariableValue( "sv_pure" ); }
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? }
static void UI_Cvar_Create( const char *var_name, const char *var_value, int flags ) { Cvar_Get( var_name, var_value, flags ); }
/* * CL_SoundModule_Init */ void CL_SoundModule_Init( qboolean verbose ) { static const char *sound_modules[] = { "qf", "openal" }; static const int num_sound_modules = sizeof( sound_modules )/sizeof( sound_modules[0] ); sound_import_t import; if( !s_module ) s_module = Cvar_Get( "s_module", "1", CVAR_ARCHIVE|CVAR_LATCH_SOUND ); if( !s_module_fallback ) s_module_fallback = Cvar_Get( "s_module_fallback", "2", CVAR_LATCH_SOUND ); // unload anything we have now CL_SoundModule_Shutdown( verbose ); if( verbose ) Com_Printf( "------- sound initialization -------\n" ); Cvar_GetLatchedVars( CVAR_LATCH_SOUND ); if( s_module->integer < 0 || s_module->integer > num_sound_modules ) { Com_Printf( "Invalid value for s_module (%i), reseting to default\n", s_module->integer ); Cvar_ForceSet( "s_module", s_module->dvalue ); } if( s_module_fallback->integer < 0 || s_module_fallback->integer > num_sound_modules ) { Com_Printf( "Invalid value for s_module_fallback (%i), reseting to default\n", s_module_fallback->integer ); Cvar_ForceSet( "s_module_fallback", s_module_fallback->dvalue ); } if( !s_module->integer ) { if( verbose ) { Com_Printf( "Not loading a sound module\n" ); Com_Printf( "------------------------------------\n" ); } return; } cl_soundmodulepool = Mem_AllocPool( NULL, "Client Sound Module" ); import.Error = CL_SoundModule_Error; import.Print = CL_SoundModule_Print; import.Cvar_Get = Cvar_Get; import.Cvar_Set = Cvar_Set; import.Cvar_SetValue = Cvar_SetValue; import.Cvar_ForceSet = Cvar_ForceSet; import.Cvar_String = Cvar_String; import.Cvar_Value = Cvar_Value; import.Cmd_Argc = Cmd_Argc; import.Cmd_Argv = Cmd_Argv; import.Cmd_Args = Cmd_Args; import.Cmd_AddCommand = Cmd_AddCommand; import.Cmd_RemoveCommand = Cmd_RemoveCommand; import.Cmd_ExecuteText = Cbuf_ExecuteText; import.Cmd_Execute = Cbuf_Execute; import.Cmd_SetCompletionFunc = Cmd_SetCompletionFunc; import.FS_FOpenFile = FS_FOpenFile; import.FS_Read = FS_Read; import.FS_Write = FS_Write; import.FS_Print = FS_Print; import.FS_Tell = FS_Tell; import.FS_Seek = FS_Seek; import.FS_Eof = FS_Eof; import.FS_Flush = FS_Flush; import.FS_FCloseFile = FS_FCloseFile; import.FS_RemoveFile = FS_RemoveFile; import.FS_GetFileList = FS_GetFileList; import.FS_IsUrl = FS_IsUrl; import.Milliseconds = Sys_Milliseconds; import.PageInMemory = Com_PageInMemory; import.Mem_Alloc = CL_SoundModule_MemAlloc; import.Mem_Free = CL_SoundModule_MemFree; import.Mem_AllocPool = CL_SoundModule_MemAllocPool; import.Mem_FreePool = CL_SoundModule_MemFreePool; import.Mem_EmptyPool = CL_SoundModule_MemEmptyPool; import.GetEntitySpatilization = CL_GameModule_GetEntitySpatilization; import.LoadLibrary = Com_LoadLibrary; import.UnloadLibrary = Com_UnloadLibrary; if( !CL_SoundModule_Load( sound_modules[s_module->integer-1], &import, verbose ) ) { if( s_module->integer == s_module_fallback->integer || !CL_SoundModule_Load( sound_modules[s_module_fallback->integer-1], &import, verbose ) ) { if( verbose ) { Com_Printf( "Couldn't load a sound module\n" ); Com_Printf( "------------------------------------\n" ); } Mem_FreePool( &cl_soundmodulepool ); se = NULL; return; } Cvar_ForceSet( "s_module", va( "%i", s_module_fallback->integer ) ); } CL_SoundModule_SetAttenuationModel(); // check memory integrity Mem_CheckSentinelsGlobal(); if( verbose ) Com_Printf( "------------------------------------\n" ); }
/* * CL_Mumble_Init */ void CL_Mumble_Init( void ) { cl_mumble = Cvar_Get( "cl_mumble", "0", CVAR_ARCHIVE | CVAR_LATCH ); cl_mumble_scale = Cvar_Get( "cl_mumble_scale", "0.0254", CVAR_ARCHIVE ); }
/* =============== GLimp_SetMode =============== */ static int GLimp_SetMode(int mode, qboolean fullscreen, qboolean noborder) { const char *glstring; int perChannelColorBits; int colorBits, depthBits, stencilBits; int samples; int i = 0; SDL_Surface *icon = NULL; Uint32 flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL; SDL_DisplayMode desktopMode; int display = 0; int x = 0, y = 0; Com_Printf( "Initializing OpenGL display\n"); if ( r_allowResize->integer ) flags |= SDL_WINDOW_RESIZABLE; /*icon = SDL_CreateRGBSurfaceFrom( (void *)CLIENT_WINDOW_ICON.pixel_data, CLIENT_WINDOW_ICON.width, CLIENT_WINDOW_ICON.height, CLIENT_WINDOW_ICON.bytes_per_pixel * 8, CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width, #ifdef Q3_LITTLE_ENDIAN 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 #else 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF #endif );*/ // If a window exists, note its display index if( screen != NULL ) display = SDL_GetWindowDisplayIndex( screen ); if( SDL_GetDesktopDisplayMode( display, &desktopMode ) == 0 ) { displayAspect = (float)desktopMode.w / (float)desktopMode.h; Com_Printf( "Display aspect: %.3f\n", displayAspect ); } else { memset( &desktopMode, 0, sizeof( SDL_DisplayMode ) ); Com_Printf( "Cannot determine display aspect, assuming 1.333\n" ); } Com_Printf( "...setting mode %d:", mode ); if (mode == -2) { // use desktop video resolution if( desktopMode.h > 0 ) { glConfig.vidWidth = desktopMode.w; glConfig.vidHeight = desktopMode.h; } else { glConfig.vidWidth = 640; glConfig.vidHeight = 480; Com_Printf( "Cannot determine display resolution, assuming 640x480\n" ); } //glConfig.windowAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight; } else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.windowAspect,*/ mode ) ) { Com_Printf( " invalid mode\n" ); return RSERR_INVALID_MODE; } Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight); // Center window if( r_centerWindow->integer && !fullscreen ) { x = ( desktopMode.w / 2 ) - ( glConfig.vidWidth / 2 ); y = ( desktopMode.h / 2 ) - ( glConfig.vidHeight / 2 ); } // Destroy existing state if it exists if( opengl_context != NULL ) { SDL_GL_DeleteContext( opengl_context ); opengl_context = NULL; } if( screen != NULL ) { SDL_GetWindowPosition( screen, &x, &y ); Com_DPrintf( "Existing window at %dx%d before being destroyed\n", x, y ); SDL_DestroyWindow( screen ); screen = NULL; } if( fullscreen ) { flags |= SDL_WINDOW_FULLSCREEN; glConfig.isFullscreen = qtrue; } else { if( noborder ) flags |= SDL_WINDOW_BORDERLESS; glConfig.isFullscreen = qfalse; } colorBits = r_colorbits->value; if ((!colorBits) || (colorBits >= 32)) colorBits = 24; if (!r_depthbits->value) depthBits = 24; else depthBits = r_depthbits->value; stencilBits = r_stencilbits->value; //samples = r_ext_multisample->value; for (i = 0; i < 16; i++) { int testColorBits, testDepthBits, testStencilBits; // 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; } } testColorBits = colorBits; testDepthBits = depthBits; testStencilBits = stencilBits; if ((i % 4) == 3) { // reduce colorBits if (testColorBits == 24) testColorBits = 16; } if ((i % 4) == 2) { // reduce depthBits if (testDepthBits == 24) testDepthBits = 16; else if (testDepthBits == 16) testDepthBits = 8; } if ((i % 4) == 1) { // reduce stencilBits if (testStencilBits == 24) testStencilBits = 16; else if (testStencilBits == 16) testStencilBits = 8; else testStencilBits = 0; } if (testColorBits == 24) perChannelColorBits = 8; else perChannelColorBits = 4; #ifdef __sgi /* Fix for SGIs grabbing too many bits of color */ if (perChannelColorBits == 4) perChannelColorBits = 0; /* Use minimum size for 16-bit color */ /* Need alpha or else SGIs choose 36+ bit RGB mode */ SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1); #endif SDL_GL_SetAttribute( SDL_GL_RED_SIZE, perChannelColorBits ); SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, perChannelColorBits ); SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, perChannelColorBits ); SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, testDepthBits ); SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, testStencilBits ); /*SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, samples ? 1 : 0 ); SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples );*/ if(r_stereo->integer) { glConfig.stereoEnabled = qtrue; SDL_GL_SetAttribute(SDL_GL_STEREO, 1); } else { glConfig.stereoEnabled = qfalse; SDL_GL_SetAttribute(SDL_GL_STEREO, 0); } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // If not allowing software GL, demand accelerated if( !r_allowSoftwareGL->integer ) SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ); if( ( screen = SDL_CreateWindow( CLIENT_WINDOW_TITLE, x, y, glConfig.vidWidth, glConfig.vidHeight, flags ) ) == 0 ) { Com_DPrintf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) ); continue; } if( fullscreen ) { SDL_DisplayMode mode; switch( testColorBits ) { case 16: mode.format = SDL_PIXELFORMAT_RGB565; break; case 24: mode.format = SDL_PIXELFORMAT_RGB24; break; default: Com_DPrintf( "testColorBits is %d, can't fullscreen\n", testColorBits ); continue; } mode.w = glConfig.vidWidth; mode.h = glConfig.vidHeight; mode.refresh_rate = glConfig.displayFrequency = Cvar_VariableIntegerValue( "r_displayRefresh" ); mode.driverdata = NULL; if( SDL_SetWindowDisplayMode( screen, &mode ) < 0 ) { Com_DPrintf( "SDL_SetWindowDisplayMode failed: %s\n", SDL_GetError( ) ); continue; } } SDL_SetWindowTitle( screen, CLIENT_WINDOW_TITLE ); SDL_SetWindowIcon( screen, icon ); if( ( opengl_context = SDL_GL_CreateContext( screen ) ) == NULL ) { Com_Printf( "SDL_GL_CreateContext failed: %s\n", SDL_GetError( ) ); continue; } if( SDL_GL_MakeCurrent( screen, opengl_context ) < 0 ) { Com_Printf( "SDL_GL_MakeCurrent failed: %s\n", SDL_GetError( ) ); continue; } SDL_GL_SetSwapInterval( r_swapInterval->integer ); glConfig.colorBits = testColorBits; glConfig.depthBits = testDepthBits; glConfig.stencilBits = testStencilBits; Com_Printf( "Using %d color bits, %d depth, %d stencil display.\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits ); break; } /*SDL_FreeSurface( icon );*/ GLimp_DetectAvailableModes(); glstring = (char *) qglGetString (GL_RENDERER); Com_Printf( "GL_RENDERER: %s\n", glstring ); return RSERR_OK; #if 0 const char* glstring; int sdlcolorbits; int colorbits, depthbits, stencilbits; int tcolorbits, tdepthbits, tstencilbits; int samples; int i = 0; Uint32 flags = SDL_WINDOW_OPENGL; Com_Printf( "Initializing OpenGL display\n"); if ( r_allowResize->integer ) flags |= SDL_WINDOW_RESIZABLE; if( videoInfo == NULL ) { static SDL_DisplayMode sVideoInfo; static SDL_PixelFormat sPixelFormat; if (SDL_GetCurrentDisplayMode( 0, &sVideoInfo ) < 0) Com_Error(ERR_FATAL, "SDL_GetCurrentDisplayMode failed : %s\n", SDL_GetError()); // Take a copy of the videoInfo sPixelFormat.format = sVideoInfo.format; sPixelFormat.palette = NULL; // Should already be the case //Com_Memcpy( &sVideoInfo, videoInfo, sizeof( SDL_DisplayMode ) ); sVideoInfo.format = sPixelFormat.format; videoInfo = &sVideoInfo; if( videoInfo->h > 0 ) { glConfig.displayWidth = videoInfo->w; glConfig.displayHeight = videoInfo->h; // Guess the display aspect ratio through the desktop resolution // by assuming (relatively safely) that it is set at or close to // the display's native aspect ratio glConfig.displayAspect = (float)videoInfo->w / (float)videoInfo->h; Com_Printf( "Estimated display aspect: %.3f\n", glConfig.displayAspect ); } else { glConfig.displayWidth = 480; glConfig.displayHeight = 640; glConfig.displayAspect = 1.333f; Com_Printf( "Cannot estimate display resolution/aspect, assuming 640x480/1.333\n" ); } } Com_Printf( "...setting mode %d:", mode ); if (mode == -2) { // use desktop video resolution if( videoInfo->h > 0 ) { glConfig.vidWidth = videoInfo->w; glConfig.vidHeight = videoInfo->h; } else { glConfig.vidWidth = 640; glConfig.vidHeight = 480; Com_Printf( "Cannot determine display resolution, assuming 640x480\n" ); } glConfig.displayAspect = (float)glConfig.vidWidth / (float)glConfig.vidHeight; } else if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, /*&glConfig.displayAspect,*/ mode ) ) { Com_Printf( " invalid mode\n" ); return RSERR_INVALID_MODE; } Com_Printf( " %d %d\n", glConfig.vidWidth, glConfig.vidHeight); if (fullscreen) { flags |= SDL_WINDOW_FULLSCREEN; glConfig.isFullscreen = qtrue; } else { if (noborder) flags |= SDL_WINDOW_BORDERLESS; glConfig.isFullscreen = qfalse; } colorbits = r_colorbits->value; if ((!colorbits) || (colorbits >= 32)) colorbits = 24; if (!r_depthbits->value) depthbits = 24; else depthbits = r_depthbits->value; stencilbits = r_stencilbits->value; //samples = r_ext_multisample->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; #ifdef __sgi /* Fix for SGIs grabbing too many bits of color */ if (sdlcolorbits == 4) sdlcolorbits = 0; /* Use minimum size for 16-bit color */ /* Need alpha or else SGIs choose 36+ bit RGB mode */ SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 1); #endif 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_MULTISAMPLEBUFFERS, samples ? 1 : 0 ); SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, samples ); /*if(r_stereoEnabled->integer) { glConfig.stereoEnabled = qtrue; SDL_GL_SetAttribute(SDL_GL_STEREO, 1); } else {*/ glConfig.stereoEnabled = qfalse; SDL_GL_SetAttribute(SDL_GL_STEREO, 0); //} SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); #if 0 // See http://bugzilla.icculus.org/show_bug.cgi?id=3526 // If not allowing software GL, demand accelerated if( !r_allowSoftwareGL->integer ) { if( SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ) < 0 ) { Com_Printf( "Unable to guarantee accelerated " "visual with libSDL < 1.2.10\n" ); } } #endif if( SDL_GL_SetSwapInterval(r_swapInterval->integer ) < 0 ) Com_Printf( "SDL_GL_SetSwapInterval not supported\n" ); #ifdef USE_ICON { SDL_Surface *icon = SDL_CreateRGBSurfaceFrom( (void *)CLIENT_WINDOW_ICON.pixel_data, CLIENT_WINDOW_ICON.width, CLIENT_WINDOW_ICON.height, CLIENT_WINDOW_ICON.bytes_per_pixel * 8, CLIENT_WINDOW_ICON.bytes_per_pixel * CLIENT_WINDOW_ICON.width, #ifdef Q3_LITTLE_ENDIAN 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 #else 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF #endif ); SDL_WM_SetIcon( icon, NULL ); SDL_FreeSurface( icon ); } #endif // FIXME: Product name cvar_t *com_productName = Cvar_Get("com_productName", "OpenJK" /* PRODUCT_NAME */, CVAR_ROM); //SDL_SetWindowTitle(com_productName->string, com_productName->string); SDL_ShowCursor(0); if (!(window = SDL_CreateWindow(com_productName->string, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, glConfig.vidWidth, glConfig.vidHeight, flags))) { Com_Printf( "SDL_CreateWindow failed: %s\n", SDL_GetError( ) ); continue; } opengl_context = SDL_GL_CreateContext(window); Com_Printf( "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; } GLimp_DetectAvailableModes(); if (!window) { Com_Printf( "Couldn't get a visual\n" ); return RSERR_INVALID_MODE; } screen = window; // FIXME: Defines needed here glstring = (char *) qglGetString (GL_RENDERER); Com_Printf( "GL_RENDERER: %s\n", glstring ); return RSERR_OK; #endif }
void GLimp_Init( void ) { Cvar_Get( "r_restartOnResize", "1", CVAR_ARCHIVE ); Cvar_Get( "r_resizeDelay", "1000", CVAR_ARCHIVE ); r_allowSoftwareGL = Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH ); r_sdlDriver = Cvar_Get( "r_sdlDriver", "", CVAR_ROM ); r_allowResize = Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE ); r_centerWindow = Cvar_Get( "r_centerWindow", "0", CVAR_ARCHIVE ); r_noborder = Cvar_Get( "r_noborder", "0", CVAR_ARCHIVE ); /* if( Cvar_VariableIntegerValue( "com_abnormalExit" ) ) { Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) ); Cvar_Set( "r_picmap", "1" ); Cvar_Set( "r_texturebits", "0" ); Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" ); Cvar_Set( "r_fullscreen", "0" ); Cvar_Set( "r_centerWindow", "0" ); Cvar_Set( "com_abnormalExit", "0" ); }*/ Sys_SetEnv( "SDL_VIDEO_CENTERED", r_centerWindow->integer ? "1" : "" ); // 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 ) { Com_Printf( "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 Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" ); success: // This values force the UI to disable driver selection // glConfig.driverType = GLDRV_ICD; // glConfig.hardwareType = GLHW_GENERIC; glConfig.deviceSupportsGamma = (qboolean)(SDL_SetGamma( screen, 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 = (qboolean)(SDL_SetGamma( screen, 1.0f, 1.0f, 1.0f ) >= 0); if ( -1 == r_ignorehwgamma->integer) glConfig.deviceSupportsGamma = 1; if ( 1 == r_ignorehwgamma->integer) glConfig.deviceSupportsGamma = 0; // 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); // 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; } // initialize extensions GLimp_InitExtensions( ); Cvar_Get( "r_availableModes", "", CVAR_ROM ); // This depends on SDL_INIT_VIDEO, hence having it here IN_Init( screen ); }
qboolean SNDDMA_Init(void) { int rc; int fmt; int tmp; int i; // char *s; // bk001204 - unused struct audio_buf_info info; int caps; if (snd_inited) return 1; if (!snddevice) { sndbits = Cvar_Get("sndbits", "16", CVAR_ARCHIVE); sndspeed = Cvar_Get("sndspeed", "0", CVAR_ARCHIVE); sndchannels = Cvar_Get("sndchannels", "2", CVAR_ARCHIVE); snddevice = Cvar_Get("snddevice", "/dev/dsp", CVAR_ARCHIVE); } // open /dev/dsp, confirm capability to mmap, and get size of dma buffer if (!audio_fd) { audio_fd = open(snddevice->string, O_RDWR); if (audio_fd < 0) { perror(snddevice->string); Com_Printf("Could not open %s\n", snddevice->string); return 0; } } if (ioctl(audio_fd, SNDCTL_DSP_GETCAPS, &caps) == -1) { perror(snddevice->string); Com_Printf("Sound driver too old\n"); close(audio_fd); return 0; } if (!(caps & DSP_CAP_TRIGGER) || !(caps & DSP_CAP_MMAP)) { Com_Printf("Sorry but your soundcard can't do this\n"); close(audio_fd); return 0; } /* SNDCTL_DSP_GETOSPACE moved to be called later */ // set sample bits & speed dma.samplebits = (int)sndbits->value; if (dma.samplebits != 16 && dma.samplebits != 8) { ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &fmt); if (fmt & AFMT_S16_LE) dma.samplebits = 16; else if (fmt & AFMT_U8) dma.samplebits = 8; } dma.speed = (int)sndspeed->value; if (!dma.speed) { for (i=0 ; i<sizeof(tryrates)/4 ; i++) if (!ioctl(audio_fd, SNDCTL_DSP_SPEED, &tryrates[i])) break; dma.speed = tryrates[i]; } dma.channels = (int)sndchannels->value; if (dma.channels < 1 || dma.channels > 2) dma.channels = 2; /* mmap() call moved forward */ tmp = 0; if (dma.channels == 2) tmp = 1; rc = ioctl(audio_fd, SNDCTL_DSP_STEREO, &tmp); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not set %s to stereo=%d", snddevice->string, dma.channels); close(audio_fd); return 0; } if (tmp) dma.channels = 2; else dma.channels = 1; rc = ioctl(audio_fd, SNDCTL_DSP_SPEED, &dma.speed); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not set %s speed to %d", snddevice->string, dma.speed); close(audio_fd); return 0; } if (dma.samplebits == 16) { rc = AFMT_S16_LE; rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not support 16-bit data. Try 8-bit.\n"); close(audio_fd); return 0; } } else if (dma.samplebits == 8) { rc = AFMT_U8; rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not support 8-bit data.\n"); close(audio_fd); return 0; } } else { perror(snddevice->string); Com_Printf("%d-bit sound not supported.", dma.samplebits); close(audio_fd); return 0; } if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info)==-1) { perror("GETOSPACE"); Com_Printf("Um, can't do GETOSPACE?\n"); close(audio_fd); return 0; } dma.samples = info.fragstotal * info.fragsize / (dma.samplebits/8); dma.submission_chunk = 1; // memory map the dma buffer // TTimo 2001/10/08 added PROT_READ to the mmap // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=371 // checking Alsa bug, doesn't allow dma alloc with PROT_READ? if (!dma.buffer) dma.buffer = (unsigned char *) mmap(NULL, info.fragstotal * info.fragsize, PROT_WRITE|PROT_READ, MAP_FILE|MAP_SHARED, audio_fd, 0); if (dma.buffer == MAP_FAILED) { Com_Printf("Could not mmap dma buffer PROT_WRITE|PROT_READ\n"); Com_Printf("trying mmap PROT_WRITE (with associated better compatibility / less performance code)\n"); dma.buffer = (unsigned char *) mmap(NULL, info.fragstotal * info.fragsize, PROT_WRITE, MAP_FILE|MAP_SHARED, audio_fd, 0); // NOTE TTimo could add a variable to force using regular memset on systems that are known to be safe use_custom_memset = qtrue; } if (dma.buffer == MAP_FAILED) { perror(snddevice->string); Com_Printf("Could not mmap %s\n", snddevice->string); close(audio_fd); return 0; } // toggle the trigger & start her up tmp = 0; rc = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not toggle.\n"); close(audio_fd); return 0; } tmp = PCM_ENABLE_OUTPUT; rc = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp); if (rc < 0) { perror(snddevice->string); Com_Printf("Could not toggle.\n"); close(audio_fd); return 0; } snd_inited = 1; return 1; }
/* =============== IN_InitJoystick =============== */ static void IN_InitJoystick( void ) { int i = 0; int total = 0; char buf[16384] = ""; if (stick != NULL) SDL_JoystickClose(stick); stick = NULL; memset(&stick_state, '\0', sizeof (stick_state)); if (!SDL_WasInit(SDL_INIT_JOYSTICK)) { Com_DPrintf("Calling SDL_Init(SDL_INIT_JOYSTICK)...\n"); if (SDL_Init(SDL_INIT_JOYSTICK) == -1) { Com_DPrintf("SDL_Init(SDL_INIT_JOYSTICK) failed: %s\n", SDL_GetError()); return; } Com_DPrintf("SDL_Init(SDL_INIT_JOYSTICK) passed.\n"); } total = SDL_NumJoysticks(); Com_DPrintf("%d possible joysticks\n", total); // Print list and build cvar to allow ui to select joystick. for (i = 0; i < total; i++) { Q_strcat(buf, sizeof(buf), SDL_JoystickNameForIndex(i)); Q_strcat(buf, sizeof(buf), "\n"); } Cvar_Get( "in_availableJoysticks", buf, CVAR_ROM ); if( !in_joystick->integer ) { Com_DPrintf( "Joystick is not active.\n" ); SDL_QuitSubSystem(SDL_INIT_JOYSTICK); return; } in_joystickNo = Cvar_Get( "in_joystickNo", "0", CVAR_ARCHIVE ); if( in_joystickNo->integer < 0 || in_joystickNo->integer >= total ) Cvar_Set( "in_joystickNo", "0" ); in_joystickUseAnalog = Cvar_Get( "in_joystickUseAnalog", "0", CVAR_ARCHIVE ); in_joystickThreshold = Cvar_Get( "joy_threshold", "0.15", CVAR_ARCHIVE ); stick = SDL_JoystickOpen( in_joystickNo->integer ); if (stick == NULL) { Com_DPrintf( "No joystick opened.\n" ); return; } Com_DPrintf( "Joystick %d opened\n", in_joystickNo->integer ); Com_DPrintf( "Name: %s\n", SDL_JoystickNameForIndex(in_joystickNo->integer) ); Com_DPrintf( "Axes: %d\n", SDL_JoystickNumAxes(stick) ); Com_DPrintf( "Hats: %d\n", SDL_JoystickNumHats(stick) ); Com_DPrintf( "Buttons: %d\n", SDL_JoystickNumButtons(stick) ); Com_DPrintf( "Balls: %d\n", SDL_JoystickNumBalls(stick) ); Com_DPrintf( "Use Analog: %s\n", in_joystickUseAnalog->integer ? "Yes" : "No" ); Com_DPrintf( "Threshold: %f\n", in_joystickThreshold->value ); SDL_JoystickEventState(SDL_QUERY); }
/* ============ Cvar_Set2 ============ */ cvar_t *Cvar_Set2( const char *var_name, const char *value, uint32_t defaultFlags, qboolean force ) { cvar_t *var; if ( !Cvar_ValidateString( var_name ) ) { Com_Printf("invalid cvar name string: %s\n", var_name ); var_name = "BADNAME"; } #if 0 // FIXME if ( value && !Cvar_ValidateString( value ) ) { Com_Printf("invalid cvar value string: %s\n", value ); var_value = "BADVALUE"; } #endif var = Cvar_FindVar (var_name); if (!var) { if ( !value ) { return NULL; } // create it return Cvar_Get( var_name, value, defaultFlags ); } if (!value ) { value = var->resetString; } value = Cvar_Validate(var, value, qtrue); if((var->flags & CVAR_LATCH) && var->latchedString) { if(!strcmp(value, var->string)) { Cvar_FreeString(var->latchedString); var->latchedString = NULL; return var; } if(!strcmp(value, var->latchedString)) return var; } else if(!strcmp(value, var->string)) return var; // note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo) cvar_modifiedFlags |= var->flags; if (!force) { if ( (var->flags & (CVAR_SYSTEMINFO|CVAR_SERVER_CREATED)) && com_sv_running && !com_sv_running->integer && CL_ConnectedToServer() ) { Com_Printf ("%s can only be set by server.\n", var_name); return var; } if (var->flags & CVAR_ROM) { Com_Printf ("%s is read only.\n", var_name); return var; } if (var->flags & CVAR_INIT) { Com_Printf ("%s is write protected.\n", var_name); return var; } if (var->flags & CVAR_LATCH) { if (var->latchedString) { if (strcmp(value, var->latchedString) == 0) return var; Cvar_FreeString (var->latchedString); } else { if (strcmp(value, var->string) == 0) return var; } Com_Printf ("%s will be changed upon restarting.\n", var_name); var->latchedString = CopyString(value); var->modified = qtrue; var->modificationCount++; return var; } if ( (var->flags & CVAR_CHEAT) && !cvar_cheats->integer ) { Com_Printf ("%s is cheat protected.\n", var_name); return var; } } else { if (var->latchedString) { Cvar_FreeString (var->latchedString); var->latchedString = NULL; } } if (!strcmp(value, var->string)) return var; // not changed var->modified = qtrue; var->modificationCount++; Cvar_FreeString (var->string); // free the old value string var->string = CopyString(value); var->value = atof (var->string); var->integer = atoi (var->string); return var; }
/* ============ Cvar_Set2 ============ */ cvar_t *Cvar_Set2( const char *var_name, const char *value, qboolean force ) { cvar_t *var; if ( !Cvar_ValidateString( var_name ) ) { Com_Printf("invalid cvar name string: %s\n", var_name ); var_name = "BADNAME"; } #if 0 // FIXME if ( value && !Cvar_ValidateString( value ) ) { Com_Printf("invalid cvar value string: %s\n", value ); var_value = "BADVALUE"; } #endif var = Cvar_FindVar (var_name); if (!var) { if ( !value ) { return NULL; } // create it if ( !force ) { return Cvar_Get( var_name, value, CVAR_USER_CREATED ); } else { return Cvar_Get (var_name, value, 0); } } // Dont display the update when its internal if ( !(var->flags & CVAR_INTERNAL) ) { Com_DPrintf( "Cvar_Set2: %s %s\n", var_name, value ); } if (!value ) { value = var->resetString; } if (!strcmp(value,var->string)) { return var; } // note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo) cvar_modifiedFlags |= var->flags; if (!force) { if (var->flags & CVAR_ROM) { Com_Printf ("%s is read only.\n", var_name); return var; } if (var->flags & CVAR_INIT) { Com_Printf ("%s is write protected.\n", var_name); return var; } if (var->flags & CVAR_LATCH) { if (var->latchedString) { if (strcmp(value, var->latchedString) == 0) return var; Z_Free (var->latchedString); } else { if (strcmp(value, var->string) == 0) return var; } Com_Printf ("%s will be changed upon restarting.\n", var_name); var->latchedString = CopyString(value); var->modified = qtrue; var->modificationCount++; return var; } if ( (var->flags & CVAR_CHEAT) && !cvar_cheats->integer ) { Com_Printf ("%s is cheat protected.\n", var_name); return var; } } else { if (var->latchedString) { Z_Free (var->latchedString); var->latchedString = NULL; } } if (!strcmp(value, var->string)) return var; // not changed var->modified = qtrue; var->modificationCount++; Z_Free (var->string); // free the old value string var->string = CopyString(value); var->value = atof (var->string); var->integer = atoi (var->string); return var; }
/* =============== Netchan_Init =============== */ void Netchan_Init( int port ) { port &= 0xffff; showpackets = Cvar_Get ("showpackets", "0", CVAR_TEMP ); showdrop = Cvar_Get ("showdrop", "0", CVAR_TEMP ); qport = Cvar_Get ("net_qport", va("%i", port), CVAR_INIT ); }
/* =============== SNDDMA_Init =============== */ qboolean SNDDMA_Init(void) { SDL_AudioSpec desired; SDL_AudioSpec obtained; const char *driver_name; const char *device_name; int tmp; if (snd_inited) { return qtrue; } Cmd_AddCommand("sndlist", SND_DeviceList); // before rc 2 we have had own s_sdl_ cvars to set this // changed back to use genuine cvar names // - it's more compatible when existing profiles are used // - we don't have to touch menu & ui to make speed/khz work (uses s_khz!) s_bits = Cvar_Get("s_bits", "16", CVAR_LATCH | CVAR_ARCHIVE); s_khz = Cvar_Get("s_khz", "44", CVAR_LATCH | CVAR_ARCHIVE); s_sdlChannels = Cvar_Get("s_channels", "2", CVAR_LATCH | CVAR_ARCHIVE); s_sdlDevSamps = Cvar_Get("s_sdlDevSamps", "0", CVAR_LATCH | CVAR_ARCHIVE); s_sdlMixSamps = Cvar_Get("s_sdlMixSamps", "0", CVAR_LATCH | CVAR_ARCHIVE); s_device = Cvar_Get("s_device", "-1", CVAR_LATCH | CVAR_ARCHIVE); Com_Printf("SDL_Init( SDL_INIT_AUDIO )... "); if (!SDL_WasInit(SDL_INIT_AUDIO)) { if (SDL_Init(SDL_INIT_AUDIO) < 0) { Com_Printf("FAILED (%s)\n", SDL_GetError()); return qfalse; } } Com_Printf("OK\n"); driver_name = SDL_GetCurrentAudioDriver(); if (driver_name) { Com_Printf("SDL audio driver is \"%s\".\n", driver_name); } else { Com_Printf("SDL audio driver isn't initialized.\n"); } memset(&desired, '\0', sizeof(desired)); memset(&obtained, '\0', sizeof(obtained)); tmp = ((int) s_bits->value); if ((tmp != 16) && (tmp != 8)) { tmp = 16; } desired.freq = (int) s_khz->value * 1000; // desired freq expects Hz not kHz if (!desired.freq) { desired.freq = 22050; } // dirty correction for profile values if (desired.freq == 11000) { desired.freq = 11025; } else if (desired.freq == 22000) { desired.freq = 22050; } else if (desired.freq == 44000) { desired.freq = 44100; } else { desired.freq = 22050; } desired.format = ((tmp == 16) ? AUDIO_S16SYS : AUDIO_U8); // I dunno if this is the best idea, but I'll give it a try... // should probably check a cvar for this... if (s_sdlDevSamps->value) { desired.samples = s_sdlDevSamps->value; } else { // just pick a sane default. if (desired.freq <= 11025) { desired.samples = 256; } else if (desired.freq <= 22050) { desired.samples = 512; } else if (desired.freq <= 44100) { desired.samples = 1024; } else { desired.samples = 2048; // (*shrug*) } } desired.channels = (int) s_sdlChannels->value; desired.callback = SNDDMA_AudioCallback; if (s_device->integer >= 0 && s_device->integer < SDL_GetNumAudioDevices(qfalse)) { device_name = SDL_GetAudioDeviceName(s_device->integer, 0); Com_Printf("Acquiring audio device: %s\n", device_name); } else { device_name = NULL; //Reset the cvar just in case Cvar_Set("s_device", "-1"); } device_id = SDL_OpenAudioDevice(device_name, qfalse, &desired, &obtained, SDL_AUDIO_ALLOW_FORMAT_CHANGE); if(device_id == 0) { Com_Printf("SDL_OpenAudioDevice() failed: %s\n", SDL_GetError()); SDL_QuitSubSystem(SDL_INIT_AUDIO); return qfalse; } SNDDMA_PrintAudiospec("SDL_AudioSpec", &obtained); // dma.samples needs to be big, or id's mixer will just refuse to // work at all; we need to keep it significantly bigger than the // amount of SDL callback samples, and just copy a little each time // the callback runs. // 32768 is what the OSS driver filled in here on my system. I don't // know if it's a good value overall, but at least we know it's // reasonable...this is why I let the user override. tmp = s_sdlMixSamps->value; if (!tmp) { tmp = (obtained.samples * obtained.channels) * 10; } if (tmp & (tmp - 1)) // not a power of two? Seems to confuse something. { int val = 1; while (val < tmp) val <<= 1; tmp = val; } dmapos = 0; dma.samplebits = obtained.format & 0xFF; // first byte of format is bits. dma.channels = obtained.channels; dma.samples = tmp; dma.submission_chunk = 1; dma.speed = obtained.freq; dmasize = (dma.samples * (dma.samplebits / 8)); dma.buffer = calloc(1, dmasize); if (!dma.buffer) { Com_Printf("Unable to allocate dma buffer\n"); SDL_QuitSubSystem(SDL_INIT_AUDIO); return qfalse; } Com_Printf("Starting SDL audio callback...\n"); SDL_PauseAudioDevice(device_id, 0); // start callback. Com_Printf("SDL audio initialized.\n"); snd_inited = qtrue; return qtrue; }
/* =============== SV_Init Only called at main exe startup, not for each game =============== */ void SV_Init(void) { int index; SV_AddOperatorCommands(); // serverinfo vars Cvar_Get("dmflags", "0", CVAR_SERVERINFO); Cvar_Get("fraglimit", "20", CVAR_SERVERINFO); Cvar_Get("timelimit", "0", CVAR_SERVERINFO); sv_gametype = Cvar_Get("g_gametype", "0", CVAR_SERVERINFO | CVAR_LATCH); Cvar_Get("sv_keywords", "", CVAR_SERVERINFO); sv_mapname = Cvar_Get("mapname", "nomap", CVAR_SERVERINFO | CVAR_ROM); sv_privateClients = Cvar_Get("sv_privateClients", "0", CVAR_SERVERINFO); sv_hostname = Cvar_Get("sv_hostname", "noname", CVAR_SERVERINFO | CVAR_ARCHIVE); sv_maxclients = Cvar_Get("sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH); sv_minRate = Cvar_Get("sv_minRate", "0", CVAR_ARCHIVE | CVAR_SERVERINFO); sv_maxRate = Cvar_Get("sv_maxRate", "0", CVAR_ARCHIVE | CVAR_SERVERINFO); sv_dlRate = Cvar_Get("sv_dlRate", "100", CVAR_ARCHIVE | CVAR_SERVERINFO); sv_minPing = Cvar_Get("sv_minPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO); sv_maxPing = Cvar_Get("sv_maxPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO); sv_floodProtect = Cvar_Get("sv_floodProtect", "1", CVAR_ARCHIVE | CVAR_SERVERINFO); // systeminfo Cvar_Get("sv_cheats", "1", CVAR_SYSTEMINFO | CVAR_ROM); sv_serverid = Cvar_Get("sv_serverid", "0", CVAR_SYSTEMINFO | CVAR_ROM); sv_pure = Cvar_Get("sv_pure", "1", CVAR_SYSTEMINFO); #ifdef USE_VOIP sv_voip = Cvar_Get("sv_voip", "1", CVAR_SYSTEMINFO | CVAR_LATCH); Cvar_CheckRange(sv_voip, 0, 1, qtrue); #endif Cvar_Get("sv_paks", "", CVAR_SYSTEMINFO | CVAR_ROM); Cvar_Get("sv_pakNames", "", CVAR_SYSTEMINFO | CVAR_ROM); Cvar_Get("sv_referencedPaks", "", CVAR_SYSTEMINFO | CVAR_ROM); Cvar_Get("sv_referencedPakNames", "", CVAR_SYSTEMINFO | CVAR_ROM); // server vars sv_rconPassword = Cvar_Get("rconPassword", "", CVAR_TEMP); sv_privatePassword = Cvar_Get("sv_privatePassword", "", CVAR_TEMP); sv_fps = Cvar_Get("sv_fps", "20", CVAR_TEMP); sv_timeout = Cvar_Get("sv_timeout", "200", CVAR_TEMP); sv_zombietime = Cvar_Get("sv_zombietime", "2", CVAR_TEMP); Cvar_Get("nextmap", "", CVAR_TEMP); sv_allowDownload = Cvar_Get("sv_allowDownload", "0", CVAR_SERVERINFO); Cvar_Get("sv_dlURL", "", CVAR_SERVERINFO | CVAR_ARCHIVE); sv_master[0] = Cvar_Get("sv_master1", MASTER_SERVER_NAME, 0); sv_master[1] = Cvar_Get("sv_master2", "master.ioquake3.org", 0); for (index = 2; index < MAX_MASTER_SERVERS; index++) sv_master[index] = Cvar_Get(va("sv_master%d", index + 1), "", CVAR_ARCHIVE); sv_reconnectlimit = Cvar_Get("sv_reconnectlimit", "3", 0); sv_showloss = Cvar_Get("sv_showloss", "0", 0); sv_padPackets = Cvar_Get("sv_padPackets", "0", 0); sv_killserver = Cvar_Get("sv_killserver", "0", 0); sv_mapChecksum = Cvar_Get("sv_mapChecksum", "", CVAR_ROM); sv_lanForceRate = Cvar_Get("sv_lanForceRate", "1", CVAR_ARCHIVE); #ifndef STANDALONE sv_strictAuth = Cvar_Get("sv_strictAuth", "1", CVAR_ARCHIVE); #endif sv_banFile = Cvar_Get("sv_banFile", "serverbans.dat", CVAR_ARCHIVE); // initialize bot cvars so they are listed and can be set before loading the botlib SV_BotInitCvars(); // init the botlib here because we need the pre-compiler in the UI SV_BotInitBotLib(); // Load saved bans Cbuf_AddText("rehashbans\n"); }
/* ============ Cvar_Set2 ============ */ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force) { cvar_t *var; var = Cvar_FindVar (var_name); if (!var) { // create it return Cvar_Get (var_name, value, 0); } if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO)) { if (!Cvar_InfoValidate (value)) { Com_Printf("invalid info cvar value\n"); return var; } } if (!force) { if (var->flags & CVAR_NOSET) { Com_Printf ("%s is write protected.\n", var_name); return var; } if (var->flags & CVAR_LATCH) { if (var->latched_string) { if (strcmp(value, var->latched_string) == 0) return var; Z_Free (var->latched_string); } else { if (strcmp(value, var->string) == 0) return var; } if (Com_ServerState()) { Com_Printf ("%s will be changed for next game.\n", var_name); var->latched_string = CopyString(value); } else { var->string = CopyString(value); var->value = atof (var->string); if (!strcmp(var->name, "game")) { FS_SetGamedir (var->string); FS_ExecAutoexec (); } } return var; } } else { if (var->latched_string) { Z_Free (var->latched_string); var->latched_string = NULL; } } if (!strcmp(value, var->string)) return var; // not changed var->modified = true; if (var->flags & CVAR_USERINFO) userinfo_modified = true; // transmit at next oportunity Z_Free (var->string); // free the old value string var->string = CopyString(value); var->value = atof (var->string); return var; }
void GLimp_SetGamma(float gamma) { #if FIND_GAMMA EXEC_ONCE(appWPrintf("Find gamma mode!\n")); float a, b; // y = ax + b a = Cvar_Get("a","1")->value; # if !FIND_GAMMA2 b = Cvar_Get("b","0.5")->value; # else b = Cvar_Get("b","-0.5")->value; # endif #endif if (!gammaStored) return; gamma = bound(gamma, 0.5, 3); float contr = bound(r_contrast->value, 0.1, 2); float bright = bound(r_brightness->value, 0.1, 2); float invGamma = 1.0f / gamma; float overbright = gl_config.overbright + 1; for (int i = 0; i < 256; i++) { #if 0 float tmp = (i / 255.0f * overbright - 0.5f) * contr + 0.5f; if (tmp < 0) tmp = 0; // without this, can get semi-negative picture when r_gamma=0.5 (invGamma=2, sqr func) int v = appRound(65535.0f * (pow(tmp, invGamma) + bright - 1)); #else // taken from UT2003 // note: ut_br = br-0.5, ut_contr = contr-0.5 (replace later: norm. bright=0.5, contr=0.5) !! float tmp = pow(i * overbright / 255.0f, invGamma) * contr * 65535; tmp = tmp + (bright - 1) * 32768 - (contr - 0.5) * 32768 + 16384; int v = appRound(tmp); #endif if (GIsWin2K) { // Win2K/XP performs checking of gamma ramp and may reject it #if !FIND_GAMMA // clamp gamma curve with line 'y=x*GAMMA_ANGLE+GAMMA_OFFSET' #define GAMMA_ANGLE 1 #define GAMMA_OFFSET 0.5 int m = i * (GAMMA_ANGLE*256) + (int)(GAMMA_OFFSET*65536); if (v > m) v = m; #define GAMMA_ANGLE2 1 #define GAMMA_OFFSET2 -0.5 m = i * (GAMMA_ANGLE2*256) + (int)(GAMMA_OFFSET2*65536); if (v < m) v = m; #else // FIND_GAMMA # if !FIND_GAMMA2 int m = appRound(i * a * 256 + b * 65535); if (v > m) v = m; # else int m = appRound(i * a * 256 + b * 65535); if (v < m) v = m; # endif #endif // FIND_GAMMA } v = bound(v, 0, 65535); newGamma[i] = newGamma[i+256] = newGamma[i+512] = v; } gammaValid = true; UpdateGamma(); }
void SV_Init (void) { SV_AddOperatorCommands (); // serverinfo vars Cvar_Get ("dmflags", "0", CVAR_SERVERINFO); Cvar_Get ("fraglimit", "20", CVAR_SERVERINFO); Cvar_Get ("timelimit", "0", CVAR_SERVERINFO); sv_gametype = Cvar_Get ("g_gametype", "0", CVAR_SERVERINFO | CVAR_LATCH ); Cvar_Get ("sv_keywords", "", CVAR_SERVERINFO); Cvar_Get ("protocol", va("%i", PROTOCOL_VERSION), CVAR_SERVERINFO | CVAR_ROM); sv_mapname = Cvar_Get ("mapname", "nomap", CVAR_SERVERINFO | CVAR_ROM); sv_privateClients = Cvar_Get ("sv_privateClients", "0", CVAR_SERVERINFO); sv_hostname = Cvar_Get ("sv_hostname", "noname", CVAR_SERVERINFO | CVAR_ARCHIVE ); sv_maxclients = Cvar_Get ("sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH); sv_maxRate = Cvar_Get ("sv_maxRate", "0", CVAR_ARCHIVE | CVAR_SERVERINFO ); sv_minPing = Cvar_Get ("sv_minPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO ); sv_maxPing = Cvar_Get ("sv_maxPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO ); sv_floodProtect = Cvar_Get ("sv_floodProtect", "1", CVAR_ARCHIVE | CVAR_SERVERINFO ); // systeminfo Cvar_Get ("sv_cheats", "1", CVAR_SYSTEMINFO | CVAR_ROM ); sv_serverid = Cvar_Get ("sv_serverid", "0", CVAR_SYSTEMINFO | CVAR_ROM ); #ifndef DLL_ONLY // bk010216 - for DLL-only servers sv_pure = Cvar_Get ("sv_pure", "1", CVAR_SYSTEMINFO ); #else sv_pure = Cvar_Get ("sv_pure", "0", CVAR_SYSTEMINFO | CVAR_INIT | CVAR_ROM ); #endif Cvar_Get ("sv_paks", "", CVAR_SYSTEMINFO | CVAR_ROM ); Cvar_Get ("sv_pakNames", "", CVAR_SYSTEMINFO | CVAR_ROM ); Cvar_Get ("sv_referencedPaks", "", CVAR_SYSTEMINFO | CVAR_ROM ); Cvar_Get ("sv_referencedPakNames", "", CVAR_SYSTEMINFO | CVAR_ROM ); // server vars sv_rconPassword = Cvar_Get ("rconPassword", "", CVAR_TEMP ); sv_privatePassword = Cvar_Get ("sv_privatePassword", "", CVAR_TEMP ); sv_fps = Cvar_Get ("sv_fps", "20", CVAR_TEMP ); sv_timeout = Cvar_Get ("sv_timeout", "200", CVAR_TEMP ); sv_zombietime = Cvar_Get ("sv_zombietime", "2", CVAR_TEMP ); Cvar_Get ("nextmap", "", CVAR_TEMP ); sv_allowDownload = Cvar_Get ("sv_allowDownload", "0", CVAR_SERVERINFO); sv_master[0] = Cvar_Get ("sv_master1", MASTER_SERVER_NAME, 0 ); sv_master[1] = Cvar_Get ("sv_master2", "", CVAR_ARCHIVE ); sv_master[2] = Cvar_Get ("sv_master3", "", CVAR_ARCHIVE ); sv_master[3] = Cvar_Get ("sv_master4", "", CVAR_ARCHIVE ); sv_master[4] = Cvar_Get ("sv_master5", "", CVAR_ARCHIVE ); sv_reconnectlimit = Cvar_Get ("sv_reconnectlimit", "3", 0); sv_showloss = Cvar_Get ("sv_showloss", "0", 0); sv_padPackets = Cvar_Get ("sv_padPackets", "0", 0); sv_killserver = Cvar_Get ("sv_killserver", "0", 0); sv_mapChecksum = Cvar_Get ("sv_mapChecksum", "", CVAR_ROM); sv_lanForceRate = Cvar_Get ("sv_lanForceRate", "1", CVAR_ARCHIVE ); sv_strictAuth = Cvar_Get ("sv_strictAuth", "1", CVAR_ARCHIVE ); // initialize bot cvars so they are listed and can be set before loading the botlib SV_BotInitCvars(); // init the botlib here because we need the pre-compiler in the UI SV_BotInitBotLib(); }
/* =========== IN_Init =========== */ void IN_Init (void) { // mouse variables m_filter = Cvar_Get ("m_filter", "0", 0); in_mouse = Cvar_Get ("in_mouse", "1", CVAR_ARCHIVE); // joystick variables in_joystick = Cvar_Get ("in_joystick", "0", CVAR_ARCHIVE); joy_name = Cvar_Get ("joy_name", "joystick", 0); joy_advanced = Cvar_Get ("joy_advanced", "0", 0); joy_advaxisx = Cvar_Get ("joy_advaxisx", "0", 0); joy_advaxisy = Cvar_Get ("joy_advaxisy", "0", 0); joy_advaxisz = Cvar_Get ("joy_advaxisz", "0", 0); joy_advaxisr = Cvar_Get ("joy_advaxisr", "0", 0); joy_advaxisu = Cvar_Get ("joy_advaxisu", "0", 0); joy_advaxisv = Cvar_Get ("joy_advaxisv", "0", 0); joy_forwardthreshold = Cvar_Get ("joy_forwardthreshold", "0.15", 0); joy_sidethreshold = Cvar_Get ("joy_sidethreshold", "0.15", 0); joy_upthreshold = Cvar_Get ("joy_upthreshold", "0.15", 0); joy_pitchthreshold = Cvar_Get ("joy_pitchthreshold", "0.15", 0); joy_yawthreshold = Cvar_Get ("joy_yawthreshold", "0.15", 0); joy_forwardsensitivity = Cvar_Get ("joy_forwardsensitivity", "-1", 0); joy_sidesensitivity = Cvar_Get ("joy_sidesensitivity", "-1", 0); joy_upsensitivity = Cvar_Get ("joy_upsensitivity", "-1", 0); joy_pitchsensitivity = Cvar_Get ("joy_pitchsensitivity", "1", 0); joy_yawsensitivity = Cvar_Get ("joy_yawsensitivity", "-1", 0); // centering v_centermove = Cvar_Get ("v_centermove", "0.15", 0); v_centerspeed = Cvar_Get ("v_centerspeed", "500", 0); Cmd_AddCommand ("+mlook", IN_MLookDown); Cmd_AddCommand ("-mlook", IN_MLookUp); Cmd_AddCommand ("joy_advancedupdate", Joy_AdvancedUpdate_f); IN_StartupMouse (); IN_StartupJoystick (); }
/** * @brief Special case for point traces because the patch collide "brushes" have no volume * @param[in,out] tw * @param[in] pc */ void CM_TracePointThroughPatchCollide(traceWork_t *tw, const struct patchCollide_s *pc) { qboolean frontFacing[MAX_PATCH_PLANES]; float intersection[MAX_PATCH_PLANES]; float intersect; const patchPlane_t *planes; const facet_t *facet; unsigned int i; int j, k; float offset; float d1, d2; static cvar_t *cv; if (!cm_playerCurveClip->integer && !tw->isPoint) { return; // FIXME: until I get player sized clipping working right } // determine the trace's relationship to all planes planes = pc->planes; for (i = 0 ; i < pc->numPlanes ; i++, planes++) { offset = DotProduct(tw->offsets[planes->signbits], planes->plane); d1 = DotProduct(tw->start, planes->plane) - planes->plane[3] + offset; d2 = DotProduct(tw->end, planes->plane) - planes->plane[3] + offset; if (d1 <= 0) { frontFacing[i] = qfalse; } else { frontFacing[i] = qtrue; } if (d1 == d2) { intersection[i] = 99999; } else { intersection[i] = d1 / (d1 - d2); if (intersection[i] <= 0) { intersection[i] = 99999; } } } // see if any of the surface planes are intersected facet = pc->facets; for (i = 0 ; i < pc->numFacets ; i++, facet++) { if (!frontFacing[facet->surfacePlane]) { continue; } intersect = intersection[facet->surfacePlane]; if (intersect < 0) { continue; // surface is behind the starting point } if (intersect > tw->trace.fraction) { continue; // already hit something closer } for (j = 0 ; j < facet->numBorders ; j++) { k = facet->borderPlanes[j]; if (frontFacing[k] ^ facet->borderInward[j]) { if (intersection[k] > intersect) { break; } } else { if (intersection[k] < intersect) { break; } } } if (j == facet->numBorders) { // we hit this facet if (!cv) { cv = Cvar_Get("r_debugSurfaceUpdate", "1", 0); } if (cv->integer) { debugPatchCollide = pc; debugFacet = facet; } planes = &pc->planes[facet->surfacePlane]; // calculate intersection with a slight pushoff offset = DotProduct(tw->offsets[planes->signbits], planes->plane); d1 = DotProduct(tw->start, planes->plane) - planes->plane[3] + offset; d2 = DotProduct(tw->end, planes->plane) - planes->plane[3] + offset; tw->trace.fraction = (d1 - SURFACE_CLIP_EPSILON) / (d1 - d2); if (tw->trace.fraction < 0) { tw->trace.fraction = 0; } VectorCopy(planes->plane, tw->trace.plane.normal); tw->trace.plane.dist = planes->plane[3]; } } }
/* =============== IN_StartupJoystick =============== */ void IN_StartupJoystick (void) { int numdevs; JOYCAPS jc; MMRESULT mmr; cvar_t *cv; // assume no joystick joy_avail = false; // abort startup if user requests no joystick cv = Cvar_Get ("in_initjoy", "1", CVAR_NOSET); if ( !cv->value ) return; // verify joystick driver is present if ((numdevs = joyGetNumDevs ()) == 0) { // Com_Printf ("\njoystick not found -- driver not present\n\n"); return; } // cycle through the joystick ids for the first valid one for (joy_id=0 ; joy_id<numdevs ; joy_id++) { memset (&ji, 0, sizeof(ji)); ji.dwSize = sizeof(ji); ji.dwFlags = JOY_RETURNCENTERED; if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR) break; } // abort startup if we didn't find a valid joystick if (mmr != JOYERR_NOERROR) { Com_Printf ("\njoystick not found -- no valid joysticks (%x)\n\n", mmr); return; } // get the capabilities of the selected joystick // abort startup if command fails memset (&jc, 0, sizeof(jc)); if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof(jc))) != JOYERR_NOERROR) { Com_Printf ("\njoystick not found -- invalid joystick capabilities (%x)\n\n", mmr); return; } // save the joystick's number of buttons and POV status joy_numbuttons = jc.wNumButtons; joy_haspov = jc.wCaps & JOYCAPS_HASPOV; // old button and POV states default to no buttons pressed joy_oldbuttonstate = joy_oldpovstate = 0; // mark the joystick as available and advanced initialization not completed // this is needed as cvars are not available during initialization joy_avail = true; joy_advancedinit = false; Com_Printf ("\njoystick detected\n\n"); }
/** * @brief Called from the renderer */ void CM_DrawDebugSurface(void (*drawPoly)(int color, int numPoints, float *points)) { static cvar_t *cv; static cvar_t *cv2; const patchCollide_t *pc; facet_t *facet; winding_t *w; unsigned int i; int j, k, n; int curplanenum, planenum, curinward, inward; float plane[4]; vec3_t mins = { -15, -15, -28 }, maxs = { 15, 15, 28 }; vec3_t v1, v2; if (!cv2) { cv2 = Cvar_Get("r_debugSurface", "0", 0); } if (cv2->integer != 1) { // TODO: remove in sv_bot.c //BotDrawDebugPolygons(drawPoly, cv2->integer); return; } if (!debugPatchCollide) { return; } if (!cv) { cv = Cvar_Get("cm_debugSize", "2", 0); } pc = debugPatchCollide; for (i = 0, facet = pc->facets ; i < pc->numFacets ; i++, facet++) { for (k = 0 ; k < facet->numBorders + 1; k++) { if (k < facet->numBorders) { planenum = facet->borderPlanes[k]; inward = facet->borderInward[k]; } else { planenum = facet->surfacePlane; inward = qfalse; //continue; } Vector4Copy(pc->planes[planenum].plane, plane); // planenum = facet->surfacePlane; if (inward) { VectorSubtract(vec3_origin, plane, plane); plane[3] = -plane[3]; } plane[3] += cv->value; //* for (n = 0; n < 3; n++) { if (plane[n] > 0) { v1[n] = maxs[n]; } else { v1[n] = mins[n]; } } //end for VectorNegate(plane, v2); plane[3] += Q_fabs(DotProduct(v1, v2)); //*/ w = BaseWindingForPlane(plane, plane[3]); for (j = 0 ; j < facet->numBorders + 1 && w; j++) { if (j < facet->numBorders) { curplanenum = facet->borderPlanes[j]; curinward = facet->borderInward[j]; } else { curplanenum = facet->surfacePlane; curinward = qfalse; //continue; } if (curplanenum == planenum) { continue; } Vector4Copy(pc->planes[curplanenum].plane, plane); if (!curinward) { VectorSubtract(vec3_origin, plane, plane); plane[3] = -plane[3]; } //if ( !facet->borderNoAdjust[j] ) { plane[3] -= cv->value; //} for (n = 0; n < 3; n++) { if (plane[n] > 0) { v1[n] = maxs[n]; } else { v1[n] = mins[n]; } } //end for VectorNegate(plane, v2); plane[3] -= Q_fabs(DotProduct(v1, v2)); ChopWindingInPlace(&w, plane, plane[3], 0.1f); } if (w) { if (facet == debugFacet) { drawPoly(4, w->numpoints, w->p[0]); //Com_Printf("blue facet has %d border planes\n", facet->numBorders); } else { drawPoly(1, w->numpoints, w->p[0]); } FreeWinding(w); } else { Com_Printf("CM_DrawDebugSurface: winding chopped away by border planes\n"); } } } // draw the debug block { vec3_t v[3]; VectorCopy(debugBlockPoints[0], v[0]); VectorCopy(debugBlockPoints[1], v[1]); VectorCopy(debugBlockPoints[2], v[2]); drawPoly(2, 3, v[0]); VectorCopy(debugBlockPoints[2], v[0]); VectorCopy(debugBlockPoints[3], v[1]); VectorCopy(debugBlockPoints[0], v[2]); drawPoly(2, 3, v[0]); } #if 0 vec3_t v[4]; v[0][0] = pc->bounds[1][0]; v[0][1] = pc->bounds[1][1]; v[0][2] = pc->bounds[1][2]; v[1][0] = pc->bounds[1][0]; v[1][1] = pc->bounds[0][1]; v[1][2] = pc->bounds[1][2]; v[2][0] = pc->bounds[0][0]; v[2][1] = pc->bounds[0][1]; v[2][2] = pc->bounds[1][2]; v[3][0] = pc->bounds[0][0]; v[3][1] = pc->bounds[1][1]; v[3][2] = pc->bounds[1][2]; drawPoly(4, v[0]); #endif }
/* =============== SV_Init Only called at startup, not for each game =============== */ void SV_Init( void ) { SV_InitOperatorCommands(); skill = Cvar_Get ("skill", "1", CVAR_LATCH, "game skill level" ); deathmatch = Cvar_Get ("deathmatch", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays deathmatch state" ); teamplay = Cvar_Get ("teamplay", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays teamplay state" ); coop = Cvar_Get ("coop", "0", CVAR_LATCH|CVAR_SERVERINFO, "displays cooperative state" ); Cvar_Get ("protocol", va( "%i", PROTOCOL_VERSION ), CVAR_INIT, "displays server protocol version" ); Cvar_Get ("defaultmap", "", CVAR_SERVERNOTIFY, "holds the multiplayer mapname" ); Cvar_Get ("showtriggers", "0", CVAR_LATCH, "debug cvar shows triggers" ); Cvar_Get ("sv_aim", "0", CVAR_ARCHIVE, "enable auto-aiming" ); Cvar_Get ("mapcyclefile", "mapcycle.txt", 0, "name of multiplayer map cycle configuration file" ); Cvar_Get ("servercfgfile","server.cfg", 0, "name of dedicated server configuration file" ); Cvar_Get ("lservercfgfile","listenserver.cfg", 0, "name of listen server configuration file" ); Cvar_Get ("motdfile", "motd.txt", 0, "name of 'message of the day' file" ); Cvar_Get ("sv_language", "0", 0, "game language (currently unused)" ); Cvar_Get ("suitvolume", "0.25", CVAR_ARCHIVE, "HEV suit volume" ); Cvar_Get ("sv_background", "0", CVAR_READ_ONLY, "indicate what background map is running" ); Cvar_Get( "gamedir", GI->gamefolder, CVAR_SERVERINFO|CVAR_SERVERNOTIFY|CVAR_INIT, "game folder" ); Cvar_Get( "sv_alltalk", "1", 0, "allow to talking for all players (legacy, unused)" ); Cvar_Get( "sv_airmove", "1", CVAR_SERVERNOTIFY, "enable airmovement (legacy, unused)" ); Cvar_Get( "mp_autocrosshair", "0", 0, "allow auto crosshair in multiplayer (legacy, unused)" ); Cvar_Get( "sv_allow_PhysX", "1", CVAR_ARCHIVE, "allow XashXT to usage PhysX engine" ); //XashXT cvar Cvar_Get( "sv_precache_meshes", "1", CVAR_ARCHIVE, "cache SOLID_CUSTOM meshes before level loading" ); // Paranoia 2 cvar // half-life shared variables sv_zmax = Cvar_Get ("sv_zmax", "4096", CVAR_PHYSICINFO, "zfar server value" ); sv_wateramp = Cvar_Get ("sv_wateramp", "0", CVAR_PHYSICINFO, "global water wave height" ); sv_skycolor_r = Cvar_Get ("sv_skycolor_r", "255", CVAR_PHYSICINFO, "skycolor red" ); sv_skycolor_g = Cvar_Get ("sv_skycolor_g", "255", CVAR_PHYSICINFO, "skycolor green" ); sv_skycolor_b = Cvar_Get ("sv_skycolor_b", "255", CVAR_PHYSICINFO, "skycolor blue" ); sv_skyvec_x = Cvar_Get ("sv_skyvec_x", "0", CVAR_PHYSICINFO, "skylight direction x" ); sv_skyvec_y = Cvar_Get ("sv_skyvec_y", "0", CVAR_PHYSICINFO, "skylight direction y" ); sv_skyvec_z = Cvar_Get ("sv_skyvec_z", "0", CVAR_PHYSICINFO, "skylight direction z" ); sv_skyname = Cvar_Get ("sv_skyname", "desert", CVAR_PHYSICINFO, "skybox name (can be dynamically changed in-game)" ); sv_skydir_x = Cvar_Get ("sv_skydir_x", "0", CVAR_PHYSICINFO, "sky rotation direction x" ); sv_skydir_y = Cvar_Get ("sv_skydir_y", "0", CVAR_PHYSICINFO, "sky rotation direction y" ); sv_skydir_z = Cvar_Get ("sv_skydir_z", "1", CVAR_PHYSICINFO, "sky rotation direction z" ); // g-cont. add default sky rotate direction sv_skyangle = Cvar_Get ("sv_skyangle", "0", CVAR_PHYSICINFO, "skybox rotational angle (in degrees)" ); sv_skyspeed = Cvar_Get ("sv_skyspeed", "0", 0, "skybox rotational speed" ); sv_footsteps = Cvar_Get ("mp_footsteps", "1", CVAR_PHYSICINFO, "can hear footsteps from other players" ); sv_wateralpha = Cvar_Get ("sv_wateralpha", "1", CVAR_PHYSICINFO, "world surfaces water transparency factor. 1.0 - solid, 0.0 - fully transparent" ); rcon_password = Cvar_Get( "rcon_password", "", 0, "remote connect password" ); sv_stepsize = Cvar_Get( "sv_stepsize", "18", CVAR_ARCHIVE|CVAR_PHYSICINFO, "how high you can step up" ); sv_newunit = Cvar_Get( "sv_newunit", "0", 0, "sets to 1 while new unit is loading" ); hostname = Cvar_Get( "hostname", "unnamed", CVAR_SERVERNOTIFY|CVAR_SERVERNOTIFY|CVAR_ARCHIVE, "host name" ); timeout = Cvar_Get( "timeout", "125", CVAR_SERVERNOTIFY, "connection timeout" ); zombietime = Cvar_Get( "zombietime", "2", CVAR_SERVERNOTIFY, "timeout for clients-zombie (who died but not respawned)" ); sv_pausable = Cvar_Get( "pausable", "1", CVAR_SERVERNOTIFY, "allow players to pause or not" ); sv_allow_studio_attachment_angles = Cvar_Get( "sv_allow_studio_attachment_angles", "0", CVAR_ARCHIVE, "enable calc angles for attachment points (on studio models)" ); sv_allow_rotate_pushables = Cvar_Get( "sv_allow_rotate_pushables", "0", CVAR_ARCHIVE, "let the pushers rotate pushables with included origin-brush" ); sv_validate_changelevel = Cvar_Get( "sv_validate_changelevel", "1", CVAR_ARCHIVE, "test change level for level-designer errors" ); sv_clienttrace = Cvar_Get( "sv_clienttrace", "1", CVAR_SERVERNOTIFY, "scaling factor for client hitboxes" ); sv_wallbounce = Cvar_Get( "sv_wallbounce", "1.0", CVAR_PHYSICINFO, "bounce factor for client with MOVETYPE_BOUNCE" ); sv_spectatormaxspeed = Cvar_Get( "sv_spectatormaxspeed", "500", CVAR_PHYSICINFO, "spectator maxspeed" ); sv_waterfriction = Cvar_Get( "sv_waterfriction", "1", CVAR_PHYSICINFO, "how fast you slow down in water" ); sv_wateraccelerate = Cvar_Get( "sv_wateraccelerate", "10", CVAR_PHYSICINFO, "rate at which a player accelerates to sv_maxspeed while in the water" ); sv_rollangle = Cvar_Get( "sv_rollangle", "0", CVAR_PHYSICINFO, "how much to tilt the view when strafing" ); sv_rollspeed = Cvar_Get( "sv_rollspeed", "200", CVAR_PHYSICINFO, "how much strafing is necessary to tilt the view" ); sv_airaccelerate = Cvar_Get("sv_airaccelerate", "10", CVAR_PHYSICINFO, "player accellerate in air" ); sv_maxvelocity = Cvar_Get( "sv_maxvelocity", "2000", CVAR_PHYSICINFO, "max world velocity" ); sv_gravity = Cvar_Get( "sv_gravity", "800", CVAR_PHYSICINFO, "world gravity" ); sv_maxspeed = Cvar_Get( "sv_maxspeed", "320", CVAR_PHYSICINFO, "maximum speed a player can accelerate to when on ground"); sv_accelerate = Cvar_Get( "sv_accelerate", "10", CVAR_PHYSICINFO, "rate at which a player accelerates to sv_maxspeed" ); sv_friction = Cvar_Get( "sv_friction", "4", CVAR_PHYSICINFO, "how fast you slow down" ); sv_edgefriction = Cvar_Get( "edgefriction", "2", CVAR_PHYSICINFO, "how much you slow down when nearing a ledge you might fall off" ); sv_stopspeed = Cvar_Get( "sv_stopspeed", "100", CVAR_PHYSICINFO, "how fast you come to a complete stop" ); sv_maxclients = Cvar_Get( "maxplayers", "1", CVAR_LATCH|CVAR_SERVERNOTIFY, "server clients limit" ); sv_check_errors = Cvar_Get( "sv_check_errors", "0", CVAR_ARCHIVE, "check edicts for errors" ); physinfo = Cvar_Get( "@physinfo", "0", CVAR_READ_ONLY, "" ); // use ->modified value only serverinfo = Cvar_Get( "@serverinfo", "0", CVAR_READ_ONLY, "" ); // use ->modified value only public_server = Cvar_Get ("public", "0", 0, "change server type from private to public" ); sv_lighting_modulate = Cvar_Get( "r_lighting_modulate", "0.6", CVAR_ARCHIVE, "lightstyles modulate scale" ); sv_reconnect_limit = Cvar_Get ("sv_reconnect_limit", "3", CVAR_ARCHIVE, "max reconnect attempts" ); sv_failuretime = Cvar_Get( "sv_failuretime", "0.5", 0, "after this long without a packet from client, don't send any more until client starts sending again" ); sv_unlag = Cvar_Get( "sv_unlag", "1", 0, "allow lag compensation on server-side" ); sv_maxunlag = Cvar_Get( "sv_maxunlag", "0.5", 0, "max latency which can be interpolated" ); sv_unlagpush = Cvar_Get( "sv_unlagpush", "0.0", 0, "unlag push bias" ); sv_unlagsamples = Cvar_Get( "sv_unlagsamples", "1", 0, "max samples to interpolate" ); sv_allow_upload = Cvar_Get( "sv_allow_upload", "1", 0, "allow uploading custom resources from clients" ); sv_allow_download = Cvar_Get( "sv_allow_download", "1", 0, "allow download missed resources to clients" ); sv_send_logos = Cvar_Get( "sv_send_logos", "1", 0, "send custom player decals to other clients" ); sv_send_resources = Cvar_Get( "sv_send_resources", "1", 0, "send generic resources that specified in 'mapname.res'" ); sv_sendvelocity = Cvar_Get( "sv_sendvelocity", "1", CVAR_ARCHIVE, "force to send velocity for event_t structure across network" ); sv_quakehulls = Cvar_Get( "sv_quakehulls", "0", CVAR_ARCHIVE, "using quake style hull select instead of half-life style hull select" ); mp_consistency = Cvar_Get( "mp_consistency", "1", CVAR_SERVERNOTIFY, "enbale consistency check in multiplayer" ); clockwindow = Cvar_Get( "clockwindow", "0.5", 0, "timewindow to execute client moves" ); sv_novis = Cvar_Get( "sv_novis", "0", 0, "force to ignore server visibility" ); SV_ClearSaveDir (); // delete all temporary *.hl files BF_Init( &net_message, "NetMessage", net_message_buffer, sizeof( net_message_buffer )); }
/* ==================== CL_UISystemCalls The ui module is making a system call ==================== */ int CL_UISystemCalls( int *args ) { switch( args[0] ) { case UI_ERROR: Com_Error( ERR_DROP, "%s", VMA(1) ); return 0; case UI_PRINT: Com_Printf( "%s", VMA(1) ); return 0; case UI_MILLISECONDS: return Sys_Milliseconds(); case UI_CVAR_REGISTER: Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); return 0; case UI_CVAR_UPDATE: Cvar_Update( VMA(1) ); return 0; case UI_CVAR_SET: Cvar_Set( VMA(1), VMA(2) ); return 0; case UI_CVAR_VARIABLEVALUE: return FloatAsInt( Cvar_VariableValue( VMA(1) ) ); case UI_CVAR_VARIABLESTRINGBUFFER: Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] ); return 0; case UI_CVAR_SETVALUE: Cvar_SetValue( VMA(1), VMF(2) ); return 0; case UI_CVAR_RESET: Cvar_Reset( VMA(1) ); return 0; case UI_CVAR_CREATE: Cvar_Get( VMA(1), VMA(2), args[3] ); return 0; case UI_CVAR_INFOSTRINGBUFFER: Cvar_InfoStringBuffer( args[1], VMA(2), args[3] ); return 0; case UI_ARGC: return Cmd_Argc(); case UI_ARGV: Cmd_ArgvBuffer( args[1], VMA(2), args[3] ); return 0; case UI_CMD_EXECUTETEXT: Cbuf_ExecuteText( args[1], VMA(2) ); return 0; case UI_FS_FOPENFILE: return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] ); case UI_FS_READ: FS_Read2( VMA(1), args[2], args[3] ); return 0; case UI_FS_WRITE: FS_Write( VMA(1), args[2], args[3] ); return 0; case UI_FS_FCLOSEFILE: FS_FCloseFile( args[1] ); return 0; case UI_FS_GETFILELIST: return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] ); case UI_FS_SEEK: return FS_Seek( args[1], args[2], args[3] ); case UI_R_REGISTERMODEL: return re.RegisterModel( VMA(1) ); case UI_R_REGISTERSKIN: return re.RegisterSkin( VMA(1) ); case UI_R_REGISTERSHADERNOMIP: return re.RegisterShaderNoMip( VMA(1) ); case UI_R_CLEARSCENE: re.ClearScene(); return 0; case UI_R_ADDREFENTITYTOSCENE: re.AddRefEntityToScene( VMA(1) ); return 0; case UI_R_ADDPOLYTOSCENE: re.AddPolyToScene( args[1], args[2], VMA(3), 1 ); return 0; case UI_R_ADDLIGHTTOSCENE: re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) ); return 0; case UI_R_RENDERSCENE: re.RenderScene( VMA(1) ); return 0; case UI_R_SETCOLOR: re.SetColor( VMA(1) ); return 0; case UI_R_DRAWSTRETCHPIC: re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] ); return 0; case UI_R_MODELBOUNDS: re.ModelBounds( args[1], VMA(2), VMA(3) ); return 0; case UI_UPDATESCREEN: SCR_UpdateScreen(); return 0; case UI_CM_LERPTAG: re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) ); return 0; case UI_S_REGISTERSOUND: return S_RegisterSound( VMA(1), args[2] ); case UI_S_STARTLOCALSOUND: S_StartLocalSound( args[1], args[2] ); return 0; case UI_KEY_KEYNUMTOSTRINGBUF: Key_KeynumToStringBuf( args[1], VMA(2), args[3] ); return 0; case UI_KEY_GETBINDINGBUF: Key_GetBindingBuf( args[1], VMA(2), args[3] ); return 0; case UI_KEY_SETBINDING: Key_SetBinding( args[1], VMA(2) ); return 0; case UI_KEY_ISDOWN: return Key_IsDown( args[1] ); case UI_KEY_GETOVERSTRIKEMODE: return Key_GetOverstrikeMode(); case UI_KEY_SETOVERSTRIKEMODE: Key_SetOverstrikeMode( args[1] ); return 0; case UI_KEY_CLEARSTATES: Key_ClearStates(); return 0; case UI_KEY_GETCATCHER: return Key_GetCatcher(); case UI_KEY_SETCATCHER: Key_SetCatcher( args[1] ); return 0; case UI_GETCLIPBOARDDATA: GetClipboardData( VMA(1), args[2] ); return 0; case UI_GETCLIENTSTATE: GetClientState( VMA(1) ); return 0; case UI_GETGLCONFIG: CL_GetGlconfig( VMA(1) ); return 0; case UI_GETCONFIGSTRING: return GetConfigString( args[1], VMA(2), args[3] ); case UI_LAN_LOADCACHEDSERVERS: LAN_LoadCachedServers(); return 0; case UI_LAN_SAVECACHEDSERVERS: LAN_SaveServersToCache(); return 0; case UI_LAN_ADDSERVER: return LAN_AddServer(args[1], VMA(2), VMA(3)); case UI_LAN_REMOVESERVER: LAN_RemoveServer(args[1], VMA(2)); return 0; case UI_LAN_GETPINGQUEUECOUNT: return LAN_GetPingQueueCount(); case UI_LAN_CLEARPING: LAN_ClearPing( args[1] ); return 0; case UI_LAN_GETPING: LAN_GetPing( args[1], VMA(2), args[3], VMA(4) ); return 0; case UI_LAN_GETPINGINFO: LAN_GetPingInfo( args[1], VMA(2), args[3] ); return 0; case UI_LAN_GETSERVERCOUNT: return LAN_GetServerCount(args[1]); case UI_LAN_GETSERVERADDRESSSTRING: LAN_GetServerAddressString( args[1], args[2], VMA(3), args[4] ); return 0; case UI_LAN_GETSERVERINFO: LAN_GetServerInfo( args[1], args[2], VMA(3), args[4] ); return 0; case UI_LAN_GETSERVERPING: return LAN_GetServerPing( args[1], args[2] ); case UI_LAN_MARKSERVERVISIBLE: LAN_MarkServerVisible( args[1], args[2], args[3] ); return 0; case UI_LAN_SERVERISVISIBLE: return LAN_ServerIsVisible( args[1], args[2] ); case UI_LAN_UPDATEVISIBLEPINGS: return LAN_UpdateVisiblePings( args[1] ); case UI_LAN_RESETPINGS: LAN_ResetPings( args[1] ); return 0; case UI_LAN_SERVERSTATUS: return LAN_GetServerStatus( VMA(1), VMA(2), args[3] ); case UI_LAN_COMPARESERVERS: return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] ); case UI_MEMORY_REMAINING: return Hunk_MemoryRemaining(); case UI_GET_CDKEY: CLUI_GetCDKey( VMA(1), args[2] ); return 0; case UI_SET_CDKEY: CLUI_SetCDKey( VMA(1) ); return 0; case UI_SET_PBCLSTATUS: return 0; case UI_R_REGISTERFONT: re.RegisterFont( VMA(1), args[2], VMA(3)); return 0; case UI_MEMSET: Com_Memset( VMA(1), args[2], args[3] ); return 0; case UI_MEMCPY: Com_Memcpy( VMA(1), VMA(2), args[3] ); return 0; case UI_STRNCPY: return (int)strncpy( VMA(1), VMA(2), args[3] ); case UI_SIN: return FloatAsInt( sin( VMF(1) ) ); case UI_COS: return FloatAsInt( cos( VMF(1) ) ); case UI_ATAN2: return FloatAsInt( atan2( VMF(1), VMF(2) ) ); case UI_SQRT: return FloatAsInt( sqrt( VMF(1) ) ); case UI_FLOOR: return FloatAsInt( floor( VMF(1) ) ); case UI_CEIL: return FloatAsInt( ceil( VMF(1) ) ); case UI_PC_ADD_GLOBAL_DEFINE: return botlib_export->PC_AddGlobalDefine( VMA(1) ); case UI_PC_LOAD_SOURCE: return botlib_export->PC_LoadSourceHandle( VMA(1) ); case UI_PC_FREE_SOURCE: return botlib_export->PC_FreeSourceHandle( args[1] ); case UI_PC_READ_TOKEN: return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) ); case UI_PC_SOURCE_FILE_AND_LINE: return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) ); case UI_S_STOPBACKGROUNDTRACK: S_StopBackgroundTrack(); return 0; case UI_S_STARTBACKGROUNDTRACK: S_StartBackgroundTrack( VMA(1), VMA(2)); return 0; case UI_REAL_TIME: return Com_RealTime( VMA(1) ); case UI_CIN_PLAYCINEMATIC: Com_DPrintf("UI_CIN_PlayCinematic\n"); return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]); case UI_CIN_STOPCINEMATIC: return CIN_StopCinematic(args[1]); case UI_CIN_RUNCINEMATIC: return CIN_RunCinematic(args[1]); case UI_CIN_DRAWCINEMATIC: CIN_DrawCinematic(args[1]); return 0; case UI_CIN_SETEXTENTS: CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]); return 0; case UI_R_REMAP_SHADER: re.RemapShader( VMA(1), VMA(2), VMA(3) ); return 0; case UI_VERIFY_CDKEY: return CL_CDKeyValidate(VMA(1), VMA(2)); default: Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] ); } return 0; }
/* * ==================== NET_Socket ==================== */ int NET_Socket(char *net_interface, int port, netsrc_t type, int family) { char Buf[BUFSIZ], *Host, *Service; int newsocket , Error; struct sockaddr_storage ss; struct addrinfo hints, *res, *ai; qboolean _true = true; int i = 1; #ifdef IPV6_BINDV6ONLY int dummy; #endif struct ipv6_mreq mreq; cvar_t *mcast; memset(&hints, 0, sizeof(hints)); hints.ai_family = family; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; hints.ai_flags = AI_PASSIVE; if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost")) Host = (family == AF_INET6) ? "::" : "0.0.0.0"; else Host = net_interface; if (port == PORT_ANY) Service = NULL; else { Com_sprintf(Buf, sizeof(Buf), "%5d", port); Service = Buf; } if ((Error = getaddrinfo(Host, Service, &hints, &res))) { /* * Com_Printf("NET_Socket: getaddrinfo: %s\n", gai_strerror * (Error)); */ return 0; } for (ai = res; ai != NULL; ai = ai->ai_next) { if ((newsocket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) { Com_Printf("NET_Socket: socket: %s\n", strerror(errno)); continue; } /* make it non-blocking */ if (ioctl(newsocket, FIONBIO, (char *)&_true) == -1) { Com_Printf("NET_Socket: ioctl FIONBIO: %s\n", strerror(errno)); continue; } #ifdef IPV6_BINDV6ONLY if (family == AF_INET6) if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_BINDV6ONLY, &dummy, sizeof(dummy)) < 0) { Com_Printf("NET_Socket: setsockopt IPV6_BINDV6ONLY: %s\n", strerror(errno)); } #endif if (family == AF_INET) { /* make it broadcast capable */ if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1) { Com_Printf("ERROR: NET_Socket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString()); return 0; } } if (bind(newsocket, ai->ai_addr, ai->ai_addrlen) < 0) { Com_Printf("NET_Socket: bind: %s\n", strerror(errno)); } else { memcpy(&ss, ai->ai_addr, ai->ai_addrlen); break; } } if (res != NULL) freeaddrinfo(res); if (ai == NULL) return 0; switch (ss.ss_family) { case AF_INET: break; case AF_INET6: /* * Multicast outgoing interface is specified for client and * server (+set multicast <ifname>) */ mcast = Cvar_Get("multicast", "NULL", CVAR_NOSET); multicast_interface = (strcmp(mcast->string, "NULL") ? mcast->string : NULL); if (multicast_interface != NULL) { /* * multicast_interface is a global variable. Also * used in NET_SendPacket() */ if ((mreq.ipv6mr_interface = if_nametoindex(multicast_interface)) == 0) { Com_Printf("NET_Socket: invalid interface: %s", multicast_interface); } if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_MULTICAST_IF, &mreq.ipv6mr_interface, sizeof(mreq.ipv6mr_interface)) < 0) { Com_Printf("NET_Socket: IPV6_MULTICAST_IF: %s", strerror(errno)); } /* Join multicast group ONLY if server */ if (type == NS_SERVER) { if (inet_pton(AF_INET6, QUAKE2MCAST, &mreq.ipv6mr_multiaddr.s6_addr) != 1) { Com_Printf("NET_Socket: inet_pton: %s", strerror(errno)); } if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq, sizeof(mreq)) < 0) { Com_Printf("NET_Socket: IPV6_JOIN_GROUP: %s", strerror(errno)); } } } break; } return newsocket; }