/* * Memory_Shutdown * * NOTE: Should be the last called function before shutdown! */ void Memory_Shutdown( void ) { mempool_t *pool, *next; if( !memory_initialized ) return; // set the cvar to NULL so nothing is printed to non-existing console developerMemory = NULL; Mem_CheckSentinelsGlobal(); Mem_FreePool( &zoneMemPool ); Mem_FreePool( &tempMemPool ); for( pool = poolChain; pool; pool = next ) { // do it here, because pool is to be freed // and the chain will be broken next = pool->next; #ifdef SHOW_NONFREED Com_Printf( "Warning: Memory pool %s was never freed\n", pool->name ); #endif Mem_FreePool( &pool ); } memory_initialized = qfalse; }
static void Mem_PrintStats( void ) { int count, size, real; int total, totalsize, realsize; mempool_t *pool; memheader_t *mem; Mem_CheckSentinelsGlobal(); for( total = 0, totalsize = 0, realsize = 0, pool = poolChain; pool; pool = pool->next ) { count = 0; size = 0; real = 0; Mem_CountPoolStats( pool, &count, &size, &real ); total += count; totalsize += size; realsize += real; } Com_Printf( "%i memory pools, totalling %i bytes (%.3fMB), %i bytes (%.3fMB) actual\n", total, totalsize, totalsize / 1048576.0, realsize, realsize / 1048576.0 ); // temporary pools are not nested for( pool = poolChain; pool; pool = pool->next ) { if( ( pool->flags & MEMPOOL_TEMPORARY ) && pool->chain ) { Com_Printf( "%i bytes (%.3fMB) (%i bytes (%.3fMB actual)) of temporary memory still allocated (Leak!)\n", pool->totalsize, pool->totalsize / 1048576.0, pool->realsize, pool->realsize / 1048576.0 ); Com_Printf( "listing temporary memory allocations for %s:\n", pool->name ); for( mem = tempMemPool->chain; mem; mem = mem->next ) Com_Printf( "%10i bytes allocated at %s:%i\n", mem->size, mem->filename, mem->fileline ); } } }
void Com_ScriptModule_Init( void ) { angelwrap_import_t import; static const char *name = "angelwrap"; Com_ScriptModule_Shutdown(); //if( !com_angelscript->integer ) //{ // if( verbose ) // { // Com_Printf( "Not loading angel script module\n" ); // Com_Printf( "------------------------------------\n" ); // } // return; //} Com_Printf( "------- angel script initialization -------\n" ); com_scriptmodulepool = Mem_AllocPool( NULL, "Angel Script Module" ); import.Error = Com_ScriptModule_Error; import.Print = Com_ScriptModule_Print; import.Milliseconds = Sys_Milliseconds; 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.Mem_Alloc = Com_ScriptModule_MemAlloc; import.Mem_Free = Com_ScriptModule_MemFree; import.Mem_AllocPool = Com_ScriptModule_MemAllocPool; import.Mem_FreePool = Com_ScriptModule_MemFreePool; import.Mem_EmptyPool = Com_ScriptModule_MemEmptyPool; // load the actual library if( !Com_ScriptModule_Load( name, &import ) ) { Mem_FreePool( &com_scriptmodulepool ); ae = NULL; return; } // check memory integrity Mem_CheckSentinelsGlobal(); Com_Printf( "------------------------------------\n" ); }
static void Mem_PrintList( int listchildren, int listallocations ) { mempool_t *pool; Mem_CheckSentinelsGlobal(); Com_Printf( "memory pool list:\n" "size name\n" ); for( pool = poolChain; pool; pool = pool->next ) Mem_PrintPoolStats( pool, listchildren, listallocations ); }
void Host_Main(void) { double time1 = 0; double time2 = 0; double time3 = 0; double cl_timer = 0, sv_timer = 0; double clframetime, deltacleantime, olddirtytime, dirtytime; double wait; int pass1, pass2, pass3, i; char vabuf[1024]; qboolean playing; Host_Init(); realtime = 0; host_dirtytime = Sys_DirtyTime(); for (;;) { if (setjmp(host_abortframe)) { SCR_ClearLoadingScreen(false); continue; // something bad happened, or the server disconnected } olddirtytime = host_dirtytime; dirtytime = Sys_DirtyTime(); deltacleantime = dirtytime - olddirtytime; if (deltacleantime < 0) { // warn if it's significant if (deltacleantime < -0.01) Con_Printf("Host_Mingled: time stepped backwards (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime); deltacleantime = 0; } else if (deltacleantime >= 1800) { Con_Printf("Host_Mingled: time stepped forward (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime); deltacleantime = 0; } realtime += deltacleantime; host_dirtytime = dirtytime; cl_timer += deltacleantime; sv_timer += deltacleantime; if (!svs.threaded) { svs.perf_acc_realtime += deltacleantime; // Look for clients who have spawned playing = false; for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++) if(host_client->begun) if(host_client->netconnection) playing = true; if(sv.time < 10) { // don't accumulate time for the first 10 seconds of a match // so things can settle svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0; } else if(svs.perf_acc_realtime > 5) { svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime; svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime; if(svs.perf_acc_offset_samples > 0) { svs.perf_offset_max = svs.perf_acc_offset_max; svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples; svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg); } if(svs.perf_lost > 0 && developer_extra.integer) if(playing) // only complain if anyone is looking Con_DPrintf("Server can't keep up: %s\n", Host_TimingReport(vabuf, sizeof(vabuf))); svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0; } } if (slowmo.value < 0.00001 && slowmo.value != 0) Cvar_SetValue("slowmo", 0); if (host_framerate.value < 0.00001 && host_framerate.value != 0) Cvar_SetValue("host_framerate", 0); // keep the random time dependent, but not when playing demos/benchmarking if(!*sv_random_seed.string && !cls.demoplayback) rand(); // get new key events Key_EventQueue_Unblock(); SndSys_SendKeyEvents(); Sys_SendKeyEvents(); NetConn_UpdateSockets(); Log_DestBuffer_Flush(); // receive packets on each main loop iteration, as the main loop may // be undersleeping due to select() detecting a new packet if (sv.active && !svs.threaded) NetConn_ServerFrame(); Curl_Run(); // check for commands typed to the host Host_GetConsoleCommands(); // when a server is running we only execute console commands on server frames // (this mainly allows frikbot .way config files to work properly by staying in sync with the server qc) // otherwise we execute them on client frames if (sv.active ? sv_timer > 0 : cl_timer > 0) { // process console commands // R_TimeReport("preconsole"); CL_VM_PreventInformationLeaks(); Cbuf_Frame(); // R_TimeReport("console"); } //Con_Printf("%6.0f %6.0f\n", cl_timer * 1000000.0, sv_timer * 1000000.0); // if the accumulators haven't become positive yet, wait a while if (cls.state == ca_dedicated) wait = sv_timer * -1000000.0; else if (!sv.active || svs.threaded) wait = cl_timer * -1000000.0; else wait = max(cl_timer, sv_timer) * -1000000.0; if (!cls.timedemo && wait >= 1) { double time0, delta; if(host_maxwait.value <= 0) wait = min(wait, 1000000.0); else wait = min(wait, host_maxwait.value * 1000.0); if(wait < 1) wait = 1; // because we cast to int time0 = Sys_DirtyTime(); if (sv_checkforpacketsduringsleep.integer && !sys_usenoclockbutbenchmark.integer && !svs.threaded) { NetConn_SleepMicroseconds((int)wait); if (cls.state != ca_dedicated) NetConn_ClientFrame(); // helps server browser get good ping values // TODO can we do the same for ServerFrame? Probably not. } else Sys_Sleep((int)wait); delta = Sys_DirtyTime() - time0; if (delta < 0 || delta >= 1800) delta = 0; if (!svs.threaded) svs.perf_acc_sleeptime += delta; // R_TimeReport("sleep"); continue; } // limit the frametime steps to no more than 100ms each if (cl_timer > 0.1) cl_timer = 0.1; if (sv_timer > 0.1) { if (!svs.threaded) svs.perf_acc_lost += (sv_timer - 0.1); sv_timer = 0.1; } R_TimeReport("---"); //------------------- // // server operations // //------------------- // limit the frametime steps to no more than 100ms each if (sv.active && sv_timer > 0 && !svs.threaded) { // execute one or more server frames, with an upper limit on how much // execution time to spend on server frames to avoid freezing the game if // the server is overloaded, this execution time limit means the game will // slow down if the server is taking too long. int framecount, framelimit = 1; double advancetime, aborttime = 0; float offset; prvm_prog_t *prog = SVVM_prog; // run the world state // don't allow simulation to run too fast or too slow or logic glitches can occur // stop running server frames if the wall time reaches this value if (sys_ticrate.value <= 0) advancetime = sv_timer; else if (cl.islocalgame && !sv_fixedframeratesingleplayer.integer) { // synchronize to the client frametime, but no less than 10ms and no more than 100ms advancetime = bound(0.01, cl_timer, 0.1); } else { advancetime = sys_ticrate.value; // listen servers can run multiple server frames per client frame framelimit = cl_maxphysicsframesperserverframe.integer; aborttime = Sys_DirtyTime() + 0.1; } if(slowmo.value > 0 && slowmo.value < 1) advancetime = min(advancetime, 0.1 / slowmo.value); else advancetime = min(advancetime, 0.1); if(advancetime > 0) { offset = Sys_DirtyTime() - dirtytime;if (offset < 0 || offset >= 1800) offset = 0; offset += sv_timer; ++svs.perf_acc_offset_samples; svs.perf_acc_offset += offset; svs.perf_acc_offset_squared += offset * offset; if(svs.perf_acc_offset_max < offset) svs.perf_acc_offset_max = offset; } // only advance time if not paused // the game also pauses in singleplayer when menu or console is used sv.frametime = advancetime * slowmo.value; if (host_framerate.value) sv.frametime = host_framerate.value; if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused))) sv.frametime = 0; for (framecount = 0;framecount < framelimit && sv_timer > 0;framecount++) { sv_timer -= advancetime; // move things around and think unless paused if (sv.frametime) SV_Physics(); // if this server frame took too long, break out of the loop if (framelimit > 1 && Sys_DirtyTime() >= aborttime) break; } R_TimeReport("serverphysics"); // send all messages to the clients SV_SendClientMessages(); if (sv.paused == 1 && realtime > sv.pausedstart && sv.pausedstart > 0) { prog->globals.fp[OFS_PARM0] = realtime - sv.pausedstart; PRVM_serverglobalfloat(time) = sv.time; prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing"); } // send an heartbeat if enough time has passed since the last one NetConn_Heartbeat(0); R_TimeReport("servernetwork"); } else if (!svs.threaded) { // don't let r_speeds display jump around R_TimeReport("serverphysics"); R_TimeReport("servernetwork"); } //------------------- // // client operations // //------------------- if (cls.state != ca_dedicated && (cl_timer > 0 || cls.timedemo || ((vid_activewindow ? cl_maxfps : cl_maxidlefps).value < 1))) { R_TimeReport("---"); Collision_Cache_NewFrame(); R_TimeReport("photoncache"); // decide the simulation time if (cls.capturevideo.active) { //*** if (cls.capturevideo.realtime) clframetime = cl.realframetime = max(cl_timer, 1.0 / cls.capturevideo.framerate); else { clframetime = 1.0 / cls.capturevideo.framerate; cl.realframetime = max(cl_timer, clframetime); } } else if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo) { clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value); // when running slow, we need to sleep to keep input responsive wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000); if (wait > 0) Sys_Sleep((int)wait); } else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo) clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value); else clframetime = cl.realframetime = cl_timer; // apply slowmo scaling clframetime *= cl.movevars_timescale; // scale playback speed of demos by slowmo cvar if (cls.demoplayback) { clframetime *= slowmo.value; // if demo playback is paused, don't advance time at all if (cls.demopaused) clframetime = 0; } else { // host_framerate overrides all else if (host_framerate.value) clframetime = host_framerate.value; if (cl.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused))) clframetime = 0; } if (cls.timedemo) clframetime = cl.realframetime = cl_timer; // deduct the frame time from the accumulator cl_timer -= cl.realframetime; cl.oldtime = cl.time; cl.time += clframetime; // update video if (host_speeds.integer) time1 = Sys_DirtyTime(); R_TimeReport("pre-input"); // Collect input into cmd CL_Input(); R_TimeReport("input"); // check for new packets NetConn_ClientFrame(); // read a new frame from a demo if needed CL_ReadDemoMessage(); R_TimeReport("clientnetwork"); // now that packets have been read, send input to server CL_SendMove(); R_TimeReport("sendmove"); // update client world (interpolate entities, create trails, etc) CL_UpdateWorld(); R_TimeReport("lerpworld"); CL_Video_Frame(); R_TimeReport("client"); CL_UpdateScreen(); CL_MeshEntities_Reset(); R_TimeReport("render"); if (host_speeds.integer) time2 = Sys_DirtyTime(); // update audio if(cl.csqc_usecsqclistener) { S_Update(&cl.csqc_listenermatrix); cl.csqc_usecsqclistener = false; } else S_Update(&r_refdef.view.matrix); CDAudio_Update(); R_TimeReport("audio"); // reset gathering of mouse input in_mouse_x = in_mouse_y = 0; if (host_speeds.integer) { pass1 = (int)((time1 - time3)*1000000); time3 = Sys_DirtyTime(); pass2 = (int)((time2 - time1)*1000000); pass3 = (int)((time3 - time2)*1000000); Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n", pass1+pass2+pass3, pass1, pass2, pass3); } } #if MEMPARANOIA Mem_CheckSentinelsGlobal(); #else if (developer_memorydebug.integer) Mem_CheckSentinelsGlobal(); #endif // if there is some time remaining from this frame, reset the timers if (cl_timer >= 0) cl_timer = 0; if (sv_timer >= 0) { if (!svs.threaded) svs.perf_acc_lost += sv_timer; sv_timer = 0; } host_framecount++; } }
/* * CIN_LoadLibrary */ void CIN_LoadLibrary( qboolean verbose ) { static cin_import_t import; dllfunc_t funcs[2]; void *( *GetCinematicsAPI )(void *); assert( !cin_libhandle ); import.Print = &CL_CinModule_Print; import.Error = &CL_CinModule_Error; 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.Microseconds = &Sys_Microseconds; import.Mem_AllocPool = &CL_CinModule_MemAllocPool; import.Mem_Alloc = &CL_CinModule_MemAlloc; import.Mem_Free = &CL_CinModule_MemFree; import.Mem_FreePool = &CL_CinModule_MemFreePool; import.Mem_EmptyPool = &CL_CinModule_MemEmptyPool; // load dynamic library cin_export = NULL; if( verbose ) { Com_Printf( "Loading CIN module... " ); } funcs[0].name = "GetCinematicsAPI"; funcs[0].funcPointer = ( void ** ) &GetCinematicsAPI; funcs[1].name = NULL; cin_libhandle = Com_LoadLibrary( LIB_DIRECTORY "/cin_" ARCH LIB_SUFFIX, funcs ); if( cin_libhandle ) { // load succeeded int api_version; cin_export = GetCinematicsAPI( &import ); cin_mempool = Mem_AllocPool( NULL, "CIN Module" ); api_version = cin_export->API(); if( api_version == CIN_API_VERSION ) { if( cin_export->Init( verbose ) ) { if( verbose ) { Com_Printf( "Success.\n" ); } } else { // initialization failed Mem_FreePool( &cin_mempool ); if( verbose ) { Com_Printf( "Initialization failed.\n" ); } CIN_UnloadLibrary( verbose ); } } else { // wrong version Mem_FreePool( &cin_mempool ); Com_Printf( "CIN_LoadLibrary: wrong version: %i, not %i.\n", api_version, CIN_API_VERSION ); CIN_UnloadLibrary( verbose ); } } else { if( verbose ) { Com_Printf( "Not found.\n" ); } } Mem_CheckSentinelsGlobal(); }
/* * 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_GameModule_Init */ void CL_GameModule_Init( void ) { int apiversion, oldState; unsigned int start; cgame_import_t import; void *( *builtinAPIfunc )(void *) = NULL; #ifdef CGAME_HARD_LINKED builtinAPIfunc = GetCGameAPI; #endif // stop all playing sounds CL_SoundModule_StopAllSounds(); CL_GameModule_Shutdown(); // disable reading of client game module chat cvars Cvar_ForceSet( "con_chatCGame", "0" ); cl_gamemodulepool = _Mem_AllocPool( NULL, "Client Game Progs", MEMPOOL_CLIENTGAME, __FILE__, __LINE__ ); import.Error = CL_GameModule_Error; import.Print = CL_GameModule_Print; import.PrintToLog = CL_GameModule_PrintToLog; import.Dynvar_Create = Dynvar_Create; import.Dynvar_Destroy = Dynvar_Destroy; import.Dynvar_Lookup = Dynvar_Lookup; import.Dynvar_GetName = Dynvar_GetName; import.Dynvar_GetValue = Dynvar_GetValue; import.Dynvar_SetValue = Dynvar_SetValue; import.Dynvar_AddListener = Dynvar_AddListener; import.Dynvar_RemoveListener = Dynvar_RemoveListener; 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_TokenizeString = Cmd_TokenizeString; 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_FirstExtension = FS_FirstExtension; import.FS_IsPureFile = FS_IsPureFile; import.FS_MoveFile = FS_MoveFile; import.FS_IsUrl = FS_IsUrl; import.FS_FileMTime = FS_BaseFileMTime; import.FS_RemoveDirectory = FS_RemoveDirectory; import.Key_GetBindingBuf = Key_GetBindingBuf; import.Key_KeynumToString = Key_KeynumToString; import.GetConfigString = CL_GameModule_GetConfigString; import.Milliseconds = Sys_Milliseconds; import.DownloadRequest = CL_DownloadRequest; import.Hash_BlockChecksum = Com_MD5Digest32; import.Hash_SuperFastHash = Com_SuperFastHash; import.NET_GetUserCmd = CL_GameModule_NET_GetUserCmd; import.NET_GetCurrentUserCmdNum = CL_GameModule_NET_GetCurrentUserCmdNum; import.NET_GetCurrentState = CL_GameModule_NET_GetCurrentState; import.RefreshMouseAngles = CL_GameModule_RefreshMouseAngles; import.R_UpdateScreen = SCR_UpdateScreen; import.R_GetClippedFragments = R_GetClippedFragments; import.R_ClearScene = R_ClearScene; import.R_AddEntityToScene = R_AddEntityToScene; import.R_AddLightToScene = R_AddLightToScene; import.R_AddPolyToScene = R_AddPolyToScene; import.R_AddLightStyleToScene = R_AddLightStyleToScene; import.R_RenderScene = R_RenderScene; import.R_SpeedsMessage = R_SpeedsMessage; import.R_RegisterWorldModel = CL_GameModule_R_RegisterWorldModel; import.R_ModelBounds = R_ModelBounds; import.R_ModelFrameBounds = R_ModelFrameBounds; import.R_RegisterModel = R_RegisterModel; import.R_RegisterPic = R_RegisterPic; import.R_RegisterRawPic = R_RegisterRawPic; import.R_RegisterLevelshot = R_RegisterLevelshot; import.R_RegisterSkin = R_RegisterSkin; import.R_RegisterSkinFile = R_RegisterSkinFile; import.R_LerpTag = R_LerpTag; import.R_LightForOrigin = R_LightForOrigin; import.R_SetCustomColor = R_SetCustomColor; import.R_DrawStretchPic = R_DrawStretchPic; import.R_DrawStretchPoly = R_DrawStretchPoly; import.R_DrawRotatedStretchPic = R_DrawRotatedStretchPic; import.R_SetScissorRegion = R_SetScissorRegion; import.R_GetShaderDimensions = R_GetShaderDimensions; import.R_TransformVectorToScreen = R_TransformVectorToScreen; import.R_SkeletalGetNumBones = R_SkeletalGetNumBones; import.R_SkeletalGetBoneInfo = R_SkeletalGetBoneInfo; import.R_SkeletalGetBonePose = R_SkeletalGetBonePose; import.VID_FlashWindow = VID_FlashWindow; import.CM_NumInlineModels = CL_GameModule_CM_NumInlineModels; import.CM_InlineModel = CL_GameModule_CM_InlineModel; import.CM_TransformedBoxTrace = CL_GameModule_CM_TransformedBoxTrace; import.CM_RoundUpToHullSize = CL_GameModule_CM_RoundUpToHullSize; import.CM_TransformedPointContents = CL_GameModule_CM_TransformedPointContents; import.CM_ModelForBBox = CL_GameModule_CM_ModelForBBox; import.CM_OctagonModelForBBox = CL_GameModule_CM_OctagonModelForBBox; import.CM_InlineModelBounds = CL_GameModule_CM_InlineModelBounds; import.S_RegisterSound = CL_SoundModule_RegisterSound; import.S_StartFixedSound = CL_SoundModule_StartFixedSound; import.S_StartRelativeSound = CL_SoundModule_StartRelativeSound; import.S_StartGlobalSound = CL_SoundModule_StartGlobalSound; import.S_Update = CL_GameModule_SoundUpdate; import.S_AddLoopSound = CL_SoundModule_AddLoopSound; import.S_StartBackgroundTrack = CL_SoundModule_StartBackgroundTrack; import.S_StopBackgroundTrack = CL_SoundModule_StopBackgroundTrack; import.SCR_RegisterFont = SCR_RegisterFont; import.SCR_DrawString = SCR_DrawString; import.SCR_DrawStringWidth = SCR_DrawStringWidth; import.SCR_DrawClampString = SCR_DrawClampString; import.SCR_strHeight = SCR_strHeight; import.SCR_strWidth = SCR_strWidth; import.SCR_StrlenForWidth = SCR_StrlenForWidth; import.Mem_Alloc = CL_GameModule_MemAlloc; import.Mem_Free = CL_GameModule_MemFree; cge = (cgame_export_t *)Com_LoadGameLibrary( "cgame", "GetCGameAPI", &module_handle, &import, builtinAPIfunc, cls.sv_pure, NULL ); if( !cge ) Com_Error( ERR_DROP, "Failed to load client game DLL" ); AC_LoadLibrary( (void *) &import, (void *) cge, ANTICHEAT_CLIENT ); // impulZ: Refire AC Init apiversion = cge->API(); if( apiversion != CGAME_API_VERSION ) { Com_UnloadGameLibrary( &module_handle ); Mem_FreePool( &cl_gamemodulepool ); cge = NULL; Com_Error( ERR_DROP, "Client game is version %i, not %i", apiversion, CGAME_API_VERSION ); } oldState = cls.state; cls.state = CA_LOADING; start = Sys_Milliseconds(); cge->Init( cl.playernum, viddef.width, viddef.height, cls.demo.playing, cls.sv_pure, cl.snapFrameTime, APP_PROTOCOL_VERSION, cls.mediaRandomSeed ); Com_DPrintf( "CL_GameModule_Init: %.2f seconds\n", (float)( Sys_Milliseconds() - start ) * 0.001f ); cls.state = oldState; cls.cgameActive = qtrue; // check memory integrity Mem_CheckSentinelsGlobal(); Sys_SendKeyEvents(); // pump message loop }
static void MemStats_f( void ) { Mem_CheckSentinelsGlobal(); Mem_PrintStats(); }