void XMLSerializer::LoadColor( ticpp::Element* element )
{
if ( Management::Get( )->GetSystemManager( )->HasSystem( System::Types::RENDER ) )
{
std::string key;
float red = 0;
float green = 0;
float blue = 0;
element->GetAttribute( "type", &key );
element->GetAttribute( "r", &red );
element->GetAttribute( "g", &green );
element->GetAttribute( "b", &blue );
AnyType::AnyTypeMap parameters;
parameters[ "r" ] = red;
parameters[ "g" ] = green;
parameters[ "b" ] = blue;
ISystem* graphicsSystem = Management::Get( )->GetSystemManager( )->GetSystem( System::Types::RENDER );
graphicsSystem->SetAttribute( key, parameters );
}
}
ISystem* PlatformManager::platform_load_system(const char* library_path, IAllocator& allocator, IPlatformManager& platform_manager, IServiceManager& service_manager, ITaskManager& task_manager)
{
typedef ISystem*(*LOAD)(IAllocator&, IPlatformManager&, IServiceManager&, ITaskManager&);
ISystem* system = nullptr;
HINSTANCE dll_handle = ::LoadLibrary(library_path);
if (dll_handle)
{
Library library{};
library.m_handle = dll_handle;
LOAD load_function = (LOAD)::GetProcAddress(dll_handle, "load");
if (load_function)
{
system = load_function(allocator, platform_manager, service_manager, task_manager);
if (system)
{
system->initialize();
m_loaded_systems[system] = library;
}
}
else
{
::FreeLibrary(dll_handle);
}
}
return system;
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true );
break;
case eFE_Update:
{
ISystem *pSystem = GetISystem();
IRenderer *pRenderer = gEnv->pRenderer;
int sysMem = pSystem->GetUsedMemory();
size_t vidMemThisFrame( 0 );
size_t vidMemRecently( 0 );
pRenderer->GetVideoMemoryUsageStats( vidMemThisFrame, vidMemRecently );
int meshMem = 0;
pRenderer->EF_Query(EFQ_Alloc_APIMesh, meshMem);
ActivateOutput(pActInfo, OUT_SYSMEM, sysMem);
// potentially unsafe if we start using >2gb of video memory...?
ActivateOutput(pActInfo, OUT_VIDEOMEM_THISFRAME, int(vidMemThisFrame));
ActivateOutput(pActInfo, OUT_VIDEOMEM_RECENTLY, int(vidMemRecently));
ActivateOutput(pActInfo, OUT_MESHMEM, meshMem);
}
break;
}
}
CEntityPoolSignature::CEntityPoolSignature()
: m_bGenerated(false)
, m_pSignatureSerializer(NULL)
{
ISystem *pSystem = GetISystem();
assert(pSystem);
m_Signature = pSystem->CreateXmlNode("EntityPoolSignature");
m_pSignatureSerializer = pSystem->GetXmlUtils()->CreateXmlSerializer();
}
void CGameStartup::RequestLoadMod(IConsoleCmdArgs* pCmdArgs)
{
if (pCmdArgs->GetArgCount() == 2)
{
m_reqModName = pCmdArgs->GetArg(1);
ISystem* pSystem = m_pFramework->GetISystem();
pSystem->Quit();
}
else
{
CryLog("Error, correct syntax is: g_loadMod modname");
}
}
void IEntity::EraseSystem(std::map<const typeSystemID, ISystem*>::iterator theSystemIter)
{
// Get our ISystem reference first
ISystem* anSystem = theSystemIter->second;
// First remove the ISystem from our list
mSystems.erase(theSystemIter);
// Now use our ISystem reference to remove any IEntity references
if(anSystem->HasEntity(GetID()))
{
// Cause ISystem to drop our reference
anSystem->DropEntity(GetID());
}
}
void CGameStartupStatic::RequestUnloadMod(IConsoleCmdArgs* pCmdArgs)
{
if (pCmdArgs->GetArgCount() == 1)
{
if (g_pGameStartup)
{
g_pGameStartup->m_reqModUnload = true;
ISystem* pSystem = g_pGameStartup->m_pFramework->GetISystem();
pSystem->Quit();
}
}
else
{
CryLog("Error, correct syntax is: g_unloadMod");
}
}
bool InitGameMembers( EntityId id )
{
if (!m_pScriptSystem)
{
ISystem * pSystem = GetISystem();
m_pScriptSystem = pSystem->GetIScriptSystem();
m_pEntitySystem = gEnv->pEntitySystem;
IEntity * pEntity = m_pEntitySystem->GetEntity( id );
if (!pEntity)
return false;
m_pScriptTable = pEntity->GetScriptTable();
if (!m_pScriptTable.GetPtr())
return false;
}
return true;
}
/**
* @inheritDoc
*/
Error DefinitionService::loadSystemLibrary(Proto::SystemType type, ISystem** ppSystem) {
Error Err = Errors::Failure;
std::string libraryName = Proto::SystemType_Name(type) + "System";
HMODULE hLib = LoadLibraryA(libraryName.c_str());
if (hLib == NULL) {
ASSERTMSG1(false, "Failed to load system %s", libraryName);
return Err;
}
InitializeSystemLibFunction fnInitSystemLib = reinterpret_cast<InitializeSystemLibFunction>(GetProcAddress(hLib, "InitializeSystemLib"));
if (fnInitSystemLib != NULL) {
fnInitSystemLib(IServiceManager::get());
}
CreateSystemFunction fnCreateSystem = reinterpret_cast<CreateSystemFunction>(GetProcAddress(hLib, "CreateSystem"));
if (fnCreateSystem == NULL) {
return Err;
}
ISystem* pSystem = fnCreateSystem();
if (pSystem == NULL) {
return Err;
}
SystemService* systemService = IServiceManager::get()->getSystemService();
Proto::SystemType systemType = pSystem->GetSystemType();
ISystem* pCurrSystem = systemService->get(systemType);
if (pCurrSystem != NULL) {
return Err;
}
systemService->add(pSystem);
SystemLib systemLib = {
reinterpret_cast<Handle>(hLib),
pSystem
};
m_systemLibs.push_back(systemLib);
*ppSystem = pSystem;
return Errors::Success;
}
IGameRef CGameStartup::Init(SSystemInitParams &startupParams)
{
MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialization");
LOADING("game_startup");
if (!InitFramework(startupParams))
{
return 0;
}
// Configuration for this game
ICVar *pCVar = gEnv->pConsole->GetCVar("ai_CompatibilityMode");
if (pCVar)
pCVar->Set("crysis");
LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem());
ISystem* pSystem = m_pFramework->GetISystem();
IConsole* pConsole = gEnv->pConsole;
startupParams.pSystem = pSystem;
#if defined(ENABLE_STATS_AGENT)
const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename");
CStatsAgent::CreatePipe( pPipeArg );
#endif
PluginManager::InitPluginManager(startupParams);
PluginManager::InitPluginsBeforeFramework();
REGISTER_COMMAND("g_loadMod", RequestLoadMod,VF_NULL,"");
// load the appropriate game/mod
const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD");
IGameRef pOut;
if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue())))
{
const char* pModName = pModArg->GetValue();
assert(pModName);
pOut = Reset(pModName);
}
else
{
pOut = Reset(GAME_NAME);
}
// Load all localized strings.
LoadLocalizationData();
if (!m_pFramework->CompleteInit())
{
pOut->Shutdown();
return 0;
}
LOADING_DONE;
// should be after init game (should be executed even if there is no game)
if(startupParams.bExecuteCommandLine)
pSystem->ExecuteCommandLine();
pSystem->GetISystemEventDispatcher()->RegisterListener( &g_system_event_listener_game );
// Creates and starts the realtime update system listener.
if (pSystem->IsDevMode())
{
CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true);
}
GCOV_FLUSH;
if (gEnv && GetISystem())
{
}
else
{
CryLogAlways("failed to find ISystem to register error observer");
assert(0);
}
PluginManager::InitPluginsLast();
return pOut;
}
int CGameStartup::Run( const char * autoStartLevelName )
{
#if defined(RELEASE_SERVER_SECURITY)
CryLogAlways("Performing Validation Checks");
if (!PerformDedicatedInstallationSanityCheck())
{
CryFatalError("Installation appears to be corrupt. Please check the log file for a list of problems.");
}
#endif
gEnv->pConsole->ExecuteString( "exec autoexec.cfg" );
if (autoStartLevelName)
{
//load savegame
if(CryStringUtils::stristr(autoStartLevelName, CRY_SAVEGAME_FILE_EXT) != 0 )
{
CryFixedStringT<256> fileName (autoStartLevelName);
// NOTE! two step trimming is intended!
fileName.Trim(" "); // first: remove enclosing spaces (outside ")
fileName.Trim("\""); // second: remove potential enclosing "
gEnv->pGame->GetIGameFramework()->LoadGame(fileName.c_str());
}
else //start specified level
{
CryFixedStringT<256> mapCmd ("map ");
mapCmd+=autoStartLevelName;
gEnv->pConsole->ExecuteString(mapCmd.c_str());
}
}
#ifdef WIN32
if (!(gEnv && gEnv->pSystem) || (!gEnv->IsEditor() && !gEnv->IsDedicated()))
{
::ShowCursor(TRUE); // Make the cursor visible again (it was hidden in InitFramework() )
if (gEnv && gEnv->pSystem && gEnv->pSystem->GetIHardwareMouse())
gEnv->pSystem->GetIHardwareMouse()->DecrementCounter();
}
AllowAccessibilityShortcutKeys(false);
for(;;)
{
ISystem *pSystem = gEnv ? gEnv->pSystem : 0;
if (!pSystem)
{
break;
}
if (pSystem->PumpWindowMessage(false) == -1)
{
break;
}
if (!Update(true, 0))
{
// need to clean the message loop (WM_QUIT might cause problems in the case of a restart)
// another message loop might have WM_QUIT already so we cannot rely only on this
pSystem->PumpWindowMessage(true);
break;
}
}
#else
// We should use bVisibleByDefault=false then...
if (gEnv && gEnv->pHardwareMouse)
gEnv->pHardwareMouse->DecrementCounter();
#if !defined(DURANGO)
for(;;)
{
if (!Update(true, 0))
{
break;
}
}
#endif
#endif //WIN32
return 0;
}
IGameRef CGameStartup::Init(SSystemInitParams &startupParams)
{
MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialisation");
#if defined(CVARS_WHITELIST)
startupParams.pCVarsWhitelist = &g_CVarsWhiteList;
#endif // defined(CVARS_WHITELIST)
startupParams.pGameStartup = this;
if (!InitFramework(startupParams))
{
return 0;
}
InlineInitializationProcessing("CGameStartup::Init");
LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem());
ISystem* pSystem = m_pFramework->GetISystem();
startupParams.pSystem = pSystem;
const ICmdLineArg* pSvBind = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "sv_bind");
IConsole* pConsole = pSystem->GetIConsole();
if ((pSvBind != NULL) && (pConsole != NULL))
{
string command = pSvBind->GetName() + string(" ") + pSvBind->GetValue();
pConsole->ExecuteString(command.c_str(), true, false);
}
#if defined(ENABLE_STATS_AGENT)
const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename");
CStatsAgent::CreatePipe( pPipeArg );
#endif
REGISTER_COMMAND("g_loadMod", CGameStartupStatic::RequestLoadMod,VF_NULL,"");
REGISTER_COMMAND("g_unloadMod", CGameStartupStatic::RequestUnloadMod, VF_NULL, "");
// load the appropriate game/mod
#if !defined(_RELEASE)
const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD");
#else
const ICmdLineArg *pModArg = NULL;
#endif // !defined(_RELEASE)
InlineInitializationProcessing("CGameStartup::Init LoadLocalizationData");
IGameRef pOut;
if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue())))
{
const char* pModName = pModArg->GetValue();
assert(pModName);
pOut = Reset(pModName);
}
else
{
pOut = Reset(GAME_NAME);
}
if (!m_pFramework->CompleteInit())
{
pOut->Shutdown();
return 0;
}
InlineInitializationProcessing("CGameStartup::Init FrameworkCompleteInit");
// should be after init game (should be executed even if there is no game)
if(startupParams.bExecuteCommandLine)
pSystem->ExecuteCommandLine();
pSystem->GetISystemEventDispatcher()->RegisterListener(this);
// Creates and starts the realtime update system listener.
if (pSystem->IsDevMode())
{
CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true);
}
GCOV_FLUSH;
if (ISystem *pSystem = gEnv ? GetISystem() : NULL)
{
pSystem->RegisterErrorObserver(&m_errorObsever);
pSystem->RegisterWindowMessageHandler(this);
}
else
{
CryLogAlways("failed to find ISystem to register error observer");
assert(0);
}
InlineInitializationProcessing("CGameStartup::Init End");
#if defined(CRY_UNIT_TESTING)
// Register All unit tests of this module.
#if defined(_LIB)
if(gEnv->pSystem)
{
CryUnitTest::Test *pTest = CryUnitTest::Test::m_pFirst;
for (; pTest != 0; pTest = pTest->m_pNext)
{
CryUnitTest::IUnitTestManager *pTestManager = gEnv->pSystem->GetITestSystem()->GetIUnitTestManager();
if (pTestManager)
{
pTest->m_unitTestInfo.module = "StaticBinary";
pTestManager->CreateTest( pTest->m_unitTestInfo );
}
}
}
#endif
// run unit tests
CryUnitTest::IUnitTestManager *pTestManager = (gEnv && gEnv->pSystem) ? gEnv->pSystem->GetITestSystem()->GetIUnitTestManager() : NULL;
if (pTestManager)
{
const ICmdLineArg* pSkipUnitTest = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "skip_unit_tests");
if(pSkipUnitTest == NULL)
{
const ICmdLineArg* pUseUnitTestExcelReporter = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "use_unit_test_excel_reporter");
if(pUseUnitTestExcelReporter)
{
gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::ExcelReporter);
}
else // default is the minimal reporter
{
gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::MinimalReporter);
}
}
}
#endif // CRY_UNIT_TESTING
assert(gEnv);
PREFAST_ASSUME(gEnv);
GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_RANDOM_SEED, (UINT_PTR)gEnv->pTimer->GetAsyncTime().GetMicroSecondsAsInt64(), 0);
return pOut;
}
