mirror of
https://github.com/ENSL/NS.git
synced 2024-11-24 05:21:16 +00:00
19b458f8bc
git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@141 67975925-1194-0748-b3d5-c16f83f1a3a1
443 lines
No EOL
9.9 KiB
C++
443 lines
No EOL
9.9 KiB
C++
/***
|
|
*
|
|
* Copyright (c) 1999, Valve LLC. All rights reserved.
|
|
*
|
|
* This product contains software technology licensed from Id
|
|
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* Use, distribution, and modification of this source code and/or resulting
|
|
* object code is restricted to non-commercial enhancements to products from
|
|
* Valve LLC. All other use, distribution, or modification is prohibited
|
|
* without written permission from Valve LLC.
|
|
*
|
|
****/
|
|
//
|
|
// cdll_int.c
|
|
//
|
|
// this implementation handles the linking of the engine to the DLL
|
|
//
|
|
|
|
#include "hud.h"
|
|
#include "cl_util.h"
|
|
#include "netadr.h"
|
|
#include "vgui_schememanager.h"
|
|
#include "particles/papi.h"
|
|
|
|
//extern "C"
|
|
//{
|
|
#include "pm_shared.h"
|
|
//}
|
|
|
|
#include <string.h>
|
|
#include "hud_servers.h"
|
|
#include "vgui_int.h"
|
|
#include "mod\AvHHud.h"
|
|
#include "mod\AvHUIFactory.h"
|
|
#include "mod\AvHParticleSystemManager.h"
|
|
#include "mod\AvHHulls.h"
|
|
#include "interface.h"
|
|
#include "ITrackerUser.h"
|
|
|
|
#include "engine/APIProxy.h"
|
|
#include "cl_dll/Exports.h"
|
|
|
|
cl_enginefunc_t gEngfuncs;
|
|
|
|
// Instead of using default Half-life HUD, use more flexible one I've added
|
|
//CHud gHUD;
|
|
//UIHud gHUD("StratHL/ui.txt", new AvHUIFactory());
|
|
AvHHud gHUD((string(getModDirectory()) + "/ui.txt").c_str(), new AvHUIFactory());
|
|
|
|
TeamFortressViewport *gViewPort = NULL;
|
|
|
|
HINTERFACEMODULE g_hTrackerModule = NULL;
|
|
ITrackerUser *g_pTrackerUser = NULL;
|
|
|
|
void InitInput (void);
|
|
void EV_HookEvents( void );
|
|
void IN_Commands( void );
|
|
|
|
/*
|
|
================================
|
|
HUD_GetHullBounds
|
|
|
|
Engine calls this to enumerate player collision hulls, for prediction. Return 0 if the hullnumber doesn't exist.
|
|
================================
|
|
*/
|
|
int CL_DLLEXPORT HUD_GetHullBounds( int hullnumber, float *mins, float *maxs )
|
|
{
|
|
RecClGetHullBounds(hullnumber, mins, maxs);
|
|
|
|
int iret = 0;
|
|
|
|
switch ( hullnumber )
|
|
{
|
|
case 0: // Human and level 4 alien, crouched level 5
|
|
HULL0_MIN.CopyToArray(mins);
|
|
HULL0_MAX.CopyToArray(maxs);
|
|
iret = 1;
|
|
break;
|
|
|
|
case 1: // Crouched human, level 2 alien, level 3, crouched level 3 and 4
|
|
HULL1_MIN.CopyToArray(mins);
|
|
HULL1_MAX.CopyToArray(maxs);
|
|
iret = 1;
|
|
break;
|
|
|
|
case 2: // Point based hull
|
|
HULL2_MIN.CopyToArray(mins);
|
|
HULL2_MAX.CopyToArray(maxs);
|
|
iret = 1;
|
|
break;
|
|
|
|
case 3: // Huge alien
|
|
HULL3_MIN.CopyToArray(mins);
|
|
HULL3_MAX.CopyToArray(maxs);
|
|
iret = 1;
|
|
break;
|
|
}
|
|
|
|
return iret;
|
|
}
|
|
|
|
/*
|
|
================================
|
|
HUD_ConnectionlessPacket
|
|
|
|
Return 1 if the packet is valid. Set response_buffer_size if you want to send a response packet. Incoming, it holds the max
|
|
size of the response_buffer, so you must zero it out if you choose not to respond.
|
|
================================
|
|
*/
|
|
int CL_DLLEXPORT HUD_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size )
|
|
{
|
|
RecClConnectionlessPacket(net_from, args, response_buffer, response_buffer_size);
|
|
|
|
// Parse stuff from args
|
|
int max_buffer_size = *response_buffer_size;
|
|
|
|
// Zero it out since we aren't going to respond.
|
|
// If we wanted to response, we'd write data into response_buffer
|
|
*response_buffer_size = 0;
|
|
|
|
// Since we don't listen for anything here, just respond that it's a bogus message
|
|
// If we didn't reject the message, we'd return 1 for success instead.
|
|
return 0;
|
|
}
|
|
|
|
void CL_DLLEXPORT HUD_PlayerMoveInit( struct playermove_s *ppmove )
|
|
{
|
|
RecClClientMoveInit(ppmove);
|
|
|
|
PM_Init( ppmove );
|
|
}
|
|
|
|
char CL_DLLEXPORT HUD_PlayerMoveTexture( char *name )
|
|
{
|
|
RecClClientTextureType(name);
|
|
|
|
return PM_FindTextureType( name );
|
|
}
|
|
|
|
void CL_DLLEXPORT HUD_PlayerMove( struct playermove_s *ppmove, int server )
|
|
{
|
|
RecClClientMove(ppmove, server);
|
|
|
|
PM_Move( ppmove, server );
|
|
}
|
|
|
|
int CL_DLLEXPORT Initialize( cl_enginefunc_t *pEnginefuncs, int iVersion )
|
|
{
|
|
gEngfuncs = *pEnginefuncs;
|
|
|
|
RecClInitialize(pEnginefuncs, iVersion);
|
|
|
|
if (iVersion != CLDLL_INTERFACE_VERSION)
|
|
return 0;
|
|
|
|
memcpy(&gEngfuncs, pEnginefuncs, sizeof(cl_enginefunc_t));
|
|
|
|
EV_HookEvents();
|
|
// get tracker interface, if any
|
|
char szDir[512];
|
|
if (!gEngfuncs.COM_ExpandFilename("Bin/TrackerUI.dll", szDir, sizeof(szDir)))
|
|
{
|
|
g_pTrackerUser = NULL;
|
|
g_hTrackerModule = NULL;
|
|
return 1;
|
|
}
|
|
|
|
g_hTrackerModule = Sys_LoadModule(szDir);
|
|
CreateInterfaceFn trackerFactory = Sys_GetFactory(g_hTrackerModule);
|
|
if (!trackerFactory)
|
|
{
|
|
g_pTrackerUser = NULL;
|
|
g_hTrackerModule = NULL;
|
|
return 1;
|
|
}
|
|
|
|
g_pTrackerUser = (ITrackerUser *)trackerFactory(TRACKERUSER_INTERFACE_VERSION, NULL);
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
==========================
|
|
HUD_VidInit
|
|
|
|
Called when the game initializes
|
|
and whenever the vid_mode is changed
|
|
so the HUD can reinitialize itself.
|
|
==========================
|
|
*/
|
|
|
|
int CL_DLLEXPORT HUD_VidInit( void )
|
|
{
|
|
RecClHudVidInit();
|
|
gHUD.VidInit();
|
|
|
|
VGui_Startup();
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
==========================
|
|
HUD_Init
|
|
|
|
Called whenever the client connects
|
|
to a server. Reinitializes all
|
|
the hud variables.
|
|
==========================
|
|
*/
|
|
|
|
void CL_DLLEXPORT HUD_Init( void )
|
|
{
|
|
RecClHudInit();
|
|
InitInput();
|
|
gHUD.Init();
|
|
Scheme_Init();
|
|
}
|
|
|
|
|
|
void UIDrawVariableBarSpriteHoles(int inSprite, int inX, int inY, float inPercentage)
|
|
{
|
|
// Assumes that frame 0 is the empty sprite, frame 1 is full sprite
|
|
const int kEmptyFrame = 0;
|
|
const int kFullFrame = 1;
|
|
|
|
int theSpriteWidth = SPR_Width(inSprite, kFullFrame);
|
|
int theSpriteHeight = SPR_Height(inSprite, kFullFrame);
|
|
|
|
int theColorComponent = 255;
|
|
|
|
// Draw empty sprite
|
|
SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent);
|
|
SPR_DrawHoles(kEmptyFrame, inX, inY, NULL);
|
|
|
|
// Draw secondary level if specified, at half brightness
|
|
int theFilledHeight = theSpriteHeight*inPercentage;
|
|
theFilledHeight = theSpriteHeight*inPercentage;
|
|
|
|
// Draw partially full sprite. Enable scissor so it's not all drawn.
|
|
SPR_EnableScissor(inX, inY + (theSpriteHeight - theFilledHeight), theSpriteWidth, theFilledHeight);
|
|
|
|
SPR_Set(inSprite, theColorComponent, theColorComponent, theColorComponent);
|
|
SPR_DrawHoles(kFullFrame, inX, inY, NULL);
|
|
|
|
SPR_DisableScissor();
|
|
}
|
|
|
|
// Demonstrates black lines around the edge of sprites (both using tri API and SPR_* calls)
|
|
// Demonstrates scissor not working properly
|
|
void Direct3DTest()
|
|
{
|
|
static int theSprite = 0;
|
|
|
|
if(!theSprite)
|
|
{
|
|
theSprite = Safe_SPR_Load("sprites/640a-energy.spr");
|
|
}
|
|
|
|
// Draw alien energy
|
|
if(theSprite)
|
|
{
|
|
int theFrame = 0;
|
|
|
|
int theX = ScreenWidth() - SPR_Width(theSprite, theFrame);
|
|
int theY = ScreenHeight() - SPR_Height(theSprite, theFrame);
|
|
|
|
// 0-1, depending how much to draw
|
|
float theFactor = .5f;
|
|
UIDrawVariableBarSpriteHoles(theSprite, theX, theY, theFactor);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==========================
|
|
HUD_Redraw
|
|
|
|
called every screen frame to
|
|
redraw the HUD.
|
|
===========================
|
|
*/
|
|
|
|
int CL_DLLEXPORT HUD_Redraw( float time, int intermission )
|
|
{
|
|
RecClHudRedraw(time, intermission);
|
|
|
|
gHUD.Redraw( time, intermission );
|
|
|
|
//Direct3DTest();
|
|
|
|
//SoftwareTest();
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
==========================
|
|
HUD_UpdateClientData
|
|
|
|
called every time shared client
|
|
dll/engine data gets changed,
|
|
and gives the cdll a chance
|
|
to modify the data.
|
|
|
|
returns 1 if anything has been changed, 0 otherwise.
|
|
==========================
|
|
*/
|
|
|
|
int CL_DLLEXPORT HUD_UpdateClientData(client_data_t *pcldata, float flTime )
|
|
{
|
|
RecClHudUpdateClientData(pcldata, flTime);
|
|
|
|
IN_Commands();
|
|
|
|
return gHUD.UpdateClientData(pcldata, flTime );
|
|
}
|
|
|
|
/*
|
|
==========================
|
|
HUD_Reset
|
|
|
|
Called at start and end of demos to restore to "non"HUD state.
|
|
==========================
|
|
*/
|
|
|
|
void CL_DLLEXPORT HUD_Reset( void )
|
|
{
|
|
RecClHudReset();
|
|
|
|
gHUD.VidInit();
|
|
AvHParticleSystemManager::Instance()->Reset();
|
|
}
|
|
|
|
/*
|
|
==========================
|
|
HUD_Frame
|
|
|
|
Called by engine every frame that client .dll is loaded
|
|
==========================
|
|
*/
|
|
|
|
void CL_DLLEXPORT HUD_Frame( double time )
|
|
{
|
|
RecClHudFrame(time);
|
|
|
|
ServersThink( time );
|
|
|
|
GetClientVoiceMgr()->Frame(time);
|
|
}
|
|
|
|
|
|
/*
|
|
==========================
|
|
HUD_VoiceStatus
|
|
|
|
Called when a player starts or stops talking.
|
|
==========================
|
|
*/
|
|
|
|
void CL_DLLEXPORT HUD_VoiceStatus(int entindex, qboolean bTalking)
|
|
{
|
|
RecClVoiceStatus(entindex, bTalking);
|
|
|
|
GetClientVoiceMgr()->UpdateSpeakerStatus(entindex, bTalking);
|
|
}
|
|
|
|
/*
|
|
==========================
|
|
HUD_DirectorEvent
|
|
|
|
Called when a director event message was received
|
|
==========================
|
|
*/
|
|
|
|
void CL_DLLEXPORT HUD_DirectorMessage( int iSize, void *pbuf )
|
|
{
|
|
RecClDirectorMessage(iSize, pbuf);
|
|
gHUD.m_Spectator.DirectorMessage( iSize, pbuf );
|
|
}
|
|
|
|
|
|
|
|
#if defined( FINAL_VAC_BUILD )
|
|
|
|
cldll_func_dst_t *g_pcldstAddrs;
|
|
|
|
extern "C" void __declspec( dllexport ) F(void *pv)
|
|
{
|
|
cldll_func_t *pcldll_func = (cldll_func_t *)pv;
|
|
|
|
g_pcldstAddrs = ((cldll_func_dst_t *)pcldll_func->pHudVidInitFunc);
|
|
|
|
cldll_func_t cldll_func =
|
|
{
|
|
Initialize,
|
|
HUD_Init,
|
|
HUD_VidInit,
|
|
HUD_Redraw,
|
|
HUD_UpdateClientData,
|
|
HUD_Reset,
|
|
HUD_PlayerMove,
|
|
HUD_PlayerMoveInit,
|
|
HUD_PlayerMoveTexture,
|
|
IN_ActivateMouse,
|
|
IN_DeactivateMouse,
|
|
IN_MouseEvent,
|
|
IN_ClearStates,
|
|
IN_Accumulate,
|
|
CL_CreateMove,
|
|
CL_IsThirdPerson,
|
|
CL_CameraOffset,
|
|
KB_Find,
|
|
CAM_Think,
|
|
V_CalcRefdef,
|
|
HUD_AddEntity,
|
|
HUD_CreateEntities,
|
|
HUD_DrawNormalTriangles,
|
|
HUD_DrawTransparentTriangles,
|
|
HUD_StudioEvent,
|
|
HUD_PostRunCmd,
|
|
HUD_Shutdown,
|
|
HUD_TxferLocalOverrides,
|
|
HUD_ProcessPlayerState,
|
|
HUD_TxferPredictionData,
|
|
Demo_ReadBuffer,
|
|
HUD_ConnectionlessPacket,
|
|
HUD_GetHullBounds,
|
|
HUD_Frame,
|
|
HUD_Key_Event,
|
|
HUD_TempEntUpdate,
|
|
HUD_GetUserEntity,
|
|
HUD_VoiceStatus,
|
|
HUD_DirectorMessage,
|
|
HUD_GetStudioModelInterface,
|
|
};
|
|
|
|
*pcldll_func = cldll_func;
|
|
}
|
|
|
|
#endif // FINAL_VAC_BUILD
|