diff options
Diffstat (limited to 'public/cdll_int.h')
| -rw-r--r-- | public/cdll_int.h | 809 |
1 files changed, 809 insertions, 0 deletions
diff --git a/public/cdll_int.h b/public/cdll_int.h new file mode 100644 index 0000000..557379a --- /dev/null +++ b/public/cdll_int.h @@ -0,0 +1,809 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Interfaces between the client.dll and engine +// +//===========================================================================// + +#ifndef CDLL_INT_H +#define CDLL_INT_H +#ifdef _WIN32 +#pragma once +#endif + +#include "basetypes.h" +#include "interface.h" +#include "mathlib/mathlib.h" +#include "const.h" +#include "checksum_crc.h" +#include "datamap.h" +#include "tier1/bitbuf.h" +#include "inputsystem/ButtonCode.h" +#include "modes.h" + +#if !defined( _X360 ) +#include "xbox/xboxstubs.h" +#endif + +//----------------------------------------------------------------------------- +// forward declarations +//----------------------------------------------------------------------------- +class ClientClass; +struct model_t; +class CSentence; +struct vrect_t; +struct cmodel_t; +class IMaterial; +class CAudioSource; +class CMeasureSection; +class SurfInfo; +class ISpatialQuery; +struct cache_user_t; +class IMaterialSystem; +class VMatrix; +struct ScreenFade_t; +struct ScreenShake_t; +class CViewSetup; +class CEngineSprite; +class CGlobalVarsBase; +class CPhysCollide; +class CSaveRestoreData; +class INetChannelInfo; +struct datamap_t; +struct typedescription_t; +class CStandardRecvProxies; +struct client_textmessage_t; +class IAchievementMgr; +class CGamestatsData; +class KeyValues; +class IFileList; +class CRenamedRecvTableInfo; +class CMouthInfo; +class IConVar; + +//----------------------------------------------------------------------------- +// Purpose: This data structure is filled in by the engine when the client .dll requests information about +// other players that the engine knows about +//----------------------------------------------------------------------------- + +// Engine player info, no game related infos here +// If you change this, change the two byteswap defintions: +// cdll_client_int.cpp and cdll_engine_int.cpp +typedef struct player_info_s +{ + DECLARE_BYTESWAP_DATADESC(); + // scoreboard information + char name[MAX_PLAYER_NAME_LENGTH]; + // local server user ID, unique while server is running + int userID; + // global unique player identifer + char guid[SIGNED_GUID_LEN + 1]; + // friends identification number + uint32 friendsID; + // friends name + char friendsName[MAX_PLAYER_NAME_LENGTH]; + // true, if player is a bot controlled by game.dll + bool fakeplayer; + // true if player is the HLTV proxy + bool ishltv; +#if defined( REPLAY_ENABLED ) + // true if player is the Replay proxy + bool isreplay; +#endif + // custom files CRC for this player + CRC32_t customFiles[MAX_CUSTOM_FILES]; + // this counter increases each time the server downloaded a new file + unsigned char filesDownloaded; +} player_info_t; + + +//----------------------------------------------------------------------------- +// Hearing info +//----------------------------------------------------------------------------- +struct AudioState_t +{ + Vector m_Origin; + QAngle m_Angles; + bool m_bIsUnderwater; +}; + + +//----------------------------------------------------------------------------- +// Skybox visibility +//----------------------------------------------------------------------------- +enum SkyboxVisibility_t +{ + SKYBOX_NOT_VISIBLE = 0, + SKYBOX_3DSKYBOX_VISIBLE, + SKYBOX_2DSKYBOX_VISIBLE, +}; + +//----------------------------------------------------------------------------- +// Skybox materials +//----------------------------------------------------------------------------- +struct SkyBoxMaterials_t +{ + // order: "rt", "bk", "lf", "ft", "up", "dn" + IMaterial *material[6]; +}; + +//----------------------------------------------------------------------------- +// Purpose: The engine reports to the client DLL what stage it's entering so the DLL can latch events +// and make sure that certain operations only happen during the right stages. +// The value for each stage goes up as you move through the frame so you can check ranges of values +// and if new stages get added in-between, the range is still valid. +//----------------------------------------------------------------------------- +enum ClientFrameStage_t +{ + FRAME_UNDEFINED=-1, // (haven't run any frames yet) + FRAME_START, + + // A network packet is being recieved + FRAME_NET_UPDATE_START, + // Data has been received and we're going to start calling PostDataUpdate + FRAME_NET_UPDATE_POSTDATAUPDATE_START, + // Data has been received and we've called PostDataUpdate on all data recipients + FRAME_NET_UPDATE_POSTDATAUPDATE_END, + // We've received all packets, we can now do interpolation, prediction, etc.. + FRAME_NET_UPDATE_END, + + // We're about to start rendering the scene + FRAME_RENDER_START, + // We've finished rendering the scene. + FRAME_RENDER_END +}; + +// Used by RenderView +enum RenderViewInfo_t +{ + RENDERVIEW_UNSPECIFIED = 0, + RENDERVIEW_DRAWVIEWMODEL = (1<<0), + RENDERVIEW_DRAWHUD = (1<<1), + RENDERVIEW_SUPPRESSMONITORRENDERING = (1<<2), +}; + +//----------------------------------------------------------------------------- +// Lightcache entry handle +//----------------------------------------------------------------------------- +DECLARE_POINTER_HANDLE( LightCacheHandle_t ); + + +//----------------------------------------------------------------------------- +// Occlusion parameters +//----------------------------------------------------------------------------- +struct OcclusionParams_t +{ + float m_flMaxOccludeeArea; + float m_flMinOccluderArea; +}; + + +//----------------------------------------------------------------------------- +// Just an interface version name for the random number interface +// See vstdlib/random.h for the interface definition +// NOTE: If you change this, also change VENGINE_SERVER_RANDOM_INTERFACE_VERSION in eiface.h +//----------------------------------------------------------------------------- +#define VENGINE_CLIENT_RANDOM_INTERFACE_VERSION "VEngineRandom001" + +// change this when the new version is incompatable with the old +#define VENGINE_CLIENT_INTERFACE_VERSION "VEngineClient014" +#define VENGINE_CLIENT_INTERFACE_VERSION_13 "VEngineClient013" + +//----------------------------------------------------------------------------- +// Purpose: Interface exposed from the engine to the client .dll +//----------------------------------------------------------------------------- +abstract_class IVEngineClient013 +{ +public: + // Find the model's surfaces that intersect the given sphere. + // Returns the number of surfaces filled in. + virtual int GetIntersectingSurfaces( + const model_t *model, + const Vector &vCenter, + const float radius, + const bool bOnlyVisibleSurfaces, // Only return surfaces visible to vCenter. + SurfInfo *pInfos, + const int nMaxInfos) = 0; + + // Get the lighting intensivty for a specified point + // If bClamp is specified, the resulting Vector is restricted to the 0.0 to 1.0 for each element + virtual Vector GetLightForPoint(const Vector &pos, bool bClamp) = 0; + + // Traces the line and reports the material impacted as well as the lighting information for the impact point + virtual IMaterial *TraceLineMaterialAndLighting( const Vector &start, const Vector &end, + Vector &diffuseLightColor, Vector& baseColor ) = 0; + + // Given an input text buffer data pointer, parses a single token into the variable token and returns the new + // reading position + virtual const char *ParseFile( const char *data, char *token, int maxlen ) = 0; + virtual bool CopyLocalFile( const char *source, const char *destination ) = 0; + + // Gets the dimensions of the game window + virtual void GetScreenSize( int& width, int& height ) = 0; + + // Forwards szCmdString to the server, sent reliably if bReliable is set + virtual void ServerCmd( const char *szCmdString, bool bReliable = true ) = 0; + // Inserts szCmdString into the command buffer as if it was typed by the client to his/her console. + // Note: Calls to this are checked against FCVAR_CLIENTCMD_CAN_EXECUTE (if that bit is not set, then this function can't change it). + // Call ClientCmd_Unrestricted to have access to FCVAR_CLIENTCMD_CAN_EXECUTE vars. + virtual void ClientCmd( const char *szCmdString ) = 0; + + // Fill in the player info structure for the specified player index (name, model, etc.) + virtual bool GetPlayerInfo( int ent_num, player_info_t *pinfo ) = 0; + + // Retrieve the player entity number for a specified userID + virtual int GetPlayerForUserID( int userID ) = 0; + + // Retrieves text message system information for the specified message by name + virtual client_textmessage_t *TextMessageGet( const char *pName ) = 0; + + // Returns true if the console is visible + virtual bool Con_IsVisible( void ) = 0; + + // Get the entity index of the local player + virtual int GetLocalPlayer( void ) = 0; + + // Client DLL is hooking a model, loads the model into memory and returns pointer to the model_t + virtual const model_t *LoadModel( const char *pName, bool bProp = false ) = 0; + + // Get accurate, sub-frame clock ( profiling use ) + virtual float Time( void ) = 0; + + // Get the exact server timesstamp ( server time ) from the last message received from the server + virtual float GetLastTimeStamp( void ) = 0; + + // Given a CAudioSource (opaque pointer), retrieve the underlying CSentence object ( stores the words, phonemes, and close + // captioning data ) + virtual CSentence *GetSentence( CAudioSource *pAudioSource ) = 0; + // Given a CAudioSource, determines the length of the underlying audio file (.wav, .mp3, etc.) + virtual float GetSentenceLength( CAudioSource *pAudioSource ) = 0; + // Returns true if the sound is streaming off of the hard disk (instead of being memory resident) + virtual bool IsStreaming( CAudioSource *pAudioSource ) const = 0; + + // Copy current view orientation into va + virtual void GetViewAngles( QAngle& va ) = 0; + // Set current view orientation from va + virtual void SetViewAngles( QAngle& va ) = 0; + + // Retrieve the current game's maxclients setting + virtual int GetMaxClients( void ) = 0; + + // Given the string pBinding which may be bound to a key, + // returns the string name of the key to which this string is bound. Returns NULL if no such binding exists + virtual const char *Key_LookupBinding( const char *pBinding ) = 0; + + // Given the name of the key "mouse1", "e", "tab", etc., return the string it is bound to "+jump", "impulse 50", etc. + virtual const char *Key_BindingForKey( ButtonCode_t code ) = 0; + + // key trapping (for binding keys) + virtual void StartKeyTrapMode( void ) = 0; + virtual bool CheckDoneKeyTrapping( ButtonCode_t &code ) = 0; + + // Returns true if the player is fully connected and active in game (i.e, not still loading) + virtual bool IsInGame( void ) = 0; + // Returns true if the player is connected, but not necessarily active in game (could still be loading) + virtual bool IsConnected( void ) = 0; + // Returns true if the loading plaque should be drawn + virtual bool IsDrawingLoadingImage( void ) = 0; + + // Prints the formatted string to the notification area of the screen ( down the right hand edge + // numbered lines starting at position 0 + virtual void Con_NPrintf( int pos, PRINTF_FORMAT_STRING const char *fmt, ... ) = 0; + // Similar to Con_NPrintf, but allows specifying custom text color and duration information + virtual void Con_NXPrintf( const struct con_nprint_s *info, PRINTF_FORMAT_STRING const char *fmt, ... ) = 0; + + // Is the specified world-space bounding box inside the view frustum? + virtual int IsBoxVisible( const Vector& mins, const Vector& maxs ) = 0; + + // Is the specified world-space boudning box in the same PVS cluster as the view origin? + virtual int IsBoxInViewCluster( const Vector& mins, const Vector& maxs ) = 0; + + // Returns true if the specified box is outside of the view frustum and should be culled + virtual bool CullBox( const Vector& mins, const Vector& maxs ) = 0; + + // Allow the sound system to paint additional data (during lengthy rendering operations) to prevent stuttering sound. + virtual void Sound_ExtraUpdate( void ) = 0; + + // Get the current game directory ( e.g., hl2, tf2, cstrike, hl1 ) + virtual const char *GetGameDirectory( void ) = 0; + + // Get access to the world to screen transformation matrix + virtual const VMatrix& WorldToScreenMatrix() = 0; + + // Get the matrix to move a point from world space into view space + // (translate and rotate so the camera is at the origin looking down X). + virtual const VMatrix& WorldToViewMatrix() = 0; + + // The .bsp file can have mod-specified data lumps. These APIs are for working with such game lumps. + + // Get mod-specified lump version id for the specified game data lump + virtual int GameLumpVersion( int lumpId ) const = 0; + // Get the raw size of the specified game data lump. + virtual int GameLumpSize( int lumpId ) const = 0; + // Loads a game lump off disk, writing the data into the buffer pointed to bye pBuffer + // Returns false if the data can't be read or the destination buffer is too small + virtual bool LoadGameLump( int lumpId, void* pBuffer, int size ) = 0; + + // Returns the number of leaves in the level + virtual int LevelLeafCount() const = 0; + + // Gets a way to perform spatial queries on the BSP tree + virtual ISpatialQuery* GetBSPTreeQuery() = 0; + + // Convert texlight to gamma... + virtual void LinearToGamma( float* linear, float* gamma ) = 0; + + // Get the lightstyle value + virtual float LightStyleValue( int style ) = 0; + + // Computes light due to dynamic lighting at a point + // If the normal isn't specified, then it'll return the maximum lighting + virtual void ComputeDynamicLighting( const Vector& pt, const Vector* pNormal, Vector& color ) = 0; + + // Returns the color of the ambient light + virtual void GetAmbientLightColor( Vector& color ) = 0; + + // Returns the dx support level + virtual int GetDXSupportLevel() = 0; + + // GR - returns the HDR support status + virtual bool SupportsHDR() = 0; + + // Replace the engine's material system pointer. + virtual void Mat_Stub( IMaterialSystem *pMatSys ) = 0; + + // Get the name of the current map + virtual void GetChapterName( char *pchBuff, int iMaxLength ) = 0; + virtual char const *GetLevelName( void ) = 0; + virtual int GetLevelVersion( void ) = 0; +#if !defined( NO_VOICE ) + // Obtain access to the voice tweaking API + virtual struct IVoiceTweak_s *GetVoiceTweakAPI( void ) = 0; +#endif + // Tell engine stats gathering system that the rendering frame is beginning/ending + virtual void EngineStats_BeginFrame( void ) = 0; + virtual void EngineStats_EndFrame( void ) = 0; + + // This tells the engine to fire any events (temp entity messages) that it has queued up this frame. + // It should only be called once per frame. + virtual void FireEvents() = 0; + + // Returns an area index if all the leaves are in the same area. If they span multple areas, then it returns -1. + virtual int GetLeavesArea( int *pLeaves, int nLeaves ) = 0; + + // Returns true if the box touches the specified area's frustum. + virtual bool DoesBoxTouchAreaFrustum( const Vector &mins, const Vector &maxs, int iArea ) = 0; + + // Sets the hearing origin (i.e., the origin and orientation of the listener so that the sound system can spatialize + // sound appropriately ). + virtual void SetAudioState( const AudioState_t& state ) = 0; + + // Sentences / sentence groups + virtual int SentenceGroupPick( int groupIndex, char *name, int nameBufLen ) = 0; + virtual int SentenceGroupPickSequential( int groupIndex, char *name, int nameBufLen, int sentenceIndex, int reset ) = 0; + virtual int SentenceIndexFromName( const char *pSentenceName ) = 0; + virtual const char *SentenceNameFromIndex( int sentenceIndex ) = 0; + virtual int SentenceGroupIndexFromName( const char *pGroupName ) = 0; + virtual const char *SentenceGroupNameFromIndex( int groupIndex ) = 0; + virtual float SentenceLength( int sentenceIndex ) = 0; + + // Computes light due to dynamic lighting at a point + // If the normal isn't specified, then it'll return the maximum lighting + // If pBoxColors is specified (it's an array of 6), then it'll copy the light contribution at each box side. + virtual void ComputeLighting( const Vector& pt, const Vector* pNormal, bool bClamp, Vector& color, Vector *pBoxColors=NULL ) = 0; + + // Activates/deactivates an occluder... + virtual void ActivateOccluder( int nOccluderIndex, bool bActive ) = 0; + virtual bool IsOccluded( const Vector &vecAbsMins, const Vector &vecAbsMaxs ) = 0; + + // The save restore system allocates memory from a shared memory pool, use this allocator to allocate/free saverestore + // memory. + virtual void *SaveAllocMemory( size_t num, size_t size ) = 0; + virtual void SaveFreeMemory( void *pSaveMem ) = 0; + + // returns info interface for client netchannel + virtual INetChannelInfo *GetNetChannelInfo( void ) = 0; + + // Debugging functionality: + // Very slow routine to draw a physics model + virtual void DebugDrawPhysCollide( const CPhysCollide *pCollide, IMaterial *pMaterial, matrix3x4_t& transform, const color32 &color ) = 0; + // This can be used to notify test scripts that we're at a particular spot in the code. + virtual void CheckPoint( const char *pName ) = 0; + // Draw portals if r_DrawPortals is set (Debugging only) + virtual void DrawPortals() = 0; + // Determine whether the client is playing back or recording a demo + virtual bool IsPlayingDemo( void ) = 0; + virtual bool IsRecordingDemo( void ) = 0; + virtual bool IsPlayingTimeDemo( void ) = 0; + virtual int GetDemoRecordingTick( void ) = 0; + virtual int GetDemoPlaybackTick( void ) = 0; + virtual int GetDemoPlaybackStartTick( void ) = 0; + virtual float GetDemoPlaybackTimeScale( void ) = 0; + virtual int GetDemoPlaybackTotalTicks( void ) = 0; + // Is the game paused? + virtual bool IsPaused( void ) = 0; + // Is the game currently taking a screenshot? + virtual bool IsTakingScreenshot( void ) = 0; + // Is this a HLTV broadcast ? + virtual bool IsHLTV( void ) = 0; + // is this level loaded as just the background to the main menu? (active, but unplayable) + virtual bool IsLevelMainMenuBackground( void ) = 0; + // returns the name of the background level + virtual void GetMainMenuBackgroundName( char *dest, int destlen ) = 0; + + // Get video modes + virtual void GetVideoModes( int &nCount, vmode_s *&pModes ) = 0; + + // Occlusion system control + virtual void SetOcclusionParameters( const OcclusionParams_t ¶ms ) = 0; + + // What language is the user expecting to hear .wavs in, "english" or another... + virtual void GetUILanguage( char *dest, int destlen ) = 0; + + // Can skybox be seen from a particular point? + virtual SkyboxVisibility_t IsSkyboxVisibleFromPoint( const Vector &vecPoint ) = 0; + + // Get the pristine map entity lump string. (e.g., used by CS to reload the map entities when restarting a round.) + virtual const char* GetMapEntitiesString() = 0; + + // Is the engine in map edit mode ? + virtual bool IsInEditMode( void ) = 0; + + // current screen aspect ratio (eg. 4.0f/3.0f, 16.0f/9.0f) + virtual float GetScreenAspectRatio() = 0; + + // allow the game UI to login a user + virtual bool REMOVED_SteamRefreshLogin( const char *password, bool isSecure ) = 0; + virtual bool REMOVED_SteamProcessCall( bool & finished ) = 0; + + // allow other modules to know about engine versioning (one use is a proxy for network compatability) + virtual unsigned int GetEngineBuildNumber() = 0; // engines build + virtual const char * GetProductVersionString() = 0; // mods version number (steam.inf) + + // Communicates to the color correction editor that it's time to grab the pre-color corrected frame + // Passes in the actual size of the viewport + virtual void GrabPreColorCorrectedFrame( int x, int y, int width, int height ) = 0; + + virtual bool IsHammerRunning( ) const = 0; + + // Inserts szCmdString into the command buffer as if it was typed by the client to his/her console. + // And then executes the command string immediately (vs ClientCmd() which executes in the next frame) + // + // Note: this is NOT checked against the FCVAR_CLIENTCMD_CAN_EXECUTE vars. + virtual void ExecuteClientCmd( const char *szCmdString ) = 0; + + // returns if the loaded map was processed with HDR info. This will be set regardless + // of what HDR mode the player is in. + virtual bool MapHasHDRLighting(void) = 0; + + virtual int GetAppID() = 0; + + // Just get the leaf ambient light - no caching, no samples + virtual Vector GetLightForPointFast(const Vector &pos, bool bClamp) = 0; + + // This version does NOT check against FCVAR_CLIENTCMD_CAN_EXECUTE. + virtual void ClientCmd_Unrestricted( const char *szCmdString ) = 0; + + // This used to be accessible through the cl_restrict_server_commands cvar. + // By default, Valve games restrict the server to only being able to execute commands marked with FCVAR_SERVER_CAN_EXECUTE. + // By default, mods are allowed to execute any server commands, and they can restrict the server's ability to execute client + // commands with this function. + virtual void SetRestrictServerCommands( bool bRestrict ) = 0; + + // If set to true (defaults to true for Valve games and false for others), then IVEngineClient::ClientCmd + // can only execute things marked with FCVAR_CLIENTCMD_CAN_EXECUTE. + virtual void SetRestrictClientCommands( bool bRestrict ) = 0; + + // Sets the client renderable for an overlay's material proxy to bind to + virtual void SetOverlayBindProxy( int iOverlayID, void *pBindProxy ) = 0; + + virtual bool CopyFrameBufferToMaterial( const char *pMaterialName ) = 0; + + // Matchmaking + virtual void ChangeTeam( const char *pTeamName ) = 0; + + // Causes the engine to read in the user's configuration on disk + virtual void ReadConfiguration( const bool readDefault = false ) = 0; + + virtual void SetAchievementMgr( IAchievementMgr *pAchievementMgr ) = 0; + virtual IAchievementMgr *GetAchievementMgr() = 0; + + virtual bool MapLoadFailed( void ) = 0; + virtual void SetMapLoadFailed( bool bState ) = 0; + + virtual bool IsLowViolence() = 0; + virtual const char *GetMostRecentSaveGame( void ) = 0; + virtual void SetMostRecentSaveGame( const char *lpszFilename ) = 0; + + virtual void StartXboxExitingProcess() = 0; + virtual bool IsSaveInProgress() = 0; + virtual uint OnStorageDeviceAttached( void ) = 0; + virtual void OnStorageDeviceDetached( void ) = 0; + + virtual void ResetDemoInterpolation( void ) = 0; + + // Methods to set/get a gamestats data container so client & server running in same process can send combined data + virtual void SetGamestatsData( CGamestatsData *pGamestatsData ) = 0; + virtual CGamestatsData *GetGamestatsData() = 0; + +#if defined( USE_SDL ) + // we need to pull delta's from the cocoa mgr, the engine vectors this for us + virtual void GetMouseDelta( int &x, int &y, bool bIgnoreNextMouseDelta = false ) = 0; +#endif + + // Sends a key values server command, not allowed from scripts execution + // Params: + // pKeyValues - key values to be serialized and sent to server + // the pointer is deleted inside the function: pKeyValues->deleteThis() + virtual void ServerCmdKeyValues( KeyValues *pKeyValues ) = 0; + + virtual bool IsSkippingPlayback( void ) = 0; + virtual bool IsLoadingDemo( void ) = 0; + + // Returns true if the engine is playing back a "locally recorded" demo, which includes + // both SourceTV and replay demos, since they're recorded locally (on servers), as opposed + // to a client recording a demo while connected to a remote server. + virtual bool IsPlayingDemoALocallyRecordedDemo() = 0; + + // Given the string pBinding which may be bound to a key, + // returns the string name of the key to which this string is bound. Returns NULL if no such binding exists + // Unlike Key_LookupBinding, leading '+' characters are not stripped from bindings. + virtual const char *Key_LookupBindingExact( const char *pBinding ) = 0; + + virtual void AddPhonemeFile( const char *pszPhonemeFile ) = 0; + virtual float GetPausedExpireTime( void ) = 0; + + virtual bool StartDemoRecording( const char *pszFilename, const char *pszFolder = NULL ) = 0; + virtual void StopDemoRecording( void ) = 0; + virtual void TakeScreenshot( const char *pszFilename, const char *pszFolder = NULL ) = 0; +}; + +abstract_class IVEngineClient : public IVEngineClient013 +{ +public: + virtual uint GetProtocolVersion() = 0; + virtual bool IsWindowedMode() = 0; + + // Flash the window (os specific) + virtual void FlashWindow() = 0; + + // Client version from the steam.inf, this will be compared to the GC version + virtual int GetClientVersion() const = 0; // engines build + + // Is App Active + virtual bool IsActiveApp() = 0; + + virtual void DisconnectInternal() = 0; + + virtual int GetInstancesRunningCount( ) = 0; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Interface exposed from the client .dll back to the engine +//----------------------------------------------------------------------------- +abstract_class IBaseClientDLL +{ +public: + // Called once when the client DLL is loaded + virtual int Init( CreateInterfaceFn appSystemFactory, + CreateInterfaceFn physicsFactory, + CGlobalVarsBase *pGlobals ) = 0; + + virtual void PostInit() = 0; + + // Called once when the client DLL is being unloaded + virtual void Shutdown( void ) = 0; + + // Called once the client is initialized to setup client-side replay interface pointers + virtual bool ReplayInit( CreateInterfaceFn replayFactory ) = 0; + virtual bool ReplayPostInit() = 0; + + // Called at the start of each level change + virtual void LevelInitPreEntity( char const* pMapName ) = 0; + // Called at the start of a new level, after the entities have been received and created + virtual void LevelInitPostEntity( ) = 0; + // Called at the end of a level + virtual void LevelShutdown( void ) = 0; + + // Request a pointer to the list of client datatable classes + virtual ClientClass *GetAllClasses( void ) = 0; + + // Called once per level to re-initialize any hud element drawing stuff + virtual int HudVidInit( void ) = 0; + // Called by the engine when gathering user input + virtual void HudProcessInput( bool bActive ) = 0; + // Called oncer per frame to allow the hud elements to think + virtual void HudUpdate( bool bActive ) = 0; + // Reset the hud elements to their initial states + virtual void HudReset( void ) = 0; + // Display a hud text message + virtual void HudText( const char * message ) = 0; + + // Mouse Input Interfaces + // Activate the mouse (hides the cursor and locks it to the center of the screen) + virtual void IN_ActivateMouse( void ) = 0; + // Deactivates the mouse (shows the cursor and unlocks it) + virtual void IN_DeactivateMouse( void ) = 0; + // This is only called during extra sound updates and just accumulates mouse x, y offets and recenters the mouse. + // This call is used to try to prevent the mouse from appearing out of the side of a windowed version of the engine if + // rendering or other processing is taking too long + virtual void IN_Accumulate (void) = 0; + // Reset all key and mouse states to their initial, unpressed state + virtual void IN_ClearStates (void) = 0; + // If key is found by name, returns whether it's being held down in isdown, otherwise function returns false + virtual bool IN_IsKeyDown( const char *name, bool& isdown ) = 0; + // Notify the client that the mouse was wheeled while in game - called prior to executing any bound commands. + virtual void IN_OnMouseWheeled( int nDelta ) = 0; + // Raw keyboard signal, if the client .dll returns 1, the engine processes the key as usual, otherwise, + // if the client .dll returns 0, the key is swallowed. + virtual int IN_KeyEvent( int eventcode, ButtonCode_t keynum, const char *pszCurrentBinding ) = 0; + + // This function is called once per tick to create the player CUserCmd (used for prediction/physics simulation of the player) + // Because the mouse can be sampled at greater than the tick interval, there is a separate input_sample_frametime, which + // specifies how much additional mouse / keyboard simulation to perform. + virtual void CreateMove ( + int sequence_number, // sequence_number of this cmd + float input_sample_frametime, // Frametime for mouse input sampling + bool active ) = 0; // True if the player is active (not paused) + + // If the game is running faster than the tick_interval framerate, then we do extra mouse sampling to avoid jittery input + // This code path is much like the normal move creation code, except no move is created + virtual void ExtraMouseSample( float frametime, bool active ) = 0; + + // Encode the delta (changes) between the CUserCmd in slot from vs the one in slot to. The game code will have + // matching logic to read the delta. + virtual bool WriteUsercmdDeltaToBuffer( bf_write *buf, int from, int to, bool isnewcommand ) = 0; + // Demos need to be able to encode/decode CUserCmds to memory buffers, so these functions wrap that + virtual void EncodeUserCmdToBuffer( bf_write& buf, int slot ) = 0; + virtual void DecodeUserCmdFromBuffer( bf_read& buf, int slot ) = 0; + + // Set up and render one or more views (e.g., rear view window, etc.). This called into RenderView below + virtual void View_Render( vrect_t *rect ) = 0; + + // Allow engine to expressly render a view (e.g., during timerefresh) + // See IVRenderView.h, PushViewFlags_t for nFlags values + virtual void RenderView( const CViewSetup &view, int nClearFlags, int whatToDraw ) = 0; + + // Apply screen fade directly from engine + virtual void View_Fade( ScreenFade_t *pSF ) = 0; + + // The engine has parsed a crosshair angle message, this function is called to dispatch the new crosshair angle + virtual void SetCrosshairAngle( const QAngle& angle ) = 0; + + // Sprite (.spr) model handling code + // Load a .spr file by name + virtual void InitSprite( CEngineSprite *pSprite, const char *loadname ) = 0; + // Shutdown a .spr file + virtual void ShutdownSprite( CEngineSprite *pSprite ) = 0; + // Returns sizeof( CEngineSprite ) so the engine can allocate appropriate memory + virtual int GetSpriteSize( void ) const = 0; + + // Called when a player starts or stops talking. + // entindex is -1 to represent the local client talking (before the data comes back from the server). + // entindex is -2 to represent the local client's voice being acked by the server. + // entindex is GetPlayer() when the server acknowledges that the local client is talking. + virtual void VoiceStatus( int entindex, qboolean bTalking ) = 0; + + // Networked string table definitions have arrived, allow client .dll to + // hook string changes with a callback function ( see INetworkStringTableClient.h ) + virtual void InstallStringTableCallback( char const *tableName ) = 0; + + // Notification that we're moving into another stage during the frame. + virtual void FrameStageNotify( ClientFrameStage_t curStage ) = 0; + + // The engine has received the specified user message, this code is used to dispatch the message handler + virtual bool DispatchUserMessage( int msg_type, bf_read &msg_data ) = 0; + + // Save/restore system hooks + virtual CSaveRestoreData *SaveInit( int size ) = 0; + virtual void SaveWriteFields( CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int ) = 0; + virtual void SaveReadFields( CSaveRestoreData *, const char *, void *, datamap_t *, typedescription_t *, int ) = 0; + virtual void PreSave( CSaveRestoreData * ) = 0; + virtual void Save( CSaveRestoreData * ) = 0; + virtual void WriteSaveHeaders( CSaveRestoreData * ) = 0; + virtual void ReadRestoreHeaders( CSaveRestoreData * ) = 0; + virtual void Restore( CSaveRestoreData *, bool ) = 0; + virtual void DispatchOnRestore() = 0; + + // Hand over the StandardRecvProxies in the client DLL's module. + virtual CStandardRecvProxies* GetStandardRecvProxies() = 0; + + // save game screenshot writing + virtual void WriteSaveGameScreenshot( const char *pFilename ) = 0; + + // Given a list of "S(wavname) S(wavname2)" tokens, look up the localized text and emit + // the appropriate close caption if running with closecaption = 1 + virtual void EmitSentenceCloseCaption( char const *tokenstream ) = 0; + // Emits a regular close caption by token name + virtual void EmitCloseCaption( char const *captionname, float duration ) = 0; + + // Returns true if the client can start recording a demo now. If the client returns false, + // an error message of up to length bytes should be returned in errorMsg. + virtual bool CanRecordDemo( char *errorMsg, int length ) const = 0; + + // Give the Client a chance to do setup/cleanup. + virtual void OnDemoRecordStart( char const* pDemoBaseName ) = 0; + virtual void OnDemoRecordStop() = 0; + virtual void OnDemoPlaybackStart( char const* pDemoBaseName ) = 0; + virtual void OnDemoPlaybackStop() = 0; + + // Draw the console overlay? + virtual bool ShouldDrawDropdownConsole() = 0; + + // Get client screen dimensions + virtual int GetScreenWidth() = 0; + virtual int GetScreenHeight() = 0; + + // Added interface + + // save game screenshot writing + virtual void WriteSaveGameScreenshotOfSize( const char *pFilename, int width, int height, bool bCreatePowerOf2Padded = false, bool bWriteVTF = false ) = 0; + + // Gets the current view + virtual bool GetPlayerView( CViewSetup &playerView ) = 0; + + // Matchmaking + virtual void SetupGameProperties( CUtlVector< XUSER_CONTEXT > &contexts, CUtlVector< XUSER_PROPERTY > &properties ) = 0; + virtual uint GetPresenceID( const char *pIDName ) = 0; + virtual const char *GetPropertyIdString( const uint id ) = 0; + virtual void GetPropertyDisplayString( uint id, uint value, char *pOutput, int nBytes ) = 0; + +#ifdef WIN32 + virtual void StartStatsReporting( HANDLE handle, bool bArbitrated ) = 0; +#endif + + virtual void InvalidateMdlCache() = 0; + + virtual void IN_SetSampleTime( float frametime ) = 0; + + + // For sv_pure mode. The filesystem figures out which files the client needs to reload to be "pure" ala the server's preferences. + virtual void ReloadFilesInList( IFileList *pFilesToReload ) = 0; +#ifdef POSIX + // AR: Same as above win32 defn but down here at the end of the vtable for back compat + virtual void StartStatsReporting( HANDLE handle, bool bArbitrated ) = 0; +#endif + + // Let the client handle UI toggle - if this function returns false, the UI will toggle, otherwise it will not. + virtual bool HandleUiToggle() = 0; + + // Allow the console to be shown? + virtual bool ShouldAllowConsole() = 0; + + // Get renamed recv tables + virtual CRenamedRecvTableInfo *GetRenamedRecvTableInfos() = 0; + + // Get the mouthinfo for the sound being played inside UI panels + virtual CMouthInfo *GetClientUIMouthInfo() = 0; + + // Notify the client that a file has been received from the game server + virtual void FileReceived( const char * fileName, unsigned int transferID ) = 0; + + virtual const char* TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName ) = 0; + + // Give the client a chance to modify sound settings however they want before the sound plays. This is used for + // things like adjusting pitch of voice lines in Pyroland in TF2. + virtual void ClientAdjustStartSoundParams( struct StartSoundParams_t& params ) = 0; + + // Returns true if the disconnect command has been handled by the client + virtual bool DisconnectAttempt( void ) = 0; + + virtual bool IsConnectedUserInfoChangeAllowed( IConVar *pCvar ) = 0; +}; + +#define CLIENT_DLL_INTERFACE_VERSION "VClient017" + +//----------------------------------------------------------------------------- +// Purpose: Interface exposed from the client .dll back to the engine for specifying shared .dll IAppSystems (e.g., ISoundEmitterSystem) +//----------------------------------------------------------------------------- +abstract_class IClientDLLSharedAppSystems +{ +public: + virtual int Count() = 0; + virtual char const *GetDllName( int idx ) = 0; + virtual char const *GetInterfaceName( int idx ) = 0; +}; + +#define CLIENT_DLL_SHARED_APPSYSTEMS "VClientDllSharedAppSystems001" + +#endif // CDLL_INT_H |