747 lines
30 KiB
C++
747 lines
30 KiB
C++
//=========== Copyright Valve Corporation, All rights reserved. ===============//
|
|
//
|
|
// Purpose:
|
|
//=============================================================================//
|
|
|
|
#ifndef IUIENGINE_H
|
|
#define IUIENGINE_H
|
|
#pragma once
|
|
|
|
#include "tier0/platform.h"
|
|
|
|
#if defined( SOURCE2_PANORAMA )
|
|
#include "tier0/platwindow.h"
|
|
#endif
|
|
|
|
#include "tier1/convar.h"
|
|
#include "panorama.h"
|
|
#include "./iuipanel.h"
|
|
#include "utlsymbol.h"
|
|
#include "panoramatypes.h"
|
|
#include "iuilayoutmanager.h"
|
|
#include "controls/panelhandle.h"
|
|
#include "tier1/utllinkedlist.h"
|
|
#include "tier1/utlstring.h"
|
|
#include "tier1/utldelegate.h"
|
|
#include "tier0/validator.h"
|
|
#ifdef SOURCE_PANORAMA_FIXME
|
|
#include "tier1/UtlSortVector.h"
|
|
#else
|
|
#include "tier1/utlsortvector.h"
|
|
#endif
|
|
#include "language.h"
|
|
#include "panorama/layout/panel2dfactory.h"
|
|
#include "iuistylefactory.h"
|
|
#include "interface.h"
|
|
#include "steam/isteamhttp.h"
|
|
#include "iuifilesystem.h"
|
|
|
|
#if !defined( SOURCE2_PANORAMA )
|
|
#include "audio/iaudiointerface.h"
|
|
#include <openvr.h>
|
|
#endif
|
|
|
|
#if _GNUC
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wshadow"
|
|
#endif
|
|
#if defined( SOURCE2_PANORAMA )
|
|
#include "../thirdparty/v8/include/v8.h"
|
|
#else
|
|
#include "tier0/memdbgoff.h"
|
|
#include "../external/v8/include/v8.h"
|
|
#include "tier0/memdbgon.h"
|
|
#endif
|
|
#if _GNUC
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
|
|
#ifdef SUPPORTS_AUDIO
|
|
class IAudioOutputStream;
|
|
#endif
|
|
typedef uint64 GID_t;
|
|
class KeyValues;
|
|
#if !defined( SOURCE2_PANORAMA )
|
|
class IHTMLChromeController;
|
|
#endif
|
|
|
|
typedef CUtlDelegate< void( GID_t, KeyValues *, void * ) > JSONWebAPIDelegate_t;
|
|
|
|
#if defined( SOURCE2_PANORAMA )
|
|
DECLARE_LOGGING_CHANNEL( LOG_PANORAMA );
|
|
DECLARE_LOGGING_CHANNEL( LOG_PANORAMA_SCRIPT );
|
|
#endif
|
|
|
|
namespace v8
|
|
{
|
|
class Isolate;
|
|
}
|
|
|
|
namespace panorama
|
|
{
|
|
|
|
// forward decl for engine components
|
|
class CUIProtoBufMsgMemoryPoolMgr;
|
|
class CUIRenderEngine;
|
|
class IUIInput;
|
|
class IUIEvent;
|
|
class IUILocalization;
|
|
class IUISoundSystem;
|
|
class IUILayoutManager;
|
|
class CMovieManager;
|
|
class IUITextLayout;
|
|
class IUISettings;
|
|
class IUIWindow;
|
|
class CPanelStyle;
|
|
class IUIJSObject;
|
|
|
|
typedef void * HAUDIOSAMPLE;
|
|
|
|
class IUIEngineFrameListener
|
|
{
|
|
public:
|
|
virtual void OnPreFrame() = 0;
|
|
virtual void OnPostFrame() = 0;
|
|
virtual void OnEngineShutdown() = 0;
|
|
};
|
|
|
|
|
|
class CJSONWebAPIParams
|
|
{
|
|
public:
|
|
|
|
struct WebAPIParam_t
|
|
{
|
|
CUtlString strParamName;
|
|
CUtlString strParamValue;
|
|
};
|
|
|
|
CJSONWebAPIParams() { }
|
|
|
|
void AddParam( const char *pchParamName, const char *pchParamValue )
|
|
{
|
|
int iVec = m_vecParams.AddToTail();
|
|
WebAPIParam_t ¶m = m_vecParams[iVec];
|
|
param.strParamName = pchParamName;
|
|
param.strParamValue = pchParamValue;
|
|
}
|
|
|
|
CUtlVector<WebAPIParam_t> *AccessParams() { return &m_vecParams; }
|
|
|
|
private:
|
|
|
|
CCopyableUtlVector< WebAPIParam_t > m_vecParams;
|
|
};
|
|
|
|
typedef void (*PanoramaFrameFunc_t)();
|
|
|
|
typedef int JSGenericCallbackHandle_t;
|
|
const JSGenericCallbackHandle_t JS_GENERIC_CALLBACK_HANDLE_INVALID = -1;
|
|
|
|
struct RegisterJSScopeInfo_t
|
|
{
|
|
const char *pName;
|
|
const char *pDescription;
|
|
int nEntries;
|
|
};
|
|
|
|
enum RegisterJSType_t : uint8
|
|
{
|
|
k_ERegisterJSTypeUnknown,
|
|
k_ERegisterJSTypeInvalid,
|
|
k_ERegisterJSTypeVoid,
|
|
k_ERegisterJSTypeBool,
|
|
k_ERegisterJSTypeInt8,
|
|
k_ERegisterJSTypeUint8,
|
|
k_ERegisterJSTypeInt16,
|
|
k_ERegisterJSTypeUint16,
|
|
k_ERegisterJSTypeInt32,
|
|
k_ERegisterJSTypeUint32,
|
|
k_ERegisterJSTypeInt64,
|
|
k_ERegisterJSTypeUint64,
|
|
k_ERegisterJSTypeFloat,
|
|
k_ERegisterJSTypeDouble,
|
|
k_ERegisterJSTypeConstString,
|
|
k_ERegisterJSTypePanoramaSymbol,
|
|
k_ERegisterJSTypeRawV8Args,
|
|
};
|
|
|
|
struct RegisterJSEntryInfo_t
|
|
{
|
|
enum
|
|
{
|
|
k_EGlobalFunction = 0x00000000,
|
|
k_EMethod = 0x00000001,
|
|
k_EAccessor = 0x00000002,
|
|
k_EAccessorReadOnly = 0x00000003,
|
|
k_EConstantValue = 0x00000004,
|
|
k_EEntryTypeMask = 0x0000000f,
|
|
};
|
|
|
|
const char *pName;
|
|
const char *pDescription;
|
|
uint32 unFlags;
|
|
|
|
// Return or value type.
|
|
RegisterJSType_t eDataType;
|
|
|
|
// Prototype information may not be known.
|
|
static const uint8 k_unNumParamsUnknown = 0xff;
|
|
uint8 unNumParams;
|
|
|
|
static const uint8 k_unMaxParams = 10;
|
|
RegisterJSType_t pParamTypes[k_unMaxParams];
|
|
|
|
uint32 GetEntryType() const
|
|
{
|
|
return unFlags & k_EEntryTypeMask;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Interface that needs to be implemented for game engines on all platforms
|
|
//
|
|
class IUIEngine
|
|
{
|
|
public:
|
|
enum ERenderTarget
|
|
{
|
|
// these assignments are important because they are cross-cast at the protobuf layer
|
|
k_ERenderToWindow = 1,
|
|
k_ERenderFullScreen = 2,
|
|
k_ERenderBorderlessFullScreenWindow = 3,
|
|
k_ERenderToOverlayTexture = 4,
|
|
k_ERenderToOverlaySharedTexture = 5,
|
|
k_ERenderToOverlaySteamWM = 6,
|
|
k_ERenderToLegacyVR = 7, // This one is used for the Steam Client's main interface and will die eventually
|
|
k_ERenderToOpenVROverlay = 8,
|
|
|
|
k_ERenderTargetUnset = 0,
|
|
};
|
|
|
|
enum EHapticFeedbackPosition
|
|
{
|
|
k_EHapticFeedbackPosition_Left,
|
|
k_EHapticFeedbackPosition_Right,
|
|
};
|
|
|
|
enum EHapticFeedbackStrength
|
|
{
|
|
k_EHapticFeedbackStrength_VeryLow,
|
|
k_EHapticFeedbackStrength_Low,
|
|
k_EHapticFeedbackStrength_Medium,
|
|
k_EHapticFeedbackStrength_High,
|
|
};
|
|
|
|
// return true if the states are different and a valid transition. Used to test fullscreen transition
|
|
static bool BValidRenderStateChange( ERenderTarget eCurrentRenderTarget, ERenderTarget eRequestedRenderTarget );
|
|
static bool BIsRenderingToTexture( ERenderTarget eTarget ) { return (eTarget == k_ERenderToOverlayTexture || eTarget == k_ERenderToOverlaySharedTexture || eTarget == k_ERenderToOpenVROverlay ); }
|
|
static bool BIsOverlayTarget( ERenderTarget eTarget )
|
|
{
|
|
return (eTarget == IUIEngine::k_ERenderToOverlayTexture ||
|
|
eTarget == IUIEngine::k_ERenderToOverlaySharedTexture ||
|
|
eTarget == IUIEngine::k_ERenderToOverlaySteamWM);
|
|
}
|
|
static bool BIsRenderingToLegacyVR( ERenderTarget eTarget ) { return (eTarget == k_ERenderToLegacyVR); }
|
|
static bool BIsRenderingToOpenVROverlay( ERenderTarget eTarget ) { return (eTarget == k_ERenderToOpenVROverlay); }
|
|
static bool BIsRenderingToFullScreen( ERenderTarget eTarget ) { return (eTarget == k_ERenderFullScreen); }
|
|
|
|
public:
|
|
virtual ~IUIEngine() {}
|
|
|
|
// Starts up subsystems and makes engine ready for use, you need to call RegisterNamedLocalPath() for at least the <config> path first!
|
|
#if defined( SOURCE2_PANORAMA )
|
|
virtual bool StartupSubsystems( IUISettings *psettings, PlatWindow_t hWindow ) = 0;
|
|
#else
|
|
virtual bool StartupSubsystems( IUISettings *psettings, IHTMLChromeController *pHTMLController ) = 0;
|
|
#endif
|
|
|
|
// Hookup convars
|
|
virtual void ConCommandInit( IConCommandBaseAccessor *pAccessor ) = 0;
|
|
|
|
// Shutdown
|
|
virtual void Shutdown() = 0;
|
|
virtual void RequestShutdown() = 0;
|
|
|
|
// Run will run frames and block, letting the UI engine control the whole frame loop.
|
|
virtual void Run() = 0;
|
|
|
|
// Run frame will run a single frame, letting you wrap the UI engine in an external frame loop
|
|
virtual void RunFrame() = 0;
|
|
|
|
// Will set the UI engine to aggressively limit frame rate it runs at to avoid resource usage
|
|
virtual void SetAggressiveFrameRateLimit( bool bLimit ) = 0;
|
|
|
|
virtual bool BIsRunning() = 0;
|
|
virtual bool BHasFocus() = 0;
|
|
virtual double GetCurrentFrameTime() = 0;
|
|
|
|
#if !defined( SOURCE2_PANORAMA )
|
|
virtual IUIWindow *CreateNewWindow( const char *pchWindowTitle, uint32 width, uint32 height, ERenderTarget eRenderType, bool bFixedSurfaceSize, bool bEnforceWindowAspectRatio, bool bUseCustomMouseCursor, const char *pchMonitorName ) = 0;
|
|
virtual IUIWindow *CreateNewOverlayWindow( const char *pchWindowTitle, uint32 width, uint32 height, panorama::IUIEngine::ERenderTarget eTarget, bool bFixedSize, bool bDrawCustomMouseCursor ) = 0;
|
|
virtual IUIWindow *CreateNewOpenVROverlayWindow( uint32 width, uint32 height, vr::VROverlayHandle_t ulOverlayHandle ) = 0;
|
|
#else
|
|
virtual IUIWindow *CreateNewUILayerWindow( uint32 xPos, uint32 yPos, uint32 width, uint32 height, bool bFixedSurfaceSize, bool bEnforceWindowAspectRatio, bool bUseCustomMouseCursor, bool bAcceptKBandMouse, const char *pName ) = 0;
|
|
#endif
|
|
|
|
virtual IUITextLayout *CreateTextLayout( const char *pchText, const char *pchFontName, float flSize, float flLineHeight, EFontWeight weight, EFontStyle style, ETextAlign align, bool bWrap, bool bEllipsis, int nLetterSpacing, float flMaxWidth, float flMaxHeight ) = 0;
|
|
virtual IUITextLayout *CreateTextLayout( const wchar_t *pwchText, const char *pchFontName, float flSize, float flLineHeight, EFontWeight weight, EFontStyle style, ETextAlign align, bool bWrap, bool bEllipsis, int nLetterSpacing, float flMaxWidth, float flMaxHeight ) = 0;
|
|
virtual void FreeTextLayout( IUITextLayout *pLayout ) = 0;
|
|
virtual const CUtlSortVector< CUtlString > &GetSortedValidFontNames() = 0;
|
|
|
|
|
|
virtual IUIInput *UIInputEngine() = 0;
|
|
virtual IUILocalization *UILocalize() = 0;
|
|
virtual IUISoundSystem *UISoundSystem() = 0;
|
|
virtual IUISettings *UISettings() = 0;
|
|
virtual IUILayoutManager *UILayoutManager() = 0;
|
|
virtual IUIFileSystem *UIFileSystem() = 0;
|
|
|
|
virtual void RegisterFrameFunc( PanoramaFrameFunc_t frameFunc ) = 0;
|
|
|
|
virtual void ReloadLayoutFile( CPanoramaSymbol symPath ) = 0;
|
|
virtual void ToggleDebugMode() = 0;
|
|
virtual CUtlLinkedList<CUtlString> &GetConsoleHistory() = 0;
|
|
|
|
// panel management
|
|
virtual IUIPanel * CreatePanel() = 0;
|
|
virtual void PanelDestroyed( IUIPanel *pPanel, IUIPanel *pOldParent ) = 0;
|
|
virtual bool IsValidPanelPointer( const IUIPanel *pPanel ) = 0;
|
|
virtual PanelHandle_t GetPanelHandle( const IUIPanel *pPanel ) = 0;
|
|
virtual IUIPanel *GetPanelPtr( const PanelHandle_t &handle ) = 0;
|
|
virtual void CallBeforeStyleAndLayout( IUIPanel *pPanel ) = 0;
|
|
|
|
// registration for panel destroyed
|
|
typedef CUtlDelegate< void( const panorama::IUIPanel *, IUIPanel *pOldParent ) > PanelDestroyedDel_t;
|
|
virtual void RegisterForPanelDestroyed( PanelDestroyedDel_t del ) = 0;
|
|
virtual void UnregisterForPanelDestroyed( PanelDestroyedDel_t del ) = 0;
|
|
|
|
// Event management
|
|
virtual void RegisterEventHandler( CPanoramaSymbol symMsg, IUIPanel *pPanel, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void UnregisterEventHandler( CPanoramaSymbol symMsg, IUIPanel *pPanel, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void RegisterEventHandler( CPanoramaSymbol symMsg, IUIPanelClient *pPanel, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void UnregisterEventHandler( CPanoramaSymbol symMsg, IUIPanelClient *pPanel, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void UnregisterEventHandlersForPanel( IUIPanel *pPanel ) = 0;
|
|
virtual void RegisterForUnhandledEvent( CPanoramaSymbol symMsg, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void UnregisterForUnhandledEvent( CPanoramaSymbol symMsg, CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual bool BHaveEventHandlersRegisteredForType( CPanoramaSymbol symPanelType ) = 0;
|
|
virtual void RegisterPanelTypeEventHandler( CPanoramaSymbol symMsg, CPanoramaSymbol symPanelType, CUtlAbstractDelegate pFunc, bool bThisPtrIsUIPanel = false ) = 0;
|
|
virtual bool DispatchEvent( IUIEvent *pEvent ) = 0;
|
|
virtual void DispatchEventAsync( float flDelay, IUIEvent *pEvent ) = 0;
|
|
virtual bool BAnyHandlerRegisteredForEvent( const CPanoramaSymbol &symEvent ) = 0;
|
|
virtual CPanoramaSymbol GetLastDispatchedEventSymbol() = 0;
|
|
virtual IUIPanel *GetLastDispatchedEventTargetPanel() = 0;
|
|
|
|
// Event filtering
|
|
virtual void RegisterEventFilter( CUtlAbstractDelegate pFunc ) = 0;
|
|
virtual void UnregisterEventFilter( CUtlAbstractDelegate pFunc ) = 0;
|
|
|
|
// Repaints all windows immediately, queuing for animation/render threads
|
|
virtual void LayoutAndPaintWindows() = 0;
|
|
|
|
// Get install path for the application
|
|
virtual const char *GetApplicationInstallPath() = 0;
|
|
|
|
// Get the userdata path for the application
|
|
virtual const char *GetApplicationUserDataPath() = 0;
|
|
|
|
// Register a named local path (executable-relative, readonly on POSIX) for resources, should be something like {images} or {movies}
|
|
virtual void RegisterNamedLocalPath( const char *pathName, const char *pchLocalPath, bool bWatchForFileChanges, bool bAddToOverwriteIfExists = false ) = 0;
|
|
|
|
// Register a named userdata path (userdata-relative, writable on POSIX) for local read/write storage like {config}
|
|
virtual void RegisterNamedUserPath( const char *pathName, const char *pchUserPath, bool bWatchForFileChanges, bool bAddToOverwriteIfExists = false ) = 0;
|
|
|
|
// Register the path to load custom vfont files from
|
|
virtual void RegisterCustomFontPath( const char *pchFontPath ) = 0;
|
|
|
|
// Get the local path for a named path like {images} or {movies}
|
|
virtual const char *GetLocalPathForNamedPath( const char *pathName ) = 0;
|
|
|
|
// Get the local path for a named path like {images} or {movies} combined with the relative pathname
|
|
// and also following up the possible overwritten paths
|
|
virtual void GetLocalPathForRelativePath( const char *pchLocalPathName, const char *pchRelativePathname, CUtlString &strLocalPath ) = 0;
|
|
|
|
// Register for a named hostname in http:// paths like {steamcommunity}
|
|
virtual void RegisterNamedRemoteHost( const char *hostName, const char*pchRemoteHost ) = 0;
|
|
|
|
// Get the named host for a named remote host like {steamcommunity}
|
|
virtual const char *GetRemoteHostForNamedHost( const char *hostName ) = 0;
|
|
|
|
// Register an additional X-Header to be sent when requesting layout from the web
|
|
virtual void RegisterXHeader( const char *pchHeaderName, const char *pchHeaderValue ) = 0;
|
|
|
|
// Get the current count of registers X-Headers
|
|
virtual int GetXHeaderCount() const = 0;
|
|
|
|
// Get the name and value for the given indexed X-Header
|
|
virtual void GetXHeader( int i, CUtlString &strName, CUtlString &strValue ) const = 0;
|
|
|
|
// Set the cookie header to use for the named remote host
|
|
virtual void SetCookieHeaderForNamedRemoteHost( const char *hostName, const CUtlVector<CUtlString> &vecCookies ) = 0;
|
|
|
|
// Sets the cookie header to use for the remote host (doesn't require named host use)
|
|
virtual void SetCookieHeaderForRemoteHost( const char *hostName, const CUtlVector<CUtlString> &vecCookies ) = 0;
|
|
|
|
// Get the cookie header string that should be used for the remote host
|
|
virtual const CUtlVector<CUtlString> &GetCookieHeadersForNamedRemoteHost( const char *namedRemoteHost ) = 0;
|
|
|
|
// Get the cookie header string that should be used for the remote host
|
|
virtual const CUtlVector<CUtlString> &GetCookieHeadersForRemoteHost( const char *hostName ) = 0;
|
|
|
|
// Gets the value of a cookie. Returns false if the cookie does not exist.
|
|
virtual bool GetCookieValueForRemoteHost( const char *hostName, const char *cookieName, CUtlString *pstrCookieValue ) = 0;
|
|
|
|
#if defined( SOURCE2_PANORAMA ) || defined( PANORAMA_PUBLIC_STEAM_SDK )
|
|
virtual ISteamHTMLSurface *AccessHTMLController() = 0;
|
|
#else
|
|
virtual IHTMLChromeController *AccessHTMLController() = 0;
|
|
#endif
|
|
|
|
// native message box. Used usually for development.
|
|
enum ENativeMessageBoxType_t
|
|
{
|
|
k_ENativeMessageOk = 1,
|
|
k_ENativeMessageYesNo = 2
|
|
};
|
|
virtual bool ShowNativeTopMostMessageBox( const char *pchMsg, const char *pchTitle, ENativeMessageBoxType_t eType ) = 0;
|
|
|
|
// Add a listener callback for pre/post frame events
|
|
virtual void AddFrameListener( IUIEngineFrameListener *pListener ) = 0;
|
|
|
|
// Remove a listener callback for pre/post frame events
|
|
virtual void RemoveFrameListener( IUIEngineFrameListener *pListener ) = 0;
|
|
|
|
// storage for mouse can activate info
|
|
virtual void RegisterMouseCanActivateParent( IUIPanel *pPanel, const char *pchParent ) = 0;
|
|
virtual void UnregisterMouseCanActivateParent( IUIPanel *pPanel ) = 0;
|
|
virtual const char *GetMouseCanActivateParent( IUIPanel *pPanel ) = 0;
|
|
|
|
// See if any window owned by the ui engine has focus
|
|
virtual bool BAnyWindowHasFocus() = 0;
|
|
|
|
// See if any window owned by the ui engine is visible and has focus, sometimes overlay windows have focus but are not visible
|
|
// and you generally don't want to consider them as focused then
|
|
virtual bool BAnyVisibleWindowHasFocus() = 0;
|
|
|
|
// See if any overlay window owned by the ui engine has focus
|
|
virtual bool BAnyOverlayWindowHasFocus() = 0;
|
|
|
|
// Get the focused window, there should really be only one, if some bug allows multiple the first found is returned
|
|
virtual IUIWindow *GetFocusedWindow() = 0;
|
|
|
|
// Get the last time any input event happened across any of our windows
|
|
virtual double GetLastInputTime() = 0;
|
|
|
|
// Called internally from input layer to update last input time to current frame
|
|
virtual void UpdateLastInputTime() = 0;
|
|
|
|
// Clipboard access
|
|
virtual void CopyToClipboard( const char *pchTextUTF8 ) = 0;
|
|
virtual void GetClipboardText( CUtlString &strUTF8 ) = 0;
|
|
|
|
// Input locale support
|
|
virtual ELanguage GetDisplayLanguage() = 0;
|
|
virtual ELanguage GetCurrentInputLocale() = 0;
|
|
virtual bool BHaveInputLocale( ELanguage language ) = 0;
|
|
virtual void SetInputLocale( ELanguage language ) = 0;
|
|
|
|
// Overlay tracking
|
|
virtual bool BHasOverlayForApp( uint64 gameID, uint64 ulPID ) = 0;
|
|
virtual void TrackOverlayForApp( uint64 gameID, uint64 ulPID, void * pOverlay ) = 0;
|
|
virtual void DeleteOverlayInstanceForApp( uint64 gameID, uint64 dwPID, void * pOverlay ) = 0;
|
|
virtual void *OverlayForApp( uint64 gameID, uint64 ulPID ) = 0;
|
|
|
|
// GPU Information
|
|
virtual bool BGetGPUInformation( char *rgchGPUDesc, uint32 unGPUDescBytes, uint64 *pulDedicatedGPUMem, uint64 *pulDedicatedSystemMem, uint64 *pulSharedMem ) = 0;
|
|
|
|
// Pool allocations for panel styles
|
|
virtual IUIPanelStyle *AllocPanelStyle( IUIPanel *pStyle, float flUIScaleFactor ) = 0;
|
|
virtual void FreePanelStyle( IUIPanelStyle *pPanel ) = 0;
|
|
|
|
virtual void SetPanelWaitingAsyncDelete( IUIPanel *pPanel ) = 0;
|
|
virtual bool BIsPanelWaitingAsyncDelete( IUIPanel *pPanel ) = 0;
|
|
|
|
virtual void PulseActiveControllerHaptic( EHapticFeedbackPosition ePosition, EHapticFeedbackStrength eStrength ) = 0;
|
|
|
|
virtual void MarkLayerToRepaintThreadSafe( uint64 ulCompositionLayerID ) = 0;
|
|
|
|
virtual void AddDirectoryChangeWatch( const char *pchPath ) = 0;
|
|
|
|
// Get how many lines to scroll for mouse wheel
|
|
virtual uint32 GetWheelScrollLines() = 0;
|
|
|
|
// Execute some javascript in the given panel context
|
|
virtual void RunScript( IUIPanel *pPanelContext, const char *pchScriptString, const char *pchSourceFilename, int nSourceBeginLine, int nSourceBeginCol, bool bPrintRetValue ) = 0;
|
|
|
|
// Expose a new object type/template to javascript with the given name,
|
|
// the function pointer passed should setup member accssors/methods with the functions
|
|
// from uijsregistration.h
|
|
virtual void ExposeObjectTypeToJavaScript( const char *pchObjectTypeName, CUtlAbstractDelegate &del ) = 0;
|
|
|
|
// Expose an instance of an object type as a global with specified name to javascript
|
|
virtual void ExposeGlobalObjectToJavaScript( const char *pchJSVarName, void *pInstance, const char *pchJsTypeName, bool bTrueGlobal = false ) = 0;
|
|
|
|
virtual void ClearGlobalObjectForJavaScript( const char *pchJSVarName, void *pInstance ) = 0;
|
|
|
|
virtual void DeleteJSObjectInstance( IUIJSObject *pInstance ) = 0;
|
|
|
|
// Get panel that contains the javascript context
|
|
virtual panorama::IUIPanel *GetPanelForJavaScriptContext( v8::Context *pContext ) = 0;
|
|
|
|
// Get javascript context for a panel (may be NULL)
|
|
virtual v8::Persistent<v8::Context> *GetJavaScriptContextForPanel( panorama::IUIPanel *pPanel ) = 0;
|
|
|
|
// Helper to spew exceptions to console
|
|
virtual void OutputJSExceptionToConsole( v8::TryCatch &try_catch, IUIPanel *pPanelContext ) = 0;
|
|
|
|
// Add a function template to global namespace, by default this is really panorama., but you can specify to make it really global as well
|
|
virtual void AddGlobalV8FunctionTemplate( const char *pchJSFuncName, v8::Handle< v8::FunctionTemplate > *pFunc, bool bTrueGlobal = false ) = 0;
|
|
|
|
// Get global v8 context
|
|
virtual v8::Persistent<v8::Context> &GetV8GlobalContext() = 0;
|
|
|
|
// Access the current object template we are setting up
|
|
virtual v8::Handle<v8::ObjectTemplate> GetCurrentV8ObjectTemplateToSetup() = 0;
|
|
|
|
// Allow access to the proto buf msg memory pool
|
|
virtual CUIProtoBufMsgMemoryPoolMgr *MsgMemoryPoolMgr() = 0;
|
|
|
|
// Allow access to style factory interface
|
|
virtual IUIStyleFactory *UIStyleFactory() = 0;
|
|
|
|
// Various code that uses JS needs this
|
|
virtual v8::Isolate * GetV8Isolate() = 0;
|
|
|
|
// Create a V8 object to wrap a panel
|
|
virtual v8::Persistent<v8::Object> *CreateV8PanelInstance( IUIPanel *pPanel ) = 0;
|
|
|
|
// Helper to create a JS object to wrap a given panel style
|
|
virtual v8::Persistent<v8::Object> *CreateV8PanelStyleInstance( IUIPanelStyle *pPanelStyle ) = 0;
|
|
|
|
// Helper to create JS object for given js object type
|
|
virtual v8::Persistent<v8::Object> *CreateV8ObjectInstance( const char *pchObjectType, void *pActualObject, IUIJSObject *pJSObject ) = 0;
|
|
|
|
// Create JSON web api job, use the helpers in uiwebapiclient.h directly instead, this is there for them to use internally
|
|
virtual uint32 InitiateAsyncJSONWebAPIRequest( EHTTPMethod eMethod, CUtlString strURL, IUIPanel *pCallbackTargetPanel, void *pContext, CJSONWebAPIParams *pParams = NULL, HTTPCookieContainerHandle hCookieContainer = INVALID_HTTPCOOKIE_HANDLE ) = 0;
|
|
|
|
// Create JSON web api job, use the helpers in uiwebapiclient.h directly instead, this is there for them to use internally
|
|
virtual uint32 InitiateAsyncJSONWebAPIRequest( EHTTPMethod eMethod, CUtlString strURL, JSONWebAPIDelegate_t callback, void *pContext, CJSONWebAPIParams *pParams = NULL, HTTPCookieContainerHandle hCookieContainer = INVALID_HTTPCOOKIE_HANDLE ) = 0;
|
|
|
|
// Cancel previously created web api request job
|
|
virtual void CancelAsyncJSONWebAPIRequest( uint32 requestID ) = 0;
|
|
|
|
// Resolves a path that may contain named path portions, etc, to a full local path
|
|
virtual CUtlString ResolvePath( const char *pchPath ) = 0;
|
|
|
|
// Used internally by initialization code to register events with framework
|
|
virtual void RegisterEventWithEngine( CPanoramaSymbol symEvent, UIEventFactory factory ) = 0;
|
|
|
|
// Check if a symbol is a valid event name
|
|
virtual bool IsValidEventName( const CPanoramaSymbol symEvent ) = 0;
|
|
|
|
// Check if a symbol is a valid panel event name
|
|
virtual bool IsValidPanelEvent( const CPanoramaSymbol symEvent, int *pParams ) = 0;
|
|
|
|
// Create input event from symbol, internal framework use
|
|
virtual IUIEvent *CreateInputEventFromSymbol( CPanoramaSymbol symEvent, IUIPanel *pPanel, EPanelEventSource_t eSource, int nRepeats ) = 0;
|
|
|
|
// Create an event from a string representation
|
|
virtual IUIEvent *CreateEventFromString( IUIPanel *pCreatingPanel, const char *pchEvent, const char **pchEventEnd ) = 0;
|
|
|
|
// Used internally by initialization code to register panels with framework
|
|
virtual void RegisterPanelFactoryWithEngine( CPanoramaSymbol symPanelType, CPanel2DFactory *pFactory ) = 0;
|
|
|
|
// Is the panel type registered
|
|
virtual bool BRegisteredPanelType( CPanoramaSymbol symPanelType ) = 0;
|
|
|
|
// Factory func for creating panels
|
|
virtual IUIPanelClient *CreatePanel( CPanoramaSymbol symName, const char *pchID, panorama::IUIPanel *parent ) = 0;
|
|
|
|
// Create debugger window
|
|
virtual void CreateDebuggerWindow() = 0;
|
|
|
|
// Close debugger window
|
|
virtual void CloseDebuggerWindow() = 0;
|
|
|
|
// Register any delegate to run at specified time, be sure to use CancelScheduledDelgate if you delete the object the delgate runs on, etc.
|
|
virtual int RegisterScheduledDelegate( double flTargetFrameTime, CUtlDelegate< void() > del ) = 0;
|
|
|
|
// Cancel a scheduled delegate by index returned from RegisterScheduledDelegate
|
|
virtual void CancelScheduledDelegate( int iScheduleIndex ) = 0;
|
|
|
|
// Return the last frame time for which we already ran scheduled delegates
|
|
virtual double GetLastScheduledDelegateRunTime() = 0;
|
|
|
|
// CPanoramaSymbol support for cross DLL symbols
|
|
virtual UtlSymId_t MakeSymbol( const char *pchText ) = 0;
|
|
|
|
// CPanoramaSymbol support for cross DLL symbols
|
|
virtual const char * ResolveSymbol( const UtlSymId_t sym ) = 0;
|
|
|
|
// Interface to allow animation/render threads to queue a decrement of a ref count on an object next frame in the main thread
|
|
virtual void QueueDecrementRefNextFrame( CRefCount *pRefCountObj ) = 0;
|
|
|
|
// Register a V8 callback function associated with a given UI panel
|
|
virtual JSGenericCallbackHandle_t RegisterJSGenericCallback( panorama::IUIPanel *pContextPanel, v8::Handle< v8::Function > callbackFunc ) = 0;
|
|
|
|
// Invoke a callback previously registered with the system. Returns false if the handle has expired (the context panel is gone, or it was explicitly unregistered)
|
|
virtual bool InvokeJSGenericCallback( JSGenericCallbackHandle_t nHandle, int nArgs = 0, v8::Handle< v8::Value > *pArgs = NULL, v8::Handle< v8::Value > *pOutRetVal = NULL ) = 0;
|
|
|
|
// Explicitly remove the callback from the system (future invokes on the handle will do nothing and return false)
|
|
virtual void UnregisterJSGenericCallback( JSGenericCallbackHandle_t nHandle ) = 0;
|
|
|
|
// Return the number of scopes, such as classes, that JS functions
|
|
// have been registered in.
|
|
virtual int GetNumRegisterJSScopes() = 0;
|
|
|
|
// Return information on a JS registration scope.
|
|
virtual void GetRegisterJSScopeInfo( int nScope, RegisterJSScopeInfo_t *pInfo ) = 0;
|
|
|
|
// Return information on a specific entry in a JS registration scope,
|
|
// such as a method in a class scope.
|
|
virtual void GetRegisterJSEntryInfo( int nScope, int nEntry, RegisterJSEntryInfo_t *pInfo ) = 0;
|
|
|
|
// Open a new scope for JS registrations.
|
|
virtual int StartRegisterJSScope( const char *pName, const char *pDesc = NULL ) = 0;
|
|
|
|
// Close current JS registration scope.
|
|
virtual void EndRegisterJSScope() = 0;
|
|
|
|
// If there is a current JS registration scope allocate a new entry
|
|
// and fill it out. If there is no scope, which is possible as
|
|
// recording registration info is only enabled in certain places,
|
|
// this will return -1.
|
|
virtual int NewRegisterJSEntry( const char *pName, uint32 unFlags, const char *pDesc = NULL, RegisterJSType_t eDataType = k_ERegisterJSTypeUnknown ) = 0;
|
|
|
|
// If there is a current JS registration entry set the parameter
|
|
// type information in it. Silently ignores -1 entry indices
|
|
// so this can be called safely when there is no scope.
|
|
virtual void SetRegisterJSEntryParams( int nEntry, uint8 unNumParams, RegisterJSType_t *pParamTypes ) = 0;
|
|
|
|
// Invalidate cached copies of all layout/style/script files (used eg. by the game when search paths change)
|
|
// (Does NOT rebuild or reload any existing UI, just causes subsequent references to the files to load from scratch.)
|
|
virtual void ClearFileCache() = 0;
|
|
|
|
// Spew the current list of all cached files and their refcounts (for debugging)
|
|
virtual void PrintCacheStatus() = 0;
|
|
|
|
// get a list of all the windows owned by the engine
|
|
virtual void GetWindowsForDebugger( CUtlVector<IUIWindow *> &vecWindows ) = 0;
|
|
|
|
// Turn on paint count tracking for panels
|
|
virtual void SetPaintCountTrackingEnabled( bool bEnablePaintCountTracking ) = 0;
|
|
|
|
// Is paint count tracking on for panels
|
|
virtual bool GetPaintCountTrackingEnabled() = 0;
|
|
|
|
// Increment paint count tracking for panels
|
|
virtual void IncrementPaintCountForPanel( uint64 ulPanelPtrValue, bool bRequiredCompositionLayer, double flFrameTime ) = 0;
|
|
|
|
// Get panel paint info for the panel
|
|
virtual void GetPanelPaintInfo( uint64 ulPanelPtrValue, uint32 &unPaintCount, bool &bRequiredCompositionLayer, double &flFrameTimeLastPaint ) = 0;
|
|
|
|
// Returns whether any windows exist for the UI engine
|
|
virtual bool BHasAnyWindows() = 0;
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
// Memory validation related interfaces
|
|
virtual bool PrepareForValidate() = 0;
|
|
virtual bool ResumeFromValidate() = 0;
|
|
virtual void Validate( CValidator &validator, const tchar *pchName ) = 0;
|
|
#endif
|
|
|
|
#if defined( SOURCE2_PANORAMA )
|
|
virtual void TextEntryFocusChange( IUIPanel *pPanel ) = 0;
|
|
virtual void TextEntryInvalid( IUIPanel *pPanel ) = 0;
|
|
#endif
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Helper for render state transitions, returns true if a state
|
|
// change is being requested, and it is valid. Helper for fullscreen switching.
|
|
//-----------------------------------------------------------------------------
|
|
inline bool IUIEngine::BValidRenderStateChange( ERenderTarget eCurrentRenderTarget, ERenderTarget eRequestedRenderTarget )
|
|
{
|
|
if( eCurrentRenderTarget == eRequestedRenderTarget )
|
|
return false;
|
|
|
|
// if we are in a mode that can switch...
|
|
if( eCurrentRenderTarget == IUIEngine::k_ERenderFullScreen || eCurrentRenderTarget == IUIEngine::k_ERenderToWindow )
|
|
{
|
|
switch( eRequestedRenderTarget ) // test if request is for a state that can be switched to
|
|
{
|
|
case IUIEngine::k_ERenderFullScreen:
|
|
case IUIEngine::k_ERenderToWindow:
|
|
return true; // we can change
|
|
default:
|
|
return false; // not so much
|
|
}
|
|
}
|
|
|
|
// render to texture toggled shared vs copied texture
|
|
if( BIsRenderingToTexture( eCurrentRenderTarget ) &&
|
|
BIsRenderingToTexture( eRequestedRenderTarget ) &&
|
|
(eCurrentRenderTarget != eRequestedRenderTarget) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#ifndef PANORAMA_EXPORTS
|
|
extern IUIEngine *g_pUIEngineSingleton;
|
|
extern CSysModule *g_PanoramaModule;
|
|
|
|
inline IUIEngine *UIEngine() { return g_pUIEngineSingleton; }
|
|
inline IUILocalization *UILocalize() { return UIEngine()->UILocalize(); }
|
|
inline IUISoundSystem *UISoundSystem() { return UIEngine()->UISoundSystem(); }
|
|
inline IUIInput *UIInputEngine() { return UIEngine() ? UIEngine()->UIInputEngine() : NULL; }
|
|
#else
|
|
IUIEngine *UIEngine();
|
|
IUILocalization *UILocalize();
|
|
IUIInput *UIInputEngine();
|
|
IUISoundSystem *UISoundSystem();
|
|
#endif
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
PANORAMA_INTERFACE void ValidateStaticsInternal( CValidator &validator );
|
|
#endif
|
|
|
|
PANORAMA_INTERFACE IUIEngine *CreatePanoramaUIEngineInternal();
|
|
|
|
extern void RegisterEventTypesWithEngine( IUIEngine *pEngine );
|
|
|
|
#ifndef PANORAMA_EXPORTS
|
|
extern bool LoadPanoramaModule( const char *pchPanoramaModulePath );
|
|
extern void UnloadPanoramaModule();
|
|
|
|
extern IUIEngine *CreatePanoramaUIEngine();
|
|
extern void ConnectPanoramaUIEngine( IUIEngine * );
|
|
extern void ShutdownPanoramaUIEngine( IUIEngine * );
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
extern void ValidateStatics( CValidator &validator );
|
|
#endif
|
|
#endif
|
|
|
|
|
|
// To expose a generic object via UIEngine()->ExposeObjectTypeToJavaScript() you should derive from this interface
|
|
// the GetTypeName member should return the same type name you register as exposed
|
|
class IUIJSObject
|
|
{
|
|
public:
|
|
~IUIJSObject()
|
|
{
|
|
UIEngine()->DeleteJSObjectInstance( this );
|
|
}
|
|
|
|
virtual const char *GetJSTypeName() = 0;
|
|
};
|
|
|
|
|
|
} // namespace panorama
|
|
|
|
#endif // IUIENGINE_H
|