/*
=================
CL_cURL_Init
=================
*/
qboolean CL_cURL_Init()
{
#ifdef USE_CURL_DLOPEN
if(cURLLib)
return qtrue;
Com_Printf("Loading \"%s\"...", cl_cURLLib->string);
if(!(cURLLib = Sys_LoadDll(cl_cURLLib->string, qtrue)))
{
#ifdef ALTERNATE_CURL_LIB
// On some linux distributions there is no libcurl.so.3, but only libcurl.so.4. That one works too.
if(!(cURLLib = Sys_LoadDll(ALTERNATE_CURL_LIB, qtrue)))
#endif
return qfalse;
}
clc.cURLEnabled = qtrue;
qcurl_version = GPA("curl_version");
qcurl_easy_init = GPA("curl_easy_init");
qcurl_easy_setopt = GPA("curl_easy_setopt");
qcurl_easy_perform = GPA("curl_easy_perform");
qcurl_easy_cleanup = GPA("curl_easy_cleanup");
qcurl_easy_getinfo = GPA("curl_easy_getinfo");
qcurl_easy_duphandle = GPA("curl_easy_duphandle");
qcurl_easy_reset = GPA("curl_easy_reset");
qcurl_easy_strerror = GPA("curl_easy_strerror");
qcurl_multi_init = GPA("curl_multi_init");
qcurl_multi_add_handle = GPA("curl_multi_add_handle");
qcurl_multi_remove_handle = GPA("curl_multi_remove_handle");
qcurl_multi_fdset = GPA("curl_multi_fdset");
qcurl_multi_perform = GPA("curl_multi_perform");
qcurl_multi_cleanup = GPA("curl_multi_cleanup");
qcurl_multi_info_read = GPA("curl_multi_info_read");
qcurl_multi_strerror = GPA("curl_multi_strerror");
if(!clc.cURLEnabled)
{
CL_cURL_Shutdown();
Com_Printf("FAIL One or more symbols not found\n");
return qfalse;
}
Com_Printf("OK\n");
return qtrue;
#else
clc.cURLEnabled = qtrue;
return qtrue;
#endif /* USE_CURL_DLOPEN */
}
void SV_BotInitBotLib( void ) {
botlib_import_t botlib_import;
GetBotLibAPI_t GetBotLibAPI;
char dllName[MAX_OSPATH] = "botlib_"ARCH_STRING DLL_EXT;
if( !(botlibLib = Sys_LoadDll( dllName, qfalse )) )
{
Com_Printf( "failed:\n\"%s\"\n", Sys_LibraryError() );
Com_Error( ERR_FATAL, "Failed to load botlib" );
}
GetBotLibAPI = (GetBotLibAPI_t)Sys_LoadFunction( botlibLib, "GetBotLibAPI" );
if ( !GetBotLibAPI )
Com_Error(ERR_FATAL, "Can't load symbol GetBotLibAPI: '%s'", Sys_LibraryError());
if (debugpolygons) Z_Free(debugpolygons);
bot_maxdebugpolys = Cvar_VariableIntegerValue("bot_maxdebugpolys");
debugpolygons = Z_Malloc(sizeof(bot_debugpoly_t) * bot_maxdebugpolys);
botlib_import.Print = BotImport_Print;
botlib_import.Error = Com_Error;
botlib_import.Trace = BotImport_Trace;
botlib_import.EntityTrace = BotImport_EntityTrace;
botlib_import.PointContents = BotImport_PointContents;
botlib_import.inPVS = BotImport_inPVS;
botlib_import.BSPEntityData = BotImport_BSPEntityData;
botlib_import.BSPModelMinsMaxsOrigin = BotImport_BSPModelMinsMaxsOrigin;
botlib_import.BotClientCommand = BotClientCommand;
//memory management
botlib_import.GetMemory = BotImport_GetMemory;
botlib_import.FreeMemory = BotImport_FreeMemory;
botlib_import.AvailableMemory = Z_AvailableMemory;
botlib_import.HunkAlloc = BotImport_HunkAlloc;
// file system access
botlib_import.FS_FOpenFile = FS_FOpenFileByMode;
botlib_import.FS_Read = FS_Read2;
botlib_import.FS_Write = FS_Write;
botlib_import.FS_FCloseFile = FS_FCloseFile;
botlib_import.FS_Seek = FS_Seek;
//debug lines
botlib_import.DebugLineCreate = BotImport_DebugLineCreate;
botlib_import.DebugLineDelete = BotImport_DebugLineDelete;
botlib_import.DebugLineShow = BotImport_DebugLineShow;
//debug polygons
botlib_import.DebugPolygonCreate = BotImport_DebugPolygonCreate;
botlib_import.DebugPolygonDelete = BotImport_DebugPolygonDelete;
botlib_export = (botlib_export_t *)GetBotLibAPI( BOTLIB_API_VERSION, &botlib_import );
assert(botlib_export); // somehow we end up with a zero import.
}
vm_t *VM_Create( const char *module, intptr_t ( *systemCalls )(intptr_t *),
vmInterpret_t interpret ) {
vm_t *vm;
int i;
if ( !module || !module[0] || !systemCalls ) {
Com_Error( ERR_FATAL, "VM_Create: bad parms" );
}
// see if we already have the VM
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !Q_stricmp( vmTable[i].name, module ) ) {
vm = &vmTable[i];
return vm;
}
}
// find a free vm
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !vmTable[i].name[0] ) {
break;
}
}
if ( i == MAX_VM ) {
Com_Error( ERR_FATAL, "VM_Create: no free vm_t" );
}
vm = &vmTable[i];
Q_strncpyz( vm->name, module, sizeof( vm->name ) );
vm->systemCall = systemCalls;
if ( interpret == VMI_NATIVE ) {
// try to load as a system dll
//vm->dllHandle = Sys_LoadDll( module, vm->fqpath, &vm->entryPoint, VM_DllSyscall );
vm->dllHandle = Sys_LoadDll( module, &vm->entryPoint, VM_DllSyscall );
if ( vm->dllHandle ) {
return vm;
}
Com_Printf( "Failed to load dll.\n" );
return NULL;
}
else
{
return NULL;
}
return NULL;
}
/*
================
VM_Create
================
*/
vm_t *VM_Create( const char *module, intptr_t ( *systemCalls )(intptr_t *), vmInterpret_t interpret ) {
vm_t *vm;
int i, remaining;
if ( !module || !module[0] || !systemCalls ) {
Com_Error( ERR_FATAL, "VM_Create: bad parms" );
}
remaining = Hunk_MemoryRemaining();
// see if we already have the VM
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !Q_stricmp( vmTable[i].name, module ) ) {
vm = &vmTable[i];
return vm;
}
}
// find a free vm
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !vmTable[i].name[0] ) {
break;
}
}
if ( i == MAX_VM ) {
Com_Error( ERR_FATAL, "VM_Create: no free vm_t" );
}
vm = &vmTable[i];
Q_strncpyz( vm->name, module, sizeof( vm->name ) );
vm->systemCall = systemCalls;
if ( interpret == VMI_NATIVE ) {
// try to load as a system dll
Com_Printf("Loading dll file '%s'.\n", vm->name);
vm->dllHandle = Sys_LoadDll( module, vm->fqpath, &vm->entryPoint, VM_DllSyscall );
if ( vm->dllHandle ) {
vm->systemCall = systemCalls;
return vm;
}
Com_Printf("Failed loading DLL.\n");
}
Com_Printf("%s loaded in %d bytes on the hunk\n", module, remaining - Hunk_MemoryRemaining());
return NULL;
}
vm_t *VM_Create( const char *module, int (*systemCalls)(int *) ) {
vm_t *vm;
int length;
int dataLength;
int i, remaining;
char filename[MAX_QPATH];
if ( !module || !module[0] || !systemCalls ) {
Com_Error( ERR_FATAL, "VM_Create: bad parms" );
}
remaining = Hunk_MemoryRemaining();
// see if we already have the VM
for ( i = 0 ; i < MAX_VM ; i++ ) {
if (!Q_stricmp(vmTable[i].name, module)) {
vm = &vmTable[i];
return vm;
}
}
// find a free vm
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !vmTable[i].name[0] ) {
break;
}
}
if ( i == MAX_VM ) {
Com_Error( ERR_FATAL, "VM_Create: no free vm_t" );
}
vm = &vmTable[i];
Q_strncpyz( vm->name, module, sizeof( vm->name ) );
vm->systemCall = systemCalls;
// try to load as a system dll
Com_Printf( "Loading dll file %s.\n", vm->name );
vm->dllHandle = Sys_LoadDll( module, vm->fqpath , &vm->entryPoint, VM_DllSyscall );
if ( vm->dllHandle ) {
return vm;
}
Com_Error( ERR_FATAL, "Unable to load %s.", vm->name );
}
vm_t *VM_Create( const char *module, int (*systemCalls)(int *),
vmInterpret_t interpret ) {
vm_t *vm;
vmHeader_t *header;
int length;
int dataLength;
int i, remaining;
char filename[MAX_QPATH];
if ( !module || !module[0] || !systemCalls ) {
Com_Error( ERR_FATAL, "VM_Create: bad parms" );
}
remaining = Hunk_MemoryRemaining();
// see if we already have the VM
for ( i = 0 ; i < MAX_VM ; i++ ) {
if (!Q_stricmp(vmTable[i].name, module)) {
vm = &vmTable[i];
return vm;
}
}
// find a free vm
for ( i = 0 ; i < MAX_VM ; i++ ) {
if ( !vmTable[i].name[0] ) {
break;
}
}
if ( i == MAX_VM ) {
Com_Error( ERR_FATAL, "VM_Create: no free vm_t" );
}
vm = &vmTable[i];
Q_strncpyz( vm->name, module, sizeof( vm->name ) );
vm->systemCall = systemCalls;
// never allow dll loading with a demo
if ( interpret == VMI_NATIVE ) {
if ( Cvar_VariableValue( "fs_restrict" ) ) {
interpret = VMI_COMPILED;
}
}
if ( interpret == VMI_NATIVE ) {
// try to load as a system dll
Com_Printf( "Loading dll file %s.\n", vm->name );
vm->dllHandle = Sys_LoadDll( module, vm->fqpath , &vm->entryPoint, VM_DllSyscall );
if ( vm->dllHandle ) {
return vm;
}
Com_Printf( "Failed to load dll, looking for qvm.\n" );
interpret = VMI_COMPILED;
}
// load the image
Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
Com_Printf( "Loading vm file %s.\n", filename );
length = FS_ReadFile( filename, (void **)&header );
if ( !header ) {
Com_Printf( "Failed.\n" );
VM_Free( vm );
return NULL;
}
// byte swap the header
for ( i = 0 ; i < sizeof( *header ) / 4 ; i++ ) {
((int *)header)[i] = LittleLong( ((int *)header)[i] );
}
// validate
if ( header->vmMagic != VM_MAGIC
|| header->bssLength < 0
|| header->dataLength < 0
|| header->litLength < 0
|| header->codeLength <= 0 ) {
VM_Free( vm );
Com_Error( ERR_FATAL, "%s has bad header", filename );
}
// round up to next power of 2 so all data operations can
// be mask protected
dataLength = header->dataLength + header->litLength + header->bssLength;
for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) {
}
dataLength = 1 << i;
// allocate zero filled space for initialized and uninitialized data
vm->dataBase = Hunk_Alloc( dataLength, h_high );
vm->dataMask = dataLength - 1;
// copy the intialized data
Com_Memcpy( vm->dataBase, (byte *)header + header->dataOffset, header->dataLength + header->litLength );
// byte swap the longs
for ( i = 0 ; i < header->dataLength ; i += 4 ) {
*(int *)(vm->dataBase + i) = LittleLong( *(int *)(vm->dataBase + i ) );
}
// allocate space for the jump targets, which will be filled in by the compile/prep functions
vm->instructionPointersLength = header->instructionCount * 4;
vm->instructionPointers = Hunk_Alloc( vm->instructionPointersLength, h_high );
// copy or compile the instructions
vm->codeLength = header->codeLength;
if ( interpret >= VMI_COMPILED ) {
vm->compiled = qtrue;
VM_Compile( vm, header );
} else {
vm->compiled = qfalse;
VM_PrepareInterpreter( vm, header );
}
// free the original file
FS_FreeFile( header );
// load the map file
VM_LoadSymbols( vm );
// the stack is implicitly at the end of the image
vm->programStack = vm->dataMask + 1;
vm->stackBottom = vm->programStack - STACK_SIZE;
Com_Printf("%s loaded in %d bytes on the hunk\n", module, remaining - Hunk_MemoryRemaining());
return vm;
}
/*
=======================================================================================================================================
QAL_Init
=======================================================================================================================================
*/
qboolean QAL_Init(const char *libname) {
if (OpenALLib) {
return qtrue;
}
if (!(OpenALLib = Sys_LoadDll(libname, qtrue)))
return qfalse;
alinit_fail = qfalse;
qalEnable = GPA("alEnable");
qalDisable = GPA("alDisable");
qalIsEnabled = GPA("alIsEnabled");
qalGetString = GPA("alGetString");
qalGetBooleanv = GPA("alGetBooleanv");
qalGetIntegerv = GPA("alGetIntegerv");
qalGetFloatv = GPA("alGetFloatv");
qalGetDoublev = GPA("alGetDoublev");
qalGetBoolean = GPA("alGetBoolean");
qalGetInteger = GPA("alGetInteger");
qalGetFloat = GPA("alGetFloat");
qalGetDouble = GPA("alGetDouble");
qalGetError = GPA("alGetError");
qalIsExtensionPresent = GPA("alIsExtensionPresent");
qalGetProcAddress = GPA("alGetProcAddress");
qalGetEnumValue = GPA("alGetEnumValue");
qalListenerf = GPA("alListenerf");
qalListener3f = GPA("alListener3f");
qalListenerfv = GPA("alListenerfv");
qalListeneri = GPA("alListeneri");
qalGetListenerf = GPA("alGetListenerf");
qalGetListener3f = GPA("alGetListener3f");
qalGetListenerfv = GPA("alGetListenerfv");
qalGetListeneri = GPA("alGetListeneri");
qalGenSources = GPA("alGenSources");
qalDeleteSources = GPA("alDeleteSources");
qalIsSource = GPA("alIsSource");
qalSourcef = GPA("alSourcef");
qalSource3f = GPA("alSource3f");
qalSourcefv = GPA("alSourcefv");
qalSourcei = GPA("alSourcei");
qalGetSourcef = GPA("alGetSourcef");
qalGetSource3f = GPA("alGetSource3f");
qalGetSourcefv = GPA("alGetSourcefv");
qalGetSourcei = GPA("alGetSourcei");
qalSourcePlayv = GPA("alSourcePlayv");
qalSourceStopv = GPA("alSourceStopv");
qalSourceRewindv = GPA("alSourceRewindv");
qalSourcePausev = GPA("alSourcePausev");
qalSourcePlay = GPA("alSourcePlay");
qalSourceStop = GPA("alSourceStop");
qalSourceRewind = GPA("alSourceRewind");
qalSourcePause = GPA("alSourcePause");
qalSourceQueueBuffers = GPA("alSourceQueueBuffers");
qalSourceUnqueueBuffers = GPA("alSourceUnqueueBuffers");
qalGenBuffers = GPA("alGenBuffers");
qalDeleteBuffers = GPA("alDeleteBuffers");
qalIsBuffer = GPA("alIsBuffer");
qalBufferData = GPA("alBufferData");
qalGetBufferf = GPA("alGetBufferf");
qalGetBufferi = GPA("alGetBufferi");
qalDopplerFactor = GPA("alDopplerFactor");
qalSpeedOfSound = GPA("alSpeedOfSound");
qalDistanceModel = GPA("alDistanceModel");
qalcCreateContext = GPA("alcCreateContext");
qalcMakeContextCurrent = GPA("alcMakeContextCurrent");
qalcProcessContext = GPA("alcProcessContext");
qalcSuspendContext = GPA("alcSuspendContext");
qalcDestroyContext = GPA("alcDestroyContext");
qalcGetCurrentContext = GPA("alcGetCurrentContext");
qalcGetContextsDevice = GPA("alcGetContextsDevice");
qalcOpenDevice = GPA("alcOpenDevice");
qalcCloseDevice = GPA("alcCloseDevice");
qalcGetError = GPA("alcGetError");
qalcIsExtensionPresent = GPA("alcIsExtensionPresent");
qalcGetProcAddress = GPA("alcGetProcAddress");
qalcGetEnumValue = GPA("alcGetEnumValue");
qalcGetString = GPA("alcGetString");
qalcGetIntegerv = GPA("alcGetIntegerv");
qalcCaptureOpenDevice = GPA("alcCaptureOpenDevice");
qalcCaptureCloseDevice = GPA("alcCaptureCloseDevice");
qalcCaptureStart = GPA("alcCaptureStart");
qalcCaptureStop = GPA("alcCaptureStop");
qalcCaptureSamples = GPA("alcCaptureSamples");
if (alinit_fail) {
QAL_Shutdown();
Com_Printf(" One or more symbols not found\n");
return qfalse;
}
return qtrue;
}
void CL_InitRef( void ) {
refexport_t *ret;
refimport_t rit;
char dllName[MAX_OSPATH];
GetRefAPI_t GetRefAPI;
Com_Printf( "----- Initializing Renderer ----\n" );
cl_renderer = Cvar_Get( "cl_renderer", DEFAULT_RENDER_LIBRARY, CVAR_ARCHIVE|CVAR_LATCH );
Com_sprintf( dllName, sizeof( dllName ), "%s_" ARCH_STRING DLL_EXT, cl_renderer->string );
if( !(rendererLib = Sys_LoadDll( dllName, qfalse )) && strcmp( cl_renderer->string, cl_renderer->resetString ) )
{
Com_Printf( "failed: trying to load fallback renderer\n" );
Cvar_ForceReset( "cl_renderer" );
Com_sprintf( dllName, sizeof( dllName ), DEFAULT_RENDER_LIBRARY "_" ARCH_STRING DLL_EXT );
rendererLib = Sys_LoadDll( dllName, qfalse );
}
if ( !rendererLib ) {
Com_Error( ERR_FATAL, "Failed to load renderer" );
}
GetRefAPI = (GetRefAPI_t)Sys_LoadFunction( rendererLib, "GetRefAPI" );
if ( !GetRefAPI )
Com_Error( ERR_FATAL, "Can't load symbol GetRefAPI: '%s'", Sys_LibraryError() );
#define RIT(y) rit.y = y
RIT(CIN_PlayCinematic);
RIT(CIN_RunCinematic);
RIT(CIN_UploadCinematic);
RIT(CL_IsRunningInGameCinematic);
RIT(Cmd_AddCommand);
RIT(Cmd_Argc);
RIT(Cmd_ArgsBuffer);
RIT(Cmd_Argv);
RIT(Cmd_ExecuteString);
RIT(Cmd_RemoveCommand);
RIT(CM_ClusterPVS);
RIT(CM_CullWorldBox);
RIT(CM_DeleteCachedMap);
RIT(CM_DrawDebugSurface);
RIT(CM_PointContents);
RIT(CM_RegisterTerrain);
RIT(CM_ShutdownTerrain);
RIT(CM_TerrainPatchIterate);
RIT(Cvar_Get);
RIT(Cvar_Set);
RIT(Cvar_SetValue);
RIT(Cvar_VariableIntegerValue);
RIT(Cvar_VariableString);
RIT(Cvar_VariableStringBuffer);
RIT(Cvar_VariableValue);
RIT(FS_FCloseFile);
RIT(FS_FileIsInPAK);
RIT(FS_FOpenFileByMode);
RIT(FS_FOpenFileRead);
RIT(FS_FOpenFileWrite);
RIT(FS_FreeFile);
RIT(FS_FreeFileList);
RIT(FS_ListFiles);
RIT(FS_Read);
RIT(FS_ReadFile);
RIT(FS_Write);
RIT(FS_WriteFile);
RIT(Hunk_ClearToMark);
RIT(SG_Append);
RIT(SND_RegisterAudio_LevelLoadEnd);
RIT(SV_GetConfigstring);
//RIT(SV_PointContents);
RIT(SV_SetConfigstring);
RIT(SV_Trace);
RIT(S_RestartMusic);
RIT(Z_Free);
RIT(Z_Malloc);
RIT(Z_MemSize);
RIT(Z_MorphMallocTag);
RIT(Hunk_ClearToMark);
#ifndef _WIN32
RIT(IN_Init);
RIT(IN_Shutdown);
RIT(IN_Restart);
#endif
// Not-so-nice usage / doesn't go along with my epic macro
rit.Error = Com_Error;
rit.FS_FileExists = S_FileExists;
rit.GetG2VertSpaceServer = GetG2VertSpaceServer;
#ifdef _WIN32
rit.GetWinVars = GetWindowsVariables;
#endif
rit.LowPhysicalMemory = Sys_LowPhysicalMemory;
rit.Milliseconds = Sys_Milliseconds;
rit.Printf = CL_RefPrintf;
rit.SE_GetString = String_GetStringValue;
rit.CM_ShaderTableCleanup = ShaderTableCleanup;
rit.SV_Trace = SV_Trace;
rit.gpvCachedMapDiskImage = get_gpvCachedMapDiskImage;
rit.gsCachedMapDiskImage = get_gsCachedMapDiskImage;
rit.gbUsingCachedMapDataRightNow = get_gbUsingCachedMapDataRightNow;
rit.gbAlreadyDoingLoad = get_gbAlreadyDoingLoad;
rit.com_frameTime = get_com_frameTime;
rit.SV_PointContents = SV_PointContents;
ret = GetRefAPI( REF_API_VERSION, &rit );
if ( !ret ) {
Com_Error (ERR_FATAL, "Couldn't initialize refresh" );
}
re = *ret;
Com_Printf( "-------------------------------\n");
// unpause so the cgame definately gets a snapshot and renders a frame
Cvar_Set( "cl_paused", "0" );
}
void CL_InitRef( void ) {
refexport_t *ret;
static refimport_t rit;
char dllName[MAX_OSPATH];
GetRefAPI_t GetRefAPI;
Com_Printf( "----- Initializing Renderer ----\n" );
cl_renderer = Cvar_Get( "cl_renderer", DEFAULT_RENDER_LIBRARY, CVAR_ARCHIVE|CVAR_LATCH|CVAR_PROTECTED );
Com_sprintf( dllName, sizeof( dllName ), "%s_" ARCH_STRING DLL_EXT, cl_renderer->string );
if( !(rendererLib = Sys_LoadDll( dllName, qfalse )) && strcmp( cl_renderer->string, cl_renderer->resetString ) )
{
Com_Printf( "failed: trying to load fallback renderer\n" );
Cvar_ForceReset( "cl_renderer" );
Com_sprintf( dllName, sizeof( dllName ), DEFAULT_RENDER_LIBRARY "_" ARCH_STRING DLL_EXT );
rendererLib = Sys_LoadDll( dllName, qfalse );
}
if ( !rendererLib ) {
Com_Error( ERR_FATAL, "Failed to load renderer\n" );
}
memset( &rit, 0, sizeof( rit ) );
GetRefAPI = (GetRefAPI_t)Sys_LoadFunction( rendererLib, "GetRefAPI" );
if ( !GetRefAPI )
Com_Error( ERR_FATAL, "Can't load symbol GetRefAPI: '%s'", Sys_LibraryError() );
#define RIT(y) rit.y = y
RIT(CIN_PlayCinematic);
RIT(CIN_RunCinematic);
RIT(CIN_UploadCinematic);
RIT(CL_IsRunningInGameCinematic);
RIT(Cmd_AddCommand);
RIT(Cmd_Argc);
RIT(Cmd_ArgsBuffer);
RIT(Cmd_Argv);
RIT(Cmd_ExecuteString);
RIT(Cmd_RemoveCommand);
RIT(CM_ClusterPVS);
RIT(CM_CullWorldBox);
RIT(CM_DeleteCachedMap);
RIT(CM_DrawDebugSurface);
RIT(CM_PointContents);
RIT(Cvar_Get);
RIT(Cvar_Set);
RIT(Cvar_SetValue);
RIT(Cvar_CheckRange);
RIT(Cvar_VariableIntegerValue);
RIT(Cvar_VariableString);
RIT(Cvar_VariableStringBuffer);
RIT(Cvar_VariableValue);
RIT(FS_FCloseFile);
RIT(FS_FileIsInPAK);
RIT(FS_FOpenFileByMode);
RIT(FS_FOpenFileRead);
RIT(FS_FOpenFileWrite);
RIT(FS_FreeFile);
RIT(FS_FreeFileList);
RIT(FS_ListFiles);
RIT(FS_Read);
RIT(FS_ReadFile);
RIT(FS_Write);
RIT(FS_WriteFile);
RIT(Hunk_ClearToMark);
RIT(SND_RegisterAudio_LevelLoadEnd);
//RIT(SV_PointContents);
RIT(SV_Trace);
RIT(S_RestartMusic);
RIT(Z_Free);
rit.Malloc=CL_Malloc;
RIT(Z_MemSize);
RIT(Z_MorphMallocTag);
RIT(Hunk_ClearToMark);
rit.WIN_Init = WIN_Init;
rit.WIN_SetGamma = WIN_SetGamma;
rit.WIN_Shutdown = WIN_Shutdown;
rit.WIN_Present = WIN_Present;
rit.GL_GetProcAddress = WIN_GL_GetProcAddress;
rit.GL_ExtensionSupported = WIN_GL_ExtensionSupported;
rit.PD_Load = PD_Load;
rit.PD_Store = PD_Store;
rit.Error = Com_Error;
rit.FS_FileExists = S_FileExists;
rit.GetG2VertSpaceServer = GetG2VertSpaceServer;
rit.LowPhysicalMemory = Sys_LowPhysicalMemory;
rit.Milliseconds = Sys_Milliseconds2;
rit.Printf = CL_RefPrintf;
rit.SE_GetString = String_GetStringValue;
rit.SV_Trace = SV_Trace;
rit.gpvCachedMapDiskImage = get_gpvCachedMapDiskImage;
rit.gsCachedMapDiskImage = get_gsCachedMapDiskImage;
rit.gbUsingCachedMapDataRightNow = get_gbUsingCachedMapDataRightNow;
rit.gbAlreadyDoingLoad = get_gbAlreadyDoingLoad;
rit.com_frameTime = get_com_frameTime;
rit.SV_PointContents = SV_PointContents;
rit.saved_game = &ojk::SavedGame::get_instance();
ret = GetRefAPI( REF_API_VERSION, &rit );
if ( !ret ) {
Com_Error (ERR_FATAL, "Couldn't initialize refresh" );
}
re = *ret;
Com_Printf( "-------------------------------\n");
// unpause so the cgame definately gets a snapshot and renders a frame
Cvar_Set( "cl_paused", "0" );
}