//========= 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 "const.h" #include "datamap.h" #include "inputsystem/ButtonCode.h" #include "mathlib/mathlib.h" #include "modes.h" #include "tier0/basetypes.h" #include "tier1/bitbuf.h" #include "tier1/checksum_crc.h" #include "tier1/interface.h" #if !defined(_X360) #include "../common/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(Vector & va) = 0; // Set current view orientation from va virtual void SetViewAngles(Vector & 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; }; 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 & contexts, CUtlVector & 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