Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/engine/sys_mainwind.cpp
KittenPopo c2130ba4e9 uid issue
2021-07-24 21:11:47 -07:00

2731 lines
72 KiB
C++
Raw Blame History

//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
//===========================================================================//
#if defined( USE_SDL )
#undef PROTECTED_THINGS_ENABLE
#include "SDL.h"
#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)
#include <Carbon/Carbon.h>
#elif defined(LINUX)
#include "tier0/dynfunction.h"
#elif defined(_WIN32)
#include "tier0/dynfunction.h"
#elif defined( _PS3 )
#include "basetypes.h"
#include "ps3/ps3_core.h"
#include "ps3/ps3_win32stubs.h"
#include <cell/audio.h>
#include <sysutil/sysutil_sysparam.h>
#else
#error
#endif
#include "appframework/ilaunchermgr.h"
#include "igame.h"
#include "cl_main.h"
#include "host.h"
#include "quakedef.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 "avi/iavi.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"
#include "GameUI/IGameUI.h"
#include "sv_main.h"
#if defined( BINK_VIDEO )
#include "bink/bink.h"
#endif
#include "vgui/IVGui.h"
#include "IHammer.h"
#include "inputsystem/iinputstacksystem.h"
#include "avi/ibik.h"
#include "materialsystem/imaterial.h"
#include "characterset.h"
#include "server.h"
#if defined( INCLUDE_SCALEFORM )
#include "scaleformui/scaleformui.h"
#endif
#include <vgui/ILocalize.h>
#include <vgui/ISystem.h>
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#include "snd_dev_xaudio.h"
#include "xmp.h"
#include "xbox/xbox_launch.h"
#include "ixboxsystem.h"
extern IXboxSystem *g_pXboxSystem;
#endif
#if defined( LINUX )
#include "snd_dev_sdl.h"
#endif
#include "matchmaking/imatchframework.h"
#include "tier2/tier2.h"
#include "tier1/fmtstr.h"
#if !defined( PLATFORM_X360 )
#include "cl_steamauth.h"
#endif
#if defined( PLATFORM_WINDOWS )
#include "vaudio/ivaudio.h"
extern void VAudioInit();
extern IVAudio * vaudio;
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern ConVar cv_vguipanel_active;
void S_BlockSound (void);
void S_UnblockSound (void);
void ClearIOStates( void );
//-----------------------------------------------------------------------------
// Game input events
//-----------------------------------------------------------------------------
enum GameInputEventType_t
{
IE_WindowMove = IE_FirstAppEvent,
IE_AppActivated,
};
//-----------------------------------------------------------------------------
// 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 );
void* GetMainWindow( 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();
virtual void OnScreenSizeChanged( int nOldWidth, int nOldHeight );
public:
void SetMainWindow( HWND window );
void SetActiveApp( bool active );
#if defined( WIN32 ) || defined( _GAMECONSOLE )
int WindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
#endif
// plays a video file and waits until completed. Can be interrupted by user input.
virtual void PlayVideoListAndWait( const char *szVideoFileList, bool bNeedHealthWarning = false );
virtual void PlayVideoAndWait(const char *filename, bool bNeedHealthWarning = false);
// 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();
InputContextHandle_t GetInputContext() { return m_hInputContext; }
private:
void AppActivate( bool fActive );
private:
void AttachToWindow();
void DetachFromWindow();
#ifndef _X360
static const wchar_t CLASSNAME[];
#else
static const char CLASSNAME[];
#endif
bool m_bExternallySuppliedWindow;
#if USE_SDL
SDL_Window *m_hWindow;
#elif defined( WIN32 )
HWND m_hWindow;
HINSTANCE m_hInstance;
// Stores a wndproc to chain message calls to
WNDPROC m_ChainedWindowProc;
RECT m_rcLastRestoredClientRect;
#elif OSX
WindowRef m_hWindow;
#else
#error
#endif
int m_x;
int m_y;
int m_width;
int m_height;
bool m_bActiveApp;
bool m_bCanPostActivateEvents;
int m_iDesktopWidth, m_iDesktopHeight, m_iDesktopRefreshRate;
void UpdateDesktopInformation( HWND hWnd );
#ifdef WIN32
void UpdateDesktopInformation( WPARAM wParam, LPARAM lParam );
#endif
InputContextHandle_t m_hInputContext;
};
static CGame g_Game;
IGame *game = ( IGame * )&g_Game;
#if defined( _PS3 )
extern void AbortLoadingUpdatesDueToShutdown();
extern bool SaveUtilV2_CanShutdown();
void PS3_sysutil_callback_forwarder( uint64 uiStatus, uint64 uiParam )
{
if ( Steam3Client().SteamUtils() )
Steam3Client().SteamUtils()->PostPS3SysutilCallback( uiStatus, uiParam, NULL );
if ( uiStatus == CELL_SYSUTIL_REQUEST_EXITGAME )
{
SaveUtilV2_CanShutdown();
AbortLoadingUpdatesDueToShutdown();
}
}
int PS3_WindowProc_Proxy( xevent_t const &ev )
{
// HWND = NULL
// message = WM_*** (arg1)
// LPARAM = parameter (arg2)
// WPARAM = 0 (arg3)
// Note the order of parameters to WindowProc:
// WindowProc( HWND, MSG, WPARAM=arg3=0, LPARAM )
if ( ev.arg3 )
{
// Event has sysutil payload
PS3_sysutil_callback_forwarder( ev.sysutil_status, ev.sysutil_param );
if ( 0 && g_pMatchFramework )
{
KeyValues *kv = new KeyValues( "Ps3SysutilCallback" );
kv->SetUint64( "status", ev.sysutil_status );
kv->SetUint64( "param", ev.sysutil_param );
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( kv );
}
}
return g_Game.WindowProc( NULL, ev.arg1, ev.arg3, ev.arg2 );
}
#endif
#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;
InputContextHandle_t GetGameInputContext()
{
return g_Game.GetInputContext();
}
// 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 DEDICATED
if ( videomode )
{
if ( fActive )
{
videomode->RestoreVideo();
}
else
{
videomode->ReleaseVideo();
}
}
#ifdef OSX
// make sure the mouse cursor is in a sane location, force it to screen middle
if ( fActive )
{
g_pLauncherMgr->SetCursorPosition( m_width/2, m_height/2 );
}
#endif
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 // DEDICATED
SetActiveApp( fActive );
// Allow queueing of activation events
SetCanPostActivateEvents( true );
}
void CGame::HandleMsg_WindowMove( const InputEvent_t &event )
{
game->SetWindowXY( event.m_nData, event.m_nData2 );
#ifndef DEDICATED
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:
case IE_KeyTyped:
case IE_KeyCodeTyped:
Key_Event( event );
break;
// Broadcast analog values both to VGui & to GameUI
case IE_AnalogValueChanged:
{
// mouse events should go to vgui first, but joystick events should go to scaleform first
if ( event.m_nData >= JOYSTICK_FIRST_AXIS )
{
if ( g_pScaleformUI && g_pScaleformUI->HandleInputEvent( event ) )
break;
if ( g_pMatSystemSurface && g_pMatSystemSurface->HandleInputEvent( event ) )
break;
}
else
{
if ( g_pMatSystemSurface && g_pMatSystemSurface->HandleInputEvent( event ) )
break;
#if defined( INCLUDE_SCALEFORM )
bool vguiActive = IsPC() && cv_vguipanel_active.GetBool();
// we filter input while the console is visible, to prevent scaleform from
// handling anything underneath the console
if ( !vguiActive && g_pScaleformUI && g_pScaleformUI->HandleInputEvent( event ) )
break;
#endif // INCLUDE_SCALEFORM
}
// Let GameUI have the next whack at events
if ( g_ClientDLL && g_ClientDLL->HandleGameUIEvent( event ) )
break;
}
break;
case IE_OverlayEvent:
if ( event.m_nData == 1 )
{
// Overlay has activated
if ( !EngineVGui()->IsGameUIVisible() && sv.IsActive() && sv.IsSinglePlayerGame() )
{
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "gameui_activate" );
}
}
break;
#ifdef _PS3
case IE_ControllerUnplugged:
WindowProc( 0, WM_SYS_INPUTDEVICESCHANGED, 0, ( 1 << event.m_nData ) );
break;
case IE_PS_CameraUnplugged:
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnPSEyeChangedStatus", "CamStatus", event.m_nData ) );
break;
case IE_PS_Move_OutOfView:
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnPSMoveOutOfViewChanged", "OutOfViewBool", event.m_nData ) );
break;
#endif
default:
// Let vgui have the first whack at events
if ( g_pMatSystemSurface && g_pMatSystemSurface->HandleInputEvent( event ) )
break;
#if defined( INCLUDE_SCALEFORM )
bool vguiActive = IsPC() && cv_vguipanel_active.GetBool();
// we filter all input while the console is visible, to prevent scaleform from
// handling anything underneath the console
if ( !vguiActive && g_pScaleformUI && g_pScaleformUI->HandleInputEvent( event ) )
break;
#endif // INCLUDE_SCALEFORM
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()
{
int nEventCount = g_pInputSystem->GetEventCount();
const InputEvent_t* pEvents = g_pInputSystem->GetEventData( );
for ( int i = 0; i < nEventCount; ++i )
{
DispatchInputEvent( pEvents[i] );
}
}
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 defined( _GAMECONSOLE )
return 0;
#else
return DefWindowProcW( hWnd, uMsg, wParam, lParam );
#endif
}
#endif
//-----------------------------------------------------------------------------
// Purpose: The user has accepted an invitation to a game, we need to detect if
// it's our game and restart properly if it is
//-----------------------------------------------------------------------------
void XBX_HandleInvite( DWORD nUserId )
{
#ifdef _X360
g_pMatchFramework->AcceptInvite( nUserId );
#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;
BOOL bCallDefault = 0;
#if defined( WIN32 )
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 );
#endif // WIN32
//
// 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 );
}
// handle focus changes including fullscreen
if ( wParam == 0 )
{
S_UpdateWindowFocus( false );
}
else
{
S_UpdateWindowFocus( true );
}
}
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;
}
bCallDefault = true;
break;
#if defined( WIN32 )
case WM_SYSCOMMAND:
if ( ( wParam == SC_MONITORPOWER ) || ( wParam == SC_KEYMENU ) || ( wParam == SC_SCREENSAVE ) )
return lRet;
if ( wParam == SC_CLOSE )
{
// handle the close message, but make sure
// it's not because we accidently hit ALT-F4
if ( HIBYTE(GetKeyState(VK_LMENU)) || HIBYTE(GetKeyState(VK_RMENU) ) )
return lRet;
Cbuf_Clear( Cbuf_GetCurrentPlayer() );
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "quit\n" );
}
#ifndef DEDICATED
S_BlockSound();
S_ClearBuffer();
#endif
lRet = CallWindowProc( m_ChainedWindowProc, hWnd, uMsg, wParam, lParam );
#ifndef DEDICATED
S_UnblockSound();
#endif
break;
#endif
case WM_SYS_SHUTDOWNREQUEST:
Assert( IsGameConsole() );
Cbuf_Clear( Cbuf_GetCurrentPlayer() );
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "quit_gameconsole\n" );
break;
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;
#if defined( WIN32 )
case WM_SIZE:
if ( wParam != SIZE_MINIMIZED )
{
// Update restored client rect
::GetClientRect( hWnd, &m_rcLastRestoredClientRect );
}
else
{
#ifndef _GAMECONSOLE
// 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;
#endif
case WM_SETFOCUS:
if ( g_pHammer )
g_pHammer->NoteEngineGotFocus();
break;
case WM_SYSCHAR:
// keep Alt-Space from happening
break;
case WM_COPYDATA:
//
// Researching all codebase legacy yields the following use cases.
// COPYDATASTRUCT.dwParam = 0 in most cases:
// + another engine instance passing over commandline when executed with -hijack param
// + worldcraft editor sending a command
// + mdlviewer sending a reload model command
// + Hammer -> engine remote console command.
// COPYDATASTRUCT.cbData = 0 in another case:
// + materialsystem enumerating and sending message to other materialsystem windows
// Our WNDPROC should return true to indicate that the message was handled.
//
{
COPYDATASTRUCT &cpData = *( ( COPYDATASTRUCT * ) lParam );
if ( cpData.cbData )
{ // There is payload supplied to the message
if ( cpData.dwData == 0 )
{ // Legacy protocol to put console command into command buffer
const char *pcBuffer = ( const char * ) ( cpData.lpData );
Cbuf_AddText( Cbuf_GetCurrentPlayer(), pcBuffer );
lRet = 1;
}
else if ( cpData.dwData == 0x43525950 ) // CRYP
{ // Encryption key supplied for connection
// Format:
// dot.ted.ip.adr:port>4bytes16bytesupto256bytes
const char *pcBuffer = ( const char * ) ( cpData.lpData );
const char *pcTerm = V_strnchr( pcBuffer, '>', 24 );
if ( pcTerm && pcTerm > pcBuffer )
{
DWORD numBytesForAddress = pcTerm - pcBuffer + 1;
if ( ( numBytesForAddress < cpData.cbData ) &&
( cpData.cbData - numBytesForAddress > sizeof( int32 ) + NET_CRYPT_KEY_LENGTH ) &&
( cpData.cbData - numBytesForAddress - sizeof( int32 ) - NET_CRYPT_KEY_LENGTH <= 256 ) &&
!!( *reinterpret_cast< const int32 * >( pcTerm + 1 ) & 0xFFFF0000 ) ) // client key must use high bits and be not zero
{
CFmtStr fmtAddr( "%.*s", pcTerm - pcBuffer, pcBuffer );
extern void RegisterServerCertificate( char const *szServerAddress, int numBytesPayload, void const *pvPayload );
RegisterServerCertificate( fmtAddr.Access(), cpData.cbData - numBytesForAddress, pcTerm + 1 );
lRet = 1;
}
}
}
}
}
break;
#if defined( _GAMECONSOLE )
case WM_XREMOTECOMMAND:
Cbuf_AddText( Cbuf_GetCurrentPlayer(), (const char*)lParam );
break;
case WM_SYS_STORAGEDEVICESCHANGED:
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnSysStorageDevicesChanged" ) );
break;
case WM_LIVE_CONTENT_INSTALLED:
{
#if defined ( _X360 )
bool isArcadeTitleUnlocked = g_pXboxSystem->IsArcadeTitleUnlocked();
g_pXboxSystem->UpdateArcadeTitleUnlockStatus();
if ( !isArcadeTitleUnlocked && g_pXboxSystem->IsArcadeTitleUnlocked() )
{
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnUnlockArcadeTitle" ) );
}
#endif
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnDowloadableContentInstalled" ) );
break;
}
case WM_LIVE_MEMBERSHIP_PURCHASED:
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnLiveMembershipPurchased" ) );
break;
case WM_LIVE_VOICECHAT_AWAY:
#if defined( _X360 )
// If we're triggered with lParam = true, we are now using LIVE Party Chat or Private Chat, not the Game Chat Channel.
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnLiveVoicechatAway", "NotTitleChat", ( lParam == 1 ) ? "1" : "0" ) );
#endif
break;
case WM_XMP_PLAYBACKCONTROLLERCHANGED:
S_EnableMusic( lParam != 0 );
break;
case WM_LIVE_INVITE_ACCEPTED:
XBX_HandleInvite( LOWORD( lParam ) );
break;
case WM_SYS_SIGNINCHANGED:
{
xevent_SYS_SIGNINCHANGED_t *pSysEvent = reinterpret_cast< xevent_SYS_SIGNINCHANGED_t * >( lParam );
Assert( pSysEvent );
if ( !pSysEvent )
break;
#if defined( _X360 ) && !defined( _CERT_NODEFINE )
DevMsg( "WM_SYS_SIGNINCHANGED( ptr=0x%p, 0x%08X )\n", pSysEvent, pSysEvent->dwParam );
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
XUSER_SIGNIN_STATE eState = XUserGetSigninState( k );
XUID xid;
if ( ERROR_SUCCESS != XUserGetXUID( k, &xid ) )
xid = 0ull;
DevMsg( " User%d [ %llx %d ] XUID=%llx state = %d\n", k, pSysEvent->xuid[k], pSysEvent->state[k], xid, eState );
}
#endif
if ( pSysEvent->dwParam )
{
//
// This is a special handler for crazy Xbox LIVE notifications
// when console lost connection to Secure Gateway and tries to
// re-establish its security tickets and other secure crap.
// See: https://bugbait.valvesoftware.com/show_bug.cgi?id=27583
// TCR 001 BAS Game Stability
// Repro Steps:
// 1) Launch [Game] with two controllers and an extra profile that is Gold, and has no Ethernet connected.
// 2) From the main menu select "Start Game"
// 3) During gameplay have the inactive controller sign into the gold profile.
// It will generate the following sign-in notification:
// [DBG]: [XNET:2] AuthWarn: SG connection failed! Retrying with fresh ticket (update 0).
// [DBG]: [XNET:2] AuthWarn: XNetDnsLookup timed out for XEAS.PART.XBOXLIVE.COM
// [DBG]: [XNET:2] Warning: Unexpected TGT error 0x80151904!
// WM_SYS_SIGNINCHANGED( 0x00000000, 0x00000001 )
// User0 XUID=0 state = 0 <--- all the users state is reported as signed out with NULL XUID
// WM_LIVE_CONNECTIONCHANGED( 0x00000000, 0x80151904 )
// User0 XUID=0 state = 0
// Followed by:
// WM_SYS_SIGNINCHANGED( 0x00000000, 0x00000002 )
// User0 XUID=e0000a2e5a849e42 state = 1
// User1 XUID=e0000b49fab8416e state = 1
// To handle this we will ignore notifications when controller mask doesn't specify signed-in controllers.
//
bool bSomeUsersStillSignedIn = false;
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
if ( (pSysEvent->dwParam & ( 1 << k )) == 0 )
continue;
if ( pSysEvent->state[k] != eXUserSigninState_NotSignedIn )
{
bSomeUsersStillSignedIn = true;
break;
}
}
if ( !bSomeUsersStillSignedIn )
{
// This is the crazy notification mentioned above, discard
DevMsg( "WM_SYS_SIGNINCHANGED is discarded due to invalid parameters!\n" );
break;
}
}
{
//
// This is a handler for TCR exploit of X360 blade
// TCR 015 BAS Sign-In Changes
// Using inactive controller to initiate sign-in, but actually
// pressing last "A" button on an active controller will not
// generate a sign-out message, but will generate a new sign-in
// message.
// We need to keep XUIDs around and if a new sign-in message is
// coming from a new XUID we fake a sign-out message first and
// then the new sign-in message.
//
MEM_ALLOC_CREDIT();
static XUID s_arrSignedInXUIDs[ XUSER_MAX_COUNT ] = { 0 };
KeyValues *pEvent = NULL;
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
XUID xidOld = s_arrSignedInXUIDs[k];
XUID xidNew = pSysEvent->xuid[k];
if ( xidOld )
{
// We had a ctrl signed in this slot
bool bSignedOut = false;
if ( pSysEvent->state[k] == eXUserSigninState_NotSignedIn )
{
bSignedOut = true;
}
else if ( !IsEqualXUID( xidNew, xidOld ) )
{
bSignedOut = true;
}
// If user signed out, add to notification
if ( bSignedOut )
{
if ( !pEvent )
{
pEvent = new KeyValues( "OnSysSigninChange" );
pEvent->SetString( "action", "signout" );
}
int idx = pEvent->GetInt( "numUsers", 0 );
pEvent->SetInt( "numUsers", idx + 1 );
int nMask = pEvent->GetInt( "mask", 0 );
pEvent->SetInt( "mask", nMask | ( 1 << k ) );
char bufUserIdx[32];
sprintf( bufUserIdx, "user%d", idx );
pEvent->SetInt( bufUserIdx, k );
}
}
s_arrSignedInXUIDs[k] = xidNew;
}
if ( pEvent )
{
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( pEvent );
}
}
if ( pSysEvent->dwParam )
{
MEM_ALLOC_CREDIT();
KeyValues *pEvent = new KeyValues( "OnSysSigninChange" );
pEvent->SetString( "action", "signin" );
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
if ( (pSysEvent->dwParam & ( 1 << k )) == 0 )
continue;
int idx = pEvent->GetInt( "numUsers", 0 );
pEvent->SetInt( "numUsers", idx + 1 );
int nMask = pEvent->GetInt( "mask", 0 );
pEvent->SetInt( "mask", nMask | ( 1 << k ) );
char bufUserIdx[32];
sprintf( bufUserIdx, "user%d", idx );
pEvent->SetInt( bufUserIdx, k );
}
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( pEvent );
}
}
break;
case WM_LIVE_CONNECTIONCHANGED:
#if defined( _X360 ) && !defined( _CERT )
DevMsg( "WM_LIVE_CONNECTIONCHANGED( 0x%08X, 0x%08X )\n", wParam, lParam );
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
XUSER_SIGNIN_STATE eState = XUserGetSigninState( k );
XUID xid;
if ( ERROR_SUCCESS != XUserGetXUID( k, &xid ) )
xid = 0ull;
DevMsg( " User%d XUID=%llx state = %d\n", k, xid, eState );
}
#endif
// Vitaliy [8/5/2008]
// Triggering any callbacks from inside WM_LIVE_CONNECTIONCHANGED is
// unreliable because access to accounts sign-in information is blocked.
// Repro case: user1 is signed into Live, user2 signs in with local account
// then WM_LIVE_CONNECTIONCHANGED will be triggered and XUserGetSigninState
// will be returning 0 for all user ids.
break; // end case WM_LIVE_CONNECTIONCHANGED
case WM_SYS_UI:
if ( lParam )
{
// When the blade opens, release all buttons
g_pInputSystem->ResetInputState();
// 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() && sv.IsActive() && sv.IsSinglePlayerGame() )
{
Cbuf_AddText( Cbuf_GetCurrentPlayer(), "gameui_activate" );
}
}
{
MEM_ALLOC_CREDIT();
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues(
"OnSysXUIEvent", "action", lParam ? "opening" : "closed" ) );
}
break;
case WM_FRIENDS_FRIEND_ADDED: // Need to update mutelist for friends changes in case of Friends-Only privileges
case WM_FRIENDS_FRIEND_REMOVED:
case WM_SYS_MUTELISTCHANGED:
{
MEM_ALLOC_CREDIT();
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues( "OnSysMuteListChanged" ) );
}
break;
case WM_SYS_PROFILESETTINGCHANGED:
{
MEM_ALLOC_CREDIT();
if ( KeyValues *kvNotify = new KeyValues( "OnSysProfileSettingsChanged" ) )
{
kvNotify->SetInt( "mask", lParam );
for ( int k = 0; k < XUSER_MAX_COUNT; ++ k )
{
if ( lParam & ( 1 << k ) )
{
kvNotify->SetInt( CFmtStr( "user%d", k ), 1 );
}
}
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( kvNotify );
}
}
break;
case WM_SYS_INPUTDEVICESCHANGED:
{
MEM_ALLOC_CREDIT();
int nDisconnectedDeviceMask = 0;
for ( DWORD k = 0; k < XBX_GetNumGameUsers(); ++ k )
{
#ifdef _X360
XINPUT_CAPABILITIES caps;
if ( XInputGetCapabilities( XBX_GetUserId(k), XINPUT_FLAG_GAMEPAD, &caps ) == ERROR_DEVICE_NOT_CONNECTED )
#elif defined( _PS3 )
if ( lParam & ( 1 << XBX_GetUserId(k) ) ) // PS3 passes disconnected controllers mask in lParam
#else
Assert(0);
if ( 0 )
#endif
{
nDisconnectedDeviceMask |= ( 1 << k );
}
}
if ( nDisconnectedDeviceMask )
{
// This message is only sent when one of our active users has lost their controller connection
// FIXME: Only do this when the guest is at fault? A "toast" is already presented to the user by the API otherwise.
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues(
"OnSysInputDevicesChanged", "mask", nDisconnectedDeviceMask ) );
}
}
break;
#if defined( _DEMO )
case WM_XCONTROLLER_KEY:
if ( lParam )
{
// any keydown activity resets the timeout or changes into interactivbe demo mode
Host_RestartDemoTimeout( true );
}
bCallDefault = true;
break;
#endif
#endif
#if defined( WIN32 )
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
RECT rcClient;
GetClientRect( hWnd, &rcClient );
EndPaint(hWnd, &ps);
break;
#endif
#if defined( WIN32 ) && !defined( _X360 )
case WM_DISPLAYCHANGE:
if ( !m_iDesktopHeight || !m_iDesktopWidth )
{
UpdateDesktopInformation( wParam, lParam );
}
break;
#endif
case WM_IME_NOTIFY:
switch ( wParam )
{
default:
break;
#ifndef DEDICATED
case 14:
if ( !videomode->IsWindowedMode() )
return 0;
break;
#endif
}
bCallDefault = true;
break;
default:
bCallDefault = true;
break;
}
if ( bCallDefault )
{
#ifdef _PS3
lRet = 0;
#else
lRet = CallWindowProc( m_ChainedWindowProc, hWnd, uMsg, wParam, lParam );
#endif
}
// 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 LRESULT 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() )
{
V_strcat( windowName, " - OpenGL", sizeof( windowName ) );
}
#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( USE_SDL )
modinfo->deleteThis();
modinfo = NULL;
if ( !g_pLauncherMgr->CreateGameWindow( windowName, true, 0, 0, true ) )
{
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( ( HWND )g_pLauncherMgr->GetWindowRef() );
AttachToWindow( );
return true;
#elif defined( WIN32 ) && !defined( USE_SDL )
#ifndef DEDICATED
#if !defined( _X360 )
WNDCLASSW wc;
#else
WNDCLASS wc;
#endif
memset( &wc, 0, sizeof( wc ) );
wc.style = CS_OWNDC | CS_DBLCLKS;
#if !defined( _GAMECONSOLE )
wc.lpfnWndProc = DefWindowProcW;
#else
wc.lpfnWndProc = CallDefaultWindowProc;
#endif
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 DEDICATED
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
UnregisterClassW( CLASSNAME, m_hInstance );
// Register it again
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" )&& !videomode->NoWindowBorder() )
{
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 = 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(OSX)
modinfo->deleteThis();
modinfo = NULL;
if ( !g_pLauncherMgr->CreateGameWindow( windowName, true, 640, 480 ) )
{
Error( "Fatal Error: Unable to create game window!" );
return false;
}
char localPath[ MAX_PATH ];
if ( g_pFileSystem->GetLocalPath( "resource/game.icns", localPath, sizeof(localPath) ) )
{
g_pFileSystem->GetLocalCopy( localPath );
g_pLauncherMgr->SetApplicationIcon( localPath );
}
SetMainWindow( g_pLauncherMgr->GetWindowRef() );
AttachToWindow( );
return true;
#else
#error
#endif
}
//-----------------------------------------------------------------------------
// Destroys the game window
//-----------------------------------------------------------------------------
void CGame::DestroyGameWindow()
{
#if defined( USE_SDL )
g_pLauncherMgr->DestroyGameWindow();
#elif defined( WIN32 )
#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 )
UnregisterClassW( CLASSNAME, m_hInstance );
#else
UnregisterClass( CLASSNAME, m_hInstance );
#endif
}
else
{
m_hWindow = (HWND)0;
m_bExternallySuppliedWindow = false;
}
#endif // !DEDICATED
#elif defined( OSX )
g_pLauncherMgr->DestroyGameWindow();
#elif defined (_PS3)
#else
#error
#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 );
#elif defined( WIN32 )
SetMainWindow( (HWND)hWnd );
#elif defined( OSX ) && defined( PLATFORM_64BITS )
Assert( !"unimpl OSX-64" );
#elif defined( OSX )
SetUserFocusWindow( (WindowRef)hWnd );
#else
#error
#endif
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CGame::AttachToWindow()
{
if ( !m_hWindow )
return;
#if defined( WIN32 ) && !defined( USE_SDL )
m_ChainedWindowProc = (WNDPROC)GetWindowLongPtrW( m_hWindow, GWLP_WNDPROC );
SetWindowLongPtrW( m_hWindow, GWLP_WNDPROC, (LONG_PTR)HLEngineWindowProc );
#endif
if ( g_pInputSystem )
{
// Attach the input system window proc
g_pInputSystem->AttachToWindow( (void *)m_hWindow );
g_pInputSystem->EnableInput( true );
g_pInputSystem->EnableMessagePump( false );
}
if ( g_pMatSystemSurface )
{
// Attach the vgui matsurface window proc
g_pMatSystemSurface->SetAppDrivesInput( true );
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
g_pMatSystemSurface->EnableWindowsMessages( false );
}
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->GetModeWidth(), videomode->GetModeHeight() );
#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
g_pInputStackSystem->SetMouseCapture( m_hInputContext, true );
#elif defined(OSX)
Assert( !"Impl me" );
return false;
#elif defined( LINUX )
Assert( !"Impl me" );
return false;
#elif defined(_WIN32)
Assert( !"Impl me" );
return false;
#elif defined(_PS3)
#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(OSX)
Assert( !"Impl me" );
#elif defined( LINUX )
Assert( !"Impl me" );
#elif defined(_WIN32)
Assert( !"Impl me" );
#elif defined(_PS3)
#else
#error
#endif
// We don't get WM_ACTIVATEAPP messages in this case; simulate one.
AppActivate( false );
DetachFromWindow();
}
void CGame::PlayStartupVideos( void )
{
if ( Plat_IsInBenchmarkMode() )
return;
#ifndef DEDICATED
// 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 ( IsPC() && videomode->IsWindowedMode() == false )
{
ThreadSleep( 1000 );
}
bool bEndGame = CommandLine()->CheckParm("-endgamevid") ? true : false;
bool bRecap = CommandLine()->CheckParm("-recapvid") ? true : false; // FIXME: This is a temp addition until the movie playback is centralized -- jdw
bool bNeedHealthWarning = IsPC() && g_pFullFileSystem->FileExists( "media/HealthWarning.txt" );
if ( !bNeedHealthWarning &&
!bEndGame &&
!bRecap &&
( CommandLine()->CheckParm( "-dev" ) ||
CommandLine()->CheckParm( "-novid" ) ||
CommandLine()->CheckParm( "-allowdebug" ) ||
CommandLine()->CheckParm( "-console" ) ||
CommandLine()->CheckParm( "-toconsole" ) ) )
return;
char *pszFile = "media/startupvids" PLATFORM_EXT ".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";
}
#if defined( PLATFORM_WINDOWS ) && defined( BINK_VIDEO )
VAudioInit();
void *pMilesEngine = NULL;
if ( g_pBIK)
{
ConVarRef windows_speaker_config("windows_speaker_config");
if ( windows_speaker_config.IsValid() && windows_speaker_config.GetInt() >= 5 )
{
pMilesEngine = vaudio ? vaudio->CreateMilesAudioEngine() : NULL;
#if !defined( _GAMECONSOLE )
g_pBIK->SetMilesSoundDevice( pMilesEngine );
#endif //!defined( _GAMECONSOLE )
}
else
{
#if !defined( _GAMECONSOLE )
g_pBIK->SetMilesSoundDevice( NULL );
#endif //!defined( _GAMECONSOLE )
}
}
#endif // defined( PLATFORM_WINDOWS ) && defined( BINK_VIDEO )
PlayVideoListAndWait( pszFile );
#if defined( PLATFORM_WINDOWS ) && defined( BINK_VIDEO )
if ( pMilesEngine )
{
#if !defined( _GAMECONSOLE )
g_pBIK->SetMilesSoundDevice( NULL );
#endif //!defined( _GAMECONSOLE )
vaudio->DestroyMilesAudioEngine( pMilesEngine );
}
#endif
#endif // DEDICATED
}
#define MAX_CAPTION_LENGTH 256
class CCaptionSequencer
{
public:
CCaptionSequencer( void ) : m_bCaptions( false )
{
Reset();
}
void Reset( void )
{
// captioning start when rendering stable, not simply at movie start
m_CaptionStartTime = 0;
// initial priming state to fetch a caption
m_bShowingCaption = false;
m_bCaptionStale = true;
m_CurCaptionString[0] = '\0';
m_CurCaptionStartTime = 0.0f;
m_CurCaptionEndTime = 0.0f;
m_CurCaptionColor = 0xFFFFFFFF;
if ( m_CaptionBuf.TellPut() )
{
// reset to start
m_CaptionBuf.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
}
}
void Init( const char *pFilename )
{
m_bCaptions = false;
if ( g_pFullFileSystem->ReadFile( pFilename, "GAME", m_CaptionBuf ) )
{
// FIXME: This needs the MOD dir to construct the filename properly!
// See me when this is being merged into Main -- jweier
g_pVGuiLocalize->AddFile( "resource/l4d360ui_%language%.txt", "GAME", true );
m_bCaptions = true;
}
}
void SetStartTime( float flStarTtime )
{
// Start our captions now
m_CaptionStartTime = Plat_FloatTime();
}
bool GetCaptionToken( char *token, int tokenLen )
{
if ( !token || !tokenLen )
return false;
if ( !m_CaptionBuf.IsValid() )
{
// end of data
return false;
}
m_CaptionBuf.GetLine( token, tokenLen );
#ifdef _WIN32
char *pCRLF = V_stristr( token, "\r" );
if ( pCRLF )
{
*pCRLF = '\0';
}
m_CaptionBuf.SeekGet( CUtlBuffer::SEEK_CURRENT, 1 );
#else
char *pCRLF = V_stristr( token, "\n" );
if ( pCRLF )
{
*pCRLF = '\0';
}
#endif
return true;
}
bool GetNextCaption( void )
{
char buff[MAX_CAPTION_LENGTH];
if ( !GetCaptionToken( m_CurCaptionString, sizeof( m_CurCaptionString ) ) )
{
// end of captions
m_CurCaptionString[0] = '\0';
return false;
}
// hex color
GetCaptionToken( buff, sizeof( buff ) );
sscanf( buff, "%x", &m_CurCaptionColor );
// float start time
GetCaptionToken( buff, sizeof( buff ) );
m_CurCaptionStartTime = atof( buff );
// float end time
GetCaptionToken( buff, sizeof( buff ) );
m_CurCaptionEndTime = atof( buff );
// have valid caption
m_bCaptionStale = false;
return true;
}
const char *GetCurrentCaption( int *pColorOut )
{
if ( m_bCaptions == false )
return NULL;
if ( m_CaptionStartTime )
{
// get a timeline
float elapsed = Plat_FloatTime() - m_CaptionStartTime;
// Get a new caption because we've just finished one
if ( !m_bShowingCaption && m_bCaptionStale )
{
GetNextCaption();
}
if ( m_bShowingCaption )
{
if ( elapsed > m_CurCaptionEndTime ) // Caption just turned off
{
m_bShowingCaption = false; // Don't draw caption
m_bCaptionStale = true; // Trigger getting a new one on the next frame
}
}
else
{
if ( elapsed > m_CurCaptionStartTime ) // Turn Caption on
{
m_bShowingCaption = true;
}
}
if ( m_bShowingCaption && m_CurCaptionString[0] )
{
if ( pColorOut )
{
*pColorOut = m_CurCaptionColor;
}
return m_CurCaptionString;
}
}
return NULL;
}
private:
// Captions / Subtitles
bool m_bCaptions;
bool m_bShowingCaption;
bool m_bCaptionStale;
vgui::HScheme m_hCaptionFont;
float m_CaptionStartTime;
CUtlBuffer m_CaptionBuf;
char m_CurCaptionString[MAX_CAPTION_LENGTH];
float m_CurCaptionStartTime;
float m_CurCaptionEndTime;
unsigned int m_CurCaptionColor;
};
// Panel for drawing subtitles on a movie panel
// Panel for drawing subtitles on a movie panel
class CSubtitlePanel : public vgui::Panel
{
public:
CSubtitlePanel( vgui::Panel *parent, const char *pMovieName, int nPlaybackHeight ) : vgui::Panel( parent, "SubtitlePanel" )
{
// FIXME: Need a better method for this
vgui::HScheme hScheme = vgui::scheme()->LoadSchemeFromFile("Resource/SourceScheme.res", "Tracker" );
vgui::IScheme *pNewScheme = vgui::scheme()->GetIScheme( hScheme );
if ( pNewScheme )
{
m_hFont = pNewScheme->GetFont( "CloseCaption_IntroMovie", true );
}
m_pSubtitleLabel = new vgui::Label( this, "SubtitleLabel", L"" );
m_pSubtitleLabel->SetFont( m_hFont );
int fontTall = vgui::surface()->GetFontTall( m_hFont );
int width, height;
vgui::surface()->GetScreenSize( width, height );
// clamp width to title safe area
int xPos = width * 0.05f;
width *= 0.9f;
// assume video is centered
// must be scaled according to playback height, due to letterboxing
// don't want to cut into or overlap border, need to be within video, and title safe
// so pushes up according to font height
int yOffset = ( nPlaybackHeight - height )/2;
int yPos = ( 0.85f * nPlaybackHeight - fontTall ) - yOffset;
// captions are anchored to a baseline and grow upward
// any resolution changes then are title safe
m_pSubtitleLabel->SetPos( xPos, yPos );
m_pSubtitleLabel->SetTall( fontTall*2 );
m_pSubtitleLabel->SetWide( width );
m_pSubtitleLabel->SetContentAlignment( vgui::Label::a_center );
m_pSubtitleLabel->SetCenterWrap( true );
// Strip our extension
char captionFilename[MAX_QPATH];
Q_StripExtension( pMovieName, captionFilename, MAX_QPATH );
// Now add on the '_captions.txt' ending
Q_strncat( captionFilename, "_captions.txt", MAX_QPATH );
// Setup our captions
m_Captions.Init( captionFilename );
}
void StartCaptions( void )
{
m_Captions.SetStartTime( Plat_FloatTime() );
}
virtual void Paint( void )
{
int nColor = 0xFFFFFFFF;
const char *pCaptionText = m_Captions.GetCurrentCaption( &nColor );
m_pSubtitleLabel->SetText( pCaptionText );
// Pull the color out of this hex value
int r = ( nColor >> 24 ) & 0xFF;
int g = ( nColor >> 16 ) & 0xFF;
int b = ( nColor >> 8 ) & 0xFF;
int a = ( nColor >> 0 ) & 0xFF;
m_pSubtitleLabel->SetFgColor( Color(r,g,b,a) );
vgui::Panel::Paint();
}
private:
CCaptionSequencer m_Captions;
vgui::HFont m_hFont;
vgui::Label *m_pSubtitleLabel;
};
const char *lpszDubbedLanguages[] =
{
"english",
"french",
"german",
"spanish",
"russian"
};
//-----------------------------------------------------------------------------
// Purpose: Determines if we should be playing with captions
//-----------------------------------------------------------------------------
inline bool ShouldUseCaptioning( void )
{
char language[64];
// Fallback to English
V_strncpy( language, "english", sizeof( language ) );
#if !defined( NO_STEAM ) && !defined( DEDICATED )
// When Steam isn't running we can't get the language info...
if ( Steam3Client().SteamApps() )
{
V_strncpy( language, Steam3Client().SteamApps()->GetCurrentGameLanguage(), sizeof(language) );
}
#endif
// Iterate through the language we have dubbed and don't subtitle in that case
for ( int i = 0; i < ARRAYSIZE( lpszDubbedLanguages ); i++ )
{
if ( Q_stricmp( language, lpszDubbedLanguages[i] ) == 0 )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Tests for players attempting to skip a movie via keypress
//-----------------------------------------------------------------------------
bool UserRequestingMovieSkip( void )
{
if ( IsGameConsole() )
{
// Any joystick can cause the skip, so we must check all four
for ( int i = 0; i < XUSER_MAX_COUNT; i++ )
{
// If any of these buttons are down, we skip
if ( g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_A, i ) ) ||
g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_B, i ) ) ||
g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_X, i ) ) ||
g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_Y, i ) ) ||
g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_START, i ) ) ||
g_pInputSystem->IsButtonDown( ButtonCodeToJoystickButtonCode( KEY_XBUTTON_BACK, i ) ) )
{
return true;
}
}
// Nothing pressed
return false;
}
return ( g_pInputSystem->IsButtonDown( KEY_ESCAPE ) ||
g_pInputSystem->IsButtonDown( KEY_SPACE ) ||
g_pInputSystem->IsButtonDown( KEY_ENTER ) );
}
#if defined( _X360 )
static char const * GetConsoleLocaleRatingsBoard()
{
switch ( XGetLocale() )
{
case XC_LOCALE_AUSTRALIA: return "OFLC";
case XC_LOCALE_AUSTRIA: return "PEGI";
case XC_LOCALE_BELGIUM: return "PEGI";
case XC_LOCALE_BRAZIL: return "";
case XC_LOCALE_CANADA: return "ESRB";
case XC_LOCALE_CHILE: return "";
case XC_LOCALE_CHINA: return "";
case XC_LOCALE_COLOMBIA: return "";
case XC_LOCALE_CZECH_REPUBLIC: return "PEGI";
case XC_LOCALE_DENMARK: return "PEGI";
case XC_LOCALE_FINLAND: return "PEGI";
case XC_LOCALE_FRANCE: return "PEGI";
case XC_LOCALE_GERMANY: return "USK";
case XC_LOCALE_GREECE: return "PEGI";
case XC_LOCALE_HONG_KONG: return "";
case XC_LOCALE_HUNGARY: return "";
case XC_LOCALE_INDIA: return "";
case XC_LOCALE_IRELAND: return "BBFCPEGI";
case XC_LOCALE_ITALY: return "PEGI";
case XC_LOCALE_JAPAN: return "CERO";
case XC_LOCALE_KOREA: return "GRB";
case XC_LOCALE_MEXICO: return "";
case XC_LOCALE_NETHERLANDS: return "PEGI";
case XC_LOCALE_NEW_ZEALAND: return "OFLC";
case XC_LOCALE_NORWAY: return "PEGI";
case XC_LOCALE_POLAND: return "PEGI";
case XC_LOCALE_PORTUGAL: return "PEGI";
case XC_LOCALE_SINGAPORE: return "";
case XC_LOCALE_SLOVAK_REPUBLIC: return "PEGI";
case XC_LOCALE_SOUTH_AFRICA: return "";
case XC_LOCALE_SPAIN: return "PEGI";
case XC_LOCALE_SWEDEN: return "PEGI";
case XC_LOCALE_SWITZERLAND: return "PEGI";
case XC_LOCALE_TAIWAN: return "";
case XC_LOCALE_GREAT_BRITAIN: return "BBFCPEGI";
case XC_LOCALE_UNITED_STATES: return "ESRB";
default: return NULL;
}
}
#endif
void CGame::PlayVideoListAndWait( const char *szVideoFileList, bool bNeedHealthWarning /* = false */ )
{
#ifndef DEDICATED
CUtlBuffer vidBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( !g_pFullFileSystem->ReadFile( szVideoFileList, "GAME", vidBuffer ) )
{
return;
}
#if defined( USE_SDL )
int CursorStateBak = SDL_ShowCursor( -1 );
SDL_ShowCursor( 0 );
#elif defined( WIN32 )
// hide cursor while playing videos
::ShowCursor(FALSE);
#endif
#if defined( OSX ) && !defined( USE_SDL )
CGDisplayHideCursor( kCGDirectMainDisplay );
#endif
#ifdef _X360
// TCR024
XMPOverrideBackgroundMusic();
#endif
#ifdef _GAMECONSOLE
// Install movie player match framework
extern IMatchFramework *g_pMoviePlayer_MatchFramework;
bool bInstalledMoviePlayerMatchFramework = false;
if ( !g_pMatchFramework && IsGameConsole() )
{
#ifdef _X360
XOnlineStartup();
#endif
g_pMatchFramework = g_pMoviePlayer_MatchFramework;
bInstalledMoviePlayerMatchFramework = true;
}
#ifdef _PS3
int iLibAudioInitCode = cellAudioInit();
CellAudioOutState caosDevice = {0};
if ( iLibAudioInitCode >= 0 )
{
int numDevices = cellAudioOutGetNumberOfDevice( CELL_AUDIO_OUT_PRIMARY );
if ( numDevices > 0 )
{
int iAudioState = cellAudioOutGetState( CELL_AUDIO_OUT_PRIMARY, 0, &caosDevice );
if ( g_pBIK && ( iAudioState >= 0 ) )
{
g_pBIK->SetPS3SoundDevice( caosDevice.soundMode.channel );
}
}
}
#endif
#endif
characterset_t breakSet;
CharacterSetBuild( &breakSet, "" );
char moviePath[MAX_PATH];
while ( !IsPS3QuitRequested() )
{
int nTokenSize = vidBuffer.ParseToken( &breakSet, moviePath, sizeof( moviePath ) );
if ( nTokenSize <= 0 )
{
break;
}
// get the path to the file and play it.
PlayVideoAndWait( moviePath, bNeedHealthWarning );
}
#ifdef _GAMECONSOLE
#ifdef _PS3
if ( iLibAudioInitCode >= 0 )
{
cellAudioQuit();
}
#endif
if ( ( g_pMatchFramework == g_pMoviePlayer_MatchFramework ) && bInstalledMoviePlayerMatchFramework )
{
#ifdef _X360
XOnlineCleanup();
#endif
g_pMatchFramework = NULL;
}
#endif
#ifdef _X360
// TCR024
XMPRestoreBackgroundMusic();
#endif
#if defined( USE_SDL )
SDL_ShowCursor( CursorStateBak );
#elif defined( WIN32 )
// show cursor again
::ShowCursor(TRUE);
#endif
#ifdef OSX
CGDisplayShowCursor( kCGDirectMainDisplay );
#endif
#endif // DEDICATED
}
//-----------------------------------------------------------------------------
// Plays a Bink video until the video completes or user input cancels
//-----------------------------------------------------------------------------
void CGame::PlayVideoAndWait( const char *filename, bool bNeedHealthWarning )
{
#if defined( BINK_VIDEO )
#if defined( IS_WINDOWS_PC ) || defined( OSX ) || defined( _GAMECONSOLE )
if ( !filename || !filename[0] )
return;
if ( !g_pBIK )
return;
#if defined( _X360 ) && defined( _DEMO )
// Xbox 360 is required to show ratings from the locale specific ratings board
if ( char const *pszRating = Q_stristr( filename, "RATINGBOARD" ) )
{
// Determine the rating of the current locale
char const *szRatingBoard = GetConsoleLocaleRatingsBoard();
if ( !szRatingBoard || !*szRatingBoard )
return;
// Format it into the buffer
int nRatingPrefixLen = ( pszRating - filename );
int numBufferBytes = nRatingPrefixLen + Q_strlen( szRatingBoard ) + 32;
char *pchRatingBuffer = ( char * ) stackalloc( numBufferBytes );
Q_snprintf( pchRatingBuffer, numBufferBytes, "%.*s%s.bik", nRatingPrefixLen, filename, szRatingBoard );
filename = pchRatingBuffer; // stackalloc ensures that the buffer is valid until the function returns
}
#else
if ( Q_stristr( filename, "RATINGBOARD" ) )
return;
#endif
// Supplying a NULL context will cause Bink to allocate its own
// FIXME: At this point we're playing at the full volume of the computer, NOT the user's set volume in the game!
#if defined( _X360 )
if ( Audio_CreateXAudioDevice( false ) )
{
#if defined ( BINK_VIDEO )
if ( !g_pBIK->HookXAudio() )
return;
#endif
}
#elif defined( LINUX )
Audio_CreateSDLAudioDevice();
#elif defined( _PS3 )
// S_Init(); // fully initialize sound system here
#elif defined( PLATFORM_WINDOWS )
//BinkSoundUseDirectSound( NULL ); // Bink sound is initialized by the caller now
#endif
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
#if defined ( QUICKTIME_VIDEO )
IQuickTime *pVideoPlayer = g_pQuickTime;
QUICKTIMEMaterial_t VideoHandle;
QUICKTIMEMaterial_t InvalidVideoHandle = QUICKTIMEMATERIAL_INVALID;
#elif defined( BINK_VIDEO )
IBik *pVideoPlayer = g_pBIK;
BIKHandle_t VideoHandle;
BIKHandle_t InvalidVideoHandle = BIKHANDLE_INVALID;
#else
#error "Need to have support for video playback enabled via source_video_base.vpc"
#endif
if ( !pVideoPlayer )
return;
// get the path to the media file and play it.
char localPath[MAX_PATH];
// Are we wanting to use a quicktime ".mov" version of the media instead of what's specified?
#if defined( FORCE_QUICKTIME ) && defined( QUICKTIME_VIDEO )
// is it not a .mov file extension?
if ( V_stristr( com_token, ".mov") == NULL )
{
// Compose Quicktime version
char QTPath[MAX_PATH];
V_strncpy( QTPath, filename, MAX_PATH );
V_SetExtension( QTPath, ".mov", MAX_PATH );
g_pFileSystem->GetLocalPath( QTPath, localPath, sizeof(localPath) );
}
else
#endif
{
V_strncpy( localPath, filename, sizeof(localPath) );
}
// Load and create our BINK or QuickTime video
VideoHandle = pVideoPlayer->CreateMaterial( "VideoMaterial", localPath, "GAME" );
if ( VideoHandle == InvalidVideoHandle )
{
return;
}
float flU0 = 0.0f;
float flV0 = 0.0f;
float flU1, flV1;
pVideoPlayer->GetTexCoordRange( VideoHandle, &flU1, &flV1 );
IMaterial *pMaterial = pVideoPlayer->GetMaterial( VideoHandle );
int nTexHeight = pMaterial->GetMappingHeight();
int nTexWidth = pMaterial->GetMappingWidth();
int nWidth, nHeight;
pVideoPlayer->GetFrameSize( VideoHandle, &nWidth, &nHeight );
const AspectRatioInfo_t &aspectRatioInfo = materials->GetAspectRatioInfo();
// Determine how the video's aspect ratio relates to the screen's
float flPhysicalFrameRatio = aspectRatioInfo.m_flFrameBuffertoPhysicalScalar * ( ( float )m_width / ( float )m_height );
float flVideoRatio = ( ( float ) nWidth / ( float ) nHeight );
int nPlaybackWidth;
int nPlaybackHeight;
if ( flVideoRatio > flPhysicalFrameRatio )
{
// Height must be adjusted
nPlaybackWidth = m_width;
// Have to account for the difference between physical and pixel aspect ratios.
nPlaybackHeight = ( ( float )m_width / aspectRatioInfo.m_flPhysicalToFrameBufferScalar ) / flVideoRatio;
}
else if ( flVideoRatio < flPhysicalFrameRatio )
{
// Width must be adjusted
// Have to account for the difference between physical and pixel aspect ratios.
nPlaybackWidth = ( float )m_height * flVideoRatio * aspectRatioInfo.m_flPhysicalToFrameBufferScalar;
nPlaybackHeight = m_height;
}
else
{
// Ratio matches
nPlaybackWidth = m_width;
nPlaybackHeight = m_height;
}
// Turn off our vertex alpha for these draw calls as they don't write alpha per-vertex
pMaterial->SetMaterialVarFlag( MATERIAL_VAR_VERTEXALPHA, false );
// Prep the screen
pRenderContext->Viewport( 0, 0, m_width, m_height );
pRenderContext->DepthRange( 0, 1 );
pRenderContext->ClearColor3ub( 0, 0, 0 );
pRenderContext->SetToneMappingScaleLinear( Vector(1,1,1) );
// Find our letterboxing offset
int xpos = ( (float) ( m_width - nPlaybackWidth ) / 2 );
int ypos = ( (float) ( m_height - nPlaybackHeight ) / 2 );
// Enable the input system's message pump
g_pInputSystem->EnableMessagePump( true );
// Panel which allows for subtitling of startup movies
CSubtitlePanel *pSubtitlePanel = NULL;
bool bUseCaptioning = ShouldUseCaptioning();
if ( bUseCaptioning )
{
// Create a panel whose purpose is to
pSubtitlePanel = new CSubtitlePanel( NULL, filename, nPlaybackHeight );
pSubtitlePanel->SetParent( g_pMatSystemSurface->GetEmbeddedPanel() );
pSubtitlePanel->SetPaintBackgroundEnabled( false );
pSubtitlePanel->SetPaintEnabled( true );
pSubtitlePanel->SetBounds( 0, 0, m_width, m_height );
// VGUI needs a chance to move this panel into its global space
vgui::ivgui()->RunFrame();
// Start the caption sequence
pSubtitlePanel->StartCaptions();
}
// We need to make sure that these keys have been released since last pressed, otherwise you can skip
// movies inadvertently
bool bKeyDebounced = ( UserRequestingMovieSkip() == false );
bool bExitingProcess = false;
#if defined( _DEMO ) && defined( _X360 )
bExitingProcess = Host_IsDemoExiting();
#endif
while ( 1 )
{
#ifdef _GAMECONSOLE
if ( !bExitingProcess )
{
XBX_ProcessEvents(); // Force events to be processed that will deliver us ingame invites
XBX_DispatchEventsQueue(); // Dispatch the events too
}
#endif
// Pump messages to avoid lockups on focus change
g_pInputSystem->PollInputState( GetBaseLocalClient().IsActive() );
game->DispatchAllStoredGameMessages();
// xbox cannot skip legals
if ( bKeyDebounced && ( IsPC() || ( IsGameConsole() && !Q_stristr( filename, "valve" ) ) ) )
{
if ( !bExitingProcess && UserRequestingMovieSkip() )
break;
}
else
{
bKeyDebounced = ( UserRequestingMovieSkip() == false );
}
// Update our frame
if ( pVideoPlayer->Update( VideoHandle ) == false )
break;
if( IsPS3QuitRequested() )
break;
pRenderContext->AntiAliasingHint( AA_HINT_MOVIE );
// Clear the draw buffer and blt the material to it
pRenderContext->ClearBuffers( true, true, true );
pRenderContext->DrawScreenSpaceRectangle( pMaterial, xpos, ypos, nPlaybackWidth, nPlaybackHeight, flU0*nTexWidth, flV0*nTexHeight, flU1*nTexWidth-1, flV1*nTexHeight-1, nTexWidth, nTexHeight );
// Draw our VGUI panel
if ( bUseCaptioning )
{
vgui::surface()->PaintTraverse( pSubtitlePanel->GetVPanel() );
}
// Busy wait until we are ready to swap.
#ifdef QUICKTIME_VIDEO
while ( !pVideoPlayer->ReadyForSwap( BIKHandle ) )
#else
// TODO - is this valid with threaded bink changes?: while ( !pVideoPlayer->ReadyForSwap( BIKHandle ) )
#endif
{
NULL;
}
g_pMaterialSystem->SwapBuffers();
if ( ENABLE_BIK_PERF_SPEW )
{
// timing debug code for bink playback
static double flPreviousTime = -1.0;
double flTime = Plat_FloatTime();
double flDeltaTime = flTime - flPreviousTime;
if ( flDeltaTime > 0.0 )
{
Warning( "%0.2lf sec*60 %0.2lf fps\n", flDeltaTime * 60.0, 1.0 / flDeltaTime );
}
flPreviousTime = flTime;
}
}
// Disable the input system's message pump
g_pInputSystem->EnableMessagePump( false );
// Clean up the Bink video
if ( VideoHandle != InvalidVideoHandle )
{
pVideoPlayer->DestroyMaterial( VideoHandle );
}
// Clean up VGUI work
delete pSubtitlePanel;
#endif
#endif // BINK_VIDEO
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGame::CGame()
{
#ifndef LINUX
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;
m_hInputContext = INPUT_CONTEXT_HANDLE_INVALID;
#if defined( WIN32 ) && !defined( USE_SDL )
m_hInstance = 0;
m_ChainedWindowProc = NULL;
#endif
}
//-----------------------------------------------------------------------------
// 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
m_hInputContext = g_pInputStackSystem->PushInputContext();
// Capture + hide the mouse
g_pInputStackSystem->SetMouseCapture( m_hInputContext, true );
return true;
}
bool CGame::Shutdown( void )
{
if ( m_hInputContext != INPUT_CONTEXT_HANDLE_INVALID )
{
g_pInputStackSystem->PopInputContext();
m_hInputContext = INPUT_CONTEXT_HANDLE_INVALID;
}
#if defined( WIN32 ) && !defined( USE_SDL )
m_hInstance = 0;
#endif
#ifdef _PS3
AbortLoadingUpdatesDueToShutdown();
#endif
return true;
}
void *CGame::GetMainWindow( void )
{
#if defined( LINUX )
return 0;
#else
return (void*)m_hWindow;
#endif
}
#if defined(USE_SDL)
void** CGame::GetMainWindowAddress( void )
{
m_hWindow = (SDL_Window *)g_pLauncherMgr->GetWindowRef();
return (void**)&m_hWindow;
}
#elif defined( WIN32 )
void** CGame::GetMainWindowAddress( void )
{
return (void**)&m_hWindow;
}
#elif defined(OSX)
void** CGame::GetMainWindowAddress( void )
{
m_hWindow = (WindowRef)g_pLauncherMgr->GetWindowRef();
return (void**)&m_hWindow;
}
#else
#error
#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;
}
}
}
#elif defined( WIN32 )
// 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;
#elif defined(OSX)
if ( m_iDesktopWidth == 0 )
{
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CGDisplayModeRef displayMode = CGDisplayCopyDisplayMode(mainDisplay);
width = (int)CGDisplayModeGetWidth(displayMode);
height = (int)CGDisplayModeGetHeight(displayMode);
refreshrate = (int)CGDisplayModeGetRefreshRate(displayMode);
}
width = m_iDesktopWidth;
height = m_iDesktopHeight;
refreshrate = m_iDesktopRefreshRate;
#else
#error
#endif
}
void CGame::UpdateDesktopInformation( HWND hWnd )
{
#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;
#elif defined( WIN32 )
HDC dc = ::GetDC( hWnd );
m_iDesktopWidth = ::GetDeviceCaps(dc, HORZRES);
m_iDesktopHeight = ::GetDeviceCaps(dc, VERTRES);
m_iDesktopRefreshRate = ::GetDeviceCaps(dc, VREFRESH);
::ReleaseDC( hWnd, dc );
#elif defined(OSX)
CGDirectDisplayID mainDisplay = CGMainDisplayID();
CGDisplayModeRef displayMode = CGDisplayCopyDisplayMode(mainDisplay);
m_iDesktopWidth = (int)CGDisplayModeGetWidth(displayMode);
m_iDesktopHeight = (int)CGDisplayModeGetHeight(displayMode);;
m_iDesktopRefreshRate = (int)CGDisplayModeGetRefreshRate(displayMode);
#else
#error
#endif
}
#ifdef WIN32
void CGame::UpdateDesktopInformation( WPARAM wParam, LPARAM lParam )
{
m_iDesktopWidth = LOWORD( lParam );
m_iDesktopHeight = HIWORD( lParam );
}
#endif
void CGame::SetMainWindow( HWND window )
{
#if defined( USE_SDL )
m_hWindow = (SDL_Window*)window;
#elif defined( WIN32 ) && !defined( USE_SDL )
m_hWindow = window;
#elif OSX
m_hWindow = (WindowRef)window;
#else
#error
#endif
if ( IsPC() && !IsPosix() )
{
avi->SetMainWindow( (void*)window );
}
// update our desktop info (since the results will change if we are going to fullscreen mode)
if ( !m_iDesktopWidth || !m_iDesktopHeight )
{
UpdateDesktopInformation( window );
}
}
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;
}
void CGame::OnScreenSizeChanged( int nOldWidth, int nOldHeight )
{
if ( g_ClientDLL )
{
g_ClientDLL->OnScreenSizeChanged( nOldWidth, nOldHeight );
}
}
Reference in New Issue View Git Blame Copy Permalink