birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove (almost) all references to pRenderer (#651)

Browse Source 
Remove all references to pRenderer, except from the DebugDraw and LyShine Gems that are still being updated.
This commit is contained in:
bosnichd
2021-05-10 10:05:15 -06:00
committed by GitHub
parent 4a2e6a77b5
commit 440c40e490
191 changed files with 118 additions and 23548 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/CryEngine/CrySystem/SystemInit.cpp
+3 -402
View File
@@ -95,7 +95,6 @@
#include <IProcess.h>
#include <LyShine/ILyShine.h>
#include <HMDBus.h>
#include "HMDCVars.h"
#include <AzFramework/Archive/Archive.h>
#include <Pak/CryPakUtils.h>
@@ -112,7 +111,6 @@
#include "SystemCFG.h"
#include "AutoDetectSpec.h"
#include "ResourceManager.h"
#include "VisRegTest.h"
#include "MTSafeAllocator.h"
#include "NotificationNetwork.h"
#include "ExtensionSystem/CryFactoryRegistryImpl.h"
@@ -123,7 +121,6 @@
#include "ZLibDecompressor.h"
#include "ZStdDecompressor.h"
#include "LZ4Decompressor.h"
#include "OverloadSceneManager/OverloadSceneManager.h"
#include "ServiceNetwork.h"
#include "RemoteCommand.h"
#include "LevelSystem/LevelSystem.h"
@@ -134,9 +131,6 @@
#include <AzCore/Jobs/JobManagerBus.h>
#include <AzFramework/Driller/DrillerConsoleAPI.h>
#include "PerfHUD.h"
#include "MiniGUI/MiniGUI.h"
#if USE_STEAM
#include "Steamworks/public/steam/steam_api.h"
#include "Steamworks/public/steam/isteamremotestorage.h"
@@ -740,28 +734,6 @@ static void LoadDetectedSpec(ICVar* pVar)
GetISystem()->LoadConfiguration("editor.cfg");
}
bool bMultiGPUEnabled = false;
if (gEnv->pRenderer)
{
gEnv->pRenderer->EF_Query(EFQ_MultiGPUEnabled, bMultiGPUEnabled);
#if defined(AZ_PLATFORM_ANDROID)
AZStd::string gpuConfigFile;
const AZStd::string& adapterDesc = gEnv->pRenderer->GetAdapterDescription();
const AZStd::string& apiver = gEnv->pRenderer->GetApiVersion();
if (!adapterDesc.empty())
{
MobileSysInspect::GetSpecForGPUAndAPI(adapterDesc, apiver, gpuConfigFile);
GetISystem()->LoadConfiguration(gpuConfigFile.c_str(), pSysSpecOverrideSinkConsole);
}
#endif
}
if (bMultiGPUEnabled)
{
GetISystem()->LoadConfiguration("mgpu.cfg");
}
// override cvars just loaded based on current API version/GPU
GetISystem()->SetConfigSpec(static_cast<ESystemConfigSpec>(spec), platform, false);
@@ -1279,7 +1251,7 @@ void CSystem::ShutdownFileSystem()
}
/////////////////////////////////////////////////////////////////////////////////
bool CSystem::InitFileSystem_LoadEngineFolders(const SSystemInitParams& initParams)
bool CSystem::InitFileSystem_LoadEngineFolders(const SSystemInitParams&)
{
LOADING_TIME_PROFILE_SECTION;
{
@@ -1320,10 +1292,6 @@ bool CSystem::InitFileSystem_LoadEngineFolders(const SSystemInitParams& initPara
static const char* g_additionalConfig = gEnv->IsDedicated() ? "server_cfg" : "client_cfg";
LoadConfiguration(g_additionalConfig, nullptr, false);
if (initParams.bShaderCacheGen)
{
LoadConfiguration("shadercachegen.cfg");
}
// We do not use CVar groups on the consoles
AddCVarGroupDirectory("Config/CVarGroups");
@@ -1359,7 +1327,6 @@ bool CSystem::InitAudioSystem(const SSystemInitParams& initParams)
bool useRealAudioSystem = false;
if (!initParams.bPreview
&& !initParams.bShaderCacheGen
&& !initParams.bMinimal
&& !m_bDedicatedServer
&& m_sys_audio_disable->GetIVal() == 0)
@@ -1859,7 +1826,6 @@ bool CSystem::Init(const SSystemInitParams& startupParams)
m_env.bTesting = startupParams.bTesting;
m_env.bNoAssertDialog = startupParams.bTesting;
m_env.bNoRandomSeed = startupParams.bNoRandom;
m_bShaderCacheGenMode = startupParams.bShaderCacheGen;
m_bNoCrashDialog = gEnv->IsDedicated();
@@ -1938,9 +1904,6 @@ AZ_POP_DISABLE_WARNING
QueryVersionInfo();
DetectGameFolderAccessRights();
m_hInst = (WIN_HINSTANCE)startupParams.hInstance;
m_hWnd = (WIN_HWND)startupParams.hWnd;
m_bEditor = startupParams.bEditor;
m_bPreviewMode = startupParams.bPreview;
m_bTestMode = startupParams.bTestMode;
@@ -2226,11 +2189,6 @@ AZ_POP_DISABLE_WARNING
InlineInitializationProcessing("CSystem::Init Create console");
if (!startupParams.bSkipRenderer)
{
CreateRendererVars(startupParams);
}
// Need to load the engine.pak that includes the config files needed during initialization
m_env.pCryPak->OpenPack("@assets@", "Engine.pak");
#if defined(AZ_PLATFORM_ANDROID) || defined(AZ_PLATFORM_IOS)
@@ -2305,17 +2263,6 @@ AZ_POP_DISABLE_WARNING
// Optional user defined overrides
LoadConfiguration("user.cfg", pCVarsWhiteListConfigSink);
if (!startupParams.bSkipRenderer)
{
// Load the hmd.cfg if it exists. This will enable optional stereo rendering.
LoadConfiguration("hmd.cfg");
}
if (startupParams.bShaderCacheGen)
{
LoadConfiguration("shadercachegen.cfg", pCVarsWhiteListConfigSink);
}
#if defined(ENABLE_STATS_AGENT)
if (m_pCmdLine->FindArg(eCLAT_Pre, "useamblecfg"))
{
@@ -2365,30 +2312,6 @@ AZ_POP_DISABLE_WARNING
InlineInitializationProcessing("CSystem::Init LoadConfigurations");
m_env.pOverloadSceneManager = new COverloadSceneManager;
if (m_bDedicatedServer && m_rDriver)
{
m_sSavedRDriver = m_rDriver->GetString();
m_rDriver->Set("NULL");
}
#if defined(WIN32) || defined(WIN64)
if (!startupParams.bSkipRenderer)
{
if (azstricmp(m_rDriver->GetString(), "Auto") == 0)
{
m_rDriver->Set("DX11");
}
}
if (gEnv->IsEditor() && azstricmp(m_rDriver->GetString(), "DX12") == 0)
{
AZ_Warning(AZ_TRACE_SYSTEM_WINDOW, false, "DX12 mode is not supported in the editor. Reverting to DX11 mode.");
m_rDriver->Set("DX11");
}
#endif
#ifdef WIN32
if ((g_cvars.sys_WER) && (!startupParams.bMinimal))
{
@@ -2410,72 +2333,6 @@ AZ_POP_DISABLE_WARNING
m_thermalInfoHandler = AZStd::make_unique<ThermalInfoAndroidHandler>();
#endif
if (g_cvars.sys_rendersplashscreen && !startupParams.bEditor && !startupParams.bShaderCacheGen)
{
if (m_env.pRenderer)
{
LOADING_TIME_PROFILE_SECTION_NAMED("Rendering Splash Screen");
ITexture* pTex = m_env.pRenderer->EF_LoadTexture(g_cvars.sys_splashscreen, FT_DONT_STREAM | FT_NOMIPS | FT_USAGE_ALLOWREADSRGB);
//check the width and height as extra verification hack. This texture is loaded before the replace me, so there is
//no backup if it fails to load.
if (pTex && pTex->GetWidth() && pTex->GetHeight())
{
const int splashWidth = pTex->GetWidth();
const int splashHeight = pTex->GetHeight();
const int screenWidth = m_env.pRenderer->GetOverlayWidth();
const int screenHeight = m_env.pRenderer->GetOverlayHeight();
const float scaleX = (float)screenWidth / (float)splashWidth;
const float scaleY = (float)screenHeight / (float)splashHeight;
float scale = 1.0f;
switch (g_cvars.sys_splashScreenScaleMode)
{
case SSystemCVars::SplashScreenScaleMode_Fit:
{
scale = AZStd::GetMin(scaleX, scaleY);
}
break;
case SSystemCVars::SplashScreenScaleMode_Fill:
{
scale = AZStd::GetMax(scaleX, scaleY);
}
break;
}
const float w = splashWidth * scale;
const float h = splashHeight * scale;
const float x = (screenWidth - w) * 0.5f;
const float y = (screenHeight - h) * 0.5f;
const float vx = (800.0f / (float) screenWidth);
const float vy = (600.0f / (float) screenHeight);
m_env.pRenderer->SetViewport(0, 0, screenWidth, screenHeight);
#if defined(AZ_PLATFORM_IOS) || defined(AZ_PLATFORM_MAC)
// Pump system events in order to update the screen
AzFramework::ApplicationRequests::Bus::Broadcast(&AzFramework::ApplicationRequests::PumpSystemEventLoopUntilEmpty);
#endif
pTex->Release();
}
#if defined(AZ_PLATFORM_ANDROID)
bool engineSplashEnabled = (g_cvars.sys_rendersplashscreen != 0);
if (engineSplashEnabled)
{
AZ::Android::Utils::DismissSplashScreen();
}
#endif
}
else
{
AZ_Warning(AZ_TRACE_SYSTEM_WINDOW, false, "Could not load startscreen image: %s.", g_cvars.sys_splashscreen);
}
}
//////////////////////////////////////////////////////////////////////////
// Open basic pak files after intro movie playback started
//////////////////////////////////////////////////////////////////////////
@@ -2507,21 +2364,6 @@ AZ_POP_DISABLE_WARNING
m_pUserCallback->OnInitProgress("First time asset processing - may take a minute...");
}
//////////////////////////////////////////////////////////////////////////
// POST RENDERER
//////////////////////////////////////////////////////////////////////////
if (!startupParams.bSkipRenderer && m_env.pRenderer)
{
m_env.pRenderer->PostInit();
if (!startupParams.bShaderCacheGen)
{
// try to do a flush to keep the renderer busy during loading
m_env.pRenderer->TryFlush();
}
}
InlineInitializationProcessing("CSystem::Init Renderer::PostInit");
#ifdef SOFTCODE_SYSTEM_ENABLED
m_env.pSoftCodeMgr = new SoftCodeMgr();
#else
@@ -2537,10 +2379,8 @@ AZ_POP_DISABLE_WARNING
// - System cursor has to be enabled manually by the Game if needed; the custom UiCursor will typically be used instead
if (!gEnv->IsDedicated() &&
m_env.pRenderer &&
!gEnv->IsEditor() &&
!startupParams.bTesting &&
!m_pCmdLine->FindArg(eCLAT_Pre, "nomouse"))
!startupParams.bTesting)
{
AzFramework::InputSystemCursorRequestBus::Event(AzFramework::InputDeviceMouse::Id,
&AzFramework::InputSystemCursorRequests::SetSystemCursorState,
@@ -2561,7 +2401,7 @@ AZ_POP_DISABLE_WARNING
//////////////////////////////////////////////////////////////////////////
// UI. Should be after input and hardware mouse
//////////////////////////////////////////////////////////////////////////
if (!startupParams.bShaderCacheGen && !m_bDedicatedServer)
if (!m_bDedicatedServer)
{
AZ_Printf(AZ_TRACE_SYSTEM_WINDOW, "UI system initialization");
INDENT_LOG_DURING_SCOPE();
@@ -2573,21 +2413,6 @@ AZ_POP_DISABLE_WARNING
InlineInitializationProcessing("CSystem::Init InitShine");
//////////////////////////////////////////////////////////////////////////
// Create MiniGUI
//////////////////////////////////////////////////////////////////////////
if (!startupParams.bMinimal)
{
minigui::IMiniGUIPtr pMiniGUI;
if (CryCreateClassInstanceForInterface(cryiidof<minigui::IMiniGUI>(), pMiniGUI))
{
m_pMiniGUI = pMiniGUI.get();
m_pMiniGUI->Init();
}
}
InlineInitializationProcessing("CSystem::Init InitMiniGUI");
//////////////////////////////////////////////////////////////////////////
// CONSOLE
//////////////////////////////////////////////////////////////////////////
@@ -2612,62 +2437,6 @@ AZ_POP_DISABLE_WARNING
m_env.pRemoteCommandManager = new CRemoteCommandManager();
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// VR SYSTEM INITIALIZATION
//////////////////////////////////////////////////////////////////////////
if ((!startupParams.bSkipRenderer) && (!startupParams.bMinimal))
{
if (m_pUserCallback)
{
m_pUserCallback->OnInitProgress("Initializing VR Systems...");
}
AZStd::vector<AZ::VR::HMDInitBus*> devices;
AZ::VR::HMDInitRequestBus::EnumerateHandlers([&devices](AZ::VR::HMDInitBus* device)
{
devices.emplace_back(device);
return true;
});
// Order the devices so that devices that only support one type of HMD are ordered first as we want
// to use any device-specific drivers over more general ones.
std::sort(devices.begin(), devices.end(), [](AZ::VR::HMDInitBus* left, AZ::VR::HMDInitBus* right)
{
return left->GetInitPriority() > right->GetInitPriority();
});
//Start up a job to init the HMDs since they may take a while to start up
AZ::JobContext* jobContext = nullptr;
EBUS_EVENT_RESULT(jobContext, AZ::JobManagerBus, GetGlobalContext);
AZ::Job* hmdJob = AZ::CreateJobFunction([devices]()
{
// Loop through the attached devices and attempt to initialize them. We'll use the first
// one that succeeds since we currently only support a single HMD.
for (AZ::VR::HMDInitBus* device : devices)
{
if (device->AttemptInit())
{
// At this point if any device connected to the HMDDeviceRequestBus then we are good to go for VR.
EBUS_EVENT(AZ::VR::HMDDeviceRequestBus, OutputHMDInfo);
EBUS_EVENT(AZ::VR::HMDDeviceRequestBus, EnableDebugging, false);
// Since this was a job and we may have beaten the level's output_to_hmd cvar initialization
// We just want to retrigger the callback to this cvar
ICVar* outputToHMD = gEnv->pConsole->GetCVar("output_to_hmd");
if (outputToHMD != nullptr)
{
int outputToHMDVal = gEnv->pConsole->GetCVar("output_to_hmd")->GetIVal();
gEnv->pConsole->GetCVar("output_to_hmd")->Set(outputToHMDVal);
}
break;
}
}
}, true, jobContext);
hmdJob->Start();
}
if (m_pUserCallback)
{
m_pUserCallback->OnInitProgress("Initializing additional systems...");
@@ -2724,28 +2493,10 @@ AZ_POP_DISABLE_WARNING
m_pIZStdDecompressor = new CZStdDecompressor();
InlineInitializationProcessing("CSystem::Init ZStdDecompressor");
//////////////////////////////////////////////////////////////////////////
// Create PerfHUD
//////////////////////////////////////////////////////////////////////////
#if defined(USE_PERFHUD)
if (!gEnv->bTesting && !gEnv->IsInToolMode())
{
//Create late in Init so that associated CVars have already been created
ICryPerfHUDPtr pPerfHUD;
if (CryCreateClassInstanceForInterface(cryiidof<ICryPerfHUD>(), pPerfHUD))
{
m_pPerfHUD = pPerfHUD.get();
m_pPerfHUD->Init();
}
}
#endif
//////////////////////////////////////////////////////////////////////////
// Initialize task threads.
//////////////////////////////////////////////////////////////////////////
if (!startupParams.bSkipRenderer)
{
m_pThreadTaskManager->InitThreads();
@@ -2775,12 +2526,6 @@ AZ_POP_DISABLE_WARNING
AZ::Interface<AZ::IConsole>::Get()->VisitRegisteredFunctors([](AZ::ConsoleFunctorBase* functor) { AzConsoleToCryConsoleBinder::Visit(functor); });
AzConsoleToCryConsoleBinder::s_commandRegisteredHandler.Connect(AZ::Interface<AZ::IConsole>::Get()->GetConsoleCommandRegisteredEvent());
// final tryflush to be sure that all framework init request have been processed
if (!startupParams.bShaderCacheGen && m_env.pRenderer)
{
m_env.pRenderer->TryFlush();
}
if (g_cvars.sys_float_exceptions > 0)
{
if (g_cvars.sys_float_exceptions == 3 && gEnv->IsEditor()) // Turn off float exceptions in editor if sys_float_exceptions = 3
@@ -2874,99 +2619,6 @@ static string ConcatPath(const char* szPart1, const char* szPart2)
return ret;
}
static void ScreenshotCmd(IConsoleCmdArgs* pParams)
{
assert(pParams);
uint32 dwCnt = pParams->GetArgCount();
if (dwCnt <= 1)
{
if (!gEnv->IsEditing())
{
// open console one line only
//line should lie within title safe area, so calculate overscan border
Vec2 overscanBorders = Vec2(0.0f, 0.0f);
gEnv->pRenderer->EF_Query(EFQ_OverscanBorders, overscanBorders);
float yDelta = /*((float)gEnv->pRenderer->GetHeight())*/ 600.0f * overscanBorders.y;
//set console height depending on top/bottom overscan border
gEnv->pConsole->ShowConsole(true, (int)(16 + yDelta));
gEnv->pConsole->SetInputLine("Screenshot ");
}
else
{
gEnv->pLog->LogWithType(ILog::eInputResponse, "Screenshot <annotation> missing - no screenshot was done");
}
}
else
{
static int iScreenshotNumber = -1;
const char* szPrefix = "Screenshot";
uint32 dwPrefixSize = strlen(szPrefix);
char path[AZ::IO::IArchive::MaxPath];
path[sizeof(path) - 1] = 0;
gEnv->pCryPak->AdjustFileName("@user@/ScreenShots", path, AZ_ARRAY_SIZE(path), AZ::IO::IArchive::FLAGS_PATH_REAL | AZ::IO::IArchive::FLAGS_FOR_WRITING);
if (iScreenshotNumber == -1) // first time - find max number to start
{
auto pCryPak = gEnv->pCryPak;
AZ::IO::ArchiveFileIterator handle = pCryPak->FindFirst((string(path) + "/*").c_str()); // mastercd folder
if (handle)
{
do
{
int iCurScreenshotNumber;
if (_strnicmp(handle.m_filename.data(), szPrefix, dwPrefixSize) == 0)
{
int iCnt = azsscanf(handle.m_filename.data() + dwPrefixSize, "%d", &iCurScreenshotNumber);
if (iCnt)
{
iScreenshotNumber = max(iCurScreenshotNumber, iScreenshotNumber);
}
}
handle = pCryPak->FindNext(handle);
} while (handle);
pCryPak->FindClose(handle);
}
}
++iScreenshotNumber;
char szNumber[16];
azsprintf(szNumber, "%.4d ", iScreenshotNumber);
string sScreenshotName = string(szPrefix) + szNumber;
for (uint32 dwI = 1; dwI < dwCnt; ++dwI)
{
if (dwI > 1)
{
sScreenshotName += "_";
}
sScreenshotName += pParams->GetArg(dwI);
}
sScreenshotName.replace("\\", "_");
sScreenshotName.replace("/", "_");
sScreenshotName.replace(":", "_");
sScreenshotName.replace(".", "_");
gEnv->pConsole->ShowConsole(false);
CSystem* pCSystem = (CSystem*)(gEnv->pSystem);
pCSystem->GetDelayedScreeenshot() = string(path) + "/" + sScreenshotName;// to delay a screenshot call for a frame
}
}
// Helper to maintain backwards compatibility with our CVar but not force our new code to
// pull in CryCommon by routing through an environment variable
void CmdSetAwsLogLevel(IConsoleCmdArgs* pArgs)
@@ -3182,18 +2834,6 @@ void ChangeLogAllocations(ICVar* pVal)
}
}
static void VisRegTest(IConsoleCmdArgs* pParams)
{
CSystem* pCSystem = (CSystem*)(gEnv->pSystem);
CVisRegTest*& visRegTest = pCSystem->GetVisRegTestPtrRef();
if (!visRegTest)
{
visRegTest = new CVisRegTest();
}
visRegTest->Init(pParams);
}
//////////////////////////////////////////////////////////////////////////
void CSystem::CreateSystemVars()
{
@@ -3278,28 +2918,10 @@ void CSystem::CreateSystemVars()
attachVariable("sys_PakLogAllFileAccess", &g_cvars.archiveVars.nLogAllFileAccess, "Log all file access allowing you to easily see whether a file has been loaded directly, or which pak file.");
#endif
attachVariable("sys_PakValidateFileHash", &g_cvars.archiveVars.nValidateFileHashes, "Validate file hashes in pak files for collisions");
attachVariable("sys_LoadFrontendShaderCache", &g_cvars.archiveVars.nLoadFrontendShaderCache, "Load frontend shader cache (on/off)");
attachVariable("sys_UncachedStreamReads", &g_cvars.archiveVars.nUncachedStreamReads, "Enable stream reads via an uncached file handle");
attachVariable("sys_PakDisableNonLevelRelatedPaks", &g_cvars.archiveVars.nDisableNonLevelRelatedPaks, "Disables all paks that are not required by specific level; This is used with per level splitted assets.");
attachVariable("sys_PakWarnOnPakAccessFailures", &g_cvars.archiveVars.nWarnOnPakAccessFails, "If 1, access failure for Paks is treated as a warning, if zero it is only a log message.");
{
int nDefaultRenderSplashScreen = 1;
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION SYSTEMINIT_CPP_SECTION_10
#include AZ_RESTRICTED_FILE(SystemInit_cpp)
#endif
REGISTER_CVAR2("sys_rendersplashscreen", &g_cvars.sys_rendersplashscreen, nDefaultRenderSplashScreen, VF_NULL,
"Render the splash screen during game initialization");
REGISTER_CVAR2("sys_splashscreenscalemode", &g_cvars.sys_splashScreenScaleMode, static_cast<int>(SSystemCVars::SplashScreenScaleMode_Fill), VF_NULL,
"0 - scale to fit (letterbox)\n"
"1 - scale to fill (cropped)\n"
"Default is 1");
REGISTER_CVAR2("sys_splashscreen", &g_cvars.sys_splashscreen, "EngineAssets/Textures/startscreen.tif", VF_NULL,
"The splash screen to render during game initialization");
}
static const int fileSystemCaseSensitivityDefault = 0;
REGISTER_CVAR2("sys_FilesystemCaseSensitivity", &g_cvars.sys_FilesystemCaseSensitivity, fileSystemCaseSensitivityDefault, VF_NULL,
"0 - CryPak lowercases all input file names\n"
@@ -3452,10 +3074,6 @@ void CSystem::CreateSystemVars()
REGISTER_CVAR2("sys_streaming_max_finalize_per_frame", &g_cvars.sys_streaming_max_finalize_per_frame, 0, VF_NULL,
"Maximum stream finalizing calls per frame to reduce the CPU impact on main thread (0 to disable)");
REGISTER_CVAR2("sys_streaming_max_bandwidth", &g_cvars.sys_streaming_max_bandwidth, 0, VF_NULL, "Enables capping of max streaming bandwidth in MB/s");
REGISTER_CVAR2("az_streaming_stats", &g_cvars.az_streaming_stats, 0, VF_NULL, "Show stats from AZ::IO::Streamer\n"
"0=off\n"
"1=on\n"
);
REGISTER_CVAR2("sys_streaming_debug", &g_cvars.sys_streaming_debug, 0, VF_NULL, "Enable streaming debug information\n"
"0=off\n"
"1=Streaming Stats\n"
@@ -3580,12 +3198,6 @@ void CSystem::CreateSystemVars()
m_env.pConsole->CreateKeyBind("alt_keyboard_key_function_F12", "Screenshot");
m_env.pConsole->CreateKeyBind("alt_keyboard_key_function_F11", "RecordClip");
// screenshot functionality in system as console
REGISTER_COMMAND("Screenshot", &ScreenshotCmd, VF_BLOCKFRAME,
"Create a screenshot with annotation\n"
"e.g. Screenshot beach scene with shark\n"
"Usage: Screenshot <annotation text>");
/*
// experimental feature? - needs to be created very early
m_sys_filecache = REGISTER_INT("sys_FileCache",0,0,
@@ -3606,9 +3218,6 @@ void CSystem::CreateSystemVars()
"'test*' and 'info' log to the log file only\n"
"Usage: sys_RestoreSpec [test|test*|apply|info]");
REGISTER_COMMAND("VisRegTest", &VisRegTest, 0, "Run visual regression test.\n"
"Usage: VisRegTest [<name>=test] [<config>=visregtest.xml] [quit=false]");
#if defined(WIN32)
REGISTER_CVAR2("sys_display_threads", &g_cvars.sys_display_threads, 0, 0, "Displays Thread info");
#elif defined(AZ_RESTRICTED_PLATFORM)
@@ -3629,9 +3238,6 @@ void CSystem::CreateSystemVars()
REGISTER_CVAR2("sys_error_debugbreak", &g_cvars.sys_error_debugbreak, 0, VF_CHEAT, "__debugbreak() if a VALIDATOR_ERROR_DBGBREAK message is hit");
// [VR]
AZ::VR::HMDCVars::Register();
REGISTER_STRING("dlc_directory", "", 0, "Holds the path to the directory where DLC should be installed to and read from");
#if defined(MAP_LOADING_SLICING)
@@ -3694,11 +3300,6 @@ void CSystem::AddCVarGroupDirectory(const string& sPath)
string sCVarName = sFilePath;
PathUtil::RemoveExtension(sCVarName);
if (m_env.pConsole != 0)
{
((CXConsole*)m_env.pConsole)->RegisterCVarGroup(PathUtil::GetFile(sCVarName), sFilePath);
}
}
} while (handle = gEnv->pCryPak->FindNext(handle));