diff options
Diffstat (limited to 'engine/cdll_engine_int.cpp')
| -rw-r--r-- | engine/cdll_engine_int.cpp | 2213 |
1 files changed, 2213 insertions, 0 deletions
diff --git a/engine/cdll_engine_int.cpp b/engine/cdll_engine_int.cpp new file mode 100644 index 0000000..f986a20 --- /dev/null +++ b/engine/cdll_engine_int.cpp @@ -0,0 +1,2213 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// 4-23-98 +// JOHN: implementation of interface between client-side DLL and game engine. +// The cdll shouldn't have to know anything about networking or file formats. +// This file is Win32-dependant +// +//=============================================================================// + +#include "client_pch.h" +#include "getintersectingsurfaces_struct.h" +#include "gl_model_private.h" +#include "surfinfo.h" +#include "vstdlib/random.h" +#include "cdll_int.h" +#include "cmodel_engine.h" +#include "tmessage.h" +#include "console.h" +#include "snd_audio_source.h" +#include <vgui_controls/Controls.h> +#include <vgui/IInput.h> +#include "iengine.h" +#include "keys.h" +#include "con_nprint.h" +#include "tier0/vprof.h" +#include "sound.h" +#include "gl_rmain.h" +#include "proto_version.h" +#include "client_class.h" +#include "gl_rsurf.h" +#include "server.h" +#include "r_local.h" +#include "lightcache.h" +#include "gl_matsysiface.h" +#include "materialsystem/imaterialsystemhardwareconfig.h" +#include "materialsystem/materialsystem_config.h" +#include "materialsystem/imaterial.h" +#include "materialsystem/imaterialvar.h" +#include "materialsystem/itexture.h" +#include "istudiorender.h" +#include "l_studio.h" +#include "voice.h" +#include "enginestats.h" +#include "testscriptmgr.h" +#include "r_areaportal.h" +#include "host.h" +#include "host_cmd.h" +#include "vox.h" +#include "iprediction.h" +#include "icliententitylist.h" +#include "eiface.h" +#include "ivguicenterprint.h" +#include "engine/IClientLeafSystem.h" +#include "dt_recv_eng.h" +#include <vgui/IVGui.h> +#include "sys_dll.h" +#include "vphysics_interface.h" +#include "materialsystem/imesh.h" +#include "IOcclusionSystem.h" +#include "filesystem_engine.h" +#include "tier0/icommandline.h" +#include "client_textmessage.h" +#include "host_saverestore.h" +#include "cl_main.h" +#include "demo.h" +#include "appframework/ilaunchermgr.h" +#include "vgui_baseui_interface.h" +#include "LocalNetworkBackdoor.h" +#include "lightcache.h" +#include "vgui/ISystem.h" +#include "ivideomode.h" +#include "icolorcorrectiontools.h" +#include "toolframework/itoolframework.h" +#include "engine/view_sharedv1.h" +#include "view.h" +#include "game/client/iclientrendertargets.h" +#include "tier2/tier2.h" +#include "matchmaking.h" +#include "inputsystem/iinputsystem.h" +#include "iachievementmgr.h" +#include "profile.h" +#include "cl_steamauth.h" +#include "download.h" +#include "replay/iclientreplay.h" +#include "demofile.h" +#include "igame.h" +#include "iclientvirtualreality.h" +#include "sourcevr/isourcevirtualreality.h" +#include "cl_check_process.h" +#include "enginethreads.h" + +#if defined( REPLAY_ENABLED ) +#include "replay_internal.h" +#include "replay/replaylib.h" +#endif + + + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +//----------------------------------------------------------------------------- +// forward declarations +//----------------------------------------------------------------------------- +IMaterial* BrushModel_GetLightingAndMaterial( const Vector &start, + const Vector &end, Vector &diffuseLightColor, Vector &baseColor ); +const char *Key_NameForBinding( const char *pBinding ); +void CL_GetBackgroundLevelName( char *pszBackgroundName, int bufSize, bool bMapName ); +CreateInterfaceFn g_ClientFactory = NULL; +extern CGlobalVars g_ServerGlobalVariables; + +//----------------------------------------------------------------------------- +// globals +//----------------------------------------------------------------------------- +CSysModule *g_ClientDLLModule = NULL; // also used by materialproxyfactory.cpp +bool g_bClientGameDLLGreaterThanV13; + +void AddIntersectingLeafSurfaces( mleaf_t *pLeaf, GetIntersectingSurfaces_Struct *pStruct ) +{ + SurfaceHandle_t *pHandle = &host_state.worldbrush->marksurfaces[pLeaf->firstmarksurface]; + for ( int iSurf=0; iSurf < pLeaf->nummarksurfaces; iSurf++ ) + { + SurfaceHandle_t surfID = pHandle[iSurf]; + ASSERT_SURF_VALID( surfID ); + + if ( MSurf_Flags(surfID) & SURFDRAW_SKY ) + continue; + + // Make sure we haven't already processed this one. + bool foundSurf = false; + for(int iTest=0; iTest < pStruct->m_nSetInfos; iTest++) + { + if(pStruct->m_pInfos[iTest].m_pEngineData == (void *)surfID) + { + foundSurf = true; + break; + } + } + if ( foundSurf ) + continue; + + // Make sure there's output room. + if(pStruct->m_nSetInfos >= pStruct->m_nMaxInfos) + return; + SurfInfo *pOut = &pStruct->m_pInfos[pStruct->m_nSetInfos]; + pOut->m_nVerts = 0; + pOut->m_pEngineData = (void *)surfID; + + // Build vertex list and bounding box. + Vector vMin( 1000000.0f, 1000000.0f, 1000000.0f); + Vector vMax(-1000000.0f, -1000000.0f, -1000000.0f); + for(int iVert=0; iVert < MSurf_VertCount( surfID ); iVert++) + { + int vertIndex = pStruct->m_pModel->brush.pShared->vertindices[MSurf_FirstVertIndex( surfID ) + iVert]; + + pOut->m_Verts[pOut->m_nVerts] = pStruct->m_pModel->brush.pShared->vertexes[vertIndex].position; + vMin = vMin.Min(pOut->m_Verts[pOut->m_nVerts]); + vMax = vMax.Max(pOut->m_Verts[pOut->m_nVerts]); + + ++pOut->m_nVerts; + if(pOut->m_nVerts >= MAX_SURFINFO_VERTS) + break; + } + + // See if the sphere intersects the box. + int iDim=0; + for(; iDim < 3; iDim++) + { + if(((*pStruct->m_pCenter)[iDim]+pStruct->m_Radius) < vMin[iDim] || + ((*pStruct->m_pCenter)[iDim]-pStruct->m_Radius) > vMax[iDim]) + { + break; + } + } + + if(iDim == 3) + { + // (Couldn't reject the sphere in the loop above). + pOut->m_Plane = MSurf_GetForwardFacingPlane( surfID ); + ++pStruct->m_nSetInfos; + } + } +} + +void GetIntersectingSurfaces_R( + GetIntersectingSurfaces_Struct *pStruct, + mnode_t *pNode + ) +{ + if(pStruct->m_nSetInfos >= pStruct->m_nMaxInfos) + return; + + // Ok, this is a leaf. Check its surfaces. + if(pNode->contents >= 0) + { + mleaf_t *pLeaf = (mleaf_t*)pNode; + + if(pStruct->m_bOnlyVisible && pStruct->m_pCenterPVS) + { + if(pLeaf->cluster < 0) + return; + + if(!(pStruct->m_pCenterPVS[pLeaf->cluster>>3] & (1 << (pLeaf->cluster&7)))) + return; + } + + // First, add tris from displacements. + for ( int i = 0; i < pLeaf->dispCount; i++ ) + { + IDispInfo *pDispInfo = MLeaf_Disaplcement( pLeaf, i ); + pDispInfo->GetIntersectingSurfaces( pStruct ); + } + + // Next, add brush tris. + AddIntersectingLeafSurfaces( pLeaf, pStruct ); + return; + } + + // Recurse. + float dot; + cplane_t *plane = pNode->plane; + if ( plane->type < 3 ) + { + dot = (*pStruct->m_pCenter)[plane->type] - plane->dist; + } + else + { + dot = pStruct->m_pCenter->Dot(plane->normal) - plane->dist; + } + + // Recurse into child nodes. + if(dot > -pStruct->m_Radius) + GetIntersectingSurfaces_R(pStruct, pNode->children[SIDE_FRONT]); + + if(dot < pStruct->m_Radius) + GetIntersectingSurfaces_R(pStruct, pNode->children[SIDE_BACK]); +} + + +//----------------------------------------------------------------------------- +// slow routine to draw a physics model +// NOTE: very slow code!!! just for debugging! +//----------------------------------------------------------------------------- +void DebugDrawPhysCollide( const CPhysCollide *pCollide, IMaterial *pMaterial, matrix3x4_t& transform, const color32 &color, bool drawAxes ) +{ + if ( !pMaterial ) + { + pMaterial = materials->FindMaterial("shadertest/wireframevertexcolor", TEXTURE_GROUP_OTHER); + } + + CMatRenderContextPtr pRenderContext( materials ); + + Vector *outVerts; + int vertCount = physcollision->CreateDebugMesh( pCollide, &outVerts ); + if ( vertCount ) + { + IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial ); + + CMeshBuilder meshBuilder; + meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, vertCount/3 ); + + for ( int j = 0; j < vertCount; j++ ) + { + Vector out; + VectorTransform( outVerts[j].Base(), transform, out.Base() ); + meshBuilder.Position3fv( out.Base() ); + meshBuilder.Color4ub( color.r, color.g, color.b, color.a ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + } + meshBuilder.End(); + pMesh->Draw(); + } + physcollision->DestroyDebugMesh( vertCount, outVerts ); + + // draw the axes + if ( drawAxes ) + { + Vector xaxis(10,0,0), yaxis(0,10,0), zaxis(0,0,10); + Vector center; + Vector out; + + MatrixGetColumn( transform, 3, center ); + IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial ); + CMeshBuilder meshBuilder; + meshBuilder.Begin( pMesh, MATERIAL_LINES, 3 ); + + // X + meshBuilder.Position3fv( center.Base() ); + meshBuilder.Color4ub( 255, 0, 0, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + VectorTransform( xaxis.Base(), transform, out.Base() ); + meshBuilder.Position3fv( out.Base() ); + meshBuilder.Color4ub( 255, 0, 0, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + + // Y + meshBuilder.Position3fv( center.Base() ); + meshBuilder.Color4ub( 0, 255, 0, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + VectorTransform( yaxis.Base(), transform, out.Base() ); + meshBuilder.Position3fv( out.Base() ); + meshBuilder.Color4ub( 0, 255, 0, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + + // Z + meshBuilder.Position3fv( center.Base() ); + meshBuilder.Color4ub( 0, 0, 255, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + VectorTransform( zaxis.Base(), transform, out.Base() ); + meshBuilder.Position3fv( out.Base() ); + meshBuilder.Color4ub( 0, 0, 255, 255 ); + meshBuilder.TexCoord2f( 0, 0, 0 ); + meshBuilder.AdvanceVertex(); + meshBuilder.End(); + pMesh->Draw(); + } +} + +//----------------------------------------------------------------------------- +// +// implementation of IVEngineHud +// +//----------------------------------------------------------------------------- + +// UNDONE: Move this to hud export code, subsume previous functions +class CEngineClient : public IVEngineClient +{ +public: + CEngineClient(); + + int GetIntersectingSurfaces( + const model_t *model, + const Vector &vCenter, + const float radius, + const bool bOnlyVisible, + SurfInfo *pInfos, + const int nMaxInfos); + + Vector GetLightForPoint(const Vector &pos, bool bClamp); + Vector GetLightForPointFast(const Vector &pos, bool bClamp); + const char *ParseFile( const char *data, char *token, int maxlen ); + virtual bool CopyLocalFile( const char *source, const char *destination ); + void GetScreenSize( int& w, int &h ); + void ServerCmd( const char *szCmdString, bool bReliable ); + void ClientCmd( const char *szCmdString ); + void ClientCmd_Unrestricted( const char *szCmdString ); + void SetRestrictServerCommands( bool bRestrict ); + void SetRestrictClientCommands( bool bRestrict ); + bool GetPlayerInfo( int ent_num, player_info_t *pinfo ); + client_textmessage_t *TextMessageGet( const char *pName ); + bool Con_IsVisible( void ); + int GetLocalPlayer( void ); + float GetLastTimeStamp( void ); + const model_t *LoadModel( const char *pName, bool bProp ); + void UnloadModel( const model_t *model, bool bProp ); + CSentence *GetSentence( CAudioSource *pAudioSource ); + float GetSentenceLength( CAudioSource *pAudioSource ); + bool IsStreaming( CAudioSource *pAudioSource ) const; + void AddPhonemeFile( const char *pszPhonemeFile ); + + // FIXME, move entirely to client .dll + void GetViewAngles( QAngle& va ); + void SetViewAngles( QAngle& va ); + int GetMaxClients( void ); + void Key_Event( ButtonCode_t key, int down ); + const char *Key_LookupBinding( const char *pBinding ); + const char *Key_LookupBindingExact( const char *pBinding ); + const char *Key_BindingForKey( ButtonCode_t code ); + void StartKeyTrapMode( void ); + bool CheckDoneKeyTrapping( ButtonCode_t &key ); + bool IsInGame( void ); + bool IsConnected( void ); + bool IsDrawingLoadingImage( void ); + void Con_NPrintf( int pos, const char *fmt, ... ); + void Con_NXPrintf( const struct con_nprint_s *info, const char *fmt, ... ); + IMaterial *TraceLineMaterialAndLighting( const Vector &start, const Vector &end, + Vector &diffuseLightColor, Vector &baseColor ); + int IsBoxVisible( const Vector& mins, const Vector& maxs ); + int IsBoxInViewCluster( const Vector& mins, const Vector& maxs ); + + float Time(); + void Sound_ExtraUpdate( void ); + + bool CullBox ( const Vector& mins, const Vector& maxs ); + const char *GetGameDirectory( void ); + const VMatrix& WorldToScreenMatrix(); + const VMatrix& WorldToViewMatrix(); + + // Loads a game lump off disk + int GameLumpVersion( int lumpId ) const; + int GameLumpSize( int lumpId ) const; + bool LoadGameLump( int lumpId, void* pBuffer, int size ); + + // Returns the number of leaves in the level + int LevelLeafCount() const; + virtual ISpatialQuery* GetBSPTreeQuery(); + + // Convert texlight to gamma... + virtual void LinearToGamma( float* linear, float* gamma ); + + // Get the lightstyle value + virtual float LightStyleValue( int style ); + virtual void DrawPortals(); + + // 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( Vector const& pt, Vector const* pNormal, Vector& color ); + + // 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 ); + + // Returns the color of the ambient light + virtual void GetAmbientLightColor( Vector& color ); + + // Returns the dx support level + virtual int GetDXSupportLevel(); + + virtual bool SupportsHDR(); + virtual void Mat_Stub( IMaterialSystem *pMatSys ); + + // menu display + virtual void GetChapterName( char *pchBuff, int iMaxLength ); + virtual char const *GetLevelName( void ); + virtual int GetLevelVersion( void ); + virtual bool IsLevelMainMenuBackground( void ); + virtual void GetMainMenuBackgroundName( char *dest, int destlen ); + + // Occlusion system control + virtual void SetOcclusionParameters( const OcclusionParams_t ¶ms ); + + //----------------------------------------------------------------------------- + // Purpose: Takes a trackerID and returns which player slot that user is in + // returns 0 if no player found with that ID + //----------------------------------------------------------------------------- + virtual int GetPlayerForUserID(int userID); +#if !defined( NO_VOICE ) + virtual struct IVoiceTweak_s *GetVoiceTweakAPI( void ); +#endif + virtual void EngineStats_BeginFrame( void ); + virtual void EngineStats_EndFrame( void ); + virtual void FireEvents(); + virtual void CheckPoint( const char *pName ); + virtual int GetLeavesArea( int *pLeaves, int nLeaves ); + virtual bool DoesBoxTouchAreaFrustum( const Vector &mins, const Vector &maxs, int iArea ); + + // Sets the hearing origin + virtual void SetAudioState( const AudioState_t &audioState ); + + //----------------------------------------------------------------------------- + // + // Sentence API + // + //----------------------------------------------------------------------------- + + virtual int SentenceGroupPick( int groupIndex, char *name, int nameLen ); + virtual int SentenceGroupPickSequential( int groupIndex, char *name, int nameLen, int sentenceIndex, int reset ); + virtual int SentenceIndexFromName( const char *pSentenceName ); + virtual const char *SentenceNameFromIndex( int sentenceIndex ); + virtual int SentenceGroupIndexFromName( const char *pGroupName ); + virtual const char *SentenceGroupNameFromIndex( int groupIndex ); + virtual float SentenceLength( int sentenceIndex ); + virtual void DebugDrawPhysCollide( const CPhysCollide *pCollide, IMaterial *pMaterial, matrix3x4_t& transform, const color32 &color ); + + // Activates/deactivates an occluder... + virtual void ActivateOccluder( int nOccluderIndex, bool bActive ); + virtual bool IsOccluded( const Vector &vecAbsMins, const Vector &vecAbsMaxs ); + virtual void *SaveAllocMemory( size_t num, size_t size ); + virtual void SaveFreeMemory( void *pSaveMem ); + virtual INetChannelInfo *GetNetChannelInfo( void ); + virtual bool IsPlayingDemo( void ); + virtual bool IsRecordingDemo( void ); + virtual bool IsPlayingTimeDemo( void ); + virtual int GetDemoRecordingTick( void ); + virtual int GetDemoPlaybackTick( void ); + virtual int GetDemoPlaybackStartTick( void ); + virtual float GetDemoPlaybackTimeScale( void ); + virtual int GetDemoPlaybackTotalTicks( void ); + virtual bool IsPaused( void ); + virtual bool IsTakingScreenshot( void ); + virtual bool IsHLTV( void ); + virtual void GetVideoModes( int &nCount, vmode_s *&pModes ); + virtual void GetUILanguage( char *dest, int destlen ); + + // Can skybox be seen from a particular point? + virtual SkyboxVisibility_t IsSkyboxVisibleFromPoint( const Vector &vecPoint ); + + virtual const char* GetMapEntitiesString(); + virtual bool IsInEditMode( void ); + virtual bool IsInCommentaryMode( void ); + virtual float GetScreenAspectRatio(); + + virtual unsigned int GetEngineBuildNumber() { return PROTOCOL_VERSION; } + virtual const char * GetProductVersionString() { return GetSteamInfIDVersionInfo().szVersionString; } + virtual void GrabPreColorCorrectedFrame( int x, int y, int width, int height ); + virtual bool IsHammerRunning( ) const; + + // Stuffs the cmd into the buffer & executes it immediately (vs ClientCmd() which executes it next frame) + virtual void ExecuteClientCmd( const char *szCmdString ); + + virtual bool MapHasHDRLighting( void) ; + virtual int GetAppID(); + + virtual void SetOverlayBindProxy( int iOverlayID, void *pBindProxy ); + + virtual bool CopyFrameBufferToMaterial( const char *pMaterialName ); + + // Matchmaking + void ChangeTeam( const char *pTeamName ); + virtual void ReadConfiguration( const bool readDefault = false ); + + virtual void SetAchievementMgr( IAchievementMgr *pAchievementMgr ); + virtual IAchievementMgr *GetAchievementMgr(); + + virtual bool MapLoadFailed( void ); + virtual void SetMapLoadFailed( bool bState ); + + virtual bool IsLowViolence(); + virtual const char *GetMostRecentSaveGame( void ); + virtual void SetMostRecentSaveGame( const char *lpszFilename ); + + virtual void StartXboxExitingProcess(); + virtual bool IsSaveInProgress(); + + virtual uint OnStorageDeviceAttached( void ); + virtual void OnStorageDeviceDetached( void ); + + virtual void ResetDemoInterpolation( void ); + + virtual bool REMOVED_SteamRefreshLogin( const char *password, bool isSecure ) { return false; } + virtual bool REMOVED_SteamProcessCall( bool & finished ) { return false; } + + virtual void SetGamestatsData( CGamestatsData *pGamestatsData ); + virtual CGamestatsData *GetGamestatsData(); + +#if defined( USE_SDL ) + virtual void GetMouseDelta( int &x, int &y, bool bIgnoreNextMouseDelta ); +#endif + + virtual void ServerCmdKeyValues( KeyValues *pKeyValues ); + + virtual bool IsSkippingPlayback( void ); + virtual bool IsLoadingDemo( void ); + + virtual bool IsPlayingDemoALocallyRecordedDemo(); + + virtual uint GetProtocolVersion( void ); + + virtual bool IsWindowedMode( void ); + + virtual void FlashWindow(); + virtual int GetClientVersion() const; // engines build + virtual bool IsActiveApp(); + virtual void DisconnectInternal(); + + virtual int GetInstancesRunningCount( ); + + virtual float GetPausedExpireTime( void ) OVERRIDE; + + virtual bool StartDemoRecording( const char *pszFilename, const char *pszFolder = NULL ); + virtual void StopDemoRecording( void ); + virtual void TakeScreenshot( const char *pszFilename, const char *pszFolder = NULL ); +}; + + +//----------------------------------------------------------------------------- +// Singleton +//----------------------------------------------------------------------------- +static CEngineClient s_VEngineClient; +IVEngineClient *engineClient = &s_VEngineClient; +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineClient, IVEngineClient, VENGINE_CLIENT_INTERFACE_VERSION, s_VEngineClient ); +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CEngineClient, IVEngineClient013, VENGINE_CLIENT_INTERFACE_VERSION_13, s_VEngineClient ); + + +//----------------------------------------------------------------------------- +// Constructor +//----------------------------------------------------------------------------- +CEngineClient::CEngineClient() +{ +} + +int CEngineClient::GetIntersectingSurfaces( + const model_t *model, + const Vector &vCenter, + const float radius, + const bool bOnlyVisible, + SurfInfo *pInfos, + const int nMaxInfos) +{ + if ( !model ) + return 0; + + byte pvs[MAX_MAP_LEAFS/8]; + GetIntersectingSurfaces_Struct theStruct; + theStruct.m_pModel = ( model_t * )model; + theStruct.m_pCenter = &vCenter; + theStruct.m_pCenterPVS = CM_Vis( pvs, sizeof(pvs), CM_LeafCluster( CM_PointLeafnum( vCenter ) ), DVIS_PVS ); + theStruct.m_Radius = radius; + theStruct.m_bOnlyVisible = bOnlyVisible; + theStruct.m_pInfos = pInfos; + theStruct.m_nMaxInfos = nMaxInfos; + theStruct.m_nSetInfos = 0; + + // Go down the BSP. + GetIntersectingSurfaces_R( + &theStruct, + &model->brush.pShared->nodes[ model->brush.firstnode ] ); + + return theStruct.m_nSetInfos; +} + +Vector CEngineClient::GetLightForPoint(const Vector &pos, bool bClamp) +{ + Vector vRet; + ComputeLighting( pos, NULL, bClamp, vRet, NULL ); + return vRet; +} + +Vector CEngineClient::GetLightForPointFast(const Vector &pos, bool bClamp) +{ + Vector vRet; + int leafIndex = CM_PointLeafnum(pos); + vRet.Init(); + Vector cube[6]; + Mod_LeafAmbientColorAtPos( cube, pos, leafIndex ); + for ( int i = 0; i < 6; i++ ) + { + vRet.x = fpmax(vRet.x, cube[i].x ); + vRet.y = fpmax(vRet.y, cube[i].y ); + vRet.z = fpmax(vRet.z, cube[i].z ); + } + if ( bClamp ) + { + if ( vRet.x > 1.0f ) + vRet.x = 1.0f; + if ( vRet.y > 1.0f ) + vRet.y = 1.0f; + if ( vRet.z > 1.0f ) + vRet.z = 1.0f; + } + return vRet; +} + +const char *CEngineClient::ParseFile( const char *data, char *token, int maxlen ) +{ + return ::COM_ParseFile( data, token, maxlen ); +} + +bool CEngineClient::CopyLocalFile( const char *source, const char *destination ) +{ + return ::COM_CopyFile( source, destination ); +} + +void CEngineClient::GetScreenSize( int& w, int &h ) +{ + CMatRenderContextPtr pRenderContext( materials ); + pRenderContext->GetWindowSize( w, h ); +} + +void CEngineClient::ServerCmd( const char *szCmdString, bool bReliable ) +{ + // info handling + char buf[255]; + Q_snprintf( buf, sizeof( buf ), "cmd %s", szCmdString ); + + CCommand args; + args.Tokenize( buf ); + Cmd_ForwardToServer( args, bReliable ); +} + +void CEngineClient::ClientCmd( const char *szCmdString ) +{ + // Check that we can add the two execution markers + if ( cl.m_bRestrictClientCommands && !Cbuf_HasRoomForExecutionMarkers( 2 ) ) + { + AssertMsg( false, "CEngineClient::ClientCmd called but there is no room for the execution markers. Ignoring command." ); + return; + } + + // Only let them run commands marked with FCVAR_CLIENTCMD_CAN_EXECUTE. + if ( cl.m_bRestrictClientCommands ) + Cbuf_AddTextWithMarkers( eCmdExecutionMarker_Enable_FCVAR_CLIENTCMD_CAN_EXECUTE, szCmdString, eCmdExecutionMarker_Disable_FCVAR_CLIENTCMD_CAN_EXECUTE ); + else + Cbuf_AddText( szCmdString ); +} + +void CEngineClient::ClientCmd_Unrestricted( const char *szCmdString ) +{ + Cbuf_AddText( szCmdString ); +} + +void CEngineClient::SetRestrictServerCommands( bool bRestrict ) +{ + cl.m_bRestrictServerCommands = bRestrict; +} + +void CEngineClient::SetRestrictClientCommands( bool bRestrict ) +{ + cl.m_bRestrictClientCommands = bRestrict; +} + +void CEngineClient::ExecuteClientCmd( const char *szCmdString ) +{ + Cbuf_AddText( szCmdString ); + Cbuf_Execute(); +} + +bool CEngineClient::GetPlayerInfo( int ent_num, player_info_t *pinfo ) +{ + ent_num--; // player list if offset by 1 from ents + + if ( ent_num >= cl.m_nMaxClients || ent_num < 0 ) + { + Q_memset( pinfo, 0, sizeof( player_info_t ) ); + return false; + } + + Assert( cl.m_pUserInfoTable ); + if ( !cl.m_pUserInfoTable ) + { + Q_memset( pinfo, 0, sizeof( player_info_t ) ); + return false; + } + + Assert( ent_num < cl.m_pUserInfoTable->GetNumStrings() ); + if ( ent_num >= cl.m_pUserInfoTable->GetNumStrings() ) + { + Q_memset( pinfo, 0, sizeof( player_info_t ) ); + return false; + } + + int cubPlayerInfo; + player_info_t *pi = (player_info_t*) cl.m_pUserInfoTable->GetStringUserData( ent_num, &cubPlayerInfo ); + + if ( !pi || cubPlayerInfo < sizeof( player_info_t ) ) + { + Q_memset( pinfo, 0, sizeof( player_info_t ) ); + return false; + } + + Q_memcpy( pinfo, pi, sizeof( player_info_t ) ); + + // Fixup from network order (little endian) + CByteswap byteswap; + byteswap.SetTargetBigEndian( false ); + byteswap.SwapFieldsToTargetEndian( pinfo ); + + return true; +} + +client_textmessage_t *CEngineClient::TextMessageGet( const char *pName ) +{ + return ::TextMessageGet( pName ); +} + +bool CEngineClient::Con_IsVisible( void ) +{ + return ::Con_IsVisible(); +} + +int CEngineClient::GetLocalPlayer( void ) +{ + return cl.m_nPlayerSlot + 1; +} + +float CEngineClient::GetLastTimeStamp( void ) +{ + return cl.m_flLastServerTickTime; +} + +bool CEngineClient::MapHasHDRLighting( void) +{ + return modelloader->LastLoadedMapHasHDRLighting(); +} + +const model_t *CEngineClient::LoadModel( const char *pName, bool bProp ) +{ + return modelloader->GetModelForName( pName, bProp ? IModelLoader::FMODELLOADER_DETAILPROP : IModelLoader::FMODELLOADER_CLIENTDLL ); +} + +CSentence *CEngineClient::GetSentence( CAudioSource *pAudioSource ) +{ + if (pAudioSource) + { + return pAudioSource->GetSentence(); + } + return NULL; +} + +void AddPhonemesFromFile( const char *pszFileName ); + +void CEngineClient::AddPhonemeFile( const char *pszPhonemeFile ) +{ + AddPhonemesFromFile( pszPhonemeFile ); +} + +float CEngineClient::GetSentenceLength( CAudioSource *pAudioSource ) +{ + if (pAudioSource && pAudioSource->SampleRate() > 0 ) + { + float length = (float)pAudioSource->SampleCount() / (float)pAudioSource->SampleRate(); + return length; + } + return 0.0f; +} + +bool CEngineClient::IsStreaming( CAudioSource *pAudioSource ) const +{ + if ( pAudioSource ) + { + return pAudioSource->IsStreaming(); + } + return false; +} + +// FIXME, move entirely to client .dll +void CEngineClient::GetViewAngles( QAngle& va ) +{ + VectorCopy( cl.viewangles, va ); +} + +void CEngineClient::SetViewAngles( QAngle& va ) +{ + cl.viewangles.x = AngleNormalize( va.x ); + cl.viewangles.y = AngleNormalize( va.y ); + cl.viewangles.z = AngleNormalize( va.z ); + Assert( !IS_NAN(cl.viewangles.x ) ); + Assert( !IS_NAN(cl.viewangles.y ) ); + Assert( !IS_NAN(cl.viewangles.z ) ); +} + +int CEngineClient::GetMaxClients( void ) +{ + return cl.m_nMaxClients; +} + +void CEngineClient::SetMapLoadFailed( bool bState ) +{ + g_ServerGlobalVariables.bMapLoadFailed = bState; +} + +bool CEngineClient::MapLoadFailed( void ) +{ + return g_ServerGlobalVariables.bMapLoadFailed; +} + +void CEngineClient::ReadConfiguration( const bool readDefault /*= false*/ ) +{ + Host_ReadConfiguration(); +} + +const char *CEngineClient::Key_LookupBinding( const char *pBinding ) +{ + return ::Key_NameForBinding( pBinding ); +} + +const char *CEngineClient::Key_LookupBindingExact( const char *pBinding ) +{ + return ::Key_NameForBindingExact( pBinding ); +} + +const char *CEngineClient::Key_BindingForKey( ButtonCode_t code ) +{ + return ::Key_BindingForKey( code ); +} + +void CEngineClient::StartKeyTrapMode( void ) +{ + Key_StartTrapMode(); +} + +bool CEngineClient::CheckDoneKeyTrapping( ButtonCode_t &code ) +{ + return Key_CheckDoneTrapping( code ); +} + +bool CEngineClient::IsInGame( void ) +{ + return cl.IsActive(); +} + +bool CEngineClient::IsConnected( void ) +{ + return cl.IsConnected(); +} + +bool CEngineClient::IsDrawingLoadingImage( void ) +{ + return scr_drawloading; +} + +void CEngineClient::Con_NPrintf( int pos, const char *fmt, ... ) +{ + va_list argptr; + char text[4096]; + va_start (argptr, fmt); + Q_vsnprintf(text, sizeof( text ), fmt, argptr); + va_end (argptr); + + ::Con_NPrintf( pos, "%s", text ); +} + +void CEngineClient::Con_NXPrintf( const struct con_nprint_s *info, const char *fmt, ... ) +{ + va_list argptr; + char text[4096]; + va_start (argptr, fmt); + Q_vsnprintf(text, sizeof( text ), fmt, argptr); + va_end (argptr); + + ::Con_NXPrintf( info, "%s", text ); +} + +IMaterial *CEngineClient::TraceLineMaterialAndLighting( const Vector &start, const Vector &end, + Vector &diffuseLightColor, Vector &baseColor ) +{ + return BrushModel_GetLightingAndMaterial( start, end, diffuseLightColor, baseColor ); +} + +int CEngineClient::IsBoxVisible( const Vector& mins, const Vector& maxs ) +{ + return CM_BoxVisible( mins, maxs, Map_VisCurrent(), CM_ClusterPVSSize() ); +} + +int CEngineClient::IsBoxInViewCluster( const Vector& mins, const Vector& maxs ) +{ + // See comments in Map_VisCurrentCluster for why we might get a negative number. + int curCluster = Map_VisCurrentCluster(); + if ( curCluster < 0 ) + return false; + + byte pvs[MAX_MAP_LEAFS/8]; + const byte *ppvs = CM_Vis( pvs, sizeof(pvs), curCluster, DVIS_PVS ); + return CM_BoxVisible(mins, maxs, ppvs, sizeof(pvs) ); +} + +float CEngineClient::Time() +{ + return Sys_FloatTime(); +} + +void CEngineClient::Sound_ExtraUpdate( void ) +{ + // On xbox this is not necessary except for long pauses, so unhook this one + if ( IsX360() ) + return; + + VPROF_BUDGET( "CEngineClient::Sound_ExtraUpdate()", VPROF_BUDGETGROUP_OTHER_SOUND ); + + S_ExtraUpdate(); +} + +bool CEngineClient::CullBox ( const Vector& mins, const Vector& maxs ) +{ + return R_CullBoxSkipNear( mins, maxs, g_Frustum ); +} + +const char *CEngineClient::GetGameDirectory( void ) +{ + return com_gamedir; +} + +const VMatrix& CEngineClient::WorldToScreenMatrix() +{ + // FIXME: this is only valid if we're currently rendering. If not, it should use the player, or it really should pass one in. + return g_EngineRenderer->WorldToScreenMatrix(); +} + +const VMatrix& CEngineClient::WorldToViewMatrix() +{ + // FIXME: this is only valid if we're currently rendering. If not, it should use the player, or it really should pass one in. + return g_EngineRenderer->ViewMatrix(); +} + +// Loads a game lump off disk +int CEngineClient::GameLumpVersion( int lumpId ) const +{ + return Mod_GameLumpVersion( lumpId ); +} + +int CEngineClient::GameLumpSize( int lumpId ) const +{ + return Mod_GameLumpSize( lumpId ); +} + +bool CEngineClient::LoadGameLump( int lumpId, void* pBuffer, int size ) +{ + return Mod_LoadGameLump( lumpId, pBuffer, size ); +} + +// Returns the number of leaves in the level +int CEngineClient::LevelLeafCount() const +{ + return host_state.worldbrush->numleafs; +} + +ISpatialQuery* CEngineClient::GetBSPTreeQuery() +{ + return g_pToolBSPTree; +} + +// Convert texlight to gamma... +void CEngineClient::LinearToGamma( float* linear, float* gamma ) +{ + gamma[0] = LinearToTexture( linear[0] ) / 255.0f; + gamma[1] = LinearToTexture( linear[1] ) / 255.0f; + gamma[2] = LinearToTexture( linear[2] ) / 255.0f; +} + +// Get the lightstyle value +float CEngineClient::LightStyleValue( int style ) +{ + return ::LightStyleValue( style ); +} + + +void CEngineClient::DrawPortals() +{ + R_DrawPortals(); +} + +// Computes light due to dynamic lighting at a point +// If the normal isn't specified, then it'll return the maximum lighting +void CEngineClient::ComputeDynamicLighting( Vector const& pt, Vector const* pNormal, Vector& color ) +{ + ::ComputeDynamicLighting( pt, pNormal, color ); +} + +// Computes light due to dynamic lighting at a point +// If the normal isn't specified, then it'll return the maximum lighting +void CEngineClient::ComputeLighting( const Vector& pt, const Vector* pNormal, bool bClamp, Vector& color, Vector *pBoxColors ) +{ + ::ComputeLighting( pt, pNormal, bClamp, color, pBoxColors ); +} + +// Returns the color of the ambient light +void CEngineClient::GetAmbientLightColor( Vector& color ) +{ + dworldlight_t* pWorldLight = FindAmbientLight(); + if (!pWorldLight) + color.Init( 0, 0, 0 ); + else + VectorCopy( pWorldLight->intensity, color ); +} + +// Returns the dx support level +int CEngineClient::GetDXSupportLevel() +{ + return g_pMaterialSystemHardwareConfig->GetDXSupportLevel(); +} + +bool CEngineClient::SupportsHDR() +{ + // deprecated. +// Assert( 0 ); + return false; +} + +void CEngineClient::Mat_Stub( IMaterialSystem *pMatSys ) +{ + materials = pMatSys; + + // Pass the call to the model renderer. + if ( g_pStudioRender ) + g_pStudioRender->Mat_Stub( pMatSys ); +} + +void CEngineClient::GetChapterName( char *pchBuff, int iMaxLength ) +{ + serverGameDLL->GetSaveComment( pchBuff, iMaxLength, 0.0f, 0.0f, true ); +} + +char const *CEngineClient::GetLevelName( void ) +{ + if ( sv.IsDedicated() ) + { + return "Dedicated Server"; + } + else if ( !cl.IsConnected() ) + { + return ""; + } + + return cl.m_szLevelFileName; +} + +int CEngineClient::GetLevelVersion( void ) +{ + return g_ServerGlobalVariables.mapversion; +} + +bool CEngineClient::IsLevelMainMenuBackground( void ) +{ + return sv.IsLevelMainMenuBackground(); +} + +void CEngineClient::GetMainMenuBackgroundName( char *dest, int destlen ) +{ + CL_GetBackgroundLevelName( dest, destlen, false ); +} + +// Occlusion system control +void CEngineClient::SetOcclusionParameters( const OcclusionParams_t ¶ms ) +{ + OcclusionSystem()->SetOcclusionParameters( params.m_flMaxOccludeeArea, params.m_flMinOccluderArea ); +} + +//----------------------------------------------------------------------------- +// Purpose: Takes a trackerID and returns which player slot that user is in +// returns 0 if no player found with that ID +//----------------------------------------------------------------------------- +int CEngineClient::GetPlayerForUserID(int userID) +{ + if ( !cl.m_pUserInfoTable ) + return 0; + + // We are occasionally getting crashes here where it looks like cl.m_nMaxClients + // is larger than the number of items in cl.m_pUserInfoTable. Callstack: + // engine.dll CEngineClient::GetPlayerForUserID + // client.dll CTFHudDeathNotice::OnGameEvent + // client.dll CHudBaseDeathNotice::FireGameEvent + // client.dll CTFHudDeathNotice::FireGameEvent + // engine.dll CGameEventManager::FireEventIntern + // engine.dll CGameEventManager::FireEventClientSide + // engine.dll CClientState::ProcessGameEvent + // So add check to make sure we don't go over m_pUserInfoTable size. + int nMaxClients = Min( cl.m_nMaxClients, cl.m_pUserInfoTable->GetNumStrings() ); + for ( int i = 0; i < nMaxClients; i++ ) + { + player_info_t *pi = (player_info_t*) cl.m_pUserInfoTable->GetStringUserData( i, NULL ); + + if ( !pi ) + continue; + + // Fixup from network order (little endian) + if ( LittleLong( pi->userID ) == userID ) + { + // return as entity index + return (i+1); + } + } + + return 0; +} + +#if !defined( NO_VOICE ) +struct IVoiceTweak_s *CEngineClient::GetVoiceTweakAPI( void ) +{ + return &g_VoiceTweakAPI; +} +#endif + +void CEngineClient::EngineStats_BeginFrame( void ) +{ + g_EngineStats.BeginFrame(); +} + +void CEngineClient::EngineStats_EndFrame( void ) +{ + g_EngineStats.EndFrame(); +} + +void CEngineClient::FireEvents() +{ + // Run any events queued up for this frame + CL_FireEvents(); +} + +void CEngineClient::CheckPoint( const char *pName ) +{ + GetTestScriptMgr()->CheckPoint( pName ); +} + +int CEngineClient::GetLeavesArea( int *pLeaves, int nLeaves ) +{ + if ( nLeaves == 0 ) + return -1; + + int iArea = host_state.worldbrush->leafs[pLeaves[0]].area; + for ( int i=1; i < nLeaves; i++ ) + { + int iTestArea = host_state.worldbrush->leafs[pLeaves[i]].area; + if ( iTestArea != iArea ) + return -1; + } + + return iArea; +} + +bool CEngineClient::DoesBoxTouchAreaFrustum( const Vector &mins, const Vector &maxs, int iArea ) +{ + const Frustum_t *pFrustum = GetAreaFrustum( iArea ); + return !R_CullBoxSkipNear( mins, maxs, *pFrustum ); +} + +//----------------------------------------------------------------------------- +// Sets the hearing origin +//----------------------------------------------------------------------------- +void CEngineClient::SetAudioState( const AudioState_t &audioState ) +{ + Host_SetAudioState( audioState ); +} + + +//----------------------------------------------------------------------------- +// +// Sentence API +// +//----------------------------------------------------------------------------- + +int CEngineClient::SentenceGroupPick( int groupIndex, char *name, int nameLen ) +{ + return VOX_GroupPick( groupIndex, name, nameLen ); +} + + +int CEngineClient::SentenceGroupPickSequential( int groupIndex, char *name, int nameLen, int sentenceIndex, int reset ) +{ + return VOX_GroupPickSequential( groupIndex, name, nameLen, sentenceIndex, reset ); +} + +int CEngineClient::SentenceIndexFromName( const char *pSentenceName ) +{ + int sentenceIndex = -1; + + VOX_LookupString( pSentenceName, &sentenceIndex ); + + return sentenceIndex; +} + +const char *CEngineClient::SentenceNameFromIndex( int sentenceIndex ) +{ + return VOX_SentenceNameFromIndex( sentenceIndex ); +} + + +int CEngineClient::SentenceGroupIndexFromName( const char *pGroupName ) +{ + return VOX_GroupIndexFromName( pGroupName ); +} + +const char *CEngineClient::SentenceGroupNameFromIndex( int groupIndex ) +{ + return VOX_GroupNameFromIndex( groupIndex ); +} + + +float CEngineClient::SentenceLength( int sentenceIndex ) +{ + return VOX_SentenceLength( sentenceIndex ); +} + +void CEngineClient::DebugDrawPhysCollide( const CPhysCollide *pCollide, IMaterial *pMaterial, matrix3x4_t& transform, const color32 &color ) +{ + ::DebugDrawPhysCollide( pCollide, pMaterial, transform, color, false ); +} + +// Activates/deactivates an occluder... +void CEngineClient::ActivateOccluder( int nOccluderIndex, bool bActive ) +{ + OcclusionSystem()->ActivateOccluder( nOccluderIndex, bActive ); +} + +bool CEngineClient::IsOccluded( const Vector &vecAbsMins, const Vector &vecAbsMaxs ) +{ + return OcclusionSystem()->IsOccluded( vecAbsMins, vecAbsMaxs ); +} + +void *CEngineClient::SaveAllocMemory( size_t num, size_t size ) +{ + return ::SaveAllocMemory( num, size ); +} + +void CEngineClient::SaveFreeMemory( void *pSaveMem ) +{ + ::SaveFreeMemory( pSaveMem ); +} + +INetChannelInfo *CEngineClient::GetNetChannelInfo( void ) +{ + return (INetChannelInfo*)cl.m_NetChannel; +} + +bool CEngineClient::IsPlayingDemo( void ) +{ + return demoplayer->IsPlayingBack(); +} + +bool CEngineClient::IsRecordingDemo( void ) +{ + return demorecorder->IsRecording(); +} + +bool CEngineClient::IsPlayingTimeDemo( void ) +{ + return demoplayer->IsPlayingTimeDemo(); +} + +bool CEngineClient::IsPaused( void ) +{ + return cl.IsPaused(); +} + +bool CEngineClient::IsTakingScreenshot( void ) +{ + return cl_takesnapshot; +} + +int CEngineClient::GetDemoRecordingTick( void ) +{ + return demorecorder->GetRecordingTick(); +} + +int CEngineClient::GetDemoPlaybackTick( void ) +{ + return demoplayer->GetPlaybackTick(); +} + +int CEngineClient::GetDemoPlaybackStartTick( void ) +{ + return demoplayer->GetPlaybackStartTick(); +} + +float CEngineClient::GetDemoPlaybackTimeScale( void ) +{ + return demoplayer->GetPlaybackTimeScale(); +} + +int CEngineClient::GetDemoPlaybackTotalTicks( void ) +{ + return demoplayer->GetTotalTicks(); +} + +bool CEngineClient::IsHLTV( void ) +{ + return cl.ishltv; +} + +void CEngineClient::GetVideoModes( int &nCount, vmode_s *&pModes ) +{ + nCount = videomode->GetModeCount(); + pModes = videomode->GetMode( 0 ); +} + +void CEngineClient::GetUILanguage( char *dest, int destlen ) +{ + const char *pStr = cl_language.GetString(); + if ( pStr ) + { + V_strncpy( dest, pStr, destlen ); + } + else if ( IsX360() ) + { + dest[0] = 0; + } +} + +//----------------------------------------------------------------------------- +// Can skybox be seen from a particular point? +//----------------------------------------------------------------------------- +SkyboxVisibility_t CEngineClient::IsSkyboxVisibleFromPoint( const Vector &vecPoint ) +{ + // In the mat_fullbright 1 case, it's always visible + // (we may have no lighting in the level, and vrad is where LEAF_FLAGS_SKY is computed) + if ( g_pMaterialSystemConfig->nFullbright == 1 ) + return SKYBOX_3DSKYBOX_VISIBLE; + + int nLeaf = CM_PointLeafnum( vecPoint ); + int nFlags = GetCollisionBSPData()->map_leafs[nLeaf].flags; + if ( nFlags & LEAF_FLAGS_SKY ) + return SKYBOX_3DSKYBOX_VISIBLE; + return ( nFlags & LEAF_FLAGS_SKY2D ) ? SKYBOX_2DSKYBOX_VISIBLE : SKYBOX_NOT_VISIBLE; +} + +const char* CEngineClient::GetMapEntitiesString() +{ + return CM_EntityString(); +} + +bool CEngineClient::IsInEditMode( void ) +{ + return g_bInEditMode; +} + +bool CEngineClient::IsInCommentaryMode( void ) +{ + return g_bInCommentaryMode; +} + +float CEngineClient::GetScreenAspectRatio() +{ + return GetScreenAspect( ); +} + +int CEngineClient::GetAppID() +{ + return GetSteamAppID(); +} + +void CEngineClient::SetOverlayBindProxy( int iOverlayID, void *pBindProxy ) +{ + OverlayMgr()->SetOverlayBindProxy( iOverlayID, pBindProxy ); +} + +void CEngineClient::ChangeTeam( const char *pTeamName ) +{ + g_pMatchmaking->ChangeTeam( pTeamName ); +} + +//----------------------------------------------------------------------------- +// Returns true if copy occured +//----------------------------------------------------------------------------- +bool CEngineClient::CopyFrameBufferToMaterial( const char *pMaterialName ) +{ + if ( !IsX360() ) + { + // not for PC + Assert( 0 ); + return false; + } + + IMaterial *pMaterial = materials->FindMaterial( pMaterialName, TEXTURE_GROUP_OTHER ); + if ( pMaterial->IsErrorMaterial() ) + { + // unknown material + return false; + } + + bool bFound; + IMaterialVar *pMaterialVar = pMaterial->FindVar( "$baseTexture", &bFound, false ); + if ( !bFound || pMaterialVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE ) + { + // lack of expected $basetexture + return false; + } + + ITexture *pTexture = pMaterialVar->GetTextureValue(); + if ( !pTexture || !pTexture->IsRenderTarget() ) + { + // base texture is not a render target + return false; + } + + CMatRenderContextPtr pRenderContext( materials ); + + int width, height; + pRenderContext->GetRenderTargetDimensions( width, height ); + if ( width != pTexture->GetActualWidth() || height != pTexture->GetActualHeight() ) + { + // better be matched, not supporting a disparate blit in this context + // disparate blit may very well use same RT we are trying to copy into + return false; + } + + pRenderContext->CopyRenderTargetToTexture( pTexture ); + return true; +} + + +//----------------------------------------------------------------------------- +// Used by the color correction UI +//----------------------------------------------------------------------------- +void CEngineClient::GrabPreColorCorrectedFrame( int x, int y, int width, int height ) +{ + colorcorrectiontools->GrabPreColorCorrectedFrame( x, y, width, height ); +} + +//----------------------------------------------------------------------------- +// Is hammer running? +//----------------------------------------------------------------------------- +bool CEngineClient::IsHammerRunning( ) const +{ + return IsPC() ? InEditMode() : false; +} + +extern IAchievementMgr *g_pAchievementMgr; + +//----------------------------------------------------------------------------- +// Sets achievement mgr +//----------------------------------------------------------------------------- +void CEngineClient::SetAchievementMgr( IAchievementMgr *pAchievementMgr ) +{ + g_pAchievementMgr = pAchievementMgr; +} + +//----------------------------------------------------------------------------- +// Gets achievement mgr +//----------------------------------------------------------------------------- +IAchievementMgr *CEngineClient::GetAchievementMgr() +{ + return g_pAchievementMgr; +} + + +//----------------------------------------------------------------------------- +// Called by the client to determine violence settings for things like ragdoll +// fading. +//----------------------------------------------------------------------------- +bool CEngineClient::IsLowViolence() +{ + return g_bLowViolence; +} + +const char *CEngineClient::GetMostRecentSaveGame( void ) +{ + return saverestore->GetMostRecentlyLoadedFileName(); +} + +void CEngineClient::SetMostRecentSaveGame( const char *lpszFilename ) +{ + saverestore->SetMostRecentSaveGame( lpszFilename ); +} + +//----------------------------------------------------------------------------- +// Called by gameui to hint the engine that an exiting process has started. +// The Engine needs to stabilize to a safe quiet state. More frames are going +// to and have to run, but the true exit will occur. +//----------------------------------------------------------------------------- +void CEngineClient::StartXboxExitingProcess() +{ + if ( IsPC() ) + { + // not for PC + return; + } + + g_pInputSystem->StopRumble(); + + // save out the achievements + g_pAchievementMgr->SaveGlobalStateIfDirty( false ); + + S_StopAllSounds( true ); + + // Shutdown QMS, need to go back to single threaded + Host_AllowQueuedMaterialSystem( false ); +} + +bool CEngineClient::IsSaveInProgress() +{ + return saverestore->IsSaveInProgress(); +} + +extern IXboxSystem *g_pXboxSystem; + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +uint CEngineClient::OnStorageDeviceAttached( void ) +{ + return g_pXboxSystem->OpenContainers(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEngineClient::OnStorageDeviceDetached( void ) +{ + XBX_SetStorageDeviceId( XBX_INVALID_STORAGE_ID ); + g_pXboxSystem->CloseContainers(); +} + +void CEngineClient::ResetDemoInterpolation( void ) +{ + if( demorecorder->IsRecording() ) + demorecorder->ResetDemoInterpolation(); + if (demoplayer->IsPlayingBack() ) + demoplayer->ResetDemoInterpolation(); +} + + +extern CGamestatsData *g_pGamestatsData; +void CEngineClient::SetGamestatsData( CGamestatsData *pGamestatsData ) +{ + g_pGamestatsData = pGamestatsData; +} + +CGamestatsData *CEngineClient::GetGamestatsData() +{ + return g_pGamestatsData; +} + +//----------------------------------------------------------------------------- + +#if defined( USE_SDL ) + +void CEngineClient::GetMouseDelta( int &x, int &y, bool bIgnoreNextMouseDelta ) +{ + g_pLauncherMgr->GetMouseDelta( x, y, bIgnoreNextMouseDelta ); +} + +#endif + + +void CEngineClient::ServerCmdKeyValues( KeyValues *pKeyValues ) +{ + cl.SendServerCmdKeyValues( pKeyValues ); +} + +bool CEngineClient::IsSkippingPlayback( void ) +{ + return demoplayer->IsSkipping(); +} + +bool CEngineClient::IsLoadingDemo( void ) +{ + return demoplayer->IsLoading(); +} + +bool CEngineClient::IsPlayingDemoALocallyRecordedDemo() +{ + return IsPlayingDemo() && + demoplayer && + demoplayer->GetDemoFile() && + !V_strnicmp( demoplayer->GetDemoFile()->m_DemoHeader.servername, "localhost", 9 ); +} + +uint CEngineClient::GetProtocolVersion() +{ + if ( demoplayer && demoplayer->IsPlayingBack() ) + { + return demoplayer->GetProtocolVersion(); + } + return PROTOCOL_VERSION; +} + +bool CEngineClient::IsWindowedMode() +{ + return videomode->IsWindowedMode(); +} + +int CEngineClient::GetClientVersion() const +{ + return GetSteamInfIDVersionInfo().ClientVersion; +} + +bool CEngineClient::IsActiveApp( void ) +{ + return game->IsActiveApp(); +} + +//----------------------------------------------------------------------------- +// Previously ConCommand disconnect +//----------------------------------------------------------------------------- +void CEngineClient::DisconnectInternal( void ) +{ + Disconnect(); +} + +//----------------------------------------------------------------------------- +// The client DLL serves out this interface +//----------------------------------------------------------------------------- +IBaseClientDLL *g_ClientDLL = NULL; +IClientVirtualReality *g_pClientVR = NULL; +IPrediction *g_pClientSidePrediction = NULL; +IClientRenderTargets *g_pClientRenderTargets = NULL; +IClientEntityList *entitylist = NULL; +ICenterPrint *centerprint = NULL; +IClientLeafSystemEngine *clientleafsystem = NULL; +bool g_bClientLeafSystemV1; +ClientClass *g_pClientClassHead = NULL; +IClientReplay *g_pClientReplay = NULL; + +ClientClass *ClientDLL_GetAllClasses( void ) +{ + if ( g_ClientDLL ) + return g_ClientDLL->GetAllClasses(); + else + return g_pClientClassHead; +} + +static void ClientDLL_InitRecvTableMgr() +{ + // Register all the receive tables. + RecvTable *pRecvTables[MAX_DATATABLES]; + int nRecvTables = 0; + for ( ClientClass *pCur = ClientDLL_GetAllClasses(); pCur; pCur=pCur->m_pNext ) + { + ErrorIfNot( + nRecvTables < ARRAYSIZE( pRecvTables ), + ("ClientDLL_InitRecvTableMgr: overflowed MAX_DATATABLES") + ); + + pRecvTables[nRecvTables] = pCur->m_pRecvTable; + ++nRecvTables; + } + + RecvTable_Init( pRecvTables, nRecvTables ); +} + + +static void ClientDLL_ShutdownRecvTableMgr() +{ + RecvTable_Term(); +} + +CreateInterfaceFn ClientDLL_GetFactory( void ) +{ + return g_ClientFactory; +} + +//----------------------------------------------------------------------------- +// Purpose: Loads the client DLL +// Input : - +//----------------------------------------------------------------------------- +bool ClientDLL_Load() +{ + Assert ( !g_ClientDLLModule ); + + // Check the signature on the client dll. If this fails we load it anyway but put this client + // into insecure mode so it won't connect to secure servers and get VAC banned + if ( !Host_AllowLoadModule( "client.dll", "GAMEBIN", true ) ) + { + // not supposed to load this but we will anyway + Host_DisallowSecureServers(); + Host_AllowLoadModule( "client.dll","GAMEBIN", true ); + } + + g_ClientDLLModule = g_pFileSystem->LoadModule( "client", "GAMEBIN", false ); + if ( g_ClientDLLModule ) + { + g_ClientFactory = Sys_GetFactory( g_ClientDLLModule ); + if ( g_ClientFactory ) + { + g_ClientDLL = (IBaseClientDLL *)g_ClientFactory( CLIENT_DLL_INTERFACE_VERSION, NULL ); + // this is to ensure the old format of the string table is used for clients version 13 and older. + // when the client version gets revved, there will need to be an else that sets this bool to true + g_bClientGameDLLGreaterThanV13 = false; + if ( !g_ClientDLL ) + { + Sys_Error( "Could not get client.dll interface from library client" ); + } + + if( g_pSourceVR ) + { + g_pClientVR = (IClientVirtualReality *)g_ClientFactory( CLIENTVIRTUALREALITY_INTERFACE_VERSION, NULL ); + if( !g_pClientVR ) + { + Msg( "client.dll is not VR-compatible.\n" ); + } + } + } + else + { + Sys_Error( "Could not find factory interface in library client" ); + } + } + else + { + // tell Steam to do a quick verify of the install. Sys_Error doesn't return, so do this first. + if( Steam3Client().SteamApps() ) + Steam3Client().SteamApps()->MarkContentCorrupt( true ); + + // library failed to load + Sys_Error( "Could not load library client. Try restarting. If that doesn't work, verify the cache." ); + } + + // Load the client render targets interface from the client .dll + // NOTE: Its OK if this returns NULL, as some mods won't provide the interface and will just use the default behavior of the engine + g_pClientRenderTargets = (IClientRenderTargets *)g_ClientFactory( CLIENTRENDERTARGETS_INTERFACE_VERSION, NULL ); + + return true; +} + +void InitExtraClientCmdCanExecuteVars() +{ + // This can go away when we ship a client DLL with the FCVAR_CLIENTCMD_CAN_EXECUTE flag set on these cvars/concommands. + Cmd_AddClientCmdCanExecuteVar( "cancelselect" ); + Cmd_AddClientCmdCanExecuteVar( "menuselect" ); + Cmd_AddClientCmdCanExecuteVar( "playgamesound" ); + Cmd_AddClientCmdCanExecuteVar( "_cl_classmenuopen" ); + Cmd_AddClientCmdCanExecuteVar( "cl_buy_favorite" ); + Cmd_AddClientCmdCanExecuteVar( "voice_modenable" ); + Cmd_AddClientCmdCanExecuteVar( "togglescores" ); + + Cmd_AddClientCmdCanExecuteVar( "spec_next" ); + Cmd_AddClientCmdCanExecuteVar( "spec_prev" ); + Cmd_AddClientCmdCanExecuteVar( "spec_mode" ); + Cmd_AddClientCmdCanExecuteVar( "spec_menu" ); + Cmd_AddClientCmdCanExecuteVar( "spec_autodirector" ); + Cmd_AddClientCmdCanExecuteVar( "overview_zoom" ); + Cmd_AddClientCmdCanExecuteVar( "overview_mode" ); + Cmd_AddClientCmdCanExecuteVar( "overview_health" ); + Cmd_AddClientCmdCanExecuteVar( "overview_names" ); + Cmd_AddClientCmdCanExecuteVar( "overview_tracks" ); + Cmd_AddClientCmdCanExecuteVar( "overview_locked" ); + Cmd_AddClientCmdCanExecuteVar( "overview_alpha" ); + + Cmd_AddClientCmdCanExecuteVar( "playgamesound" ); +} + +//----------------------------------------------------------------------------- +// Purpose: Inits the client .dll +//----------------------------------------------------------------------------- +void ClientDLL_Init( void ) +{ + extern void CL_SetSteamCrashComment(); + + // Assert ClientDLL_Load successfully created these interfaces, as we need them to init properly + Assert ( g_ClientDLL ); + Assert ( g_ClientFactory ); + + // this will get updated after we load a map, but this gets video info if we sys_error() prior to loading a map + CL_SetSteamCrashComment(); + + if ( g_ClientDLL ) + { + COM_TimestampedLog( "g_ClientDLL->Init" ); + + if ( !g_ClientDLL->Init(g_AppSystemFactory, g_AppSystemFactory, &g_ClientGlobalVariables ) ) + { + Sys_Error("Client.dll Init() in library client failed."); + } + + if ( g_ClientFactory ) + { + COM_TimestampedLog( "g_pClientSidePrediction->Init" ); + + // Load the prediction interface from the client .dll + g_pClientSidePrediction = (IPrediction *)g_ClientFactory( VCLIENT_PREDICTION_INTERFACE_VERSION, NULL ); + if ( !g_pClientSidePrediction ) + { + Sys_Error( "Could not get IPrediction interface from library client" ); + } + g_pClientSidePrediction->Init(); + + entitylist = ( IClientEntityList *)g_ClientFactory( VCLIENTENTITYLIST_INTERFACE_VERSION, NULL ); + if ( !entitylist ) + { + Sys_Error( "Could not get client entity list interface from library client" ); + } + + centerprint = ( ICenterPrint * )g_ClientFactory( VCENTERPRINT_INTERFACE_VERSION, NULL ); + if ( !centerprint ) + { + Sys_Error( "Could not get centerprint interface from library client" ); + } + + clientleafsystem = ( IClientLeafSystemEngine *)g_ClientFactory( CLIENTLEAFSYSTEM_INTERFACE_VERSION, NULL ); + if ( clientleafsystem ) + { + g_bClientLeafSystemV1 = false; + } + else if ( !clientleafsystem ) + { + clientleafsystem = ( IClientLeafSystemEngine *)g_ClientFactory( CLIENTLEAFSYSTEM_INTERFACE_VERSION_1, NULL ); + if ( !clientleafsystem ) + { + Sys_Error( "Could not get client leaf system interface from library client" ); + } + else + { + g_bClientLeafSystemV1 = true; + } + } + +#if defined( REPLAY_ENABLED ) + if ( Replay_IsSupportedModAndPlatform() ) + { + // Replay dll should be loaded by this point + if ( !g_pReplay ) + { + Sys_Error( "Replay.dll was not loaded" ); + } + + // Get pointer to client-side replay interface implementation + g_pClientReplay = (IClientReplay *)g_ClientFactory( CLIENT_REPLAY_INTERFACE_VERSION, NULL ); + if ( !g_pClientReplay ) + { + Sys_Error( "Could not get the replay interface from library client" ); + } + + // Allow the client dll to setup pointers to replay interfaces + extern CreateInterfaceFn g_fnReplayFactory; + if ( !g_ClientDLL->ReplayInit( g_fnReplayFactory ) ) + { + Sys_Error( "Client ReplayInit() failed!" ); + } + + // Allow the replay dll to setup pointers to client interfaces + if ( !g_pReplay->CL_Init( g_ClientFactory ) ) + { + Sys_Error( "Replay system ClientInit() failed" ); + } + + if ( !g_ClientDLL->ReplayPostInit() ) + { + Sys_Error( "Client ReplayPostInit() failed!" ); + } + +#if !defined( DEDICATED ) + extern CGameServer sv; + if ( !sv.IsDedicated() ) + { + g_pClientReplayContext = g_pReplay->CL_GetContext(); + g_pReplayManager = g_pClientReplayContext->GetReplayManager(); + g_pReplayMovieManager = g_pClientReplayContext->GetMovieManager(); + g_pReplayMovieRenderer = g_pClientReplayContext->GetMovieRenderer(); + g_pReplayPerformanceManager = g_pClientReplayContext->GetPerformanceManager(); + g_pReplayPerformanceController = g_pClientReplayContext->GetPerformanceController(); + + ReplayLib_Init( com_gamedir, g_pClientReplayContext ); + } +#endif + } +#endif + + toolframework->ClientInit( g_ClientFactory ); + } + + // Don't want TF2 running less than DX 8 + if ( g_pMaterialSystemHardwareConfig && g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 80 ) + { + if ( ( Q_stricmp( COM_GetModDirectory(), "tf" ) == 0 ) || ( Q_stricmp( COM_GetModDirectory(), "ep2" ) == 0 ) || ( Q_stricmp( COM_GetModDirectory(), "portal" ) == 0 ) || ( Q_stricmp( COM_GetModDirectory(), "tf_beta" ) == 0 ) ) + { + Sys_Error( "Your graphics hardware must support at least pixel shader version 1.1 to run this game!" ); + } + } + } + + COM_TimestampedLog( "ClientDLL_InitRecvTableMgr" ); + + ClientDLL_InitRecvTableMgr(); + + InitExtraClientCmdCanExecuteVars(); +} + +//----------------------------------------------------------------------------- +// Purpose: Shuts down the client .dll +//----------------------------------------------------------------------------- +void ClientDLL_Shutdown( void ) +{ +#if defined( REPLAY_ENABLED ) + if ( g_pReplay ) + { + g_pReplay->CL_Shutdown(); + } +#endif + + toolframework->ClientShutdown(); + + ClientDLL_ShutdownRecvTableMgr(); + + vgui::ivgui()->RunFrame(); + + materials->UncacheAllMaterials(); + + vgui::ivgui()->RunFrame(); + + g_pClientSidePrediction->Shutdown(); + + entitylist = NULL; + g_pClientSidePrediction = NULL; + g_ClientFactory = NULL; + centerprint = NULL; + + g_ClientDLL->Shutdown(); +} + +//----------------------------------------------------------------------------- +// Purpose: Unloads the client .dll +// Input : - +//----------------------------------------------------------------------------- +void ClientDLL_Unload() +{ + FileSystem_UnloadModule( g_ClientDLLModule ); + + g_ClientDLL = NULL; + g_ClientDLLModule = NULL; + g_pClientRenderTargets = NULL; + +} + +//----------------------------------------------------------------------------- +// Purpose: Called when the game initializes and whenever the vid_mode is changed +// so the HUD can reinitialize itself. +//----------------------------------------------------------------------------- +void ClientDLL_HudVidInit( void ) +{ + g_ClientDLL->HudVidInit(); +} + +//----------------------------------------------------------------------------- +// Purpose: Allow client .dll to modify input data +//----------------------------------------------------------------------------- + +void ClientDLL_ProcessInput( void ) +{ + if ( !g_ClientDLL ) + return; + + VPROF("ClientDLL_ProcessInput"); + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ ); + g_ClientDLL->HudProcessInput( cl.IsConnected() ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void ClientDLL_FrameStageNotify( ClientFrameStage_t frameStage ) +{ + if ( !g_ClientDLL ) + return; + + tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ ); + + g_ClientDLL->FrameStageNotify( frameStage ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Allow client .dll to think +//----------------------------------------------------------------------------- +void ClientDLL_Update( void ) +{ + if ( sv.IsDedicated() ) + return; + + if ( !g_ClientDLL ) + return; + + g_ClientDLL->HudUpdate( true ); +} + + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void ClientDLL_VoiceStatus( int entindex, bool bTalking ) +{ + if( g_ClientDLL ) + g_ClientDLL->VoiceStatus( entindex, bTalking ); +} + + +#ifdef IS_WINDOWS_PC +#include "winlite.h" +#endif + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEngineClient::FlashWindow() +{ +#ifndef USE_SDL + FLASHWINFO flashwinfo; + flashwinfo.cbSize = sizeof( flashwinfo ); + flashwinfo.hwnd = (HWND)game->GetMainWindow(); + flashwinfo.dwFlags = FLASHW_ALL; + flashwinfo.uCount = 5; + flashwinfo.dwTimeout = 0; + FlashWindowEx( &flashwinfo ); +#endif +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +int CEngineClient::GetInstancesRunningCount( ) +{ + return CheckOtherInstancesRunning( ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +float CEngineClient::GetPausedExpireTime( void ) +{ + return cl.GetPausedExpireTime(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +bool CEngineClient::StartDemoRecording( const char *pszFilename, const char *pszFolder /* = NULL */ ) +{ + bool bUseFolder = ( pszFolder && pszFolder[0] ); + + if ( demorecorder->IsRecording() ) + { + ConMsg( "Already recording.\n" ); + return false; + } + + if ( demoplayer->IsPlayingBack() ) + { + ConMsg( "Can't record during demo playback.\n" ); + return false; + } + + // check filename + if ( !COM_IsValidPath( pszFilename ) ) + { + ConMsg( "record %s: invalid filename.\n", pszFilename ); + return false; + } + + if ( bUseFolder ) + { + // check folder + if ( !COM_IsValidPath( pszFolder ) ) + { + ConMsg( "record %s: invalid folder.\n", pszFolder ); + return false; + } + } + + char szFinal[MAX_OSPATH]; + char szTemp[MAX_OSPATH]; + + if ( !g_ClientDLL->CanRecordDemo( szTemp, sizeof( szTemp ) ) ) + { + ConMsg( "%s\n", szTemp ); // re-use szTemp as the error string if the client prevents us from starting a demo + return false; + } + + if ( bUseFolder ) + { + V_sprintf_safe( szTemp, "%s%c%s", pszFolder, CORRECT_PATH_SEPARATOR, pszFilename ); + } + else + { + V_sprintf_safe( szTemp, "%s", pszFilename ); + } + + // remove .dem extension if it exists + Q_StripExtension( szTemp, szFinal, sizeof( szFinal ) ); + + // record it + demorecorder->StartRecording( szFinal, false ); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEngineClient::StopDemoRecording( void ) +{ + if ( !demorecorder->IsRecording() ) + { + ConDMsg( "Not recording a demo.\n" ); + return; + } + + demorecorder->StopRecording(); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CEngineClient::TakeScreenshot( const char *pszFilename, const char *pszFolder /* = NULL */ ) +{ + bool bUseFolder = ( pszFolder && pszFolder[0] ); + + // check filename + if ( !COM_IsValidPath( pszFilename ) ) + { + ConMsg( "TakeScreenshot invalid filename: %s\n", pszFilename ); + return; + } + + if ( bUseFolder ) + { + // check folder + if ( !COM_IsValidPath( pszFolder ) ) + { + ConMsg( "TakeScreenshot invalid folder: %s\n", pszFolder ); + return; + } + } + + bool bReadPixelsFromFrontBuffer = g_pMaterialSystemHardwareConfig->ReadPixelsFromFrontBuffer(); + if ( bReadPixelsFromFrontBuffer ) + { + Shader_SwapBuffers(); + } + + // Disable threading for the duration of the screenshots, because we need to get pointers to the (complete) + // back buffer right now. + bool bEnabled = materials->AllowThreading( false, g_nMaterialSystemThread ); + + char szFinal[MAX_OSPATH] = {0}; + + if ( bUseFolder ) + { + V_sprintf_safe( szFinal, "%s%c%s", pszFolder, CORRECT_PATH_SEPARATOR, pszFilename ); + } + else + { + V_sprintf_safe( szFinal, "%s", pszFilename ); + } + + V_SetExtension( szFinal, ".tga", sizeof( szFinal ) ); + + videomode->TakeSnapshotTGA( szFinal ); + + // Restore threading if it was previously enabled (if it wasn't this will do nothing). + materials->AllowThreading( bEnabled, g_nMaterialSystemThread ); + + if ( !bReadPixelsFromFrontBuffer ) + { + Shader_SwapBuffers(); + } +} |