void CEditorGame::InitActionMapsEnums(IGameToEditorInterface* pGTE) { IActionMapManager* pAM = m_pGame->GetIGameFramework()->GetIActionMapManager(); IActionMapIteratorPtr iter = pAM->CreateActionMapIterator(); const int numActionMaps = pAM->GetActionMapsCount(); if(numActionMaps == 0) return; const char** nameValueStrings = new const char*[numActionMaps]; int curEntryIndex = 0; while (IActionMap* pMap = iter->Next()) { assert(curEntryIndex < numActionMaps); PREFAST_ASSUME(curEntryIndex < numActionMaps); nameValueStrings[curEntryIndex++] = pMap->GetName(); if (curEntryIndex > numActionMaps) { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "[InitActionMapsEnums] Wrong number of Action Maps."); break; } } pGTE->SetUIEnums("action_maps", nameValueStrings, numActionMaps); delete[] nameValueStrings; }
//------------------------------------------------------------------------ CVehicleActionEntityAttachment* CFlowVehicleEntityAttachment::GetVehicleAction() { if (!m_vehicleId) return NULL; IVehicleSystem* pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem(); assert(pVehicleSystem); if (IVehicle* pVehicle = pVehicleSystem->GetVehicle(m_vehicleId)) { for (int i = 1; i < pVehicle->GetActionCount(); i++) { IVehicleAction* pAction = pVehicle->GetAction(i); assert(pAction); PREFAST_ASSUME(pAction); if (CVehicleActionEntityAttachment* pAttachment = CAST_VEHICLEOBJECT(CVehicleActionEntityAttachment, pAction)) { return pAttachment; } } } return NULL; }
void CEditorGame::InitModularBehaviorTreeEnum(IGameToEditorInterface* pGTE) { std::vector<string> behaviorTrees; // no behavior tree behaviorTrees.push_back(""); ScanBehaviorTrees("Scripts/AI/BehaviorTrees/", behaviorTrees); size_t numTrees = 0; const int behaviorTreeCount = behaviorTrees.size(); const char** allTrees = new const char*[behaviorTreeCount]; std::vector<string>::const_iterator iter = behaviorTrees.begin(); std::vector<string>::const_iterator iterEnd = behaviorTrees.end(); while (iter != iterEnd) { assert(numTrees >= 0 && numTrees < behaviorTreeCount); PREFAST_ASSUME(numTrees >= 0 && numTrees < behaviorTreeCount); allTrees[numTrees++] = iter->c_str(); ++iter; } pGTE->SetUIEnums("ModularBehaviorTree", allTrees, numTrees); SAFE_DELETE_ARRAY(allTrees); }
// Description: // Create // Arguments: // // Return: // CVisualLog& CVisualLog::ref() { if ( NULL == m_pInstance ) { Create(); } CRY_ASSERT(m_pInstance); PREFAST_ASSUME(m_pInstance); return( *m_pInstance ); }
void CEditorGame::InitLevelTypesEnums(IGameToEditorInterface* pGTE) { DynArray<string>* levelTypes; levelTypes = g_pGame->GetIGameFramework()->GetILevelSystem()->GetLevelTypeList(); const char** allLevelTypes = new const char*[levelTypes->size()]; for (int i = 0; i < levelTypes->size(); i++) { PREFAST_ASSUME(i > 0 && i < levelTypes->size()); allLevelTypes[i] = (*levelTypes)[i]; } pGTE->SetUIEnums("level_types", allLevelTypes, levelTypes->size()); delete[] allLevelTypes; }
// Description: // // Arguments: // // Return: // void CVisualLog::InitCVars() { m_pCVVisualLog = REGISTER_INT( "cl_visualLog", 0, 0, "Enables Visual Logging." ); m_pCVVisualLogFolder = REGISTER_STRING( "cl_visualLogFolder", "VisualLog", 0, "Specifies sub folder to write logs to." ); m_pCVVisualLogImageFormat = REGISTER_STRING( "cl_visualLogImageFormat", "bmp", 0, "Specifies file format of captured files (jpg, bmp)." ); m_pCVVisualLogImageScale = REGISTER_FLOAT( "cl_visualLogImageScale", 128, 0, "Image size. [0-1] = scale value. >1 = actual pixels for image width" ); assert(gEnv->pConsole); PREFAST_ASSUME(gEnv->pConsole); m_pCV_capture_frames = gEnv->pConsole->GetCVar("capture_frames"); m_pCV_capture_file_format = gEnv->pConsole->GetCVar("capture_file_format"); m_pCV_capture_frame_once = gEnv->pConsole->GetCVar("capture_frame_once"); m_pCV_capture_file_name = gEnv->pConsole->GetCVar("capture_file_name"); CRY_ASSERT( m_pCV_capture_frames ); CRY_ASSERT( m_pCV_capture_file_format ); CRY_ASSERT( m_pCV_capture_frame_once ); CRY_ASSERT( m_pCV_capture_file_name ); }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { if ( event != eFE_Activate ) return; ICustomAction* pCustomAction = pActInfo->pGraph->GetCustomAction(); if (!pCustomAction) // Not inside a custom graph, must be an instance hack, get associated entity { IEntity* pEntity = pActInfo->pEntity; if(!pEntity) { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CFlowNode_CustomActionEnd::ProcessEvent: Instance hack must have assigned entity"); return; } ICustomActionManager* pCustomActionManager = gEnv->pGame->GetIGameFramework()->GetICustomActionManager(); if (pCustomActionManager) { pCustomAction = pCustomActionManager->GetActiveCustomAction(pEntity); if (!pCustomAction) { CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CFlowNode_CustomActionEnd::ProcessEvent: Can't find custom action for entity"); return; } } } PREFAST_ASSUME(pCustomAction); // is validated above, if it fails it should already have returned if ( IsPortActive(pActInfo, 0) ) pCustomAction->SucceedAction(); if ( IsPortActive(pActInfo, 1) ) pCustomAction->SucceedWaitAction(); if ( IsPortActive(pActInfo, 2) ) pCustomAction->SucceedWaitCompleteAction(); else if ( IsPortActive(pActInfo, 3) ) pCustomAction->AbortAction(); else if ( IsPortActive(pActInfo, 4) ) pCustomAction->EndActionSuccess(); else if ( IsPortActive(pActInfo, 5) ) pCustomAction->EndActionFailure(); }
void CreateEnum(IGameToEditorInterface *pGTEInterface, const char* enumName) const { assert(pGTEInterface); assert(enumName && enumName[0]); if (!m_vecNames.empty()) { const size_t numNames = m_vecNames.size(); const char** pNameArray = new const char* [numNames]; TNamesVec::const_iterator itName = m_vecNames.begin(); TNamesVec::const_iterator itNameEnd = m_vecNames.end(); for (size_t index = 0; itName != itNameEnd; ++itName, ++index) { assert(index >= 0 && index < numNames); PREFAST_ASSUME(index >= 0 && index < numNames); pNameArray[index] = *itName; } pGTEInterface->SetUIEnums(enumName, pNameArray, numNames); delete [] pNameArray; } }
void CRecordingSystem::ClProcessKillCamData(IActor *pActor, const CActor::KillCamFPData &packet) { // Receiver gets a second to validate the expectations. static float timeToValidateUnexpectedData = 1.f; // Find the existing StreamData for this packet. SKillCamStreamData* pStreamData = m_streamer.GetExpectedStreamData(packet.m_victim); // If it arrived before the kill was relayed to the client, then create false expectations of this data and store it in anticipation of validation. if(!pStreamData) { CryLogAlways("Receiving unexpected packet data. This is most likely because the data is arriving before the kill has been requested. Creating false expectations."); SKillCamExpectedData falseExpectations(pActor->GetEntityId(), packet.m_victim, packet.m_bToEveryone); pStreamData = m_streamer.ExpectStreamData(falseExpectations, false); if(!pStreamData) { CryFatalError("CRecordingSystem::ClProcessKillCamData: Cannot find free slot to add new receive data from: Sender[%d] Victim[%d]", falseExpectations.m_sender, falseExpectations.m_victim); } PREFAST_ASSUME(pStreamData); //validated above pStreamData->SetValidationTimer(timeToValidateUnexpectedData); } else { // Update the timer if it's still not been validated and we receive a new packet... if(pStreamData->IsValidationTimerSet()) { pStreamData->SetValidationTimer(timeToValidateUnexpectedData); } } if(pStreamData) { // Process the Packet. CRecordingSystem::ProcessKillCamData(pActor, packet, *pStreamData, true); } }
virtual void Run() { SetName("ZLibCompressor"); #if defined (DURANGO) SetThreadAffinityMask(GetCurrentThread(), BIT(3)); #endif while(!m_bCancelled || !m_files.empty()) { m_event.Wait(); uint8* pZLibCompressedBuffer = AllocateBlock(); while(!m_files.empty()) { CFile* pFile = m_files.pop(); assert(pFile); PREFAST_ASSUME(pFile); while(!pFile->Closed() || !pFile->m_blocks.empty()) { if( pFile->m_blocks.empty() ) { CrySleep(1); // yield to give other threads a chance to do some work } while(!pFile->m_blocks.empty()) { SZLibBlock* block = pFile->m_blocks.pop(); assert(block); PREFAST_ASSUME(block); if(pFile->m_pCompressor->m_bUseZLibCompression) { size_t compressedLength = XMLCPB_ZLIB_BUFFER_SIZE; bool compressionOk = gEnv->pSystem->CompressDataBlock( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed, pZLibCompressedBuffer, compressedLength ); SZLibBlockHeader zlibHeader; zlibHeader.m_compressedSize = compressionOk ? compressedLength : SZLibBlockHeader::NO_ZLIB_USED; zlibHeader.m_uncompressedSize = block->m_ZLibBufferSizeUsed; pFile->m_bytesWrittenIntoFileUncompressed += block->m_ZLibBufferSizeUsed; pFile->Write( &zlibHeader, sizeof(SZLibBlockHeader) ); if (compressionOk) pFile->Write( pZLibCompressedBuffer, compressedLength ); else pFile->Write( block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed ); } else { pFile->Write(block->m_pZLibBuffer, block->m_ZLibBufferSizeUsed); } delete block; } } pFile->Finish(); delete pFile; } FreeBlock(pZLibCompressedBuffer); } }
void CEditorGame::InitEntityArchetypeEnums(IGameToEditorInterface* pGTE, const char* levelFolder /*= NULL*/, const char* levelName /*= NULL*/) { CRY_ASSERT(pGTE); // Look in all the archetype files ICryPak* pCryPak = gEnv->pCryPak; CRY_ASSERT(pCryPak); std::vector<string> vecArchetypeNames; if (levelFolder && levelName) { string levelPath = string(levelFolder) + "/" + string(levelName) + ".cry"; if (pCryPak && pCryPak->OpenPack(levelPath)) { string editorXML = string(levelFolder) + "/Level.editor_xml"; XmlNodeRef pRoot = gEnv->pSystem->LoadXmlFromFile(editorXML); if (pRoot) GetArchetypesFromLevelLib(pRoot, &vecArchetypeNames); pCryPak->ClosePack(levelPath); } } _finddata_t fd; string sSearchPath = PathUtil::Make("Libs\\EntityArchetypes", "*", "xml"); intptr_t handle = pCryPak->FindFirst(sSearchPath, &fd); if (handle >= 0) { do { string sFilePath = PathUtil::Make("Libs\\EntityArchetypes", fd.name, "xml"); XmlNodeRef pRoot = gEnv->pSystem->LoadXmlFromFile(sFilePath.c_str()); if (!pRoot || stricmp(pRoot->getTag(), "EntityPrototypeLibrary")) continue; XmlString sRootName; pRoot->getAttr("Name", sRootName); GetArchetypesFromLib(pRoot, sRootName, &vecArchetypeNames); } while (pCryPak->FindNext(handle, &fd) >= 0); pCryPak->FindClose(handle); } if (!vecArchetypeNames.empty()) { size_t numFilters = 0; const int allArchetypeCount = vecArchetypeNames.size()+1; const char** allArchetypeNames = new const char*[allArchetypeCount]; allArchetypeNames[numFilters++] = ""; // Blank entry at top std::vector<string>::const_iterator iter = vecArchetypeNames.begin(); std::vector<string>::const_iterator iterEnd = vecArchetypeNames.end(); while (iter != iterEnd) { assert(numFilters > 0 && numFilters < allArchetypeCount); PREFAST_ASSUME(numFilters > 0 && numFilters < allArchetypeCount); allArchetypeNames[numFilters++] = iter->c_str(); ++iter; } pGTE->SetUIEnums("entity_archetypes", allArchetypeNames, numFilters); delete[] allArchetypeNames; } }
void CVar::Init( struct IConsole *pConsole ) { assert(gEnv->pConsole); PREFAST_ASSUME(gEnv->pConsole); REGISTER_COMMAND("es_dump_entities", (ConsoleCommandFunc)DumpEntities, 0, "Dumps current entities and their states!"); REGISTER_COMMAND("es_dump_entity_classes_in_use", (ConsoleCommandFunc)DumpEntityClassesInUse, 0, "Dumps all used entity classes"); REGISTER_COMMAND("es_compile_area_grid", (ConsoleCommandFunc)CompileAreaGrid, 0, "Trigger a recompile of the area grid"); REGISTER_COMMAND("es_dump_bookmarks", (ConsoleCommandFunc)DumpEntityBookmarks, 0, "Dumps information about all bookmarked entities"); REGISTER_COMMAND("es_AudioListenerOffset", (ConsoleCommandFunc)SetAudioListenerOffsets, 0, "Sets by how much the audio listener offsets its position and rotation in regards to its entity.\n" "Usage: es_AudioListenerOffset PosX PosY PosZ RotX RotY RotZ\n"); REGISTER_CVAR( es_SortUpdatesByClass, 0, 0, "Sort entity updates by class (possible optimization)" ); pDebug = REGISTER_INT("es_debug",0,VF_CHEAT, "Enable entity debugging info\n" "Usage: es_debug [0/1]\n" "Default is 0 (on)."); pCharacterIK = REGISTER_INT("p_CharacterIK",1,VF_CHEAT, "Toggles character IK.\n" "Usage: p_characterik [0/1]\n" "Default is 1 (on). Set to 0 to disable inverse kinematics."); pEntityBBoxes = REGISTER_INT("es_bboxes",0,VF_CHEAT, "Toggles entity bounding boxes.\n" "Usage: es_bboxes [0/1]\n" "Default is 0 (off). Set to 1 to display bounding boxes."); pEntityHelpers = REGISTER_INT("es_helpers",0,VF_CHEAT, "Toggles helpers.\n" "Usage: es_helpers [0/1]\n" "Default is 0 (off). Set to 1 to display entity helpers."); pProfileEntities = REGISTER_INT("es_profileentities",0,VF_CHEAT, "Usage: es_profileentities 1,2,3\n" "Default is 0 (off)."); /* pUpdateInvisibleCharacter = REGISTER_INT("es_UpdateInvisibleCharacter",0,VF_CHEAT, "Usage: \n" "Default is 0 (off)."); pUpdateBonePositions = REGISTER_INT("es_UpdateBonePositions",1,VF_CHEAT, "Usage: \n" "Default is 1 (on)."); */ pUpdateScript = REGISTER_INT("es_UpdateScript",1,VF_CHEAT, "Usage: es_UpdateScript [0/1]\n" "Default is 1 (on)."); pUpdatePhysics = REGISTER_INT("es_UpdatePhysics",1,VF_CHEAT, "Toggles updating of entity physics.\n" "Usage: es_UpdatePhysics [0/1]\n" "Default is 1 (on). Set to 0 to prevent entity physics from updating."); pUpdateAI = REGISTER_INT("es_UpdateAI",1,VF_CHEAT, "Toggles updating of AI entities.\n" "Usage: es_UpdateAI [0/1]\n" "Default is 1 (on). Set to 0 to prevent AI entities from updating."); pUpdateEntities = REGISTER_INT("es_UpdateEntities",1,VF_CHEAT, "Toggles entity updating.\n" "Usage: es_UpdateEntities [0/1]\n" "Default is 1 (on). Set to 0 to prevent all entities from updating."); pUpdateCollision= REGISTER_INT("es_UpdateCollision",1,VF_CHEAT, "Toggles updating of entity collisions.\n" "Usage: es_UpdateCollision [0/1]\n" "Default is 1 (on). Set to 0 to disable entity collision updating."); pUpdateContainer= REGISTER_INT("es_UpdateContainer",1,VF_CHEAT, "Usage: es_UpdateContainer [0/1]\n" "Default is 1 (on)."); pUpdateTimer = REGISTER_INT("es_UpdateTimer",1,VF_CHEAT, "Usage: es_UpdateTimer [0/1]\n" "Default is 1 (on)."); pUpdateCollisionScript = REGISTER_INT("es_UpdateCollisionScript",1,VF_CHEAT, "Usage: es_UpdateCollisionScript [0/1]\n" "Default is 1 (on)."); pVisCheckForUpdate = REGISTER_INT("es_VisCheckForUpdate",1,VF_CHEAT, "Usage: es_VisCheckForUpdate [0/1]\n" "Default is 1 (on)."); pMinImpulseVel = REGISTER_FLOAT("es_MinImpulseVel",0.0f,VF_CHEAT, "Usage: es_MinImpulseVel 0.0"); pImpulseScale = REGISTER_FLOAT("es_ImpulseScale",0.0f,VF_CHEAT, "Usage: es_ImpulseScale 0.0"); pMaxImpulseAdjMass = REGISTER_FLOAT("es_MaxImpulseAdjMass",2000.0f,VF_CHEAT, "Usage: es_MaxImpulseAdjMass 2000.0"); pDebrisLifetimeScale = REGISTER_FLOAT("es_DebrisLifetimeScale",1.0f,0, "Usage: es_DebrisLifetimeScale 1.0"); pSplashThreshold = REGISTER_FLOAT("es_SplashThreshold",1.0f,VF_CHEAT, "minimum instantaneous water resistance that is detected as a splash" "Usage: es_SplashThreshold 200.0"); pSplashTimeout = REGISTER_FLOAT("es_SplashTimeout",3.0f,VF_CHEAT, "minimum time interval between consecutive splashes" "Usage: es_SplashTimeout 3.0"); pHitCharacters = REGISTER_INT("es_HitCharacters",1,0, "specifies whether alive characters are affected by bullet hits (0 or 1)"); pHitDeadBodies = REGISTER_INT("es_HitDeadBodies",1,0, "specifies whether dead bodies are affected by bullet hits (0 or 1)"); pCharZOffsetSpeed = REGISTER_FLOAT("es_CharZOffsetSpeed",2.0f,VF_DUMPTODISK, "sets the character Z-offset change speed (in m/s), used for IK"); pNotSeenTimeout = REGISTER_INT("es_not_seen_timeout", 30, VF_DUMPTODISK, "number of seconds after which to cleanup temporary render buffers in entity"); pDebugNotSeenTimeout = REGISTER_INT("es_debug_not_seen_timeout", 0, VF_DUMPTODISK, "if true, log messages when entities undergo not seen timeout"); pEnableFullScriptSave = REGISTER_INT("es_enable_full_script_save",0, VF_DUMPTODISK,"Enable (experimental) full script save functionality"); pLogCollisions = REGISTER_INT("es_log_collisions",0,0,"Enables collision events logging" ); REGISTER_CVAR(es_DebugTimers,0,VF_CHEAT, "This is for profiling and debugging (for game coders and level designer)\n" "By enabling this you get a lot of console printouts that show all entities that receive OnTimer\n" "events - it's good to minimize the call count. Certain entities might require this feature and\n" "using less active entities can often be defined by the level designer.\n" "Usage: es_DebugTimers 0/1"); REGISTER_CVAR(es_DebugFindEntity,0,VF_CHEAT,"" ); REGISTER_CVAR(es_DebugEvents,0,VF_CHEAT,"Enables logging of entity events" ); REGISTER_CVAR(es_DisableTriggers,0,0,"Disable enter/leave events for proximity and area triggers"); REGISTER_CVAR(es_DrawProximityTriggers,0,0, "Shows Proximity Triggers.\n" "Usage: es_DrawProximityTriggers [0-255]. The parameter sets the transparency (alpha) level.\n" "Value 1 will be changed to 70.\n" "Default is 0 (off)\n"); REGISTER_CVAR(es_DebugEntityUsage,0,0, "Draws information to the screen to show how entities are being used, per class, including total, active and hidden counts and memory usage" "\nUsage: es_DebugEntityUsage update_rate" "\nupdate_rate - Time in ms to refresh memory usage calculation or 0 to disable"); REGISTER_CVAR(es_DebugEntityUsageFilter,"",0,"Filter entity usage debugging to classes which have this string in their name"); REGISTER_CVAR(es_EnablePoolUse,-1,0, "Force toggle the use of entity pools on/off.\n" "Usage: es_EnablePoolUse 1\n" "Default is -1, or normal behavior. 0 forces system off. 1 forces system on."); REGISTER_CVAR(es_DebugPool,0,0,"Enable debug drawing of entity pools"); REGISTER_CVAR(es_TestPoolSignatures,0,VF_CHEAT,"Enable signature testing on entity classes the first time they're prepared from an entity pool"); REGISTER_CVAR(es_DebugPoolFilter,"",0,"Filter entity pool debugging for just this pool and draw more info about it"); REGISTER_CVAR(es_LayerSaveLoadSerialization, 0, VF_CHEAT, "Switches layer entity serialization: \n" "0 - serialize all \n" "1 - automatically ignore entities on disabled layers \n" "2 - only ignore entities on non-save layers."); REGISTER_CVAR(es_LayerDebugInfo, 0, VF_CHEAT, "Render debug info on active layers: \n" "0 - inactive \n" "1 - active brush layers \n" "2 - all layer info \n" "3 - all layer and all layer pak info"); REGISTER_CVAR(es_SaveLoadUseLUANoSaveFlag, 0, VF_CHEAT, "Save&Load optimization : use lua flag to not serialize entities, for example rigid bodies."); REGISTER_CVAR(es_ClearPoolBookmarksOnLayerUnload, 1, VF_CHEAT, "Clear pool bookmarks when a layer is unloaded (saves memory and makes smaller saves)"); pUpdateType = REGISTER_INT_CB("es_updateType", CComponentEventDistributer::EEventUpdatePolicy_UseDistributer, VF_CHEAT, "Defines how we update type for the entities", OnUpdateTypeChange); pDrawAreas = REGISTER_INT("es_DrawAreas",0,VF_CHEAT,"Enables drawing of Areas" ); pDrawAreaGrid = REGISTER_INT("es_DrawAreaGrid",0,VF_CHEAT,"Enables drawing of Area Grid" ); pDrawAreaDebug = REGISTER_INT("es_DrawAreaDebug",0,VF_CHEAT,"Enables debug drawing of Areas, set 2 for log details" ); pDrawAudioProxyZRay = REGISTER_INT("es_DrawAudioProxyZRay",0,VF_CHEAT,"Enables drawing of Z ray on check for Z visibility" ); REGISTER_CVAR(es_UsePhysVisibilityChecks, 1, 0, "Activates physics quality degradation and forceful sleeping for invisible and faraway entities" ); REGISTER_CVAR(es_MaxPhysDist, 300.0f, 0, "Physical entities farther from the camera than this are forcefully deactivated" ); REGISTER_CVAR(es_MaxPhysDistCloth, 300.0f, 0, "Cloth entities farther from the camera than this are forcefully deactivated" ); REGISTER_CVAR(es_MaxPhysDistInvisible, 40.0f, 0, "Invisible physical entities farther from the camera than this are forcefully deactivated" ); REGISTER_CVAR(es_FarPhysTimeout, 4.0f, 0, "Timeout for faraway physics forceful deactivation" ); pMotionBlur = gEnv->pConsole->GetCVar("r_MotionBlur"); pSysSpecLight = gEnv->pConsole->GetCVar("sys_spec_light"); if (pSysSpecLight && gEnv->IsEditor()) pSysSpecLight->SetOnChangeCallback( OnSysSpecLightChange ); REGISTER_CVAR(es_debugEntityLifetime,0,0, "Debug entities creation and deletion time" ); REGISTER_COMMAND("es_debugAnim", (ConsoleCommandFunc)EnableDebugAnimText, 0, "Debug entity animation (toggle on off)"); REGISTER_CVAR(es_EntityUpdatePosDelta, 0.1f, 0, "Indicates the position delta by which an entity must move before the AreaManager updates position relevant data.\n" "Default: 0.1 (10 cm)"); REGISTER_CVAR(es_debugDrawEntityIDs, 0, VF_CHEAT, "Displays the EntityId of all entities.\n" "Default is 0 (off), any other number enables it.\n" "Note: es_debug must be set to 1 also (or else the EntityId won't be displayed)"); }
int CGameStartup::Update(bool haveFocus, unsigned int updateFlags) { CRYPROFILE_SCOPE_PROFILE_MARKER("MT: MainLoop"); #if defined(JOBMANAGER_SUPPORT_PROFILING) gEnv->GetJobManager()->SetFrameStartTime(gEnv->pTimer->GetAsyncTime()); #endif int returnCode = 0; if (gEnv && gEnv->pSystem && gEnv->pConsole) { #ifdef WIN32 if(gEnv && gEnv->pRenderer && gEnv->pRenderer->GetHWND()) { bool focus = (::GetFocus() == gEnv->pRenderer->GetHWND()); static bool focused = focus; if (focus != focused) { if(gEnv->pSystem->GetISystemEventDispatcher()) { gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_CHANGE_FOCUS, focus, 0); } focused = focus; } } #endif } // update the game if (m_pMod) { returnCode = m_pMod->Update(haveFocus, updateFlags); } #if defined(ENABLE_STATS_AGENT) CStatsAgent::Update(); #endif #if defined(JOBMANAGER_SUPPORT_FRAMEPROFILER) // Update Backend profilers uint32 timeSample = JobManager::IWorkerBackEndProfiler::GetTimeSample(); assert(gEnv); PREFAST_ASSUME(gEnv); const JobManager::IBackend * const __restrict pBackends[] = { gEnv->GetJobManager()->GetBackEnd(JobManager::eBET_Thread), gEnv->GetJobManager()->GetBackEnd(JobManager::eBET_Blocking), }; for(int i=0; i<sizeof(pBackends)/sizeof(pBackends[0]); ++i) { if(pBackends[i]) { JobManager::IWorkerBackEndProfiler* pWorkerProfiler = pBackends[i]->GetBackEndWorkerProfiler(); pWorkerProfiler->Update(timeSample); } } #endif // ghetto fullscreen detection, because renderer does not provide any kind of listener if (!m_fullScreenCVarSetup && gEnv && gEnv->pSystem && gEnv->pConsole) { ICVar *pVar = gEnv->pConsole->GetCVar("r_Fullscreen"); if (pVar) { pVar->SetOnChangeCallback(FullScreenCVarChanged); m_fullScreenCVarSetup = true; } } #if ENABLE_AUTO_TESTER s_autoTesterSingleton.Update(); #endif GCOV_FLUSH_UPDATE; return returnCode; }
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; }