mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
2fb712af66
* Fix macOS build * Fix *BSD build * Add missing *BSD include
4610 lines
130 KiB
C++
4610 lines
130 KiB
C++
//========= 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"
|
|
#ifdef OSX
|
|
#include <malloc/malloc.h>
|
|
#else
|
|
#include <malloc.h>
|
|
#endif
|
|
#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 );
|
|
|
|
#if defined(LINUX) || defined(OSX) || defined(PLATFORM_BSD)
|
|
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" );
|
|
}
|
|
|
|
#if defined(LINUX) || defined(OSX) || defined(PLATFORM_BSD)
|
|
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 defined(LINUX) || defined(OSX) || defined(PLATFORM_BSD)
|
|
|
|
int size;
|
|
if ( CMatSystemSurface::FontDataHelper( fontName, size, fontFileName ) )
|
|
return true;
|
|
return false;
|
|
|
|
#elif defined( _X360 )
|
|
#include "xbox/xbox_win32stubs.h"
|
|
#else
|
|
#error
|
|
#endif
|
|
}
|
|
|
|
#if defined(LINUX) || defined(OSX) || defined(PLATFORM_BSD)
|
|
|
|
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 );
|
|
}
|
|
}
|