mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
2694 lines
82 KiB
C++
2694 lines
82 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#if defined( USE_SDL )
|
|
#undef PROTECTED_THINGS_ENABLE
|
|
#include "SDL.h"
|
|
#include "SDL_syswm.h"
|
|
#endif
|
|
|
|
#if defined( _WIN32 ) && !defined( _X360 )
|
|
#include "winlite.h"
|
|
#elif defined(POSIX)
|
|
typedef void *HDC;
|
|
#endif
|
|
|
|
#include "appframework/ilaunchermgr.h"
|
|
|
|
#include "basetypes.h"
|
|
#include "sysexternal.h"
|
|
#include "cmd.h"
|
|
#include "modelloader.h"
|
|
#include "gl_matsysiface.h"
|
|
#include "vmodes.h"
|
|
#include "modes.h"
|
|
#include "ivideomode.h"
|
|
#include "igame.h"
|
|
#include "iengine.h"
|
|
#include "engine_launcher_api.h"
|
|
#include "iregistry.h"
|
|
#include "common.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "cl_main.h"
|
|
#include "filesystem_engine.h"
|
|
#include "host.h"
|
|
#include "gl_model_private.h"
|
|
#include "bitmap/tgawriter.h"
|
|
#include "vtf/vtf.h"
|
|
#include "materialsystem/materialsystem_config.h"
|
|
#include "materialsystem/itexture.h"
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
|
#include "jpeglib/jpeglib.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui_controls/Controls.h"
|
|
#include "gl_shader.h"
|
|
#include "sys_dll.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "IHammer.h"
|
|
#include "sourcevr/isourcevirtualreality.h"
|
|
#include "tier2/tier2.h"
|
|
#include "tier2/renderutils.h"
|
|
#include "tier0/etwprof.h"
|
|
#if defined( _X360 )
|
|
#include "xbox/xbox_win32stubs.h"
|
|
#else
|
|
#include "xbox/xboxstubs.h"
|
|
#endif
|
|
#include "video/ivideoservices.h"
|
|
#if !defined(NO_STEAM)
|
|
#include "cl_steamauth.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CL_GetBackgroundLevelName(char *pszBackgroundName, int bufSize, bool bMapName);
|
|
void ClientDLL_HudVidInit( void );
|
|
|
|
ConVar cl_savescreenshotstosteam( "cl_savescreenshotstosteam", "0", FCVAR_HIDDEN, "Saves screenshots to the Steam's screenshot library" );
|
|
ConVar cl_screenshotusertag( "cl_screenshotusertag", "", FCVAR_HIDDEN, "User to tag in the screenshot" );
|
|
ConVar cl_screenshotlocation( "cl_screenshotlocation", "", FCVAR_HIDDEN, "Location to tag the screenshot with" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// HDRFIXME: move this somewhere else.
|
|
//-----------------------------------------------------------------------------
|
|
static void PFMWrite( float *pFloatImage, const char *pFilename, int width, int height )
|
|
{
|
|
FileHandle_t fp;
|
|
fp = g_pFileSystem->Open( pFilename, "wb" );
|
|
g_pFileSystem->FPrintf( fp, "PF\n%d %d\n-1.000000\n", width, height );
|
|
int i;
|
|
for( i = height-1; i >= 0; i-- )
|
|
{
|
|
float *pRow = &pFloatImage[3 * width * i];
|
|
g_pFileSystem->Write( pRow, width * sizeof( float ) * 3, fp );
|
|
}
|
|
g_pFileSystem->Close( fp );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Functionality shared by all video modes
|
|
//-----------------------------------------------------------------------------
|
|
class CVideoMode_Common : public IVideoMode
|
|
{
|
|
public:
|
|
CVideoMode_Common( void );
|
|
virtual ~CVideoMode_Common( void );
|
|
|
|
// Methods of IVideoMode
|
|
virtual bool Init( );
|
|
virtual void Shutdown( void );
|
|
virtual vmode_t *GetMode( int num );
|
|
virtual int GetModeCount( void );
|
|
virtual bool IsWindowedMode( void ) const;
|
|
virtual void UpdateWindowPosition( void );
|
|
virtual void RestoreVideo( void );
|
|
virtual void ReleaseVideo( void );
|
|
virtual void DrawNullBackground( void *hdc, int w, int h );
|
|
virtual void InvalidateWindow();
|
|
virtual void DrawStartupGraphic();
|
|
virtual bool CreateGameWindow( int nWidth, int nHeight, bool bWindowed );
|
|
virtual int GetModeWidth( void ) const;
|
|
virtual int GetModeHeight( void ) const;
|
|
virtual int GetModeStereoWidth() const;
|
|
virtual int GetModeStereoHeight() const;
|
|
virtual int GetModeUIWidth() const OVERRIDE;
|
|
virtual int GetModeUIHeight() const OVERRIDE;
|
|
virtual const vrect_t &GetClientViewRect( ) const;
|
|
virtual void SetClientViewRect( const vrect_t &viewRect );
|
|
virtual void MarkClientViewRectDirty();
|
|
virtual void TakeSnapshotTGA( const char *pFileName );
|
|
virtual void TakeSnapshotTGARect( const char *pFilename, int x, int y, int w, int h, int resampleWidth, int resampleHeight, bool bPFM, CubeMapFaceIndex_t faceIndex );
|
|
virtual void WriteMovieFrame( const MovieInfo_t& info );
|
|
virtual void TakeSnapshotJPEG( const char *pFileName, int quality );
|
|
virtual bool TakeSnapshotJPEGToBuffer( CUtlBuffer& buf, int quality );
|
|
protected:
|
|
bool GetInitialized( ) const;
|
|
void SetInitialized( bool init );
|
|
void AdjustWindow( int nWidth, int nHeight, int nBPP, bool bWindowed );
|
|
void ResetCurrentModeForNewResolution( int width, int height, bool bWindowed );
|
|
int GetModeBPP( ) const { return 32; }
|
|
void DrawStartupVideo();
|
|
void ComputeStartupGraphicName( char *pBuf, int nBufLen );
|
|
void WriteScreenshotToSteam( uint8 *pImage, int cubImage, int width, int height );
|
|
void AddScreenshotToSteam( const char *pchFilenameJpeg, int width, int height );
|
|
#if !defined(NO_STEAM)
|
|
void ApplySteamScreenshotTags( ScreenshotHandle hScreenshot );
|
|
#endif
|
|
|
|
// Finds the video mode in the list of video modes
|
|
int FindVideoMode( int nDesiredWidth, int nDesiredHeight, bool bWindowed );
|
|
|
|
// Purpose: Returns the optimal refresh rate for the specified mode
|
|
int GetRefreshRateForMode( const vmode_t *pMode );
|
|
|
|
// Inline accessors
|
|
vmode_t& DefaultVideoMode();
|
|
vmode_t& RequestedWindowVideoMode();
|
|
|
|
private:
|
|
// Purpose: Loads the startup graphic
|
|
void SetupStartupGraphic();
|
|
void CenterEngineWindow(void *hWndCenter, int width, int height);
|
|
void DrawStartupGraphic( HWND window );
|
|
void BlitGraphicToHDC(HDC hdc, byte *rgba, int imageWidth, int imageHeight, int x0, int y0, int x1, int y1);
|
|
void BlitGraphicToHDCWithAlpha(HDC hdc, byte *rgba, int imageWidth, int imageHeight, int x0, int y0, int x1, int y1);
|
|
IVTFTexture *LoadVTF( CUtlBuffer &temp, const char *szFileName );
|
|
void RecomputeClientViewRect();
|
|
|
|
// Overridden by derived classes
|
|
virtual void ReleaseFullScreen( void );
|
|
virtual void ChangeDisplaySettingsToFullscreen( int nWidth, int nHeight, int nBPP );
|
|
virtual void ReadScreenPixels( int x, int y, int w, int h, void *pBuffer, ImageFormat format );
|
|
|
|
// PFM screenshot methods
|
|
ITexture *GetBuildCubemaps16BitTexture( void );
|
|
ITexture *GetFullFrameFB0( void );
|
|
|
|
void BlitHiLoScreenBuffersTo16Bit( void );
|
|
void TakeSnapshotPFMRect( const char *pFilename, int x, int y, int w, int h, int resampleWidth, int resampleHeight, CubeMapFaceIndex_t faceIndex );
|
|
|
|
protected:
|
|
enum
|
|
{
|
|
#if !defined( _X360 )
|
|
MAX_MODE_LIST = 512
|
|
#else
|
|
MAX_MODE_LIST = 2
|
|
#endif
|
|
};
|
|
|
|
enum
|
|
{
|
|
VIDEO_MODE_DEFAULT = -1,
|
|
VIDEO_MODE_REQUESTED_WINDOW_SIZE = -2,
|
|
CUSTOM_VIDEO_MODES = 2
|
|
};
|
|
|
|
// Master mode list
|
|
int m_nNumModes;
|
|
vmode_t m_rgModeList[MAX_MODE_LIST];
|
|
vmode_t m_nCustomModeList[CUSTOM_VIDEO_MODES];
|
|
bool m_bInitialized;
|
|
bool m_bPlayedStartupVideo;
|
|
|
|
// Renderable surface information
|
|
int m_nModeWidth;
|
|
int m_nModeHeight;
|
|
int m_nStereoWidth;
|
|
int m_nStereoHeight;
|
|
int m_nUIWidth;
|
|
int m_nUIHeight;
|
|
int m_nVROverrideX;
|
|
int m_nVROverrideY;
|
|
#if defined( USE_SDL )
|
|
int m_nRenderWidth;
|
|
int m_nRenderHeight;
|
|
#endif
|
|
bool m_bWindowed;
|
|
bool m_bSetModeOnce;
|
|
bool m_bVROverride;
|
|
|
|
// Client view rectangle
|
|
vrect_t m_ClientViewRect;
|
|
bool m_bClientViewRectDirty;
|
|
|
|
// loading image
|
|
IVTFTexture *m_pBackgroundTexture;
|
|
IVTFTexture *m_pLoadingTexture;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inline accessors
|
|
//-----------------------------------------------------------------------------
|
|
inline vmode_t& CVideoMode_Common::DefaultVideoMode()
|
|
{
|
|
return m_nCustomModeList[ - VIDEO_MODE_DEFAULT - 1 ];
|
|
}
|
|
|
|
inline vmode_t& CVideoMode_Common::RequestedWindowVideoMode()
|
|
{
|
|
return m_nCustomModeList[ - VIDEO_MODE_REQUESTED_WINDOW_SIZE - 1 ];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CVideoMode_Common::CVideoMode_Common( void )
|
|
{
|
|
m_nNumModes = 0;
|
|
m_bInitialized = false;
|
|
|
|
DefaultVideoMode().width = 640;
|
|
DefaultVideoMode().height = 480;
|
|
DefaultVideoMode().bpp = 32;
|
|
DefaultVideoMode().refreshRate = 0;
|
|
|
|
RequestedWindowVideoMode().width = -1;
|
|
RequestedWindowVideoMode().height = -1;
|
|
RequestedWindowVideoMode().bpp = 32;
|
|
RequestedWindowVideoMode().refreshRate = 0;
|
|
|
|
m_bClientViewRectDirty = false;
|
|
m_pBackgroundTexture = NULL;
|
|
m_pLoadingTexture = NULL;
|
|
m_bWindowed = false;
|
|
m_nModeWidth = IsPC() ? 1024 : 640;
|
|
m_nModeHeight = IsPC() ? 768 : 480;
|
|
m_bVROverride = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CVideoMode_Common::~CVideoMode_Common( void )
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_Common::GetInitialized( void ) const
|
|
{
|
|
return m_bInitialized;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : init -
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::SetInitialized( bool init )
|
|
{
|
|
m_bInitialized = init;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_Common::IsWindowedMode( void ) const
|
|
{
|
|
return m_bWindowed;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the video mode width + height.
|
|
//-----------------------------------------------------------------------------
|
|
int CVideoMode_Common::GetModeWidth( void ) const
|
|
{
|
|
return m_nModeWidth;
|
|
}
|
|
|
|
int CVideoMode_Common::GetModeHeight( void ) const
|
|
{
|
|
return m_nModeHeight;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the video mode width + height for one stereo view.
|
|
//-----------------------------------------------------------------------------
|
|
int CVideoMode_Common::GetModeStereoWidth( void ) const
|
|
{
|
|
return m_nStereoWidth;
|
|
}
|
|
|
|
int CVideoMode_Common::GetModeStereoHeight( void ) const
|
|
{
|
|
return m_nStereoHeight;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the video mode full screen UI width + height.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int CVideoMode_Common::GetModeUIWidth( void ) const
|
|
{
|
|
return m_nUIWidth;
|
|
}
|
|
|
|
int CVideoMode_Common::GetModeUIHeight( void ) const
|
|
{
|
|
return m_nUIHeight;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the enumerated video mode
|
|
//-----------------------------------------------------------------------------
|
|
vmode_t *CVideoMode_Common::GetMode( int num )
|
|
{
|
|
if ( num < 0 )
|
|
return &m_nCustomModeList[-num - 1];
|
|
|
|
if ( num >= m_nNumModes )
|
|
return &DefaultVideoMode();
|
|
|
|
return &m_rgModeList[num];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the number of fullscreen video modes
|
|
//-----------------------------------------------------------------------------
|
|
int CVideoMode_Common::GetModeCount( void )
|
|
{
|
|
return m_nNumModes;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Compares video modes so we can sort the list
|
|
// Input : *arg1 -
|
|
// *arg2 -
|
|
// Output : static int
|
|
//-----------------------------------------------------------------------------
|
|
static int __cdecl VideoModeCompare( const void *arg1, const void *arg2 )
|
|
{
|
|
vmode_t *m1, *m2;
|
|
|
|
m1 = (vmode_t *)arg1;
|
|
m2 = (vmode_t *)arg2;
|
|
|
|
if ( m1->width < m2->width )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ( m1->width == m2->width )
|
|
{
|
|
if ( m1->height < m2->height )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ( m1->height > m2->height )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_Common::Init( )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds the video mode in the list of video modes
|
|
//-----------------------------------------------------------------------------
|
|
int CVideoMode_Common::FindVideoMode( int nDesiredWidth, int nDesiredHeight, bool bWindowed )
|
|
{
|
|
#if defined( USE_SDL )
|
|
|
|
// If we want to scale the 3D portion of the game and leave the UI at the same res, then
|
|
// re-enable this code. Not that on retina displays the UI will be super small and that
|
|
// should probably be fixed.
|
|
#if 0
|
|
static ConVarRef mat_viewportscale( "mat_viewportscale" );
|
|
|
|
if ( !bWindowed )
|
|
{
|
|
m_nRenderWidth = nDesiredWidth;
|
|
m_nRenderHeight = nDesiredHeight;
|
|
|
|
uint nWidth, nHeight, nRefreshHz;
|
|
|
|
g_pLauncherMgr->GetNativeDisplayInfo( -1, nWidth, nHeight, nRefreshHz );
|
|
|
|
for ( int i = 0; i < m_nNumModes; i++)
|
|
{
|
|
if ( m_rgModeList[i].width != ( int )nWidth )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( m_rgModeList[i].height != ( int )nHeight )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( m_rgModeList[i].refreshRate != ( int )nRefreshHz )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
mat_viewportscale.SetValue( ( float )nDesiredWidth / ( float )nWidth );
|
|
return i;
|
|
}
|
|
|
|
Assert( 0 ); // we should have found our native resolution, why not???
|
|
}
|
|
else
|
|
{
|
|
mat_viewportscale.SetValue( 1.0f );
|
|
}
|
|
#endif // 0
|
|
|
|
#endif // USE_SDL
|
|
|
|
// Check the default window size..
|
|
if ( ( nDesiredWidth == DefaultVideoMode().width) && (nDesiredHeight == DefaultVideoMode().height) )
|
|
return VIDEO_MODE_DEFAULT;
|
|
|
|
// Check the requested window size, but only if we're running windowed
|
|
if ( bWindowed )
|
|
{
|
|
if ( ( nDesiredWidth == RequestedWindowVideoMode().width) && (nDesiredHeight == RequestedWindowVideoMode().height) )
|
|
return VIDEO_MODE_REQUESTED_WINDOW_SIZE;
|
|
}
|
|
|
|
int i;
|
|
int iOK = VIDEO_MODE_DEFAULT;
|
|
for ( i = 0; i < m_nNumModes; i++)
|
|
{
|
|
// Match width first
|
|
if ( m_rgModeList[i].width != nDesiredWidth )
|
|
continue;
|
|
|
|
iOK = i;
|
|
|
|
if ( m_rgModeList[i].height != nDesiredHeight )
|
|
continue;
|
|
|
|
// Found a decent match
|
|
break;
|
|
}
|
|
|
|
// No match, use mode 0
|
|
if ( i >= m_nNumModes )
|
|
{
|
|
if ( iOK != VIDEO_MODE_DEFAULT )
|
|
{
|
|
i = iOK;
|
|
}
|
|
else
|
|
{
|
|
i = 0;
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Choose the actual video mode based on the available modes
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::ResetCurrentModeForNewResolution( int nWidth, int nHeight, bool bWindowed )
|
|
{
|
|
// Fill in vid structure for the mode
|
|
int nGameMode = FindVideoMode( nWidth, nHeight, bWindowed );
|
|
vmode_t *pMode = GetMode( nGameMode );
|
|
|
|
// default to non-VR values
|
|
m_bWindowed = bWindowed;
|
|
m_nModeWidth = pMode->width;
|
|
m_nModeHeight = pMode->height;
|
|
m_nUIWidth = pMode->width;
|
|
m_nUIHeight = pMode->height;
|
|
m_nStereoWidth = pMode->width;
|
|
m_nStereoHeight = pMode->height;
|
|
|
|
// assume we won't be overriding the position
|
|
m_bVROverride = false;
|
|
|
|
if ( UseVR() || ShouldForceVRActive() )
|
|
{
|
|
g_pSourceVR->GetViewportBounds( ISourceVirtualReality::VREye_Left, NULL, NULL, &m_nStereoWidth, &m_nStereoHeight );
|
|
VRRect_t vrBounds;
|
|
if( g_pSourceVR->GetDisplayBounds( &vrBounds ) )
|
|
{
|
|
ConVarRef vr_force_windowed( "vr_force_windowed" );
|
|
|
|
RequestedWindowVideoMode().width = m_nModeWidth = vrBounds.nWidth;
|
|
RequestedWindowVideoMode().height = m_nModeHeight = vrBounds.nHeight;
|
|
m_bVROverride = true;
|
|
m_bWindowed = vr_force_windowed.GetBool();
|
|
|
|
|
|
// This is the smallest size the the UI in source games can handle.
|
|
m_nUIWidth = 640;
|
|
m_nUIHeight = 480;
|
|
|
|
#if defined( WIN32 ) && !defined( USE_SDL )
|
|
m_nVROverrideX = vrBounds.nX;
|
|
m_nVROverrideY = vrBounds.nY;
|
|
#elif defined( USE_SDL )
|
|
for ( int i = 0; i < SDL_GetNumVideoDisplays(); i++ )
|
|
{
|
|
SDL_Rect sdlRect;
|
|
SDL_GetDisplayBounds( i, &sdlRect );
|
|
|
|
if( sdlRect.x == vrBounds.nX && sdlRect.y == vrBounds.nY
|
|
&& sdlRect.w == vrBounds.nWidth && sdlRect.h == vrBounds.nHeight )
|
|
{
|
|
static ConVarRef sdl_displayindex( "sdl_displayindex" );
|
|
sdl_displayindex.SetValue( i );
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
else if( materials->GetCurrentConfigForVideoCard().m_nVRModeAdapter == materials->GetCurrentAdapter() )
|
|
{
|
|
// if we aren't in VR mode but we do have a VR mode adapter set, we must not be full
|
|
// screen because that would show up on the HMD
|
|
m_bWindowed = true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates the game window, plays the startup movie
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_Common::CreateGameWindow( int nWidth, int nHeight, bool bWindowed )
|
|
{
|
|
COM_TimestampedLog( "CVideoMode_Common::Init CreateGameWindow" );
|
|
|
|
if ( ShouldForceVRActive() )
|
|
{
|
|
// First make sure we're running a compatible version of DirectX
|
|
ConVarRef mat_dxlevel( "mat_dxlevel" );
|
|
if ( mat_dxlevel.IsValid() )
|
|
{
|
|
if ( mat_dxlevel.GetInt() < 90 )
|
|
{
|
|
Msg( "VR mode does not work with DirectX8.\nPlease use at least \"-dxlevel 90\" or higher.\n" );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
VRRect_t bounds;
|
|
g_pSourceVR->GetDisplayBounds( &bounds );
|
|
|
|
nWidth = bounds.nWidth;
|
|
nHeight = bounds.nHeight;
|
|
|
|
m_nVROverrideX = bounds.nX;
|
|
m_nVROverrideY = bounds.nY;
|
|
}
|
|
|
|
// This allows you to have a window of any size.
|
|
// Requires you to set both width and height for the window and
|
|
// that you start in windowed mode
|
|
if ( bWindowed && nWidth && nHeight )
|
|
{
|
|
// FIXME: There's some ordering issues related to the config record
|
|
// and reading the command-line. Would be nice for just one place where this is done.
|
|
RequestedWindowVideoMode().width = nWidth;
|
|
RequestedWindowVideoMode().height = nHeight;
|
|
}
|
|
|
|
if ( !InEditMode() )
|
|
{
|
|
// Fill in vid structure for the mode.
|
|
// Note: ModeWidth/Height may *not* match requested nWidth/nHeight
|
|
ResetCurrentModeForNewResolution( nWidth, nHeight, bWindowed );
|
|
|
|
COM_TimestampedLog( "CreateGameWindow - Start" );
|
|
// When running in stand-alone mode, create your own window
|
|
if ( !game->CreateGameWindow() )
|
|
return false;
|
|
COM_TimestampedLog( "CreateGameWindow - Finish" );
|
|
|
|
// Re-size and re-center the window
|
|
AdjustWindow( GetModeWidth(), GetModeHeight(), GetModeBPP(), IsWindowedMode() );
|
|
|
|
COM_TimestampedLog( "SetMode - Start" );
|
|
// Set the mode and let the materialsystem take over
|
|
if ( !SetMode( GetModeWidth(), GetModeHeight(), IsWindowedMode() ) )
|
|
return false;
|
|
|
|
#if defined( USE_SDL ) && 0
|
|
static ConVarRef mat_viewportscale( "mat_viewportscale" );
|
|
|
|
if ( !bWindowed )
|
|
{
|
|
m_nRenderWidth = nWidth;
|
|
m_nRenderHeight = nHeight;
|
|
|
|
mat_viewportscale.SetValue( ( float )nWidth / ( float )GetModeWidth() );
|
|
}
|
|
#endif
|
|
|
|
COM_TimestampedLog( "SetMode - Finish" );
|
|
|
|
// Play our videos for the background after the render device has been initialized
|
|
DrawStartupVideo();
|
|
|
|
COM_TimestampedLog( "DrawStartupGraphic - Start" );
|
|
// Play our videos or display our temp image for the background
|
|
DrawStartupGraphic();
|
|
|
|
COM_TimestampedLog( "DrawStartupGraphic - Finish" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: loads a vtf, through the temporary buffer
|
|
//-----------------------------------------------------------------------------
|
|
IVTFTexture *CVideoMode_Common::LoadVTF( CUtlBuffer &temp, const char *szFileName )
|
|
{
|
|
if ( !g_pFileSystem->ReadFile( szFileName, NULL, temp ) )
|
|
return NULL;
|
|
|
|
IVTFTexture *texture = CreateVTFTexture();
|
|
if ( !texture->Unserialize( temp ) )
|
|
{
|
|
Error( "Invalid or corrupt background texture %s\n", szFileName );
|
|
return NULL;
|
|
}
|
|
texture->ConvertImageFormat( IMAGE_FORMAT_RGBA8888, false );
|
|
return texture;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the startup graphic name
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::ComputeStartupGraphicName( char *pBuf, int nBufLen )
|
|
{
|
|
char szBackgroundName[_MAX_PATH];
|
|
CL_GetBackgroundLevelName( szBackgroundName, sizeof(szBackgroundName), false );
|
|
|
|
float aspectRatio = (float)GetModeStereoWidth() / GetModeStereoHeight();
|
|
if ( aspectRatio >= 1.6f )
|
|
{
|
|
// use the widescreen version
|
|
Q_snprintf( pBuf, nBufLen, "materials/console/%s_widescreen.vtf", szBackgroundName );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( pBuf, nBufLen, "materials/console/%s.vtf", szBackgroundName );
|
|
}
|
|
|
|
if ( !g_pFileSystem->FileExists( pBuf, "GAME" ) )
|
|
{
|
|
Q_strncpy( pBuf, ( aspectRatio >= 1.6f ) ? "materials/console/background01_widescreen.vtf" : "materials/console/background01.vtf", nBufLen );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Writes a screenshot to Steam screenshot library given an RGB buffer
|
|
// and applies any tags that have been set for it
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::WriteScreenshotToSteam( uint8 *pImage, int cubImage, int width, int height )
|
|
{
|
|
#if !defined(NO_STEAM)
|
|
if ( cl_savescreenshotstosteam.GetBool() )
|
|
{
|
|
if ( Steam3Client().SteamScreenshots() )
|
|
{
|
|
ScreenshotHandle hScreenshot = Steam3Client().SteamScreenshots()->WriteScreenshot( pImage, cubImage, width, height );
|
|
ApplySteamScreenshotTags( hScreenshot );
|
|
}
|
|
}
|
|
cl_screenshotusertag.SetValue(0);
|
|
cl_screenshotlocation.SetValue("");
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a screenshot to the Steam screenshot library from disk
|
|
// and applies any tags that have been set for it
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::AddScreenshotToSteam( const char *pchFilename, int width, int height )
|
|
{
|
|
#if !defined(NO_STEAM)
|
|
if ( cl_savescreenshotstosteam.GetBool() )
|
|
{
|
|
if ( Steam3Client().SteamScreenshots() )
|
|
{
|
|
ScreenshotHandle hScreenshot = Steam3Client().SteamScreenshots()->AddScreenshotToLibrary( pchFilename, NULL, width, height );
|
|
ApplySteamScreenshotTags( hScreenshot );
|
|
}
|
|
}
|
|
cl_screenshotusertag.SetValue(0);
|
|
cl_screenshotlocation.SetValue("");
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Applies tags to a screenshot for the Steam screenshot library, which are
|
|
// passed in through convars
|
|
//-----------------------------------------------------------------------------
|
|
#if !defined(NO_STEAM)
|
|
void CVideoMode_Common::ApplySteamScreenshotTags( ScreenshotHandle hScreenshot )
|
|
{
|
|
if ( hScreenshot != INVALID_SCREENSHOT_HANDLE )
|
|
{
|
|
if ( cl_screenshotusertag.GetBool() )
|
|
{
|
|
if ( Steam3Client().SteamUtils() )
|
|
{
|
|
CSteamID steamID( cl_screenshotusertag.GetInt(), Steam3Client().SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual );
|
|
Steam3Client().SteamScreenshots()->TagUser( hScreenshot, steamID );
|
|
}
|
|
}
|
|
const char *pchLocation = cl_screenshotlocation.GetString();
|
|
if ( pchLocation && pchLocation[0] )
|
|
{
|
|
Steam3Client().SteamScreenshots()->SetLocation( hScreenshot, pchLocation );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void CVideoMode_Common::SetupStartupGraphic()
|
|
{
|
|
COM_TimestampedLog( "CVideoMode_Common::Init SetupStartupGraphic" );
|
|
|
|
char szBackgroundName[_MAX_PATH];
|
|
CL_GetBackgroundLevelName( szBackgroundName, sizeof(szBackgroundName), false );
|
|
|
|
// get the image to load
|
|
char material[_MAX_PATH];
|
|
CUtlBuffer buf;
|
|
|
|
float aspectRatio = (float)GetModeWidth() / GetModeHeight();
|
|
if ( aspectRatio >= 1.6f )
|
|
{
|
|
// use the widescreen version
|
|
Q_snprintf( material, sizeof(material),
|
|
"materials/console/%s_widescreen.vtf", szBackgroundName );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( material, sizeof(material),
|
|
"materials/console/%s.vtf", szBackgroundName );
|
|
}
|
|
|
|
// load in the background vtf
|
|
buf.Clear();
|
|
m_pBackgroundTexture = LoadVTF( buf, material );
|
|
if ( !m_pBackgroundTexture )
|
|
{
|
|
// fallback to opening just the default background
|
|
m_pBackgroundTexture = LoadVTF( buf, ( aspectRatio >= 1.6f ) ? "materials/console/background01_widescreen.vtf" : "materials/console/background01.vtf" );
|
|
if ( !m_pBackgroundTexture )
|
|
{
|
|
Error( "Can't find background image '%s'\n", material );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// loading.vtf
|
|
buf.Clear(); // added this Clear() because we saw cases where LoadVTF was not emptying the buf fully in the above section
|
|
const char* loading = "materials/console/startup_loading.vtf";
|
|
if ( IsSteamDeck() )
|
|
loading = "materials/gamepadui/game_logo.vtf";
|
|
m_pLoadingTexture = LoadVTF( buf, loading );
|
|
if ( !m_pLoadingTexture )
|
|
{
|
|
Error( "Can't find background image '%s'\n", loading );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders the startup video into the HWND
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::DrawStartupVideo()
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
CETWScope timer( "CVideoMode_Common::DrawStartupGraphic" );
|
|
|
|
// render an avi, if we have one
|
|
if ( !m_bPlayedStartupVideo && !InEditMode() && !ShouldForceVRActive() )
|
|
{
|
|
game->PlayStartupVideos();
|
|
m_bPlayedStartupVideo = true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders the startup graphic into the HWND
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::DrawStartupGraphic()
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
char debugstartup = CommandLine()->FindParm("-debugstartupscreen");
|
|
|
|
SetupStartupGraphic();
|
|
|
|
if ( !m_pBackgroundTexture || !m_pLoadingTexture )
|
|
return;
|
|
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
|
|
char pStartupGraphicName[MAX_PATH];
|
|
ComputeStartupGraphicName( pStartupGraphicName, sizeof(pStartupGraphicName) );
|
|
|
|
if(debugstartup)
|
|
{
|
|
// slam the startup graphic name for sanity - take your pick
|
|
strcpy( pStartupGraphicName, "materials/console/background01.vtf");
|
|
//strcpy( pStartupGraphicName, "materials/console/testramp.vtf");
|
|
}
|
|
|
|
// Allocate a white material
|
|
KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" );
|
|
pVMTKeyValues->SetString( "$basetexture", pStartupGraphicName + 10 );
|
|
pVMTKeyValues->SetInt( "$ignorez", 1 );
|
|
pVMTKeyValues->SetInt( "$nofog", 1 );
|
|
pVMTKeyValues->SetInt( "$no_fullbright", 1 );
|
|
pVMTKeyValues->SetInt( "$nocull", 1 );
|
|
IMaterial *pMaterial = g_pMaterialSystem->CreateMaterial( "__background", pVMTKeyValues );
|
|
|
|
const char* loading = "console/startup_loading.vtf";
|
|
if ( IsSteamDeck() )
|
|
loading = "gamepadui/game_logo.vtf";
|
|
|
|
pVMTKeyValues = new KeyValues( "UnlitGeneric" );
|
|
pVMTKeyValues->SetString( "$basetexture", loading );
|
|
pVMTKeyValues->SetInt( "$translucent", 1 );
|
|
pVMTKeyValues->SetInt( "$ignorez", 1 );
|
|
pVMTKeyValues->SetInt( "$nofog", 1 );
|
|
pVMTKeyValues->SetInt( "$no_fullbright", 1 );
|
|
pVMTKeyValues->SetInt( "$nocull", 1 );
|
|
IMaterial *pLoadingMaterial = g_pMaterialSystem->CreateMaterial( "__loading", pVMTKeyValues );
|
|
|
|
int w = GetModeStereoWidth();
|
|
int h = GetModeStereoHeight();
|
|
int tw = m_pBackgroundTexture->Width();
|
|
int th = m_pBackgroundTexture->Height();
|
|
int lw = m_pLoadingTexture->Width();
|
|
int lh = m_pLoadingTexture->Height();
|
|
|
|
if (debugstartup)
|
|
{
|
|
for ( int repeat = 0; repeat<100000; repeat++)
|
|
{
|
|
pRenderContext->Viewport( 0, 0, w, h );
|
|
pRenderContext->DepthRange( 0, 1 );
|
|
pRenderContext->ClearColor3ub( 0, (repeat & 0x7) << 3, 0 );
|
|
pRenderContext->ClearBuffers( true, true, true );
|
|
pRenderContext->SetToneMappingScaleLinear( Vector(1,1,1) );
|
|
|
|
if(1) // draw normal BK
|
|
{
|
|
float depth = 0.55f;
|
|
int slide = (repeat) % 200; // 100 down and 100 up
|
|
if (slide > 100)
|
|
{
|
|
slide = 200-slide; // aka 100-(slide-100).
|
|
}
|
|
|
|
// stop sliding about
|
|
slide = 0;
|
|
|
|
DrawScreenSpaceRectangle( pMaterial, 0, 0+slide, w, h-50, 0, 0, tw-1, th-1, tw, th, NULL,1,1,depth );
|
|
if ( !IsSteamDeck() )
|
|
DrawScreenSpaceRectangle( pLoadingMaterial, w-lw, h-lh+slide/2, lw, lh, 0, 0, lw-1, lh-1, lw, lh, NULL,1,1,depth-0.1 );
|
|
else
|
|
// TODO: Steam Deck
|
|
DrawScreenSpaceRectangle( pLoadingMaterial, w-lw, h-lh+slide/2, lw, lh, 0, 0, lw-1, lh-1, lw, lh, NULL,1,1,depth-0.1 );
|
|
}
|
|
|
|
if(0)
|
|
{
|
|
// draw a grid too
|
|
int grid_size = 8;
|
|
float depthacc = 0.0;
|
|
float depthinc = 1.0 / (float)((grid_size * grid_size)+1);
|
|
|
|
for( int x = 0; x<grid_size; x++)
|
|
{
|
|
float cornerx = ((float)x) * 20.0f;
|
|
|
|
for( int y=0; y<grid_size; y++)
|
|
{
|
|
float cornery = ((float)y) * 20.0f;
|
|
|
|
//if (! ((x^y) & 1) )
|
|
{
|
|
DrawScreenSpaceRectangle( pMaterial, 10.0f+cornerx,10.0f+ cornery, 15, 15, 0, 0, tw-1, th-1, tw, th, NULL,1,1, depthacc );
|
|
}
|
|
|
|
depthacc += depthinc;
|
|
}
|
|
}
|
|
}
|
|
|
|
g_pMaterialSystem->SwapBuffers();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pRenderContext->Viewport( 0, 0, w, h );
|
|
pRenderContext->DepthRange( 0, 1 );
|
|
pRenderContext->SetToneMappingScaleLinear( Vector(1,1,1) );
|
|
|
|
float depth = 0.5f;
|
|
|
|
// Make sure we clear both front & back buffer.
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
pRenderContext->ClearColor3ub( 0, 0, 0 );
|
|
pRenderContext->ClearBuffers( true, true, true );
|
|
DrawScreenSpaceRectangle( pMaterial, 0, 0, w, h, 0, 0, tw-1, th-1, tw, th, NULL,1,1,depth );
|
|
DrawScreenSpaceRectangle( pLoadingMaterial, w-lw, h-lh, lw, lh, 0, 0, lw-1, lh-1, lw, lh, NULL,1,1,depth );
|
|
g_pMaterialSystem->SwapBuffers();
|
|
}
|
|
}
|
|
|
|
#ifdef DX_TO_GL_ABSTRACTION
|
|
g_pMaterialSystem->DoStartupShaderPreloading();
|
|
#endif
|
|
|
|
pMaterial->Release();
|
|
pLoadingMaterial->Release();
|
|
|
|
// release graphics
|
|
DestroyVTFTexture( m_pBackgroundTexture );
|
|
m_pBackgroundTexture = NULL;
|
|
DestroyVTFTexture( m_pLoadingTexture );
|
|
m_pLoadingTexture = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Blits an image to the loading window hdc
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::BlitGraphicToHDCWithAlpha(HDC hdc, byte *rgba, int imageWidth, int imageHeight, int x0, int y0, int x1, int y1)
|
|
{
|
|
#ifdef WIN32
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
int x = x0;
|
|
int y = y0;
|
|
int wide = x1 - x0;
|
|
int tall = y1 - y0;
|
|
|
|
Assert(imageWidth == wide && imageHeight == tall);
|
|
|
|
int texwby4 = imageWidth << 2;
|
|
|
|
for ( int v = 0; v < tall; v++ )
|
|
{
|
|
int *src = (int *)(rgba + (v * texwby4));
|
|
int xaccum = 0;
|
|
|
|
for ( int u = 0; u < wide; u++ )
|
|
{
|
|
byte *xsrc = (byte *)(src + xaccum);
|
|
if (xsrc[3])
|
|
{
|
|
::SetPixel(hdc, x + u, y + v, RGB(xsrc[0], xsrc[1], xsrc[2]));
|
|
}
|
|
xaccum += 1;
|
|
}
|
|
}
|
|
#else
|
|
Assert( !"Impl me" );
|
|
#endif
|
|
}
|
|
|
|
void CVideoMode_Common::InvalidateWindow()
|
|
{
|
|
if ( CommandLine()->FindParm( "-noshaderapi" ) )
|
|
{
|
|
#if defined( USE_SDL )
|
|
SDL_Event fake;
|
|
memset(&fake, '\0', sizeof (SDL_Event));
|
|
fake.type = SDL_WINDOWEVENT;
|
|
fake.window.windowID = SDL_GetWindowID( (SDL_Window *) g_pLauncherMgr->GetWindowRef() );
|
|
fake.window.event = SDL_WINDOWEVENT_EXPOSED;
|
|
SDL_PushEvent(&fake);
|
|
#else
|
|
InvalidateRect( (HWND)game->GetMainWindow(), NULL, FALSE );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CVideoMode_Common::DrawNullBackground( void *hHDC, int w, int h )
|
|
{
|
|
#ifdef WIN32
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
HDC hdc = (HDC)hHDC;
|
|
|
|
// Show a message if running without renderer..
|
|
if ( CommandLine()->FindParm( "-noshaderapi" ) )
|
|
{
|
|
HFONT fnt = CreateFontA( -18,
|
|
0,
|
|
0,
|
|
0,
|
|
FW_NORMAL,
|
|
FALSE,
|
|
FALSE,
|
|
FALSE,
|
|
ANSI_CHARSET,
|
|
OUT_TT_PRECIS,
|
|
CLIP_DEFAULT_PRECIS,
|
|
ANTIALIASED_QUALITY,
|
|
DEFAULT_PITCH,
|
|
"Arial" );
|
|
|
|
HFONT oldFont = (HFONT)SelectObject( hdc, fnt );
|
|
int oldBkMode = SetBkMode( hdc, TRANSPARENT );
|
|
COLORREF oldFgColor = SetTextColor( hdc, RGB( 255, 255, 255 ) );
|
|
|
|
HBRUSH br = CreateSolidBrush( RGB( 0, 0, 0 ) );
|
|
HBRUSH oldBr = (HBRUSH)SelectObject( hdc, br );
|
|
Rectangle( hdc, 0, 0, w, h );
|
|
|
|
RECT rc;
|
|
rc.left = 0;
|
|
rc.top = 0;
|
|
rc.right = w;
|
|
rc.bottom = h;
|
|
|
|
DrawText( hdc, "Running with -noshaderapi", -1, &rc, DT_NOPREFIX | DT_VCENTER | DT_CENTER | DT_SINGLELINE );
|
|
|
|
rc.top = rc.bottom - 30;
|
|
|
|
if ( host_state.worldmodel != NULL )
|
|
{
|
|
rc.left += 10;
|
|
DrawText( hdc, modelloader->GetName( host_state.worldmodel ), -1, &rc, DT_NOPREFIX | DT_VCENTER | DT_SINGLELINE );
|
|
}
|
|
|
|
SetTextColor( hdc, oldFgColor );
|
|
|
|
SelectObject( hdc, oldBr );
|
|
SetBkMode( hdc, oldBkMode );
|
|
SelectObject( hdc, oldFont );
|
|
|
|
DeleteObject( br );
|
|
DeleteObject( fnt );
|
|
}
|
|
#else
|
|
Assert( !"Impl me" );
|
|
#endif
|
|
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
|
|
typedef unsigned char BYTE;
|
|
typedef signed long LONG;
|
|
typedef unsigned long ULONG;
|
|
|
|
typedef char * LPSTR;
|
|
|
|
typedef struct tagBITMAPINFOHEADER{
|
|
DWORD biSize;
|
|
LONG biWidth;
|
|
LONG biHeight;
|
|
WORD biPlanes;
|
|
WORD biBitCount;
|
|
DWORD biCompression;
|
|
DWORD biSizeImage;
|
|
LONG biXPelsPerMeter;
|
|
LONG biYPelsPerMeter;
|
|
DWORD biClrUsed;
|
|
DWORD biClrImportant;
|
|
} BITMAPINFOHEADER;
|
|
|
|
typedef struct tagBITMAPFILEHEADER {
|
|
WORD bfType;
|
|
DWORD bfSize;
|
|
WORD bfReserved1;
|
|
WORD bfReserved2;
|
|
DWORD bfOffBits;
|
|
} BITMAPFILEHEADER;
|
|
|
|
typedef struct tagRGBQUAD {
|
|
BYTE rgbBlue;
|
|
BYTE rgbGreen;
|
|
BYTE rgbRed;
|
|
BYTE rgbReserved;
|
|
} RGBQUAD;
|
|
|
|
/* constants for the biCompression field */
|
|
#define BI_RGB 0L
|
|
#define BI_RLE8 1L
|
|
#define BI_RLE4 2L
|
|
#define BI_BITFIELDS 3L
|
|
|
|
#if 0
|
|
typedef struct _GUID
|
|
{
|
|
unsigned long Data1;
|
|
unsigned short Data2;
|
|
unsigned short Data3;
|
|
unsigned char Data4[8];
|
|
} GUID;
|
|
|
|
#endif
|
|
typedef GUID UUID;
|
|
|
|
#endif //WIN32
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Blits an image to the loading window hdc
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::BlitGraphicToHDC(HDC hdc, byte *rgba, int imageWidth, int imageHeight, int x0, int y0, int x1, int y1)
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
#ifdef WIN32
|
|
int x = x0;
|
|
int y = y0;
|
|
int wide = x1 - x0;
|
|
int tall = y1 - y0;
|
|
|
|
// Needs to be a multiple of 4
|
|
int dibwide = ( wide + 3 ) & ~3;
|
|
|
|
Assert(rgba);
|
|
int texwby4 = imageWidth << 2;
|
|
|
|
double st = Plat_FloatTime();
|
|
|
|
void *destBits = NULL;
|
|
|
|
HBITMAP bm;
|
|
BITMAPINFO bmi;
|
|
Q_memset( &bmi, 0, sizeof( bmi ) );
|
|
|
|
BITMAPINFOHEADER *hdr = &bmi.bmiHeader;
|
|
|
|
hdr->biSize = sizeof( *hdr );
|
|
hdr->biWidth = dibwide;
|
|
hdr->biHeight = -tall; // top down bitmap
|
|
hdr->biBitCount = 24;
|
|
hdr->biPlanes = 1;
|
|
hdr->biCompression = BI_RGB;
|
|
hdr->biSizeImage = dibwide * tall * 3;
|
|
hdr->biXPelsPerMeter = 3780;
|
|
hdr->biYPelsPerMeter = 3780;
|
|
|
|
// Create a "source" DC
|
|
HDC tempDC = CreateCompatibleDC( hdc );
|
|
|
|
// Create the dibsection bitmap
|
|
bm = CreateDIBSection
|
|
(
|
|
tempDC, // handle to DC
|
|
&bmi, // bitmap data
|
|
DIB_RGB_COLORS, // data type indicator
|
|
&destBits, // bit values
|
|
NULL, // handle to file mapping object
|
|
0 // offset to bitmap bit values
|
|
);
|
|
|
|
// Select it into the source DC
|
|
HBITMAP oldBitmap = (HBITMAP)SelectObject( tempDC, bm );
|
|
|
|
// Setup for bilinaer filtering. If we don't do this filter here, there will be a big
|
|
// annoying pop when it switches to the vguimatsurface version of the background.
|
|
// We leave room for 14 bits of integer precision, so the image can be up to 16k x 16k.
|
|
const int BILINEAR_FIX_SHIFT = 17;
|
|
const int BILINEAR_FIX_MUL = (1 << BILINEAR_FIX_SHIFT);
|
|
|
|
#define FIXED_BLEND( a, b, out, frac ) \
|
|
out[0] = (a[0]*frac + b[0]*(BILINEAR_FIX_MUL-frac)) >> BILINEAR_FIX_SHIFT; \
|
|
out[1] = (a[1]*frac + b[1]*(BILINEAR_FIX_MUL-frac)) >> BILINEAR_FIX_SHIFT; \
|
|
out[2] = (a[2]*frac + b[2]*(BILINEAR_FIX_MUL-frac)) >> BILINEAR_FIX_SHIFT;
|
|
|
|
float eps = 0.001f;
|
|
float uMax = imageWidth - 1 - eps;
|
|
float vMax = imageHeight - 1 - eps;
|
|
|
|
int fixedBilinearV = 0;
|
|
int bilinearUInc = (int)( (uMax / (dibwide-1)) * BILINEAR_FIX_MUL );
|
|
int bilinearVInc = (int)( (vMax / (tall-1)) * BILINEAR_FIX_MUL );
|
|
|
|
for ( int v = 0; v < tall; v++ )
|
|
{
|
|
int iBilinearV = fixedBilinearV >> BILINEAR_FIX_SHIFT;
|
|
int fixedFractionV = fixedBilinearV & (BILINEAR_FIX_MUL-1);
|
|
fixedBilinearV += bilinearVInc;
|
|
|
|
int fixedBilinearU = 0;
|
|
byte *dest = (byte *)destBits + ( ( y + v ) * dibwide + x ) * 3;
|
|
|
|
for ( int u = 0; u < dibwide; u++, dest+=3 )
|
|
{
|
|
int iBilinearU = fixedBilinearU >> BILINEAR_FIX_SHIFT;
|
|
int fixedFractionU = fixedBilinearU & (BILINEAR_FIX_MUL-1);
|
|
fixedBilinearU += bilinearUInc;
|
|
|
|
Assert( iBilinearU >= 0 && iBilinearU+1 < imageWidth );
|
|
Assert( iBilinearV >= 0 && iBilinearV+1 < imageHeight );
|
|
|
|
byte *srcTopLine = rgba + iBilinearV * texwby4;
|
|
byte *srcBottomLine = rgba + (iBilinearV+1) * texwby4;
|
|
|
|
byte *xsrc[4] = {
|
|
srcTopLine + (iBilinearU+0)*4, srcTopLine + (iBilinearU+1)*4,
|
|
srcBottomLine + (iBilinearU+0)*4, srcBottomLine + (iBilinearU+1)*4 };
|
|
|
|
int topColor[3], bottomColor[3], finalColor[3];
|
|
FIXED_BLEND( xsrc[1], xsrc[0], topColor, fixedFractionU );
|
|
FIXED_BLEND( xsrc[3], xsrc[2], bottomColor, fixedFractionU );
|
|
FIXED_BLEND( bottomColor, topColor, finalColor, fixedFractionV );
|
|
|
|
// Windows wants the colors in reverse order.
|
|
dest[0] = finalColor[2];
|
|
dest[1] = finalColor[1];
|
|
dest[2] = finalColor[0];
|
|
}
|
|
}
|
|
|
|
// Now do the Blt
|
|
BitBlt( hdc, 0, 0, dibwide, tall, tempDC, 0, 0, SRCCOPY );
|
|
|
|
// This only draws if running -noshaderapi
|
|
DrawNullBackground( hdc, dibwide, tall );
|
|
|
|
// Restore the old Bitmap
|
|
SelectObject( tempDC, oldBitmap );
|
|
|
|
// Destroy the temporary DC
|
|
DeleteDC( tempDC );
|
|
|
|
// Destroy the DIBSection bitmap
|
|
DeleteObject( bm );
|
|
|
|
double elapsed = Plat_FloatTime() - st;
|
|
|
|
COM_TimestampedLog( "BlitGraphicToHDC: new ver took %.4f", elapsed );
|
|
#else
|
|
Assert( !"Impl me" );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This is called in response to a WM_MOVE message
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::UpdateWindowPosition( void )
|
|
{
|
|
int x, y, w, h;
|
|
|
|
// Get the window from the game ( right place for it? )
|
|
game->GetWindowRect( &x, &y, &w, &h );
|
|
|
|
#ifdef WIN32
|
|
RECT window_rect;
|
|
window_rect.left = x;
|
|
window_rect.right = x + w;
|
|
window_rect.top = y;
|
|
window_rect.bottom = y + h;
|
|
#endif
|
|
// NOTE: We need to feed this back into the video mode stuff
|
|
// esp. in Resizing window mode.
|
|
}
|
|
|
|
void CVideoMode_Common::ChangeDisplaySettingsToFullscreen( int nWidth, int nHeight, int nBPP )
|
|
{
|
|
}
|
|
|
|
void CVideoMode_Common::ReleaseFullScreen( void )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns the optimal refresh rate for the specified mode
|
|
//-----------------------------------------------------------------------------
|
|
int CVideoMode_Common::GetRefreshRateForMode( const vmode_t *pMode )
|
|
{
|
|
int nRefreshRate = pMode->refreshRate;
|
|
|
|
// FIXME: We should only read this once, at the beginning
|
|
// override the refresh rate from the command-line maybe
|
|
nRefreshRate = CommandLine()->ParmValue( "-freq", nRefreshRate );
|
|
nRefreshRate = CommandLine()->ParmValue( "-refresh", nRefreshRate );
|
|
nRefreshRate = CommandLine()->ParmValue( "-refreshrate", nRefreshRate );
|
|
|
|
return nRefreshRate;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *mode -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::AdjustWindow( int nWidth, int nHeight, int nBPP, bool bWindowed )
|
|
{
|
|
if ( g_bTextMode )
|
|
return;
|
|
|
|
// Use Change Display Settings to go full screen
|
|
ChangeDisplaySettingsToFullscreen( nWidth, nHeight, nBPP );
|
|
|
|
RECT WindowRect;
|
|
WindowRect.top = 0;
|
|
WindowRect.left = 0;
|
|
WindowRect.right = nWidth;
|
|
WindowRect.bottom = nHeight;
|
|
|
|
#ifndef USE_SDL
|
|
#ifndef _X360
|
|
// Get window style
|
|
DWORD style = GetWindowLong( (HWND)game->GetMainWindow(), GWL_STYLE );
|
|
DWORD exStyle = GetWindowLong( (HWND)game->GetMainWindow(), GWL_EXSTYLE );
|
|
|
|
if ( bWindowed )
|
|
{
|
|
// Give it a frame (pretty much WS_OVERLAPPEDWINDOW except for we do not modify the
|
|
// flags corresponding to resizing-frame and maximize-box)
|
|
if( !CommandLine()->FindParm( "-noborder" ) && !m_bVROverride )
|
|
{
|
|
style |= WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
|
|
}
|
|
else
|
|
{
|
|
style &= ~WS_OVERLAPPEDWINDOW;
|
|
}
|
|
|
|
// remove topmost flag
|
|
exStyle &= ~WS_EX_TOPMOST;
|
|
SetWindowLong( (HWND)game->GetMainWindow(), GWL_EXSTYLE, exStyle );
|
|
}
|
|
else
|
|
{
|
|
// Remove window border going into fullscreen mode to avoid Vista sizing issues when DWM is enabled
|
|
style &= ~WS_OVERLAPPEDWINDOW;
|
|
}
|
|
|
|
SetWindowLong( (HWND)game->GetMainWindow(), GWL_STYLE, style );
|
|
|
|
// Compute rect needed for that size client area based on window style
|
|
AdjustWindowRectEx( &WindowRect, style, FALSE, exStyle );
|
|
#endif
|
|
|
|
// Prepare to set window pos, which is required when toggling between topmost and not window flags
|
|
HWND hWndAfter = NULL;
|
|
DWORD dwSwpFlags = 0;
|
|
#ifndef _X360
|
|
{
|
|
if ( bWindowed )
|
|
{
|
|
hWndAfter = HWND_NOTOPMOST;
|
|
}
|
|
else
|
|
{
|
|
hWndAfter = HWND_TOPMOST;
|
|
}
|
|
dwSwpFlags = SWP_FRAMECHANGED;
|
|
}
|
|
#else
|
|
{
|
|
dwSwpFlags = SWP_NOZORDER;
|
|
}
|
|
#endif
|
|
|
|
// Move the window to 0, 0 and the new true size
|
|
SetWindowPos( (HWND)game->GetMainWindow(),
|
|
hWndAfter,
|
|
0, 0, WindowRect.right - WindowRect.left,
|
|
WindowRect.bottom - WindowRect.top,
|
|
SWP_NOREDRAW | dwSwpFlags );
|
|
#endif // !USE_SDL
|
|
|
|
// Now center
|
|
CenterEngineWindow( game->GetMainWindow(),
|
|
WindowRect.right - WindowRect.left,
|
|
WindowRect.bottom - WindowRect.top );
|
|
#if defined( USE_SDL )
|
|
g_pLauncherMgr->SetWindowFullScreen( !bWindowed, WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top );
|
|
|
|
CenterEngineWindow( game->GetMainWindow(),
|
|
WindowRect.right - WindowRect.left,
|
|
WindowRect.bottom - WindowRect.top );
|
|
|
|
g_pLauncherMgr->SizeWindow( WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top );
|
|
|
|
if( bWindowed )
|
|
{
|
|
SDL_Window* win = (SDL_Window*)g_pLauncherMgr->GetWindowRef();
|
|
if ( m_bVROverride || CommandLine()->FindParm( "-noborder" ) )
|
|
SDL_SetWindowBordered( win, SDL_FALSE );
|
|
else
|
|
SDL_SetWindowBordered( win, SDL_TRUE );
|
|
|
|
}
|
|
#endif
|
|
|
|
game->SetWindowSize( nWidth, nHeight );
|
|
|
|
// Make sure we have updated window information
|
|
UpdateWindowPosition();
|
|
MarkClientViewRectDirty();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::Shutdown( void )
|
|
{
|
|
ReleaseFullScreen();
|
|
game->DestroyGameWindow();
|
|
|
|
if ( !GetInitialized() )
|
|
return;
|
|
|
|
SetInitialized( false );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets/sets the client view rectangle
|
|
//-----------------------------------------------------------------------------
|
|
const vrect_t &CVideoMode_Common::GetClientViewRect( ) const
|
|
{
|
|
const_cast<CVideoMode_Common*>(this)->RecomputeClientViewRect();
|
|
return m_ClientViewRect;
|
|
}
|
|
|
|
void CVideoMode_Common::SetClientViewRect( const vrect_t &viewRect )
|
|
{
|
|
m_ClientViewRect = viewRect;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the client view rect dirty
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::MarkClientViewRectDirty()
|
|
{
|
|
m_bClientViewRectDirty = true;
|
|
}
|
|
|
|
void CVideoMode_Common::RecomputeClientViewRect()
|
|
{
|
|
if ( !InEditMode() )
|
|
{
|
|
if ( !m_bClientViewRectDirty )
|
|
return;
|
|
}
|
|
|
|
m_bClientViewRectDirty = false;
|
|
|
|
int nWidth, nHeight;
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
pRenderContext->GetRenderTargetDimensions( nWidth, nHeight );
|
|
m_ClientViewRect.width = nWidth;
|
|
m_ClientViewRect.height = nHeight;
|
|
m_ClientViewRect.x = 0;
|
|
m_ClientViewRect.y = 0;
|
|
|
|
if (!nWidth || !nHeight)
|
|
{
|
|
// didn't successfully get the screen size, try again next frame
|
|
// window is probably minimized
|
|
m_bClientViewRectDirty = true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : hWndCenter -
|
|
// width -
|
|
// height -
|
|
// Output : static void
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::CenterEngineWindow( void *hWndCenter, int width, int height)
|
|
{
|
|
int CenterX, CenterY;
|
|
|
|
#if defined(USE_SDL)
|
|
// Get the displayindex, and center our window on that display.
|
|
static ConVarRef sdl_displayindex( "sdl_displayindex" );
|
|
int displayindex = sdl_displayindex.IsValid() ? sdl_displayindex.GetInt() : 0;
|
|
|
|
SDL_DisplayMode mode;
|
|
SDL_GetCurrentDisplayMode( displayindex, &mode );
|
|
|
|
const int wide = mode.w;
|
|
const int tall = mode.h;
|
|
|
|
CenterX = (wide - width) / 2;
|
|
CenterY = (tall - height) / 2;
|
|
CenterX = (CenterX < 0) ? 0: CenterX;
|
|
CenterY = (CenterY < 0) ? 0: CenterY;
|
|
|
|
// tweak the x and w positions if the user species them on the command-line
|
|
CenterX = CommandLine()->ParmValue( "-x", CenterX );
|
|
CenterY = CommandLine()->ParmValue( "-y", CenterY );
|
|
|
|
// also check for the negated form (since it is hard to say "-x -1000")
|
|
int negx = CommandLine()->ParmValue( "-negx", 0 );
|
|
if (negx > 0)
|
|
{
|
|
CenterX = -negx;
|
|
}
|
|
int negy = CommandLine()->ParmValue( "-negy", 0 );
|
|
if (negy > 0)
|
|
{
|
|
CenterY = -negy;
|
|
}
|
|
|
|
SDL_Rect rect = { 0, 0, 0, 0 };
|
|
SDL_GetDisplayBounds( displayindex, &rect );
|
|
|
|
CenterX += rect.x;
|
|
CenterY += rect.y;
|
|
|
|
game->SetWindowXY( CenterX, CenterY );
|
|
g_pLauncherMgr->MoveWindow( CenterX, CenterY );
|
|
#else
|
|
if ( IsPC() )
|
|
{
|
|
// In windowed mode go through game->GetDesktopInfo because system metrics change
|
|
// when going fullscreen vs windowed.
|
|
// Use system metrics for fullscreen or when game didn't have a chance to initialize.
|
|
|
|
int cxScreen = 0, cyScreen = 0, refreshRate = 0;
|
|
|
|
if ( !( WS_EX_TOPMOST & ::GetWindowLong( (HWND)hWndCenter, GWL_EXSTYLE ) ) && m_bWindowed )
|
|
{
|
|
game->GetDesktopInfo( cxScreen, cyScreen, refreshRate );
|
|
}
|
|
|
|
if ( !cxScreen || !cyScreen )
|
|
{
|
|
cxScreen = GetSystemMetrics(SM_CXSCREEN);
|
|
cyScreen = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
|
|
// Compute top-left corner offset
|
|
CenterX = (cxScreen - width) / 2;
|
|
CenterY = (cyScreen - height) / 2;
|
|
CenterX = (CenterX < 0) ? 0: CenterX;
|
|
CenterY = (CenterY < 0) ? 0: CenterY;
|
|
}
|
|
else
|
|
{
|
|
CenterX = 0;
|
|
CenterY = 0;
|
|
}
|
|
|
|
if( m_bVROverride )
|
|
{
|
|
CenterX = m_nVROverrideX;
|
|
CenterY = m_nVROverrideY;
|
|
}
|
|
|
|
// tweak the x and w positions if the user species them on the command-line
|
|
CenterX = CommandLine()->ParmValue( "-x", CenterX );
|
|
CenterY = CommandLine()->ParmValue( "-y", CenterY );
|
|
|
|
game->SetWindowXY( CenterX, CenterY );
|
|
|
|
SetWindowPos ( (HWND)hWndCenter, NULL, CenterX, CenterY, 0, 0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW | SWP_DRAWFRAME);
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Handle alt-tab
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::RestoreVideo( void )
|
|
{
|
|
}
|
|
|
|
void CVideoMode_Common::ReleaseVideo( void )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Read screen pixels
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::ReadScreenPixels( int x, int y, int w, int h, void *pBuffer, ImageFormat format )
|
|
{
|
|
int nBytes = ImageLoader::GetMemRequired( w, h, 1, format, false );
|
|
memset( pBuffer, 0, nBytes );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Write vid.buffer out as a .tga file
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::TakeSnapshotTGA( const char *pFilename )
|
|
{
|
|
// bitmap bits
|
|
uint8 *pImage = new uint8[ GetModeStereoWidth() * 3 * GetModeStereoHeight() ];
|
|
|
|
// Get Bits from the material system
|
|
ReadScreenPixels( 0, 0, GetModeStereoWidth(), GetModeStereoHeight(), pImage, IMAGE_FORMAT_RGB888 );
|
|
|
|
CUtlBuffer outBuf;
|
|
if ( TGAWriter::WriteToBuffer( pImage, outBuf, GetModeStereoWidth(), GetModeStereoHeight(), IMAGE_FORMAT_RGB888,
|
|
IMAGE_FORMAT_RGB888 ) )
|
|
{
|
|
if ( !g_pFileSystem->WriteFile( pFilename, NULL, outBuf ) )
|
|
{
|
|
Warning( "Couldn't write bitmap data snapshot to file %s.\n", pFilename );
|
|
}
|
|
else
|
|
{
|
|
char szPath[MAX_PATH];
|
|
szPath[0] = 0;
|
|
if ( g_pFileSystem->GetLocalPath( pFilename, szPath, sizeof(szPath) ) )
|
|
{
|
|
AddScreenshotToSteam( szPath, GetModeStereoWidth(), GetModeStereoHeight() );
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] pImage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// PFM screenshot helpers
|
|
//-----------------------------------------------------------------------------
|
|
ITexture *CVideoMode_Common::GetBuildCubemaps16BitTexture( void )
|
|
{
|
|
return materials->FindTexture( "_rt_BuildCubemaps16bit", TEXTURE_GROUP_RENDER_TARGET );
|
|
}
|
|
|
|
ITexture *CVideoMode_Common::GetFullFrameFB0( void )
|
|
{
|
|
return materials->FindTexture( "_rt_FullFrameFB", TEXTURE_GROUP_RENDER_TARGET );
|
|
}
|
|
|
|
void CVideoMode_Common::BlitHiLoScreenBuffersTo16Bit( void )
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
// FIXME: this breaks in 480p due to (at least) the multisampled depth buffer (need to cache, clear and restore the depth target)
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
IMaterial *pHDRCombineMaterial = materials->FindMaterial( "dev/hdrcombineto16bit", TEXTURE_GROUP_OTHER, true );
|
|
// if( IsErrorMaterial( pHDRCombineMaterial ) )
|
|
// {
|
|
// Assert( 0 );
|
|
// return;
|
|
// }
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
ITexture *pSaveRenderTarget;
|
|
pSaveRenderTarget = pRenderContext->GetRenderTarget();
|
|
|
|
int oldX, oldY, oldW, oldH;
|
|
pRenderContext->GetViewport( oldX, oldY, oldW, oldH );
|
|
|
|
pRenderContext->SetRenderTarget( GetBuildCubemaps16BitTexture() );
|
|
int width, height;
|
|
pRenderContext->GetRenderTargetDimensions( width, height );
|
|
pRenderContext->Viewport( 0, 0, width, height );
|
|
pRenderContext->DrawScreenSpaceQuad( pHDRCombineMaterial );
|
|
|
|
pRenderContext->SetRenderTarget( pSaveRenderTarget );
|
|
pRenderContext->Viewport( oldX, oldY, oldW, oldH );
|
|
}
|
|
|
|
void GetCubemapOffset( CubeMapFaceIndex_t faceIndex, int &x, int &y, int &faceDim )
|
|
{
|
|
int fbWidth, fbHeight;
|
|
materials->GetBackBufferDimensions( fbWidth, fbHeight );
|
|
|
|
if( fbWidth * 4 > fbHeight * 3 )
|
|
{
|
|
faceDim = fbHeight / 3;
|
|
}
|
|
else
|
|
{
|
|
faceDim = fbWidth / 4;
|
|
}
|
|
|
|
switch( faceIndex )
|
|
{
|
|
case CUBEMAP_FACE_RIGHT:
|
|
x = 2;
|
|
y = 1;
|
|
break;
|
|
case CUBEMAP_FACE_LEFT:
|
|
x = 0;
|
|
y = 1;
|
|
break;
|
|
case CUBEMAP_FACE_BACK:
|
|
x = 1;
|
|
y = 1;
|
|
break;
|
|
case CUBEMAP_FACE_FRONT:
|
|
x = 3;
|
|
y = 1;
|
|
break;
|
|
case CUBEMAP_FACE_UP:
|
|
x = 2;
|
|
y = 0;
|
|
break;
|
|
case CUBEMAP_FACE_DOWN:
|
|
x = 2;
|
|
y = 2;
|
|
break;
|
|
NO_DEFAULT
|
|
}
|
|
x *= faceDim;
|
|
y *= faceDim;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Takes a snapshot to PFM
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::TakeSnapshotPFMRect( const char *pFilename, int x, int y, int w, int h, int resampleWidth, int resampleHeight, CubeMapFaceIndex_t faceIndex )
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
// FIXME: this breaks in 480p due to (at least) the multisampled depth buffer (need to cache, clear and restore the depth target)
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
if ( g_pMaterialSystemHardwareConfig->GetHDRType() == HDR_TYPE_NONE )
|
|
{
|
|
Warning( "Unable to take PFM screenshots if HDR isn't enabled!\n" );
|
|
return;
|
|
}
|
|
|
|
// hack
|
|
// resampleWidth = w;
|
|
// resampleHeight = h;
|
|
// bitmap bits
|
|
float16 *pImage = ( float16 * )malloc( w * h * ImageLoader::SizeInBytes( IMAGE_FORMAT_RGBA16161616F ) );
|
|
float *pImage1 = ( float * )malloc( w * h * ImageLoader::SizeInBytes( IMAGE_FORMAT_RGB323232F ) );
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
// Save the current render target.
|
|
ITexture *pSaveRenderTarget = pRenderContext->GetRenderTarget();
|
|
|
|
// Set this as the render target so that we can read it.
|
|
pRenderContext->SetRenderTarget( GetFullFrameFB0() );
|
|
|
|
// Get Bits from the material system
|
|
ReadScreenPixels( x, y, w, h, pImage, IMAGE_FORMAT_RGBA16161616F );
|
|
|
|
// Draw what we just grabbed to the screen
|
|
pRenderContext->SetRenderTarget( NULL);
|
|
|
|
int scrw, scrh;
|
|
pRenderContext->GetRenderTargetDimensions( scrw, scrh );
|
|
pRenderContext->Viewport( 0, 0, scrw,scrh );
|
|
|
|
int offsetX, offsetY, faceDim;
|
|
GetCubemapOffset( faceIndex, offsetX, offsetY, faceDim );
|
|
pRenderContext->DrawScreenSpaceRectangle( materials->FindMaterial( "dev/copyfullframefb", "" ),
|
|
offsetX, offsetY, faceDim, faceDim, 0, 0, w-1, h-1, scrw, scrh );
|
|
|
|
// Restore the render target.
|
|
pRenderContext->SetRenderTarget( pSaveRenderTarget );
|
|
|
|
// convert from float16 to float32
|
|
ImageLoader::ConvertImageFormat( ( unsigned char * )pImage, IMAGE_FORMAT_RGBA16161616F,
|
|
( unsigned char * )pImage1, IMAGE_FORMAT_RGB323232F,
|
|
w, h );
|
|
|
|
Assert( w == h ); // garymcthack - this only works for square images
|
|
|
|
float *pFloatImage = ( float * )malloc( resampleWidth * resampleHeight * ImageLoader::SizeInBytes( IMAGE_FORMAT_RGB323232F ) );
|
|
|
|
ImageLoader::ResampleInfo_t info;
|
|
info.m_pSrc = ( unsigned char * )pImage1;
|
|
info.m_pDest = ( unsigned char * )pFloatImage;
|
|
info.m_nSrcWidth = w;
|
|
info.m_nSrcHeight = h;
|
|
info.m_nDestWidth = resampleWidth;
|
|
info.m_nDestHeight = resampleHeight;
|
|
info.m_flSrcGamma = 1.0f;
|
|
info.m_flDestGamma = 1.0f;
|
|
|
|
if( !ImageLoader::ResampleRGB323232F( info ) )
|
|
{
|
|
Sys_Error( "Can't resample\n" );
|
|
}
|
|
|
|
PFMWrite( pFloatImage, pFilename, resampleWidth, resampleHeight );
|
|
|
|
free( pImage1 );
|
|
free( pImage );
|
|
free( pFloatImage );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Takes a snapshot
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::TakeSnapshotTGARect( const char *pFilename, int x, int y, int w, int h, int resampleWidth, int resampleHeight, bool bPFM, CubeMapFaceIndex_t faceIndex )
|
|
{
|
|
if ( IsX360() )
|
|
{
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
if ( bPFM )
|
|
{
|
|
TakeSnapshotPFMRect( pFilename, x, y, w, h, resampleWidth, resampleHeight, faceIndex );
|
|
return;
|
|
}
|
|
|
|
// bitmap bits
|
|
uint8 *pImage = new uint8[ w * h * 4 ];
|
|
uint8 *pImage1 = new uint8[ resampleWidth * resampleHeight * 4 ];
|
|
|
|
// Get Bits from the material system
|
|
ReadScreenPixels( x, y, w, h, pImage, IMAGE_FORMAT_RGBA8888 );
|
|
|
|
Assert( w == h ); // garymcthack - this only works for square images
|
|
|
|
ImageLoader::ResampleInfo_t info;
|
|
info.m_pSrc = pImage;
|
|
info.m_pDest = pImage1;
|
|
info.m_nSrcWidth = w;
|
|
info.m_nSrcHeight = h;
|
|
info.m_nDestWidth = resampleWidth;
|
|
info.m_nDestHeight = resampleHeight;
|
|
info.m_flSrcGamma = 1.0f;
|
|
info.m_flDestGamma = 1.0f;
|
|
|
|
if( !ImageLoader::ResampleRGBA8888( info ) )
|
|
{
|
|
Sys_Error( "Can't resample\n" );
|
|
}
|
|
|
|
CUtlBuffer outBuf;
|
|
if ( TGAWriter::WriteToBuffer( pImage1, outBuf, resampleWidth, resampleHeight, IMAGE_FORMAT_RGBA8888, IMAGE_FORMAT_RGBA8888 ) )
|
|
{
|
|
if ( !g_pFileSystem->WriteFile( pFilename, NULL, outBuf ) )
|
|
{
|
|
Error( "Couldn't write bitmap data snapshot to file %s.\n", pFilename );
|
|
}
|
|
else
|
|
{
|
|
DevMsg( "Screenshot: %dx%d saved to '%s'.\n", w, h, pFilename );
|
|
}
|
|
}
|
|
|
|
delete[] pImage1;
|
|
delete[] pImage;
|
|
materials->SwapBuffers();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Writes the data in *data to the sequentially number .bmp file filename
|
|
// Input : *filename -
|
|
// width -
|
|
// height -
|
|
// depth -
|
|
// *data -
|
|
// Output : static void
|
|
//-----------------------------------------------------------------------------
|
|
static void VID_ProcessMovieFrame( const MovieInfo_t& info, bool jpeg, const char *filename, int width, int height, byte *data )
|
|
{
|
|
CUtlBuffer outBuf;
|
|
bool bSuccess = false;
|
|
if ( jpeg )
|
|
{
|
|
#if HAVE_JPEG
|
|
bSuccess = videomode->TakeSnapshotJPEGToBuffer( outBuf, info.jpeg_quality );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
bSuccess = TGAWriter::WriteToBuffer( data, outBuf, width, height, IMAGE_FORMAT_BGR888, IMAGE_FORMAT_RGB888 );
|
|
}
|
|
|
|
if ( bSuccess )
|
|
{
|
|
if ( !g_pFileSystem->WriteFile( filename, NULL, outBuf ) )
|
|
{
|
|
Warning( "Couldn't write movie snapshot to file %s.\n", filename );
|
|
Cbuf_AddText( "endmovie\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Store current frame to numbered .bmp file
|
|
// Input : *pFilename -
|
|
//-----------------------------------------------------------------------------
|
|
extern IVideoRecorder *g_pVideoRecorder;
|
|
|
|
void CVideoMode_Common::WriteMovieFrame( const MovieInfo_t& info )
|
|
{
|
|
char const *pMovieName = info.moviename;
|
|
int nMovieFrame = info.movieframe;
|
|
|
|
if ( g_LostVideoMemory )
|
|
return;
|
|
|
|
if ( !pMovieName[0] )
|
|
{
|
|
Cbuf_AddText( "endmovie\n" );
|
|
ConMsg( "Tried to write movie buffer with no filename set!\n" );
|
|
return;
|
|
}
|
|
|
|
int imagesize = GetModeStereoWidth() * GetModeStereoHeight();
|
|
BGR888_t *hp = new BGR888_t[ imagesize ];
|
|
if ( hp == NULL )
|
|
{
|
|
Sys_Error( "Couldn't allocate bitmap header to snapshot.\n" );
|
|
}
|
|
|
|
// Get Bits from material system
|
|
ReadScreenPixels( 0, 0, GetModeStereoWidth(), GetModeStereoHeight(), hp, IMAGE_FORMAT_BGR888 );
|
|
|
|
// Store frame to disk
|
|
if ( info.DoTga() )
|
|
{
|
|
VID_ProcessMovieFrame( info, false, va( "%s%04d.tga", pMovieName, nMovieFrame ),
|
|
GetModeStereoWidth(), GetModeStereoHeight(), (unsigned char*)hp );
|
|
}
|
|
|
|
if ( info.DoJpg() )
|
|
{
|
|
VID_ProcessMovieFrame( info, true, va( "%s%04d.jpg", pMovieName, nMovieFrame ),
|
|
GetModeStereoWidth(), GetModeStereoHeight(), (unsigned char*)hp );
|
|
}
|
|
|
|
if ( info.DoVideo() )
|
|
{
|
|
g_pVideoRecorder->AppendVideoFrame( hp );
|
|
}
|
|
|
|
delete[] hp;
|
|
}
|
|
|
|
#if HAVE_JPEG
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Expanded data destination object for CUtlBuffer output
|
|
//-----------------------------------------------------------------------------
|
|
struct JPEGDestinationManager_t
|
|
{
|
|
struct jpeg_destination_mgr pub; // public fields
|
|
|
|
CUtlBuffer *pBuffer; // target/final buffer
|
|
byte *buffer; // start of temp buffer
|
|
};
|
|
|
|
// choose an efficiently bufferaable size
|
|
#define OUTPUT_BUF_SIZE 4096
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initialize destination --- called by jpeg_start_compress
|
|
// before any data is actually written.
|
|
//-----------------------------------------------------------------------------
|
|
METHODDEF(void) init_destination (j_compress_ptr cinfo)
|
|
{
|
|
JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t *) cinfo->dest;
|
|
|
|
// Allocate the output buffer --- it will be released when done with image
|
|
dest->buffer = (byte *)
|
|
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
|
OUTPUT_BUF_SIZE * sizeof(byte));
|
|
|
|
dest->pub.next_output_byte = dest->buffer;
|
|
dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Empty the output buffer --- called whenever buffer fills up.
|
|
// Input : boolean -
|
|
//-----------------------------------------------------------------------------
|
|
METHODDEF(boolean) empty_output_buffer (j_compress_ptr cinfo)
|
|
{
|
|
JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t * ) cinfo->dest;
|
|
|
|
CUtlBuffer *buf = dest->pBuffer;
|
|
|
|
// Add some data
|
|
buf->Put( dest->buffer, OUTPUT_BUF_SIZE );
|
|
|
|
dest->pub.next_output_byte = dest->buffer;
|
|
dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Terminate destination --- called by jpeg_finish_compress
|
|
// after all data has been written. Usually needs to flush buffer.
|
|
//
|
|
// NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
|
|
// application must deal with any cleanup that should happen even
|
|
// for error exit.
|
|
//-----------------------------------------------------------------------------
|
|
METHODDEF(void) term_destination (j_compress_ptr cinfo)
|
|
{
|
|
JPEGDestinationManager_t *dest = (JPEGDestinationManager_t *) cinfo->dest;
|
|
size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
|
|
|
|
CUtlBuffer *buf = dest->pBuffer;
|
|
|
|
/* Write any data remaining in the buffer */
|
|
if (datacount > 0)
|
|
{
|
|
buf->Put( dest->buffer, datacount );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set up functions for writing data to a CUtlBuffer instead of FILE *
|
|
//-----------------------------------------------------------------------------
|
|
GLOBAL(void) jpeg_UtlBuffer_dest (j_compress_ptr cinfo, CUtlBuffer *pBuffer )
|
|
{
|
|
JPEGDestinationManager_t *dest;
|
|
|
|
/* The destination object is made permanent so that multiple JPEG images
|
|
* can be written to the same file without re-executing jpeg_stdio_dest.
|
|
* This makes it dangerous to use this manager and a different destination
|
|
* manager serially with the same JPEG object, because their private object
|
|
* sizes may be different. Caveat programmer.
|
|
*/
|
|
if (cinfo->dest == NULL) { /* first time for this JPEG object? */
|
|
cinfo->dest = (struct jpeg_destination_mgr *)
|
|
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
|
|
sizeof(JPEGDestinationManager_t));
|
|
}
|
|
|
|
dest = ( JPEGDestinationManager_t * ) cinfo->dest;
|
|
|
|
dest->pub.init_destination = init_destination;
|
|
dest->pub.empty_output_buffer = empty_output_buffer;
|
|
dest->pub.term_destination = term_destination;
|
|
dest->pBuffer = pBuffer;
|
|
}
|
|
#endif
|
|
|
|
bool CVideoMode_Common::TakeSnapshotJPEGToBuffer( CUtlBuffer& buf, int quality )
|
|
{
|
|
#if !defined( _X360 ) && HAVE_JPEG
|
|
if ( g_LostVideoMemory )
|
|
return false;
|
|
|
|
// Validate quality level
|
|
quality = clamp( quality, 1, 100 );
|
|
|
|
// Allocate space for bits
|
|
uint8 *pImage = new uint8[ GetModeStereoWidth() * 3 * GetModeStereoHeight() ];
|
|
if ( !pImage )
|
|
{
|
|
Msg( "Unable to allocate %i bytes for image\n", GetModeStereoWidth() * 3 * GetModeStereoHeight() );
|
|
return false;
|
|
}
|
|
|
|
// Get Bits from the material system
|
|
ReadScreenPixels( 0, 0, GetModeStereoWidth(), GetModeStereoHeight(), pImage, IMAGE_FORMAT_RGB888 );
|
|
|
|
JSAMPROW row_pointer[1]; // pointer to JSAMPLE row[s]
|
|
int row_stride; // physical row width in image buffer
|
|
|
|
// stderr handler
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
// compression data structure
|
|
struct jpeg_compress_struct cinfo;
|
|
|
|
row_stride = GetModeStereoWidth() * 3; // JSAMPLEs per row in image_buffer
|
|
|
|
// point at stderr
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
|
|
// create compressor
|
|
jpeg_create_compress(&cinfo);
|
|
|
|
// Hook CUtlBuffer to compression
|
|
jpeg_UtlBuffer_dest(&cinfo, &buf );
|
|
|
|
// image width and height, in pixels
|
|
cinfo.image_width = GetModeStereoWidth();
|
|
cinfo.image_height = GetModeStereoHeight();
|
|
// RGB is 3 componnent
|
|
cinfo.input_components = 3;
|
|
// # of color components per pixel
|
|
cinfo.in_color_space = JCS_RGB;
|
|
|
|
// Apply settings
|
|
jpeg_set_defaults(&cinfo);
|
|
jpeg_set_quality(&cinfo, quality, TRUE );
|
|
|
|
// Start compressor
|
|
jpeg_start_compress(&cinfo, TRUE);
|
|
|
|
// Write scanlines
|
|
while ( cinfo.next_scanline < cinfo.image_height )
|
|
{
|
|
row_pointer[ 0 ] = &pImage[ cinfo.next_scanline * row_stride ];
|
|
jpeg_write_scanlines( &cinfo, row_pointer, 1 );
|
|
}
|
|
|
|
// Finalize image
|
|
jpeg_finish_compress(&cinfo);
|
|
|
|
// Cleanup
|
|
jpeg_destroy_compress(&cinfo);
|
|
|
|
delete[] pImage;
|
|
|
|
#else
|
|
// not supporting
|
|
Assert( 0 );
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Write vid.buffer out as a .jpg file
|
|
// Input : *pFilename -
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_Common::TakeSnapshotJPEG( const char *pFilename, int quality )
|
|
{
|
|
#if !defined( _X360 )
|
|
Assert( pFilename );
|
|
|
|
// Output buffer
|
|
CUtlBuffer buf( 0, 0 );
|
|
TakeSnapshotJPEGToBuffer( buf, quality );
|
|
|
|
int finalSize = 0;
|
|
FileHandle_t fh = g_pFileSystem->Open( pFilename, "wb" );
|
|
if ( FILESYSTEM_INVALID_HANDLE != fh )
|
|
{
|
|
g_pFileSystem->Write( buf.Base(), buf.TellPut(), fh );
|
|
finalSize = g_pFileSystem->Tell( fh );
|
|
g_pFileSystem->Close( fh );
|
|
}
|
|
|
|
// Show info to console.
|
|
char orig[ 64 ];
|
|
char final[ 64 ];
|
|
Q_strncpy( orig, Q_pretifymem( GetModeStereoWidth() * 3 * GetModeStereoHeight(), 2 ), sizeof( orig ) );
|
|
Q_strncpy( final, Q_pretifymem( finalSize, 2 ), sizeof( final ) );
|
|
|
|
Msg( "Wrote '%s': %s (%dx%d) compresssed (quality %i) to %s\n",
|
|
pFilename, orig, GetModeStereoWidth(), GetModeStereoHeight(), quality, final );
|
|
|
|
if ( finalSize > 0 )
|
|
{
|
|
char szPath[MAX_PATH];
|
|
szPath[0] = 0;
|
|
if ( g_pFileSystem->GetLocalPath( pFilename, szPath, sizeof(szPath) ) )
|
|
{
|
|
AddScreenshotToSteam( szPath, GetModeStereoWidth(), GetModeStereoHeight() );
|
|
}
|
|
}
|
|
|
|
#else
|
|
Assert( 0 );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The version of the VideoMode class for the material system
|
|
//-----------------------------------------------------------------------------
|
|
class CVideoMode_MaterialSystem: public CVideoMode_Common
|
|
{
|
|
public:
|
|
typedef CVideoMode_Common BaseClass;
|
|
|
|
CVideoMode_MaterialSystem( );
|
|
|
|
virtual bool Init( );
|
|
virtual void Shutdown( void );
|
|
virtual void SetGameWindow( void *hWnd );
|
|
virtual bool SetMode( int nWidth, int nHeight, bool bWindowed );
|
|
virtual void ReleaseVideo( void );
|
|
virtual void RestoreVideo( void );
|
|
virtual void AdjustForModeChange( void );
|
|
virtual void ReadScreenPixels( int x, int y, int w, int h, void *pBuffer, ImageFormat format );
|
|
|
|
private:
|
|
virtual void ReleaseFullScreen( void );
|
|
virtual void ChangeDisplaySettingsToFullscreen( int nWidth, int nHeight, int nBPP );
|
|
|
|
#ifdef WIN32
|
|
int m_nLastCDSWidth;
|
|
int m_nLastCDSHeight;
|
|
int m_nLastCDSBPP;
|
|
int m_nLastCDSFreq;
|
|
#endif
|
|
};
|
|
|
|
static void VideoMode_AdjustForModeChange( void )
|
|
{
|
|
( ( CVideoMode_MaterialSystem * )videomode )->AdjustForModeChange();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CVideoMode_MaterialSystem::CVideoMode_MaterialSystem( )
|
|
{
|
|
#ifdef WIN32
|
|
m_nLastCDSWidth = 0;
|
|
m_nLastCDSHeight = 0;
|
|
m_nLastCDSBPP = 0;
|
|
m_nLastCDSFreq = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Initialization
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_MaterialSystem::Init( )
|
|
{
|
|
m_bSetModeOnce = false;
|
|
m_bPlayedStartupVideo = false;
|
|
|
|
// we only support 32-bit rendering.
|
|
int bitsperpixel = 32;
|
|
|
|
bool bAllowSmallModes = false;
|
|
#ifndef ANDROID
|
|
if ( CommandLine()->FindParm( "-small" ) )
|
|
#endif
|
|
{
|
|
bAllowSmallModes = true;
|
|
}
|
|
|
|
int nAdapter = materials->GetCurrentAdapter();
|
|
int nModeCount = materials->GetModeCount( nAdapter );
|
|
|
|
int nDesktopWidth, nDesktopHeight, nDesktopRefresh;
|
|
game->GetDesktopInfo( nDesktopWidth, nDesktopHeight, nDesktopRefresh );
|
|
|
|
for ( int i = 0; i < nModeCount; i++ )
|
|
{
|
|
MaterialVideoMode_t info;
|
|
materials->GetModeInfo( nAdapter, i, info );
|
|
|
|
if ( info.m_Width < 640 || info.m_Height < 480 )
|
|
{
|
|
if ( !bAllowSmallModes )
|
|
continue;
|
|
}
|
|
|
|
// make sure we don't already have this mode listed
|
|
bool bAlreadyInList = false;
|
|
for ( int j = 0; j < m_nNumModes; j++ )
|
|
{
|
|
if ( info.m_Width == m_rgModeList[ j ].width && info.m_Height == m_rgModeList[ j ].height )
|
|
{
|
|
|
|
// in VR mode we want the highest refresh rate, without regard for the desktop refresh rate
|
|
if ( UseVR() || ShouldForceVRActive() )
|
|
{
|
|
if ( info.m_RefreshRate > m_rgModeList[j].refreshRate )
|
|
{
|
|
m_rgModeList[j].refreshRate = info.m_RefreshRate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// choose the highest refresh rate available for each mode up to the desktop rate
|
|
|
|
// if the new mode is valid and current is invalid or not as high, choose the new one
|
|
if ( info.m_RefreshRate <= nDesktopRefresh && (m_rgModeList[j].refreshRate > nDesktopRefresh || m_rgModeList[j].refreshRate < info.m_RefreshRate) )
|
|
{
|
|
m_rgModeList[j].refreshRate = info.m_RefreshRate;
|
|
}
|
|
}
|
|
|
|
bAlreadyInList = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bAlreadyInList )
|
|
continue;
|
|
|
|
m_rgModeList[ m_nNumModes ].width = info.m_Width;
|
|
m_rgModeList[ m_nNumModes ].height = info.m_Height;
|
|
m_rgModeList[ m_nNumModes ].bpp = bitsperpixel;
|
|
// NOTE: Don't clamp this to the desktop rate because we want to be sure we've only added
|
|
// modes that the adapter can do and maybe the desktop rate isn't available in this mode
|
|
m_rgModeList[ m_nNumModes ].refreshRate = info.m_RefreshRate;
|
|
|
|
if ( ++m_nNumModes >= MAX_MODE_LIST )
|
|
break;
|
|
}
|
|
|
|
// Sort modes for easy searching later
|
|
if ( m_nNumModes > 1 )
|
|
{
|
|
qsort( (void *)&m_rgModeList[0], m_nNumModes, sizeof(vmode_t), VideoModeCompare );
|
|
}
|
|
|
|
materials->AddModeChangeCallBack( &VideoMode_AdjustForModeChange );
|
|
SetInitialized( true );
|
|
return true;
|
|
}
|
|
|
|
|
|
void CVideoMode_MaterialSystem::Shutdown()
|
|
{
|
|
materials->RemoveModeChangeCallBack( &VideoMode_AdjustForModeChange );
|
|
BaseClass::Shutdown();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the video mode
|
|
//-----------------------------------------------------------------------------
|
|
bool CVideoMode_MaterialSystem::SetMode( int nWidth, int nHeight, bool bWindowed )
|
|
{
|
|
// Necessary for mode selection to work
|
|
int nFoundMode = FindVideoMode( nWidth, nHeight, bWindowed );
|
|
vmode_t *pMode = GetMode( nFoundMode );
|
|
|
|
// update current video state
|
|
MaterialSystem_Config_t config = *g_pMaterialSystemConfig;
|
|
config.m_VideoMode.m_Width = pMode->width;
|
|
config.m_VideoMode.m_Height = pMode->height;
|
|
|
|
// make sure VR mode is up to date
|
|
config.SetFlag( MATSYS_VIDCFG_FLAGS_VR_MODE, UseVR() || ShouldForceVRActive() );
|
|
|
|
if ( ShouldForceVRActive() )
|
|
{
|
|
config.m_nVRModeAdapter = materials->GetCurrentAdapter();
|
|
}
|
|
|
|
#ifdef SWDS
|
|
config.m_VideoMode.m_RefreshRate = 60;
|
|
#else
|
|
config.m_VideoMode.m_RefreshRate = GetRefreshRateForMode( pMode );
|
|
#endif
|
|
|
|
config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, bWindowed );
|
|
|
|
#if defined( _X360 )
|
|
XVIDEO_MODE videoMode;
|
|
XGetVideoMode( &videoMode );
|
|
if ( videoMode.fIsWideScreen )
|
|
{
|
|
extern ConVar r_aspectratio;
|
|
r_aspectratio.SetValue( 16.0f/9.0f );
|
|
}
|
|
config.SetFlag( MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION, (DWORD)nWidth != videoMode.dwDisplayWidth || (DWORD)nHeight != videoMode.dwDisplayHeight );
|
|
if ( nHeight == 480 || nWidth == 576 )
|
|
{
|
|
// Use 2xMSAA for standard def (see mat_software_aa_strength for fake hi-def aa)
|
|
// FIXME: shuffle the EDRAM surfaces to allow 4xMSAA for standard def
|
|
// (they would overlap & trash each other with the current arrangement)
|
|
// NOTE: This should affect 640x480 and 848x480 (which is also used for 640x480 widescreen), and PAL 640x576
|
|
config.m_nAASamples = 2;
|
|
}
|
|
#endif
|
|
|
|
// FIXME: This is trash. We have to do *different* things depending on how we're setting the mode!
|
|
if ( !m_bSetModeOnce )
|
|
{
|
|
//Debugger();
|
|
|
|
if ( !materials->SetMode( (void*)game->GetMainDeviceWindow(), config ) )
|
|
return false;
|
|
|
|
m_bSetModeOnce = true;
|
|
|
|
InitStartupScreen();
|
|
return true;
|
|
}
|
|
|
|
// update the config
|
|
OverrideMaterialSystemConfig( config );
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the material system when mode changes after a call to OverrideConfig
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::AdjustForModeChange( void )
|
|
{
|
|
if ( InEditMode() )
|
|
return;
|
|
|
|
// get previous size
|
|
int nOldUIWidth = GetModeUIWidth();
|
|
int nOldUIHeight = GetModeUIHeight();
|
|
|
|
// Get the new mode info from the config record
|
|
int nNewWidth = g_pMaterialSystemConfig->m_VideoMode.m_Width;
|
|
int nNewHeight = g_pMaterialSystemConfig->m_VideoMode.m_Height;
|
|
bool bWindowed = g_pMaterialSystemConfig->Windowed();
|
|
|
|
// reset the window size
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
ResetCurrentModeForNewResolution( nNewWidth, nNewHeight, bWindowed );
|
|
AdjustWindow( GetModeWidth(), GetModeHeight(), GetModeBPP(), IsWindowedMode() );
|
|
MarkClientViewRectDirty();
|
|
pRenderContext->Viewport( 0, 0, GetModeStereoWidth(), GetModeStereoHeight() );
|
|
|
|
// fixup vgui
|
|
vgui::surface()->OnScreenSizeChanged( nOldUIWidth, nOldUIHeight );
|
|
|
|
// Re-init the HUD
|
|
ClientDLL_HudVidInit();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets the game window in editor mode
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::SetGameWindow( void *hWnd )
|
|
{
|
|
if ( hWnd == NULL )
|
|
{
|
|
// No longer confine rendering into this view
|
|
materials->SetView( NULL );
|
|
return;
|
|
}
|
|
|
|
// When running in edit mode, just use hammer's window
|
|
game->SetGameWindow( (HWND)hWnd );
|
|
|
|
// FIXME: Move this code into the _MaterialSystem version of CVideoMode
|
|
// In editor mode, the mode width + height is equal to the desktop width + height
|
|
MaterialVideoMode_t mode;
|
|
materials->GetDisplayMode( mode );
|
|
m_bWindowed = true;
|
|
m_nModeWidth = mode.m_Width;
|
|
m_nModeHeight = mode.m_Height;
|
|
|
|
materials->SetView( game->GetMainDeviceWindow() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when we lose the video buffer (alt-tab)
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::ReleaseVideo( void )
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
if ( IsWindowedMode() )
|
|
return;
|
|
|
|
ReleaseFullScreen();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::RestoreVideo( void )
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
if ( IsWindowedMode() )
|
|
return;
|
|
|
|
#if defined( USE_SDL )
|
|
SDL_ShowWindow( (SDL_Window*)game->GetMainWindow() );
|
|
#else
|
|
ShowWindow( (HWND)game->GetMainWindow(), SW_SHOWNORMAL );
|
|
#endif
|
|
AdjustWindow( GetModeWidth(), GetModeHeight(), GetModeBPP(), IsWindowedMode() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::ReleaseFullScreen( void )
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
if ( IsWindowedMode() )
|
|
return;
|
|
|
|
#if !defined( USE_SDL )
|
|
// Hide the main window
|
|
if ( m_nLastCDSWidth != 0 )
|
|
ChangeDisplaySettings( NULL, 0 );
|
|
ShowWindow( (HWND)game->GetMainWindow(), SW_MINIMIZE );
|
|
m_nLastCDSWidth = 0;
|
|
m_nLastCDSHeight = 0;
|
|
m_nLastCDSBPP = 0;
|
|
m_nLastCDSFreq = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use Change Display Settings to go Full Screen
|
|
//-----------------------------------------------------------------------------
|
|
void CVideoMode_MaterialSystem::ChangeDisplaySettingsToFullscreen( int nWidth, int nHeight, int nBPP )
|
|
{
|
|
if ( IsX360() )
|
|
return;
|
|
|
|
if ( IsWindowedMode() )
|
|
return;
|
|
|
|
#if defined( WIN32 ) && !defined( USE_SDL )
|
|
DEVMODE dm;
|
|
memset(&dm, 0, sizeof(dm));
|
|
|
|
dm.dmSize = sizeof( dm );
|
|
dm.dmPelsWidth = nWidth;
|
|
dm.dmPelsHeight = nHeight;
|
|
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
|
|
dm.dmBitsPerPel = nBPP;
|
|
|
|
// FIXME: Fix direct reference of refresh rate from config record
|
|
int freq = g_pMaterialSystemConfig->m_VideoMode.m_RefreshRate;
|
|
if ( freq >= 60 )
|
|
{
|
|
dm.dmDisplayFrequency = freq;
|
|
dm.dmFields |= DM_DISPLAYFREQUENCY;
|
|
}
|
|
|
|
#if defined(IS_WINDOWS_PC)
|
|
DEVMODE dmCurrent;
|
|
if ( EnumDisplaySettings( materials->GetDisplayDeviceName(), ENUM_CURRENT_SETTINGS, &dmCurrent ) &&
|
|
dmCurrent.dmBitsPerPel == dm.dmBitsPerPel &&
|
|
dmCurrent.dmPelsWidth == dm.dmPelsWidth &&
|
|
dmCurrent.dmPelsHeight == dm.dmPelsHeight &&
|
|
( (dm.dmFields & DM_DISPLAYFREQUENCY) == 0 || dmCurrent.dmDisplayFrequency == dm.dmDisplayFrequency ) )
|
|
{
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if ( nWidth == m_nLastCDSWidth && nHeight == m_nLastCDSHeight && nBPP == m_nLastCDSBPP && freq == m_nLastCDSFreq )
|
|
return;
|
|
|
|
m_nLastCDSWidth = nWidth;
|
|
m_nLastCDSHeight = nHeight;
|
|
m_nLastCDSBPP = nBPP;
|
|
m_nLastCDSFreq = freq;
|
|
|
|
ChangeDisplaySettingsEx( materials->GetDisplayDeviceName(), &dm, NULL, CDS_FULLSCREEN, NULL );
|
|
#elif defined( USE_SDL )
|
|
g_pLauncherMgr->SetWindowFullScreen( true, nWidth, nHeight );
|
|
#else
|
|
if ( !HushAsserts() )
|
|
{
|
|
Assert( !"Impl me" );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void CVideoMode_MaterialSystem::ReadScreenPixels( int x, int y, int w, int h, void *pBuffer, ImageFormat format )
|
|
{
|
|
if ( !g_LostVideoMemory )
|
|
{
|
|
bool bReadPixelsFromFrontBuffer = g_pMaterialSystemHardwareConfig->ReadPixelsFromFrontBuffer();
|
|
if( bReadPixelsFromFrontBuffer )
|
|
{
|
|
Shader_SwapBuffers();
|
|
}
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
|
|
Rect_t rect;
|
|
rect.x = x;
|
|
rect.y = y;
|
|
rect.width = w;
|
|
rect.height = h;
|
|
|
|
pRenderContext->ReadPixelsAndStretch( &rect, &rect, (unsigned char*)pBuffer, format, w * ImageLoader::SizeInBytes( format ) );
|
|
|
|
if( bReadPixelsFromFrontBuffer )
|
|
{
|
|
Shader_SwapBuffers();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int nBytes = ImageLoader::GetMemRequired( w, h, 1, format, false );
|
|
memset( pBuffer, 0, nBytes );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Class factory
|
|
//-----------------------------------------------------------------------------
|
|
|
|
IVideoMode *videomode = ( IVideoMode * )NULL;
|
|
|
|
void VideoMode_Create( )
|
|
{
|
|
videomode = new CVideoMode_MaterialSystem;
|
|
Assert( videomode );
|
|
}
|
|
|
|
void VideoMode_Destroy()
|
|
{
|
|
if ( videomode )
|
|
{
|
|
CVideoMode_MaterialSystem *pVideoMode_MS = static_cast<CVideoMode_MaterialSystem*>(videomode);
|
|
delete pVideoMode_MS;
|
|
videomode = NULL;
|
|
}
|
|
}
|