d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
528 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 047f8b1185
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '047f8b1185'
${ noResults }
source-engine/vguimatsurface/Cursor.cpp

565 lines
17 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Methods associated with the cursor
//
// $Revision: $
// $NoKeywords: $
//===========================================================================//
#if !defined( _X360 )
#define OEMRESOURCE //for OCR_* cursor junk
#include "winlite.h"
#endif
#include <appframework/ilaunchermgr.h>
#if defined( USE_SDL )
#undef M_PI
#include "SDL.h"
#endif
#include "tier0/dbg.h"
#include "tier0/vcrmode.h"
#include "tier0/icommandline.h"
#include "tier1/utldict.h"
#include "Cursor.h"
#include "vguimatsurface.h"
#include "MatSystemSurface.h"
#include "filesystem.h"
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif
#if defined( USE_SDL )
#include "materialsystem/imaterialsystem.h"
#endif
#include "inputsystem/iinputsystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
#if defined( USE_SDL )
static SDL_Cursor *s_pDefaultCursor[ dc_last ];
static SDL_Cursor *s_hCurrentCursor = NULL;
static SDL_Cursor *s_hCurrentlySetCursor = NULL;
#elif defined( WIN32 )
static HICON s_pDefaultCursor[ dc_last ];
static HICON s_hCurrentCursor = NULL;
#endif
static bool s_bCursorLocked = false;
static bool s_bCursorVisible = true;
static int s_nForceCursorVisibleCount = 0;
static bool s_bSoftwareCursorActive = false;
static int s_nSoftwareCursorTexture = -1;
static float s_fSoftwareCursorOffsetX = 0;
static float s_fSoftwareCursorOffsetY = 0;
static int s_rnSoftwareCursorID[20];
static float s_rfSoftwareCursorOffset[20][2];
static bool s_bSoftwareCursorsInitialized = false;
extern CMatSystemSurface g_MatSystemSurface;
//-----------------------------------------------------------------------------
// Initializes cursors
//-----------------------------------------------------------------------------
void InitCursors()
{
// load up all default cursors
#if defined( USE_SDL )
s_pDefaultCursor[ dc_none ] = NULL;
s_pDefaultCursor[ dc_arrow ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_ARROW );
s_pDefaultCursor[ dc_ibeam ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_IBEAM );
s_pDefaultCursor[ dc_hourglass ]= SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_WAIT );
s_pDefaultCursor[ dc_crosshair ]= SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_CROSSHAIR );
s_pDefaultCursor[ dc_waitarrow ]= SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_WAITARROW );
s_pDefaultCursor[ dc_sizenwse ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_SIZENWSE );
s_pDefaultCursor[ dc_sizenesw ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_SIZENESW );
s_pDefaultCursor[ dc_sizewe ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_SIZEWE );
s_pDefaultCursor[ dc_sizens ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_SIZENS );
s_pDefaultCursor[ dc_sizeall ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_SIZEALL );
s_pDefaultCursor[ dc_no ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_NO );
s_pDefaultCursor[ dc_hand ] = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_HAND );
s_hCurrentCursor = s_pDefaultCursor[ dc_arrow ];
#elif defined( WIN32 )
s_pDefaultCursor[ dc_none ] = NULL;
s_pDefaultCursor[ dc_arrow ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_NORMAL);
s_pDefaultCursor[ dc_ibeam ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_IBEAM);
s_pDefaultCursor[ dc_hourglass ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_WAIT);
s_pDefaultCursor[ dc_crosshair ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_CROSS);
s_pDefaultCursor[ dc_waitarrow ] =(HICON)LoadCursor(NULL, (LPCTSTR)32650);
s_pDefaultCursor[ dc_up ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_UP);
s_pDefaultCursor[ dc_sizenwse ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_SIZENWSE);
s_pDefaultCursor[ dc_sizenesw ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_SIZENESW);
s_pDefaultCursor[ dc_sizewe ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_SIZEWE);
s_pDefaultCursor[ dc_sizens ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_SIZENS);
s_pDefaultCursor[ dc_sizeall ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_SIZEALL);
s_pDefaultCursor[ dc_no ] =(HICON)LoadCursor(NULL, (LPCTSTR)OCR_NO);
s_pDefaultCursor[ dc_hand ] =(HICON)LoadCursor(NULL, (LPCTSTR)32649);
s_hCurrentCursor = s_pDefaultCursor[ dc_arrow ];
#endif
s_bCursorLocked = false;
s_bCursorVisible = true;
s_nForceCursorVisibleCount = 0;
}
#define USER_CURSOR_MASK 0x80000000
#ifdef WIN32
//-----------------------------------------------------------------------------
// Purpose: Simple manager for user loaded windows cursors in vgui
//-----------------------------------------------------------------------------
class CUserCursorManager
{
public:
void Shutdown();
vgui::HCursor CreateCursorFromFile( char const *curOrAniFile, char const *pPathID );
bool LookupCursor( vgui::HCursor cursor, HCURSOR& handle );
private:
CUtlDict< HCURSOR, int > m_UserCursors;
};
void CUserCursorManager::Shutdown()
{
for ( int i = m_UserCursors.First() ; i != m_UserCursors.InvalidIndex(); i = m_UserCursors.Next( i ) )
{
::DestroyCursor( m_UserCursors[ i ] );
}
m_UserCursors.RemoveAll();
}
vgui::HCursor CUserCursorManager::CreateCursorFromFile( char const *curOrAniFile, char const *pPathID )
{
char fn[ 512 ];
Q_strncpy( fn, curOrAniFile, sizeof( fn ) );
Q_strlower( fn );
Q_FixSlashes( fn );
int cursorIndex = m_UserCursors.Find( fn );
if ( cursorIndex != m_UserCursors.InvalidIndex() )
{
return cursorIndex | USER_CURSOR_MASK;
}
g_pFullFileSystem->GetLocalCopy( fn );
char fullpath[ 512 ];
g_pFullFileSystem->RelativePathToFullPath( fn, pPathID, fullpath, sizeof( fullpath ) );
HCURSOR newCursor = (HCURSOR)LoadCursorFromFile( fullpath );
cursorIndex = m_UserCursors.Insert( fn, newCursor );
return cursorIndex | USER_CURSOR_MASK;
}
bool CUserCursorManager::LookupCursor( vgui::HCursor cursor, HCURSOR& handle )
{
if ( !( (int)cursor & USER_CURSOR_MASK ) )
{
handle = 0;
return false;
}
int cursorIndex = (int)cursor & ~USER_CURSOR_MASK;
if ( !m_UserCursors.IsValidIndex( cursorIndex ) )
{
handle = 0;
return false;
}
handle = m_UserCursors[ cursorIndex ];
return true;
}
static CUserCursorManager g_UserCursors;
#endif
vgui::HCursor Cursor_CreateCursorFromFile( char const *curOrAniFile, char const *pPathID )
{
#ifdef WIN32
return g_UserCursors.CreateCursorFromFile( curOrAniFile, pPathID );
#else
return dc_user;
#endif
}
void Cursor_ClearUserCursors()
{
#ifdef WIN32
g_UserCursors.Shutdown();
#endif
}
//-----------------------------------------------------------------------------
// Initializes all the textures for software cursors
//-----------------------------------------------------------------------------
int InitSoftwareCursorTexture( const char *pchFilename )
{
if( !pchFilename || !*pchFilename )
return -1;
int nTextureID = g_MatSystemSurface.DrawGetTextureId( pchFilename );
if( nTextureID == -1 )
{
nTextureID = g_MatSystemSurface.CreateNewTextureID();
g_MatSystemSurface.DrawSetTextureFile( nTextureID, pchFilename, true, false );
}
return nTextureID;
}
void InitSoftwareCursors()
{
if( s_bSoftwareCursorsInitialized )
return;
memset( s_rfSoftwareCursorOffset, 0, sizeof( s_rfSoftwareCursorOffset ) );
s_rnSoftwareCursorID[dc_none] = -1;
s_rnSoftwareCursorID[dc_arrow] =InitSoftwareCursorTexture( "vgui/cursors/arrow" );
s_rnSoftwareCursorID[dc_ibeam] =InitSoftwareCursorTexture( "vgui/cursors/ibeam" );
s_rnSoftwareCursorID[dc_hourglass]=InitSoftwareCursorTexture( "vgui/cursors/hourglass" );
s_rnSoftwareCursorID[dc_crosshair]=InitSoftwareCursorTexture( "vgui/cursors/crosshair" );
s_rnSoftwareCursorID[dc_waitarrow]=InitSoftwareCursorTexture( "vgui/cursors/waitarrow" );
s_rnSoftwareCursorID[dc_up] =InitSoftwareCursorTexture( "vgui/cursors/up" );
s_rnSoftwareCursorID[dc_sizenwse] =InitSoftwareCursorTexture( "vgui/cursors/sizenwse" );
s_rnSoftwareCursorID[dc_sizenesw] =InitSoftwareCursorTexture( "vgui/cursors/sizenesw" );
s_rnSoftwareCursorID[dc_sizewe] =InitSoftwareCursorTexture( "vgui/cursors/sizewe" );
s_rnSoftwareCursorID[dc_sizens] =InitSoftwareCursorTexture( "vgui/cursors/sizens" );
s_rnSoftwareCursorID[dc_sizeall] =InitSoftwareCursorTexture( "vgui/cursors/sizeall" );
s_rnSoftwareCursorID[dc_no] =InitSoftwareCursorTexture( "vgui/cursors/no" );
s_rnSoftwareCursorID[dc_hand] =InitSoftwareCursorTexture( "vgui/cursors/hand" );
// handle the cursor hotspots not being at their origin
s_rfSoftwareCursorOffset[dc_arrow][0] = -0.1;
s_rfSoftwareCursorOffset[dc_arrow][1] = -0.1;
s_rfSoftwareCursorOffset[dc_ibeam][0] = -0.5;
s_rfSoftwareCursorOffset[dc_ibeam][1] = -0.8;
s_rfSoftwareCursorOffset[dc_hourglass][0] = -0.5;
s_rfSoftwareCursorOffset[dc_hourglass][1] = -0.5;
s_rfSoftwareCursorOffset[dc_crosshair][0] = -0.5;
s_rfSoftwareCursorOffset[dc_crosshair][1] = -0.5;
s_rfSoftwareCursorOffset[dc_waitarrow][0] = -0.1;
s_rfSoftwareCursorOffset[dc_waitarrow][1] = -0.1;
s_rfSoftwareCursorOffset[dc_up][0] = -0.5;
s_rfSoftwareCursorOffset[dc_up][1] = -0.5;
s_rfSoftwareCursorOffset[dc_sizenwse][0] = -0.5;
s_rfSoftwareCursorOffset[dc_sizenwse][1] = -0.5;
s_rfSoftwareCursorOffset[dc_sizenesw][0] = -0.5;
s_rfSoftwareCursorOffset[dc_sizenesw][1] = -0.5;
s_rfSoftwareCursorOffset[dc_sizewe][0] = -0.5;
s_rfSoftwareCursorOffset[dc_sizewe][1] = -0.5;
s_rfSoftwareCursorOffset[dc_sizens][0] = -0.5;
s_rfSoftwareCursorOffset[dc_sizens][1] = -0.5;
s_rfSoftwareCursorOffset[dc_sizeall][0] = -0.5;
s_rfSoftwareCursorOffset[dc_sizeall][1] = -0.5;
s_rfSoftwareCursorOffset[dc_no][0] = -0.5;
s_rfSoftwareCursorOffset[dc_no][1] = -0.5;
s_rfSoftwareCursorOffset[dc_hand][0] = -0.5;
s_rfSoftwareCursorOffset[dc_hand][1] = -0.5;
s_bSoftwareCursorsInitialized = true;
}
//-----------------------------------------------------------------------------
// Selects a cursor
//-----------------------------------------------------------------------------
void CursorSelect(HCursor hCursor)
{
if ( ( hCursor == dc_alwaysvisible_push ) || ( hCursor == dc_alwaysvisible_pop ) )
{
// CConPanel in engine/console.cpp does a SetCursor(null). So when the TF2 chat window pops up
// and there are console commands showing and fading out in the top left, our chat window
// will have a cursor show/hide fight with them. So the cursor flickers or doesn't show up
// at all. Unfortunately on Linux, it's even worse since we recenter the mouse when it's
// not shown - so we added this API call which causes cursor.cpp to always show the cursor.
s_nForceCursorVisibleCount += ( hCursor == dc_alwaysvisible_push ? 1 : -1 );
Assert( s_nForceCursorVisibleCount >= 0 );
if( ( s_nForceCursorVisibleCount && !s_bCursorVisible ) ||
( !s_nForceCursorVisibleCount && s_bCursorVisible ) )
{
ActivateCurrentCursor();
}
return;
}
if (s_bCursorLocked)
return;
#if defined( WIN32 ) && !defined( USE_SDL )
s_bCursorVisible = true;
switch (hCursor)
{
case dc_user:
case dc_none:
case dc_blank:
s_bCursorVisible = false;
break;
case dc_arrow:
case dc_waitarrow:
case dc_ibeam:
case dc_hourglass:
case dc_crosshair:
case dc_up:
case dc_sizenwse:
case dc_sizenesw:
case dc_sizewe:
case dc_sizens:
case dc_sizeall:
case dc_no:
case dc_hand:
if( !s_bSoftwareCursorActive )
{
s_hCurrentCursor = s_pDefaultCursor[hCursor];
}
else
{
s_nSoftwareCursorTexture = s_rnSoftwareCursorID[ hCursor ];
s_fSoftwareCursorOffsetX = s_rfSoftwareCursorOffset[ hCursor ][0];
s_fSoftwareCursorOffsetY = s_rfSoftwareCursorOffset[ hCursor ][1];
}
break;
default:
{
HCURSOR custom = 0;
if ( g_UserCursors.LookupCursor( hCursor, custom ) && custom != 0 )
{
s_hCurrentCursor = custom;
}
else
{
s_bCursorVisible = false;
Assert(0);
}
}
break;
}
ActivateCurrentCursor();
#elif defined( USE_SDL )
switch (hCursor)
{
case dc_user:
case dc_none:
case dc_blank:
s_bCursorVisible = false;
break;
default:
// We don't support custom cursors at the moment (but could, if necessary).
// Fall through and use the arrow for now...
Assert(0);
hCursor = dc_arrow;
case dc_arrow:
case dc_waitarrow:
case dc_ibeam:
case dc_hourglass:
case dc_crosshair:
case dc_up:
case dc_sizenwse:
case dc_sizenesw:
case dc_sizewe:
case dc_sizens:
case dc_sizeall:
case dc_no:
case dc_hand:
s_bCursorVisible = true;
if( !s_bSoftwareCursorActive )
{
s_hCurrentCursor = s_pDefaultCursor[hCursor];
}
else
{
s_nSoftwareCursorTexture = s_rnSoftwareCursorID[ hCursor ];
s_fSoftwareCursorOffsetX = s_rfSoftwareCursorOffset[ hCursor ][0];
s_fSoftwareCursorOffsetY = s_rfSoftwareCursorOffset[ hCursor ][1];
}
break;
}
ActivateCurrentCursor();
#else
#error
#endif
}
//-----------------------------------------------------------------------------
// Hides the hardware cursor
//-----------------------------------------------------------------------------
void HideHardwareCursor()
{
#if defined( WIN32 ) && !defined( USE_SDL )
::SetCursor(NULL);
#elif defined( USE_SDL )
//if ( s_hCurrentlySetCursor != s_pDefaultCursor[ dc_none ] )
{
s_hCurrentlySetCursor = s_pDefaultCursor[ dc_none ];
g_pLauncherMgr->SetMouseCursor( s_hCurrentlySetCursor );
g_pLauncherMgr->SetMouseVisible( false );
}
#else
#error
#endif
}
//-----------------------------------------------------------------------------
// Activates the current cursor
//-----------------------------------------------------------------------------
void ActivateCurrentCursor()
{
if( s_bSoftwareCursorActive )
{
HideHardwareCursor();
return;
}
if ( s_bCursorVisible || ( s_nForceCursorVisibleCount > 0 ) )
{
#if defined( WIN32 ) && !defined( USE_SDL )
::SetCursor(s_hCurrentCursor);
#elif defined( USE_SDL )
if (s_hCurrentlySetCursor != s_hCurrentCursor )
{
s_hCurrentlySetCursor = s_hCurrentCursor;
g_pLauncherMgr->SetMouseCursor( s_hCurrentlySetCursor );
g_pLauncherMgr->SetMouseVisible( true );
}
#else
#error
#endif
}
else
{
HideHardwareCursor();
}
}
//-----------------------------------------------------------------------------
// Purpose: prevents vgui from changing the cursor
//-----------------------------------------------------------------------------
void LockCursor( bool bEnable )
{
s_bCursorLocked = bEnable;
ActivateCurrentCursor();
}
//-----------------------------------------------------------------------------
// Purpose: unlocks the cursor state
//-----------------------------------------------------------------------------
bool IsCursorLocked()
{
return s_bCursorLocked;
}
//-----------------------------------------------------------------------------
// handles mouse movement
//-----------------------------------------------------------------------------
void CursorSetPos( void *hwnd, int x, int y )
{
#if defined( USE_SDL )
if ( s_bCursorVisible )
#endif
g_pInputSystem->SetCursorPosition( x, y );
}
void CursorGetPos(void *hwnd, int &x, int &y)
{
#if defined ( USE_SDL ) && !defined( PLATFORM_WINDOWS )
if ( s_bCursorVisible )
{
SDL_GetMouseState( &x, &y );
int windowHeight = 0;
int windowWidth = 0;
//unsigned int ignored;
SDL_GetWindowSize( ( SDL_Window * )g_pLauncherMgr->GetWindowRef(), &windowWidth, &windowHeight );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
int rx, ry, width, height;
pRenderContext->GetViewport( rx, ry, width, height );
if ( !s_bSoftwareCursorActive && (width != windowWidth || height != windowHeight ) )
{
// scale the x/y back into the co-ords of the back buffer, not the scaled up window
//DevMsg( "Mouse x:%d y:%d %d %d %d %d\n", x, y, width, windowWidth, height, abs( height - windowHeight ) );
x = x * (float)width/windowWidth;
y = y * (float)height/windowHeight;
}
}
else
{
// cursor is invisible, just say we have it pinned to the middle of the screen
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
int rx, ry, width, height;
pRenderContext->GetViewport( rx, ry, width, height );
x = rx + width/2;
y = ry + height/2;
//printf( "Mouse(inv) x:%d y:%d %d %d\n", x, y, width, height );
}
#else
POINT pt;
// Default implementation
VCRHook_GetCursorPos( &pt );
VCRHook_ScreenToClient((HWND)hwnd, &pt);
x = pt.x; y = pt.y;
#endif
}
void EnableSoftwareCursor( bool bEnable )
{
if( bEnable )
InitSoftwareCursors();
bool bWasEnabled = s_bSoftwareCursorActive;
s_bSoftwareCursorActive = bEnable;
// set the cursor to the arrow (or none if appropriate) if we're activating the
// software cursor. VGUI will likely update it again soon, but this will give
// us some kind of cursor in the meantime
if( !bWasEnabled && bEnable )
{
if( s_bCursorVisible )
CursorSelect( dc_arrow );
}
}
bool ShouldDrawSoftwareCursor()
{
return s_bSoftwareCursorActive && s_bCursorVisible;
}
int GetSoftwareCursorTexture( float *px, float *py )
{
if( px && py )
{
*px = s_fSoftwareCursorOffsetX;
*py = s_fSoftwareCursorOffsetY;
}
return s_nSoftwareCursorTexture;
}