1145 lines
35 KiB
C
1145 lines
35 KiB
C
/*
|
|
client.h - primary header for client
|
|
Copyright (C) 2009 Uncle Mike
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
*/
|
|
|
|
#ifndef CLIENT_H
|
|
#define CLIENT_H
|
|
|
|
#include "xash3d_types.h"
|
|
#include "xash3d_mathlib.h"
|
|
#include "cdll_int.h"
|
|
#include "menu_int.h"
|
|
#include "cl_entity.h"
|
|
#include "mod_local.h"
|
|
#include "pm_defs.h"
|
|
#include "pm_movevars.h"
|
|
#include "ref_params.h"
|
|
#include "render_api.h"
|
|
#include "cdll_exp.h"
|
|
#include "screenfade.h"
|
|
#include "protocol.h"
|
|
#include "netchan.h"
|
|
#include "net_api.h"
|
|
#include "world.h"
|
|
#include "ref_common.h"
|
|
|
|
// client sprite types
|
|
#define SPR_CLIENT 0 // client sprite for temp-entities or user-textures
|
|
#define SPR_HUDSPRITE 1 // hud sprite
|
|
#define SPR_MAPSPRITE 2 // contain overview.bmp that diced into frames 128x128
|
|
|
|
//=============================================================================
|
|
typedef struct netbandwithgraph_s
|
|
{
|
|
word client;
|
|
word players;
|
|
word entities; // entities bytes, except for players
|
|
word tentities; // temp entities
|
|
word sound;
|
|
word event;
|
|
word usr;
|
|
word msgbytes;
|
|
word voicebytes;
|
|
} netbandwidthgraph_t;
|
|
|
|
typedef struct frame_s
|
|
{
|
|
// received from server
|
|
double receivedtime; // time message was received, or -1
|
|
double latency;
|
|
double time; // server timestamp
|
|
qboolean valid; // cleared if delta parsing was invalid
|
|
qboolean choked;
|
|
|
|
clientdata_t clientdata; // local client private data
|
|
entity_state_t playerstate[MAX_CLIENTS];
|
|
weapon_data_t weapondata[MAX_LOCAL_WEAPONS];
|
|
netbandwidthgraph_t graphdata;
|
|
byte flags[MAX_VISIBLE_PACKET_VIS_BYTES];
|
|
int num_entities;
|
|
int first_entity; // into the circular cl_packet_entities[]
|
|
} frame_t;
|
|
|
|
typedef struct runcmd_s
|
|
{
|
|
double senttime;
|
|
double receivedtime;
|
|
float frame_lerp;
|
|
|
|
usercmd_t cmd;
|
|
|
|
qboolean processedfuncs;
|
|
qboolean heldback;
|
|
int sendsize;
|
|
} runcmd_t;
|
|
|
|
// add angles
|
|
typedef struct
|
|
{
|
|
float starttime;
|
|
float total;
|
|
} pred_viewangle_t;
|
|
|
|
#define ANGLE_BACKUP 16
|
|
#define ANGLE_MASK (ANGLE_BACKUP - 1)
|
|
|
|
#define CL_UPDATE_MASK (CL_UPDATE_BACKUP - 1)
|
|
#if XASH_LOW_MEMORY == 2
|
|
#define CL_UPDATE_BACKUP SINGLEPLAYER_BACKUP
|
|
#else
|
|
extern int CL_UPDATE_BACKUP;
|
|
#endif
|
|
|
|
#define SIGNONS 2 // signon messages to receive before connected
|
|
#define INVALID_HANDLE 0xFFFF // for XashXT cache system
|
|
|
|
#define MIN_UPDATERATE 10.0f
|
|
#define MAX_UPDATERATE 102.0f
|
|
|
|
#define MIN_EX_INTERP 50.0f
|
|
#define MAX_EX_INTERP 100.0f
|
|
|
|
#define CL_MIN_RESEND_TIME 1.5f // mininum time gap (in seconds) before a subsequent connection request is sent.
|
|
#define CL_MAX_RESEND_TIME 20.0f // max time. The cvar cl_resend is bounded by these.
|
|
|
|
#define cl_serverframetime() (cl.mtime[0] - cl.mtime[1])
|
|
#define cl_clientframetime() (cl.time - cl.oldtime)
|
|
|
|
typedef struct
|
|
{
|
|
// got from prediction system
|
|
vec3_t predicted_origins[CMD_BACKUP];
|
|
vec3_t prediction_error;
|
|
vec3_t lastorigin;
|
|
int lastground;
|
|
|
|
// interp info
|
|
float interp_amount;
|
|
|
|
// misc local info
|
|
qboolean repredicting; // repredicting in progress
|
|
qboolean thirdperson;
|
|
qboolean apply_effects; // local player will not added but we should apply their effects: flashlight etc
|
|
float idealpitch;
|
|
int viewmodel;
|
|
int health; // client health
|
|
int onground;
|
|
int light_level;
|
|
int waterlevel;
|
|
int usehull;
|
|
int moving;
|
|
int pushmsec;
|
|
int weapons;
|
|
float maxspeed;
|
|
float scr_fov;
|
|
|
|
// weapon predict stuff
|
|
int weaponsequence;
|
|
float weaponstarttime;
|
|
} cl_local_data_t;
|
|
|
|
typedef struct
|
|
{
|
|
qboolean bUsed;
|
|
float fTime;
|
|
int nBytesRemaining;
|
|
} downloadtime_t;
|
|
|
|
typedef struct
|
|
{
|
|
qboolean doneregistering;
|
|
int percent;
|
|
qboolean downloadrequested;
|
|
downloadtime_t rgStats[8];
|
|
int nCurStat;
|
|
int nTotalSize;
|
|
int nTotalToTransfer;
|
|
int nRemainingToTransfer;
|
|
float fLastStatusUpdate;
|
|
qboolean custom;
|
|
} incomingtransfer_t;
|
|
|
|
// the client_t structure is wiped completely
|
|
// at every server map change
|
|
typedef struct
|
|
{
|
|
int servercount; // server identification for prespawns
|
|
int validsequence; // this is the sequence number of the last good
|
|
// world snapshot/update we got. If this is 0, we can't
|
|
// render a frame yet
|
|
int parsecount; // server message counter
|
|
int parsecountmod; // modulo with network window
|
|
|
|
qboolean video_prepped; // false if on new level or new ref dll
|
|
qboolean audio_prepped; // false if on new level or new snd dll
|
|
qboolean paused;
|
|
|
|
int delta_sequence; // acknowledged sequence number
|
|
|
|
double mtime[2]; // the timestamp of the last two messages
|
|
float lerpFrac;
|
|
|
|
int last_command_ack;
|
|
int last_incoming_sequence;
|
|
|
|
qboolean send_reply;
|
|
qboolean background; // not real game, just a background
|
|
qboolean first_frame; // first rendering frame
|
|
qboolean proxy_redirect; // spectator stuff
|
|
qboolean skip_interp; // skip interpolation this frame
|
|
|
|
uint checksum; // for catching cheater maps
|
|
|
|
frame_t frames[MULTIPLAYER_BACKUP]; // alloced on svc_serverdata
|
|
runcmd_t commands[MULTIPLAYER_BACKUP]; // each mesage will send several old cmds
|
|
local_state_t predicted_frames[MULTIPLAYER_BACKUP]; // local client state
|
|
|
|
double time; // this is the time value that the client
|
|
// is rendering at. always <= cls.realtime
|
|
// a lerp point for other data
|
|
double oldtime; // previous cl.time, time-oldtime is used
|
|
// to decay light values and smooth step ups
|
|
float timedelta; // floating delta between two updates
|
|
|
|
char serverinfo[MAX_SERVERINFO_STRING];
|
|
player_info_t players[MAX_CLIENTS]; // collected info about all other players include himself
|
|
double lastresourcecheck;
|
|
string downloadUrl;
|
|
event_state_t events;
|
|
|
|
// predicting stuff but not only...
|
|
cl_local_data_t local;
|
|
|
|
// player final info
|
|
usercmd_t *cmd; // cl.commands[outgoing_sequence].cmd
|
|
int viewentity;
|
|
vec3_t viewangles;
|
|
vec3_t viewheight;
|
|
vec3_t punchangle;
|
|
|
|
int intermission; // don't change view angle, full screen, et
|
|
vec3_t crosshairangle;
|
|
|
|
pred_viewangle_t predicted_angle[ANGLE_BACKUP];// accumulate angles from server
|
|
int angle_position;
|
|
float addangletotal;
|
|
float prevaddangletotal;
|
|
|
|
// predicted origin and velocity
|
|
vec3_t simorg;
|
|
vec3_t simvel;
|
|
|
|
// server state information
|
|
int playernum;
|
|
int maxclients;
|
|
|
|
entity_state_t instanced_baseline[MAX_CUSTOM_BASELINES];
|
|
int instanced_baseline_count;
|
|
|
|
char sound_precache[MAX_SOUNDS][MAX_QPATH];
|
|
char event_precache[MAX_EVENTS][MAX_QPATH];
|
|
char files_precache[MAX_CUSTOM][MAX_QPATH];
|
|
lightstyle_t lightstyles[MAX_LIGHTSTYLES];
|
|
model_t *models[MAX_MODELS+1]; // precached models (plus sentinel slot)
|
|
int nummodels;
|
|
int numfiles;
|
|
|
|
consistency_t consistency_list[MAX_MODELS];
|
|
int num_consistency;
|
|
|
|
qboolean need_force_consistency_response;
|
|
resource_t resourcesonhand;
|
|
resource_t resourcesneeded;
|
|
resource_t resourcelist[MAX_RESOURCES];
|
|
int num_resources;
|
|
|
|
short sound_index[MAX_SOUNDS];
|
|
short decal_index[MAX_DECALS];
|
|
|
|
model_t *worldmodel; // pointer to world
|
|
|
|
int lostpackets; // count lost packets and show dialog in menu
|
|
} client_t;
|
|
|
|
/*
|
|
==================================================================
|
|
|
|
the client_static_t structure is persistant through an arbitrary number
|
|
of server connections
|
|
|
|
==================================================================
|
|
*/
|
|
typedef enum
|
|
{
|
|
scrshot_inactive,
|
|
scrshot_normal, // in-game screenshot
|
|
scrshot_snapshot, // in-game snapshot
|
|
scrshot_plaque, // levelshot
|
|
scrshot_savegame, // saveshot
|
|
scrshot_envshot, // cubemap view
|
|
scrshot_skyshot, // skybox view
|
|
scrshot_mapshot // overview layer
|
|
} scrshot_t;
|
|
|
|
// client screen state
|
|
typedef enum
|
|
{
|
|
CL_LOADING = 1, // draw loading progress-bar
|
|
CL_ACTIVE, // draw normal hud
|
|
CL_PAUSED, // pause when active
|
|
CL_CHANGELEVEL, // draw 'loading' during changelevel
|
|
} scrstate_t;
|
|
|
|
typedef struct
|
|
{
|
|
char name[32];
|
|
int number; // svc_ number
|
|
int size; // if size == -1, size come from first byte after svcnum
|
|
pfnUserMsgHook func; // user-defined function
|
|
} cl_user_message_t;
|
|
|
|
typedef void (*pfnEventHook)( event_args_t *args );
|
|
|
|
typedef struct
|
|
{
|
|
char name[MAX_QPATH];
|
|
word index; // event index
|
|
pfnEventHook func; // user-defined function
|
|
} cl_user_event_t;
|
|
|
|
#define FONT_FIXED 0
|
|
#define FONT_VARIABLE 1
|
|
|
|
typedef struct
|
|
{
|
|
int hFontTexture; // handle to texture
|
|
wrect_t fontRc[256]; // rectangles
|
|
byte charWidths[256];
|
|
int charHeight;
|
|
int type;
|
|
qboolean valid; // all rectangles are valid
|
|
} cl_font_t;
|
|
|
|
typedef struct
|
|
{
|
|
// temp handle
|
|
const model_t *pSprite; // pointer to current SpriteTexture
|
|
|
|
// scissor test
|
|
int scissor_x;
|
|
int scissor_y;
|
|
int scissor_width;
|
|
int scissor_height;
|
|
qboolean scissor_test;
|
|
qboolean adjust_size; // allow to adjust scale for fonts
|
|
|
|
int renderMode; // override kRenderMode from TriAPI
|
|
TRICULLSTYLE cullMode; // override CULL FACE from TriAPI
|
|
|
|
// holds text color
|
|
rgba_t textColor;
|
|
rgba_t spriteColor;
|
|
vec4_t triRGBA;
|
|
|
|
// crosshair members
|
|
const model_t *pCrosshair;
|
|
wrect_t rcCrosshair;
|
|
rgba_t rgbaCrosshair;
|
|
} client_draw_t;
|
|
|
|
typedef struct cl_predicted_player_s
|
|
{
|
|
int movetype;
|
|
int solid;
|
|
int usehull;
|
|
qboolean active;
|
|
vec3_t origin; // interpolated origin
|
|
vec3_t angles;
|
|
} predicted_player_t;
|
|
|
|
typedef struct
|
|
{
|
|
int gl_texturenum; // this is a real texnum
|
|
|
|
// scissor test
|
|
int scissor_x;
|
|
int scissor_y;
|
|
int scissor_width;
|
|
int scissor_height;
|
|
qboolean scissor_test;
|
|
|
|
// holds text color
|
|
rgba_t textColor;
|
|
} gameui_draw_t;
|
|
|
|
typedef struct
|
|
{
|
|
char szListName[MAX_QPATH];
|
|
client_sprite_t *pList;
|
|
int count;
|
|
} cached_spritelist_t;
|
|
|
|
typedef struct
|
|
{
|
|
// centerprint stuff
|
|
float time;
|
|
int y, lines;
|
|
char message[2048];
|
|
int totalWidth;
|
|
int totalHeight;
|
|
} center_print_t;
|
|
|
|
typedef struct
|
|
{
|
|
float time;
|
|
float duration;
|
|
float amplitude;
|
|
float frequency;
|
|
float next_shake;
|
|
vec3_t offset;
|
|
float angle;
|
|
vec3_t applied_offset;
|
|
float applied_angle;
|
|
} screen_shake_t;
|
|
|
|
typedef enum
|
|
{
|
|
NET_REQUEST_CANCEL = 0, // request was cancelled for some reasons
|
|
NET_REQUEST_GAMEUI, // called from GameUI
|
|
NET_REQUEST_CLIENT, // called from Client
|
|
} net_request_type_t;
|
|
|
|
typedef struct
|
|
{
|
|
net_response_t resp;
|
|
net_api_response_func_t pfnFunc;
|
|
double timeout;
|
|
double timesend; // time when request was sended
|
|
int flags; // FNETAPI_MULTIPLE_RESPONSE etc
|
|
} net_request_t;
|
|
|
|
// new versions of client dlls have a single export with all callbacks
|
|
typedef void (*CL_EXPORT_FUNCS)( void *pv );
|
|
|
|
typedef struct
|
|
{
|
|
void *hInstance; // pointer to client.dll
|
|
cldll_func_t dllFuncs; // dll exported funcs
|
|
render_interface_t drawFuncs; // custom renderer support
|
|
byte *mempool; // client edicts pool
|
|
string mapname; // map name
|
|
string maptitle; // display map title
|
|
string itemspath; // path to items description for auto-complete func
|
|
|
|
cl_entity_t *entities; // dynamically allocated entity array
|
|
cl_entity_t *static_entities; // dynamically allocated static entity array
|
|
remap_info_t **remap_info; // store local copy of all remap textures for each entity
|
|
|
|
int maxEntities;
|
|
int maxRemapInfos; // maxEntities + cl.viewEnt; also used for catch entcount
|
|
int numStatics; // actual static entity count
|
|
int maxModels;
|
|
|
|
// movement values from server
|
|
movevars_t movevars;
|
|
movevars_t oldmovevars;
|
|
playermove_t *pmove; // pmove state
|
|
|
|
qboolean pushed; // used by PM_Push\Pop state
|
|
int oldviscount; // used by PM_Push\Pop state
|
|
int oldphyscount; // used by PM_Push\Pop state
|
|
|
|
cl_user_message_t msg[MAX_USER_MESSAGES]; // keep static to avoid fragment memory
|
|
cl_user_event_t *events[MAX_EVENTS];
|
|
|
|
string cdtracks[MAX_CDTRACKS]; // 32 cd-tracks read from cdaudio.txt
|
|
|
|
model_t sprites[MAX_CLIENT_SPRITES]; // client spritetextures
|
|
int viewport[4]; // viewport sizes
|
|
|
|
client_draw_t ds; // draw2d stuff (hud, weaponmenu etc)
|
|
screenfade_t fade; // screen fade
|
|
screen_shake_t shake; // screen shake
|
|
center_print_t centerPrint; // centerprint variables
|
|
SCREENINFO scrInfo; // actual screen info
|
|
ref_overview_t overView; // overView params
|
|
color24 palette[256]; // palette used for particle colors
|
|
|
|
cached_spritelist_t sprlist[MAX_CLIENT_SPRITES]; // client list sprites
|
|
|
|
client_textmessage_t *titles; // title messages, not network messages
|
|
int numTitles;
|
|
|
|
net_request_type_t request_type; // filter the requests
|
|
net_request_t net_requests[MAX_REQUESTS]; // no reason to keep more
|
|
net_request_t *master_request; // queued master request
|
|
|
|
efrag_t *free_efrags; // linked efrags
|
|
cl_entity_t viewent; // viewmodel
|
|
|
|
qboolean client_dll_uses_sdl;
|
|
} clgame_static_t;
|
|
|
|
typedef struct
|
|
{
|
|
void *hInstance; // pointer to client.dll
|
|
UI_FUNCTIONS dllFuncs; // dll exported funcs
|
|
UI_EXTENDED_FUNCTIONS dllFuncs2; // fwgs extension
|
|
byte *mempool; // client edicts pool
|
|
|
|
cl_entity_t playermodel; // uiPlayerSetup drawing model
|
|
player_info_t playerinfo; // local playerinfo
|
|
|
|
gameui_draw_t ds; // draw2d stuff (menu images)
|
|
GAMEINFO gameInfo; // current gameInfo
|
|
GAMEINFO *modsInfo[MAX_MODS]; // simplified gameInfo for MainUI
|
|
|
|
ui_globalvars_t *globals;
|
|
|
|
qboolean drawLogo; // set to TRUE if logo.avi missed or corrupted
|
|
int logo_xres;
|
|
int logo_yres;
|
|
float logo_length;
|
|
|
|
qboolean use_text_api;
|
|
} gameui_static_t;
|
|
|
|
typedef struct
|
|
{
|
|
connstate_t state;
|
|
qboolean initialized;
|
|
qboolean changelevel; // during changelevel
|
|
qboolean changedemo; // during changedemo
|
|
double timestart; // just for profiling
|
|
|
|
// screen rendering information
|
|
float disable_screen; // showing loading plaque between levels
|
|
// or changing rendering dlls
|
|
// if time gets > 30 seconds ahead, break it
|
|
int disable_servercount; // when we receive a frame and cl.servercount
|
|
// > cls.disable_servercount, clear disable_screen
|
|
|
|
qboolean draw_changelevel; // draw changelevel image 'Loading...'
|
|
|
|
keydest_t key_dest;
|
|
|
|
byte *mempool; // client premamnent pool: edicts etc
|
|
|
|
netadr_t hltv_listen_address;
|
|
|
|
int signon; // 0 to SIGNONS, for the signon sequence.
|
|
int quakePort; // a 16 bit value that allows quake servers
|
|
// to work around address translating routers
|
|
// g-cont. this port allow many copies of engine in multiplayer game
|
|
// connection information
|
|
char servername[MAX_QPATH]; // name of server from original connect
|
|
double connect_time; // for connection retransmits
|
|
int max_fragment_size; // we needs to test a real network bandwidth
|
|
int connect_retry; // how many times we send a connect packet to the server
|
|
qboolean spectator; // not a real player, just spectator
|
|
|
|
local_state_t spectator_state; // init as client startup
|
|
|
|
char userinfo[MAX_INFO_STRING];
|
|
char physinfo[MAX_INFO_STRING]; // read-only
|
|
|
|
sizebuf_t datagram; // unreliable stuff. gets sent in CL_Move about cl_cmdrate times per second.
|
|
byte datagram_buf[MAX_DATAGRAM];
|
|
|
|
netchan_t netchan;
|
|
int challenge; // from the server to use for connecting
|
|
|
|
float packet_loss;
|
|
double packet_loss_recalc_time;
|
|
int starting_count; // message num readed bits
|
|
|
|
float nextcmdtime; // when can we send the next command packet?
|
|
int lastoutgoingcommand; // sequence number of last outgoing command
|
|
int lastupdate_sequence; // prediction stuff
|
|
|
|
int td_lastframe; // to meter out one message a frame
|
|
int td_startframe; // host_framecount at start
|
|
double td_starttime; // realtime at second frame of timedemo
|
|
int forcetrack; // -1 = use normal cd track
|
|
|
|
// game images
|
|
int pauseIcon; // draw 'paused' when game in-pause
|
|
int tileImage; // for draw any areas not covered by the refresh
|
|
int loadingBar; // 'loading' progress bar
|
|
cl_font_t creditsFont; // shared creditsfont
|
|
|
|
float latency; // rolling average of frame latencey (receivedtime - senttime) values.
|
|
|
|
int num_client_entities; // cl.maxclients * CL_UPDATE_BACKUP * MAX_PACKET_ENTITIES
|
|
int next_client_entities; // next client_entity to use
|
|
entity_state_t *packet_entities; // [num_client_entities]
|
|
|
|
predicted_player_t predicted_players[MAX_CLIENTS];
|
|
double correction_time;
|
|
|
|
scrshot_t scrshot_request; // request for screen shot
|
|
scrshot_t scrshot_action; // in-action
|
|
const float *envshot_vieworg; // envshot position
|
|
int envshot_viewsize; // override cvar
|
|
qboolean envshot_disable_vis; // disable VIS on server while makes an envshots
|
|
string shotname;
|
|
|
|
// download info
|
|
incomingtransfer_t dl;
|
|
|
|
// demo loop control
|
|
int demonum; // -1 = don't play demos
|
|
int olddemonum; // restore playing
|
|
char demos[MAX_DEMOS][MAX_QPATH]; // when not playing
|
|
qboolean demos_pending;
|
|
|
|
// movie playlist
|
|
int movienum;
|
|
string movies[MAX_MOVIES];
|
|
|
|
// demo recording info must be here, so it isn't clearing on level change
|
|
qboolean demorecording;
|
|
int demoplayback;
|
|
qboolean demowaiting; // don't record until a non-delta message is received
|
|
qboolean timedemo;
|
|
string demoname; // for demo looping
|
|
double demotime; // recording time
|
|
qboolean set_lastdemo; // store name of last played demo into the cvar
|
|
|
|
file_t *demofile;
|
|
file_t *demoheader; // contain demo startup info in case we record a demo on this level
|
|
qboolean internetservers_wait; // internetservers is waiting for dns request
|
|
qboolean internetservers_pending; // internetservers is waiting for dns request
|
|
|
|
// legacy mode support
|
|
qboolean legacymode; // one-way 48 protocol compatibility
|
|
netadr_t legacyserver;
|
|
netadr_t legacyservers[MAX_LEGACY_SERVERS];
|
|
int legacyservercount;
|
|
int extensions;
|
|
|
|
netadr_t serveradr;
|
|
} client_static_t;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern client_t cl;
|
|
extern client_static_t cls;
|
|
extern clgame_static_t clgame;
|
|
extern gameui_static_t gameui;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// cvars
|
|
//
|
|
extern convar_t mp_decals;
|
|
extern convar_t cl_logofile;
|
|
extern convar_t cl_logocolor;
|
|
extern convar_t cl_allow_download;
|
|
extern convar_t cl_allow_upload;
|
|
extern convar_t cl_download_ingame;
|
|
extern convar_t *cl_nopred;
|
|
extern convar_t *cl_showfps;
|
|
extern convar_t *cl_envshot_size;
|
|
extern convar_t *cl_timeout;
|
|
extern convar_t *cl_nodelta;
|
|
extern convar_t *cl_interp;
|
|
extern convar_t *cl_showerror;
|
|
extern convar_t *cl_nosmooth;
|
|
extern convar_t *cl_smoothtime;
|
|
extern convar_t *cl_crosshair;
|
|
extern convar_t *cl_testlights;
|
|
extern convar_t *cl_cmdrate;
|
|
extern convar_t *cl_updaterate;
|
|
extern convar_t *cl_solid_players;
|
|
extern convar_t *cl_idealpitchscale;
|
|
extern convar_t *cl_allow_levelshots;
|
|
extern convar_t *cl_lightstyle_lerping;
|
|
extern convar_t *cl_draw_particles;
|
|
extern convar_t *cl_draw_tracers;
|
|
extern convar_t *cl_levelshot_name;
|
|
extern convar_t *cl_draw_beams;
|
|
extern convar_t *cl_clockreset;
|
|
extern convar_t *cl_fixtimerate;
|
|
extern convar_t *hud_scale;
|
|
extern convar_t *gl_showtextures;
|
|
extern convar_t *cl_bmodelinterp;
|
|
extern convar_t *cl_righthand;
|
|
extern convar_t *cl_lw; // local weapons
|
|
extern convar_t *cl_charset;
|
|
extern convar_t *cl_trace_messages;
|
|
extern convar_t *hud_utf8;
|
|
extern convar_t *cl_showevents;
|
|
extern convar_t *scr_centertime;
|
|
extern convar_t *scr_viewsize;
|
|
extern convar_t *scr_loading;
|
|
extern convar_t *v_dark; // start from dark
|
|
extern convar_t *net_graph;
|
|
extern convar_t *rate;
|
|
extern convar_t *m_ignore;
|
|
extern convar_t *r_showtree;
|
|
extern convar_t *ui_renderworld;
|
|
|
|
//=============================================================================
|
|
|
|
void CL_SetLightstyle( int style, const char* s, float f );
|
|
void CL_RunLightStyles( void );
|
|
void CL_DecayLights( void );
|
|
dlight_t *CL_GetDynamicLight( int number );
|
|
dlight_t *CL_GetEntityLight( int number );
|
|
|
|
//=================================================
|
|
|
|
//
|
|
// cl_cmds.c
|
|
//
|
|
void CL_Quit_f( void ) NORETURN;
|
|
void CL_ScreenShot_f( void );
|
|
void CL_SnapShot_f( void );
|
|
void CL_PlayCDTrack_f( void );
|
|
void CL_EnvShot_f( void );
|
|
void CL_SkyShot_f( void );
|
|
void CL_SaveShot_f( void );
|
|
void CL_LevelShot_f( void );
|
|
void CL_SetSky_f( void );
|
|
void SCR_Viewpos_f( void );
|
|
|
|
//
|
|
// cl_custom.c
|
|
//
|
|
qboolean CL_CheckFile( sizebuf_t *msg, resource_t *pResource );
|
|
void CL_AddToResourceList( resource_t *pResource, resource_t *pList );
|
|
void CL_RemoveFromResourceList( resource_t *pResource );
|
|
void CL_MoveToOnHandList( resource_t *pResource );
|
|
void CL_ClearResourceLists( void );
|
|
|
|
//
|
|
// cl_debug.c
|
|
//
|
|
void CL_Parse_Debug( qboolean enable );
|
|
void CL_Parse_RecordCommand( int cmd, int startoffset );
|
|
void CL_ResetFrame( frame_t *frame );
|
|
void CL_WriteMessageHistory( void );
|
|
const char *CL_MsgInfo( int cmd );
|
|
|
|
//
|
|
// cl_efx.c
|
|
//
|
|
void CL_Particle( const vec3_t org, int color, float life, int zpos, int zvel );
|
|
|
|
//
|
|
// cl_main.c
|
|
//
|
|
void CL_Init( void );
|
|
void CL_SendCommand( void );
|
|
void CL_Disconnect_f( void );
|
|
void CL_ProcessFile( qboolean successfully_received, const char *filename );
|
|
void CL_WriteUsercmd( sizebuf_t *msg, int from, int to );
|
|
int CL_GetFragmentSize( void *unused , fragsize_t mode );
|
|
qboolean CL_PrecacheResources( void );
|
|
void CL_SetupOverviewParams( void );
|
|
void CL_UpdateFrameLerp( void );
|
|
int CL_IsDevOverviewMode( void );
|
|
void CL_PingServers_f( void );
|
|
void CL_SignonReply( void );
|
|
void CL_ClearState( void );
|
|
|
|
//
|
|
// cl_demo.c
|
|
//
|
|
void CL_StartupDemoHeader( void );
|
|
void CL_DrawDemoRecording( void );
|
|
void CL_WriteDemoUserCmd( int cmdnumber );
|
|
void CL_WriteDemoMessage( qboolean startup, int start, sizebuf_t *msg );
|
|
void CL_WriteDemoUserMessage( const byte *buffer, size_t size );
|
|
qboolean CL_DemoReadMessage( byte *buffer, size_t *length );
|
|
void CL_DemoInterpolateAngles( void );
|
|
void CL_CheckStartupDemos( void );
|
|
void CL_WriteDemoJumpTime( void );
|
|
void CL_CloseDemoHeader( void );
|
|
void CL_DemoCompleted( void );
|
|
void CL_StopPlayback( void );
|
|
void CL_StopRecord( void );
|
|
void CL_PlayDemo_f( void );
|
|
void CL_TimeDemo_f( void );
|
|
void CL_StartDemos_f( void );
|
|
void CL_Demos_f( void );
|
|
void CL_DeleteDemo_f( void );
|
|
void CL_Record_f( void );
|
|
void CL_Stop_f( void );
|
|
|
|
//
|
|
// cl_events.c
|
|
//
|
|
void CL_ParseEvent( sizebuf_t *msg );
|
|
void CL_ParseReliableEvent( sizebuf_t *msg );
|
|
void CL_SetEventIndex( const char *szEvName, int ev_index );
|
|
void CL_QueueEvent( int flags, int index, float delay, event_args_t *args );
|
|
void CL_PlaybackEvent( int flags, const edict_t *pInvoker, word eventindex, float delay, float *origin,
|
|
float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
|
|
void CL_RegisterEvent( int lastnum, const char *szEvName, pfnEventHook func );
|
|
void CL_BatchResourceRequest( qboolean initialize );
|
|
int CL_EstimateNeededResources( void );
|
|
void CL_ResetEvent( event_info_t *ei );
|
|
word CL_EventIndex( const char *name );
|
|
void CL_FireEvents( void );
|
|
|
|
//
|
|
// cl_game.c
|
|
//
|
|
void CL_UnloadProgs( void );
|
|
qboolean CL_LoadProgs( const char *name );
|
|
void CL_ParseUserMessage( sizebuf_t *msg, int svc_num );
|
|
void CL_LinkUserMessage( char *pszName, const int svc_num, int iSize );
|
|
void CL_ParseFinaleCutscene( sizebuf_t *msg, int level );
|
|
void CL_ParseTextMessage( sizebuf_t *msg );
|
|
void CL_DrawHUD( int state );
|
|
void CL_InitEdicts( void );
|
|
void CL_FreeEdicts( void );
|
|
void CL_ClearWorld( void );
|
|
void CL_DrawCenterPrint( void );
|
|
void CL_ClearSpriteTextures( void );
|
|
void CL_FreeEntity( cl_entity_t *pEdict );
|
|
void CL_CenterPrint( const char *text, float y );
|
|
void CL_TextMessageParse( byte *pMemFile, int fileSize );
|
|
client_textmessage_t *CL_TextMessageGet( const char *pName );
|
|
int pfnDecalIndexFromName( const char *szDecalName );
|
|
int pfnIndexFromTrace( struct pmtrace_s *pTrace );
|
|
model_t *CL_ModelHandle( int modelindex );
|
|
void NetAPI_CancelAllRequests( void );
|
|
int CL_FindModelIndex( const char *m );
|
|
cl_entity_t *CL_GetLocalPlayer( void );
|
|
model_t *CL_LoadClientSprite( const char *filename );
|
|
model_t *CL_LoadModel( const char *modelname, int *index );
|
|
HSPRITE pfnSPR_Load( const char *szPicName );
|
|
HSPRITE pfnSPR_LoadExt( const char *szPicName, uint texFlags );
|
|
void PicAdjustSize( float *x, float *y, float *w, float *h );
|
|
int CL_GetScreenInfo( SCREENINFO *pscrinfo );
|
|
void CL_FillRGBA( int x, int y, int width, int height, int r, int g, int b, int a );
|
|
void CL_PlayerTrace( float *start, float *end, int traceFlags, int ignore_pe, pmtrace_t *tr );
|
|
void CL_PlayerTraceExt( float *start, float *end, int traceFlags, int (*pfnIgnore)( physent_t *pe ), pmtrace_t *tr );
|
|
void CL_SetTraceHull( int hull );
|
|
void CL_GetMousePosition( int *mx, int *my ); // TODO: move to input
|
|
cl_entity_t* CL_GetViewModel( void );
|
|
void pfnGetScreenFade( struct screenfade_s *fade );
|
|
physent_t *pfnGetPhysent( int idx );
|
|
struct msurface_s *pfnTraceSurface( int ground, float *vstart, float *vend );
|
|
movevars_t *pfnGetMoveVars( void );
|
|
|
|
_inline cl_entity_t *CL_EDICT_NUM( int n )
|
|
{
|
|
if(( n >= 0 ) && ( n < clgame.maxEntities ))
|
|
return clgame.entities + n;
|
|
|
|
Host_Error( "CL_EDICT_NUM: bad number %i\n", n );
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// cl_parse.c
|
|
//
|
|
void CL_ParseServerMessage( sizebuf_t *msg, qboolean normal_message );
|
|
void CL_ParseLegacyServerMessage( sizebuf_t *msg, qboolean normal_message );
|
|
void CL_LegacyPrecache_f( void );
|
|
|
|
void CL_ParseTempEntity( sizebuf_t *msg );
|
|
void CL_StartResourceDownloading( const char *pszMessage, qboolean bCustom );
|
|
qboolean CL_DispatchUserMessage( const char *pszName, int iSize, void *pbuf );
|
|
qboolean CL_RequestMissingResources( void );
|
|
void CL_RegisterResources ( sizebuf_t *msg );
|
|
void CL_ParseViewEntity( sizebuf_t *msg );
|
|
void CL_ParseServerTime( sizebuf_t *msg );
|
|
|
|
//
|
|
// cl_scrn.c
|
|
//
|
|
void SCR_VidInit( void );
|
|
void SCR_TileClear( void );
|
|
void SCR_DirtyScreen( void );
|
|
void SCR_AddDirtyPoint( int x, int y );
|
|
void SCR_InstallParticlePalette( void );
|
|
void SCR_EndLoadingPlaque( void );
|
|
void SCR_RegisterTextures( void );
|
|
void SCR_LoadCreditsFont( void );
|
|
void SCR_MakeScreenShot( void );
|
|
void SCR_MakeLevelShot( void );
|
|
void SCR_NetSpeeds( void );
|
|
void SCR_RSpeeds( void );
|
|
void SCR_DrawFPS( int height );
|
|
|
|
//
|
|
// cl_netgraph.c
|
|
//
|
|
void CL_InitNetgraph( void );
|
|
void SCR_DrawNetGraph( void );
|
|
|
|
//
|
|
// cl_view.c
|
|
//
|
|
|
|
void V_Init (void);
|
|
void V_Shutdown( void );
|
|
qboolean V_PreRender( void );
|
|
void V_PostRender( void );
|
|
void V_RenderView( void );
|
|
|
|
//
|
|
// cl_pmove.c
|
|
//
|
|
void CL_SetSolidEntities( void );
|
|
void CL_SetSolidPlayers( int playernum );
|
|
void CL_InitClientMove( void );
|
|
void CL_PredictMovement( qboolean repredicting );
|
|
void CL_CheckPredictionError( void );
|
|
qboolean CL_IsPredicted( void );
|
|
int CL_TruePointContents( const vec3_t p );
|
|
int CL_PointContents( const vec3_t p );
|
|
int CL_WaterEntity( const float *rgflPos );
|
|
cl_entity_t *CL_GetWaterEntity( const float *rgflPos );
|
|
void CL_SetupPMove( playermove_t *pmove, local_state_t *from, usercmd_t *ucmd, qboolean runfuncs, double time );
|
|
int CL_TestLine( const vec3_t start, const vec3_t end, int flags );
|
|
pmtrace_t *CL_VisTraceLine( vec3_t start, vec3_t end, int flags );
|
|
pmtrace_t CL_TraceLine( vec3_t start, vec3_t end, int flags );
|
|
void CL_PushTraceBounds( int hullnum, const float *mins, const float *maxs );
|
|
void CL_PopTraceBounds( void );
|
|
void CL_MoveSpectatorCamera( void );
|
|
void CL_SetLastUpdate( void );
|
|
void CL_RedoPrediction( void );
|
|
void CL_ClearPhysEnts( void );
|
|
void CL_PushPMStates( void );
|
|
void CL_PopPMStates( void );
|
|
void CL_SetUpPlayerPrediction( int dopred, int bIncludeLocalClient );
|
|
|
|
//
|
|
// cl_qparse.c
|
|
//
|
|
void CL_ParseQuakeMessage( sizebuf_t *msg, qboolean normal_message );
|
|
|
|
//
|
|
// cl_frame.c
|
|
//
|
|
struct channel_s;
|
|
struct rawchan_s;
|
|
int CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta );
|
|
qboolean CL_AddVisibleEntity( cl_entity_t *ent, int entityType );
|
|
void CL_ResetLatchedVars( cl_entity_t *ent, qboolean full_reset );
|
|
qboolean CL_GetEntitySpatialization( struct channel_s *ch );
|
|
qboolean CL_GetMovieSpatialization( struct rawchan_s *ch );
|
|
void CL_ProcessPlayerState( int playerindex, entity_state_t *state );
|
|
void CL_ComputePlayerOrigin( cl_entity_t *clent );
|
|
void CL_ProcessPacket( frame_t *frame );
|
|
void CL_MoveThirdpersonCamera( void );
|
|
qboolean CL_IsPlayerIndex( int idx );
|
|
void CL_SetIdealPitch( void );
|
|
void CL_EmitEntities( void );
|
|
|
|
//
|
|
// cl_remap.c
|
|
//
|
|
remap_info_t *CL_GetRemapInfoForEntity( cl_entity_t *e );
|
|
void CL_AllocRemapInfo( cl_entity_t *ent, int topcolor, int bottomcolor );
|
|
void CL_FreeRemapInfo( remap_info_t *info );
|
|
void CL_UpdateRemapInfo( cl_entity_t *ent, int topcolor, int bottomcolor );
|
|
void CL_ClearAllRemaps( void );
|
|
|
|
//
|
|
// cl_render.c
|
|
//
|
|
qboolean R_InitRenderAPI( void );
|
|
int CL_RenderGetParm( const int parm, const int arg, const qboolean checkRef );
|
|
lightstyle_t *CL_GetLightStyle( int number );
|
|
int R_FatPVS( const vec3_t org, float radius, byte *visbuffer, qboolean merge, qboolean fullvis );
|
|
const ref_overview_t *GL_GetOverviewParms( void );
|
|
|
|
//
|
|
// cl_efrag.c
|
|
//
|
|
void R_StoreEfrags( efrag_t **ppefrag, int framecount );
|
|
void R_AddEfrags( cl_entity_t *ent );
|
|
void R_RemoveEfrags( cl_entity_t *ent );
|
|
//
|
|
// cl_tent.c
|
|
//
|
|
struct particle_s;
|
|
int CL_AddEntity( int entityType, cl_entity_t *pEnt );
|
|
void CL_WeaponAnim( int iAnim, int body );
|
|
void CL_ClearEffects( void );
|
|
void CL_ClearEfrags( void );
|
|
void CL_TestLights( void );
|
|
void CL_FireCustomDecal( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags, float scale );
|
|
void CL_DecalShoot( int textureIndex, int entityIndex, int modelIndex, float *pos, int flags );
|
|
void CL_PlayerDecal( int playerIndex, int textureIndex, int entityIndex, float *pos );
|
|
void R_FreeDeadParticles( struct particle_s **ppparticles );
|
|
void CL_AddClientResource( const char *filename, int type );
|
|
void CL_AddClientResources( void );
|
|
void CL_InitParticles( void );
|
|
void CL_ClearParticles( void );
|
|
void CL_FreeParticles( void );
|
|
void CL_InitTempEnts( void );
|
|
void CL_ClearTempEnts( void );
|
|
void CL_FreeTempEnts( void );
|
|
void CL_TempEntUpdate( void );
|
|
void CL_InitViewBeams( void );
|
|
void CL_ClearViewBeams( void );
|
|
void CL_FreeViewBeams( void );
|
|
cl_entity_t *R_BeamGetEntity( int index );
|
|
void CL_KillDeadBeams( cl_entity_t *pDeadEntity );
|
|
void CL_ParseViewBeam( sizebuf_t *msg, int beamType );
|
|
void CL_LoadClientSprites( void );
|
|
void CL_ReadPointFile_f( void );
|
|
void CL_DrawEFX( float time, qboolean fTrans );
|
|
void CL_ThinkParticle( double frametime, particle_t *p );
|
|
void CL_ReadLineFile_f( void );
|
|
void CL_RunLightStyles( void );
|
|
|
|
//
|
|
// console.c
|
|
//
|
|
extern convar_t *con_fontsize;
|
|
int Con_Visible( void );
|
|
qboolean Con_FixedFont( void );
|
|
void Con_VidInit( void );
|
|
void Con_Shutdown( void );
|
|
void Con_ToggleConsole_f( void );
|
|
void Con_ClearNotify( void );
|
|
void Con_DrawDebug( void );
|
|
void Con_RunConsole( void );
|
|
void Con_DrawConsole( void );
|
|
void Con_DrawVersion( void );
|
|
int Con_UtfProcessChar( int in );
|
|
int Con_UtfProcessCharForce( int in );
|
|
int Con_UtfMoveLeft( char *str, int pos );
|
|
int Con_UtfMoveRight( char *str, int pos, int length );
|
|
void Con_DrawStringLen( const char *pText, int *length, int *height );
|
|
int Con_DrawString( int x, int y, const char *string, rgba_t setColor );
|
|
int Con_DrawCharacter( int x, int y, int number, rgba_t color );
|
|
void Con_DrawCharacterLen( int number, int *width, int *height );
|
|
void Con_DefaultColor( int r, int g, int b );
|
|
void Con_InvalidateFonts( void );
|
|
void Con_SetFont( int fontNum );
|
|
void Con_CharEvent( int key );
|
|
void Con_RestoreFont( void );
|
|
void Key_Console( int key );
|
|
void Key_Message( int key );
|
|
void Con_FastClose( void );
|
|
void Con_Bottom( void );
|
|
void Con_Top( void );
|
|
void Con_PageDown( int lines );
|
|
void Con_PageUp( int lines );
|
|
void Con_LoadHistory( void );
|
|
|
|
//
|
|
// s_main.c
|
|
//
|
|
void S_StreamRawSamples( int samples, int rate, int width, int channels, const byte *data );
|
|
void S_StreamAviSamples( void *Avi, int entnum, float fvol, float attn, float synctime );
|
|
void S_StartBackgroundTrack( const char *intro, const char *loop, int position, qboolean fullpath );
|
|
void S_StopBackgroundTrack( void );
|
|
void S_StreamSetPause( int pause );
|
|
void S_StartStreaming( void );
|
|
void S_StopStreaming( void );
|
|
void S_BeginRegistration( void );
|
|
sound_t S_RegisterSound( const char *sample );
|
|
void S_EndRegistration( void );
|
|
void S_RestoreSound( const vec3_t pos, int ent, int chan, sound_t handle, float fvol, float attn, int pitch, int flags, double sample, double end, int wordIndex );
|
|
void S_StartSound( const vec3_t pos, int ent, int chan, sound_t sfx, float vol, float attn, int pitch, int flags );
|
|
void S_AmbientSound( const vec3_t pos, int ent, sound_t handle, float fvol, float attn, int pitch, int flags );
|
|
void S_FadeClientVolume( float fadePercent, float fadeOutSeconds, float holdTime, float fadeInSeconds );
|
|
void S_FadeMusicVolume( float fadePercent );
|
|
void S_StartLocalSound( const char *name, float volume, qboolean reliable );
|
|
void SND_UpdateSound( void );
|
|
void S_ExtraUpdate( void );
|
|
|
|
//
|
|
// cl_gameui.c
|
|
//
|
|
void UI_UnloadProgs( void );
|
|
qboolean UI_LoadProgs( void );
|
|
void UI_UpdateMenu( float realtime );
|
|
void UI_KeyEvent( int key, qboolean down );
|
|
void UI_MouseMove( int x, int y );
|
|
void UI_SetActiveMenu( qboolean fActive );
|
|
void UI_AddServerToList( netadr_t adr, const char *info );
|
|
void UI_GetCursorPos( int *pos_x, int *pos_y );
|
|
void UI_SetCursorPos( int pos_x, int pos_y );
|
|
void UI_ShowCursor( qboolean show );
|
|
qboolean UI_CreditsActive( void );
|
|
void UI_CharEvent( int key );
|
|
qboolean UI_MouseInRect( void );
|
|
qboolean UI_IsVisible( void );
|
|
void UI_ResetPing( void );
|
|
void UI_ShowUpdateDialog( qboolean preferStore );
|
|
void UI_ShowMessageBox( const char *text );
|
|
void UI_AddTouchButtonToList( const char *name, const char *texture, const char *command, unsigned char *color, int flags );
|
|
void UI_ConnectionProgress_Disconnect( void );
|
|
void UI_ConnectionProgress_Download( const char *pszFileName, const char *pszServerName, const char *pszServerPath, int iCurrent, int iTotal, const char *comment );
|
|
void UI_ConnectionProgress_DownloadEnd( void );
|
|
void UI_ConnectionProgress_Precache( void );
|
|
void UI_ConnectionProgress_Connect( const char *server );
|
|
void UI_ConnectionProgress_ChangeLevel( void );
|
|
void UI_ConnectionProgress_ParseServerInfo( const char *server );
|
|
void pfnPIC_Set( HIMAGE hPic, int r, int g, int b, int a );
|
|
void pfnPIC_Draw( int x, int y, int width, int height, const wrect_t *prc );
|
|
void pfnPIC_DrawTrans( int x, int y, int width, int height, const wrect_t *prc );
|
|
void pfnPIC_DrawHoles( int x, int y, int width, int height, const wrect_t *prc );
|
|
void pfnPIC_DrawAdditive( int x, int y, int width, int height, const wrect_t *prc );
|
|
|
|
//
|
|
// cl_mobile.c
|
|
//
|
|
qboolean Mobile_Init( void );
|
|
void Mobile_Shutdown( void );
|
|
|
|
//
|
|
// cl_video.c
|
|
//
|
|
void SCR_InitCinematic( void );
|
|
void SCR_FreeCinematic( void );
|
|
qboolean SCR_PlayCinematic( const char *name );
|
|
qboolean SCR_DrawCinematic( void );
|
|
qboolean SCR_NextMovie( void );
|
|
void SCR_RunCinematic( void );
|
|
void SCR_StopCinematic( void );
|
|
void CL_PlayVideo_f( void );
|
|
|
|
|
|
//
|
|
// keys.c
|
|
//
|
|
int Key_IsDown( int keynum );
|
|
const char *Key_IsBind( int keynum );
|
|
void Key_Event( int key, int down );
|
|
void Key_Init( void );
|
|
void Key_WriteBindings( file_t *f );
|
|
const char *Key_GetBinding( int keynum );
|
|
void Key_SetBinding( int keynum, const char *binding );
|
|
void Key_ClearStates( void );
|
|
const char *Key_KeynumToString( int keynum );
|
|
int Key_StringToKeynum( const char *str );
|
|
int Key_GetKey( const char *binding );
|
|
void Key_EnumCmds_f( void );
|
|
void Key_SetKeyDest( int key_dest );
|
|
void Key_EnableTextInput( qboolean enable, qboolean force );
|
|
int Key_ToUpper( int key );
|
|
void OSK_Draw( void );
|
|
|
|
extern rgba_t g_color_table[8];
|
|
|
|
#endif//CLIENT_H
|