int Start(lua_State *L) { CreateInterfaceFn interfaceFactory = Sys_GetFactory( ENGINE_LIB ); CreateInterfaceFn gameServerFactory = Sys_GetFactory( SERVER_LIB ); CreateInterfaceFn physicsFactory = Sys_GetFactory( VPHYSICS_LIB ); surfaceprop = (IPhysicsSurfaceProps*)physicsFactory(VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL); engine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL); ILuaInterface *gLua = Lua(); ILuaObject *vmeta = gLua->GetMetaTable("Vehicle", GLua::TYPE_ENTITY); vmeta->SetMember("GetOperatingParams", getoperatingparams); vmeta->SetMember("GetVehicleParams", getvehicleparams); vmeta->SetMember("SetVehicleParams", setvehicleparams); vmeta->SetMember("SetWheelMaterial", SetWheelMaterial); vmeta->SetMember("GetWheelMaterial", GetWheelMaterial); vmeta->UnReference(); gLua->SetGlobal("GetUcmdButtons", GetUcmdButtons); gLua->SetGlobal("SetUcmdButtons", SetUcmdButtons); return 0; }
int Open(lua_State *L) { ml_Lua = Lua(); CreateInterfaceFn g_pEngineFactory = Sys_GetFactory("engine.dll"); //Engine g_pEngine = (IVEngineClient*)g_pEngineFactory(VENGINE_CLIENT_INTERFACE_VERSION, NULL); if (!g_pEngine) { ml_Lua->Msg("[gmcl_replicator] Can't get IVEngineClient interface " VENGINE_CLIENT_INTERFACE_VERSION " :(\n"); return 0; } CreateInterfaceFn VSTDLibFactory = Sys_GetFactory("vstdlib.dll"); if (!VSTDLibFactory) { ml_Lua->Msg("[gmcl_replicator] Error getting vstdlib.dll factory.\n"); return 0; } g_ICvar = (ICvar*)VSTDLibFactory(CVAR_INTERFACE_VERSION, NULL); if (!g_ICvar) { ml_Lua->Msg("[gmcl_replicator] Error getting ICvar " CVAR_INTERFACE_VERSION " interface.\n"); return 0; } ml_Lua->NewGlobalTable("replicator"); ILuaObject* replicator = ml_Lua->GetGlobal("replicator"); replicator->SetMember("ConCommand", DoClientCommand); replicator->SetMember("GetAllConVars", GetAllCvars); replicator->SetMember("GetAllConCommands", GetAllCmds); replicator->SetMember("GetConCommand", GetCommand); replicator->UnReference(); ml_Lua->SetGlobal("FCVAR_DEVELOPMENTONLY", (float) FCVAR_DEVELOPMENTONLY); ml_Lua->SetGlobal("FCVAR_HIDDEN", (float) FCVAR_HIDDEN); ILuaObject* conVarMeta = ml_Lua->GetMetaTable("ConVar", GLua::TYPE_CONVAR); if (conVarMeta) { conVarMeta->SetMember("SetValue", SetConVarValue); //conVarMeta->SetMember("GetBool", GetConVarBool); conVarMeta->SetMember("GetDefault", GetConVarDefault); conVarMeta->SetMember("GetFloat", GetConVarFloat); //conVarMeta->SetMember("GetInt", GetConVarInt); conVarMeta->SetMember("GetName", GetConVarName); conVarMeta->SetMember("SetName", SetConVarName); //conVarMeta->SetMember("GetString", GetConVarString); conVarMeta->SetMember("SetFlags", SetConVarFlags); conVarMeta->SetMember("GetFlags", GetConVarFlags); conVarMeta->SetMember("HasFlag", ConVarHasFlag); conVarMeta->SetMember("SetHelpText", SetConVarHelpText); //conVarMeta->SetMember("GetHelpText", GetConVarHelpText); conVarMeta->SetMember("Reset", ResetConVarValue); conVarMeta->SetMember("Remove", RemoveConVar); conVarMeta->SetMember("__tostring", __tostring); conVarMeta->SetMember("__eq", __eq); conVarMeta->SetMember("__index", conVarMeta); } conVarMeta->UnReference(); return 0; }
int main( int argc, char **argv ) { const char *pModuleName = "vtex_dll.dll"; CSysModule *pModule = Sys_LoadModule( pModuleName ); if ( !pModule ) { printf( "Can't load %s.", pModuleName ); return false; } CreateInterfaceFn fn = Sys_GetFactory( pModule ); if ( !fn ) { printf( "Can't get factory from %s.", pModuleName ); Sys_UnloadModule( pModule ); return false; } ILaunchableDLL *pInterface = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, NULL ); if ( !pInterface ) { printf( "Can't get '%s' interface from %s.", LAUNCHABLE_DLL_INTERFACE_VERSION, pModuleName ); Sys_UnloadModule( pModule ); return false; } int iRet = pInterface->main( argc, argv ); Sys_UnloadModule( pModule ); return iRet; }
void RunInDLL( const char *pFilename, CUtlVector<char*> &newArgv ) { if ( g_pConnMgr ) g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_BUSY ); bool bSuccess = false; CSysModule *pModule = Sys_LoadModule( pFilename ); if ( pModule ) { CreateInterfaceFn fn = Sys_GetFactory( pModule ); if ( fn ) { ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, NULL ); if( pDLL ) { // Do this here because the executables we would have launched usually would do it. CommandLine()->CreateCmdLine( newArgv.Count(), newArgv.Base() ); pDLL->main( newArgv.Count(), newArgv.Base() ); bSuccess = true; SpewOutputFunc( MySpewOutputFunc ); } } Sys_UnloadModule( pModule ); } if ( !bSuccess ) { Msg( "Error running VRAD (or VVIS) out of DLL '%s'\n", pFilename ); } if ( g_pConnMgr ) g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE ); }
void LoadMaterialSystemInterface( CreateInterfaceFn fileSystemFactory ) { if( g_pMaterialSystem ) return; // materialsystem.dll should be in the path, it's in bin along with vbsp. const char *pDllName = "materialsystem.dll"; CSysModule *materialSystemDLLHInst; materialSystemDLLHInst = g_pFullFileSystem->LoadModule( pDllName ); if( !materialSystemDLLHInst ) { Error( "Can't load MaterialSystem.dll\n" ); } CreateInterfaceFn clientFactory = Sys_GetFactory( materialSystemDLLHInst ); if ( clientFactory ) { g_pMaterialSystem = (IMaterialSystem *)clientFactory( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL ); if ( !g_pMaterialSystem ) { Error( "Could not get the material system interface from materialsystem.dll (" __FILE__ ")" ); } } else { Error( "Could not find factory interface in library MaterialSystem.dll" ); } if (!g_pMaterialSystem->Init( "shaderapiempty.dll", 0, fileSystemFactory )) { Error( "Could not start the empty shader (shaderapiempty.dll)!" ); } }
//----------------------------------------------------------------------------- // Purpose: Application entry point // Loads and runs the TrackerSRV //----------------------------------------------------------------------------- int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) { // winsock aware WSAData wsaData; int nReturnCode = ::WSAStartup(MAKEWORD(2,0), &wsaData); // load the Tracker Server DLL CSysModule *serverDll = Sys_LoadModule("TrackerSRV.dll"); CreateInterfaceFn serverFactory = Sys_GetFactory(serverDll); if (!serverFactory) { ::MessageBox(NULL, "Could not load 'TrackerSRV.dll'", "Fatal Error - TrackerServer", MB_OK | MB_ICONERROR); return 1; } ITrackerSRV *trackerInterface = (ITrackerSRV *)serverFactory(TRACKERSERVER_INTERFACE_VERSION, NULL); // Activate server trackerInterface->RunTrackerServer(lpCmdLine); Sys_UnloadModule(serverDll); ::WSACleanup(); return 0; }
int CL_DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion ) { gEngfuncs = *pEnginefuncs; RecClInitialize(pEnginefuncs, iVersion); if (iVersion != CLDLL_INTERFACE_VERSION) return 0; memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t)); EV_HookEvents(); // get tracker interface, if any char szDir[512]; if (!gEngfuncs.COM_ExpandFilename("Bin/TrackerUI.dll", szDir, sizeof(szDir))) { g_pTrackerUser = NULL; g_hTrackerModule = NULL; return 1; } g_hTrackerModule = Sys_LoadModule(szDir); CreateInterfaceFn trackerFactory = Sys_GetFactory(g_hTrackerModule); if (!trackerFactory) { g_pTrackerUser = NULL; g_hTrackerModule = NULL; return 1; } g_pTrackerUser = (ITrackerUser *)trackerFactory(TRACKERUSER_INTERFACE_VERSION, NULL); return 1; }
void CL_LoadParticleMan( void ) { char szPDir[512]; if ( gEngfuncs.COM_ExpandFilename( PARTICLEMAN_DLLNAME, szPDir, sizeof( szPDir ) ) == FALSE ) { g_pParticleMan = NULL; g_hParticleManModule = NULL; return; } g_hParticleManModule = Sys_LoadModule( szPDir ); CreateInterfaceFn particleManFactory = Sys_GetFactory( g_hParticleManModule ); if ( particleManFactory == NULL ) { g_pParticleMan = NULL; g_hParticleManModule = NULL; return; } g_pParticleMan = (IParticleMan *)particleManFactory( PARTICLEMAN_INTERFACE, NULL); if ( g_pParticleMan ) { g_pParticleMan->SetUp( &gEngfuncs ); // Add custom particle classes here BEFORE calling anything else or you will die. g_pParticleMan->AddCustomParticleClassSize ( sizeof ( CBaseParticle ) ); } }
void InitStudioRender( void ) { if ( g_pStudioRenderModule ) return; Assert( g_MatSysFactory ); g_pStudioRenderModule = g_pFullFileSystem->LoadModule( "StudioRender.dll" ); if( !g_pStudioRenderModule ) { MdlError( "Can't load StudioRender.dll\n" ); } CreateInterfaceFn studioRenderFactory = Sys_GetFactory( g_pStudioRenderModule ); if (!studioRenderFactory ) { MdlError( "Can't get factory for StudioRender.dll\n" ); } g_pStudioRender = ( IStudioRender * )studioRenderFactory( STUDIO_RENDER_INTERFACE_VERSION, NULL ); if (!g_pStudioRender) { MdlError( "Unable to init studio render system version %s\n", STUDIO_RENDER_INTERFACE_VERSION ); } g_pStudioRender->Init( g_MatSysFactory, g_ShaderAPIFactory, g_ShaderAPIFactory, Sys_GetFactoryThis() ); UpdateStudioRenderConfig(); }
void FileFilter_Load() { CreateInterfaceFn engineFactory = Sys_GetFactory("engine.dll"); netstringtables = (INetworkStringTableContainer *)engineFactory(INTERFACENAME_NETWORKSTRINGTABLESERVER, NULL); if(netstringtables == NULL) { Msg("Unable to find string tables!\n"); return; } CSigScan::sigscan_dllfunc = engineFactory; bool scan = CSigScan::GetDllMemInfo(); sigcheckfileext_Sig.Init((unsigned char *)SIG_CHECKFILE, SIG_CHECKFILEMASK, SIG_CHECKFILELEN); Msg("CheckFile signature %x\n", sigcheckfileext_Sig.sig_addr); if(sigcheckfileext_Sig.sig_addr) { checkext_trampoline = (checkext_t)sigcheckfileext_Sig.sig_addr; DetourTransactionBegin(); DetourUpdateThread(GetCurrentThread()); DetourAttach(&(PVOID&)checkext_trampoline, (PVOID)(&(PVOID&)checkext_hook)); DetourTransactionCommit(); } else { Msg("Couldn't find CheckFile function!\n"); return; } }
int main(int argc, char* argv[]) { CommandLine()->CreateCmdLine( argc, argv ); const char *pDLLName = "vvis_dll.dll"; CSysModule *pModule = Sys_LoadModule( pDLLName ); if ( !pModule ) { printf( "vvis launcher error: can't load %s\n%s", pDLLName, GetLastErrorString() ); return 1; } CreateInterfaceFn fn = Sys_GetFactory( pModule ); if( !fn ) { printf( "vvis launcher error: can't get factory from %s\n", pDLLName ); Sys_UnloadModule( pModule ); return 2; } int retCode = 0; ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, &retCode ); if( !pDLL ) { printf( "vvis launcher error: can't get IVVisDLL interface from %s\n", pDLLName ); Sys_UnloadModule( pModule ); return 3; } pDLL->main( argc, argv ); Sys_UnloadModule( pModule ); return 0; }
//----------------------------------------------------------------------------- // Purpose: get the interface for the specified module and version // Input : // Output : //----------------------------------------------------------------------------- bool Sys_LoadInterface( const char *pModuleName, const char *pInterfaceVersionName, CSysModule **pOutModule, void **pOutInterface ) { CSysModule *pMod = Sys_LoadModule( pModuleName ); if ( !pMod ) return false; CreateInterfaceFn fn = Sys_GetFactory( pMod ); if ( !fn ) { Sys_UnloadModule( pMod ); return false; } *pOutInterface = fn( pInterfaceVersionName, NULL ); if ( !( *pOutInterface ) ) { Sys_UnloadModule( pMod ); return false; } if ( pOutModule ) *pOutModule = pMod; return true; }
static void LoadMaterialSystem( void ) { if( g_pMaterialSystem ) return; const char *pDllName = "materialsystem.dll"; CSysModule *materialSystemDLLHInst; materialSystemDLLHInst = g_pFullFileSystem->LoadModule( pDllName ); if( !materialSystemDLLHInst ) { MdlError( "Can't load MaterialSystem.dll\n" ); } g_MatSysFactory = Sys_GetFactory( materialSystemDLLHInst ); if ( g_MatSysFactory ) { g_pMaterialSystem = (IMaterialSystem *)g_MatSysFactory( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL ); if ( !g_pMaterialSystem ) { MdlError( "Could not get the material system interface from materialsystem.dll" ); } } else { MdlError( "Could not find factory interface in library MaterialSystem.dll" ); } if (!( g_ShaderAPIFactory = g_pMaterialSystem->Init( "shaderapiempty.dll", 0, CmdLib_GetFileSystemFactory() )) ) { MdlError( "Could not start the empty shader (shaderapiempty.dll)!" ); } }
bool LoadShaderDLL( const char *pFilename ) { // Load the new shader CSysModule *hInstance = g_pFullFileSystem->LoadModule( pFilename ); if ( !hInstance ) return false; // Get at the shader DLL interface CreateInterfaceFn factory = Sys_GetFactory( hInstance ); if (!factory) { g_pFullFileSystem->UnloadModule( hInstance ); return false; } IShaderDLLInternal *pShaderDLL = (IShaderDLLInternal*)factory( SHADER_DLL_INTERFACE_VERSION, NULL ); if ( !pShaderDLL ) { g_pFullFileSystem->UnloadModule( hInstance ); return false; } CShaderDLLInfo *pOut = &g_ShaderDLLs[ g_ShaderDLLs.AddToTail() ]; pOut->m_pInternal = pShaderDLL; Q_strncpy( pOut->m_Filename, pFilename, sizeof( pOut->m_Filename ) ); return true; }
CreateInterfaceFn FileSystem_GetFactory() { #if defined( MPI ) if ( g_bUseMPI ) return VMPI_FileSystem_GetFactory(); #endif return Sys_GetFactory( g_pFullFileSystemModule ); }
int EXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion ) { gEngfuncs = *pEnginefuncs; //!!! mwh UNDONE We need to think about our versioning strategy. Do we want to try to be compatible // with previous versions, especially when we're only 'bonus' functionality? Should it be the engine // that decides if the DLL is compliant? if (iVersion != CLDLL_INTERFACE_VERSION) return 0; memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t)); EV_HookEvents(); // Determine which filesystem to use. #if defined ( _WIN32 ) char *szFsModule = "filesystem_stdio.dll"; #elif defined(OSX) char *szFsModule = "filesystem_stdio.dylib"; #elif defined(LINUX) char *szFsModule = "filesystem_stdio.so"; #else #error #endif char szFSDir[MAX_PATH]; szFSDir[0] = 0; if ( gEngfuncs.COM_ExpandFilename( szFsModule, szFSDir, sizeof( szFSDir ) ) == FALSE ) { return false; } // Get filesystem interface. g_pFileSystemModule = Sys_LoadModule( szFSDir ); assert( g_pFileSystemModule ); if( !g_pFileSystemModule ) { return false; } CreateInterfaceFn fileSystemFactory = Sys_GetFactory( g_pFileSystemModule ); if( !fileSystemFactory ) { return false; } g_pFileSystem = ( IFileSystem * )fileSystemFactory( FILESYSTEM_INTERFACE_VERSION, NULL ); assert( g_pFileSystem ); if( !g_pFileSystem ) { return false; } return 1; }
//----------------------------------------------------------------------------- // Purpose: Adds tool from specified library // Input : *dllname - //----------------------------------------------------------------------------- void CToolFrameworkInternal::LoadToolsFromLibrary( const char *dllname ) { CSysModule *module = Sys_LoadModule( dllname ); if ( !module ) { Warning( "CToolFrameworkInternal::LoadToolsFromLibrary: Unable to load '%s'\n", dllname ); return; } CreateInterfaceFn factory = Sys_GetFactory( module ); if ( !factory ) { Sys_UnloadModule( module ); Warning( "CToolFrameworkInternal::LoadToolsFromLibrary: Dll '%s' has no factory\n", dllname ); return; } IToolDictionary *dictionary = ( IToolDictionary * )factory( VTOOLDICTIONARY_INTERFACE_VERSION, NULL ); if ( !dictionary ) { Sys_UnloadModule( module ); Warning( "CToolFrameworkInternal::LoadToolsFromLibrary: Dll '%s' doesn't support '%s'\n", dllname, VTOOLDICTIONARY_INTERFACE_VERSION ); return; } if ( !dictionary->Connect( g_AppSystemFactory ) ) { Sys_UnloadModule( module ); Warning( "CToolFrameworkInternal::LoadToolsFromLibrary: Dll '%s' connection phase failed.\n", dllname ); return; } if ( dictionary->Init( ) != INIT_OK ) { Sys_UnloadModule( module ); Warning( "CToolFrameworkInternal::LoadToolsFromLibrary: Dll '%s' initialization phase failed.\n", dllname ); return; } dictionary->CreateTools(); int toolCount = dictionary->GetToolCount(); for ( int i = 0; i < toolCount; ++i ) { IToolSystem *tool = dictionary->GetTool( i ); if ( tool ) { Msg( "Loaded tool '%s'\n", tool->GetToolName() ); m_ToolSystems.AddToTail( tool ); } } m_Dictionaries.AddToTail( dictionary ); m_Modules.AddToTail( module ); }
//----------------------------------------------------------------------------- // The application object //----------------------------------------------------------------------------- bool CUnitTestApp::Create() { // Install a special Spew handler that ignores all assertions and lets us // run for as long as possible SpewOutputFunc( UnitTestSpew ); // FIXME: This list of dlls should come from the unittests themselves AppSystemInfo_t appSystems[] = { { "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION }, { "", "" } // Required to terminate the list }; if ( !AddSystems( appSystems ) ) return false; // Very simple... just iterate over all .DLLs in the current directory // see if they export UNITTEST_INTERFACE_VERSION. If not, then unload them // just as quick. // We may want to make this more sophisticated, giving it a search path, // or giving test DLLs special extensions, or statically linking the test DLLs // to this program. WIN32_FIND_DATA findFileData; HANDLE hFind= FindFirstFile("*.dll", &findFileData); while (hFind != INVALID_HANDLE_VALUE) { CSysModule* hLib = Sys_LoadModule(findFileData.cFileName); if ( hLib ) { CreateInterfaceFn factory = Sys_GetFactory( hLib ); if ( factory && factory( UNITTEST_INTERFACE_VERSION, NULL ) ) { AppModule_t module = LoadModule( factory ); AddSystem( module, UNITTEST_INTERFACE_VERSION ); } else { Sys_UnloadModule( hLib ); } } if (!FindNextFile( hFind, &findFileData )) break; } return true; }
void Hook_DemoPlayer(void * hModule) { static bool firstRun = true; if(!firstRun) return; firstRun = false; CreateInterfaceFn demoPlayerCreateInterface = Sys_GetFactory((CSysModule *)hModule); if(0 != demoPlayerCreateInterface) { int returnCode = 0; g_DemoPlayer = (IDemoPlayer001 *)demoPlayerCreateInterface("demoplayer001", &returnCode); } }
CreateInterfaceFn CDllDemandLoader::GetFactory() { if ( !m_hModule && !m_bLoadAttempted ) { m_bLoadAttempted = true; m_hModule = Sys_LoadModule( m_pchModuleName ); } if ( !m_hModule ) { return NULL; } return Sys_GetFactory( m_hModule ); }
//----------------------------------------------------------------------------- // Purpose: sets up all the modules for use //----------------------------------------------------------------------------- bool CVGuiSystemModuleLoader::InitializeAllModules(CreateInterfaceFn *factorylist, int factorycount) { if ( IsX360() ) { // not valid for 360 return false; } bool bSuccess = true; // Init vgui in the modules int i; for ( i = 0; i < m_Modules.Count(); i++ ) { if (!m_Modules[i].moduleInterface->Initialize(factorylist, factorycount)) { bSuccess = false; Error("Platform Error: module failed to initialize\n"); } } // create a table of all the loaded modules CreateInterfaceFn *moduleFactories = (CreateInterfaceFn *)_alloca(sizeof(CreateInterfaceFn) * m_Modules.Count()); for ( i = 0; i < m_Modules.Count(); i++ ) { moduleFactories[i] = Sys_GetFactory(m_Modules[i].module); } // give the modules a chance to link themselves together for (i = 0; i < m_Modules.Count(); i++) { if (!m_Modules[i].moduleInterface->PostInitialize(moduleFactories, m_Modules.Count())) { bSuccess = false; Error("Platform Error: module failed to initialize\n"); } #ifdef GAMEUI_EXPORTS m_Modules[i].moduleInterface->SetParent(GetGameUIBasePanel()); #else m_Modules[i].moduleInterface->SetParent(g_pMainPanel->GetVPanel()); #endif } m_bModulesInitialized = true; return bSuccess; }
// ------------------------------------------------------------------------ // // Global functions. // ------------------------------------------------------------------------ // IFileSystem* ScratchPad3D_SetupFileSystem() { // Get a filesystem interface. CSysModule *pModule = Sys_LoadModule( "filesystem_stdio" ); if( !pModule ) return NULL; CreateInterfaceFn fn = Sys_GetFactory( pModule ); IFileSystem *pFileSystem; if( !fn || (pFileSystem = (IFileSystem *)fn( FILESYSTEM_INTERFACE_VERSION, NULL )) == NULL ) { Sys_UnloadModule( pModule ); return NULL; } return pFileSystem; }
void LoadFileSystem( void ) { hFileSystemModule = Sys_LoadModule( FILESYSTEM_DLLNAME ); CreateInterfaceFn fileSystemFactory = Sys_GetFactory( hFileSystemModule ); if( fileSystemFactory == NULL ) { g_pFileSystem = NULL; } g_pFileSystem = (IFileSystem *)fileSystemFactory( FILESYSTEM_INTERFACE_VERSION, NULL ); if( g_pFileSystem ) { ALERT( at_aiconsole, "%s interface instantiated.\n", FILESYSTEM_INTERFACE_VERSION ); } }
IBaseInterface *CreateFileSystemInterface() { if (g_pOriginalFileSystem) return g_pOriginalFileSystem; if (g_pOriginalFileSystemModule) { g_OriginalFileSystemFactory = Sys_GetFactory(g_pOriginalFileSystemModule); if (g_OriginalFileSystemFactory) { int returnCode = 0; g_pOriginalFileSystem = reinterpret_cast<IBaseFileSystem *>(g_OriginalFileSystemFactory(FILESYSTEM_INTERFACE_VERSION, &returnCode)); return g_pOriginalFileSystem; } } return NULL; }
SystemWrapper::library_t *SystemWrapper::GetLibrary(char *name) { char fixedname[MAX_PATH]; Q_strlcpy(fixedname, name); COM_FixSlashes(fixedname); library_t *lib = (library_t *)m_Libraries.GetFirst(); while (lib) { if (Q_stricmp(lib->name, name) == 0) { return lib; } lib = (library_t *)m_Libraries.GetNext(); } lib = (library_t *)Mem_Malloc(sizeof(library_t)); if (!lib) { DPrintf("ERROR! System::GetLibrary: out of memory (%s).\n", name); return nullptr; } Q_snprintf(lib->name, sizeof(lib->name), "%s." LIBRARY_PREFIX, fixedname); FS_GetLocalCopy(lib->name); lib->handle = (CSysModule *)Sys_LoadModule(lib->name); if (!lib->handle) { DPrintf("ERROR! System::GetLibrary: coulnd't load library (%s).\n", lib->name); Mem_Free(lib); return nullptr; } lib->createInterfaceFn = (CreateInterfaceFn)Sys_GetFactory(lib->handle); if (!lib->createInterfaceFn) { DPrintf("ERROR! System::GetLibrary: coulnd't get object factory(%s).\n", lib->name); Mem_Free(lib); return nullptr; } m_Libraries.Add(lib); DPrintf("Loaded library %s.\n", lib->name); return lib; }
bool ConnectShaderPostprocessInterface() { char modulePath[MAX_PATH*4]; Q_snprintf( modulePath, sizeof( modulePath ), "%s/bin/game_shader_dx9.dll", engine->GetGameDirectory() ); __g_pShaderAPIShaderModule = Sys_LoadModule( modulePath ); if ( __g_pShaderAPIShaderModule ) { CreateInterfaceFn shaderShaderAPIDLLFactory = Sys_GetFactory( __g_pShaderAPIShaderModule ); __g_shaderExt = shaderShaderAPIDLLFactory ? ((IShaderEnginePostprocessInterface *)shaderShaderAPIDLLFactory(POSTPROCESS_INTERFACE_VERSION, NULL)) : NULL; if ( !__g_shaderExt ) Warning( "Unable to pull IShaderEnginePostprocessInterface interface.\n" ); } else Warning( "Cannot load game_shader_dx9.dll from %s!\n", modulePath ); return __g_shaderExt != NULL; }
int Init(lua_State* L) { gLua = Lua(); CreateInterfaceFn engineFactory = Sys_GetFactory("engine.dll"); engine = (IVEngineServer*)engineFactory(INTERFACEVERSION_VENGINESERVER, NULL); if(!engine) { gLua->Error("gmsv_teleport: Failed to load IVEngineServer\n"); } Msg("gmsv_teleport: Loaded\n"); ILuaObject *oEntity = gLua->GetGlobal("Entity"); oEntity->Push(); refEntity = gLua->GetReference(-1, true); oEntity->UnReference(); ILuaObject *ohook = gLua->GetGlobal("hook"); ILuaObject *oCall = ohook->GetMember("Call"); oCall->Push(); refHookCall = gLua->GetReference(-1, true); oCall->UnReference(); ohook->UnReference(); ILuaObject *oEntityMeta = gLua->GetMetaTable("Entity", GLua::TYPE_ENTITY); ILuaObject *oEntIndex = oEntityMeta->GetMember("EntIndex"); oEntIndex->Push(); refEntIndex = gLua->GetReference(-1, true); oEntIndex->UnReference(); oEntityMeta->UnReference(); ILuaObject *entityMeta = gLua->GetMetaTable("Entity", GLua::TYPE_ENTITY); if(entityMeta) { entityMeta->SetMember("SetupTeleportHook", SetupTeleportHook); } entityMeta->UnReference(); return 0; }
bool ConnectDeferredExt() { char modulePath[MAX_PATH*4]; Q_snprintf( modulePath, sizeof( modulePath ), "%s/bin/game_shader_generic_deferred.dll\0", engine->GetGameDirectory() ); __g_pDeferredShaderModule = Sys_LoadModule( modulePath ); if ( __g_pDeferredShaderModule ) { CreateInterfaceFn shaderDeferredDLLFactory = Sys_GetFactory( __g_pDeferredShaderModule ); __g_defExt = shaderDeferredDLLFactory ? ((IDeferredExtension *) shaderDeferredDLLFactory( DEFERRED_EXTENSION_VERSION, NULL )) : NULL; if ( !__g_defExt ) Warning( "Unable to pull IDeferredExtension interface.\n" ); } else Warning( "Cannot load game_shader_generic_deferred.dll from %s!\n", modulePath ); return __g_defExt != NULL; }
void ConnectHaptics(CreateInterfaceFn appFactory) { bool success = false; // NVNT load haptics module pFalconModule = Sys_LoadModule( HAPTICS_TEST_PREFIX HAPTICS_DLL_NAME ); if(pFalconModule) { CreateInterfaceFn factory = Sys_GetFactory( pFalconModule ); if(factory) { haptics = reinterpret_cast< IHaptics* >( factory( HAPTICS_INTERFACE_VERSION, NULL ) ); if(haptics && haptics->Initialize(engine, view, g_InputInternal, gpGlobals, appFactory, g_pVGuiInput->GetIMEWindow(), filesystem, enginevgui, ActivityList_IndexForName, ActivityList_NameForIndex)) { success = true; hap_HasDevice.SetValue(1); } } } if(!success) { Sys_UnloadModule(pFalconModule); pFalconModule = 0; haptics = new CHapticsStubbed; } if(haptics->HasDevice()) { Assert( (void*)haptics == inputsystem->GetHapticsInterfaceAddress() ); } HookHapticMessages(); }
bool CPluginHandle::LoadFromFile(const tString &asPath) { msPrevPath = asPath; if(!(mpHandle = LibUtil::LoadLibrary(asPath.c_str()))) return false; CreateInterfaceFn fnCreateInterface = Sys_GetFactory((CSysModule*)mpHandle); if(fnCreateInterface) { if(!(mpCallbacks = (IEnginePlugin*)fnCreateInterface(MGT_ENGINEPLUGIN_INTERFACE_VERSION, nullptr))) return false; if(!mpCallbacks->Load(mfnModuleFactory)) return false; mpCallbacks->GetInfo(*mpInfo); }; return true; };