2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
# if defined( USE_SDL )
# undef PROTECTED_THINGS_ENABLE
# include "SDL.h"
# include "SDL_syswm.h"
# if defined( OSX )
# define DONT_DEFINE_BOOL
# include <objc/message.h>
# endif
# endif
# if defined( WIN32 ) && !defined( _X360 ) && !defined( DX_TO_GL_ABSTRACTION )
# include "winlite.h"
# include "xbox/xboxstubs.h"
# endif
# if defined( IS_WINDOWS_PC ) && !defined( USE_SDL )
# include <winsock.h>
# elif defined(_X360)
// nothing to include for 360
# elif defined(OSX)
# elif defined(LINUX)
# include "tier0/dynfunction.h"
# elif defined(_WIN32)
# include "tier0/dynfunction.h"
# else
# error
# endif
# include "appframework/ilaunchermgr.h"
# include "igame.h"
# include "cl_main.h"
# include "host.h"
# include "quakedef.h"
# include "tier0/vcrmode.h"
# include "tier0/icommandline.h"
# include "ivideomode.h"
# include "gl_matsysiface.h"
# include "cdll_engine_int.h"
# include "vgui_baseui_interface.h"
# include "iengine.h"
# include "keys.h"
# include "VGuiMatSurface/IMatSystemSurface.h"
# include "tier3/tier3.h"
# include "sound.h"
# include "vgui_controls/Controls.h"
# include "vgui_controls/MessageDialog.h"
# include "sys_dll.h"
# include "inputsystem/iinputsystem.h"
# include "inputsystem/ButtonCode.h"
# ifdef WIN32
# undef WIN32_LEAN_AND_MEAN
# include "unicode/unicode.h"
# endif
# include "GameUI/IGameUI.h"
# include "matchmaking.h"
# include "sv_main.h"
# include "video/ivideoservices.h"
# include "sys.h"
# include "materialsystem/imaterial.h"
# if defined( _X360 )
# include "xbox/xbox_win32stubs.h"
# include "hl2orange.spa.h"
# endif
# if defined( LINUX )
# include "snd_dev_sdl.h"
# endif
# ifdef DBGFLAG_ASSERT
# define AssertExit( _exp ) Assert( _exp )
# define AssertExitF( _exp ) Assert( _exp )
# else
# define AssertExit( _exp ) if ( !( _exp ) ) return;
# define AssertExitF( _exp ) if ( !( _exp ) ) return false;
# endif
// memdbgon must be the last include file in a .cpp file!!!
# include "tier0/memdbgon.h"
void S_BlockSound ( void ) ;
void S_UnblockSound ( void ) ;
void ClearIOStates ( void ) ;
//-----------------------------------------------------------------------------
// Game input events
//-----------------------------------------------------------------------------
enum GameInputEventType_t
{
IE_Close = IE_FirstAppEvent ,
IE_WindowMove ,
IE_AppActivated ,
} ;
# ifdef WIN32
static IUnicodeWindows * unicode = NULL ;
# endif
//-----------------------------------------------------------------------------
// Purpose: Main game interface, including message pump and window creation
//-----------------------------------------------------------------------------
class CGame : public IGame
{
public :
CGame ( void ) ;
virtual ~ CGame ( void ) ;
bool Init ( void * pvInstance ) ;
bool Shutdown ( void ) ;
bool CreateGameWindow ( void ) ;
void DestroyGameWindow ( ) ;
void SetGameWindow ( void * hWnd ) ;
// This is used in edit mode to override the default wnd proc associated w/
bool InputAttachToGameWindow ( ) ;
void InputDetachFromGameWindow ( ) ;
void PlayStartupVideos ( void ) ;
// This is the SDL_Window* under SDL, HWND otherwise.
void * GetMainWindow ( void ) ;
// This will be the HWND under D3D + Windows (both with and without SDL), SDL_Window* everywhere else.
void * GetMainDeviceWindow ( void ) ;
// This will be the HWND under Windows, the WindowRef under Mac, and (for now) NULL on Linux
void * GetMainWindowPlatformSpecificHandle ( void ) ;
void * * GetMainWindowAddress ( void ) ;
void GetDesktopInfo ( int & width , int & height , int & refreshrate ) ;
void SetWindowXY ( int x , int y ) ;
void SetWindowSize ( int w , int h ) ;
void GetWindowRect ( int * x , int * y , int * w , int * h ) ;
bool IsActiveApp ( void ) ;
void SetCanPostActivateEvents ( bool bEnable ) ;
bool CanPostActivateEvents ( ) ;
public :
# ifdef USE_SDL
void SetMainWindow ( SDL_Window * window ) ;
# else
# ifdef WIN32
int WindowProc ( HWND hWnd , UINT uMsg , WPARAM wParam , LPARAM lParam ) ;
# endif
void SetMainWindow ( HWND window ) ;
# endif
void SetActiveApp ( bool active ) ;
bool LoadUnicode ( ) ;
void UnloadUnicode ( ) ;
// Message handlers.
public :
void HandleMsg_WindowMove ( const InputEvent_t & event ) ;
void HandleMsg_ActivateApp ( const InputEvent_t & event ) ;
void HandleMsg_Close ( const InputEvent_t & event ) ;
// Call the appropriate HandleMsg_ function.
void DispatchInputEvent ( const InputEvent_t & event ) ;
// Dispatch all the queued up messages.
virtual void DispatchAllStoredGameMessages ( ) ;
private :
void AppActivate ( bool fActive ) ;
void PlayVideoAndWait ( const char * filename , bool bNeedHealthWarning = false ) ; // plays a video file and waits till it's done to return. Can be interrupted by user.
private :
void AttachToWindow ( ) ;
void DetachFromWindow ( ) ;
# ifndef _X360
static const wchar_t CLASSNAME [ ] ;
# else
static const char CLASSNAME [ ] ;
# endif
bool m_bExternallySuppliedWindow ;
# if defined( WIN32 )
HWND m_hWindow ;
# if !defined( USE_SDL )
HINSTANCE m_hInstance ;
// Stores a wndproc to chain message calls to
WNDPROC m_ChainedWindowProc ;
RECT m_rcLastRestoredClientRect ;
# endif
# endif
# if defined( USE_SDL )
SDL_Window * m_pSDLWindow ;
# endif
int m_x ;
int m_y ;
int m_width ;
int m_height ;
bool m_bActiveApp ;
CSysModule * m_hUnicodeModule ;
bool m_bCanPostActivateEvents ;
int m_iDesktopWidth , m_iDesktopHeight , m_iDesktopRefreshRate ;
void UpdateDesktopInformation ( ) ;
# ifdef WIN32
void UpdateDesktopInformation ( WPARAM wParam , LPARAM lParam ) ;
# endif
} ;
static CGame g_Game ;
IGame * game = ( IGame * ) & g_Game ;
# if !defined( _X360 )
const wchar_t CGame : : CLASSNAME [ ] = L " Valve001 " ;
# else
const char CGame : : CLASSNAME [ ] = " Valve001 " ;
# endif
// In VCR playback mode, it sleeps this amount each frame.
int g_iVCRPlaybackSleepInterval = 0 ;
// During VCR playback, if this is true, then it'll pause at the end of each frame.
bool g_bVCRSingleStep = false ;
bool g_bWaitingForStepKeyUp = false ; // Used to prevent it from running frames while you hold the S key down.
bool g_bShowVCRPlaybackDisplay = true ;
// These are all the windows messages that can change game state.
// See CGame::WindowProc for a description of how they work.
struct GameMessageHandler_t
{
int m_nEventType ;
void ( CGame : : * pFn ) ( const InputEvent_t & event ) ;
} ;
GameMessageHandler_t g_GameMessageHandlers [ ] =
{
{ IE_AppActivated , & CGame : : HandleMsg_ActivateApp } ,
{ IE_WindowMove , & CGame : : HandleMsg_WindowMove } ,
{ IE_Close , & CGame : : HandleMsg_Close } ,
{ IE_Quit , & CGame : : HandleMsg_Close } ,
} ;
void CGame : : AppActivate ( bool fActive )
{
// If text mode, force it to be active.
if ( g_bTextMode )
{
fActive = true ;
}
// Don't bother if we're already in the correct state
if ( IsActiveApp ( ) = = fActive )
return ;
// Don't let video modes changes queue up another activate event
SetCanPostActivateEvents ( false ) ;
# ifndef SWDS
if ( videomode )
{
if ( fActive )
{
videomode - > RestoreVideo ( ) ;
}
else
{
videomode - > ReleaseVideo ( ) ;
}
}
if ( host_initialized )
{
if ( fActive )
{
// Clear keyboard states (should be cleared already but...)
// VGui_ActivateMouse will reactivate the mouse soon.
ClearIOStates ( ) ;
UpdateMaterialSystemConfig ( ) ;
}
else
{
// Clear keyboard input and deactivate the mouse while we're away.
ClearIOStates ( ) ;
if ( g_ClientDLL )
{
g_ClientDLL - > IN_DeactivateMouse ( ) ;
}
}
}
# endif // SWDS
SetActiveApp ( fActive ) ;
# ifdef _XBOX
if ( host_initialized )
{
ClearIOStates ( ) ;
if ( fActive )
{
UpdateMaterialSystemConfig ( ) ;
}
}
SetActiveApp ( fActive ) ;
# endif
// Allow queueing of activation events
SetCanPostActivateEvents ( true ) ;
}
void CGame : : HandleMsg_WindowMove ( const InputEvent_t & event )
{
game - > SetWindowXY ( event . m_nData , event . m_nData2 ) ;
# ifndef SWDS
videomode - > UpdateWindowPosition ( ) ;
# endif
}
void CGame : : HandleMsg_ActivateApp ( const InputEvent_t & event )
{
AppActivate ( event . m_nData ? true : false ) ;
}
void CGame : : HandleMsg_Close ( const InputEvent_t & event )
{
if ( eng - > GetState ( ) = = IEngine : : DLL_ACTIVE )
{
eng - > SetQuitting ( IEngine : : QUIT_TODESKTOP ) ;
}
}
void CGame : : DispatchInputEvent ( const InputEvent_t & event )
{
switch ( event . m_nType )
{
// Handle button events specially,
// since we have all manner of crazy filtering going on when dealing with them
case IE_ButtonPressed :
case IE_ButtonDoubleClicked :
case IE_ButtonReleased :
Key_Event ( event ) ;
break ;
2021-10-09 12:22:16 +00:00
case IE_FingerDown :
case IE_FingerUp :
case IE_FingerMotion :
if ( g_ClientDLL )
g_ClientDLL - > IN_TouchEvent ( event . m_nType , event . m_nData , event . m_nData2 , event . m_nData3 ) ;
2020-04-22 16:56:21 +00:00
default :
// Let vgui have the first whack at events
if ( g_pMatSystemSurface & & g_pMatSystemSurface - > HandleInputEvent ( event ) )
break ;
for ( int i = 0 ; i < ARRAYSIZE ( g_GameMessageHandlers ) ; i + + )
{
if ( g_GameMessageHandlers [ i ] . m_nEventType = = event . m_nType )
{
( this - > * g_GameMessageHandlers [ i ] . pFn ) ( event ) ;
break ;
}
}
break ;
}
}
void CGame : : DispatchAllStoredGameMessages ( )
{
# if !defined( NO_VCR )
if ( VCRGetMode ( ) = = VCR_Playback )
{
InputEvent_t event ;
while ( VCRHook_PlaybackGameMsg ( & event ) )
{
event . m_nTick = g_pInputSystem - > GetPollTick ( ) ;
DispatchInputEvent ( event ) ;
}
}
else
{
int nEventCount = g_pInputSystem - > GetEventCount ( ) ;
const InputEvent_t * pEvents = g_pInputSystem - > GetEventData ( ) ;
for ( int i = 0 ; i < nEventCount ; + + i )
{
VCRHook_RecordGameMsg ( pEvents [ i ] ) ;
DispatchInputEvent ( pEvents [ i ] ) ;
}
VCRHook_RecordEndGameMsg ( ) ;
}
# else
int nEventCount = g_pInputSystem - > GetEventCount ( ) ;
const InputEvent_t * pEvents = g_pInputSystem - > GetEventData ( ) ;
for ( int i = 0 ; i < nEventCount ; + + i )
{
DispatchInputEvent ( pEvents [ i ] ) ;
}
# endif
}
void VCR_EnterPausedState ( )
{
// Turn this off in case they're in single-step mode.
g_bVCRSingleStep = false ;
# ifdef WIN32
// This is cheesy, but GetAsyncKeyState is blocked (in protected_things.h)
// from being accidentally used, so we get it through it by getting its pointer directly.
static HINSTANCE hInst = LoadLibrary ( " user32.dll " ) ;
if ( ! hInst )
return ;
typedef SHORT ( WINAPI * GetAsyncKeyStateFn ) ( int vKey ) ;
static GetAsyncKeyStateFn pfn = ( GetAsyncKeyStateFn ) GetProcAddress ( hInst , " GetAsyncKeyState " ) ;
if ( ! pfn )
return ;
// In this mode, we enter a wait state where we only pay attention to R and Q.
while ( 1 )
{
if ( pfn ( ' R ' ) & 0x8000 )
break ;
if ( pfn ( ' Q ' ) & 0x8000 )
TerminateProcess ( GetCurrentProcess ( ) , 1 ) ;
if ( pfn ( ' S ' ) & 0x8000 )
{
if ( ! g_bWaitingForStepKeyUp )
{
// Do a single step.
g_bVCRSingleStep = true ;
g_bWaitingForStepKeyUp = true ; // Don't do another single step until they release the S key.
break ;
}
}
else
{
// Ok, they released the S key, so we'll process it next time the key goes down.
g_bWaitingForStepKeyUp = false ;
}
Sleep ( 2 ) ;
}
# else
Assert ( ! " Impl me " ) ;
# endif
}
# ifdef WIN32
void VCR_HandlePlaybackMessages (
HWND hWnd ,
UINT uMsg ,
WPARAM wParam ,
LPARAM lParam
)
{
if ( uMsg = = WM_KEYDOWN )
{
if ( wParam = = VK_SUBTRACT | | wParam = = 0xbd )
{
g_iVCRPlaybackSleepInterval + = 5 ;
}
else if ( wParam = = VK_ADD | | wParam = = 0xbb )
{
g_iVCRPlaybackSleepInterval - = 5 ;
}
else if ( toupper ( wParam ) = = ' Q ' )
{
TerminateProcess ( GetCurrentProcess ( ) , 1 ) ;
}
else if ( toupper ( wParam ) = = ' P ' )
{
VCR_EnterPausedState ( ) ;
}
else if ( toupper ( wParam ) = = ' S ' & & ! g_bVCRSingleStep )
{
g_bWaitingForStepKeyUp = true ;
VCR_EnterPausedState ( ) ;
}
else if ( toupper ( wParam ) = = ' D ' )
{
g_bShowVCRPlaybackDisplay = ! g_bShowVCRPlaybackDisplay ;
}
g_iVCRPlaybackSleepInterval = clamp ( g_iVCRPlaybackSleepInterval , 0 , 500 ) ;
}
}
//-----------------------------------------------------------------------------
// Calls the default window procedure
// FIXME: It would be nice to remove the need for this, which we can do
// if we can make unicode work when running inside hammer.
//-----------------------------------------------------------------------------
static LONG WINAPI CallDefaultWindowProc ( HWND hWnd , UINT uMsg , WPARAM wParam , LPARAM lParam )
{
if ( unicode )
return unicode - > DefWindowProcW ( hWnd , uMsg , wParam , lParam ) ;
return DefWindowProc ( hWnd , uMsg , wParam , lParam ) ;
}
# endif
//-----------------------------------------------------------------------------
// Purpose: The user has accepted an invitation to a game, we need to detect if
// it's TF2 and restart properly if it is
//-----------------------------------------------------------------------------
void XBX_HandleInvite ( DWORD nUserId )
{
# ifdef _X360
// Grab our invite info
XINVITE_INFO inviteInfo ;
DWORD dwError = XInviteGetAcceptedInfo ( nUserId , & inviteInfo ) ;
if ( dwError ! = ERROR_SUCCESS )
return ;
// We only care if we're asked to join an Orange Box session
if ( inviteInfo . dwTitleID ! = TITLEID_THE_ORANGE_BOX )
{
// Do the normal "we've been invited to a game" behavior
return ;
}
// Otherwise, launch depending on our current MOD
if ( ! Q_stricmp ( GetCurrentMod ( ) , " tf " ) )
{
// We're already running TF2, so just join the session
if ( nUserId ! = XBX_GetPrimaryUserId ( ) )
{
// Switch users, the other had the invite
XBX_SetPrimaryUserId ( nUserId ) ;
}
// Kick off our join
g_pMatchmaking - > JoinInviteSession ( & ( inviteInfo . hostInfo ) ) ;
}
else
{
// Save off our session ID for later retrieval
// NOTE: We may need to actually save off the inviter's XID and search for them later on if we took too long or the
// session they were a part of went away
XBX_SetInviteSessionId ( inviteInfo . hostInfo . sessionID ) ;
XBX_SetInvitedUserId ( nUserId ) ;
// Quit via the menu path "QuitNoConfirm"
EngineVGui ( ) - > SystemNotification ( SYSTEMNOTIFY_INVITE_SHUTDOWN ) ;
}
# endif //_X360
}
# if defined( WIN32 ) && !defined( USE_SDL )
//-----------------------------------------------------------------------------
// Main windows procedure
//-----------------------------------------------------------------------------
int CGame : : WindowProc ( HWND hWnd , UINT uMsg , WPARAM wParam , LPARAM lParam )
{
LONG lRet = 0 ;
HDC hdc ;
PAINTSTRUCT ps ;
//
// NOTE: the way this function works is to handle all messages that just call through to
// Windows or provide data to it.
//
// Any messages that change the engine's internal state (like key events) are stored in a list
// and processed at the end of the frame. This is necessary for VCR mode to work correctly because
// Windows likes to pump messages during some of its API calls like SetWindowPos, and unless we add
// custom code around every Windows API call so VCR mode can trap the wndproc calls, VCR mode can't
// reproduce the calls to the wndproc.
//
if ( eng - > GetQuitting ( ) ! = IEngine : : QUIT_NOTQUITTING )
return CallWindowProc ( m_ChainedWindowProc , hWnd , uMsg , wParam , lParam ) ;
// If we're playing back, listen to a couple input things used to drive VCR mode
if ( VCRGetMode ( ) = = VCR_Playback )
{
VCR_HandlePlaybackMessages ( hWnd , uMsg , wParam , lParam ) ;
}
//
// Note: NO engine state should be changed in here while in VCR record or playback.
// We can send whatever we want to Windows, but if we change its state in here instead of
// in DispatchAllStoredGameMessages, the playback may not work because Windows messages
// are not deterministic, so you might get different messages during playback than you did during record.
//
InputEvent_t event ;
memset ( & event , 0 , sizeof ( event ) ) ;
event . m_nTick = g_pInputSystem - > GetPollTick ( ) ;
switch ( uMsg )
{
case WM_CREATE :
: : SetForegroundWindow ( hWnd ) ;
break ;
case WM_ACTIVATEAPP :
{
if ( CanPostActivateEvents ( ) )
{
bool bActivated = ( wParam = = 1 ) ;
event . m_nType = IE_AppActivated ;
event . m_nData = bActivated ;
g_pInputSystem - > PostUserEvent ( event ) ;
}
}
break ;
case WM_POWERBROADCAST :
// Don't go into Sleep mode when running engine, we crash on resume for some reason (as
// do half of the apps I have running usually anyway...)
if ( wParam = = PBT_APMQUERYSUSPEND )
{
Msg ( " OS requested hibernation, ignoring request. \n " ) ;
return BROADCAST_QUERY_DENY ;
}
lRet = CallWindowProc ( m_ChainedWindowProc , hWnd , uMsg , wParam , lParam ) ;
break ;
case WM_SYSCOMMAND :
if ( ( wParam = = SC_MONITORPOWER ) | | ( wParam = = SC_KEYMENU ) | | ( wParam = = SC_SCREENSAVE ) )
return lRet ;
if ( wParam = = SC_CLOSE )
{
# if !defined( NO_VCR )
// handle the close message, but make sure
// it's not because we accidently hit ALT-F4
if ( HIBYTE ( VCRHook_GetKeyState ( VK_LMENU ) ) | | HIBYTE ( VCRHook_GetKeyState ( VK_RMENU ) ) )
return lRet ;
# endif
Cbuf_Clear ( ) ;
Cbuf_AddText ( " quit \n " ) ;
}
# ifndef SWDS
if ( VCRGetMode ( ) = = VCR_Disabled )
{
S_BlockSound ( ) ;
S_ClearBuffer ( ) ;
}
# endif
lRet = CallWindowProc ( m_ChainedWindowProc , hWnd , uMsg , wParam , lParam ) ;
# ifndef SWDS
if ( VCRGetMode ( ) = = VCR_Disabled )
{
S_UnblockSound ( ) ;
}
# endif
break ;
case WM_CLOSE :
// Handle close messages
event . m_nType = IE_Close ;
g_pInputSystem - > PostUserEvent ( event ) ;
return 0 ;
case WM_MOVE :
event . m_nType = IE_WindowMove ;
event . m_nData = ( short ) LOWORD ( lParam ) ;
event . m_nData2 = ( short ) HIWORD ( lParam ) ;
g_pInputSystem - > PostUserEvent ( event ) ;
break ;
case WM_SIZE :
if ( wParam ! = SIZE_MINIMIZED )
{
// Update restored client rect
: : GetClientRect ( hWnd , & m_rcLastRestoredClientRect ) ;
}
else
{
# ifndef _X360
// Fix the window rect to have same client area as it used to have
// before it got minimized
RECT rcWindow ;
: : GetWindowRect ( hWnd , & rcWindow ) ;
rcWindow . right = rcWindow . left + m_rcLastRestoredClientRect . right ;
rcWindow . bottom = rcWindow . top + m_rcLastRestoredClientRect . bottom ;
: : AdjustWindowRect ( & rcWindow , : : GetWindowLong ( hWnd , GWL_STYLE ) , FALSE ) ;
: : MoveWindow ( hWnd , rcWindow . left , rcWindow . top ,
rcWindow . right - rcWindow . left , rcWindow . bottom - rcWindow . top , FALSE ) ;
# endif
}
break ;
case WM_SYSCHAR :
// keep Alt-Space from happening
break ;
case WM_COPYDATA :
// Hammer -> engine remote console command.
// Return true to indicate that the message was handled.
Cbuf_AddText ( ( const char * ) ( ( ( COPYDATASTRUCT * ) lParam ) - > lpData ) ) ;
Cbuf_AddText ( " \n " ) ;
lRet = 1 ;
break ;
# if defined( _X360 )
case WM_XREMOTECOMMAND :
Cbuf_AddText ( ( const char * ) lParam ) ;
Cbuf_AddText ( " \n " ) ;
break ;
case WM_SYS_STORAGEDEVICESCHANGED :
if ( ! EngineVGui ( ) - > IsGameUIVisible ( ) )
{
EngineVGui ( ) - > ActivateGameUI ( ) ;
}
EngineVGui ( ) - > SystemNotification ( SYSTEMNOTIFY_STORAGEDEVICES_CHANGED ) ;
break ;
case WM_XMP_PLAYBACKCONTROLLERCHANGED :
S_EnableMusic ( lParam ! = 0 ) ;
break ;
case WM_LIVE_INVITE_ACCEPTED :
XBX_HandleInvite ( LOWORD ( lParam ) ) ;
break ;
case WM_SYS_SIGNINCHANGED :
if ( XUserGetSigninState ( XBX_GetPrimaryUserId ( ) ) = = eXUserSigninState_NotSignedIn )
{
// X360TBD: User signed out - pause the game?
}
EngineVGui ( ) - > SystemNotification ( lParam ? SYSTEMNOTIFY_USER_SIGNEDIN : SYSTEMNOTIFY_USER_SIGNEDOUT ) ;
break ;
case WM_SYS_UI :
if ( lParam )
{
// Don't activate it if it's already active (a sub window may be active)
// Multiplayer doesn't want the UI to appear, since it can't pause anyway
if ( ! EngineVGui ( ) - > IsGameUIVisible ( ) & & g_ServerGlobalVariables . maxClients = = 1 )
{
Cbuf_AddText ( " gameui_activate " ) ;
}
}
EngineVGui ( ) - > SystemNotification ( lParam ? SYSTEMNOTIFY_XUIOPENING : SYSTEMNOTIFY_XUICLOSED ) ;
break ;
case WM_SYS_MUTELISTCHANGED :
g_pMatchmaking - > UpdateMuteList ( ) ;
break ;
case WM_SYS_INPUTDEVICESCHANGED :
{
XINPUT_CAPABILITIES caps ;
if ( XInputGetCapabilities ( XBX_GetPrimaryUserId ( ) , XINPUT_FLAG_GAMEPAD , & caps ) = = ERROR_DEVICE_NOT_CONNECTED )
{
if ( EngineVGui ( ) - > IsGameUIVisible ( ) = = false )
{
EngineVGui ( ) - > ActivateGameUI ( ) ;
}
}
}
break ;
# endif
case WM_PAINT :
hdc = BeginPaint ( hWnd , & ps ) ;
RECT rcClient ;
GetClientRect ( hWnd , & rcClient ) ;
# ifndef SWDS
// Only renders stuff if running -noshaderapi
if ( videomode )
{
videomode - > DrawNullBackground ( hdc , rcClient . right , rcClient . bottom ) ;
}
# endif
EndPaint ( hWnd , & ps ) ;
break ;
# ifndef _X360
case WM_DISPLAYCHANGE :
if ( ! m_iDesktopHeight | | ! m_iDesktopWidth )
{
UpdateDesktopInformation ( wParam , lParam ) ;
}
break ;
# endif
case WM_IME_NOTIFY :
switch ( wParam )
{
default :
break ;
# ifndef SWDS
case 14 :
if ( ! videomode - > IsWindowedMode ( ) )
return 0 ;
break ;
# endif
}
return CallWindowProc ( m_ChainedWindowProc , hWnd , uMsg , wParam , lParam ) ;
default :
lRet = CallWindowProc ( m_ChainedWindowProc , hWnd , uMsg , wParam , lParam ) ;
break ;
}
// return 0 if handled message, 1 if not
return lRet ;
}
# elif defined(OSX)
# elif defined(LINUX)
# elif defined(_WIN32)
# else
# error
# endif
# if defined( WIN32 ) && !defined( USE_SDL )
//-----------------------------------------------------------------------------
// Creates the game window
//-----------------------------------------------------------------------------
static LONG WINAPI HLEngineWindowProc ( HWND hWnd , UINT uMsg , WPARAM wParam , LPARAM lParam )
{
return g_Game . WindowProc ( hWnd , uMsg , wParam , lParam ) ;
}
# define DEFAULT_EXE_ICON 101
static void DoSomeSocketStuffInOrderToGetZoneAlarmToNoticeUs ( void )
{
# ifdef IS_WINDOWS_PC
WSAData wsaData ;
if ( ! WSAStartup ( 0x0101 , & wsaData ) )
{
SOCKET tmpSocket = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
if ( tmpSocket ! = INVALID_SOCKET )
{
char Options [ ] = { 1 } ;
setsockopt ( tmpSocket , SOL_SOCKET , SO_BROADCAST , Options , sizeof ( Options ) ) ;
char pszHostName [ 256 ] ;
gethostname ( pszHostName , sizeof ( pszHostName ) ) ;
hostent * hInfo = gethostbyname ( pszHostName ) ;
if ( hInfo )
{
sockaddr_in myIpAddress ;
memset ( & myIpAddress , 0 , sizeof ( myIpAddress ) ) ;
myIpAddress . sin_family = AF_INET ;
myIpAddress . sin_port = htons ( 27015 ) ; // our normal server port
myIpAddress . sin_addr . S_un . S_un_b . s_b1 = hInfo - > h_addr_list [ 0 ] [ 0 ] ;
myIpAddress . sin_addr . S_un . S_un_b . s_b2 = hInfo - > h_addr_list [ 0 ] [ 1 ] ;
myIpAddress . sin_addr . S_un . S_un_b . s_b3 = hInfo - > h_addr_list [ 0 ] [ 2 ] ;
myIpAddress . sin_addr . S_un . S_un_b . s_b4 = hInfo - > h_addr_list [ 0 ] [ 3 ] ;
if ( bind ( tmpSocket , ( sockaddr * ) & myIpAddress , sizeof ( myIpAddress ) ) ! = - 1 )
{
if ( sendto ( tmpSocket , pszHostName , 1 , 0 , ( sockaddr * ) & myIpAddress , sizeof ( myIpAddress ) ) = = - 1 )
{
// error?
}
}
}
closesocket ( tmpSocket ) ;
}
WSACleanup ( ) ;
}
# endif
}
# endif
bool CGame : : CreateGameWindow ( void )
{
// get the window name
char windowName [ 256 ] ;
windowName [ 0 ] = 0 ;
KeyValues * modinfo = new KeyValues ( " ModInfo " ) ;
if ( modinfo - > LoadFromFile ( g_pFileSystem , " gameinfo.txt " ) )
{
Q_strncpy ( windowName , modinfo - > GetString ( " game " ) , sizeof ( windowName ) ) ;
}
if ( ! windowName [ 0 ] )
{
Q_strncpy ( windowName , " HALF-LIFE 2 " , sizeof ( windowName ) ) ;
}
if ( IsOpenGL ( ) )
{
2021-11-21 15:51:30 +00:00
# ifdef TOGLES
V_strcat ( windowName , " - OpenGLES " , sizeof ( windowName ) ) ;
# else
2020-04-22 16:56:21 +00:00
V_strcat ( windowName , " - OpenGL " , sizeof ( windowName ) ) ;
2021-11-21 15:51:30 +00:00
# endif
2020-04-22 16:56:21 +00:00
}
# if PIX_ENABLE || defined( PIX_INSTRUMENTATION )
// PIX_ENABLE/PIX_INSTRUMENTATION is a big slowdown (that should never be checked in, but sometimes is by accident), so add this to the Window title too.
V_strcat ( windowName , " - PIX_ENABLE " , sizeof ( windowName ) ) ;
# endif
const char * p = CommandLine ( ) - > ParmValue ( " -window_name_suffix " , " " ) ;
if ( p & & V_strlen ( p ) )
{
V_strcat ( windowName , " - " , sizeof ( windowName ) ) ;
V_strcat ( windowName , p , sizeof ( windowName ) ) ;
}
# if defined( WIN32 ) && !defined( USE_SDL )
# ifndef SWDS
if ( IsPC ( ) )
{
if ( ! LoadUnicode ( ) )
{
return false ;
}
}
# if !defined( _X360 )
WNDCLASSW wc ;
# else
WNDCLASS wc ;
# endif
memset ( & wc , 0 , sizeof ( wc ) ) ;
wc . style = CS_OWNDC | CS_DBLCLKS ;
wc . lpfnWndProc = CallDefaultWindowProc ;
wc . hInstance = m_hInstance ;
wc . lpszClassName = CLASSNAME ;
// find the icon file in the filesystem
if ( IsPC ( ) )
{
char localPath [ MAX_PATH ] ;
if ( g_pFileSystem - > GetLocalPath ( " resource/game.ico " , localPath , sizeof ( localPath ) ) )
{
g_pFileSystem - > GetLocalCopy ( localPath ) ;
wc . hIcon = ( HICON ) : : LoadImage ( NULL , localPath , IMAGE_ICON , 0 , 0 , LR_LOADFROMFILE | LR_DEFAULTSIZE ) ;
}
else
{
wc . hIcon = ( HICON ) LoadIcon ( GetModuleHandle ( 0 ) , MAKEINTRESOURCE ( DEFAULT_EXE_ICON ) ) ;
}
}
# ifndef SWDS
char const * pszGameType = modinfo - > GetString ( " type " ) ;
if ( pszGameType & & Q_stristr ( pszGameType , " multiplayer " ) )
DoSomeSocketStuffInOrderToGetZoneAlarmToNoticeUs ( ) ;
# endif
wchar_t uc [ 512 ] ;
if ( IsPC ( ) )
{
: : MultiByteToWideChar ( CP_UTF8 , 0 , windowName , - 1 , uc , sizeof ( uc ) / sizeof ( wchar_t ) ) ;
}
modinfo - > deleteThis ( ) ;
modinfo = NULL ;
// Oops, we didn't clean up the class registration from last cycle which
// might mean that the wndproc pointer is bogus
# ifndef _X360
unicode - > UnregisterClassW ( CLASSNAME , m_hInstance ) ;
// Register it again
unicode - > RegisterClassW ( & wc ) ;
# else
RegisterClass ( & wc ) ;
# endif
// Note, it's hidden
DWORD style = WS_POPUP | WS_CLIPSIBLINGS ;
// Give it a frame if we want a border
if ( videomode - > IsWindowedMode ( ) )
{
if ( ! CommandLine ( ) - > FindParm ( " -noborder " ) )
{
style | = WS_OVERLAPPEDWINDOW ;
style & = ~ WS_THICKFRAME ;
}
}
// Never a max box
style & = ~ WS_MAXIMIZEBOX ;
int w , h ;
// Create a full screen size window by default, it'll get resized later anyway
w = GetSystemMetrics ( SM_CXSCREEN ) ;
h = GetSystemMetrics ( SM_CYSCREEN ) ;
// Create the window
DWORD exFlags = 0 ;
if ( g_bTextMode )
{
style & = ~ WS_VISIBLE ;
exFlags | = WS_EX_TOOLWINDOW ; // So it doesn't show up in the taskbar.
}
# if !defined( _X360 )
HWND hwnd = unicode - > CreateWindowExW ( exFlags , CLASSNAME , uc , style ,
0 , 0 , w , h , NULL , NULL , m_hInstance , NULL ) ;
// NOTE: On some cards, CreateWindowExW slams the FPU control word
SetupFPUControlWord ( ) ;
# else
HWND hwnd = CreateWindowEx ( exFlags , CLASSNAME , windowName , style ,
0 , 0 , w , h , NULL , NULL , m_hInstance , NULL ) ;
# endif
if ( ! hwnd )
{
Error ( " Fatal Error: Unable to create game window! " ) ;
return false ;
}
SetMainWindow ( hwnd ) ;
AttachToWindow ( ) ;
return true ;
# else
return true ;
# endif
# elif defined( USE_SDL )
bool windowed = videomode - > IsWindowedMode ( ) ;
modinfo - > deleteThis ( ) ;
modinfo = NULL ;
if ( ! g_pLauncherMgr - > CreateGameWindow ( windowName , windowed , 0 , 0 ) )
{
Error ( " Fatal Error: Unable to create game window! " ) ;
return false ;
}
char localPath [ MAX_PATH ] ;
if ( g_pFileSystem - > GetLocalPath ( " resource/game-icon.bmp " , localPath , sizeof ( localPath ) ) )
{
g_pFileSystem - > GetLocalCopy ( localPath ) ;
g_pLauncherMgr - > SetApplicationIcon ( localPath ) ;
}
SetMainWindow ( ( SDL_Window * ) g_pLauncherMgr - > GetWindowRef ( ) ) ;
AttachToWindow ( ) ;
return true ;
# else
# error
# endif
}
//-----------------------------------------------------------------------------
// Destroys the game window
//-----------------------------------------------------------------------------
void CGame : : DestroyGameWindow ( )
{
# if defined( USE_SDL )
g_pLauncherMgr - > DestroyGameWindow ( ) ;
# else
# ifndef DEDICATED
// Destroy all things created when the window was created
if ( ! m_bExternallySuppliedWindow )
{
DetachFromWindow ( ) ;
if ( m_hWindow )
{
DestroyWindow ( m_hWindow ) ;
m_hWindow = ( HWND ) 0 ;
}
# if !defined( _X360 )
unicode - > UnregisterClassW ( CLASSNAME , m_hInstance ) ;
UnloadUnicode ( ) ;
# else
UnregisterClass ( CLASSNAME , m_hInstance ) ;
# endif
}
else
{
m_hWindow = ( HWND ) 0 ;
m_bExternallySuppliedWindow = false ;
}
# endif // !defined( SWDS )
# endif
}
//-----------------------------------------------------------------------------
// This is used in edit mode to specify a particular game window (created by hammer)
//-----------------------------------------------------------------------------
void CGame : : SetGameWindow ( void * hWnd )
{
m_bExternallySuppliedWindow = true ;
# if defined( USE_SDL )
SDL_RaiseWindow ( ( SDL_Window * ) hWnd ) ;
# else
SetMainWindow ( ( HWND ) hWnd ) ;
# endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGame : : AttachToWindow ( )
{
# if defined( WIN32 )
if ( ! m_hWindow )
return ;
# if !defined( USE_SDL )
m_ChainedWindowProc = ( WNDPROC ) GetWindowLongPtrW ( m_hWindow , GWLP_WNDPROC ) ;
SetWindowLongPtrW ( m_hWindow , GWLP_WNDPROC , ( LONG_PTR ) HLEngineWindowProc ) ;
# endif
# endif // WIN32
if ( g_pInputSystem )
{
// Attach the input system window proc
# if defined( WIN32 )
g_pInputSystem - > AttachToWindow ( ( void * ) m_hWindow ) ;
# else
g_pInputSystem - > AttachToWindow ( ( void * ) m_pSDLWindow ) ;
# endif
g_pInputSystem - > EnableInput ( true ) ;
g_pInputSystem - > EnableMessagePump ( false ) ;
}
if ( g_pMatSystemSurface )
{
// Attach the vgui matsurface window proc
# if defined( WIN32 )
g_pMatSystemSurface - > AttachToWindow ( ( void * ) m_hWindow , true ) ;
# else
g_pMatSystemSurface - > AttachToWindow ( ( void * ) m_pSDLWindow , true ) ;
# endif
g_pMatSystemSurface - > EnableWindowsMessages ( true ) ;
}
}
void CGame : : DetachFromWindow ( )
{
# if defined( WIN32 ) && !defined( USE_SDL )
if ( ! m_hWindow | | ! m_ChainedWindowProc )
{
m_ChainedWindowProc = NULL ;
return ;
}
# endif
if ( g_pMatSystemSurface )
{
// Detach the vgui matsurface window proc
g_pMatSystemSurface - > AttachToWindow ( NULL ) ;
}
if ( g_pInputSystem )
{
// Detach the input system window proc
g_pInputSystem - > EnableInput ( false ) ;
g_pInputSystem - > DetachFromWindow ( ) ;
}
# if defined( WIN32 ) && !defined( USE_SDL )
Assert ( ( WNDPROC ) GetWindowLongPtrW ( m_hWindow , GWLP_WNDPROC ) = = HLEngineWindowProc ) ;
SetWindowLongPtrW ( m_hWindow , GWLP_WNDPROC , ( LONG_PTR ) m_ChainedWindowProc ) ;
# endif
}
//-----------------------------------------------------------------------------
// This is used in edit mode to override the default wnd proc associated w/
// the game window specified in SetGameWindow.
//-----------------------------------------------------------------------------
bool CGame : : InputAttachToGameWindow ( )
{
// We can't use this feature unless we didn't control the creation of the window
if ( ! m_bExternallySuppliedWindow )
return true ;
AttachToWindow ( ) ;
# ifndef DEDICATED
vgui : : surface ( ) - > OnScreenSizeChanged ( videomode - > GetModeStereoWidth ( ) , videomode - > GetModeStereoHeight ( ) ) ;
# endif
// We don't get WM_ACTIVATEAPP messages in this case; simulate one.
AppActivate ( true ) ;
# if defined( WIN32 ) && !defined( USE_SDL )
// Capture + hide the mouse
SetCapture ( m_hWindow ) ;
# elif defined( USE_SDL )
Assert ( ! " Impl me " ) ;
return false ;
# else
# error
# endif
return true ;
}
void CGame : : InputDetachFromGameWindow ( )
{
// We can't use this feature unless we didn't control the creation of the window
if ( ! m_bExternallySuppliedWindow )
return ;
# if defined( WIN32 ) && !defined( USE_SDL )
if ( ! m_ChainedWindowProc )
return ;
// Release + show the mouse
ReleaseCapture ( ) ;
# elif defined( USE_SDL )
Assert ( ! " Impl me " ) ;
# else
# error "have no idea what OS we are building for"
# endif
// We don't get WM_ACTIVATEAPP messages in this case; simulate one.
AppActivate ( false ) ;
DetachFromWindow ( ) ;
}
void CGame : : PlayStartupVideos ( void )
{
if ( IsX360 ( ) | | Plat_IsInBenchmarkMode ( ) )
return ;
# ifndef SWDS
// Wait for the mode to change and stabilized
// FIXME: There's really no way to know when this is completed, so we have to guess a time that will mostly be correct
if ( videomode - > IsWindowedMode ( ) = = false )
{
Sys_Sleep ( 1000 ) ;
}
bool bEndGame = CommandLine ( ) - > CheckParm ( " -endgamevid " ) ;
bool bRecap = CommandLine ( ) - > CheckParm ( " -recapvid " ) ; // FIXME: This is a temp addition until the movie playback is centralized -- jdw
bool bNeedHealthWarning = false ;
const char * HealthFile = " media/HealthWarning.txt " ;
FileHandle_t hFile ;
COM_OpenFile ( HealthFile , & hFile ) ;
//There is no access to steam at this point so we are checking for the presence of an empty file that will only exist in the chinese depot
if ( hFile ! = FILESYSTEM_INVALID_HANDLE )
{
bNeedHealthWarning = true ;
COM_CloseFile ( hFile ) ;
}
if ( ! bNeedHealthWarning & & ! bEndGame & & ! bRecap & & ( CommandLine ( ) - > CheckParm ( " -dev " ) | | CommandLine ( ) - > CheckParm ( " -novid " ) | | CommandLine ( ) - > CheckParm ( " -allowdebug " ) ) )
return ;
const char * pszFile = " media/StartupVids.txt " ;
if ( bEndGame )
{
// Don't go back into the map that triggered this.
CommandLine ( ) - > RemoveParm ( " +map " ) ;
CommandLine ( ) - > RemoveParm ( " +load " ) ;
pszFile = " media/EndGameVids.txt " ;
}
else if ( bRecap )
{
pszFile = " media/RecapVids.txt " ;
}
int vidFileLength ;
// have to use the malloc memory allocation option in COM_LoadFile since the memory system isn't set up at this point.
const char * buffer = ( char * ) COM_LoadFile ( pszFile , 5 , & vidFileLength ) ;
if ( ( buffer = = NULL ) | | ( vidFileLength = = 0 ) )
{
return ;
}
// hide cursor while playing videos
# if defined( USE_SDL )
g_pLauncherMgr - > SetMouseVisible ( false ) ;
# elif defined( WIN32 )
: : ShowCursor ( FALSE ) ;
# endif
# if defined( LINUX )
extern void VAudioInit ( ) ;
VAudioInit ( ) ;
Audio_CreateSDLAudioDevice ( ) ;
# endif
const char * start = buffer ;
while ( true )
{
start = COM_Parse ( start ) ;
if ( Q_strlen ( com_token ) < = 0 )
{
break ;
}
// get the path to the media file and play it.
char localPath [ MAX_PATH ] ;
g_pFileSystem - > GetLocalPath ( com_token , localPath , sizeof ( localPath ) ) ;
PlayVideoAndWait ( localPath , bNeedHealthWarning ) ;
localPath [ 0 ] = 0 ; // just to make sure we don't play the same avi file twice in the case that one movie is there but another isn't.
}
// show cursor again
# if defined( USE_SDL )
g_pLauncherMgr - > SetMouseVisible ( true ) ;
# elif defined( WIN32 )
: : ShowCursor ( TRUE ) ;
# endif
// call free on the buffer since the buffer was malloc'd in COM_LoadFile
free ( ( void * ) buffer ) ;
# endif // SWDS
}
//-----------------------------------------------------------------------------
// Purpose: Plays a video until the video completes or ESC is pressed
// Input : *filename - Name of the file (relative to the filesystem)
//-----------------------------------------------------------------------------
void CGame : : PlayVideoAndWait ( const char * filename , bool bNeedHealthWarning )
{
// do we have a filename and a video system, and not on a console?
if ( ! filename | | ! filename [ 0 ] | | g_pVideo = = NULL )
return ;
// is it the valve logo file?
bool bIsValveLogo = ( Q_strstr ( filename , " valve. " ) ! = NULL ) ;
//Chinese health messages appears for 11 seconds, so we force a minimum delay time for those
float forcedMinTime = ( bIsValveLogo & & bNeedHealthWarning ) ? 11.0f : - 1.0f ;
# if defined( WIN32 ) && !defined ( _X360 ) && !defined( USE_SDL )
// Black out the back of the screen once at the beginning of each video (since we're not scaling to fit)
HDC dc = : : GetDC ( m_hWindow ) ;
RECT rect ;
rect . top = 0 ;
rect . bottom = m_height ;
rect . left = 0 ;
rect . right = m_width ;
HBRUSH hBlackBrush = ( HBRUSH ) : : GetStockObject ( BLACK_BRUSH ) ;
: : SetViewportOrgEx ( dc , 0 , 0 , NULL ) ;
: : FillRect ( dc , & rect , hBlackBrush ) ;
: : ReleaseDC ( ( HWND ) GetMainWindow ( ) , dc ) ;
# else
// need OS specific way to clear screen
# endif
VideoResult_t status = g_pVideo - > PlayVideoFileFullScreen ( filename , " GAME " , GetMainWindowPlatformSpecificHandle ( ) ,
m_width , m_height , m_iDesktopWidth , m_iDesktopHeight , videomode - > IsWindowedMode ( ) ,
forcedMinTime , VideoPlaybackFlags : : DEFAULT_FULLSCREEN_OPTIONS | VideoPlaybackFlags : : FILL_WINDOW ) ;
// Everything ok?
if ( status = = VideoResult : : SUCCESS )
{
return ;
}
// We don't worry if it could not find something to could play
if ( status = = VideoResult : : VIDEO_FILE_NOT_FOUND )
{
return ;
}
// Debug Builds, we want an error looked at by a developer, Release builds just send a message to the spew
# ifdef _DEBUG
Error ( " Error %d occurred attempting to play video file %s \n " , ( int ) status , filename ) ;
# else
Msg ( " Error %d occurred attempting to play video file %s \n " , ( int ) status , filename ) ;
# endif
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGame : : CGame ( )
{
# if defined( USE_SDL )
m_pSDLWindow = 0 ;
# endif
# if defined( WIN32 )
# if !defined( USE_SDL )
unicode = NULL ;
m_hUnicodeModule = NULL ;
m_hInstance = 0 ;
m_ChainedWindowProc = NULL ;
# endif
m_hWindow = 0 ;
# endif
m_x = m_y = 0 ;
m_width = m_height = 0 ;
m_bActiveApp = false ;
m_bCanPostActivateEvents = true ;
m_iDesktopWidth = 0 ;
m_iDesktopHeight = 0 ;
m_iDesktopRefreshRate = 0 ;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGame : : ~ CGame ( )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CGame : : Init ( void * pvInstance )
{
m_bExternallySuppliedWindow = false ;
# if defined( WIN32 ) && !defined( USE_SDL )
OSVERSIONINFO vinfo ;
vinfo . dwOSVersionInfoSize = sizeof ( vinfo ) ;
if ( ! GetVersionEx ( & vinfo ) )
{
return false ;
}
if ( vinfo . dwPlatformId = = VER_PLATFORM_WIN32s )
{
return false ;
}
m_hInstance = ( HINSTANCE ) pvInstance ;
# endif
return true ;
}
bool CGame : : Shutdown ( void )
{
# if defined( WIN32 ) && !defined( USE_SDL )
m_hInstance = 0 ;
# endif
return true ;
}
bool CGame : : LoadUnicode ( void )
{
# ifdef WIN32
m_hUnicodeModule = Sys_LoadModule ( " unicode " ) ;
if ( ! m_hUnicodeModule )
{
Error ( " Unable to load unicode.dll " ) ;
return false ;
}
CreateInterfaceFn factory = Sys_GetFactory ( m_hUnicodeModule ) ;
if ( ! factory )
{
Error ( " Unable to get factory from unicode.dll " ) ;
return false ;
}
unicode = ( IUnicodeWindows * ) factory ( VENGINE_UNICODEINTERFACE_VERSION , NULL ) ;
if ( ! unicode )
{
Error ( " Unable to load interface '%s' from unicode.dll " , VENGINE_UNICODEINTERFACE_VERSION ) ;
return false ;
}
# endif
return true ;
}
void CGame : : UnloadUnicode ( )
{
# ifdef WIN32
unicode = NULL ;
if ( m_hUnicodeModule )
{
Sys_UnloadModule ( m_hUnicodeModule ) ;
m_hUnicodeModule = NULL ;
}
# endif
}
void * CGame : : GetMainWindow ( void )
{
# ifdef USE_SDL
return ( void * ) m_pSDLWindow ;
# else
return GetMainWindowPlatformSpecificHandle ( ) ;
# endif
}
void * CGame : : GetMainDeviceWindow ( void )
{
# if defined( DX_TO_GL_ABSTRACTION ) && defined( USE_SDL )
return ( void * ) m_pSDLWindow ;
# else
return ( void * ) m_hWindow ;
# endif
}
void * CGame : : GetMainWindowPlatformSpecificHandle ( void )
{
# ifdef WIN32
return ( void * ) m_hWindow ;
# else
SDL_SysWMinfo pInfo ;
SDL_VERSION ( & pInfo . version ) ;
if ( ! SDL_GetWindowWMInfo ( ( SDL_Window * ) m_pSDLWindow , & pInfo ) )
{
Error ( " Fatal Error: Unable to get window info from SDL. " ) ;
return NULL ;
}
# ifdef OSX
id nsWindow = ( id ) pInfo . info . cocoa . window ;
SEL selector = sel_registerName ( " windowRef " ) ;
id windowRef = objc_msgSend ( nsWindow , selector ) ;
return windowRef ;
# else
// Not used on Linux.
return NULL ;
# endif
# endif // !WIN32
}
void * * CGame : : GetMainWindowAddress ( void )
{
# ifdef WIN32
return ( void * * ) & m_hWindow ;
# else
return NULL ;
# endif
}
void CGame : : GetDesktopInfo ( int & width , int & height , int & refreshrate )
{
# if defined( USE_SDL )
width = 640 ;
height = 480 ;
refreshrate = 0 ;
// Go through all the displays and return the size of the largest.
for ( int i = 0 ; i < SDL_GetNumVideoDisplays ( ) ; i + + )
{
SDL_Rect rect ;
if ( ! SDL_GetDisplayBounds ( i , & rect ) )
{
if ( ( rect . w > width ) | | ( ( rect . w = = width ) & & ( rect . h > height ) ) )
{
width = rect . w ;
height = rect . h ;
}
}
}
# else
// order of initialization means that this might get called early. In that case go ahead and grab the current
// screen window and setup based on that.
// we need to do this when initializing the base list of video modes, for example
if ( m_iDesktopWidth = = 0 )
{
HDC dc = : : GetDC ( NULL ) ;
width = : : GetDeviceCaps ( dc , HORZRES ) ;
height = : : GetDeviceCaps ( dc , VERTRES ) ;
refreshrate = : : GetDeviceCaps ( dc , VREFRESH ) ;
: : ReleaseDC ( NULL , dc ) ;
return ;
}
width = m_iDesktopWidth ;
height = m_iDesktopHeight ;
refreshrate = m_iDesktopRefreshRate ;
# endif
}
void CGame : : UpdateDesktopInformation ( )
{
# if defined( USE_SDL )
// Get the size of the display we will be displayed fullscreen on.
static ConVarRef sdl_displayindex ( " sdl_displayindex " ) ;
int displayIndex = sdl_displayindex . IsValid ( ) ? sdl_displayindex . GetInt ( ) : 0 ;
SDL_DisplayMode mode ;
SDL_GetDesktopDisplayMode ( displayIndex , & mode ) ;
m_iDesktopWidth = mode . w ;
m_iDesktopHeight = mode . h ;
m_iDesktopRefreshRate = mode . refresh_rate ;
# else
HDC dc = : : GetDC ( m_hWindow ) ;
m_iDesktopWidth = : : GetDeviceCaps ( dc , HORZRES ) ;
m_iDesktopHeight = : : GetDeviceCaps ( dc , VERTRES ) ;
m_iDesktopRefreshRate = : : GetDeviceCaps ( dc , VREFRESH ) ;
: : ReleaseDC ( m_hWindow , dc ) ;
# endif
}
# ifdef WIN32
void CGame : : UpdateDesktopInformation ( WPARAM wParam , LPARAM lParam )
{
m_iDesktopWidth = LOWORD ( lParam ) ;
m_iDesktopHeight = HIWORD ( lParam ) ;
}
# endif
# ifndef USE_SDL
void CGame : : SetMainWindow ( HWND window )
{
m_hWindow = window ;
// update our desktop info (since the results will change if we are going to fullscreen mode)
if ( ! m_iDesktopWidth | | ! m_iDesktopHeight )
{
UpdateDesktopInformation ( ) ;
}
}
# else
void CGame : : SetMainWindow ( SDL_Window * window )
{
# if defined( WIN32 )
// For D3D, we need to access the underlying HWND of the SDL_Window.
// We also can't do this in GetMainDeviceWindow and just use that, because for some reason
// people use GetMainWindowAddress and store that pointer to our member.
SDL_SysWMinfo pInfo ;
SDL_VERSION ( & pInfo . version ) ;
if ( ! SDL_GetWindowWMInfo ( ( SDL_Window * ) g_pLauncherMgr - > GetWindowRef ( ) , & pInfo ) )
{
Error ( " Fatal Error: Unable to get window info from SDL. " ) ;
return ;
}
m_hWindow = pInfo . info . win . window ;
# endif
m_pSDLWindow = window ;
// update our desktop info (since the results will change if we are going to fullscreen mode)
if ( ! m_iDesktopWidth | | ! m_iDesktopHeight )
{
UpdateDesktopInformation ( ) ;
}
}
# endif
void CGame : : SetWindowXY ( int x , int y )
{
m_x = x ;
m_y = y ;
}
void CGame : : SetWindowSize ( int w , int h )
{
m_width = w ;
m_height = h ;
}
void CGame : : GetWindowRect ( int * x , int * y , int * w , int * h )
{
if ( x )
{
* x = m_x ;
}
if ( y )
{
* y = m_y ;
}
if ( w )
{
* w = m_width ;
}
if ( h )
{
* h = m_height ;
}
}
bool CGame : : IsActiveApp ( void )
{
return m_bActiveApp ;
}
void CGame : : SetCanPostActivateEvents ( bool bEnabled )
{
m_bCanPostActivateEvents = bEnabled ;
}
bool CGame : : CanPostActivateEvents ( )
{
return m_bCanPostActivateEvents ;
}
void CGame : : SetActiveApp ( bool active )
{
m_bActiveApp = active ;
}