diff options
Diffstat (limited to 'engine/vgui_baseui_interface.cpp')
| -rw-r--r-- | engine/vgui_baseui_interface.cpp | 2371 |
1 files changed, 2371 insertions, 0 deletions
diff --git a/engine/vgui_baseui_interface.cpp b/engine/vgui_baseui_interface.cpp new file mode 100644 index 0000000..368485a --- /dev/null +++ b/engine/vgui_baseui_interface.cpp @@ -0,0 +1,2371 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Implements all the functions exported by the GameUI dll +// +// $NoKeywords: $ +//===========================================================================// + + +#include "client_pch.h" + +#include "tier0/platform.h" + +#ifdef IS_WINDOWS_PC +#include "winlite.h" +#endif +#include "appframework/ilaunchermgr.h" +#include <vgui_controls/Panel.h> +#include <vgui_controls/EditablePanel.h> +#include <matsys_controls/matsyscontrols.h> +#include <vgui/Cursor.h> +#include <vgui_controls/PHandle.h> +#include "keys.h" +#include "console.h" +#include "gl_matsysiface.h" +#include "cdll_engine_int.h" +#include "demo.h" +#include "sys_dll.h" +#include "sound.h" +#include "soundflags.h" +#include "filesystem_engine.h" +#include "igame.h" +#include "con_nprint.h" +#include "vgui_DebugSystemPanel.h" +#include "tier0/vprof.h" +#include "cl_demoactionmanager.h" +#include "enginebugreporter.h" +#include "engineperftools.h" +#include "icolorcorrectiontools.h" +#include "tier0/icommandline.h" +#include "client.h" +#include "server.h" +#include "sys.h" // Sys_GetRegKeyValue() +#include "vgui_drawtreepanel.h" +#include "vgui_vprofpanel.h" +#include "vgui/VGUI.h" +#include "vgui/IInput.h" +#include <vgui/IInputInternal.h> +#include "vgui_controls/AnimationController.h" +#include "vgui_vprofgraphpanel.h" +#include "vgui_texturebudgetpanel.h" +#include "vgui_budgetpanel.h" +#include "ivideomode.h" +#include "sourcevr/isourcevirtualreality.h" +#include "cl_pluginhelpers.h" +#include "cl_main.h" // CL_IsHL2Demo() +#include "cl_steamauth.h" + +// interface to gameui dll +#include <GameUI/IGameUI.h> +#include <GameUI/IGameConsole.h> + +// interface to expose vgui root panels +#include <ienginevgui.h> +#include "VGuiMatSurface/IMatSystemSurface.h" + +#include "cl_texturelistpanel.h" +#include "cl_demouipanel.h" +#include "cl_foguipanel.h" +#include "cl_txviewpanel.h" + +// vgui2 interface +// note that GameUI project uses ..\public\vgui and ..\public\vgui_controls, not ..\utils\vgui\include +#include <vgui/VGUI.h> +#include <vgui/Cursor.h> +#include <KeyValues.h> +#include <vgui/ILocalize.h> +#include <vgui/IPanel.h> +#include <vgui/IScheme.h> +#include <vgui/IVGui.h> +#include <vgui/ISystem.h> +#include <vgui/ISurface.h> +#include <vgui_controls/EditablePanel.h> + +#include <vgui_controls/MenuButton.h> +#include <vgui_controls/Menu.h> +#include <vgui_controls/PHandle.h> + +#include "IVguiModule.h" +#include "vgui_baseui_interface.h" +#include "vgui_DebugSystemPanel.h" +#include "toolframework/itoolframework.h" +#include "filesystem/IQueuedLoader.h" + +#if defined( _X360 ) +#include "xbox/xbox_win32stubs.h" +#endif + +#include "vgui_askconnectpanel.h" + +#if defined( REPLAY_ENABLED ) +#include "replay_internal.h" +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +#ifndef USE_SDL +extern HWND *pmainwindow; +#endif + +extern IVEngineClient *engineClient; +extern bool g_bTextMode; +static int g_syncReportLevel = -1; + +void VGui_ActivateMouse(); + +extern CreateInterfaceFn g_AppSystemFactory; + +// functions to reference GameUI and GameConsole functions, from GameUI.dll +IGameUI *staticGameUIFuncs = NULL; +IGameConsole *staticGameConsole = NULL; + +// cache some of the state we pass through to matsystemsurface, for visibility +bool s_bWindowsInputEnabled = true; + +ConVar r_drawvgui( "r_drawvgui", "1", FCVAR_CHEAT, "Enable the rendering of vgui panels" ); +ConVar gameui_xbox( "gameui_xbox", "0", 0 ); + +void Con_CreateConsolePanel( vgui::Panel *parent ); +void CL_CreateEntityReportPanel( vgui::Panel *parent ); +void ClearIOStates( void ); + +// turn this on if you're tuning progress bars +//#define ENABLE_LOADING_PROGRESS_PROFILING + +//----------------------------------------------------------------------------- +// Purpose: Console command to hide the gameUI, most commonly called from gameUI.dll +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_hide, "Hides the game UI" ) +{ + EngineVGui()->HideGameUI(); +} + +//----------------------------------------------------------------------------- +// Purpose: Console command to activate the gameUI, most commonly called from gameUI.dll +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_activate, "Shows the game UI" ) +{ + EngineVGui()->ActivateGameUI(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_preventescape, "Escape key doesn't hide game UI" ) +{ + EngineVGui()->SetNotAllowedToHideGameUI( true ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_allowescapetoshow, "Escape key allowed to show game UI" ) +{ + EngineVGui()->SetNotAllowedToShowGameUI( false ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_preventescapetoshow, "Escape key doesn't show game UI" ) +{ + EngineVGui()->SetNotAllowedToShowGameUI( true ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +CON_COMMAND( gameui_allowescape, "Escape key allowed to hide game UI" ) +{ + EngineVGui()->SetNotAllowedToHideGameUI( false ); +} + +//----------------------------------------------------------------------------- +// Purpose: Console command to enable progress bar for next load +//----------------------------------------------------------------------------- +void BaseUI_ProgressEnabled_f() +{ + EngineVGui()->EnabledProgressBarForNextLoad(); +} +static ConCommand progress_enable("progress_enable", &BaseUI_ProgressEnabled_f ); + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +class CEnginePanel : public vgui::EditablePanel +{ + typedef vgui::EditablePanel BaseClass; +public: + CEnginePanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName ) + { + //m_bCanFocus = true; + SetMouseInputEnabled( true ); + SetKeyBoardInputEnabled( true ); + } + + void EnableMouseFocus( bool state ) + { + //m_bCanFocus = state; + SetMouseInputEnabled( state ); + SetKeyBoardInputEnabled( state ); + } + +/* virtual vgui::VPANEL IsWithinTraverse(int x, int y, bool traversePopups) + { + if ( !m_bCanFocus ) + return NULL; + + vgui::VPANEL retval = BaseClass::IsWithinTraverse( x, y, traversePopups ); + if ( retval == GetVPanel() ) + return NULL; + return retval; + }*/ + +//private: +// bool m_bCanFocus; +}; + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +class CStaticPanel : public vgui::Panel +{ + typedef vgui::Panel BaseClass; + +public: + CStaticPanel( vgui::Panel *pParent, const char *pName ) : vgui::Panel( pParent, pName ) + { + SetCursor( vgui::dc_none ); + SetKeyBoardInputEnabled( false ); + SetMouseInputEnabled( false ); + } +}; + +vgui::VPanelHandle g_DrawTreeSelectedPanel; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +class CFocusOverlayPanel : public vgui::Panel +{ + typedef vgui::Panel BaseClass; + +public: + CFocusOverlayPanel( vgui::Panel *pParent, const char *pName ); + + virtual void PostChildPaint( void ); + static void GetColorForSlot( int slot, int& r, int& g, int& b ) + { + r = (int)( 124.0 + slot * 47.3 ) & 255; + g = (int)( 63.78 - slot * 71.4 ) & 255; + b = (int)( 188.42 + slot * 13.57 ) & 255; + } + + bool DrawTitleSafeOverlay( void ); + bool DrawFocusPanelList( void ); +}; + +//----------------------------------------------------------------------------- +// +// Purpose: Centerpoint for handling all user interface in the engine +// +//----------------------------------------------------------------------------- +class CEngineVGui : public IEngineVGuiInternal +{ +public: + CEngineVGui(); + ~CEngineVGui(); + + // Methods of IEngineVGui + virtual vgui::VPANEL GetPanel( VGuiPanel_t type ); + + // Methods of IEngineVGuiInternal + virtual void Init(); + virtual void Connect(); + virtual void Shutdown(); + virtual bool SetVGUIDirectories(); + virtual bool IsInitialized() const; + virtual bool Key_Event( const InputEvent_t &event ); + virtual void UpdateButtonState( const InputEvent_t &event ); + virtual void BackwardCompatibility_Paint(); + virtual void Paint( PaintMode_t mode ); + virtual void PostInit(); + + CreateInterfaceFn GetGameUIFactory() + { + return m_GameUIFactory; + } + + // handlers for game UI (main menu) + virtual void ActivateGameUI(); + virtual bool HideGameUI(); + virtual bool IsGameUIVisible(); + + // console + virtual void ShowConsole(); + virtual void HideConsole(); + virtual bool IsConsoleVisible(); + virtual void ClearConsole(); + + // level loading + virtual void OnLevelLoadingStarted(); + virtual void OnLevelLoadingFinished(); + virtual void NotifyOfServerConnect(const char *game, int IP, int connectionPort, int queryPort); + virtual void NotifyOfServerDisconnect(); + virtual void UpdateProgressBar(LevelLoadingProgress_e progress); + virtual void UpdateCustomProgressBar( float progress, const wchar_t *desc ); + virtual void StartCustomProgress(); + virtual void FinishCustomProgress(); + + virtual void EnabledProgressBarForNextLoad() + { + m_bShowProgressDialog = true; + } + + // Should pause? + virtual bool ShouldPause(); + virtual void ShowErrorMessage(); + + virtual void SetNotAllowedToHideGameUI( bool bNotAllowedToHide ) + { + m_bNotAllowedToHideGameUI = bNotAllowedToHide; + } + + virtual void SetNotAllowedToShowGameUI( bool bNotAllowedToShow ) + { + m_bNotAllowedToShowGameUI = bNotAllowedToShow; + } + + void SetGameDLLPanelsVisible( bool show ) + { + if ( !staticGameDLLPanel ) + { + return; + } + + staticGameDLLPanel->SetVisible( show ); + } + + virtual void ShowNewGameDialog( int chapter = -1 ); // -1 means just keep the currently select chapter + + // Xbox 360 + virtual void SessionNotification( const int notification, const int param = 0 ); + virtual void SystemNotification( const int notification ); + virtual void ShowMessageDialog( const uint nType, vgui::Panel *pOwner = NULL ); + virtual void UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost ); + virtual void SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping ); + virtual void OnCreditsFinished( void ); + + // Storage device validation: + // returns true right away if storage device has been previously selected. + // otherwise returns false and will set the variable pointed by pStorageDeviceValidated to 1 + // once the storage device is selected by user. + virtual bool ValidateStorageDevice( int *pStorageDeviceValidated ); + + void SetProgressBias( float bias ); + void UpdateProgressBar( float progress ); + + virtual void ConfirmQuit( void ); + +private: + vgui::Panel *GetRootPanel( VGuiPanel_t type ); + void SetEngineVisible( bool state ); + void DrawMouseFocus( void ); + void CreateVProfPanels( vgui::Panel *pParent ); + void DestroyVProfPanels( ); + + virtual void Simulate(); + + // debug overlays + bool IsDebugSystemVisible(); + void HideDebugSystem(); + + bool IsShiftKeyDown(); + bool IsAltKeyDown(); + bool IsCtrlKeyDown(); + + CON_COMMAND_MEMBER_F( CEngineVGui, "debugsystemui", ToggleDebugSystemUI, "Show/hide the debug system UI.", FCVAR_CHEAT ); + +private: + enum { MAX_NUM_FACTORIES = 5 }; + CreateInterfaceFn m_FactoryList[MAX_NUM_FACTORIES]; + int m_iNumFactories; + + CSysModule *m_hStaticGameUIModule; + CreateInterfaceFn m_GameUIFactory; + + // top level VGUI2 panel + CStaticPanel *staticPanel; + + // base level panels for other subsystems, rooted on staticPanel + CEnginePanel *staticClientDLLPanel; + CEnginePanel *staticClientDLLToolsPanel; + CEnginePanel *staticGameUIPanel; + CEnginePanel *staticGameDLLPanel; + + // Want engine tools to be on top of other engine panels + CEnginePanel *staticEngineToolsPanel; + CDebugSystemPanel *staticDebugSystemPanel; + CFocusOverlayPanel *staticFocusOverlayPanel; + +#ifdef VPROF_ENABLED + CVProfPanel *m_pVProfPanel; + CBudgetPanelEngine *m_pBudgetPanel; + CTextureBudgetPanel *m_pTextureBudgetPanel; +#endif + + // progress bar + bool m_bShowProgressDialog; + LevelLoadingProgress_e m_eLastProgressPoint; + + // progress bar debugging + int m_nLastProgressPointRepeatCount; + double m_flLoadingStartTime; + struct LoadingProgressEntry_t + { + double flTime; + LevelLoadingProgress_e eProgress; + }; + CUtlVector<LoadingProgressEntry_t> m_LoadingProgress; + + bool m_bSaveProgress : 1; + bool m_bNoShaderAPI : 1; + // game ui hiding control + bool m_bNotAllowedToHideGameUI : 1; + bool m_bNotAllowedToShowGameUI : 1; + + vgui::IInputInternal *m_pInputInternal; + + // used to start the progress from an arbitrary position + float m_ProgressBias; +}; + + +//----------------------------------------------------------------------------- +// Purpose: singleton accessor +//----------------------------------------------------------------------------- +static CEngineVGui g_EngineVGuiImp; +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineVGui, IEngineVGui, VENGINE_VGUI_VERSION, g_EngineVGuiImp ); + +IEngineVGuiInternal *EngineVGui() +{ + return &g_EngineVGuiImp; +} + +//----------------------------------------------------------------------------- +// The loader progress is updated by the queued loader. It uses an initial +// reserved portion of the bar. +//----------------------------------------------------------------------------- +#define PROGRESS_RESERVE 0.50f +class CLoaderProgress : public ILoaderProgress +{ +public: + CLoaderProgress() + { + // initialize to disabled state + m_SnappedProgress = -1; + } + + void BeginProgress() + { + g_EngineVGuiImp.SetProgressBias( 0 ); + m_SnappedProgress = 0; + } + + void UpdateProgress( float progress ) + { + if ( m_SnappedProgress == - 1 ) + { + // not enabled + return; + } + + int snappedProgress = progress * 15; + + // Need excessive updates on the 360 to keep the XBox slider inny bar active + if ( !IsX360() && ( snappedProgress <= m_SnappedProgress ) ) + { + // prevent excessive updates + return; + } + m_SnappedProgress = snappedProgress; + + // up to reserved + g_EngineVGuiImp.UpdateProgressBar( PROGRESS_RESERVE * progress ); + } + + void EndProgress() + { + // the normal legacy bar now picks up after reserved region + g_EngineVGuiImp.SetProgressBias( PROGRESS_RESERVE ); + m_SnappedProgress = -1; + } + +private: + int m_SnappedProgress; +}; +static CLoaderProgress s_LoaderProgress; + + +//----------------------------------------------------------------------------- +// Purpose: Constructor +//----------------------------------------------------------------------------- +CEngineVGui::CEngineVGui() +{ + staticPanel = NULL; + staticClientDLLToolsPanel = NULL; + staticClientDLLPanel = NULL; + staticGameDLLPanel = NULL; + staticGameUIPanel = NULL; + staticEngineToolsPanel = NULL; + staticDebugSystemPanel = NULL; + staticFocusOverlayPanel = NULL; + + m_hStaticGameUIModule = NULL; + m_GameUIFactory = NULL; + +#ifdef VPROF_ENABLED + m_pVProfPanel = NULL; +#endif + + m_bShowProgressDialog = false; + m_bSaveProgress = false; + m_bNoShaderAPI = false; + m_bNotAllowedToHideGameUI = false; + m_bNotAllowedToShowGameUI = false; + m_pInputInternal = NULL; + m_ProgressBias = 0; +} + + +//----------------------------------------------------------------------------- +// Purpose: Destructor +//----------------------------------------------------------------------------- +CEngineVGui::~CEngineVGui() +{ +} + + +//----------------------------------------------------------------------------- +// add all the base search paths used by VGUI (platform, skins directory, language dirs) +//----------------------------------------------------------------------------- +bool CEngineVGui::SetVGUIDirectories() +{ + // Legacy, not supported anymore + return true; +} + +//----------------------------------------------------------------------------- +// Setup the base vgui panels +//----------------------------------------------------------------------------- +void CEngineVGui::Init() +{ + COM_TimestampedLog( "Loading gameui.dll" ); + + // load the GameUI dll + const char *szDllName = "GameUI"; + m_hStaticGameUIModule = g_pFileSystem->LoadModule(szDllName, "EXECUTABLE_PATH", true); // LoadModule() does a GetLocalCopy() call + m_GameUIFactory = Sys_GetFactory(m_hStaticGameUIModule); + if ( !m_GameUIFactory ) + { + Error( "Could not load: %s\n", szDllName ); + } + + // get the initialization func + staticGameUIFuncs = (IGameUI *)m_GameUIFactory(GAMEUI_INTERFACE_VERSION, NULL); + if (!staticGameUIFuncs ) + { + Error( "Could not get IGameUI interface %s from %s\n", GAMEUI_INTERFACE_VERSION, szDllName ); + } + + if ( IsPC() ) + { + staticGameConsole = (IGameConsole *)m_GameUIFactory(GAMECONSOLE_INTERFACE_VERSION, NULL); + if ( !staticGameConsole ) + { + Sys_Error( "Could not get IGameConsole interface %s from %s\n", GAMECONSOLE_INTERFACE_VERSION, szDllName ); + } + } + + vgui::VGui_InitMatSysInterfacesList( "BaseUI", &g_AppSystemFactory, 1 ); + + // Get our langauge string + char lang[ 64 ]; + lang[0] = 0; + engineClient->GetUILanguage( lang, sizeof( lang ) ); + if ( lang[0] ) + vgui::system()->SetRegistryString( "HKEY_CURRENT_USER\\Software\\Valve\\Source\\Language", lang ); + + COM_TimestampedLog( "AttachToWindow" ); + + // Need to be able to play sounds through vgui + g_pMatSystemSurface->InstallPlaySoundFunc( VGui_PlaySound ); + + COM_TimestampedLog( "Load Scheme File" ); + + // load scheme + const char *pStr = "Resource/SourceScheme.res"; + if ( !vgui::scheme()->LoadSchemeFromFile( pStr, "Tracker" )) + { + Sys_Error( "Error loading file %s\n", pStr ); + return; + } + + if ( IsX360() ) + { + CCommand ccommand; + if ( CL_ShouldLoadBackgroundLevel( ccommand ) ) + { + // Must be before the game ui base panel starts up + // This is a hint to avoid the menu pop due to the impending background map + // that the game ui is not aware of until 1 frame later. + staticGameUIFuncs->SetProgressOnStart(); + } + } + + COM_TimestampedLog( "vgui::ivgui()->Start()" ); + + // Start the App running + vgui::ivgui()->Start(); + vgui::ivgui()->SetSleep(false); + + // setup base panel for the whole VGUI System + // The root panel for everything ( NULL parent makes it a child of the embedded panel ) + + // Ideal hierarchy: + + COM_TimestampedLog( "Building Panels (staticPanel)" ); + + // Root -- staticPanel + // staticBackgroundImagePanel (from gamui) zpos == 0 + // staticClientDLLPanel ( zpos == 25 ) + // staticClientDLLToolsPanel ( zpos == 28 + // staticGameDLLPanel ( zpos == 30 ) + // staticEngineToolsPanel ( zpos == 75 ) + // staticGameUIPanel ( GameUI stuff ) ( zpos == 100 ) + // staticDebugSystemPanel ( Engine debug stuff ) zpos == 125 ) + + staticPanel = new CStaticPanel( NULL, "staticPanel" ); + staticPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticPanel->SetPaintBorderEnabled(false); + staticPanel->SetPaintBackgroundEnabled(false); + staticPanel->SetPaintEnabled(false); + staticPanel->SetVisible(true); + staticPanel->SetCursor( vgui::dc_none ); + staticPanel->SetZPos(0); + staticPanel->SetVisible(true); + staticPanel->SetParent( vgui::surface()->GetEmbeddedPanel() ); + + COM_TimestampedLog( "Building Panels (staticClientDLLPanel)" ); + + staticClientDLLPanel = new CEnginePanel( staticPanel, "staticClientDLLPanel" ); + staticClientDLLPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticClientDLLPanel->SetPaintBorderEnabled(false); + staticClientDLLPanel->SetPaintBackgroundEnabled(false); + staticClientDLLPanel->SetKeyBoardInputEnabled( false ); // popups in the client DLL can enable this. + staticClientDLLPanel->SetPaintEnabled(false); + staticClientDLLPanel->SetVisible( false ); + staticClientDLLPanel->SetCursor( vgui::dc_none ); + staticClientDLLPanel->SetZPos( 25 ); + + CreateAskConnectPanel( staticPanel->GetVPanel() ); + + COM_TimestampedLog( "Building Panels (staticClientDLLToolsPanel)" ); + + staticClientDLLToolsPanel = new CEnginePanel( staticPanel, "staticClientDLLToolsPanel" ); + staticClientDLLToolsPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticClientDLLToolsPanel->SetPaintBorderEnabled(false); + staticClientDLLToolsPanel->SetPaintBackgroundEnabled(false); + staticClientDLLToolsPanel->SetKeyBoardInputEnabled( false ); // popups in the client DLL can enable this. + staticClientDLLToolsPanel->SetPaintEnabled(false); + staticClientDLLToolsPanel->SetVisible( true ); + staticClientDLLToolsPanel->SetCursor( vgui::dc_none ); + staticClientDLLToolsPanel->SetZPos( 28 ); + + staticEngineToolsPanel = new CEnginePanel( staticPanel, "Engine Tools" ); + staticEngineToolsPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticEngineToolsPanel->SetPaintBorderEnabled(false); + staticEngineToolsPanel->SetPaintBackgroundEnabled(false); + staticEngineToolsPanel->SetPaintEnabled(false); + staticEngineToolsPanel->SetVisible( true ); + staticEngineToolsPanel->SetCursor( vgui::dc_none ); + staticEngineToolsPanel->SetZPos( 75 ); + + COM_TimestampedLog( "Building Panels (staticGameUIPanel)" ); + + staticGameUIPanel = new CEnginePanel( staticPanel, "GameUI Panel" ); + staticGameUIPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticGameUIPanel->SetPaintBorderEnabled(false); + staticGameUIPanel->SetPaintBackgroundEnabled(false); + staticGameUIPanel->SetPaintEnabled(false); + staticGameUIPanel->SetVisible( true ); + staticGameUIPanel->SetCursor( vgui::dc_none ); + staticGameUIPanel->SetZPos( 100 ); + + staticGameDLLPanel = new CEnginePanel( staticPanel, "staticGameDLLPanel" ); + staticGameDLLPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticGameDLLPanel->SetPaintBorderEnabled(false); + staticGameDLLPanel->SetPaintBackgroundEnabled(false); + staticGameDLLPanel->SetKeyBoardInputEnabled( false ); // popups in the game DLL can enable this. + staticGameDLLPanel->SetPaintEnabled(false); + staticGameDLLPanel->SetCursor( vgui::dc_none ); + staticGameDLLPanel->SetZPos( 135 ); + + if ( CommandLine()->CheckParm( "-tools" ) != NULL ) + { + staticGameDLLPanel->SetVisible( true ); + } + else + { + staticGameDLLPanel->SetVisible( false ); + } + + if ( IsPC() ) + { + COM_TimestampedLog( "Building Panels (staticDebugSystemPanel)" ); + + staticDebugSystemPanel = new CDebugSystemPanel( staticPanel, "Engine Debug System" ); + staticDebugSystemPanel->SetZPos( 125 ); + + // Install demo playback/editing UI + CDemoUIPanel::InstallDemoUI( staticEngineToolsPanel ); + CDemoUIPanel2::Install( staticClientDLLPanel, staticEngineToolsPanel, true ); + + // Install fog control panel UI + CFogUIPanel::InstallFogUI( staticEngineToolsPanel ); + + // Install texture view panel + TxViewPanel::Install( staticEngineToolsPanel ); + + COM_TimestampedLog( "Install bug reporter" ); + + // Create and initialize bug reporting system + bugreporter->InstallBugReportingUI( staticGameUIPanel, IEngineBugReporter::BR_AUTOSELECT ); + bugreporter->Init(); + + COM_TimestampedLog( "Install perf tools" ); + + // Create a performance toolkit system + perftools->InstallPerformanceToolsUI( staticEngineToolsPanel ); + perftools->Init(); + + // Create a color correction UI + colorcorrectiontools->InstallColorCorrectionUI( staticEngineToolsPanel ); + colorcorrectiontools->Init(); + } + + // Make sure this is on top of everything + staticFocusOverlayPanel = new CFocusOverlayPanel( staticPanel, "FocusOverlayPanel" ); + staticFocusOverlayPanel->SetBounds( 0, 0, videomode->GetModeUIWidth(), videomode->GetModeUIHeight() ); + staticFocusOverlayPanel->SetZPos( 150 ); + staticFocusOverlayPanel->MoveToFront(); + + // Create engine vgui panels + if ( IsPC() ) + { + Con_CreateConsolePanel( staticEngineToolsPanel ); + CL_CreateEntityReportPanel( staticEngineToolsPanel ); + VGui_CreateDrawTreePanel( staticEngineToolsPanel ); + CL_CreateTextureListPanel( staticEngineToolsPanel ); + CreateVProfPanels( staticEngineToolsPanel ); + } + staticEngineToolsPanel->LoadControlSettings( "scripts/EngineVGuiLayout.res" ); + + COM_TimestampedLog( "materials->CacheUsedMaterials()" ); + + // Make sure that these materials are in the materials cache + materials->CacheUsedMaterials(); + + COM_TimestampedLog( "g_pVGuiLocalize->AddFile" ); + + // load the base localization file + g_pVGuiLocalize->AddFile( "Resource/valve_%language%.txt" ); + + COM_TimestampedLog( "staticGameUIFuncs->Initialize" ); + + staticGameUIFuncs->Initialize( g_AppSystemFactory ); + + COM_TimestampedLog( "staticGameUIFuncs->Start" ); + staticGameUIFuncs->Start(); + + // don't need to load the "valve" localization file twice + // Each mod acn have its own language.txt in addition to the valve_%%langauge%%.txt file under defaultgamedir. + // load mod-specific localization file for kb_act.lst, user.scr, settings.scr, etc. + char szFileName[MAX_PATH]; + Q_snprintf( szFileName, sizeof( szFileName ) - 1, "resource/%s_%%language%%.txt", GetCurrentMod() ); + szFileName[ sizeof( szFileName ) - 1 ] = '\0'; + g_pVGuiLocalize->AddFile( szFileName ); + + // setup console + if ( staticGameConsole ) + { + staticGameConsole->Initialize(); + staticGameConsole->SetParent(staticGameUIPanel->GetVPanel()); + } + + if ( IsX360() ) + { + // provide an interface for loader to send progress notifications + g_pQueuedLoader->InstallProgress( &s_LoaderProgress ); + } + + // show the game UI + COM_TimestampedLog( "ActivateGameUI()" ); + ActivateGameUI(); + + if ( staticGameConsole && + !CommandLine()->CheckParm( "-forcestartupmenu" ) && + !CommandLine()->CheckParm( "-hideconsole" ) && + ( CommandLine()->FindParm( "-toconsole" ) || CommandLine()->FindParm( "-console" ) || CommandLine()->FindParm( "-rpt" ) || CommandLine()->FindParm( "-allowdebug" ) ) ) + { + // activate the console + staticGameConsole->Activate(); + } + + m_bNoShaderAPI = CommandLine()->FindParm( "-noshaderapi" ); +} + +void CEngineVGui::PostInit() +{ + staticGameUIFuncs->PostInit(); +#if defined( _X360 ) + g_pMatSystemSurface->ClearTemporaryFontCache(); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: connects interfaces in gameui +//----------------------------------------------------------------------------- +void CEngineVGui::Connect() +{ + m_pInputInternal = (vgui::IInputInternal *)g_GameSystemFactory( VGUI_INPUTINTERNAL_INTERFACE_VERSION, NULL ); + staticGameUIFuncs->Connect( g_GameSystemFactory ); + +} + +//----------------------------------------------------------------------------- +// Create/destroy the vprof panels +//----------------------------------------------------------------------------- +void CEngineVGui::CreateVProfPanels( vgui::Panel *pParent ) +{ + if ( IsX360() ) + return; + +#ifdef VPROF_ENABLED + m_pVProfPanel = new CVProfPanel( pParent, "VProfPanel" ); + m_pBudgetPanel = new CBudgetPanelEngine( pParent, "BudgetPanel" ); + CreateVProfGraphPanel( pParent ); + m_pTextureBudgetPanel = new CTextureBudgetPanel( pParent, "TextureBudgetPanel" ); +#endif +} + +void CEngineVGui::DestroyVProfPanels( ) +{ + if ( IsX360() ) + return; + +#ifdef VPROF_ENABLED + if ( m_pVProfPanel ) + { + delete m_pVProfPanel; + m_pVProfPanel = NULL; + } + if ( m_pBudgetPanel ) + { + delete m_pBudgetPanel; + m_pBudgetPanel = NULL; + } + DestroyVProfGraphPanel(); + + if ( m_pTextureBudgetPanel ) + { + delete m_pTextureBudgetPanel; + m_pTextureBudgetPanel = NULL; + } +#endif +} + + +//----------------------------------------------------------------------------- +// Are we initialized? +//----------------------------------------------------------------------------- +bool CEngineVGui::IsInitialized() const +{ + return staticPanel != NULL; +} + +extern bool g_bUsingLegacyAppSystems; +//----------------------------------------------------------------------------- +// Purpose: Called to Shutdown the game UI system +//----------------------------------------------------------------------------- +void CEngineVGui::Shutdown() +{ + if ( IsPC() && CL_IsHL2Demo() ) // if they are playing the demo then open the storefront on shutdown + { + vgui::system()->ShellExecute("open", "steam://store_demo/220"); + } + + if ( IsPC() && CL_IsPortalDemo() ) // if they are playing the demo then open the storefront on shutdown + { + vgui::system()->ShellExecute("open", "steam://store_demo/400"); + } + + DestroyVProfPanels(); + bugreporter->Shutdown(); + colorcorrectiontools->Shutdown(); + perftools->Shutdown(); + + demoaction->Shutdown(); + + if ( g_PluginManager ) + { + g_PluginManager->Shutdown(); + } + + // HACK HACK: There was a bug in the old versions of the viewport which would crash in the case where the client .dll hadn't been fully unloaded, so + // we'll leak this panel here instead!!! + if ( g_bUsingLegacyAppSystems ) + { + staticClientDLLPanel->SetParent( (vgui::VPANEL)0 ); + } + + // This will delete the engine subpanel since it's a child + delete staticPanel; + staticPanel = NULL; + staticClientDLLToolsPanel = NULL; + staticClientDLLPanel = NULL; + staticEngineToolsPanel = NULL; + staticDebugSystemPanel = NULL; + staticFocusOverlayPanel = NULL; + staticGameDLLPanel = NULL; + + // Give panels a chance to settle so things + // Marked for deletion will actually get deleted + vgui::ivgui()->RunFrame(); + + // unload the gameUI + staticGameUIFuncs->Shutdown(); + + staticGameUIFuncs = NULL; + staticGameConsole = NULL; + staticGameUIPanel = NULL; + + // stop the App running + vgui::ivgui()->Stop(); + + // unload the dll + Sys_UnloadModule(m_hStaticGameUIModule); + m_hStaticGameUIModule = NULL; + m_GameUIFactory = NULL; + m_pInputInternal = NULL; +} + + +//----------------------------------------------------------------------------- +// Purpose: Retrieve specified root panel +//----------------------------------------------------------------------------- +inline vgui::Panel *CEngineVGui::GetRootPanel( VGuiPanel_t type ) +{ + if ( sv.IsDedicated() ) + { + return NULL; + } + + switch ( type ) + { + default: + case PANEL_ROOT: + return staticPanel; + case PANEL_CLIENTDLL: + return staticClientDLLPanel; + case PANEL_GAMEUIDLL: + return staticGameUIPanel; + case PANEL_TOOLS: + return staticEngineToolsPanel; + case PANEL_GAMEDLL: + return staticGameDLLPanel; + case PANEL_CLIENTDLL_TOOLS: + return staticClientDLLToolsPanel; + } +} + +vgui::VPANEL CEngineVGui::GetPanel( VGuiPanel_t type ) +{ + return GetRootPanel( type )->GetVPanel(); +} + +//----------------------------------------------------------------------------- +// Purpose: Toggle engine panel active/inactive +//----------------------------------------------------------------------------- +void CEngineVGui::SetEngineVisible( bool state ) +{ + if ( staticClientDLLPanel ) + { + staticClientDLLPanel->SetVisible( state ); + } +} + + +//----------------------------------------------------------------------------- +// Should pause? +//----------------------------------------------------------------------------- +bool CEngineVGui::ShouldPause() +{ + if ( IsPC() ) + { + return bugreporter->ShouldPause() || perftools->ShouldPause(); + } + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEngineVGui::ConfirmQuit() +{ + ActivateGameUI(); + staticGameUIFuncs->OnConfirmQuit(); +} + +//----------------------------------------------------------------------------- +// Purpose: Shows any GameUI related panels +//----------------------------------------------------------------------------- +void CEngineVGui::ActivateGameUI() +{ + if ( m_bNotAllowedToShowGameUI ) + return; + + if (!staticGameUIFuncs) + return; + +#if defined( REPLAY_ENABLED ) + // Don't allow the game UI to be activated when a replay is being rendered + if ( g_pReplayMovieManager && g_pReplayMovieManager->IsRendering() ) + return; +#endif + + // clear any keys that might be stuck down + ClearIOStates(); + + staticGameUIPanel->SetVisible(true); + staticGameUIPanel->MoveToFront(); + + staticClientDLLPanel->SetVisible(false); + staticClientDLLPanel->SetMouseInputEnabled(false); + + vgui::surface()->SetCursor( vgui::dc_arrow ); + + //staticGameDLLPanel->SetVisible( true ); + //staticGameDLLPanel->SetMouseInputEnabled( true ); + + SetEngineVisible( false ); + + staticGameUIFuncs->OnGameUIActivated(); +} + +//----------------------------------------------------------------------------- +// Purpose: Hides an Game UI related features (not client UI stuff tho!) +//----------------------------------------------------------------------------- +bool CEngineVGui::HideGameUI() +{ + if ( m_bNotAllowedToHideGameUI ) + return false; + + const char *levelName = engineClient->GetLevelName(); + bool bInNonBgLevel = levelName && levelName[0] && !engineClient->IsLevelMainMenuBackground(); + if ( bInNonBgLevel ) + { + staticGameUIPanel->SetVisible(false); + staticGameUIPanel->SetPaintBackgroundEnabled(false); + + staticClientDLLPanel->SetVisible(true); + staticClientDLLPanel->MoveToFront(); + staticClientDLLPanel->SetMouseInputEnabled(true); + + //staticGameDLLPanel->SetVisible( false ); + //staticGameDLLPanel->SetMouseInputEnabled(false); + + SetEngineVisible( true ); + + staticGameUIFuncs->OnGameUIHidden(); + } + else + { + // Tracker 18820: Pulling up options/console was perma-pausing the background levels, now we + // unpause them when you hit the Esc key even though the UI remains... + if ( levelName && + levelName[0] && + ( engineClient->GetMaxClients() <= 1 ) && + engineClient->IsPaused() ) + { + Cbuf_AddText("unpause\n"); + } + } + + VGui_MoveDrawTreePanelToFront(); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Hides the game console (but not the complete GameUI!) +//----------------------------------------------------------------------------- +void CEngineVGui::HideConsole() +{ + if ( IsX360() ) + return; + + if ( staticGameConsole ) + { + staticGameConsole->Hide(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: shows the console +//----------------------------------------------------------------------------- +void CEngineVGui::ShowConsole() +{ + if ( IsX360() ) + return; + + ActivateGameUI(); + + if ( staticGameConsole ) + { + staticGameConsole->Activate(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: returns true if the console is currently open +//----------------------------------------------------------------------------- +bool CEngineVGui::IsConsoleVisible() +{ + if ( IsPC() ) + { + return IsGameUIVisible() && staticGameConsole && staticGameConsole->IsConsoleVisible(); + } + else + { + // xbox has no drop down console + return false; + } +} + +//----------------------------------------------------------------------------- +// Purpose: clears all text from the console +//----------------------------------------------------------------------------- +void CEngineVGui::ClearConsole() +{ + if ( staticGameConsole ) + { + staticGameConsole->Clear(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: data accessor +//----------------------------------------------------------------------------- +bool CEngineVGui::IsGameUIVisible() +{ + return staticGameUIPanel && staticGameUIPanel->IsVisible(); +} + + +// list of progress bar strings +struct LoadingProgressDescription_t +{ + LevelLoadingProgress_e eProgress; // current progress + int nPercent; // % of the total time this is at + int nRepeat; // number of times this is expected to repeat (usually 0) + const char *pszDesc; // user description of progress +}; + +LoadingProgressDescription_t g_ListenServerLoadingProgressDescriptions[] = +{ + { PROGRESS_NONE, 0, 0, NULL }, + { PROGRESS_SPAWNSERVER, 2, 0, "#LoadingProgress_SpawningServer" }, + { PROGRESS_LOADWORLDMODEL, 4, 7, "#LoadingProgress_LoadMap" }, + { PROGRESS_CREATENETWORKSTRINGTABLES, 23, 0, NULL }, + { PROGRESS_PRECACHEWORLD, 23, 0, "#LoadingProgress_PrecacheWorld" }, + { PROGRESS_CLEARWORLD, 23, 0, NULL }, + { PROGRESS_LEVELINIT, 34, 0, "#LoadingProgress_LoadResources" }, + { PROGRESS_PRECACHE, 35, 239, NULL }, + { PROGRESS_ACTIVATESERVER, 68, 0, NULL }, + { PROGRESS_SIGNONCHALLENGE, 68, 0, NULL }, + { PROGRESS_SIGNONCONNECT, 70, 0, NULL }, + { PROGRESS_SIGNONCONNECTED, 73, 0, "#LoadingProgress_SignonLocal" }, + { PROGRESS_PROCESSSERVERINFO, 75, 0, NULL }, + { PROGRESS_PROCESSSTRINGTABLE, 77, 12, NULL }, // 16 + { PROGRESS_SIGNONNEW, 84, 0, NULL }, + { PROGRESS_SENDCLIENTINFO, 88, 0, NULL }, + { PROGRESS_SENDSIGNONDATA, 91, 0, "#LoadingProgress_SignonDataLocal" }, + { PROGRESS_SIGNONSPAWN, 94, 0, NULL }, + { PROGRESS_FULLYCONNECTED, 97, 0, NULL }, + { PROGRESS_READYTOPLAY, 99, 0, NULL }, + { PROGRESS_HIGHESTITEM, 100, 0, NULL }, +}; + +LoadingProgressDescription_t g_RemoteConnectLoadingProgressDescriptions[] = +{ + { PROGRESS_NONE, 0, 0, NULL }, + { PROGRESS_CHANGELEVEL, 1, 0, "#LoadingProgress_Changelevel" }, + { PROGRESS_BEGINCONNECT, 5, 0, "#LoadingProgress_BeginConnect" }, + { PROGRESS_SIGNONCHALLENGE, 10, 0, "#LoadingProgress_Connecting" }, + { PROGRESS_SIGNONCONNECTED, 15, 0, NULL }, + { PROGRESS_PROCESSSERVERINFO, 20, 0, "#LoadingProgress_ProcessServerInfo" }, + { PROGRESS_PROCESSSTRINGTABLE, 25, 11, NULL }, + { PROGRESS_LOADWORLDMODEL, 45, 7, "#LoadingProgress_LoadMap" }, + { PROGRESS_SIGNONNEW, 75, 0, NULL }, + { PROGRESS_SENDCLIENTINFO, 80, 0, "#LoadingProgress_SendClientInfo" }, + { PROGRESS_SENDSIGNONDATA, 85, 0, "#LoadingProgress_SignonData" }, + { PROGRESS_SIGNONSPAWN, 90, 0, NULL }, + { PROGRESS_FULLYCONNECTED, 95, 0, NULL }, + { PROGRESS_READYTOPLAY, 99, 0, NULL }, + { PROGRESS_HIGHESTITEM, 100, 0, NULL }, +}; + +static LoadingProgressDescription_t *g_pLoadingProgressDescriptions = NULL; + +//----------------------------------------------------------------------------- +// Purpose: returns current progress point description +//----------------------------------------------------------------------------- +LoadingProgressDescription_t &GetProgressDescription(int eProgress) +{ + // search for the item in the current list + int i = 0; + while (g_pLoadingProgressDescriptions[i].eProgress != PROGRESS_HIGHESTITEM) + { + // find the closest match + if (g_pLoadingProgressDescriptions[i].eProgress >= eProgress) + return g_pLoadingProgressDescriptions[i]; + + ++i; + } + + // not found + return g_pLoadingProgressDescriptions[0]; +} + +//----------------------------------------------------------------------------- +// Purpose: transition handler +//----------------------------------------------------------------------------- +void CEngineVGui::OnLevelLoadingStarted() +{ + if (!staticGameUIFuncs) + return; + + ConVar *pSyncReportConVar = g_pCVar->FindVar( "fs_report_sync_opens" ); + if ( pSyncReportConVar ) + { + // If convar is set to 2, suppress warnings during level load + g_syncReportLevel = pSyncReportConVar->GetInt(); + if ( g_syncReportLevel > 1 ) + { + pSyncReportConVar->SetValue( 0 ); + } + } + + if ( IsX360() ) + { + // TCR requirement, always!!! + m_bShowProgressDialog = true; + } + + // we've starting loading a level/connecting to a server + staticGameUIFuncs->OnLevelLoadingStarted( m_bShowProgressDialog ); + + // reset progress bar timers + m_flLoadingStartTime = Plat_FloatTime(); + m_LoadingProgress.RemoveAll(); + m_eLastProgressPoint = PROGRESS_NONE; + m_nLastProgressPointRepeatCount = 0; + m_ProgressBias = 0; + + // choose which progress bar to use + if (NET_IsMultiplayer()) + { + // we're connecting + g_pLoadingProgressDescriptions = g_RemoteConnectLoadingProgressDescriptions; + } + else + { + g_pLoadingProgressDescriptions = g_ListenServerLoadingProgressDescriptions; + } + + if ( m_bShowProgressDialog ) + { + ActivateGameUI(); + } + + m_bShowProgressDialog = false; +} + +//----------------------------------------------------------------------------- +// Purpose: transition handler +//----------------------------------------------------------------------------- +void CEngineVGui::OnLevelLoadingFinished() +{ + if (!staticGameUIFuncs) + return; + + staticGameUIFuncs->OnLevelLoadingFinished( gfExtendedError, gszDisconnectReason, gszExtendedDisconnectReason ); + m_eLastProgressPoint = PROGRESS_NONE; + + // clear any error message + gfExtendedError = false; + gszDisconnectReason[0] = 0; + gszExtendedDisconnectReason[0] = 0; + +#if defined(ENABLE_LOADING_PROGRESS_PROFILING) + // display progress bar stats (for debugging/tuning progress bar) + float flEndTime = (float)Plat_FloatTime(); + // add a finished entry + LoadingProgressEntry_t &entry = m_LoadingProgress[m_LoadingProgress.AddToTail()]; + entry.flTime = flEndTime - m_flLoadingStartTime; + entry.eProgress = PROGRESS_HIGHESTITEM; + // dump the info + Msg("Level load timings:\n"); + float flTotalTime = flEndTime - m_flLoadingStartTime; + int nRepeatCount = 0; + float flTimeTaken = 0.0f; + float flFirstLoadProgressTime = 0.0f; + for (int i = 0; i < m_LoadingProgress.Count() - 1; i++) + { + // keep track of time + flTimeTaken += (float)m_LoadingProgress[i+1].flTime - m_LoadingProgress[i].flTime; + + // keep track of how often something is repeated + if (m_LoadingProgress[i+1].eProgress == m_LoadingProgress[i].eProgress) + { + if (nRepeatCount == 0) + { + flFirstLoadProgressTime = m_LoadingProgress[i].flTime; + } + ++nRepeatCount; + continue; + } + + // work out the time it took to do this + if (nRepeatCount == 0) + { + flFirstLoadProgressTime = m_LoadingProgress[i].flTime; + } + + int nPerc = (int)(100 * (flFirstLoadProgressTime / flTotalTime)); + int nTickPerc = (int)(100 * ((float)m_LoadingProgress[i].eProgress / (float)PROGRESS_HIGHESTITEM)); + + // interpolated percentage is in between the real times and the most ticks + int nInterpPerc = (nPerc + nTickPerc) / 2; + Msg("\t%d\t%.3f\t\ttime: %d%%\t\tinterp: %d%%\t\trepeat: %d\n", m_LoadingProgress[i].eProgress, flTimeTaken, nPerc, nInterpPerc, nRepeatCount); + + // reset accumlated vars + nRepeatCount = 0; + flTimeTaken = 0.0f; + } +#endif // ENABLE_LOADING_PROGRESS_PROFILING + + HideGameUI(); + + // Restore convar setting after level load + if ( g_syncReportLevel > 1 ) + { + ConVar *pSyncReportConVar = g_pCVar->FindVar( "fs_report_sync_opens" ); + if ( pSyncReportConVar ) + { + pSyncReportConVar->SetValue( g_syncReportLevel ); + } + } +} + + +//----------------------------------------------------------------------------- +// Purpose: transition handler +//----------------------------------------------------------------------------- +void CEngineVGui::ShowErrorMessage() +{ + if (!staticGameUIFuncs || !gfExtendedError) + return; + + staticGameUIFuncs->OnLevelLoadingFinished( gfExtendedError, gszDisconnectReason, gszExtendedDisconnectReason ); + m_eLastProgressPoint = PROGRESS_NONE; + + // clear any error message + gfExtendedError = false; + gszDisconnectReason[0] = 0; + gszExtendedDisconnectReason[0] = 0; + + HideGameUI(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Updates progress +//----------------------------------------------------------------------------- +void CEngineVGui::UpdateProgressBar(LevelLoadingProgress_e progress) +{ + if (!staticGameUIFuncs) + return; + + if ( !ThreadInMainThread() ) + return; + +#if defined(ENABLE_LOADING_PROGRESS_PROFILING) + // track the progress times, for debugging & tuning + LoadingProgressEntry_t &entry = m_LoadingProgress[m_LoadingProgress.AddToTail()]; + entry.flTime = Plat_FloatTime() - m_flLoadingStartTime; + entry.eProgress = progress; +#endif + + if (!g_pLoadingProgressDescriptions) + return; + + // don't go backwards + if (progress < m_eLastProgressPoint) + return; + + // count progress repeats + if (progress == m_eLastProgressPoint) + { + ++m_nLastProgressPointRepeatCount; + } + else + { + m_nLastProgressPointRepeatCount = 0; + } + + // construct a string describing it + LoadingProgressDescription_t &desc = GetProgressDescription(progress); + + // calculate partial progress + float flPerc = desc.nPercent / 100.0f; + if ( desc.nRepeat > 1 && m_nLastProgressPointRepeatCount ) + { + // cap the repeat count + m_nLastProgressPointRepeatCount = min(m_nLastProgressPointRepeatCount, desc.nRepeat); + + // next progress point + float flNextPerc = GetProgressDescription(progress + 1).nPercent / 100.0f; + + // move along partially towards the next tick + flPerc += (flNextPerc - flPerc) * ((float)m_nLastProgressPointRepeatCount / desc.nRepeat); + } + + // the bias allows the loading bar to have an optional reserved initial band + // isolated from the normal progress descriptions + flPerc = flPerc * ( 1.0f - m_ProgressBias ) + m_ProgressBias; + + if ( staticGameUIFuncs->UpdateProgressBar( flPerc, desc.pszDesc ) ) + { + // re-render vgui on screen + extern void V_RenderVGuiOnly(); + V_RenderVGuiOnly(); + } + + m_eLastProgressPoint = progress; +} + +//----------------------------------------------------------------------------- +// Purpose: Updates progress +//----------------------------------------------------------------------------- +void CEngineVGui::UpdateCustomProgressBar( float progress, const wchar_t *desc ) +{ + if (!staticGameUIFuncs) + return; + + char ansi[1024]; + g_pVGuiLocalize->ConvertUnicodeToANSI( desc, ansi, sizeof( ansi ) ); + + if ( staticGameUIFuncs->UpdateProgressBar( progress, ansi ) ) + { + // re-render vgui on screen + extern void V_RenderVGuiOnly(); + V_RenderVGuiOnly(); + } +} + +void CEngineVGui::StartCustomProgress() +{ + if (!staticGameUIFuncs) + return; + + // we've starting loading a level/connecting to a server + staticGameUIFuncs->OnLevelLoadingStarted(true); + m_bSaveProgress = staticGameUIFuncs->SetShowProgressText( true ); +} + +void CEngineVGui::FinishCustomProgress() +{ + if (!staticGameUIFuncs) + return; + + staticGameUIFuncs->SetShowProgressText( m_bSaveProgress ); + staticGameUIFuncs->OnLevelLoadingFinished( false, "", "" ); +} + +void CEngineVGui::SetProgressBias( float bias ) +{ + m_ProgressBias = bias; +} + +void CEngineVGui::UpdateProgressBar( float progress ) +{ + if ( !staticGameUIFuncs ) + return; + + if ( staticGameUIFuncs->UpdateProgressBar( progress, "" ) ) + { + // re-render vgui on screen + extern void V_RenderVGuiOnly(); + V_RenderVGuiOnly(); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns 1 if the key event is handled, 0 if the engine should handle it +//----------------------------------------------------------------------------- +void CEngineVGui::UpdateButtonState( const InputEvent_t &event ) +{ + m_pInputInternal->UpdateButtonState( event ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns 1 if the key event is handled, 0 if the engine should handle it +//----------------------------------------------------------------------------- +bool CEngineVGui::Key_Event( const InputEvent_t &event ) +{ + bool bDown = event.m_nType != IE_ButtonReleased; + ButtonCode_t code = (ButtonCode_t)event.m_nData; + + if ( IsPC() && IsShiftKeyDown() ) + { + switch( code ) + { + case KEY_F1: + if ( bDown ) + { + Cbuf_AddText( "debugsystemui" ); + } + return true; + + case KEY_F2: + if ( bDown ) + { + Cbuf_AddText( "demoui" ); + } + return true; + } + } + +#if defined( _WIN32 ) + // Ignore alt tilde, since the Japanese IME uses this to toggle itself on/off + if ( IsPC() && code == KEY_BACKQUOTE && ( IsAltKeyDown() || IsCtrlKeyDown() ) ) + return true; +#endif + + // ESCAPE toggles game ui + if ( bDown && ( code == KEY_ESCAPE || code == KEY_XBUTTON_START || code == STEAMCONTROLLER_START) && !g_ClientDLL->HandleUiToggle() ) + { + if ( IsPC() ) + { + if ( IsGameUIVisible() ) + { + // Don't allow hiding of the game ui if there's no level + const char *pLevelName = engineClient->GetLevelName(); + if ( pLevelName && pLevelName[0] ) + { + Cbuf_AddText( "gameui_hide" ); + if ( IsDebugSystemVisible() ) + { + Cbuf_AddText( "debugsystemui 0" ); + } + } + } + else + { + Cbuf_AddText( "gameui_activate" ); + } + return true; + } + if ( IsX360() && !IsGameUIVisible() ) + { + // 360 UI does not toggle, engine does "show", but UI needs to handle "hide" + Cbuf_AddText( "gameui_activate" ); + return true; + } + } + + if ( g_pMatSystemSurface && g_pMatSystemSurface->HandleInputEvent( event ) ) + { + // always let the engine handle the console keys + // FIXME: Do a lookup of the key bound to toggleconsole + // want to cache it off so the lookup happens only when keys are bound? + if ( IsPC() && ( code == KEY_BACKQUOTE ) ) + return false; + return true; + } + return false; +} + +void CEngineVGui::Simulate() +{ + toolframework->VGui_PreSimulateAllTools(); + + if ( staticPanel ) + { + VPROF_BUDGET( "CEngineVGui::Simulate", VPROF_BUDGETGROUP_OTHER_VGUI ); + + // update vgui animations + //!! currently this has to be done once per dll, because the anim controller object is in a lib; + //!! need to make it globally pumped (gameUI.dll has it's own version of this) + vgui::GetAnimationController()->UpdateAnimations( Sys_FloatTime() ); + + int w, h; +#if defined( USE_SDL ) + uint width,height; + g_pLauncherMgr->RenderedSize( width, height, false ); // false = get + w = width; + h = height; +#else + if ( ::IsIconic( *pmainwindow ) ) + { + w = videomode->GetModeWidth(); + h = videomode->GetModeHeight(); + } + else + { + RECT rect; + ::GetClientRect(*pmainwindow, &rect); + + w = rect.right; + h = rect.bottom; + } +#endif + // don't hold this reference over RunFrame() + { + CMatRenderContextPtr pRenderContext( materials ); + pRenderContext->Viewport( 0, 0, w, h ); + } + + staticGameUIFuncs->RunFrame(); + vgui::ivgui()->RunFrame(); + + // Some debugging helpers + DrawMouseFocus(); + VGui_UpdateDrawTreePanel(); + VGui_UpdateTextureListPanel(); + + vgui::surface()->CalculateMouseVisible(); + VGui_ActivateMouse(); + } + +// if ( !vgui::ivgui()->IsRunning() ) +// Cbuf_AddText( "quit\n" ); + + toolframework->VGui_PostSimulateAllTools(); +} + +void CEngineVGui::BackwardCompatibility_Paint() +{ + Paint( (PaintMode_t)(PAINT_UIPANELS | PAINT_INGAMEPANELS) ); +} + + +//----------------------------------------------------------------------------- +// Purpose: paints all the vgui elements +//----------------------------------------------------------------------------- +void CEngineVGui::Paint( PaintMode_t mode ) +{ + VPROF_BUDGET( "CEngineVGui::Paint", VPROF_BUDGETGROUP_OTHER_VGUI ); + + if ( !staticPanel ) + return; + + // setup the base panel to cover the screen + vgui::VPANEL pVPanel = vgui::surface()->GetEmbeddedPanel(); + if ( !pVPanel ) + return; + + bool drawVgui = r_drawvgui.GetBool(); + + // Don't draw the console at all if vgui is off during a time demo + if ( demoplayer->IsPlayingTimeDemo() && !drawVgui ) + { + return; + } + + if ( !drawVgui || m_bNoShaderAPI ) + { + return; + } + + // draw from the main panel down + vgui::Panel *panel = staticPanel; + + // Force engine's root panel (staticPanel) to be full screen size + { + int x, y, w, h; + CMatRenderContextPtr pRenderContext( materials ); + pRenderContext->GetViewport( x, y, w, h ); + panel->SetBounds(0, 0, w, h); // ignore x and y here because the viewport takes care of that + } + + panel->Repaint(); + + toolframework->VGui_PreRenderAllTools( mode ); + + // Paint both ( backward compatibility support ) + + // It's either the full screen, or just the client .dll stuff + if ( mode & PAINT_UIPANELS ) + { + // Hide the client .dll, and paint everything else + bool saveVisible = staticClientDLLPanel->IsVisible(); + bool saveToolsVisible = staticClientDLLToolsPanel->IsVisible(); + staticClientDLLPanel->SetVisible( false ); + staticClientDLLToolsPanel->SetVisible( false ); + + vgui::surface()->PaintTraverseEx(pVPanel, true ); + + staticClientDLLPanel->SetVisible( saveVisible ); + staticClientDLLToolsPanel->SetVisible( saveToolsVisible ); + } + + if ( mode & PAINT_INGAMEPANELS ) + { + bool bSaveVisible = vgui::ipanel()->IsVisible( pVPanel ); + vgui::ipanel()->SetVisible( pVPanel, false ); + + // Remove the client .dll from the main hierarchy so that popups will only paint for the client .dll here + // NOTE: Disconnect each surface one at a time so that we don't draw popups twice + + // Paint the client .dll only + vgui::VPANEL ingameRoot = staticClientDLLPanel->GetVPanel(); + vgui::VPANEL saveParent = vgui::ipanel()->GetParent( ingameRoot ); + vgui::ipanel()->SetParent( ingameRoot, 0 ); + vgui::surface()->PaintTraverseEx( ingameRoot, true ); + vgui::ipanel()->SetParent( ingameRoot, saveParent ); + + // Overlay the client .dll tools next + vgui::VPANEL ingameToolsRoot = staticClientDLLToolsPanel->GetVPanel(); + vgui::VPANEL saveToolParent = vgui::ipanel()->GetParent( ingameToolsRoot ); + vgui::ipanel()->SetParent( ingameToolsRoot, 0 ); + vgui::surface()->PaintTraverseEx( ingameToolsRoot, true ); + vgui::ipanel()->SetParent( ingameToolsRoot, saveToolParent ); + + vgui::ipanel()->SetVisible( pVPanel, bSaveVisible ); + } + + if ( mode & PAINT_CURSOR ) + { + vgui::surface()->PaintSoftwareCursor(); + } + + toolframework->VGui_PostRenderAllTools( mode ); +} + +bool CEngineVGui::IsDebugSystemVisible( void ) +{ + return staticDebugSystemPanel ? staticDebugSystemPanel->IsVisible() : false; +} + +void CEngineVGui::HideDebugSystem( void ) +{ + if ( staticDebugSystemPanel ) + { + staticDebugSystemPanel->SetVisible( false ); + SetEngineVisible( true ); + } +} + + +void CEngineVGui::ToggleDebugSystemUI( const CCommand &args ) +{ + if ( !staticDebugSystemPanel ) + return; + + bool bVisible; + if ( args.ArgC() == 1 ) + { + // toggle the game UI + bVisible = !IsDebugSystemVisible(); + } + else + { + bVisible = atoi( args[1] ) != 0; + } + + if ( !bVisible ) + { + staticDebugSystemPanel->SetVisible( false ); + SetEngineVisible( true ); + } + else + { + // clear any keys that might be stuck down + ClearIOStates(); + staticDebugSystemPanel->SetVisible( true ); + SetEngineVisible( false ); + } +} + +bool CEngineVGui::IsShiftKeyDown( void ) +{ + if ( !vgui::input() ) + return false; + + return vgui::input()->IsKeyDown( KEY_LSHIFT ) || vgui::input()->IsKeyDown( KEY_RSHIFT ); +} + +bool CEngineVGui::IsAltKeyDown( void ) +{ + if ( !vgui::input() ) + return false; + + return vgui::input()->IsKeyDown( KEY_LALT ) || vgui::input()->IsKeyDown( KEY_RALT ); +} + +bool CEngineVGui::IsCtrlKeyDown( void ) +{ + if ( !vgui::input() ) + return false; + + return vgui::input()->IsKeyDown( KEY_LCONTROL ) || vgui::input()->IsKeyDown( KEY_RCONTROL ); +} + + +//----------------------------------------------------------------------------- +// Purpose: notification +//----------------------------------------------------------------------------- +void CEngineVGui::NotifyOfServerConnect(const char *pchGame, int IP, int connectionPort, int queryPort) +{ + if (!staticGameUIFuncs) + return; + + staticGameUIFuncs->OnConnectToServer2( pchGame, IP, connectionPort, queryPort); +} + +//----------------------------------------------------------------------------- +// Purpose: notification +//----------------------------------------------------------------------------- +void CEngineVGui::NotifyOfServerDisconnect() +{ + if (!staticGameUIFuncs) + return; + + staticGameUIFuncs->OnDisconnectFromServer( g_eSteamLoginFailure ); + g_eSteamLoginFailure = 0; +} + +//----------------------------------------------------------------------------- +// Xbox 360: Matchmaking sessions send progress notifications to GameUI +//----------------------------------------------------------------------------- +void CEngineVGui::SessionNotification( const int notification, const int param ) +{ + staticGameUIFuncs->SessionNotification( notification, param ); +} + +void CEngineVGui::SystemNotification( const int notification ) +{ + staticGameUIFuncs->SystemNotification( notification ); +} + +//----------------------------------------------------------------------------- +// Xbox 360: Show a message/error dialog +//----------------------------------------------------------------------------- +void CEngineVGui::ShowMessageDialog( const uint nType, vgui::Panel *pOwner ) +{ + ActivateGameUI(); + staticGameUIFuncs->ShowMessageDialog( nType, pOwner ); +} + +void CEngineVGui::UpdatePlayerInfo( uint64 nPlayerId, const char *pName, int nTeam, byte cVoiceState, int nPlayersNeeded, bool bHost ) +{ + staticGameUIFuncs->UpdatePlayerInfo( nPlayerId, pName, nTeam, cVoiceState, nPlayersNeeded, bHost ); +} + +void CEngineVGui::SessionSearchResult( int searchIdx, void *pHostData, XSESSION_SEARCHRESULT *pResult, int ping ) +{ + staticGameUIFuncs->SessionSearchResult( searchIdx, pHostData, pResult, ping ); +} + +//----------------------------------------------------------------------------- +// A helper to play sounds through vgui +//----------------------------------------------------------------------------- +void VGui_PlaySound( const char *pFileName ) +{ + // Point at origin if they didn't specify a sound source. + Vector vDummyOrigin; + vDummyOrigin.Init(); + + CSfxTable *pSound = (CSfxTable*)S_PrecacheSound(pFileName); + if ( pSound ) + { + S_MarkUISound( pSound ); + + StartSoundParams_t params; + params.staticsound = IsX360() ? true : false; + params.soundsource = cl.m_nViewEntity; + params.entchannel = CHAN_AUTO; + params.pSfx = pSound; + params.origin = vDummyOrigin; + params.pitch = PITCH_NORM; + params.soundlevel = SNDLVL_IDLE; + params.flags = 0; + params.fvol = 1.0f; + + S_StartSound( params ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void VGui_ActivateMouse() +{ + if ( !g_ClientDLL ) + return; + + // Don't mess with mouse if not active + if ( !game->IsActiveApp() ) + { + g_ClientDLL->IN_DeactivateMouse (); + return; + } + + /* + // + // MIKE AND ALFRED: these panels should expose whether they want mouse input or not and + // CalculateMouseVisible will take them into account. + // + // If showing game ui, make sure nothing else is hooking it + if ( Base().IsGameUIVisible() || Base().IsDebugSystemVisible() ) + { + g_ClientDLL->IN_DeactivateMouse(); + return; + } + */ + + if ( vgui::surface()->IsCursorLocked() && !g_bTextMode ) + { + g_ClientDLL->IN_ActivateMouse (); + } + else + { + g_ClientDLL->IN_DeactivateMouse (); + } +} + +static ConVar mat_drawTitleSafe( "mat_drawTitleSafe", "0", 0, "Enable title safe overlay" ); + +CUtlVector< vgui::VPANEL > g_FocusPanelList; + +ConVar vgui_drawfocus( "vgui_drawfocus", "0", 0, "Report which panel is under the mouse." ); + +CFocusOverlayPanel::CFocusOverlayPanel( vgui::Panel *pParent, const char *pName ) : vgui::Panel( pParent, pName ) +{ + SetPaintEnabled( false ); + SetPaintBorderEnabled( false ); + SetPaintBackgroundEnabled( false ); + + MakePopup(); + + SetPostChildPaintEnabled( true ); + SetKeyBoardInputEnabled( false ); + SetMouseInputEnabled( false ); +} + +bool CFocusOverlayPanel::DrawTitleSafeOverlay( void ) +{ + if ( !mat_drawTitleSafe.GetBool() ) + return false; + + int backBufferWidth, backBufferHeight; + materials->GetBackBufferDimensions( backBufferWidth, backBufferHeight ); + + int x, y, x1, y1; + + // Required Title safe is TCR documented at inner 90% (RED) + int insetX = 0.05f * backBufferWidth; + int insetY = 0.05f * backBufferHeight; + + x = insetX; + y = insetY; + x1 = backBufferWidth - insetX; + y1 = backBufferHeight - insetY; + + vgui::surface()->DrawSetColor( 255, 0, 0, 255 ); + vgui::surface()->DrawOutlinedRect( x, y, x1, y1 ); + + + // Suggested Title Safe is TCR documented at inner 85% (YELLOW) + insetX = 0.075f * backBufferWidth; + insetY = 0.075f * backBufferHeight; + + x = insetX; + y = insetY; + x1 = backBufferWidth - insetX; + y1 = backBufferHeight - insetY; + + vgui::surface()->DrawSetColor( 255, 255, 0, 255 ); + vgui::surface()->DrawOutlinedRect( x, y, x1, y1 ); + + return true; +} + +void CFocusOverlayPanel::PostChildPaint( void ) +{ + BaseClass::PostChildPaint(); + + bool bNeedsMoveToFront = false; + + if ( g_DrawTreeSelectedPanel ) + { + int x, y, x1, y1; + vgui::ipanel()->GetClipRect( g_DrawTreeSelectedPanel, x, y, x1, y1 ); + vgui::surface()->DrawSetColor( Color( 255, 0, 0, 255 ) ); + vgui::surface()->DrawOutlinedRect( x, y, x1, y1 ); + + bNeedsMoveToFront = true; + } + + if ( DrawTitleSafeOverlay() ) + { + bNeedsMoveToFront = true; + } + + if ( DrawFocusPanelList() ) + { + bNeedsMoveToFront = true; + } + + if ( bNeedsMoveToFront ) + { + // will be valid for the next frame + MoveToFront(); + } +} + +bool CFocusOverlayPanel::DrawFocusPanelList( void ) +{ + if( !vgui_drawfocus.GetBool() ) + return false; + + int c = g_FocusPanelList.Size(); + if ( c <= 0 ) + return false; + + int slot = 0; + int fullscreeninset = 0; + + for ( int i = 0; i < c; i++ ) + { + if ( slot > 31 ) + break; + + vgui::VPANEL vpanel = g_FocusPanelList[ i ]; + if ( !vpanel ) + continue; + + if ( !vgui::ipanel()->IsVisible( vpanel ) ) + return false; + + // Convert panel bounds to screen space + int r, g, b; + GetColorForSlot( slot, r, g, b ); + + int x, y, x1, y1; + vgui::ipanel()->GetClipRect( vpanel, x, y, x1, y1 ); + + if ( (x1 - x) == videomode->GetModeUIWidth() && + (y1 - y) == videomode->GetModeUIHeight() ) + { + x += fullscreeninset; + y += fullscreeninset; + x1 -= fullscreeninset; + y1 -= fullscreeninset; + fullscreeninset++; + } + vgui::surface()->DrawSetColor( Color( r, g, b, 255 ) ); + vgui::surface()->DrawOutlinedRect( x, y, x1, y1 ); + + slot++; + } + + return true; +} + + +static void VGui_RecursiveFindPanels( CUtlVector< vgui::VPANEL >& panelList, vgui::VPANEL check, char const *panelname ) +{ + vgui::Panel *panel = vgui::ipanel()->GetPanel( check, "ENGINE" ); + if ( !panel ) + return; + + if ( !Q_strncmp( panel->GetName(), panelname, strlen( panelname ) ) ) + { + panelList.AddToTail( panel->GetVPanel() ); + } + + int childcount = panel->GetChildCount(); + for ( int i = 0; i < childcount; i++ ) + { + vgui::Panel *child = panel->GetChild( i ); + VGui_RecursiveFindPanels( panelList, child->GetVPanel(), panelname ); + } +} + +void VGui_FindNamedPanels( CUtlVector< vgui::VPANEL >& panelList, char const *panelname ) +{ + vgui::VPANEL embedded = vgui::surface()->GetEmbeddedPanel(); + + // faster version of code below + // checks through each popup in order, top to bottom windows + int c = vgui::surface()->GetPopupCount(); + for (int i = c - 1; i >= 0; i--) + { + vgui::VPANEL popup = vgui::surface()->GetPopup(i); + if ( !popup ) + continue; + + if ( embedded == popup ) + continue; + + VGui_RecursiveFindPanels( panelList, popup, panelname ); + } + + VGui_RecursiveFindPanels( panelList, embedded, panelname ); +} + +CON_COMMAND( vgui_togglepanel, "show/hide vgui panel by name." ) +{ + if ( args.ArgC() < 2 ) + { + ConMsg( "Usage: vgui_showpanel panelname\n" ); + return; + } + + bool flip = false; + bool fg = true; + bool bg = true; + + if ( args.ArgC() == 5 ) + { + flip = atoi( args[ 2 ] ) ? true : false; + fg = atoi( args[ 3 ] ) ? true : false; + bg = atoi( args[ 4 ] ) ? true : false; + } + + char const *panelname = args[ 1 ]; + if ( !panelname || !panelname[ 0 ] ) + return; + + CUtlVector< vgui::VPANEL > panelList; + + VGui_FindNamedPanels( panelList, panelname ); + if ( !panelList.Size() ) + { + ConMsg( "No panels starting with %s\n", panelname ); + return; + } + + for ( int i = 0; i < panelList.Size(); i++ ) + { + vgui::VPANEL p = panelList[ i ]; + if ( !p ) + continue; + + vgui::Panel *panel = vgui::ipanel()->GetPanel( p, "ENGINE"); + if ( !panel ) + continue; + + Msg( "Toggling %s\n", panel->GetName() ); + + if ( fg ) + { + panel->SetPaintEnabled( flip ); + } + if ( bg ) + { + panel->SetPaintBackgroundEnabled( flip ); + } + } +} + +static void VGui_RecursePanel( CUtlVector< vgui::VPANEL >& panelList, int x, int y, vgui::VPANEL check, bool include_hidden ) +{ + if( !include_hidden && !vgui::ipanel()->IsVisible( check ) ) + { + return; + } + + if ( vgui::ipanel()->IsWithinTraverse( check, x, y, false ) ) + { + panelList.AddToTail( check ); + } + + int childcount = vgui::ipanel()->GetChildCount( check ); + for ( int i = 0; i < childcount; i++ ) + { + vgui::VPANEL child = vgui::ipanel()->GetChild( check, i ); + VGui_RecursePanel( panelList, x, y, child, include_hidden ); + } +} + +void CEngineVGui::DrawMouseFocus( void ) +{ + VPROF( "CEngineVGui::DrawMouseFocus" ); + + g_FocusPanelList.RemoveAll(); + + if ( !vgui_drawfocus.GetBool() ) + return; + + staticFocusOverlayPanel->MoveToFront(); + + bool include_hidden = vgui_drawfocus.GetInt() == 2; + + int x, y; + vgui::input()->GetCursorPos( x, y ); + + vgui::VPANEL embedded = vgui::surface()->GetEmbeddedPanel(); + + if ( vgui::surface()->IsCursorVisible() && vgui::surface()->IsWithin(x, y) ) + { + // faster version of code below + // checks through each popup in order, top to bottom windows + int c = vgui::surface()->GetPopupCount(); + for (int i = c - 1; i >= 0; i--) + { + vgui::VPANEL popup = vgui::surface()->GetPopup(i); + if ( !popup ) + continue; + + if ( popup == embedded ) + continue; + if ( !vgui::ipanel()->IsVisible( popup ) ) + continue; + + VGui_RecursePanel( g_FocusPanelList, x, y, popup, include_hidden ); + } + + VGui_RecursePanel( g_FocusPanelList, x, y, embedded, include_hidden ); + } + + // Now draw them + con_nprint_t np; + np.time_to_live = 1.0f; + + int c = g_FocusPanelList.Size(); + + int slot = 0; + for ( int i = 0; i < c; i++ ) + { + if ( slot > 31 ) + break; + + vgui::VPANEL vpanel = g_FocusPanelList[ i ]; + if ( !vpanel ) + continue; + + np.index = slot; + + int r, g, b; + CFocusOverlayPanel::GetColorForSlot( slot, r, g, b ); + + np.color[ 0 ] = r / 255.0f; + np.color[ 1 ] = g / 255.0f; + np.color[ 2 ] = b / 255.0f; + + Con_NXPrintf( &np, "%3i: %s\n", slot + 1, vgui::ipanel()->GetName(vpanel) ); + + slot++; + } + + while ( slot <= 31 ) + { + Con_NPrintf( slot, "" ); + slot++; + } +} + +void VGui_SetGameDLLPanelsVisible( bool show ) +{ + EngineVGui()->SetGameDLLPanelsVisible( show ); +} + +void CEngineVGui::ShowNewGameDialog( int chapter ) +{ + staticGameUIFuncs->ShowNewGameDialog( chapter ); +} + +void CEngineVGui::OnCreditsFinished( void ) +{ + staticGameUIFuncs->OnCreditsFinished(); +} + +bool CEngineVGui::ValidateStorageDevice(int *pStorageDeviceValidated) +{ + return staticGameUIFuncs->ValidateStorageDevice( pStorageDeviceValidated ); +} + +//----------------------------------------------------------------------------- +// Dump the panel hierarchy +//----------------------------------------------------------------------------- +void DumpPanels_r( vgui::VPANEL panel, int level ) +{ + int i; + + vgui::IPanel *ipanel = vgui::ipanel(); + + const char *pName = ipanel->GetName( panel ); + + char indentBuff[32]; + for (i=0; i<level; i++) + { + indentBuff[i] = '.'; + } + indentBuff[i] = '\0'; + + ConMsg( "%s%s\n", indentBuff, pName[0] ? pName : "???" ); + + int childcount = ipanel->GetChildCount( panel ); + for ( i = 0; i < childcount; i++ ) + { + vgui::VPANEL child = ipanel->GetChild( panel, i ); + DumpPanels_r( child, level+1 ); + } +} + +void DumpPanels_f() +{ + vgui::VPANEL embedded = vgui::surface()->GetEmbeddedPanel(); + DumpPanels_r( embedded, 0 ); +} +ConCommand DumpPanels("dump_panels", DumpPanels_f, "Dump Panel Tree" ); + +#if defined( _X360 ) +//----------------------------------------------------------------------------- +// Purpose: For testing message dialogs +//----------------------------------------------------------------------------- +#include "vgui_controls/MessageDialog.h" +CON_COMMAND( dlg_normal, "Display a sample message dialog" ) +{ + EngineVGui()->ShowMessageDialog( MD_STANDARD_SAMPLE ); +} + +CON_COMMAND( dlg_warning, "Display a sample warning message dialog" ) +{ + EngineVGui()->ShowMessageDialog( MD_WARNING_SAMPLE ); +} + +CON_COMMAND( dlg_error, "Display a sample error message dialog" ) +{ + EngineVGui()->ShowMessageDialog( MD_ERROR_SAMPLE ); +} +#endif |