diff options
Diffstat (limited to 'vguimatsurface/MatSystemSurface.cpp')
| -rw-r--r-- | vguimatsurface/MatSystemSurface.cpp | 4614 |
1 files changed, 4614 insertions, 0 deletions
diff --git a/vguimatsurface/MatSystemSurface.cpp b/vguimatsurface/MatSystemSurface.cpp new file mode 100644 index 0000000..7426590 --- /dev/null +++ b/vguimatsurface/MatSystemSurface.cpp @@ -0,0 +1,4614 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Implementation of the VGUI ISurface interface using the +// material system to implement it +// +//=============================================================================// + +#if defined( WIN32) && !defined( _X360 ) +#include <windows.h> +#endif +#ifdef OSX +#include <Carbon/Carbon.h> +#endif + +#if defined( USE_SDL ) +#include <appframework/ilaunchermgr.h> +ILauncherMgr *g_pLauncherMgr = NULL; +#endif + + +#include "tier1/strtools.h" +#include "tier0/icommandline.h" +#include "tier0/dbg.h" +#include "filesystem.h" +#include <vgui/VGUI.h> +#include <Color.h> +#include "utlbuffer.h" +#include "utlvector.h" +#include "Clip2D.h" +#include <vgui_controls/Panel.h> +#include <vgui/IInput.h> +#include <vgui/Point.h> +#include "bitmap/imageformat.h" +#include "TextureDictionary.h" +#include "Cursor.h" +#include "Input.h" +#include <vgui/IHTML.h> +#include <vgui/IVGui.h> +#include "vgui_surfacelib/FontManager.h" +#include "FontTextureCache.h" +#include "MatSystemSurface.h" +#include "inputsystem/iinputsystem.h" +#include <vgui_controls/Controls.h> +#include <vgui/ISystem.h> +#include "icvar.h" +#include "mathlib/mathlib.h" +#include <vgui/ILocalize.h> +#include "mathlib/vmatrix.h" +#include <tier0/vprof.h> +#include "materialsystem/itexture.h" +#include <malloc.h> +#include "../vgui2/src/VPanel.h" +#include <vgui/IInputInternal.h> +#if defined( _X360 ) +#include "xbox/xbox_win32stubs.h" +#endif +#include "xbox/xboxstubs.h" +#include "../vgui2/src/Memorybitmap.h" + +#pragma warning( disable : 4706 ) + +#include <vgui/IVguiMatInfo.h> +#include <vgui/IVguiMatInfoVar.h> +#include "materialsystem/imaterialvar.h" + +#pragma warning( default : 4706 ) + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + + + +#define VPANEL_NORMAL ((vgui::SurfacePlat *) NULL) +#define VPANEL_MINIMIZED ((vgui::SurfacePlat *) 0x00000001) + +using namespace vgui; + +static bool g_bSpewFocus = false; + +class CVguiMatInfoVar : public IVguiMatInfoVar +{ +public: + CVguiMatInfoVar( IMaterialVar *pMaterialVar ) + { + m_pMaterialVar = pMaterialVar; + } + + // from IVguiMatInfoVar + virtual int GetIntValue ( void ) const + { + return m_pMaterialVar->GetIntValue(); + } + + virtual void SetIntValue ( int val ) + { + m_pMaterialVar->SetIntValue( val ); + } + +private: + IMaterialVar *m_pMaterialVar; +}; + +class CVguiMatInfo : public IVguiMatInfo +{ +public: + CVguiMatInfo( IMaterial *pMaterial ) + { + m_pMaterial = pMaterial; + } + + // from IVguiMatInfo + virtual IVguiMatInfoVar* FindVarFactory( const char *varName, bool *found ) + { + IMaterialVar *pMaterialVar = m_pMaterial->FindVar( varName, found ); + + if ( pMaterialVar == NULL ) + return NULL; + return new CVguiMatInfoVar( pMaterialVar ); + } + + virtual int GetNumAnimationFrames( void ) + { + return m_pMaterial->GetNumAnimationFrames(); + } + +private: + IMaterial *m_pMaterial; +}; + + +//----------------------------------------------------------------------------- +// Globals... +//----------------------------------------------------------------------------- +vgui::IInputInternal *g_pIInput; +static bool g_bInDrawing; +static CFontTextureCache g_FontTextureCache; + +//----------------------------------------------------------------------------- +// Singleton instance +//----------------------------------------------------------------------------- +CMatSystemSurface g_MatSystemSurface; +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMatSystemSurface, ISurface, + VGUI_SURFACE_INTERFACE_VERSION, g_MatSystemSurface ); + +#ifdef LINUX +CUtlDict< CMatSystemSurface::font_entry, unsigned short > CMatSystemSurface::m_FontData; +#endif + +//----------------------------------------------------------------------------- +// Make sure the panel is the same size as the viewport +//----------------------------------------------------------------------------- +CMatEmbeddedPanel::CMatEmbeddedPanel() : BaseClass( NULL, "MatSystemTopPanel" ) +{ + SetPaintBackgroundEnabled( false ); + +#if defined( _X360 ) + SetPos( 0, 0 ); + SetSize( GetSystemMetrics( SM_CXSCREEN ), GetSystemMetrics( SM_CYSCREEN ) ); +#endif +} + +void CMatEmbeddedPanel::OnThink() +{ + int x, y, width, height; + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + pRenderContext->GetViewport( x, y, width, height ); + SetSize( width, height ); + SetPos( x, y ); + Repaint(); +} + +VPANEL CMatEmbeddedPanel::IsWithinTraverse(int x, int y, bool traversePopups) +{ + VPANEL retval = BaseClass::IsWithinTraverse( x, y, traversePopups ); + if ( retval == GetVPanel() ) + return 0; + return retval; +} + + +//----------------------------------------------------------------------------- +// Constructor, destructor +//----------------------------------------------------------------------------- +CMatSystemSurface::CMatSystemSurface() : m_pEmbeddedPanel(NULL), m_pWhite(NULL) +{ + m_iBoundTexture = -1; + m_HWnd = NULL; + m_bIn3DPaintMode = false; + m_b3DPaintRenderToTexture = false; + m_bDrawingIn3DWorld = false; + m_PlaySoundFunc = NULL; + m_bInThink = false; + m_bAllowJavaScript = false; + m_bAppDrivesInput = false; + m_nLastInputPollCount = 0; + + m_hCurrentFont = NULL; + m_pRestrictedPanel = NULL; + + m_bNeedsKeyboard = true; + m_bNeedsMouse = true; + m_bUsingTempFullScreenBufferMaterial = false; + m_nFullScreenBufferMaterialId = -1; + + memset( m_WorkSpaceInsets, 0, sizeof( m_WorkSpaceInsets ) ); + m_nBatchedCharVertCount = 0; + + m_nFullscreenViewportX = m_nFullscreenViewportY = 0; + m_nFullscreenViewportWidth = m_nFullscreenViewportHeight = 0; + m_pFullscreenRenderTarget = NULL; + + m_cursorAlwaysVisible = false; +} + +CMatSystemSurface::~CMatSystemSurface() +{ + if ( m_nFullScreenBufferMaterialId != -1 ) + { + DestroyTextureID( m_nFullScreenBufferMaterialId ); + m_nFullScreenBufferMaterialId = -1; + } +} + + +//----------------------------------------------------------------------------- +// Connect, disconnect... +//----------------------------------------------------------------------------- +bool CMatSystemSurface::Connect( CreateInterfaceFn factory ) +{ + if ( !BaseClass::Connect( factory ) ) + return false; + + if ( !g_pFullFileSystem ) + { + Warning( "MatSystemSurface requires the file system to run!\n" ); + return false; + } + + if ( !g_pMaterialSystem ) + { + Warning( "MatSystemSurface requires the material system to run!\n" ); + return false; + } + + if ( !g_pVGuiPanel ) + { + Warning( "MatSystemSurface requires the vgui::IPanel system to run!\n" ); + return false; + } + + g_pIInput = (IInputInternal *)factory( VGUI_INPUTINTERNAL_INTERFACE_VERSION, NULL ); + if ( !g_pIInput ) + { + Warning( "MatSystemSurface requires the vgui::IInput system to run!\n" ); + return false; + } + + if ( !g_pVGui ) + { + Warning( "MatSystemSurface requires the vgui::IVGUI system to run!\n" ); + return false; + } + + Assert( g_pVGuiSurface == this ); + + // initialize vgui_control interfaces + if ( !vgui::VGui_InitInterfacesList( "MATSURFACE", &factory, 1 ) ) + return false; + +#ifdef USE_SDL + g_pLauncherMgr = (ILauncherMgr *)factory( SDLMGR_INTERFACE_VERSION, NULL ); +#endif + + return true; +} + +void CMatSystemSurface::Disconnect() +{ + g_pIInput = NULL; + BaseClass::Disconnect(); +} + + +//----------------------------------------------------------------------------- +// Access to other interfaces... +//----------------------------------------------------------------------------- +void *CMatSystemSurface::QueryInterface( const char *pInterfaceName ) +{ + // We also implement the IMatSystemSurface interface + if (!Q_strncmp( pInterfaceName, MAT_SYSTEM_SURFACE_INTERFACE_VERSION, Q_strlen(MAT_SYSTEM_SURFACE_INTERFACE_VERSION) + 1)) + return (IMatSystemSurface*)this; + + // We also implement the IMatSystemSurface interface + if (!Q_strncmp( pInterfaceName, VGUI_SURFACE_INTERFACE_VERSION, Q_strlen(VGUI_SURFACE_INTERFACE_VERSION) + 1)) + return (vgui::ISurface*)this; + + return BaseClass::QueryInterface( pInterfaceName ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::InitFullScreenBuffer( const char *pszRenderTargetName ) +{ + if ( !IsPC() ) + return; + + char pTemp[512]; + Q_snprintf( pTemp, sizeof(pTemp), "VGUI_3DPaint_FullScreen_%s", pszRenderTargetName ); + m_FullScreenBufferMaterial.Shutdown(); + + // Set up a material with which to reference the final image for subsequent display using vgui + KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" ); + pVMTKeyValues->SetString( "$basetexture", pszRenderTargetName ); + pVMTKeyValues->SetInt( "$nocull", 1 ); + pVMTKeyValues->SetInt( "$nofog", 1 ); + pVMTKeyValues->SetInt( "$ignorez", 1 ); + pVMTKeyValues->SetInt( "$translucent", 1 ); + m_FullScreenBufferMaterial.Init( pTemp, TEXTURE_GROUP_OTHER, pVMTKeyValues ); + m_FullScreenBufferMaterial->Refresh(); + + if ( m_nFullScreenBufferMaterialId != -1 ) + { + DestroyTextureID( m_nFullScreenBufferMaterialId ); + } + m_nFullScreenBufferMaterialId = -1; + m_FullScreenBuffer.Shutdown(); + + m_FullScreenBufferName = pszRenderTargetName; +} + +//----------------------------------------------------------------------------- +// Initialization and shutdown... +//----------------------------------------------------------------------------- +InitReturnVal_t CMatSystemSurface::Init( void ) +{ + InitReturnVal_t nRetVal = BaseClass::Init(); + if ( nRetVal != INIT_OK ) + return nRetVal; + + // Allocate a white material + KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" ); + pVMTKeyValues->SetInt( "$vertexcolor", 1 ); + pVMTKeyValues->SetInt( "$vertexalpha", 1 ); + pVMTKeyValues->SetInt( "$ignorez", 1 ); + pVMTKeyValues->SetInt( "$no_fullbright", 1 ); + + if ( ! (CommandLine()->FindParm("-disable_matsurf_noculls")) ) + { + pVMTKeyValues->SetInt( "$nocull", 1 ); // skip this if user asks for the switch above + } + + m_pWhite.Init( "VGUI_White", TEXTURE_GROUP_OTHER, pVMTKeyValues ); + + InitFullScreenBuffer( "_rt_FullScreen" ); + + m_DrawColor[0] = m_DrawColor[1] = m_DrawColor[2] = m_DrawColor[3] = 255; + m_nTranslateX = m_nTranslateY = 0; + EnableScissor( false ); + SetScissorRect( 0, 0, 100000, 100000 ); + m_flAlphaMultiplier = 1.0f; + + // By default, use the default embedded panel + m_pDefaultEmbeddedPanel = new CMatEmbeddedPanel; + SetEmbeddedPanel( m_pDefaultEmbeddedPanel->GetVPanel() ); + + m_iBoundTexture = -1; + + // Initialize font info.. + m_pDrawTextPos[0] = m_pDrawTextPos[1] = 0; + m_DrawTextColor[0] = m_DrawTextColor[1] = m_DrawTextColor[2] = m_DrawTextColor[3] = 255; + + m_bIn3DPaintMode = false; + m_b3DPaintRenderToTexture = false; + m_bDrawingIn3DWorld = false; + m_PlaySoundFunc = NULL; + + // Input system + InitInput(); + + // Initialize cursors + InitCursors(); + + // fonts initialization + char language[64]; + bool bValid; + if ( IsPC() ) + { + bValid = system()->GetRegistryString( "HKEY_CURRENT_USER\\Software\\Valve\\Source\\Language", language, sizeof(language)-1 ); + } + else + { + Q_strncpy( language, XBX_GetLanguageString(), sizeof( language ) ); + bValid = true; + } + + if ( bValid ) + { + FontManager().SetLanguage( language ); + } + else + { + FontManager().SetLanguage( "english" ); + } + +#ifdef LINUX + FontManager().SetFontDataHelper( &CMatSystemSurface::FontDataHelper ); +#endif + + // font manager needs the file system and material system for bitmap fonts + FontManager().SetInterfaces( g_pFullFileSystem, g_pMaterialSystem ); + + g_bSpewFocus = CommandLine()->FindParm( "-vguifocus" ) ? true : false; + + return INIT_OK; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::Shutdown( void ) +{ + for ( int i = m_FileTypeImages.First(); i != m_FileTypeImages.InvalidIndex(); i = m_FileTypeImages.Next( i ) ) + { + delete m_FileTypeImages[ i ]; + } + m_FileTypeImages.RemoveAll(); + + // Release all textures + TextureDictionary()->DestroyAllTextures(); + m_iBoundTexture = -1; + + // Release the standard materials + m_pWhite.Shutdown(); + m_FullScreenBufferMaterial.Shutdown(); + m_FullScreenBuffer.Shutdown(); + + m_Titles.Purge(); + m_PaintStateStack.Purge(); + +#if defined( WIN32 ) && !defined( _X360 ) + // release any custom font files + // use newer function if possible + HMODULE gdiModule = ::LoadLibrary( "gdi32.dll" ); + typedef int (WINAPI *RemoveFontResourceExProc)(LPCTSTR, DWORD, PVOID); + RemoveFontResourceExProc pRemoveFontResourceEx = NULL; + if ( gdiModule ) + { + pRemoveFontResourceEx = (RemoveFontResourceExProc)::GetProcAddress(gdiModule, "RemoveFontResourceExA"); + } + + for (int i = 0; i < m_CustomFontFileNames.Count(); i++) + { + if (pRemoveFontResourceEx) + { + // dvs: Keep removing the font until we get an error back. After consulting with Microsoft, it appears + // that RemoveFontResourceEx must sometimes be called multiple times to work. Doing this insures that + // when we load the font next time we get the real font instead of Ariel. + int nRetries = 0; + while ( (*pRemoveFontResourceEx)(m_CustomFontFileNames[i].String(), 0x10, NULL) && ( nRetries < 10 ) ) + { + nRetries++; + Msg( "Removed font resource %s on attempt %d.\n", m_CustomFontFileNames[i].String(), nRetries ); + } + } + else + { + // dvs: Keep removing the font until we get an error back. After consulting with Microsoft, it appears + // that RemoveFontResourceEx must sometimes be called multiple times to work. Doing this insures that + // when we load the font next time we get the real font instead of Ariel. + int nRetries = 0; + while ( ::RemoveFontResource(m_CustomFontFileNames[i].String()) && ( nRetries < 10 ) ) + { + nRetries++; + Msg( "Removed font resource %s on attempt %d.\n", m_CustomFontFileNames[i].String(), nRetries ); + } + } + } +#endif + + m_CustomFontFileNames.RemoveAll(); + m_BitmapFontFileNames.RemoveAll(); + m_BitmapFontFileMapping.RemoveAll(); + + Cursor_ClearUserCursors(); + +#if defined( WIN32 ) && !defined( _X360 ) + if ( gdiModule ) + { + ::FreeLibrary(gdiModule); + } +#endif + + BaseClass::Shutdown(); +} + +void CMatSystemSurface::SetEmbeddedPanel(VPANEL pEmbeddedPanel) +{ + m_pEmbeddedPanel = pEmbeddedPanel; + ((VPanel *)pEmbeddedPanel)->Client()->RequestFocus(0); +} + +//----------------------------------------------------------------------------- +// hierarchy root +//----------------------------------------------------------------------------- +VPANEL CMatSystemSurface::GetEmbeddedPanel() +{ + return m_pEmbeddedPanel; +} + +//----------------------------------------------------------------------------- +// Purpose: cap bits +// Warning: if you change this, make sure the SurfaceV28 wrapper above reports +// the correct capabilities. +//----------------------------------------------------------------------------- +bool CMatSystemSurface::SupportsFeature(SurfaceFeature_e feature) +{ + switch (feature) + { + case ISurface::ANTIALIASED_FONTS: + case ISurface::DROPSHADOW_FONTS: + return true; + + case ISurface::OUTLINE_FONTS: + if ( IsX360() ) + return false; + return true; + + case ISurface::ESCAPE_KEY: + return true; + + case ISurface::OPENING_NEW_HTML_WINDOWS: + case ISurface::FRAME_MINIMIZE_MAXIMIZE: + default: + return false; + }; +} + +//----------------------------------------------------------------------------- +// Hook needed to Get input to work +//----------------------------------------------------------------------------- +void CMatSystemSurface::AttachToWindow( void *hWnd, bool bLetAppDriveInput ) +{ + InputDetachFromWindow( m_HWnd ); + m_HWnd = hWnd; + if ( hWnd ) + { + InputAttachToWindow( hWnd ); + m_bAppDrivesInput = bLetAppDriveInput; + } + else + { + // Never call RunFrame stuff + m_bAppDrivesInput = true; + } +} + +bool CMatSystemSurface::HandleInputEvent( const InputEvent_t &event ) +{ + if ( !m_bAppDrivesInput ) + { + g_pIInput->UpdateButtonState( event ); + } + + return InputHandleInputEvent( event ); +} + + +//----------------------------------------------------------------------------- +// Draws a panel in 3D space. Assumes view + projection are already set up +// Also assumes the (x,y) coordinates of the panels are defined in 640xN coords +// (N isn't necessary 480 because the panel may not be 4x3) +// The width + height specified are the size of the panel in world coordinates +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawPanelIn3DSpace( vgui::VPANEL pRootPanel, const VMatrix &panelCenterToWorld, int pw, int ph, float sw, float sh ) +{ + Assert( pRootPanel ); + + // FIXME: When should such panels be solved?!? + SolveTraverse( pRootPanel, false ); + + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + + // Force Z buffering to be on for all panels drawn... + pRenderContext->OverrideDepthEnable( true, false ); + + Assert(!m_bDrawingIn3DWorld); + m_bDrawingIn3DWorld = true; + + StartDrawingIn3DSpace( panelCenterToWorld, pw, ph, sw, sh ); + + ((VPanel *)pRootPanel)->Client()->Repaint(); + ((VPanel *)pRootPanel)->Client()->PaintTraverse(true, false); + + FinishDrawing(); + + // Reset z buffering to normal state + pRenderContext->OverrideDepthEnable( false, true ); + + m_bDrawingIn3DWorld = false; +} + + +//----------------------------------------------------------------------------- +// Purpose: Setup rendering for vgui on a panel existing in 3D space +//----------------------------------------------------------------------------- +void CMatSystemSurface::StartDrawingIn3DSpace( const VMatrix &screenToWorld, int pw, int ph, float sw, float sh ) +{ + g_bInDrawing = true; + m_iBoundTexture = -1; + + int px = 0; + int py = 0; + + m_pSurfaceExtents[0] = px; + m_pSurfaceExtents[1] = py; + m_pSurfaceExtents[2] = px + pw; + m_pSurfaceExtents[3] = py + ph; + + // In order for this to work, the model matrix must have its origin + // at the upper left corner of the screen. We must also scale down the + // rendering from pixel space to screen space. Let's construct a matrix + // transforming from pixel coordinates (640xN) to screen coordinates + // (wxh, with the origin at the upper left of the screen). Then we'll + // concatenate it with the panelCenterToWorld to produce pixelToWorld transform + VMatrix pixelToScreen; + + // First, scale it so that 0->pw transforms to 0->sw + MatrixBuildScale( pixelToScreen, sw / pw, -sh / ph, 1.0f ); + + // Construct pixelToWorld + VMatrix pixelToWorld; + MatrixMultiply( screenToWorld, pixelToScreen, pixelToWorld ); + + // make sure there is no translation and rotation laying around + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PushMatrix(); + pRenderContext->LoadMatrix( pixelToWorld ); + + // These are only here so that FinishDrawing works... + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PushMatrix(); + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->PushMatrix(); + + // Always enable scissoring (translate to origin because of the glTranslatef call above..) + EnableScissor( true ); + + m_nTranslateX = 0; + m_nTranslateY = 0; + m_flAlphaMultiplier = 1.0f; +} + + +//----------------------------------------------------------------------------- +// Purpose: Setup ortho for vgui +//----------------------------------------------------------------------------- + +// we may need to offset by 0.5 texels to account for the different in pixel vs. texel centers in dx7-9 +// however, we do this fixup already when we set up the texture coordinates for all materials/fonts +// so in theory we shouldn't need to do any adjustments for setting up the screen +// HOWEVER, we must do the offset, else the driver will think the text is something that should +// be antialiased, so the text will look broken if antialiasing is turned on (usually forced on in the driver) +float g_flPixelOffsetX = 0.5f; +float g_flPixelOffsetY = 0.5f; + +bool g_bCheckedCommandLine = false; + +extern void ___stop___( void ); +void CMatSystemSurface::StartDrawing( void ) +{ + MAT_FUNC; + + if ( !g_bCheckedCommandLine ) + { + g_bCheckedCommandLine = true; + + const char *pX = CommandLine()->ParmValue( "-pixel_offset_x", (const char*)NULL ); + if ( pX ) + g_flPixelOffsetX = atof( pX ); + + const char *pY = CommandLine()->ParmValue( "-pixel_offset_y", (const char*)NULL ); + if ( pY ) + g_flPixelOffsetY = atof( pY ); + } + + g_bInDrawing = true; + m_iBoundTexture = -1; + + int x, y, width, height; + + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + pRenderContext->GetViewport( x, y, width, height); + + // we don't want to include x and y from the viewport here. DX will + // automatically translate any drawing we do into that viewport. + m_pSurfaceExtents[0] = 0; + m_pSurfaceExtents[1] = 0; + m_pSurfaceExtents[2] = width; + m_pSurfaceExtents[3] = height; + + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PushMatrix(); + pRenderContext->LoadIdentity(); + pRenderContext->Scale( 1, -1, 1 ); + + //___stop___(); + pRenderContext->Ortho( g_flPixelOffsetX, g_flPixelOffsetY, width + g_flPixelOffsetX, height + g_flPixelOffsetY, -1.0f, 1.0f ); + + // make sure there is no translation and rotation laying around + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PushMatrix(); + pRenderContext->LoadIdentity(); + + // Always enable scissoring (translate to origin because of the glTranslatef call above..) + EnableScissor( true ); + + m_nTranslateX = 0; + m_nTranslateY = 0; + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->PushMatrix(); + pRenderContext->LoadIdentity(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::FinishDrawing( void ) +{ + MAT_FUNC; + + // We're done with scissoring + EnableScissor( false ); + + // Restore the matrices + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PopMatrix(); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PopMatrix(); + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->PopMatrix(); + + Assert( g_bInDrawing ); + g_bInDrawing = false; +} + + +//----------------------------------------------------------------------------- +// frame +//----------------------------------------------------------------------------- +void CMatSystemSurface::RunFrame() +{ + int nPollCount = g_pInputSystem->GetPollCount(); + if ( m_nLastInputPollCount == nPollCount ) + return; + + // If this isn't true, we've lost input! + if ( !m_bAppDrivesInput && m_nLastInputPollCount != nPollCount - 1 ) + { + Assert( 0 ); + Warning( "Vgui is losing input messages! Call brian!\n" ); + } + + m_nLastInputPollCount = nPollCount; + + if ( m_bAppDrivesInput ) + return; + + // Generate all input messages + int nEventCount = g_pInputSystem->GetEventCount(); + const InputEvent_t* pEvents = g_pInputSystem->GetEventData( ); + for ( int i = 0; i < nEventCount; ++i ) + { + HandleInputEvent( pEvents[i] ); + } +} + + +//----------------------------------------------------------------------------- +// Sets up a particular painting state... +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetupPaintState( const PaintState_t &paintState ) +{ + m_nTranslateX = paintState.m_iTranslateX; + m_nTranslateY = paintState.m_iTranslateY; + SetScissorRect( paintState.m_iScissorLeft, paintState.m_iScissorTop, + paintState.m_iScissorRight, paintState.m_iScissorBottom ); +} + +//----------------------------------------------------------------------------- +// Indicates a particular panel is about to be rendered +//----------------------------------------------------------------------------- +void CMatSystemSurface::PushMakeCurrent(VPANEL pPanel, bool useInSets) +{ + int inSets[4] = {0, 0, 0, 0}; + int absExtents[4]; + int clipRect[4]; + + if (useInSets) + { + g_pVGuiPanel->GetInset(pPanel, inSets[0], inSets[1], inSets[2], inSets[3]); + } + + g_pVGuiPanel->GetAbsPos(pPanel, absExtents[0], absExtents[1]); + int wide, tall; + g_pVGuiPanel->GetSize(pPanel, wide, tall); + absExtents[2] = absExtents[0] + wide; + absExtents[3] = absExtents[1] + tall; + + g_pVGuiPanel->GetClipRect(pPanel, clipRect[0], clipRect[1], clipRect[2], clipRect[3]); + + int i = m_PaintStateStack.AddToTail(); + PaintState_t &paintState = m_PaintStateStack[i]; + paintState.m_pPanel = pPanel; + + // Determine corrected top left origin + paintState.m_iTranslateX = inSets[0] + absExtents[0] - m_pSurfaceExtents[0]; + paintState.m_iTranslateY = inSets[1] + absExtents[1] - m_pSurfaceExtents[1]; + + // Setup clipping rectangle for scissoring + paintState.m_iScissorLeft = clipRect[0] - m_pSurfaceExtents[0]; + paintState.m_iScissorTop = clipRect[1] - m_pSurfaceExtents[1]; + paintState.m_iScissorRight = clipRect[2] - m_pSurfaceExtents[0]; + paintState.m_iScissorBottom = clipRect[3] - m_pSurfaceExtents[1]; + + SetupPaintState( paintState ); +} + +void CMatSystemSurface::PopMakeCurrent(VPANEL pPanel) +{ + //hushed MAT_FUNC; + + // draw any remaining text + if ( m_nBatchedCharVertCount > 0 ) + { + DrawFlushText(); + } + + int top = m_PaintStateStack.Count() - 1; + + // More pops that pushes? + Assert( top >= 0 ); + + // Didn't pop in reverse order of push? + Assert( m_PaintStateStack[top].m_pPanel == pPanel ); + + m_PaintStateStack.Remove(top); + + if (top > 0) + SetupPaintState( m_PaintStateStack[top-1] ); + +// m_iBoundTexture = -1; +} + + +//----------------------------------------------------------------------------- +// Color Setting methods +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetColor(int r, int g, int b, int a) +{ + Assert( g_bInDrawing ); + m_DrawColor[0]=(unsigned char)r; + m_DrawColor[1]=(unsigned char)g; + m_DrawColor[2]=(unsigned char)b; + m_DrawColor[3]=(unsigned char)(a * m_flAlphaMultiplier); +} + +void CMatSystemSurface::DrawSetColor(Color col) +{ + Assert( g_bInDrawing ); + DrawSetColor(col[0], col[1], col[2], col[3]); +} + + +//----------------------------------------------------------------------------- +// material Setting methods +//----------------------------------------------------------------------------- +void CMatSystemSurface::InternalSetMaterial( IMaterial *pMaterial ) +{ + if (!pMaterial) + { + pMaterial = m_pWhite; + } + + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + m_pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial ); +} + + +//----------------------------------------------------------------------------- +// Helper method to initialize vertices (transforms them into screen space too) +//----------------------------------------------------------------------------- +void CMatSystemSurface::InitVertex( vgui::Vertex_t &vertex, int x, int y, float u, float v ) +{ + vertex.m_Position.Init( x + m_nTranslateX, y + m_nTranslateY ); + vertex.m_TexCoord.Init( u, v ); +} + + +//----------------------------------------------------------------------------- +// Draws a line! +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawTexturedLineInternal( const Vertex_t &a, const Vertex_t &b ) +{ + MAT_FUNC; + + Assert( !m_bIn3DPaintMode ); + + // Don't bother drawing fully transparent lines + if( m_DrawColor[3] == 0 ) + return; + + vgui::Vertex_t verts[2] = { a, b }; + + verts[0].m_Position.x += m_nTranslateX + g_flPixelOffsetX; + verts[0].m_Position.y += m_nTranslateY + g_flPixelOffsetY; + + verts[1].m_Position.x += m_nTranslateX + g_flPixelOffsetX; + verts[1].m_Position.y += m_nTranslateY + g_flPixelOffsetY; + + vgui::Vertex_t clippedVerts[2]; + + if (!ClipLine( verts, clippedVerts )) + return; + + meshBuilder.Begin( m_pMesh, MATERIAL_LINES, 1 ); + + meshBuilder.Position3f( clippedVerts[0].m_Position.x, clippedVerts[0].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, clippedVerts[0].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( clippedVerts[1].m_Position.x, clippedVerts[1].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, clippedVerts[1].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.End(); + m_pMesh->Draw(); +} + +void CMatSystemSurface::DrawLine( int x0, int y0, int x1, int y1 ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Don't bother drawing fully transparent lines + if( m_DrawColor[3] == 0 ) + return; + + vgui::Vertex_t verts[2]; + verts[0].Init( Vector2D( x0, y0 ), Vector2D( 0, 0 ) ); + verts[1].Init( Vector2D( x1, y1 ), Vector2D( 1, 1 ) ); + + InternalSetMaterial( ); + DrawTexturedLineInternal( verts[0], verts[1] ); +} + + +void CMatSystemSurface::DrawTexturedLine( const Vertex_t &a, const Vertex_t &b ) +{ + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + DrawTexturedLineInternal( a, b ); +} + + +//----------------------------------------------------------------------------- +// Draws a line! +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawPolyLine( int *px, int *py ,int n ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + Assert( !m_bIn3DPaintMode ); + + // Don't bother drawing fully transparent lines + if( m_DrawColor[3] == 0 ) + return; + + InternalSetMaterial( ); + meshBuilder.Begin( m_pMesh, MATERIAL_LINES, n ); + + for ( int i = 0; i < n ; i++ ) + { + int inext = ( i + 1 ) % n; + + vgui::Vertex_t verts[2]; + vgui::Vertex_t clippedVerts[2]; + + int x0, y0, x1, y1; + + x0 = px[ i ]; + x1 = px[ inext ]; + y0 = py[ i ]; + y1 = py[ inext ]; + + InitVertex( verts[0], x0, y0, 0, 0 ); + InitVertex( verts[1], x1, y1, 1, 1 ); + + if (!ClipLine( verts, clippedVerts )) + continue; + + meshBuilder.Position3f( clippedVerts[0].m_Position.x+ g_flPixelOffsetX, clippedVerts[0].m_Position.y + g_flPixelOffsetY, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, clippedVerts[0].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( clippedVerts[1].m_Position.x+ g_flPixelOffsetX, clippedVerts[1].m_Position.y + g_flPixelOffsetY, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, clippedVerts[1].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + + meshBuilder.End(); + m_pMesh->Draw(); +} + + +void CMatSystemSurface::DrawTexturedPolyLine( const vgui::Vertex_t *p,int n ) +{ + MAT_FUNC; + + int iPrev = n - 1; + for ( int i=0; i < n; i++ ) + { + DrawTexturedLine( p[iPrev], p[i] ); + iPrev = i; + } +} + + +//----------------------------------------------------------------------------- +// Draws a quad: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawQuad( const vgui::Vertex_t &ul, const vgui::Vertex_t &lr, unsigned char *pColor ) +{ + MAT_FUNC; + + Assert( !m_bIn3DPaintMode ); + + if ( !m_pMesh ) + return; + + meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, 1 ); + + meshBuilder.Position3f( ul.m_Position.x, ul.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, ul.m_TexCoord.x, ul.m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( lr.m_Position.x, ul.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, lr.m_TexCoord.x, ul.m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( lr.m_Position.x, lr.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, lr.m_TexCoord.x, lr.m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( ul.m_Position.x, lr.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, ul.m_TexCoord.x, lr.m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.End(); + m_pMesh->Draw(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Draws an array of quads +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawQuadArray( int quadCount, vgui::Vertex_t *pVerts, unsigned char *pColor, bool bShouldClip ) +{ + MAT_FUNC; + + Assert( !m_bIn3DPaintMode ); + + if ( !m_pMesh ) + return; + + meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, quadCount ); + + vgui::Vertex_t ulc; + vgui::Vertex_t lrc; + vgui::Vertex_t *pulc; + vgui::Vertex_t *plrc; + + if ( bShouldClip ) + { + for ( int i = 0; i < quadCount; ++i ) + { + PREFETCH360( &pVerts[ 2 * ( i + 1 ) ], 0 ); + + if ( !ClipRect( pVerts[2*i], pVerts[2*i + 1], &ulc, &lrc ) ) + { + continue; + } + pulc = &ulc; + plrc = &lrc; + + meshBuilder.Position3f( pulc->m_Position.x, pulc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, pulc->m_TexCoord.x, pulc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( plrc->m_Position.x, pulc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, plrc->m_TexCoord.x, pulc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( plrc->m_Position.x, plrc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, plrc->m_TexCoord.x, plrc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( pulc->m_Position.x, plrc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, pulc->m_TexCoord.x, plrc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + } + else + { + for ( int i = 0; i < quadCount; ++i ) + { + PREFETCH360( &pVerts[ 2 * ( i + 1 ) ], 0 ); + + pulc = &pVerts[2*i]; + plrc = &pVerts[2*i + 1]; + + meshBuilder.Position3f( pulc->m_Position.x, pulc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, pulc->m_TexCoord.x, pulc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( plrc->m_Position.x, pulc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, plrc->m_TexCoord.x, pulc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( plrc->m_Position.x, plrc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, plrc->m_TexCoord.x, plrc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( pulc->m_Position.x, plrc->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( pColor ); + meshBuilder.TexCoord2f( 0, pulc->m_TexCoord.x, plrc->m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + } + + meshBuilder.End(); + m_pMesh->Draw(); +} + + +//----------------------------------------------------------------------------- +// Purpose: Draws a rectangle colored with the current drawcolor +// using the white material +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFilledRect( int x0, int y0, int x1, int y1 ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Don't even bother drawing fully transparent junk + if( m_DrawColor[3]!=0 ) + { + vgui::Vertex_t rect[2]; + vgui::Vertex_t clippedRect[2]; + InitVertex( rect[0], x0, y0, 0, 0 ); + InitVertex( rect[1], x1, y1, 0, 0 ); + + // Fully clipped? + if ( !ClipRect(rect[0], rect[1], &clippedRect[0], &clippedRect[1]) ) + return; + + InternalSetMaterial(); + DrawQuad( clippedRect[0], clippedRect[1], m_DrawColor ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Draws an array of rectangles colored with the current drawcolor +// using the white material +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFilledRectArray( IntRect *pRects, int numRects ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Don't even bother drawing fully transparent junk + if( m_DrawColor[3]==0 ) + return; + + if ( !m_pMesh ) + return; + + InternalSetMaterial( ); + + meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, numRects ); + + for (int i = 0; i < numRects; ++i ) + { + vgui::Vertex_t rect[2]; + vgui::Vertex_t clippedRect[2]; + InitVertex( rect[0], pRects[i].x0, pRects[i].y0, 0, 0 ); + InitVertex( rect[1], pRects[i].x1, pRects[i].y1, 0, 0 ); + + ClipRect( rect[0], rect[1], &clippedRect[0], &clippedRect[1] ); + + vgui::Vertex_t &ul = clippedRect[0]; + vgui::Vertex_t &lr = clippedRect[1]; + + meshBuilder.Position3f( ul.m_Position.x, ul.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>(); + + meshBuilder.Position3f( lr.m_Position.x, ul.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>(); + + meshBuilder.Position3f( lr.m_Position.x, lr.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>(); + + meshBuilder.Position3f( ul.m_Position.x, lr.m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 0>(); + } + + meshBuilder.End(); + m_pMesh->Draw(); +} + +//----------------------------------------------------------------------------- +// Draws a fade between the fadeStartPt and fadeEndPT with the current draw color oriented according to argument +// Example: DrawFilledRectFastFade( 10, 10, 100, 20, 50, 60, 255, 128, true ); +// -this will draw +// a solid rect (10,10,50,20) //alpha 255 +// a solid rect (50,10,60,20) //alpha faded from 255 to 128 +// a solid rect (60,10,100,20) //alpha 128 +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFilledRectFastFade( int x0, int y0, int x1, int y1, int fadeStartPt, int fadeEndPt, unsigned int alpha0, unsigned int alpha1, bool bHorizontal ) +{ + if( bHorizontal ) + { + if( alpha0 ) + { + DrawSetColor( m_DrawColor[0], m_DrawColor[1], m_DrawColor[2], alpha0 ); + DrawFilledRect( x0, y0, fadeStartPt, y1 ); + } + DrawFilledRectFade( fadeStartPt, y0, fadeEndPt, y1, alpha0, alpha1, true ); + if( alpha1 ) + { + DrawSetColor( m_DrawColor[0], m_DrawColor[1], m_DrawColor[2], alpha1 ); + DrawFilledRect( fadeEndPt, y0, x1, y1 ); + } + } + else + { + if( alpha0 ) + { + DrawSetColor( m_DrawColor[0], m_DrawColor[1], m_DrawColor[2], alpha0 ); + DrawFilledRect( x0, y0, x1, fadeStartPt ); + } + DrawFilledRectFade( x0, fadeStartPt, x1, fadeEndPt, alpha0, alpha1, false ); + if( alpha1 ) + { + DrawSetColor( m_DrawColor[0], m_DrawColor[1], m_DrawColor[2], alpha1 ); + DrawFilledRect( x0, fadeEndPt, x1, y1 ); + } + } +} + +//----------------------------------------------------------------------------- +// Draws a fade with the current draw color oriented according to argument +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFilledRectFade( int x0, int y0, int x1, int y1, unsigned int alpha0, unsigned int alpha1, bool bHorizontal ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Scale the desired alphas by the surface alpha + float alphaScale = m_DrawColor[3] / 255.f; + alpha0 *= alphaScale; + alpha1 *= alphaScale; + + // Don't even bother drawing fully transparent junk + if ( alpha0 == 0 && alpha1 == 0 ) + return; + + vgui::Vertex_t rect[2]; + vgui::Vertex_t clippedRect[2]; + InitVertex( rect[0], x0, y0, 0, 0 ); + InitVertex( rect[1], x1, y1, 0, 0 ); + + // Fully clipped? + if ( !ClipRect(rect[0], rect[1], &clippedRect[0], &clippedRect[1]) ) + return; + + InternalSetMaterial(); + + unsigned char colors[4][4] = {{0}}; + for ( int i=0; i<4; i++ ) + { + // copy the rgb and leave the alpha at zero + Q_memcpy( colors[i], m_DrawColor, 3 ); + } + + unsigned char nAlpha0 = (alpha0 & 0xFF); + unsigned char nAlpha1 = (alpha1 & 0xFF); + + if ( bHorizontal ) + { + // horizontal fade + colors[0][3] = nAlpha0; + colors[1][3] = nAlpha1; + colors[2][3] = nAlpha1; + colors[3][3] = nAlpha0; + } + else + { + // vertical fade + colors[0][3] = nAlpha0; + colors[1][3] = nAlpha0; + colors[2][3] = nAlpha1; + colors[3][3] = nAlpha1; + } + + meshBuilder.Begin( m_pMesh, MATERIAL_QUADS, 1 ); + + meshBuilder.Position3f( clippedRect[0].m_Position.x, clippedRect[0].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( colors[0] ); + meshBuilder.TexCoord2f( 0, clippedRect[0].m_TexCoord.x, clippedRect[0].m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( clippedRect[1].m_Position.x, clippedRect[0].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( colors[1] ); + meshBuilder.TexCoord2f( 0, clippedRect[1].m_TexCoord.x, clippedRect[0].m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( clippedRect[1].m_Position.x, clippedRect[1].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( colors[2] ); + meshBuilder.TexCoord2f( 0, clippedRect[1].m_TexCoord.x, clippedRect[1].m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( clippedRect[0].m_Position.x, clippedRect[1].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( colors[3] ); + meshBuilder.TexCoord2f( 0, clippedRect[0].m_TexCoord.x, clippedRect[1].m_TexCoord.y ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.End(); + m_pMesh->Draw(); +} + +//----------------------------------------------------------------------------- +// Purpose: Draws an unfilled rectangle in the current drawcolor +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawOutlinedRect(int x0,int y0,int x1,int y1) +{ + MAT_FUNC; + + // Don't even bother drawing fully transparent junk + if ( m_DrawColor[3] == 0 ) + return; + + DrawFilledRect(x0,y0,x1,y0+1); //top + DrawFilledRect(x0,y1-1,x1,y1); //bottom + DrawFilledRect(x0,y0+1,x0+1,y1-1); //left + DrawFilledRect(x1-1,y0+1,x1,y1-1); //right +} + + +//----------------------------------------------------------------------------- +// Purpose: Draws an outlined circle in the current drawcolor +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawOutlinedCircle(int x, int y, int radius, int segments) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + Assert( !m_bIn3DPaintMode ); + + // Don't even bother drawing fully transparent junk + if( m_DrawColor[3]==0 ) + return; + + // NOTE: Gotta use lines instead of linelist or lineloop due to clipping + InternalSetMaterial( ); + meshBuilder.Begin( m_pMesh, MATERIAL_LINES, segments ); + + vgui::Vertex_t renderVertex[2]; + vgui::Vertex_t vertex[2]; + vertex[0].m_Position.Init( m_nTranslateX + x + radius, m_nTranslateY + y ); + vertex[0].m_TexCoord.Init( 1.0f, 0.5f ); + + float invDelta = 2.0f * M_PI / segments; + for ( int i = 1; i <= segments; ++i ) + { + float flRadians = i * invDelta; + float ca = cos( flRadians ); + float sa = sin( flRadians ); + + // Rotate it around the circle + vertex[1].m_Position.x = m_nTranslateX + x + (radius * ca); + vertex[1].m_Position.y = m_nTranslateY + y + (radius * sa); + vertex[1].m_TexCoord.x = 0.5f * (ca + 1.0f); + vertex[1].m_TexCoord.y = 0.5f * (sa + 1.0f); + + if (ClipLine( vertex, renderVertex )) + { + meshBuilder.Position3f( renderVertex[0].m_Position.x, renderVertex[0].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, renderVertex[0].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + + meshBuilder.Position3f( renderVertex[1].m_Position.x, renderVertex[1].m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, renderVertex[1].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + + vertex[0].m_Position = vertex[1].m_Position; + vertex[0].m_TexCoord = vertex[1].m_TexCoord; + } + + meshBuilder.End(); + m_pMesh->Draw(); +} + + +//----------------------------------------------------------------------------- +// Loads a particular texture (material) +//----------------------------------------------------------------------------- +int CMatSystemSurface::CreateNewTextureID( bool procedural /*=false*/ ) +{ + return TextureDictionary()->CreateTexture( procedural ); +} + +void CMatSystemSurface::DestroyTextureID( int id ) +{ + TextureDictionary()->DestroyTexture( id ); +} + +bool CMatSystemSurface::DeleteTextureByID(int id) +{ + TextureDictionary()->DestroyTexture( id ); + return false; +} + +#ifdef _X360 +void CMatSystemSurface::UncacheUnusedMaterials() +{ + // unbind any currently set texture (which may be uncached) + DrawSetTexture( -1 ); + + // X360TBD: Need to only destroy "marked" textures +} +#endif + +//----------------------------------------------------------------------------- +// Purpose: +// Input : id - +// *filename - +// maxlen - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CMatSystemSurface::DrawGetTextureFile(int id, char *filename, int maxlen ) +{ + if ( !TextureDictionary()->IsValidId( id ) ) + return false; + + IMaterial *texture = TextureDictionary()->GetTextureMaterial(id); + if ( !texture ) + return false; + + Q_strncpy( filename, texture->GetName(), maxlen ); + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : id - texture id +// Output : returns IMaterial for the referenced texture +//----------------------------------------------------------------------------- +IVguiMatInfo *CMatSystemSurface::DrawGetTextureMatInfoFactory(int id) +{ + if ( !TextureDictionary()->IsValidId( id ) ) + return NULL; + + IMaterial *texture = TextureDictionary()->GetTextureMaterial(id); + + if ( texture == NULL ) + return NULL; + + return new CVguiMatInfo(texture); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *filename - +// Output : int +//----------------------------------------------------------------------------- +int CMatSystemSurface::DrawGetTextureId( char const *filename ) +{ + return TextureDictionary()->FindTextureIdForTextureFile( filename ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *pTexture +// Output : int +//----------------------------------------------------------------------------- +int CMatSystemSurface::DrawGetTextureId( ITexture *pTexture ) +{ + return TextureDictionary()->CreateTextureByTexture( pTexture ); +} + + +//----------------------------------------------------------------------------- +// Associates a texture with a material file (also binds it) +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextureFile(int id, const char *pFileName, int hardwareFilter, bool forceReload /*= false*/) +{ + TextureDictionary()->BindTextureToFile( id, pFileName ); + DrawSetTexture( id ); +} + + +//----------------------------------------------------------------------------- +// Associates a texture with a material file (also binds it) +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextureMaterial(int id, IMaterial *pMaterial) +{ + TextureDictionary()->BindTextureToMaterial( id, pMaterial ); + DrawSetTexture( id ); +} + +IMaterial *CMatSystemSurface::DrawGetTextureMaterial( int id ) +{ + return TextureDictionary()->GetTextureMaterial( id ); +} + + +void CMatSystemSurface::ReferenceProceduralMaterial( int id, int referenceId, IMaterial *pMaterial ) +{ + TextureDictionary()->BindTextureToMaterialReference( id, referenceId, pMaterial ); +} + + +//----------------------------------------------------------------------------- +// Binds a texture +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTexture( int id ) +{ + // if we're switching textures, flush any batched text + if ( id != m_iBoundTexture ) + { + DrawFlushText(); + m_iBoundTexture = id; + + if ( IsX360() && id == -1 ) + { + // ensure we unbind current material that may go away + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + pRenderContext->Bind( m_pWhite ); + } + } +} + + +//----------------------------------------------------------------------------- +// Returns texture size +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawGetTextureSize(int id, int &iWide, int &iTall) +{ + TextureDictionary()->GetTextureSize( id, iWide, iTall ); +} + + +//----------------------------------------------------------------------------- +// Draws a textured rectangle +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawTexturedRect( int x0, int y0, int x1, int y1 ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Don't even bother drawing fully transparent junk + if( m_DrawColor[3] == 0 ) + return; + + float s0, t0, s1, t1; + TextureDictionary()->GetTextureTexCoords( m_iBoundTexture, s0, t0, s1, t1 ); + + vgui::Vertex_t rect[2]; + vgui::Vertex_t clippedRect[2]; + InitVertex( rect[0], x0, y0, s0, t0 ); + InitVertex( rect[1], x1, y1, s1, t1 ); + + // Fully clipped? + if ( !ClipRect(rect[0], rect[1], &clippedRect[0], &clippedRect[1]) ) + return; + + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + DrawQuad( clippedRect[0], clippedRect[1], m_DrawColor ); +} + +//----------------------------------------------------------------------------- +// Draws a textured rectangle +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawTexturedSubRect( int x0, int y0, int x1, int y1, float texs0, float text0, float texs1, float text1 ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + + // Don't even bother drawing fully transparent junk + if( m_DrawColor[3] == 0 ) + return; + + float s0, t0, s1, t1; + TextureDictionary()->GetTextureTexCoords( m_iBoundTexture, s0, t0, s1, t1 ); + + float ssize = s1 - s0; + float tsize = t1 - t0; + + // Rescale tex values into range of s0 to s1 ,etc. + texs0 = s0 + texs0 * ( ssize ); + texs1 = s0 + texs1 * ( ssize ); + text0 = t0 + text0 * ( tsize ); + text1 = t0 + text1 * ( tsize ); + + vgui::Vertex_t rect[2]; + vgui::Vertex_t clippedRect[2]; + InitVertex( rect[0], x0, y0, texs0, text0 ); + InitVertex( rect[1], x1, y1, texs1, text1 ); + + // Fully clipped? + if ( !ClipRect(rect[0], rect[1], &clippedRect[0], &clippedRect[1]) ) + return; + + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + DrawQuad( clippedRect[0], clippedRect[1], m_DrawColor ); +} + +//----------------------------------------------------------------------------- +// Draws a textured polygon +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawTexturedPolygon(int n, Vertex_t *pVertices, bool bClipVertices /*= true*/ ) +{ + MAT_FUNC; + + Assert( !m_bIn3DPaintMode ); + + Assert( g_bInDrawing ); + + // Don't even bother drawing fully transparent junk + if( (n == 0) || (m_DrawColor[3]==0) ) + return; + + if ( bClipVertices ) + { + int iCount; + Vertex_t **ppClippedVerts = NULL; + iCount = ClipPolygon( n, pVertices, m_nTranslateX, m_nTranslateY, &ppClippedVerts ); + if (iCount <= 0) + return; + + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + + meshBuilder.Begin( m_pMesh, MATERIAL_POLYGON, iCount ); + + for (int i = 0; i < iCount; ++i) + { + meshBuilder.Position3f( ppClippedVerts[i]->m_Position.x, ppClippedVerts[i]->m_Position.y, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, ppClippedVerts[i]->m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + + meshBuilder.End(); + m_pMesh->Draw(); + } + else + { + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + + meshBuilder.Begin( m_pMesh, MATERIAL_POLYGON, n ); + + for (int i = 0; i < n; ++i) + { + meshBuilder.Position3f( pVertices[i].m_Position.x + m_nTranslateX, pVertices[i].m_Position.y + m_nTranslateY, m_flZPos ); + meshBuilder.Color4ubv( m_DrawColor ); + meshBuilder.TexCoord2fv( 0, pVertices[i].m_TexCoord.Base() ); + meshBuilder.AdvanceVertexF<VTX_HAVEPOS | VTX_HAVECOLOR, 1>(); + } + + meshBuilder.End(); + m_pMesh->Draw(); + } +} + + + +//----------------------------------------------------------------------------- +// +// Font-related methods begin here +// +//----------------------------------------------------------------------------- + + +//----------------------------------------------------------------------------- +// Purpose: creates a new empty font +//----------------------------------------------------------------------------- +HFont CMatSystemSurface::CreateFont() +{ + MAT_FUNC; + + return FontManager().CreateFont(); +} + +//----------------------------------------------------------------------------- +// Purpose: adds glyphs to a font created by CreateFont() +//----------------------------------------------------------------------------- +bool CMatSystemSurface::SetFontGlyphSet(HFont font, const char *windowsFontName, int tall, int weight, int blur, int scanlines, int flags, int nRangeMin, int nRangeMax) +{ + return FontManager().SetFontGlyphSet(font, windowsFontName, tall, weight, blur, scanlines, flags, nRangeMin, nRangeMax); +} + +//----------------------------------------------------------------------------- +// Purpose: adds glyphs to a font created by CreateFont() +//----------------------------------------------------------------------------- +bool CMatSystemSurface::SetBitmapFontGlyphSet(HFont font, const char *windowsFontName, float scalex, float scaley, int flags) +{ + return FontManager().SetBitmapFontGlyphSet(font, windowsFontName, scalex, scaley, flags); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the max height of a font +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetFontTall(HFont font) +{ + return FontManager().GetFontTall(font); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the requested height of a font +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetFontTallRequested(HFont font) +{ + return FontManager().GetFontTallRequested(font); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the max height of a font +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetFontAscent(HFont font, wchar_t wch) +{ + return FontManager().GetFontAscent(font,wch); +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : font - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CMatSystemSurface::IsFontAdditive(HFont font) +{ + return FontManager().IsFontAdditive(font); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the abc widths of a single character +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetCharABCwide(HFont font, int ch, int &a, int &b, int &c) +{ + FontManager().GetCharABCwide(font, ch, a, b, c); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the pixel width of a single character +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetCharacterWidth(HFont font, int ch) +{ + return FontManager().GetCharacterWidth(font, ch); +} + +//----------------------------------------------------------------------------- +// Purpose: returns the kerned width of this char +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetKernedCharWidth( HFont font, wchar_t ch, wchar_t chBefore, wchar_t chAfter, float &wide, float &abcA ) //, float &abcC ) +{ + float abcC = 0.0f; + FontManager().GetKernedCharWidth(font, ch, chBefore, chAfter, wide, abcA, abcC ); +} + + +//----------------------------------------------------------------------------- +// Purpose: returns the area of a text string, including newlines +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetTextSize(HFont font, const wchar_t *text, int &wide, int &tall) +{ + FontManager().GetTextSize(font, text, wide, tall); +} + +//----------------------------------------------------------------------------- +// Purpose: adds a custom font file (only supports true type font files (.ttf) for now) +//----------------------------------------------------------------------------- +bool CMatSystemSurface::AddCustomFontFile( const char *fontName, const char *fontFileName ) +{ + if ( IsX360() ) + { + // custom fonts are not supported (not needed) on xbox, all .vfonts are offline converted to ttfs + // ttfs are mounted/handled elsewhere + return true; + } + MAT_FUNC; + + char fullPath[MAX_PATH]; + bool bFound = false; + // windows needs an absolute path for ttf + bFound = g_pFullFileSystem->GetLocalPath( fontFileName, fullPath, sizeof( fullPath ) ); + if ( !bFound ) + { + Warning( "Couldn't find custom font file '%s'\n", fontFileName ); + return false; + } + + // only add if it's not already in the list + Q_strlower( fullPath ); + CUtlSymbol sym(fullPath); + int i; + for ( i = 0; i < m_CustomFontFileNames.Count(); i++ ) + { + if ( m_CustomFontFileNames[i] == sym ) + break; + } + if ( !m_CustomFontFileNames.IsValidIndex( i ) ) + { + m_CustomFontFileNames.AddToTail( fullPath ); + + if ( IsPC() ) + { + // make sure it's on disk + // only do this once for each font since in steam it will overwrite the + // registered font file, causing windows to invalidate the font + g_pFullFileSystem->GetLocalCopy( fullPath ); + } + } + + // try and use the optimal custom font loader, will makes sure fonts are unloaded properly + // this function is in a newer version of the gdi library (win2k+), so need to try get it directly +#if defined( WIN32 ) && !defined( _X360 ) + bool successfullyAdded = false; + HMODULE gdiModule = ::LoadLibrary("gdi32.dll"); + if (gdiModule) + { + typedef int (WINAPI *AddFontResourceExProc)(LPCTSTR, DWORD, PVOID); + AddFontResourceExProc pAddFontResourceEx = (AddFontResourceExProc)::GetProcAddress(gdiModule, "AddFontResourceExA"); + if (pAddFontResourceEx) + { + int result = (*pAddFontResourceEx)(fullPath, 0x10, NULL); + if (result > 0) + { + successfullyAdded = true; + } + } + ::FreeLibrary(gdiModule); + } + + // add to windows + bool success = successfullyAdded || (::AddFontResource(fullPath) > 0); + if ( !success ) + { + Msg( "Failed to load custom font file '%s'\n", fullPath ); + } + Assert( success ); + return success; +#elif OSX + + FSRef ref; + OSStatus err = FSPathMakeRef( (const UInt8*)fullPath, &ref, NULL ); + if ( err == noErr ) + err = ATSFontActivateFromFileReference( &ref, kATSFontContextLocal, kATSFontFormatUnspecified, NULL, kATSOptionFlagsDefault, NULL ); + + return err == noErr; + +#elif LINUX + + int size; + if ( CMatSystemSurface::FontDataHelper( fontName, size, fontFileName ) ) + return true; + return false; + +#elif defined( _X360 ) +#include "xbox/xbox_win32stubs.h" +#else +#error +#endif +} + +#ifdef LINUX + +static void RemoveSpaces( CUtlString &str ) +{ + char *dst = str.GetForModify(); + + for( int i = 0; i < str.Length(); i++ ) + { + if( ( str[ i ] != ' ' ) && ( str[ i ] != '-' ) ) + { + *dst++ = str[ i ]; + } + } + + *dst = 0; +} + +void *CMatSystemSurface::FontDataHelper( const char *pchFontName, int &size, const char *fontFileName ) +{ + size = 0; + + if( fontFileName ) + { + // If we were given a fontFileName, then load that bugger and shove it in the cache. + + // Just load the font data, decrypt in memory and register for this process + CUtlBuffer buf; + if ( !g_pFullFileSystem->ReadFile( fontFileName, NULL, buf ) ) + { + Msg( "Failed to load custom font file '%s'\n", fontFileName ); + return NULL; + } + + FT_Face face; + const FT_Error error = FT_New_Memory_Face( FontManager().GetFontLibraryHandle(), (FT_Byte *)buf.Base(), buf.TellPut(), 0, &face ); + + if ( error ) + { + // FT_Err_Unknown_File_Format, etc. + Msg( "ERROR %d: UNABLE TO LOAD FONT FILE %s\n", error, fontFileName ); + return NULL; + } + + if( !pchFontName ) + { + // If we weren't passed a font name for this thing, then use the one from the face. + pchFontName = face->family_name; + if ( !pchFontName || !pchFontName[ 0 ] ) + { + pchFontName = FT_Get_Postscript_Name( face ); + } + } + + // Replace spaces and dashes with underscores. + CUtlString strFontName( pchFontName ); + RemoveSpaces( strFontName ); + + font_entry entry; + entry.size = buf.TellPut(); + entry.data = malloc( entry.size ); + memcpy( entry.data, buf.Base(), entry.size ); + m_FontData.Insert( strFontName.Get(), entry ); + + FT_Done_Face( face ); + + size = entry.size; + return entry.data; + } + else + { + // Replace spaces and dashes with underscores. + CUtlString strFontName( pchFontName ); + RemoveSpaces( strFontName ); + + int iIndex = m_FontData.Find( strFontName.Get() ); + if ( iIndex != m_FontData.InvalidIndex() ) + { + size = m_FontData[ iIndex ].size; + return m_FontData[ iIndex ].data; + } + } + + return NULL; +} + +#endif // LINUX + +//----------------------------------------------------------------------------- +// Purpose: adds a bitmap font file +//----------------------------------------------------------------------------- +bool CMatSystemSurface::AddBitmapFontFile( const char *fontFileName ) +{ + MAT_FUNC; + + bool bFound = false; + bFound = ( ( g_pFullFileSystem->GetDVDMode() == DVDMODE_STRICT ) || g_pFullFileSystem->FileExists( fontFileName, IsX360() ? "GAME" : NULL ) ); + if ( !bFound ) + { + Msg( "Couldn't find bitmap font file '%s'\n", fontFileName ); + return false; + } + char path[MAX_PATH]; + Q_strncpy( path, fontFileName, MAX_PATH ); + + // only add if it's not already in the list + Q_strlower( path ); + CUtlSymbol sym( path ); + int i; + for ( i = 0; i < m_BitmapFontFileNames.Count(); i++ ) + { + if ( m_BitmapFontFileNames[i] == sym ) + break; + } + if ( !m_BitmapFontFileNames.IsValidIndex( i ) ) + { + m_BitmapFontFileNames.AddToTail( path ); + + if ( IsPC() ) + { + // make sure it's on disk + // only do this once for each font since in steam it will overwrite the + // registered font file, causing windows to invalidate the font + g_pFullFileSystem->GetLocalCopy( path ); + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetBitmapFontName( const char *pName, const char *pFontFilename ) +{ + char fontPath[MAX_PATH]; + Q_strncpy( fontPath, pFontFilename, MAX_PATH ); + Q_strlower( fontPath ); + + CUtlSymbol sym( fontPath ); + int i; + for (i = 0; i < m_BitmapFontFileNames.Count(); i++) + { + if ( m_BitmapFontFileNames[i] == sym ) + { + // found it, update the mapping + int index = m_BitmapFontFileMapping.Find( pName ); + if ( !m_BitmapFontFileMapping.IsValidIndex( index ) ) + { + index = m_BitmapFontFileMapping.Insert( pName ); + } + m_BitmapFontFileMapping.Element( index ) = i; + break; + } + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +const char *CMatSystemSurface::GetBitmapFontName( const char *pName ) +{ + // find it in the mapping symbol table + int index = m_BitmapFontFileMapping.Find( pName ); + if ( index == m_BitmapFontFileMapping.InvalidIndex() ) + { + return ""; + } + + return m_BitmapFontFileNames[m_BitmapFontFileMapping.Element( index )].String(); +} + +void CMatSystemSurface::ClearTemporaryFontCache( void ) +{ + FontManager().ClearTemporaryFontCache(); +} + +//----------------------------------------------------------------------------- +// Purpose: Force a set of characters to be rendered into the font page. +//----------------------------------------------------------------------------- +void CMatSystemSurface::PrecacheFontCharacters( HFont font, const wchar_t *pCharacterString ) +{ + wchar_t *pCommonChars = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,.!:-/%"; + MAT_FUNC; + + if ( !pCharacterString || !pCharacterString[0] ) + { + // use the common chars, alternate languages are not handled + pCharacterString = pCommonChars; + } + + StartDrawing(); + DrawSetTextFont( font ); + + int numChars = 0; + while( pCharacterString[ numChars ] ) + { + numChars++; + } + int *pTextureIDs_ignored = (int *)_alloca( numChars*sizeof( int ) ); + float **pTexCoords_ignored = (float **)_alloca( numChars*sizeof( float * ) ); + g_FontTextureCache.GetTextureForChars( m_hCurrentFont, FONT_DRAW_DEFAULT, pCharacterString, pTextureIDs_ignored, pTexCoords_ignored, numChars ); + + FinishDrawing(); +} + +const char *CMatSystemSurface::GetFontName( HFont font ) +{ + return FontManager().GetFontName( font ); +} + +const char *CMatSystemSurface::GetFontFamilyName( HFont font ) +{ + return FontManager().GetFontFamilyName( font ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextFont(HFont font) +{ + Assert( g_bInDrawing ); + + m_hCurrentFont = font; +} + +//----------------------------------------------------------------------------- +// Purpose: Renders any batched up text +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFlushText() +{ + if ( !m_nBatchedCharVertCount ) + return; + + { + // don't log entry unless actual work happens.. + MAT_FUNC; + + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(m_iBoundTexture); + InternalSetMaterial( pMaterial ); + DrawQuadArray( m_nBatchedCharVertCount / 2, m_BatchedCharVerts, m_DrawTextColor ); + m_nBatchedCharVertCount = 0; + } +} + +//----------------------------------------------------------------------------- +// Sets the text color +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextColor(int r, int g, int b, int a) +{ + int adjustedAlpha = (a * m_flAlphaMultiplier); + + if ( r != m_DrawTextColor[0] || g != m_DrawTextColor[1] || b != m_DrawTextColor[2] || adjustedAlpha != m_DrawTextColor[3] ) + { + // text color changed, flush any existing text + DrawFlushText(); + + m_DrawTextColor[0] = (unsigned char)r; + m_DrawTextColor[1] = (unsigned char)g; + m_DrawTextColor[2] = (unsigned char)b; + m_DrawTextColor[3] = (unsigned char)adjustedAlpha; + } +} + +//----------------------------------------------------------------------------- +// Purpose: alternate color set +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextColor(Color col) +{ + DrawSetTextColor(col[0], col[1], col[2], col[3]); +} + +//----------------------------------------------------------------------------- +// Purpose: change the scale of a bitmap font +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextScale(float sx, float sy) +{ + FontManager().SetFontScale( m_hCurrentFont, sx, sy ); +} + +//----------------------------------------------------------------------------- +// Text rendering location +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetTextPos(int x, int y) +{ + Assert( g_bInDrawing ); + + m_pDrawTextPos[0] = x; + m_pDrawTextPos[1] = y; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawGetTextPos(int& x,int& y) +{ + Assert( g_bInDrawing ); + + x = m_pDrawTextPos[0]; + y = m_pDrawTextPos[1]; +} + +#pragma warning( disable : 4706 ) +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawUnicodeString( const wchar_t *pString, FontDrawType_t drawType /*= FONT_DRAW_DEFAULT */ ) +{ + // skip fully transparent characters + if ( m_DrawTextColor[3] == 0 ) + return; + + //hushed MAT_FUNC; +#ifdef POSIX + DrawPrintText( pString, V_wcslen( pString ) , drawType ); +#else + wchar_t ch; + + while ( ( ch = *pString++ ) ) + { + DrawUnicodeChar( ch ); + } +#endif +} +#pragma warning( default : 4706 ) + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawUnicodeChar(wchar_t ch, FontDrawType_t drawType /*= FONT_DRAW_DEFAULT */ ) +{ + // skip fully transparent characters + if ( m_DrawTextColor[3] == 0 ) + return; + //hushed MAT_FUNC; + + CharRenderInfo info; + info.drawType = drawType; + if ( DrawGetUnicodeCharRenderInfo( ch, info ) ) + { + DrawRenderCharFromInfo( info ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CMatSystemSurface::DrawGetUnicodeCharRenderInfo( wchar_t ch, CharRenderInfo& info ) +{ + //hushed MAT_FUNC; + + Assert( g_bInDrawing ); + info.valid = false; + + if ( !m_hCurrentFont ) + { + return info.valid; + } + + PREFETCH360( &m_BatchedCharVerts[ m_nBatchedCharVertCount ], 0 ); + + info.valid = true; + info.ch = ch; + DrawGetTextPos(info.x, info.y); + + info.currentFont = m_hCurrentFont; + info.fontTall = GetFontTall(m_hCurrentFont); + + GetCharABCwide(m_hCurrentFont, ch, info.abcA, info.abcB, info.abcC); + bool bUnderlined = FontManager().GetFontUnderlined( m_hCurrentFont ); + + // Do prestep before generating texture coordinates, etc. + if ( !bUnderlined ) + { + info.x += info.abcA; + } + + // get the character texture from the cache + info.textureId = 0; + float *texCoords = NULL; + if (!g_FontTextureCache.GetTextureForChar(m_hCurrentFont, info.drawType, ch, &info.textureId, &texCoords)) + { + info.valid = false; + return info.valid; + } + + int fontWide = info.abcB; + if ( bUnderlined ) + { + fontWide += ( info.abcA + info.abcC ); + info.x-= info.abcA; + } + + // Because CharRenderInfo has a pointer to the verts, we need to keep m_BatchedCharVerts in sync, so if we + // will be flushing the text when we get to this char, flush it now instead. + if ( info.textureId != m_iBoundTexture ) + { + DrawFlushText(); + } + + // This avoid copying the data in the nonclipped case!!! (X360) + info.verts = &m_BatchedCharVerts[ m_nBatchedCharVertCount ]; + InitVertex( info.verts[0], info.x, info.y, texCoords[0], texCoords[1] ); + InitVertex( info.verts[1], info.x + fontWide, info.y + info.fontTall, texCoords[2], texCoords[3] ); + + info.shouldclip = true; + + return info.valid; +} + +//----------------------------------------------------------------------------- +// Purpose: batches up characters for rendering +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawRenderCharInternal( const CharRenderInfo& info ) +{ + //hushed MAT_FUNC; + + Assert( g_bInDrawing ); + + // xbox opts out of pricey/pointless text clipping + if ( IsPC() && info.shouldclip ) + { + Vertex_t clip[ 2 ]; + clip[ 0 ] = info.verts[ 0 ]; + clip[ 1 ] = info.verts[ 1 ]; + if ( !ClipRect( clip[0], clip[1], &info.verts[0], &info.verts[1] ) ) + { + // Fully clipped + return; + } + } + + m_nBatchedCharVertCount += 2; + + if ( m_nBatchedCharVertCount >= MAX_BATCHED_CHAR_VERTS - 2 ) + { + DrawFlushText(); + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawRenderCharFromInfo( const CharRenderInfo& info ) +{ + //hushed MAT_FUNC; + + if ( !info.valid ) + return; + + int x = info.x; + + // get the character texture from the cache + DrawSetTexture( info.textureId ); + + DrawRenderCharInternal( info ); + + // Only do post step + x += ( info.abcB + info.abcC ); + + // Update cursor pos + DrawSetTextPos(x, info.y); +} + +//----------------------------------------------------------------------------- +// Renders a text buffer +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawPrintText(const wchar_t *text, int iTextLen, FontDrawType_t drawType /*= FONT_DRAW_DEFAULT */ ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + if (!text) + return; + + if (!m_hCurrentFont) + return; + + int x = m_pDrawTextPos[0] + m_nTranslateX; + int y = m_pDrawTextPos[1] + m_nTranslateY; + + int iTall = GetFontTall(m_hCurrentFont); + int iLastTexId = -1; + + int iCount = 0; + vgui::Vertex_t *pQuads = (vgui::Vertex_t*)stackalloc((2 * iTextLen) * sizeof(vgui::Vertex_t) ); + bool bUnderlined = FontManager().GetFontUnderlined( m_hCurrentFont ); + + int iTotalWidth = 0; + for (int i=0; i<iTextLen; ++i) + { + wchar_t ch = text[i]; + +#if USE_GETKERNEDCHARWIDTH + //iTotalWidth += abcA; + float flWide; + float flabcA; + float flabcC; + wchar_t chBefore = 0; + wchar_t chAfter = 0; + if ( i > 0 ) + chBefore = text[i-1]; + if ( i < (iTextLen-1) ) + chAfter = text[i+1]; + FontManager().GetKernedCharWidth( m_hCurrentFont, ch, chBefore, chAfter, flWide, flabcA, flabcC ); + + int abcA,abcB,abcC; + // also grab the single char dimensions so we match the texture size to the one in the font page, + // different to the amount we step ahead once rendered + GetCharABCwide(m_hCurrentFont, ch, abcA, abcB, abcC); + + int textureWide = abcB; + if ( bUnderlined ) + { + textureWide += ( abcA + abcC ); + x-= flabcA; + } +#else + int abcA,abcB,abcC; + GetCharABCwide(m_hCurrentFont, ch, abcA, abcB, abcC); + int textureWide = abcB; + if ( bUnderlined ) + { + textureWide += ( abcA + abcC ); + x-= abcA; + } + float flabcA = abcA; + float flWide = abcA + abcB + abcC; +#endif + + if ( !iswspace( ch ) || bUnderlined ) + { + // get the character texture from the cache + int iTexId = 0; + float *texCoords = NULL; + if (!g_FontTextureCache.GetTextureForChar(m_hCurrentFont, drawType, ch, &iTexId, &texCoords)) + continue; + + Assert( texCoords ); + + if (iTexId != iLastTexId) + { + // FIXME: At the moment, we just draw all the batched up + // text when the font changes. We Should batch up per material + // and *then* draw + if (iCount) + { + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(iLastTexId); + InternalSetMaterial( pMaterial ); + DrawQuadArray( iCount, pQuads, m_DrawTextColor, IsPC() ); + iCount = 0; + } + + iLastTexId = iTexId; + } + + vgui::Vertex_t &ul = pQuads[2*iCount]; + vgui::Vertex_t &lr = pQuads[2*iCount + 1]; + ++iCount; + + ul.m_Position.x = x + iTotalWidth + floor(flabcA + 0.6); + ul.m_Position.y = y; + lr.m_Position.x = ul.m_Position.x + textureWide; + lr.m_Position.y = ul.m_Position.y + iTall; + + // Gets at the texture coords for this character in its texture page + /* + float tex_U0_bias = prc->Knob("tex-U0-bias"); + float tex_V0_bias = prc->Knob("tex-V0-bias"); + float tex_U1_bias = prc->Knob("tex-U1-bias"); + float tex_V1_bias = prc->Knob("tex-V1-bias"); + + ul.m_TexCoord[0] = texCoords[0] + tex_U0_bias; + ul.m_TexCoord[1] = texCoords[1] + tex_V0_bias; + lr.m_TexCoord[0] = texCoords[2] + tex_U1_bias; + lr.m_TexCoord[1] = texCoords[3] + tex_V1_bias; + */ + + ul.m_TexCoord[0] = texCoords[0]; + ul.m_TexCoord[1] = texCoords[1]; + lr.m_TexCoord[0] = texCoords[2]; + lr.m_TexCoord[1] = texCoords[3]; + } + + iTotalWidth += floor(flWide+0.6); + } + + // Draw any left-over characters + if (iCount) + { + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial(iLastTexId); + InternalSetMaterial( pMaterial ); + DrawQuadArray( iCount, pQuads, m_DrawTextColor, IsPC() ); + } + + m_pDrawTextPos[0] += iTotalWidth; + + stackfree(pQuads); +} + + +//----------------------------------------------------------------------------- +// Returns the screen size +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetScreenSize(int &iWide, int &iTall) +{ + if ( m_ScreenSizeOverride.m_bActive ) + { + iWide = m_ScreenSizeOverride.m_nValue[ 0 ]; + iTall = m_ScreenSizeOverride.m_nValue[ 1 ]; + return; + } + + int x, y; + + // mikesart: This is just sticking in unnecessary BeginRender/EndRender calls to the queue. + // CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + IMatRenderContext *pRenderContext = g_pMaterialSystem->GetRenderContext(); + pRenderContext->GetViewport( x, y, iWide, iTall ); +} + +bool CMatSystemSurface::ForceScreenSizeOverride( bool bState, int wide, int tall ) +{ + bool bWasSet = m_ScreenSizeOverride.m_bActive; + m_ScreenSizeOverride.m_bActive = bState; + m_ScreenSizeOverride.m_nValue[ 0 ] = wide; + m_ScreenSizeOverride.m_nValue[ 1 ] = tall; + return bWasSet; +} + +// LocalToScreen, ParentLocalToScreen fixups for explicit PaintTraverse calls on Panels not at 0, 0 position +bool CMatSystemSurface::ForceScreenPosOffset( bool bState, int x, int y ) +{ + bool bWasSet = m_ScreenPosOverride.m_bActive; + m_ScreenPosOverride.m_bActive = bState; + m_ScreenPosOverride.m_nValue[ 0 ] = x; + m_ScreenPosOverride.m_nValue[ 1 ] = y; + return bWasSet; +} + +void CMatSystemSurface::OffsetAbsPos( int &x, int &y ) +{ + if ( !m_ScreenPosOverride.m_bActive ) + return; + + x += m_ScreenPosOverride.m_nValue[ 0 ]; + y += m_ScreenPosOverride.m_nValue[ 1 ]; +} + + +bool CMatSystemSurface::IsScreenSizeOverrideActive( void ) +{ + return ( m_ScreenSizeOverride.m_bActive ); +} + +bool CMatSystemSurface::IsScreenPosOverrideActive( void ) +{ + return ( m_ScreenPosOverride.m_bActive ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Notification of a new screen size +//----------------------------------------------------------------------------- +void CMatSystemSurface::OnScreenSizeChanged( int nOldWidth, int nOldHeight ) +{ + int iNewWidth, iNewHeight; + GetScreenSize( iNewWidth, iNewHeight ); + + Msg( "Changing resolutions from (%d, %d) -> (%d, %d)\n", nOldWidth, nOldHeight, iNewWidth, iNewHeight ); + + // update the root panel size + ipanel()->SetSize(m_pEmbeddedPanel, iNewWidth, iNewHeight); + + // notify every panel + VPANEL panel = GetEmbeddedPanel(); + ivgui()->PostMessage(panel, new KeyValues("OnScreenSizeChanged", "oldwide", nOldWidth, "oldtall", nOldHeight), NULL); + + // Run a frame of the GUI to notify all subwindows of the message size change + ivgui()->RunFrame(); + + // clear font texture cache + ResetFontCaches(); +} + +// Causes fonts to get reloaded, etc. +void CMatSystemSurface::ResetFontCaches() +{ + // Don't do this on x360!!! + if ( IsX360() ) + return; + + // clear font texture cache + g_FontTextureCache.Clear(); + m_iBoundTexture = -1; + + // reload fonts + FontManager().ClearAllFonts(); + scheme()->ReloadFonts(); + + // Run a frame of the GUI to notify all subwindows of the message size change + ivgui()->RunFrame(); +} + +//----------------------------------------------------------------------------- +// Returns the size of the embedded panel +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetWorkspaceBounds(int &x, int &y, int &iWide, int &iTall) +{ + if ( m_ScreenSizeOverride.m_bActive ) + { + x = y = 0; + iWide = m_ScreenSizeOverride.m_nValue[ 0 ]; + iTall = m_ScreenSizeOverride.m_nValue[ 1 ]; + return; + } + // NOTE: This is equal to the viewport size by default, + // but other embedded panels can be used + x = m_WorkSpaceInsets[0]; + y = m_WorkSpaceInsets[1]; + g_pVGuiPanel->GetSize(m_pEmbeddedPanel, iWide, iTall); + + iWide -= m_WorkSpaceInsets[2]; + iTall -= m_WorkSpaceInsets[3]; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetWorkspaceInsets( int left, int top, int right, int bottom ) +{ + m_WorkSpaceInsets[0] = left; + m_WorkSpaceInsets[1] = top; + m_WorkSpaceInsets[2] = right; + m_WorkSpaceInsets[3] = bottom; +} + +//----------------------------------------------------------------------------- +// A bunch of methods needed for the windows version only +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetAsTopMost(VPANEL panel, bool state) +{ +} + +void CMatSystemSurface::SetAsToolBar(VPANEL panel, bool state) // removes the window's task bar entry (for context menu's, etc.) +{ +} + +void CMatSystemSurface::SetForegroundWindow (VPANEL panel) +{ + BringToFront(panel); +} + +void CMatSystemSurface::SetPanelVisible(VPANEL panel, bool state) +{ +} + +void CMatSystemSurface::SetMinimized(VPANEL panel, bool state) +{ + if (state) + { + g_pVGuiPanel->SetPlat(panel, VPANEL_MINIMIZED); + g_pVGuiPanel->SetVisible(panel, false); + } + else + { + g_pVGuiPanel->SetPlat(panel, VPANEL_NORMAL); + } +} + +bool CMatSystemSurface::IsMinimized(vgui::VPANEL panel) +{ + return (g_pVGuiPanel->Plat(panel) == VPANEL_MINIMIZED); + +} + +void CMatSystemSurface::FlashWindow(VPANEL panel, bool state) +{ +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetTitle(VPANEL panel, const wchar_t *title) +{ + int entry = GetTitleEntry( panel ); + if ( entry == -1 ) + { + entry = m_Titles.AddToTail(); + } + + TitleEntry *e = &m_Titles[ entry ]; + Assert( e ); + wcsncpy( e->title, title, sizeof( e->title )/ sizeof( wchar_t ) ); + e->panel = panel; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +wchar_t const *CMatSystemSurface::GetTitle( VPANEL panel ) +{ + int entry = GetTitleEntry( panel ); + if ( entry != -1 ) + { + TitleEntry *e = &m_Titles[ entry ]; + return e->title; + } + + return NULL; +} + +//----------------------------------------------------------------------------- +// Purpose: Private lookup method +// Input : *panel - +// Output : TitleEntry +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetTitleEntry( vgui::VPANEL panel ) +{ + for ( int i = 0; i < m_Titles.Count(); i++ ) + { + TitleEntry* entry = &m_Titles[ i ]; + if ( entry->panel == panel ) + return i; + } + return -1; +} + +void CMatSystemSurface::SwapBuffers(VPANEL panel) +{ +} + +void CMatSystemSurface::Invalidate(VPANEL panel) +{ +} + +void CMatSystemSurface::ApplyChanges() +{ +} + +// notify icons?!? +VPANEL CMatSystemSurface::GetNotifyPanel() +{ + return NULL; +} + +void CMatSystemSurface::SetNotifyIcon(VPANEL context, HTexture icon, VPANEL panelToReceiveMessages, const char *text) +{ +} + +bool CMatSystemSurface::IsWithin(int x, int y) +{ + return true; +} + +bool CMatSystemSurface::ShouldPaintChildPanel(VPANEL childPanel) +{ + if ( m_pRestrictedPanel && ( m_pRestrictedPanel != childPanel ) && + !g_pVGuiPanel->HasParent( childPanel, m_pRestrictedPanel ) ) + { + return false; + } + + bool isPopup = ipanel()->IsPopup(childPanel); + return !isPopup; +} + +bool CMatSystemSurface::RecreateContext(VPANEL panel) +{ + return false; +} + +//----------------------------------------------------------------------------- +// Focus-related methods +//----------------------------------------------------------------------------- +bool CMatSystemSurface::HasFocus() +{ + return true; +} + +void CMatSystemSurface::BringToFront(VPANEL panel) +{ + // move panel to top of list + g_pVGuiPanel->MoveToFront(panel); + + // move panel to top of popup list + if ( g_pVGuiPanel->IsPopup( panel ) ) + { + MovePopupToFront( panel ); + } +} + + +// engine-only focus handling (replacing WM_FOCUS windows handling) +void CMatSystemSurface::SetTopLevelFocus(VPANEL pSubFocus) +{ + // walk up the hierarchy until we find what popup panel belongs to + while (pSubFocus) + { + if (ipanel()->IsPopup(pSubFocus) && ipanel()->IsMouseInputEnabled(pSubFocus)) + { + BringToFront(pSubFocus); + break; + } + + pSubFocus = ipanel()->GetParent(pSubFocus); + } +} + + +//----------------------------------------------------------------------------- +// Installs a function to play sounds +//----------------------------------------------------------------------------- +void CMatSystemSurface::InstallPlaySoundFunc( PlaySoundFunc_t soundFunc ) +{ + m_PlaySoundFunc = soundFunc; +} + + +//----------------------------------------------------------------------------- +// plays a sound +//----------------------------------------------------------------------------- +void CMatSystemSurface::PlaySound(const char *pFileName) +{ + if (m_PlaySoundFunc) + m_PlaySoundFunc( pFileName ); +} + + +//----------------------------------------------------------------------------- +// handles mouse movement +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetCursorPos(int x, int y) +{ + CursorSetPos( m_HWnd, x, y ); +} + +void CMatSystemSurface::GetCursorPos(int &x, int &y) +{ + CursorGetPos( m_HWnd, x, y ); +} + +void CMatSystemSurface::SetCursor(HCursor hCursor) +{ + if ( IsCursorLocked() ) + return; + + if ( _currentCursor != hCursor ) + { + _currentCursor = hCursor; + CursorSelect( hCursor ); + } +} + +void CMatSystemSurface::EnableMouseCapture( VPANEL panel, bool state ) +{ +#ifdef WIN32 + if ( state ) + { + ::SetCapture( reinterpret_cast< HWND >( m_HWnd ) ); + } + else + { + ::ReleaseCapture(); + } +#elif defined( POSIX ) + // SetCapture on Win32 makes all the mouse messages (move and button up/down) head to + // the captured window. From what I can tell, this routine is called for modal dialogs + // when you click down on a button. However the current behavior is to highlight the + // buttons when you're over them, and trigger when you mouse up over the top - so I + // don't believe that SetCapture is needed on Windows, and Linux is behaving exactly + // the same as Win32 in all the tests I've run so far. (I've clicked on a lot of dialogs). + // I talked with Alfred about this and we haven't done any SetCapture stuff on OSX ever + // and he says nobody has ever reported any regressions. + // So I've removed the Assert. 8/32/2012 - mikesart. +#else +#error +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: Turns the panel into a standalone window +//----------------------------------------------------------------------------- +void CMatSystemSurface::CreatePopup(VPANEL panel, bool minimized, bool showTaskbarIcon, bool disabled , bool mouseInput , bool kbInput) +{ + if (!g_pVGuiPanel->GetParent(panel)) + { + g_pVGuiPanel->SetParent(panel, GetEmbeddedPanel()); + } + ((VPanel *)panel)->SetPopup(true); + ((VPanel *)panel)->SetKeyBoardInputEnabled(kbInput); + ((VPanel *)panel)->SetMouseInputEnabled(mouseInput); + + HPanel p = ivgui()->PanelToHandle( panel ); + + if ( m_PopupList.Find( p ) == m_PopupList.InvalidIndex() ) + { + m_PopupList.AddToTail( p ); + } + else + { + MovePopupToFront( panel ); + } +} + + +//----------------------------------------------------------------------------- +// Create/destroy panels.. +//----------------------------------------------------------------------------- +void CMatSystemSurface::AddPanel(VPANEL panel) +{ + if (g_pVGuiPanel->IsPopup(panel)) + { + // turn it into a popup menu + CreatePopup(panel, false); + } +} + +void CMatSystemSurface::ReleasePanel(VPANEL panel) +{ + // Remove from popup list if needed and remove any dead popups while we're at it + RemovePopup( panel ); + + int entry = GetTitleEntry( panel ); + if ( entry != -1 ) + { + m_Titles.Remove( entry ); + } +} + + +//----------------------------------------------------------------------------- +// Popup accessors used by VGUI +//----------------------------------------------------------------------------- +int CMatSystemSurface::GetPopupCount( ) +{ + return m_PopupList.Count(); +} + +VPANEL CMatSystemSurface::GetPopup( int index ) +{ + HPanel p = m_PopupList[ index ]; + VPANEL panel = ivgui()->HandleToPanel( p ); + return panel; +} + +void CMatSystemSurface::ResetPopupList( ) +{ + m_PopupList.RemoveAll(); +} + +void CMatSystemSurface::AddPopup( VPANEL panel ) +{ + HPanel p = ivgui()->PanelToHandle( panel ); + + if ( m_PopupList.Find( p ) == m_PopupList.InvalidIndex() ) + { + m_PopupList.AddToTail( p ); + } +} + + +void CMatSystemSurface::RemovePopup( vgui::VPANEL panel ) +{ + // Remove from popup list if needed and remove any dead popups while we're at it + int c = GetPopupCount(); + + for ( int i = c - 1; i >= 0 ; i-- ) + { + VPANEL popup = GetPopup(i ); + if ( popup && ( popup != panel ) ) + continue; + + m_PopupList.Remove( i ); + break; + } +} + +//----------------------------------------------------------------------------- +// Methods associated with iterating + drawing the panel tree +//----------------------------------------------------------------------------- +void CMatSystemSurface::AddPopupsToList( VPANEL panel ) +{ + if (!g_pVGuiPanel->IsVisible(panel)) + return; + + // Add to popup list as we visit popups + // Note: popup list is cleared in RunFrame which occurs before this call!!! + if ( g_pVGuiPanel->IsPopup( panel ) ) + { + AddPopup( panel ); + } + + int count = g_pVGuiPanel->GetChildCount(panel); + for (int i = 0; i < count; ++i) + { + VPANEL child = g_pVGuiPanel->GetChild(panel, i); + AddPopupsToList( child ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: recurses the panels calculating absolute positions +// parents must be solved before children +//----------------------------------------------------------------------------- +void CMatSystemSurface::InternalSolveTraverse(VPANEL panel) +{ + VPanel * RESTRICT vp = (VPanel *)panel; + + vp->TraverseLevel( 1 ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - %s", __FUNCTION__, vp->GetName() ); + + // solve the parent + vp->Solve(); + + CUtlVector< VPanel * > &children = vp->GetChildren(); + + // WARNING: Some of the think functions add/remove children, so make sure we + // explicitly check for children.Count(). + for ( int i = 0; i < children.Count(); ++i ) + { + VPanel *child = children[ i ]; + if (child->IsVisible()) + { + InternalSolveTraverse( (VPANEL)child ); + } + } + + vp->TraverseLevel( -1 ); +} + +//----------------------------------------------------------------------------- +// Purpose: recurses the panels giving them a chance to do a user-defined think, +// PerformLayout and ApplySchemeSettings +// must be done child before parent +//----------------------------------------------------------------------------- +void CMatSystemSurface::InternalThinkTraverse(VPANEL panel) +{ + VPanel * RESTRICT vp = (VPanel *)panel; + + vp->TraverseLevel( 1 ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - %s", __FUNCTION__, vp->GetName() ); + + // think the parent + vp->Client()->Think(); + + CUtlVector< VPanel * > &children = vp->GetChildren(); + + // WARNING: Some of the think functions add/remove children, so make sure we + // explicitly check for children.Count(). + for ( int i = 0; i < children.Count(); ++i ) + { + VPanel *child = children[ i ]; + if ( child->IsVisible() ) + { + InternalThinkTraverse( (VPANEL)child ); + } + } + + vp->TraverseLevel( -1 ); +} + +//----------------------------------------------------------------------------- +// Purpose: recurses the panels giving them a chance to do apply settings, +//----------------------------------------------------------------------------- +void CMatSystemSurface::InternalSchemeSettingsTraverse(VPANEL panel, bool forceApplySchemeSettings) +{ + VPanel * RESTRICT vp = (VPanel *)panel; + + vp->TraverseLevel( 1 ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - %s", __FUNCTION__, vp->GetName() ); + + CUtlVector< VPanel * > &children = vp->GetChildren(); + + // apply to the children... + for ( int i = 0; i < children.Count(); ++i ) + { + VPanel *child = children[ i ]; + if ( forceApplySchemeSettings || child->IsVisible() ) + { + InternalSchemeSettingsTraverse((VPANEL)child, forceApplySchemeSettings); + } + } + // and then the parent + vp->Client()->PerformApplySchemeSettings(); + + vp->TraverseLevel( -1 ); +} + +//----------------------------------------------------------------------------- +// Purpose: Walks through the panel tree calling Solve() on them all, in order +//----------------------------------------------------------------------------- +void CMatSystemSurface::SolveTraverse(VPANEL panel, bool forceApplySchemeSettings) +{ + { + VPROF( "InternalSchemeSettingsTraverse" ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - InternalSchemeSettingsTraverse", __FUNCTION__ ); + InternalSchemeSettingsTraverse(panel, forceApplySchemeSettings); + } + + { + VPROF( "InternalThinkTraverse" ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - InternalThinkTraverse", __FUNCTION__ ); + InternalThinkTraverse(panel); + } + + { + VPROF( "InternalSolveTraverse" ); + tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s - InternalSolveTraverse", __FUNCTION__ ); + InternalSolveTraverse(panel); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Restricts rendering to a single panel +//----------------------------------------------------------------------------- +void CMatSystemSurface::RestrictPaintToSinglePanel(VPANEL panel) +{ + if ( panel && m_pRestrictedPanel && m_pRestrictedPanel == input()->GetAppModalSurface() ) + { + return; // don't restrict drawing to a panel other than the modal one - that's a good way to hang the game. + } + + m_pRestrictedPanel = panel; + + if ( !input()->GetAppModalSurface() ) + { + input()->SetAppModalSurface( panel ); // if painting is restricted to this panel, it had better be modal, or else you can get in some bad state... + } +} + + +//----------------------------------------------------------------------------- +// Is a panel under the restricted panel? +//----------------------------------------------------------------------------- +bool CMatSystemSurface::IsPanelUnderRestrictedPanel( VPANEL panel ) +{ + if ( !m_pRestrictedPanel ) + return true; + + while ( panel ) + { + if ( panel == m_pRestrictedPanel ) + return true; + + panel = ipanel()->GetParent( panel ); + } + return false; +} + + +//----------------------------------------------------------------------------- +// Main entry point for painting +//----------------------------------------------------------------------------- +void CMatSystemSurface::PaintTraverseEx(VPANEL panel, bool paintPopups /*= false*/ ) +{ + MAT_FUNC; + + if ( !ipanel()->IsVisible( panel ) ) + return; + + VPROF( "CMatSystemSurface::PaintTraverse" ); + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + bool bTopLevelDraw = false; + + if ( g_bInDrawing == false ) + { + // only set the 2d ortho mode once + bTopLevelDraw = true; + StartDrawing(); + + // clear z + stencil buffer + // NOTE: Stencil is used to get 3D painting in vgui panels working correctly + pRenderContext->ClearBuffers( false, true, true ); + pRenderContext->SetStencilEnable( true ); + pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE ); + pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_GREATEREQUAL ); + pRenderContext->SetStencilReferenceValue( 0 ); + pRenderContext->SetStencilTestMask( 0xFFFFFFFF ); + pRenderContext->SetStencilWriteMask( 0xFFFFFFFF ); + } + + float flOldZPos = m_flZPos; + + // NOTE You might expect we'd have to draw these under the popups so they would occlude + // them, but there are a few things we do have to draw on top of, esp. the black + // panel that draws over the top of the engine to darken everything. + m_flZPos = 0.0f; + if ( panel == GetEmbeddedPanel() ) + { + if ( m_pRestrictedPanel ) + { + // Paint the restricted panel, and its parent. + // NOTE: This call has guards to not draw popups. If the restricted panel + // is a popup, it won't draw here. + ipanel()->PaintTraverse( ipanel()->GetParent( m_pRestrictedPanel ), true ); + } + else + { + // paint traverse the root panel, painting all children + VPROF( "ipanel()->PaintTraverse" ); + ipanel()->PaintTraverse( panel, true ); + } + } + else + { + // If it's a popup, it should already have been painted above + VPROF( "ipanel()->PaintTraverse" ); + if ( !paintPopups || !ipanel()->IsPopup( panel ) ) + { + ipanel()->PaintTraverse( panel, true ); + } + } + + // draw the popups + if ( paintPopups ) + { + // now draw the popups front to back + // since depth-test and depth-write are on, the front panels will occlude the underlying ones + { + VPROF( "CMatSystemSurface::PaintTraverse popups loop" ); + int popups = GetPopupCount(); + if ( popups > 254 ) + { + Warning( "Too many popups! Rendering will be bad!\n" ); + } + + // HACK! Using stencil ref 254 so drag/drop helper can use 255. + int nStencilRef = 254; + for ( int i = popups - 1; i >= 0; --i ) + { + VPANEL popupPanel = GetPopup( i ); + + if ( !popupPanel ) + continue; + + if ( !ipanel()->IsFullyVisible( popupPanel ) ) + continue; + + if ( !IsPanelUnderRestrictedPanel( popupPanel ) ) + continue; + + // This makes sure the drag/drop helper is always the first thing drawn + bool bIsTopmostPopup = ( (VPanel *)popupPanel )->IsTopmostPopup(); + + // set our z position + pRenderContext->SetStencilReferenceValue( bIsTopmostPopup ? 255 : nStencilRef ); + --nStencilRef; + + m_flZPos = ((float)(i) / (float)popups); + ipanel()->PaintTraverse( popupPanel, true ); + } + } + } + + // Restore the old Z Pos + m_flZPos = flOldZPos; + + if ( bTopLevelDraw ) + { + // only undo the 2d ortho mode once + VPROF( "FinishDrawing" ); + + // Reset stencil to normal state + pRenderContext->SetStencilEnable( false ); + + FinishDrawing(); + } +} + +//----------------------------------------------------------------------------- +// Draw a panel +//----------------------------------------------------------------------------- +void CMatSystemSurface::PaintTraverse(VPANEL panel) +{ + PaintTraverseEx( panel, false ); +} + + +//----------------------------------------------------------------------------- +// Begins, ends 3D painting from within a panel paint() method +//----------------------------------------------------------------------------- +void CMatSystemSurface::Begin3DPaint( int iLeft, int iTop, int iRight, int iBottom, bool bRenderToTexture ) +{ + MAT_FUNC; + + if ( IsX360() ) + { + Assert( 0 ); + return; + } + + Assert( iRight > iLeft ); + Assert( iBottom > iTop ); + + // Can't use this while drawing in the 3D world since it relies on + // whacking the shared depth buffer + Assert( !m_bDrawingIn3DWorld ); + if ( m_bDrawingIn3DWorld ) + return; + + m_n3DLeft = iLeft; + m_n3DRight = iRight; + m_n3DTop = iTop; + m_n3DBottom = iBottom; + + // Can't use this feature when drawing into the 3D world + Assert( !m_bDrawingIn3DWorld ); + Assert( !m_bIn3DPaintMode ); + m_bIn3DPaintMode = true; + m_b3DPaintRenderToTexture = bRenderToTexture; + + // Save off the matrices in case the painting method changes them. + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PushMatrix(); + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->PushMatrix(); + + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PushMatrix(); + + if ( bRenderToTexture ) + { + + // For 3d painting, use the off-screen render target the material system allocates + // NOTE: We have to grab it here, as opposed to during init, + // because the mode hasn't been set by now. + if ( !m_FullScreenBuffer ) + { + m_FullScreenBuffer.Init( materials->FindTexture( m_FullScreenBufferName, "render targets" ) ); + } + + // FIXME: Set the viewport to match the clip rectangle? + // Set the viewport to match the scissor rectangle + pRenderContext->PushRenderTargetAndViewport( m_FullScreenBuffer, + 0, 0, iRight - iLeft, iBottom - iTop ); + + // NOTE: Stencil is used to get 3D painting in vgui panels working correctly + pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE ); + pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_EQUAL ); + + // Don't draw the 3D scene w/ stencil + pRenderContext->SetStencilEnable( false ); + } + else + { + int clipLeft, clipTop, clipRight, clipBottom; + bool clipEnabled; + GetScissorRect( clipLeft, clipTop, clipRight, clipBottom, clipEnabled ); + pRenderContext->PushRenderTargetAndViewport(); + pRenderContext->Viewport( clipLeft + iLeft, clipTop + iTop, iRight - iLeft, iBottom - iTop ); + } + + pRenderContext->CullMode( MATERIAL_CULLMODE_CW ); + + pRenderContext->Flush(); +} + +void CMatSystemSurface::End3DPaint() +{ + MAT_FUNC; + + if ( IsX360() ) + { + Assert( 0 ); + return; + } + + // Can't use this feature when drawing into the 3D world + Assert( !m_bDrawingIn3DWorld ); + Assert( m_bIn3DPaintMode ); + m_bIn3DPaintMode = false; + + // Reset stencil to set stencil everywhere we draw + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + + pRenderContext->SetStencilEnable( true ); + pRenderContext->SetStencilFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilZFailOperation( STENCILOPERATION_KEEP ); + pRenderContext->SetStencilPassOperation( STENCILOPERATION_REPLACE ); + pRenderContext->SetStencilCompareFunction( STENCILCOMPARISONFUNCTION_GREATEREQUAL ); + + // Restore the matrices + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PopMatrix(); + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->PopMatrix(); + + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PopMatrix(); + + // Restore the viewport (it was stored off in StartDrawing) + pRenderContext->PopRenderTargetAndViewport(); + pRenderContext->CullMode(MATERIAL_CULLMODE_CCW); + + // Draw the full-screen buffer into the panel, if we rendering + // to a texture + if ( m_b3DPaintRenderToTexture ) + DrawFullScreenBuffer( m_n3DLeft, m_n3DTop, m_n3DRight, m_n3DBottom ); + + // ReSet the material state + InternalSetMaterial( NULL ); +} + + +//----------------------------------------------------------------------------- +// skin composition, force drawing +//----------------------------------------------------------------------------- +void CMatSystemSurface::BeginSkinCompositionPainting() +{ + g_bInDrawing = true; +} + + +//----------------------------------------------------------------------------- +// end drawing when finish skin composition +//----------------------------------------------------------------------------- +void CMatSystemSurface::EndSkinCompositionPainting() +{ + g_bInDrawing = false; +} + + +//----------------------------------------------------------------------------- +// Gets texture coordinates for drawing the full screen buffer +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetFullScreenTexCoords( int x, int y, int w, int h, float *pMinU, float *pMinV, float *pMaxU, float *pMaxV ) +{ + int nTexWidth = m_FullScreenBuffer->GetActualWidth(); + int nTexHeight = m_FullScreenBuffer->GetActualHeight(); + float flOOWidth = 1.0f / nTexWidth; + float flOOHeight = 1.0f / nTexHeight; + + *pMinU = ( (float)x + 0.5f ) * flOOWidth; + *pMinV = ( (float)y + 0.5f ) * flOOHeight; + *pMaxU = ( (float)(x+w) - 0.5f ) * flOOWidth; + *pMaxV = ( (float)(y+h) - 0.5f ) * flOOHeight; +} + + +//----------------------------------------------------------------------------- +// Draws the fullscreen buffer into the panel +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawFullScreenBuffer( int nLeft, int nTop, int nRight, int nBottom ) +{ + MAT_FUNC; + + // Draw a textured rectangle over the area + if ( m_nFullScreenBufferMaterialId == -1 ) + { + m_nFullScreenBufferMaterialId = CreateNewTextureID(); + DrawSetTextureMaterial( m_nFullScreenBufferMaterialId, m_FullScreenBufferMaterial ); + } + + float flGetAlphaMultiplier = DrawGetAlphaMultiplier(); + unsigned char oldColor[4]; + oldColor[0] = m_DrawColor[0]; + oldColor[1] = m_DrawColor[1]; + oldColor[2] = m_DrawColor[2]; + oldColor[3] = m_DrawColor[3]; + + DrawSetAlphaMultiplier( 1.0f ); + DrawSetColor( 255, 255, 255, 255 ); + + DrawSetTexture( m_nFullScreenBufferMaterialId ); + + float u0, u1, v0, v1; + GetFullScreenTexCoords( 0, 0, nRight - nLeft, nBottom - nTop, &u0, &v0, &u1, &v1 ); + DrawTexturedSubRect( nLeft, nTop, nRight, nBottom, u0, v0, u1, v1 ); + + m_DrawColor[0] = oldColor[0]; + m_DrawColor[1] = oldColor[1]; + m_DrawColor[2] = oldColor[2]; + m_DrawColor[3] = oldColor[3]; + DrawSetAlphaMultiplier( flGetAlphaMultiplier ); +} + + +//----------------------------------------------------------------------------- +// Draws a rectangle, setting z to the current value +//----------------------------------------------------------------------------- +float CMatSystemSurface::GetZPos() const +{ + return m_flZPos; +} + + +//----------------------------------------------------------------------------- +// Some drawing methods that cannot be accomplished under Win32 +//----------------------------------------------------------------------------- +#define CIRCLE_POINTS 360 + +void CMatSystemSurface::DrawColoredCircle( int centerx, int centery, float radius, int r, int g, int b, int a ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + // Draw a circle + int iDegrees = 0; + Vector vecPoint, vecLastPoint(0,0,0); + vecPoint.z = 0.0f; + Color clr; + clr.SetColor( r, g, b, a ); + DrawSetColor( clr ); + + for ( int i = 0; i < CIRCLE_POINTS; i++ ) + { + float flRadians = DEG2RAD( iDegrees ); + iDegrees += (360 / CIRCLE_POINTS); + + float ca = cos( flRadians ); + float sa = sin( flRadians ); + + // Rotate it around the circle + vecPoint.x = centerx + (radius * sa); + vecPoint.y = centery - (radius * ca); + + // Draw the point, if it's not on the previous point, to avoid smaller circles being brighter + if ( vecLastPoint != vecPoint ) + { + DrawFilledRect( vecPoint.x, vecPoint.y, vecPoint.x + 1, vecPoint.y + 1 ); + } + + vecLastPoint = vecPoint; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Draws colored text to a vgui panel +// Input : *font - font to use +// x - position of text +// y - +// r - color of text +// g - +// b - +// a - alpha ( 255 = opaque, 0 = transparent ) +// *fmt - va_* text string +// ... - +// Output : int - horizontal # of pixels drawn +//----------------------------------------------------------------------------- +int CMatSystemSurface::DrawColoredText( vgui::HFont font, int x, int y, int r, int g, int b, int a, const char *fmt, va_list argptr ) +{ + MAT_FUNC; + Assert( g_bInDrawing ); + int len; + char data[1024]; + + DrawSetTextPos( x, y ); + DrawSetTextColor( r, g, b, a ); + + len = Q_vsnprintf(data, sizeof( data ), fmt, argptr); + + DrawSetTextFont( font ); + + wchar_t szconverted[ 1024 ]; + g_pVGuiLocalize->ConvertANSIToUnicode( data, szconverted, 1024 ); + DrawPrintText( szconverted, wcslen(szconverted ) ); + + int totalLength = DrawTextLen( font, data ); + + return x + totalLength; +} + +int CMatSystemSurface::DrawColoredText( vgui::HFont font, int x, int y, int r, int g, int b, int a, const char *fmt, ... ) +{ + MAT_FUNC; + + va_list argptr; + va_start( argptr, fmt ); + int ret = DrawColoredText( font, x, y, r, g, b, a, fmt, argptr ); + va_end(argptr); + return ret; +} + + +//----------------------------------------------------------------------------- +// Draws text with current font at position and wordwrapped to the rect using color values specified +//----------------------------------------------------------------------------- +void CMatSystemSurface::SearchForWordBreak( vgui::HFont font, char *text, int& chars, int& pixels ) +{ + chars = pixels = 0; + while ( 1 ) + { + char ch = text[ chars ]; + int a, b, c; + GetCharABCwide( font, ch, a, b, c ); + + if ( ch == 0 || ch <= 32 ) + { + if ( ch == 32 && chars == 0 ) + { + pixels += ( b + c ); + chars++; + } + break; + } + + pixels += ( b + c ); + chars++; + } +} + +//----------------------------------------------------------------------------- +// Purpose: If text width is specified, reterns height of text at that width +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawTextHeight( vgui::HFont font, int w, int& h, const char *fmt, ... ) +{ + if ( !font ) + return; + + int len; + char data[8192]; + + va_list argptr; + va_start( argptr, fmt ); + len = Q_vsnprintf( data, sizeof( data ), fmt, argptr ); + va_end( argptr ); + + int x = 0; + int y = 0; + + int ystep = GetFontTall( font ); + int startx = x; + int endx = x + w; + //int endy = y + h; + int endy = 0; + + int chars = 0; + int pixels = 0; + for ( int i = 0 ; i < len; i += chars ) + { + SearchForWordBreak( font, &data[ i ], chars, pixels ); + + if ( data[ i ] == '\n' ) + { + x = startx; + y += ystep; + chars = 1; + continue; + } + + if ( x + ( pixels ) >= endx ) + { + x = startx; + // No room even on new line!!! + if ( x + pixels >= endx ) + break; + + y += ystep; + } + + for ( int j = 0 ; j < chars; j++ ) + { + int a, b, c; + char ch = data[ i + j ]; + + GetCharABCwide( font, ch, a, b, c ); + + x += a + b + c; + } + } + + endy = y+ystep; + + h = endy; +} + + +//----------------------------------------------------------------------------- +// Draws text with current font at position and wordwrapped to the rect using color values specified +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawColoredTextRect( vgui::HFont font, int x, int y, int w, int h, int r, int g, int b, int a, const char *fmt, ... ) +{ + MAT_FUNC; + + Assert( g_bInDrawing ); + if ( !font ) + return; + + int len; + char data[8192]; + + va_list argptr; + va_start( argptr, fmt ); + len = Q_vsnprintf( data, sizeof( data ), fmt, argptr ); + va_end( argptr ); + + DrawSetTextPos( x, y ); + DrawSetTextColor( r, g, b, a ); + DrawSetTextFont( font ); + + int ystep = GetFontTall( font ); + int startx = x; + int endx = x + w; + int endy = y + h; + + int chars = 0; + int pixels = 0; + + char word[ 512 ]; + char space[ 2 ]; + space[1] = 0; + space[0] = ' '; + + for ( int i = 0 ; i < len; i += chars ) + { + SearchForWordBreak( font, &data[ i ], chars, pixels ); + + if ( data[ i ] == '\n' ) + { + x = startx; + y += ystep; + chars = 1; + continue; + } + + if ( x + ( pixels ) >= endx ) + { + x = startx; + // No room even on new line!!! + if ( x + pixels >= endx ) + break; + + y += ystep; + } + + if ( y + ystep >= endy ) + break; + + + if ( chars <= 0 ) + continue; + + Q_strncpy( word, &data[ i ], chars + 1 ); + + DrawSetTextPos( x, y ); + + wchar_t szconverted[ 1024 ]; + g_pVGuiLocalize->ConvertANSIToUnicode( word, szconverted, 1024 ); + DrawPrintText( szconverted, wcslen(szconverted ) ); + + // Leave room for space, too + x += DrawTextLen( font, word ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Determine length of text string +//----------------------------------------------------------------------------- +int CMatSystemSurface::DrawTextLen( vgui::HFont font, const char *fmt, ... ) +{ + va_list argptr; + char data[1024]; + int len; + + va_start(argptr, fmt); + len = Q_vsnprintf(data, sizeof( data ), fmt, argptr); + va_end(argptr); + + int i; + int x = 0; + + for ( i = 0 ; i < len; i++ ) + { + int a, b, c; + GetCharABCwide( font, data[i], a, b, c ); + + // Ignore a + // x += a; + x += b; + x += c; + } + + return x; +} + +//----------------------------------------------------------------------------- +// Disable clipping during rendering +//----------------------------------------------------------------------------- +void CMatSystemSurface::DisableClipping( bool bDisable ) +{ + // when the clipping rules change. flush any text we've + // queued up to draw so it gets clipped appropriatesly + DrawFlushText(); + + EnableScissor( !bDisable ); +} + + +//----------------------------------------------------------------------------- +// Fetch current clipping rectangle +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetClippingRect( int &left, int &top, int &right, int &bottom, bool &bClippingDisabled ) +{ + bool bEnabled = true; + GetScissorRect( left, top, right, bottom, bEnabled ); + bClippingDisabled = !bEnabled; +} + +//----------------------------------------------------------------------------- +// Set clipping rectangle +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetClippingRect( int left, int top, int right, int bottom ) +{ + SetScissorRect( left, top, right, bottom ); +} + +//----------------------------------------------------------------------------- +// Purpose: unlocks the cursor state +//----------------------------------------------------------------------------- +bool CMatSystemSurface::IsCursorLocked() const +{ + return ::IsCursorLocked(); +} + + +//----------------------------------------------------------------------------- +// Sets the mouse Get + Set callbacks +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetMouseCallbacks( GetMouseCallback_t GetFunc, SetMouseCallback_t SetFunc ) +{ + // FIXME: Remove! This is obsolete + Assert(0); +} + + +//----------------------------------------------------------------------------- +// Tells the surface to ignore windows messages +//----------------------------------------------------------------------------- +void CMatSystemSurface::EnableWindowsMessages( bool bEnable ) +{ + EnableInput( bEnable ); +} + +void CMatSystemSurface::MovePopupToFront(VPANEL panel) +{ + HPanel p = ivgui()->PanelToHandle( panel ); + + int index = m_PopupList.Find( p ); + if ( index == m_PopupList.InvalidIndex() ) + return; + + m_PopupList.Remove( index ); + m_PopupList.AddToTail( p ); + + if ( g_bSpewFocus ) + { + char const *pName = ipanel()->GetName( panel ); + Msg( "%s moved to front\n", pName ? pName : "(no name)" ); + } + + // If the modal panel isn't a parent, restore it to the top, to prevent a hard lock + if ( input()->GetAppModalSurface() ) + { + if ( !g_pVGuiPanel->HasParent(panel, input()->GetAppModalSurface()) ) + { + HPanel p = ivgui()->PanelToHandle( input()->GetAppModalSurface() ); + index = m_PopupList.Find( p ); + if ( index != m_PopupList.InvalidIndex() ) + { + m_PopupList.Remove( index ); + m_PopupList.AddToTail( p ); + } + } + } + + ivgui()->PostMessage(panel, new KeyValues("OnMovedPopupToFront"), NULL); +} + +void CMatSystemSurface::MovePopupToBack(VPANEL panel) +{ + HPanel p = ivgui()->PanelToHandle( panel ); + + int index = m_PopupList.Find( p ); + if ( index == m_PopupList.InvalidIndex() ) + { + return; + } + + m_PopupList.Remove( index ); + m_PopupList.AddToHead( p ); +} + + +bool CMatSystemSurface::IsInThink( VPANEL panel) +{ + if ( m_bInThink ) + { + if ( panel == m_CurrentThinkPanel ) // HasParent() returns true if you pass yourself in + { + return false; + } + + return ipanel()->HasParent( panel, m_CurrentThinkPanel); + } + return false; +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CMatSystemSurface::IsCursorVisible() +{ + return m_cursorAlwaysVisible || (_currentCursor != dc_none); +} + +void CMatSystemSurface::SetCursorAlwaysVisible( bool visible ) +{ + m_cursorAlwaysVisible = visible; + CursorSelect( visible ? dc_alwaysvisible_push : dc_alwaysvisible_pop ); +} + +bool CMatSystemSurface::IsTextureIDValid(int id) +{ + // FIXME: + return true; +} + +void CMatSystemSurface::SetAllowHTMLJavaScript( bool state ) +{ + m_bAllowJavaScript = state; +} + +IHTML *CMatSystemSurface::CreateHTMLWindow(vgui::IHTMLEvents *events,VPANEL context) +{ + Assert( !"CMatSystemSurface::CreateHTMLWindow" ); + return NULL; +} + + +void CMatSystemSurface::DeleteHTMLWindow(IHTML *htmlwin) +{ +} + + + +void CMatSystemSurface::PaintHTMLWindow(IHTML *htmlwin) +{ +} + +bool CMatSystemSurface::BHTMLWindowNeedsPaint(IHTML *htmlwin) +{ + return false; +} + +//----------------------------------------------------------------------------- +/*void CMatSystemSurface::DrawSetTextureRGBA( int id, const unsigned char* rgba, int wide, int tall ) +{ + TextureDictionary()->SetTextureRGBAEx( id, (const char *)rgba, wide, tall, IMAGE_FORMAT_RGBA8888 ); +}*/ + +void CMatSystemSurface::DrawSetTextureRGBA(int id, const unsigned char* rgba, int wide, int tall, int hardwareFilter, bool forceUpload) +{ + TextureDictionary()->SetTextureRGBAEx( id, (const char *)rgba, wide, tall, IMAGE_FORMAT_RGBA8888, false ); +} + +void CMatSystemSurface::DrawSetTextureRGBAEx( int id, const unsigned char* rgba, int wide, int tall, ImageFormat format ) +{ + TextureDictionary()->SetTextureRGBAEx( id, (const char *)rgba, wide, tall, format, true ); +} + +void CMatSystemSurface::DrawSetSubTextureRGBA(int textureID, int drawX, int drawY, unsigned const char *rgba, int subTextureWide, int subTextureTall) +{ + TextureDictionary()->SetSubTextureRGBA( textureID, drawX, drawY, rgba, subTextureWide, subTextureTall ); +} + +void CMatSystemSurface::DrawUpdateRegionTextureRGBA( int nTextureID, int x, int y, const unsigned char *pchData, int wide, int tall, ImageFormat imageFormat ) +{ + TextureDictionary()->UpdateSubTextureRGBA( nTextureID, x, y, pchData, wide, tall, imageFormat ); +} + +void CMatSystemSurface::SetModalPanel(VPANEL ) +{ +} + +VPANEL CMatSystemSurface::GetModalPanel() +{ + return 0; +} + +void CMatSystemSurface::UnlockCursor() +{ + ::LockCursor( false ); +} + +void CMatSystemSurface::LockCursor() +{ + ::LockCursor( true ); +} + +void CMatSystemSurface::SetTranslateExtendedKeys(bool state) +{ +} + +VPANEL CMatSystemSurface::GetTopmostPopup() +{ + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: gets the absolute coordinates of the screen (in screen space) +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetAbsoluteWindowBounds(int &x, int &y, int &wide, int &tall) +{ + // always work in full window screen space + x = 0; + y = 0; + GetScreenSize(wide, tall); +} + +// returns true if the specified panel is a child of the current modal panel +// if no modal panel is set, then this always returns TRUE +static bool IsChildOfModalSubTree(VPANEL panel) +{ + if ( !panel ) + return true; + + VPANEL modalSubTree = input()->GetModalSubTree(); + + if ( modalSubTree ) + { + bool restrictMessages = input()->ShouldModalSubTreeReceiveMessages(); + + // If panel is child of modal subtree, the allow messages to route to it if restrict messages is set + bool isChildOfModal = ipanel()->HasParent( panel, modalSubTree ); + if ( isChildOfModal ) + { + return restrictMessages; + } + // If panel is not a child of modal subtree, then only allow messages if we're not restricting them to the modal subtree + else + { + return !restrictMessages; + } + } + + return true; +} + +void CMatSystemSurface::CalculateMouseVisible() +{ + int i; + m_bNeedsMouse = false; + m_bNeedsKeyboard = false; + + if ( input()->GetMouseCapture() != 0 ) + return; + + int c = surface()->GetPopupCount(); + + VPANEL modalSubTree = input()->GetModalSubTree(); + if ( modalSubTree ) + { + for (i = 0 ; i < c ; i++ ) + { + VPanel *pop = (VPanel *)surface()->GetPopup(i) ; + bool isChildOfModalSubPanel = IsChildOfModalSubTree( (VPANEL)pop ); + if ( !isChildOfModalSubPanel ) + continue; + + bool isVisible=pop->IsVisible(); + VPanel *p= pop->GetParent(); + + while (p && isVisible) + { + if( p->IsVisible()==false) + { + isVisible=false; + break; + } + p=p->GetParent(); + } + + if ( isVisible ) + { + m_bNeedsMouse = m_bNeedsMouse || pop->IsMouseInputEnabled(); + m_bNeedsKeyboard = m_bNeedsKeyboard || pop->IsKeyBoardInputEnabled(); + + // Seen enough!!! + if ( m_bNeedsMouse && m_bNeedsKeyboard ) + break; + } + } + } + else + { + for (i = 0 ; i < c ; i++ ) + { + VPanel *pop = (VPanel *)surface()->GetPopup(i) ; + + bool isVisible=pop->IsVisible(); + VPanel *p= pop->GetParent(); + + while (p && isVisible) + { + if( p->IsVisible()==false) + { + isVisible=false; + break; + } + p=p->GetParent(); + } + + if ( isVisible ) + { + m_bNeedsMouse = m_bNeedsMouse || pop->IsMouseInputEnabled(); + m_bNeedsKeyboard = m_bNeedsKeyboard || pop->IsKeyBoardInputEnabled(); + + // Seen enough!!! + if ( m_bNeedsMouse && m_bNeedsKeyboard ) + break; + } + } + } + + if (m_bNeedsMouse) + { + // NOTE: We must unlock the cursor *before* the set call here. + // Failing to do this causes s_bCursorVisible to not be set correctly + // (UnlockCursor fails to set it correctly) + UnlockCursor(); + if ( _currentCursor == vgui::dc_none ) + { + SetCursor(vgui::dc_arrow); + } + } + else + { + SetCursor(vgui::dc_none); + LockCursor(); + } +} + +bool CMatSystemSurface::NeedKBInput() +{ + return m_bNeedsKeyboard; +} + +void CMatSystemSurface::SurfaceGetCursorPos(int &x, int &y) +{ + GetCursorPos( x, y ); +} +void CMatSystemSurface::SurfaceSetCursorPos(int x, int y) +{ + SetCursorPos( x, y ); +} + +//----------------------------------------------------------------------------- +// Purpose: global alpha setting functions +//----------------------------------------------------------------------------- +void CMatSystemSurface::DrawSetAlphaMultiplier( float alpha /* [0..1] */ ) +{ + m_flAlphaMultiplier = clamp(alpha, 0.0f, 1.0f); +} + +//----------------------------------------------------------------------------- +// Purpose: data accessor +//----------------------------------------------------------------------------- +float CMatSystemSurface::DrawGetAlphaMultiplier() +{ + return m_flAlphaMultiplier; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *curOrAniFile - +// Output : vgui::HCursor +//----------------------------------------------------------------------------- +vgui::HCursor CMatSystemSurface::CreateCursorFromFile( char const *curOrAniFile, char const *pPathID ) +{ + return Cursor_CreateCursorFromFile( curOrAniFile, pPathID ); +} + +void CMatSystemSurface::SetPanelForInput( VPANEL vpanel ) +{ + g_pIInput->AssociatePanelWithInputContext( DEFAULT_INPUT_CONTEXT, vpanel ); + if ( vpanel ) + { + m_bNeedsKeyboard = true; + } + else + { + m_bNeedsKeyboard = false; + } +} + +#if defined( WIN32 ) && !defined( _X360 ) +static bool GetIconSize( ICONINFO& iconInfo, int& w, int& h ) +{ + w = h = 0; + + HBITMAP bitmap = iconInfo.hbmColor; + BITMAP bm; + if ( 0 == GetObject((HGDIOBJ)bitmap, sizeof(BITMAP), (LPVOID)&bm) ) + { + return false; + } + + w = bm.bmWidth; + h = bm.bmHeight; + + return true; +} + +// If rgba is NULL, bufsize gets filled in w/ # of bytes required +static bool GetIconBits( HDC hdc, ICONINFO& iconInfo, int& w, int& h, unsigned char *rgba, size_t& bufsize ) +{ + if ( !iconInfo.hbmColor || !iconInfo.hbmMask ) + return false; + + if ( !rgba ) + { + if ( !GetIconSize( iconInfo, w, h ) ) + return false; + + bufsize = (size_t)( ( w * h ) << 2 ); + return true; + } + + bool bret = false; + + Assert( w > 0 ); + Assert( h > 0 ); + Assert( bufsize == (size_t)( ( w * h ) << 2 ) ); + + DWORD *maskData = new DWORD[ w * h ]; + DWORD *colorData = new DWORD[ w * h ]; + DWORD *output = (DWORD *)rgba; + + BITMAPINFO bmInfo; + + memset( &bmInfo, 0, sizeof( bmInfo ) ); + bmInfo.bmiHeader.biSize = sizeof( bmInfo.bmiHeader ); + bmInfo.bmiHeader.biWidth = w; + bmInfo.bmiHeader.biHeight = h; + bmInfo.bmiHeader.biPlanes = 1; + bmInfo.bmiHeader.biBitCount = 32; + bmInfo.bmiHeader.biCompression = BI_RGB; + + // Get the info about the bits + if ( GetDIBits( hdc, iconInfo.hbmMask, 0, h, maskData, &bmInfo, DIB_RGB_COLORS ) == h && + GetDIBits( hdc, iconInfo.hbmColor, 0, h, colorData, &bmInfo, DIB_RGB_COLORS ) == h ) + { + bret = true; + + for ( int row = 0; row < h; ++row ) + { + // Invert + int r = ( h - row - 1 ); + int rowstart = r * w; + + DWORD *color = &colorData[ rowstart ]; + DWORD *mask = &maskData[ rowstart ]; + DWORD *outdata = &output[ row * w ]; + + for ( int col = 0; col < w; ++col ) + { + unsigned char *cr = ( unsigned char * )&color[ col ]; + + // Set alpha + cr[ 3 ] = mask[ col ] == 0 ? 0xff : 0x00; + + // Swap blue and red + unsigned char t = cr[ 2 ]; + cr[ 2 ] = cr[ 0 ]; + cr[ 0 ] = t; + + *( unsigned int *)&outdata[ col ] = *( unsigned int * )cr; + } + } + } + + delete[] colorData; + delete[] maskData; + + return bret; +} + +static bool ShouldMakeUnique( char const *extension ) +{ + if ( !Q_stricmp( extension, "cur" ) ) + return true; + if ( !Q_stricmp( extension, "ani" ) ) + return true; + return false; +} +#endif // !_X360 + +vgui::IImage *CMatSystemSurface::GetIconImageForFullPath( char const *pFullPath ) +{ + vgui::IImage *newIcon = NULL; + +#if defined( WIN32 ) && !defined( _X360 ) + SHFILEINFO info = { 0 }; + DWORD_PTR dwResult = SHGetFileInfo( + pFullPath, + 0, + &info, + sizeof( info ), + SHGFI_TYPENAME | SHGFI_ICON | SHGFI_SMALLICON | SHGFI_SHELLICONSIZE + ); + if ( dwResult ) + { + if ( info.szTypeName[ 0 ] != 0 ) + { + char ext[ 32 ]; + Q_ExtractFileExtension( pFullPath, ext, sizeof( ext ) ); + + char lookup[ 512 ]; + Q_snprintf( lookup, sizeof( lookup ), "%s", ShouldMakeUnique( ext ) ? pFullPath : info.szTypeName ); + + // Now check the dictionary + unsigned short idx = m_FileTypeImages.Find( lookup ); + if ( idx == m_FileTypeImages.InvalidIndex() ) + { + ICONINFO iconInfo; + if ( 0 != GetIconInfo( info.hIcon, &iconInfo ) ) + { + int w, h; + size_t bufsize = 0; + + HDC hdc = ::GetDC(reinterpret_cast<HWND>(m_HWnd)); + + if ( GetIconBits( hdc, iconInfo, w, h, NULL, bufsize ) ) + { + byte *bits = new byte[ bufsize ]; + if ( bits && GetIconBits( hdc, iconInfo, w, h, bits, bufsize ) ) + { + newIcon = new MemoryBitmap( bits, w, h ); + } + delete[] bits; + } + + ::ReleaseDC( reinterpret_cast<HWND>(m_HWnd), hdc ); + } + + idx = m_FileTypeImages.Insert( lookup, newIcon ); + } + + newIcon = m_FileTypeImages[ idx ]; + } + + DestroyIcon( info.hIcon ); + } +#endif + return newIcon; +} + +const char *CMatSystemSurface::GetResolutionKey( void ) const +{ + Assert( !IsPC() ); + int x, y, width, height; + CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); + pRenderContext->GetViewport( x, y, width, height ); + if( height <= 480 ) + { + return "_lodef"; + } + else + { + return "_hidef"; + } +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::Set3DPaintTempRenderTarget( const char *pRenderTargetName ) +{ + MAT_FUNC; + + Assert( !m_bUsingTempFullScreenBufferMaterial ); + m_bUsingTempFullScreenBufferMaterial = true; + + InitFullScreenBuffer( pRenderTargetName ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CMatSystemSurface::Reset3DPaintTempRenderTarget( void ) +{ + MAT_FUNC; + + Assert( m_bUsingTempFullScreenBufferMaterial ); + m_bUsingTempFullScreenBufferMaterial = false; + + InitFullScreenBuffer( "_rt_FullScreen" ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the origin of the viewport to render into if we were +// rendering into the frame buffer. This version of the function is +// mostly here for backward compatibility and always uses a NULL +// render target (i.e. the frame buffer.) +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetFullscreenViewport( int x, int y, int w, int h ) +{ + SetFullscreenViewportAndRenderTarget( x, y, w, h, NULL ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Sets the origin of the viewport to render into if we were +// rendering into the frame buffer. We might actually be generally +// using a render target but need to switch back to the frame buffer +// for some panels. +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetFullscreenViewportAndRenderTarget( int x, int y, int w, int h, ITexture *pRenderTarget ) +{ + m_nFullscreenViewportX = x; + m_nFullscreenViewportY = y; + m_nFullscreenViewportWidth = w; + m_nFullscreenViewportHeight = h; + m_pFullscreenRenderTarget = pRenderTarget; +} + + +//----------------------------------------------------------------------------- +// Purpose: Gets the origin of the viewport to render into if we were +// rendering into the frame buffer. We might actually be generally +// using a render target but need to switch back to the frame buffer +// for some panels. +//----------------------------------------------------------------------------- +void CMatSystemSurface::GetFullscreenViewportAndRenderTarget( int & x, int & y, int & w, int & h, ITexture **ppRenderTarget ) +{ + if( m_nFullscreenViewportHeight == 0 ) + { + // this can't actually be zero. If it is, use the height of the screen instead + x = y = 0; + GetScreenSize( w, h ); + if( ppRenderTarget) + *ppRenderTarget = NULL; + } + else + { + x = m_nFullscreenViewportX; + y = m_nFullscreenViewportY; + w = m_nFullscreenViewportWidth; + h = m_nFullscreenViewportHeight; + if( ppRenderTarget) + *ppRenderTarget = m_pFullscreenRenderTarget; + } +} +void CMatSystemSurface::GetFullscreenViewport( int & x, int & y, int & w, int & h ) +{ + GetFullscreenViewportAndRenderTarget( x, y, w, h, NULL ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Handle switching in and out of "render to fullscreen" mode. We don't +// actually support this mode in tools. +//----------------------------------------------------------------------------- +void CMatSystemSurface::PushFullscreenViewport() +{ + CMatRenderContextPtr pRenderContext( materials ); + + // the viewport x/y will be wrong because the render target is only for one eye. + // Ask the surface for that information instead. + int vx, vy, vw, vh; + ITexture *pRenderTarget; + GetFullscreenViewportAndRenderTarget( vx, vy, vw, vh, &pRenderTarget ); + pRenderContext->PushRenderTargetAndViewport( pRenderTarget, NULL, vx, vy, vw, vh ); + + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PushMatrix(); + pRenderContext->LoadIdentity(); + pRenderContext->Scale( 1, -1, 1 ); + + //___stop___(); + pRenderContext->Ortho( g_flPixelOffsetX, g_flPixelOffsetY, vw + g_flPixelOffsetX, vh + g_flPixelOffsetY, -1.0f, 1.0f ); + + DisableClipping( true ); +} + +void CMatSystemSurface::PopFullscreenViewport() +{ + CMatRenderContextPtr pRenderContext( materials ); + + pRenderContext->PopRenderTargetAndViewport(); + + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->PopMatrix(); + + DisableClipping( false ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Handle switching in and out of "render to fullscreen" mode. We don't +// actually support this mode in tools. +//----------------------------------------------------------------------------- +void CMatSystemSurface::SetSoftwareCursor( bool bUseSoftwareCursor ) +{ + EnableSoftwareCursor( bUseSoftwareCursor ); +} + +void CMatSystemSurface::PaintSoftwareCursor() +{ + if( !ShouldDrawSoftwareCursor() ) + return; + + // this asks Windows for the position RIGHT NOW, which should be the least + // latent notion we have of where to draw the cursor + int x, y; + GetCursorPos( x, y ); + + Color clr( 255, 255, 255, 255 ); + + float uOffset, vOffset; + int nTextureID = GetSoftwareCursorTexture( &uOffset, &vOffset ); + if( nTextureID <= 0 ) + return; + + int w, h; + DrawGetTextureSize( nTextureID, w, h ); + + // the cursors are actually pretty big. Make them smaller. + w /= 2; + h /= 2; + + int xOffset = (int)(uOffset * (float)w); + int yOffset = (int)(vOffset * (float)h); + + Assert( !g_bInDrawing ); + StartDrawing(); + + PaintState_t paintState; + paintState.m_iTranslateX = paintState.m_iTranslateY = 0; + paintState.m_iScissorLeft = paintState.m_iScissorTop = 0; + GetScreenSize( paintState.m_iScissorRight, paintState.m_iScissorBottom ); + + SetupPaintState( paintState ); + + DrawSetColor( clr ); + DrawSetTexture( nTextureID ); + DrawTexturedRect( x + xOffset, y + yOffset, x + xOffset + w, y + yOffset + h ); + DrawSetTexture(0); + + FinishDrawing(); +} + +int CMatSystemSurface::GetTextureNumFrames( int id ) +{ + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial( id ); + if ( !pMaterial ) + { + return 0; + } + return pMaterial->GetNumAnimationFrames(); +} + +void CMatSystemSurface::DrawSetTextureFrame( int id, int nFrame, unsigned int *pFrameCache ) +{ + IMaterial *pMaterial = TextureDictionary()->GetTextureMaterial( id ); + if ( !pMaterial ) + { + return; + } + + int nTotalFrames = pMaterial->GetNumAnimationFrames(); + if ( !nTotalFrames ) + { + return; + } + + IMaterialVar *pFrameVar = pMaterial->FindVarFast( "$frame", pFrameCache ); + if ( pFrameVar ) + { + pFrameVar->SetIntValue( nFrame % nTotalFrames ); + } +} |