/* Copyright (C) 1996-1997 Id Software, Inc. 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 2 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. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // client.h #include "particles.h" enum { SKIN_NOTLOADED, //not trying to load it. shouldn't really happen, but can. SKIN_LOADING, //still loading. just do something else for now... SKIN_LOADED, SKIN_FAILED }; typedef struct qwskin_s { char name[64]; int loadstate; // the name isn't a valid skin //qw skin info int width; int height; void *skindata; //for hardware 32bit texture overrides texnums_t textures; } qwskin_t; // player_state_t is the information needed by a player entity // to do move prediction and to generate a drawable entity typedef struct { int messagenum; // all player's won't be updated each frame double state_time; // not the same as the packet time, // because player commands come asyncronously usercmd_t command; // last command for prediction vec3_t origin; vec3_t predorigin; // pre-predicted pos vec3_t viewangles; // only for demos, not from server vec3_t velocity; int weaponframe; unsigned int modelindex; int frame; int skinnum; int effects; #ifdef PEXT_SCALE float scale; #endif qbyte colourmod[3]; qbyte alpha; #ifdef PEXT_FATNESS float fatness; #endif int flags; // dead, gib, etc int pm_type; float waterjumptime; qboolean onground; qboolean jump_held; int jump_msec; // hack for fixing bunny-hop flickering on non-ZQuake servers vec3_t szmins, szmaxs; vec3_t gravitydir; float lerpstarttime; int oldframe; } player_state_t; #if defined(Q2CLIENT) || defined(Q2SERVER) typedef enum { // can accelerate and turn Q2PM_NORMAL, Q2PM_SPECTATOR, // no acceleration or turning Q2PM_DEAD, Q2PM_GIB, // different bounding box Q2PM_FREEZE } q2pmtype_t; typedef struct { //shared with q2 dll q2pmtype_t pm_type; #if 0 int origin[3]; // 12.3 #else short origin[3]; // 20.3 #endif short velocity[3]; // 12.3 qbyte pm_flags; // ducked, jump_held, etc qbyte pm_time; // each unit = 8 ms short gravity; short delta_angles[3]; // add to command angles to get view direction // changed by spawns, rotating objects, and teleporters // short pad; } q2pmove_state_t; typedef struct { //shared with q2 dll so cannot be changed q2pmove_state_t pmove; // for prediction // these fields do not need to be communicated bit-precise vec3_t viewangles; // for fixed views vec3_t viewoffset; // add to pmovestate->origin vec3_t kick_angles; // add to view direction to get render angles // set by weapon kicks, pain effects, etc vec3_t gunangles; vec3_t gunoffset; int gunindex; int gunframe; float blend[4]; // rgba full screen effect float fov; // horizontal field of view int rdflags; // refdef flags short stats[Q2MAX_STATS]; // fast status bar updates } q2player_state_t; #endif typedef struct colourised_s { char name[64]; unsigned int topcolour; unsigned int bottomcolour; char skin[64]; struct colourised_s *next; } colourised_t; #define MAX_SCOREBOARDNAME 64 #define MAX_DISPLAYEDNAME 16 typedef struct player_info_s { int userid; char userinfo[EXTENDED_INFO_STRING]; qboolean userinfovalid; //set if we actually know the userinfo (ie: false on vanilla nq servers) char teamstatus[128]; float teamstatustime; // scoreboard information char name[MAX_SCOREBOARDNAME]; char team[MAX_INFO_KEY]; float realentertime; //pegged against realtime, to cope with potentially not knowing the server's time when we first receive this message int frags; int ping; qbyte pl; char ip[128]; struct { float time; //invalid if too old. int health; int armour; unsigned int items; vec3_t org; char nick[8]; //kinda short, yes. } tinfo; qboolean ignored; qboolean vignored; colourised_t *colourised; // skin information unsigned int rtopcolor; //real, according to their userinfo unsigned int rbottomcolor; unsigned int ttopcolor; //team, according to colour forcing unsigned int tbottomcolor; int spectator; qwskin_t *qwskin; qwskin_t *lastskin; //last-known-good skin skinid_t skinid; struct model_s *model; // unsigned short vweapindex; #ifdef HEXEN2 unsigned char h2playerclass; #endif int prevcount; #ifdef QUAKEHUD struct wstats_s { char wname[16]; unsigned int hit; unsigned int total; } weaponstats[16]; #endif int stats[MAX_CL_STATS]; float statsf[MAX_CL_STATS]; } player_info_t; typedef struct { double senttime; // time cmd was sent off float latency; // the time the packet was acked. -1=choked, -2=dropped, -3=never sent, -4=reply came back invalid // generated on client side usercmd_t cmd[MAX_SPLITS]; // cmd that generated the frame int cmd_sequence; //the outgoing move sequence. if not equal to expected, that index was stale and is no longer valid int server_message_num; //the inbound frame that was valid when this command was generated int server_time; int client_time; } outframe_t; typedef struct { //this is the sequence we requested for this frame. int delta_sequence; // sequence number to delta from, -1 = full update // received from server int frameid; //the sequence number of the frame, so we can easily detect which frames are valid without poking all in advance, etc int ackframe; //the outgoing sequence this frame acked (for prediction backlerping). double receivedtime; // time message was received, or -1 player_state_t playerstate[MAX_CLIENTS+MAX_SPLITS]; // message received that reflects performing // the usercmd packet_entities_t packet_entities; qboolean invalid; // true if the packet_entities delta was invalid } inframe_t; #ifdef Q2CLIENT typedef struct { qboolean valid; // cleared if delta parsing was invalid int serverframe; int servertime; // server time the message is valid for (in msec) int deltaframe; qbyte areabits[MAX_Q2MAP_AREAS/8]; // portalarea visibility bits q2player_state_t playerstate[MAX_SPLITS]; int clientnum[MAX_SPLITS]; int num_entities; int parse_entities; // non-masked index into cl_parse_entities array } q2frame_t; #endif typedef struct { int destcolor[3]; float percent; // 0-256 } cshift_t; #define CSHIFT_CONTENTS 0 #define CSHIFT_DAMAGE 1 #define CSHIFT_BONUS 2 #define CSHIFT_POWERUP 3 #define CSHIFT_SERVER 4 #define NUM_CSHIFTS 5 // // client_state_t should hold all pieces of the client state // //the light array works thusly: //dlights are allocated DL_LAST downwards to 0, static wlights are allocated DL_LAST+1 to MAX_RTLIGHTS. //thus to clear the dlights but not rtlights, set the first light to RTL_FIRST #define DL_LAST (sizeof(unsigned int)*8-1) #define RTL_FIRST (sizeof(unsigned int)*8) #define LFLAG_NORMALMODE (1<<0) /*ppl with r_shadow_realtime_dlight*/ #define LFLAG_REALTIMEMODE (1<<1) /*ppl with r_shadow_realtime_world*/ #define LFLAG_LIGHTMAP (1<<2) #define LFLAG_FLASHBLEND (1<<3) #define LFLAG_NOSHADOWS (1<<8) #define LFLAG_SHADOWMAP (1<<9) #define LFLAG_CREPUSCULAR (1<<10) #define LFLAG_DYNAMIC (LFLAG_LIGHTMAP | LFLAG_FLASHBLEND | LFLAG_NORMALMODE | LFLAG_REALTIMEMODE) typedef struct dlight_s { int key; // so entities can reuse same entry vec3_t origin; vec3_t axis[3]; vec3_t rotation; //cubemap/spotlight rotation float radius; float die; // stop lighting after this time float decay; // drop this each second float minlight; // don't add when contributing less float color[3]; float channelfade[3]; #ifdef RTLIGHTS vec3_t lightcolourscales; //ambient, diffuse, specular #endif float corona; float coronascale; unsigned int flags; char cubemapname[64]; int coronaocclusionquery; unsigned int coronaocclusionresult; //the following are used for rendering (client code should clear on create) qboolean rebuildcache; struct shadowmesh_s *worldshadowmesh; texid_t cubetexture; struct { float updatetime; } face [6]; int style; //multiply by style values if > 0 float fov; //spotlight struct dlight_s *next; } dlight_t; typedef struct { int length; char map[MAX_STYLESTRING]; vec3_t colours; int colourkey; //compacted version of the colours, for comparison against caches } lightstyle_t; #define MAX_EFRAGS 512 #define MAX_DEMOS 8 #define MAX_DEMONAME 16 typedef enum { ca_disconnected, // full screen console with no connection ca_demostart, // starting up a demo ca_connected, // netchan_t established, waiting for svc_serverdata ca_onserver, // processing data lists, donwloading, etc ca_active // everything is in, so frames can be rendered } cactive_t; typedef enum { dl_none, dl_model, dl_sound, dl_skin, dl_wad, dl_single, dl_singlestuffed } dltype_t; // download type typedef struct qdownload_s { enum {DL_QW, DL_QWCHUNKS, DL_Q3, DL_DARKPLACES, DL_QWPENDING, DL_HTTP, DL_FTP} method; vfsfile_t *file; // file transfer from server char dclname[MAX_OSPATH]; //file to read/write the chunklist from, for download resumption. char tempname[MAX_OSPATH]; //file its currently writing to. char localname[MAX_OSPATH]; //file its going to be renamed to. int prefixbytes; //number of bytes that prefix the above names (ie: package/ or nothing). char remotename[MAX_OSPATH]; //file its coming from. float percent; //for progress indicator. float starttime; //for speed info qofs_t completedbytes; //number of bytes downloaded, for progress/speed info qofs_t size; //total size (may be a guess) qboolean sizeunknown; //says that size is a guess unsigned int filesequence; //unique file id. enum fs_relative fsroot; //where the local+temp file is meant to be relative to. double ratetime; int rate; int ratebytes; unsigned int flags; //chunked downloads uses this struct dlblock_s { qofs_t start; qofs_t end; enum { DLB_MISSING, DLB_PENDING, DLB_RECEIVED } state:16; unsigned int sequence; //sequence is only valid on pending blocks. struct dlblock_s *next; } *dlblocks; } qdownload_t; enum qdlabort { QDL_FAILED, //delete file, tell server. QDL_DISCONNECT, //delete file, don't tell server. QDL_COMPLETED, //rename file, tell server. }; qboolean DL_Begun(qdownload_t *dl); void DL_Abort(qdownload_t *dl, enum qdlabort aborttype); //just frees the download's resources. does not delete the temp file. qboolean CL_AllowArbitaryDownload(char *oldname, char *localfile); // // the client_static_t structure is persistant through an arbitrary number // of server connections // typedef struct { // connection information cactive_t state; /*Specifies which protocol family we're speaking*/ enum { CP_UNKNOWN, CP_QUAKEWORLD, CP_NETQUAKE, CP_QUAKE2, CP_QUAKE3, CP_PLUGIN } protocol; /*QuakeWorld protocol flags*/ #ifdef PROTOCOLEXTENSIONS unsigned long fteprotocolextensions; unsigned long fteprotocolextensions2; #endif unsigned long z_ext; /*NQ Protocol flags*/ enum { CPNQ_ID, CPNQ_BJP1, //16bit models, strict 8bit sounds CPNQ_BJP2, //16bit models, strict 16bit sounds CPNQ_BJP3, //16bit models, flagged 16bit sounds CPNQ_FITZ666, /*and rmqe999 protocol*/ CPNQ_DP5, CPNQ_DP6, CPNQ_DP7 } protocol_nq; #define CPNQ_IS_DP (cls.protocol_nq >= CPNQ_DP5) #define CPNQ_IS_BJP (cls.protocol_nq >= CPNQ_BJP1 && cls.protocol_nq <= CPNQ_BJP3) qboolean proquake_angles_hack; //angles are always 16bit int protocol_q2; qboolean resendinfo; qboolean findtrack; int framecount; int realip_ident; netadr_t realserverip; // network stuff netchan_t netchan; float lastarbiatarypackettime; //used to mark when packets were sent to prevent mvdsv servers from causing us to disconnect. // private userinfo for sending to masterless servers char userinfo[MAX_SPLITS][EXTENDED_INFO_STRING]; char servername[MAX_OSPATH]; // name of server from original connect struct ftenet_connections_s *sockets; qdownload_t *download; // demo loop control int demonum; // -1 = don't play demos char demos[MAX_DEMOS][MAX_DEMONAME]; // when not playing // demo recording info must be here, because record is started before // entering a map (and clearing client_state_t) vfsfile_t *demooutfile; enum{DPB_NONE,DPB_QUAKEWORLD,DPB_MVD,DPB_EZTV, #ifdef NQPROT DPB_NETQUAKE, #endif #ifdef Q2CLIENT DPB_QUAKE2 #endif } demoplayback, demorecording; qboolean demohadkeyframe; //q2 needs to wait for a packet with a key frame, supposedly. qboolean demoseeking; float demoseektime; qboolean timedemo; vfsfile_t *demoinfile; float td_lastframe; // to meter out one message a frame int td_startframe; // host_framecount at start float td_starttime; // realtime at second frame of timedemo float demostarttime; // the time of the first frame, so we don't get weird results with qw demos int challenge; float latency; // rolling average qboolean allow_anyparticles; qboolean allow_skyboxes; qboolean allow_watervis; //fixme: not checked any more float allow_fbskins; //fraction of allowance qboolean allow_cheats; qboolean allow_semicheats; //defaults to true, but this allows a server to enforce a strict ruleset (smackdown type rules). qboolean allow_csqc; //disables some legacy/compat things, like proquake parsing. float maxfps; //server capped int deathmatch; #ifdef NQPROT int signon; #endif int language; colourised_t *colourised; qboolean nqexpectingstatusresponse; } client_static_t; extern client_static_t cls; typedef struct downloadlist_s { char rname[128]; char localname[128]; unsigned int size; unsigned int flags; #define DLLF_VERBOSE (1u<<0) //tell the user that its downloading #define DLLF_REQUIRED (1u<<1) //means that it won't load models etc until its downloaded (ie: requiredownloads 0 makes no difference) #define DLLF_OVERWRITE (1u<<2) //overwrite it even if it already exists #define DLLF_SIZEUNKNOWN (1u<<3) //download's size isn't known #define DLLF_IGNOREFAILED (1u<<4) // #define DLLF_NONGAME (1u<<5) //means the requested download filename+localname is gamedir explicit (so id1/foo.txt is distinct from qw/foo.txt) #define DLLF_TEMPORARY (1u<<6) //download it, but don't actually save it (DLLF_OVERWRITE doesn't actually overwrite, but does ignore any local files) #define DLLF_USEREXPLICIT (1u<<7) //use explicitly requested it, ignore the cl_downloads cvar. #define DLLF_BEGUN (1u<<8) //server has confirmed that the file exists, is readable, and we've opened a file. should not be set on new requests. #define DLLF_ALLOWWEB (1u<<9) //failed http downloads should retry but from the game server itself struct downloadlist_s *next; } downloadlist_t; typedef struct { //current persistant state trailstate_t *trailstate; //when to next throw out a trail trailstate_t *emitstate; //when to next emit //current origin vec3_t origin; //current render position vec3_t angles; //previous rendering frame (for trails) vec3_t lastorigin; qboolean isnew; qboolean isplayer; //intermediate values for frame lerping //separate upper+lower lerps float framelerpdeltatime[FS_COUNT]; float newframestarttime[FS_COUNT]; int newframe[FS_COUNT]; float oldframestarttime[FS_COUNT]; int oldframe[FS_COUNT]; qbyte basebone; //intermediate values for origin lerping of stepping things int newsequence; float orglerpdeltatime; float orglerpstarttime; vec3_t neworigin; /*origin that we're lerping towards*/ vec3_t oldorigin; /*origin that we're lerping away from*/ vec3_t newangle; vec3_t oldangle; //for further info int skeletalobject; int sequence; /*so we know if the ent is still valid*/ entity_state_t *entstate; } lerpents_t; //state associated with each player 'seat' (one for each splitscreen client) //note that this doesn't include networking inputlog info. struct playerview_s { int playernum; //cl.players index for this player. qboolean nolocalplayer; //inhibit use of qw-style players, predict based on entities. #ifdef PEXT_SETVIEW int viewentity; //view is attached to this entity. #endif // information for local display int stats[MAX_CL_STATS]; // health, etc float statsf[MAX_CL_STATS]; // health, etc char *statsstr[MAX_CL_STATS]; // health, etc float item_gettime[32]; // cl.time of aquiring item, for blinking float faceanimtime; // use anim frame if cl.time < this #ifdef HEXEN2 int sb_hexen2_cur_item;//hexen2 hud float sb_hexen2_item_time; qboolean sb_hexen2_extra_info;//show the extra stuff qboolean sb_hexen2_infoplaque; #endif // the client maintains its own idea of view angles, which are // sent to the server each frame. And only reset at level change // and teleport times vec3_t viewangles; //current angles vec3_t viewanglechange; //angles set by input code this frame vec3_t intermissionangles; //absolute angles for intermission vec3_t gravitydir; // pitch drifting vars float pitchvel; qboolean nodrift; float driftmove; double laststop; int gamerectknown; //equals cls.framecount if valid vrect_t gamerect; //position the player's main view was drawn at this frame. //prediction state int pmovetype; float entgravity; float maxspeed; vec3_t simorg; vec3_t simvel; vec3_t simangles; float rollangle; float hdr_last; int chatstate; //1=talking, 2=afk float crouch; // local amount for smoothing stepups vec3_t oldorigin; // to track step smoothing float oldz, extracrouch, crouchspeed; // to track step smoothing qboolean onground; float viewheight; int waterlevel; //for smartjump #ifdef Q2CLIENT vec3_t predicted_origin; vec3_t predicted_angles; vec3_t prediction_error; float predicted_step_time; float predicted_step; #endif //temporary view kick from weapon firing, angles+origins float punchangle_cl; // qw-style angles vec3_t punchangle_sv; // nq-style vec3_t punchorigin; // nq-style float v_dmg_time; //various view knockbacks. float v_dmg_roll; float v_dmg_pitch; double bobtime; //sine wave double bobcltime; //for tracking time increments float bob; //bob height vec3_t cam_desired_position; // where the camera wants to be int cam_oldbuttons; // vec3_t cam_viewangles; // double cam_lastviewtime; // timer for wallcam float cam_reautotrack; // timer to throttle tracking changes. int cam_spec_track; // player# of who we are tracking / want to track / might want to track enum { CAM_FREECAM = 0, //not attached to another player. we are our own thing (or actually playing). CAM_PENDING = 1, //we want to lock on to cam_spec_track, but we don't have their position / stats yet. still freecamming CAM_WALLCAM = 2, //locked, cl_chasecam=0. we're watching them from a wall. CAM_EYECAM = 3 //locked, cl_chasecam=1. we know where they are, we're in their eyes. #define CAM_ISLOCKED(pv) ((pv)->cam_state > CAM_PENDING) } cam_state; cshift_t cshifts[NUM_CSHIFTS]; // color shifts for damage, powerups and content types vec4_t screentint; vec3_t vw_axis[3]; //weapons should be positioned relative to this vec3_t vw_origin; //weapons should be positioned relative to this // entity_t viewent; // is this not utterly redundant yet? struct { struct model_s *oldmodel; float lerptime; float oldlerptime; float frameduration; int prevframe; int oldframe; } vm; struct { qboolean defaulted; int entnum; vec3_t origin; vec3_t forward; vec3_t right; vec3_t up; size_t reverbtype; vec3_t velocity; } audio; }; // // the client_state_t structure is wiped completely at every // server signon // typedef struct { int fpd; int servercount; // server identification for prespawns float gamespeed; qboolean csqcdebug; qboolean allowsendpacket; qboolean stillloading; // set when doing something slow, and the game is still loading. qboolean haveserverinfo; //nq servers will usually be false. don't override stuff if we already know better. char serverinfo[MAX_SERVERINFO_STRING]; char serverpaknames[1024]; char serverpakcrcs[1024]; qboolean serverpakschanged; int parsecount; // server message counter int oldparsecount; int oldvalidsequence; int ackedmovesequence; //in quakeworld/q2 this is always equal to validsequence. nq can differ. may only be updated when validsequence is updated. int lastackedmovesequence; //can be higher than ackedmovesequence when the received frame was unusable. int validsequence; // this is the sequence number of the last good // packetentity_t we got. If this is 0, we can't // render a frame yet int movesequence; // client->server frames int spectator; int autotrack_hint; //the latest hint from the mod, might be negative for invalid. int autotrack_killer; //if someone kills the guy we're tracking, this is the guy we should switch to. double last_ping_request; // while showing scoreboard double last_servermessage; //list of ent frames that still need to be acked. int numackframes; int ackframes[64]; #ifdef Q2CLIENT q2frame_t q2frame; q2frame_t q2frames[Q2UPDATE_BACKUP]; #endif // sentcmds[cl.netchan.outgoing_sequence & UPDATE_MASK] = cmd outframe_t outframes[UPDATE_BACKUP]; //user inputs (cl.ackedmovesequence+1 to cl.movesequence are still pending) inframe_t inframes[UPDATE_BACKUP]; //server state (cl.validsequence is the most recent set) lerpents_t *lerpents; int maxlerpents; //number of slots allocated. int lerpentssequence; lerpents_t lerpplayers[MAX_CLIENTS]; //when running splitscreen, we have multiple viewports all active at once int splitclients; //we are running this many clients split screen. playerview_t playerview[MAX_SPLITS]; int defaultnetsplit;//which multiview splitscreen to parse the message for (set by mvd playback code) // localized movement vars float bunnyspeedcap; // the client simulates or interpolates movement to get these values double time; // this is the time value that the client // is rendering at. always <= realtime float servertime; //current server time, bound between gametime and gametimemark float mtime; //server time as on the server when we last received a packet. not allowed to decrease. float oldmtime; //server time as on the server for the previously received packet. float gametime; float gametimemark; float oldgametime; //used as the old time to lerp cl.time from. float oldgametimemark; //if it's 0, cl.time will casually increase. float demogametimebias; //mvd timings are weird. float minpitch; float maxpitch; qboolean paused; // send over by server enum { IM_NONE, //off. IM_NQSCORES, //+showscores forced, view still attached to regular view IM_NQFINALE, //slow centerprint text etc, view still attached to regular view. no hud IM_NQCUTSCENE, //IM_NQFINALE, but without the 'finale' header on centerprints. IM_H2FINALE, //IM_NQFINALE, but with the view offset by the player's viewheight. IM_QWSCORES //intermission, view locked at a specific point } intermissionmode; // don't change view angle, full screen, etc float completed_time; // latched ffrom time at intermission start #define Q2MAX_VISIBLE_WEAPONS 32 //q2 has about 20. int numq2visibleweapons; //q2 sends out visible-on-model weapons in a wierd gender-nutral way. char *q2visibleweapons[Q2MAX_VISIBLE_WEAPONS];//model names beginning with a # are considered 'sexed', and are loaded on a per-client basis. yay. :( // // information that is static for the entire time connected to a server // char model_name_vwep[MAX_VWEP_MODELS][MAX_QPATH]; char model_name[MAX_PRECACHE_MODELS][MAX_QPATH]; char sound_name[MAX_PRECACHE_SOUNDS][MAX_QPATH]; char *particle_ssname[MAX_SSPARTICLESPRE]; #ifdef Q2CLIENT char *configstring_general[Q2MAX_CLIENTS|Q2MAX_GENERAL]; char *image_name[Q2MAX_IMAGES]; char *item_name[Q2MAX_ITEMS]; short inventory[MAX_SPLITS][Q2MAX_ITEMS]; #endif struct model_s *model_precache_vwep[MAX_VWEP_MODELS]; struct model_s *model_precache[MAX_PRECACHE_MODELS]; struct sfx_s *sound_precache[MAX_PRECACHE_SOUNDS]; int particle_ssprecache[MAX_SSPARTICLESPRE]; //these are actually 1-based, so 0 can be used to lazy-init them. I cheat. char model_csqcname[MAX_CSMODELS][MAX_QPATH]; struct model_s *model_csqcprecache[MAX_CSMODELS]; char *particle_csname[MAX_CSPARTICLESPRE]; int particle_csprecache[MAX_CSPARTICLESPRE]; //these are actually 1-based, so we can be lazy and do a simple negate. qboolean model_precaches_added; qboolean particle_ssprecaches; //says to not try to do any dp-compat hacks. qboolean particle_csprecaches; //says to not try to do any dp-compat hacks. //used for q2 sky/configstrings char skyname[MAX_QPATH]; float skyrotate; vec3_t skyaxis; qboolean fog_locked; fogstate_t fog[2]; //0 = air, 1 = water. if water has no density fall back on air. fogstate_t oldfog[2]; char levelname[40]; // for display on solo scoreboard char *windowtitle; // fully overrides the window caption. // refresh related state struct model_s *worldmodel; // cl_entitites[0].model int num_entities; // stored bottom up in cl_entities array int num_statics; // stored top down in cl_entitiers // all player information unsigned int allocated_client_slots; player_info_t players[MAX_CLIENTS]; downloadlist_t *downloadlist; downloadlist_t *faileddownloads; qboolean gamedirchanged; #ifdef Q2CLIENT char q2statusbar[1024]; char q2layout[MAX_SPLITS][1024]; int parse_entities; float lerpfrac; float q2svnetrate; //number of frames we expect to receive per second (required to calculate the server time correctly). #endif char lastcenterprint[1024]; //prevents too much spam with console centerprint logging. struct itemtimer_s { float end; int entnum; float start; float duration; vec3_t origin; float radius; struct itemtimer_s *next; } *itemtimers; //interpolation+snapshots float packfrac; packet_entities_t *currentpackentities; packet_entities_t *previouspackentities; float currentpacktime; qboolean do_lerp_players; int teamplay; int deathmatch; qboolean teamfortress; // *sigh*. This is used for teamplay stuff. This sucks. qboolean hexen2pickups; qboolean sendprespawn; int contentstage; double matchgametimestart; enum { MATCH_DONTKNOW, //assumed to be in progress. MATCH_COUNTDOWN, MATCH_STANDBY, MATCH_INPROGRESS } matchstate; enum { CLNQPP_NONE, CLNQPP_PINGS, CLNQPP_STATUS, //"host: *\n" ... "players: *\n\n" CLNQPP_STATUSPLAYER, //#...\n CLNQPP_STATUSPLAYERIP, // foobar\n } nqparseprint; int nqparseprintplayer; float nqplayernamechanged; } client_state_t; extern unsigned int cl_teamtopcolor; extern unsigned int cl_teambottomcolor; extern unsigned int cl_enemytopcolor; extern unsigned int cl_enemybottomcolor; //FPD values //(commented out ones are ones that we don't support) #define FPD_NO_FORCE_SKIN 256 #define FPD_NO_FORCE_COLOR 512 #define FPD_LIMIT_PITCH (1 << 14) //limit scripted pitch changes #define FPD_LIMIT_YAW (1 << 15) //limit scripted yaw changes // // cvars // extern cvar_t cl_warncmd; extern cvar_t cl_upspeed; extern cvar_t cl_forwardspeed; extern cvar_t cl_backspeed; extern cvar_t cl_sidespeed; extern cvar_t cl_movespeedkey; extern cvar_t cl_yawspeed; extern cvar_t cl_pitchspeed; extern cvar_t cl_anglespeedkey; extern cvar_t cl_shownet; extern cvar_t cl_sbar; extern cvar_t cl_hudswap; extern cvar_t cl_pitchdriftspeed; extern cvar_t lookspring; extern cvar_t lookstrafe; extern cvar_t sensitivity; extern cvar_t m_pitch; extern cvar_t m_yaw; extern cvar_t m_forward; extern cvar_t m_side; extern cvar_t _windowed_mouse; #ifndef SERVERONLY extern cvar_t name; #endif extern cvar_t ruleset_allow_playercount; extern cvar_t ruleset_allow_frj; extern cvar_t ruleset_allow_semicheats; extern cvar_t ruleset_allow_packet; extern cvar_t ruleset_allow_particle_lightning; extern cvar_t ruleset_allow_overlongsounds; extern cvar_t ruleset_allow_larger_models; extern cvar_t ruleset_allow_modified_eyes; extern cvar_t ruleset_allow_sensitive_texture_replacements; extern cvar_t ruleset_allow_localvolume; extern cvar_t ruleset_allow_shaders; extern cvar_t ruleset_allow_watervis; #ifndef SERVERONLY extern client_state_t cl; #endif typedef struct { entity_t ent; entity_state_t state; trailstate_t *emit; int mdlidx; /*negative are csqc indexes*/ pvscache_t pvscache; } static_entity_t; // FIXME, allocate dynamically extern entity_state_t *cl_baselines; extern static_entity_t *cl_static_entities; extern unsigned int cl_max_static_entities; extern lightstyle_t cl_lightstyle[MAX_LIGHTSTYLES]; extern dlight_t *cl_dlights; extern unsigned int cl_maxdlights; extern int rtlights_first, rtlights_max; extern int cl_baselines_count; extern qboolean nomaster; //============================================================================= // // cl_main // void CL_InitDlights(void); void CL_FreeDlights(void); dlight_t *CL_AllocDlight (int key); dlight_t *CL_AllocSlight (void); //allocates a static light dlight_t *CL_NewDlight (int key, const vec3_t origin, float radius, float time, float r, float g, float b); dlight_t *CL_NewDlightCube (int key, const vec3_t origin, vec3_t angles, float radius, float time, vec3_t colours); void CL_DecayLights (void); void CLQW_ParseDelta (struct entity_state_s *from, struct entity_state_s *to, int bits); void CL_Init (void); void Host_WriteConfiguration (void); void CL_CheckServerInfo(void); void CL_CheckServerPacks(void); void CL_EstablishConnection (char *host); void CL_Disconnect (void); void CL_Disconnect_f (void); void CL_Reconnect_f (void); void CL_NextDemo (void); void CL_Startdemos_f (void); void CL_Demos_f (void); void CL_Stopdemo_f (void); void CL_Changing_f (void); void CL_Reconnect_f (void); void CL_ConnectionlessPacket (void); qboolean CL_DemoBehind(void); void CL_SaveInfo(vfsfile_t *f); void CL_SetInfo (int pnum, char *key, char *value); void CL_BeginServerConnect(const char *host, int port, qboolean noproxy); char *CL_TryingToConnect(void); void CL_ExecInitialConfigs(char *defaultexec); extern int cl_framecount; //number of times the entity lists have been cleared+reset. extern int cl_numvisedicts; extern int cl_maxvisedicts; extern entity_t *cl_visedicts; /*these are for q3 really*/ typedef struct { struct shader_s *shader; int firstvert; int firstidx; int numvert; int numidx; unsigned int flags; } scenetris_t; extern scenetris_t *cl_stris; extern vecV_t *fte_restrict cl_strisvertv; extern vec4_t *fte_restrict cl_strisvertc; extern vec2_t *fte_restrict cl_strisvertt; extern index_t *fte_restrict cl_strisidx; extern unsigned int cl_numstrisidx; extern unsigned int cl_maxstrisidx; extern unsigned int cl_numstrisvert; extern unsigned int cl_maxstrisvert; extern unsigned int cl_numstris; extern unsigned int cl_maxstris; extern char emodel_name[], pmodel_name[], prespawn_name[], modellist_name[], soundlist_name[]; //CL_TraceLine traces against network(positive)+csqc(negative) ents. returns frac(1 on failure), and impact, normal, ent values float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int *ent); entity_t *TraceLineR (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal); // // cl_input // typedef struct { int down[MAX_SPLITS][2]; // key nums holding it down int state[MAX_SPLITS]; // low bit is down state } kbutton_t; extern kbutton_t in_mlook, in_klook; extern kbutton_t in_strafe; extern kbutton_t in_speed; extern float in_sensitivityscale; void CL_MakeActive(char *gamename); void CL_UpdateWindowTitle(void); void CL_InitInput (void); void CL_SendCmd (double frametime, qboolean mainloop); void CL_SendMove (usercmd_t *cmd); #ifdef NQPROT void CL_ParseTEnt (qboolean nqprot); #else void CL_ParseTEnt (void); #endif void CL_UpdateTEnts (void); enum beamtype_e { //these are internal ids, matching the beam table BT_Q1LIGHTNING1, BT_Q1LIGHTNING2, BT_Q1LIGHTNING3, BT_Q1BEAM, BT_Q2PARASITE, BT_Q2GRAPPLE, BT_Q2HEATBEAM, BT_Q2LIGHTNING, BT_H2LIGHTNING_SMALL, BT_H2CHAIN, BT_H2SUNSTAFF1, BT_H2SUNSTAFF1_SUB, //inner beam hack BT_H2SUNSTAFF2, //same model as 1, but different particle effect BT_H2LIGHTNING, BT_H2COLORBEAM, BT_H2ICECHUNKS, BT_H2GAZE, BT_H2FAMINE, }; typedef struct beam_s beam_t; beam_t *CL_AddBeam (enum beamtype_e tent, int ent, vec3_t start, vec3_t end); void CL_ClearState (void); void CLQ2_ClearState(void); void CL_ReadPackets (void); void CL_ClampPitch (int pnum); int CL_ReadFromServer (void); void CL_WriteToServer (usercmd_t *cmd); void CL_BaseMove (usercmd_t *cmd, int pnum, float extra, float wantfps); int Master_FindBestRoute(char *server, char *out, size_t outsize, int *directcost, int *chainedcost); float CL_KeyState (kbutton_t *key, int pnum, qboolean noslowstart); char *Key_KeynumToString (int keynum, int modifier); int Key_StringToKeynum (const char *str, int *modifier); char *Key_GetBinding(int keynum, int bindmap, int modifier); void Key_GetBindMap(int *bindmaps); void Key_SetBindMap(int *bindmaps); void CL_UseIndepPhysics(qboolean allow); void CL_FlushClientCommands(void); void VARGS CL_SendClientCommand(qboolean reliable, char *format, ...) LIKEPRINTF(2); float CL_FilterTime (double time, float wantfps, qboolean ignoreserver); int CL_RemoveClientCommands(char *command); void CL_AllowIndependantSendCmd(qboolean allow); // // cl_demo.c // void CL_StopPlayback (void); qboolean CL_GetMessage (void); void CL_WriteDemoCmd (usercmd_t *pcmd); void CL_Demo_ClientCommand(char *commandtext); //for QTV. void CL_WriteSetDemoMessage (void); //'restarts' a qwd, when we have reloads/map changes in them void CL_WriteRecordQ2DemoMessage(sizebuf_t *msg); void CL_Stop_f (void); void CL_Record_f (void); void CL_ReRecord_f (void); void CL_PlayDemo_f (void); void CL_QTVPlay_f (void); void CL_QTVPoll (void); void CL_QTVList_f (void); void CL_QTVDemos_f (void); void CL_DemoJump_f(void); void CL_ProgressDemoTime(void); void CL_TimeDemo_f (void); typedef struct { enum { QTVCT_NONE, QTVCT_STREAM, QTVCT_CONNECT, QTVCT_JOIN, QTVCT_OBSERVE, QTVCT_MAP } connectiontype; enum { QTVCT_NETQUAKE, QTVCT_QUAKEWORLD, QTVCT_QUAKE2, QTVCT_QUAKE3 } protocol; char server[256]; char splashscreen[256]; //char *datafiles; } qtvfile_t; void CL_ParseQTVFile(vfsfile_t *f, const char *fname, qtvfile_t *result); // // cl_parse.c // #define NET_TIMINGS 256 #define NET_TIMINGSMASK 255 extern int packet_latency[NET_TIMINGS]; int CL_CalcNet (float scale); void CL_CalcNet2 (float *pings, float *pings_min, float *pings_max, float *pingms_stddev, float *pingfr, int *pingfr_min, int *pingfr_max, float *dropped, float *choked, float *invalid); void CL_ClearParseState(void); void CL_Parse_Disconnected(void); void CL_DumpPacket(void); void CL_ParseEstablished(void); void CLQW_ParseServerMessage (void); void CLNQ_ParseServerMessage (void); #ifdef Q2CLIENT void CLQ2_ParseServerMessage (void); #endif void CL_NewTranslation (int slot); int CL_IsDownloading(const char *localname); qboolean CL_CheckOrEnqueDownloadFile (const char *filename, const char *localname, unsigned int flags); qboolean CL_EnqueDownload(const char *filename, const char *localname, unsigned int flags); downloadlist_t *CL_DownloadFailed(const char *name, qdownload_t *qdl); int CL_DownloadRate(void); void CL_GetDownloadSizes(unsigned int *filecount, qofs_t *totalsize, qboolean *somesizesunknown); qboolean CL_ParseOOBDownload(void); void CL_DownloadFinished(qdownload_t *dl); void CL_RequestNextDownload (void); void CL_SendDownloadReq(sizebuf_t *msg); void Sound_CheckDownload(const char *s); /*checkorenqueue a sound file*/ qboolean CL_IsUploading(void); void CL_NextUpload(void); void CL_StartUpload (qbyte *data, int size); void CL_StopUpload(void); qboolean CL_CheckBaselines (int size); // // view.c // void V_StartPitchDrift (playerview_t *pv); void V_StopPitchDrift (playerview_t *pv); void V_RenderView (void); void V_Register (void); void V_ParseDamage (playerview_t *pv); void V_SetContentsColor (int contents); //used directly by csqc void V_CalcRefdef (playerview_t *pv); void V_ClearRefdef(playerview_t *pv); void V_ApplyRefdef(void); void V_CalcGunPositionAngle (playerview_t *pv, float bob); float V_CalcBob (playerview_t *pv, qboolean queryold); void DropPunchAngle (playerview_t *pv); int V_EditExternalModels(int newviewentity, entity_t *viewentities, int maxviewenties); void V_DepthSortEntities(float *vieworg); // // cl_tent // void CL_RegisterParticles(void); void CL_InitTEnts (void); void CL_InitTEntSounds (void); void CL_ClearTEnts (void); void CL_ClearTEntParticleState (void); void CL_ClearCustomTEnts(void); void CL_ParseCustomTEnt(void); qboolean CL_WriteCustomTEnt(sizebuf_t *buf, int id); void CL_ParseEffect (qboolean effect2); void CLNQ_ParseParticleEffect (void); void CL_ParseParticleEffect2 (void); void CL_ParseParticleEffect3 (void); void CL_ParseParticleEffect4 (void); int CL_TranslateParticleFromServer(int sveffect); void CL_ParseTrailParticles(void); void CL_ParsePointParticles(qboolean compact); void CL_SpawnSpriteEffect(vec3_t org, vec3_t dir, vec3_t orientationup, struct model_s *model, int startframe, int framecount, float framerate, float alpha, float scale, float randspin, float gravity, int traileffect, unsigned int renderflags, int skinnum); /*called from the particlesystem*/ // // cl_ents.c // void CL_SetSolidPlayers (void); void CL_SetUpPlayerPrediction(qboolean dopred); void CL_LinkStaticEntities(void *pvs); void CL_TransitionEntities (void); /*call at the start of the frame*/ void CL_EmitEntities (void); void CL_ClearProjectiles (void); void CL_ParseProjectiles (int modelindex, qboolean nails2); void CLQW_ParsePacketEntities (qboolean delta); void CLFTE_ParseEntities (void); void CLFTE_ParseBaseline(entity_state_t *es, qboolean numberisimportant); void CL_SetSolidEntities (void); void CL_ParsePlayerinfo (void); void CL_ParseClientPersist(void); //these last ones are needed for csqc handling of engine-bound ents. void CL_ClearEntityLists(void); void CL_FreeVisEdicts(void); void CL_LinkViewModel(void); void CL_LinkPlayers (void); void CL_LinkPacketEntities (void); void CL_LinkProjectiles (void); void CL_ClearLerpEntsParticleState (void); qboolean CL_MayLerp(void); // //clq3_parse.c // #ifdef Q3CLIENT void VARGS CLQ3_SendClientCommand(const char *fmt, ...) LIKEPRINTF(1); void CLQ3_SendAuthPacket(netadr_t *gameserver); void CLQ3_SendConnectPacket(netadr_t *to, int challenge, int qport); void CLQ3_SendCmd(usercmd_t *cmd); qboolean CLQ3_Netchan_Process(void); void CLQ3_ParseServerMessage (void); struct snapshot_s; qboolean CG_FillQ3Snapshot(int snapnum, struct snapshot_s *snapshot); void CG_InsertIntoGameState(int num, char *str); void CG_Restart_f(void); char *CG_GetConfigString(int num); #endif // //pr_csqc.c // #ifdef CSQC_DAT qboolean CSQC_Inited(void); void CSQC_RendererRestarted(void); qboolean CSQC_UnconnectedOkay(qboolean inprinciple); qboolean CSQC_UnconnectedInit(void); qboolean CSQC_Init (qboolean anycsqc, qboolean csdatenabled, unsigned int checksum); qboolean CSQC_ConsoleLink(char *text, char *info); void CSQC_RegisterCvarsAndThings(void); qboolean CSQC_SetupToRenderPortal(int entnum); qboolean CSQC_DrawView(void); qboolean CSQC_UseGamecodeLoadingScreen(void); void CSQC_Shutdown(void); qboolean CSQC_StuffCmd(int lplayernum, char *cmd, char *cmdend); void CSQC_MapEntityEdited(int modelindex, int idx, const char *newe); qboolean CSQC_LoadResource(char *resname, char *restype); qboolean CSQC_ParsePrint(char *message, int printlevel); qboolean CSQC_ParseGamePacket(void); qboolean CSQC_CenterPrint(int lplayernum, char *cmd); qboolean CSQC_Parse_Damage(float save, float take, vec3_t source); void CSQC_Input_Frame(int lplayernum, usercmd_t *cmd); void CSQC_WorldLoaded(void); qboolean CSQC_ParseTempEntity(void); qboolean CSQC_ConsoleCommand(char *cmd); qboolean CSQC_KeyPress(int key, int unicode, qboolean down, unsigned int devid); qboolean CSQC_MouseMove(float xdelta, float ydelta, unsigned int devid); qboolean CSQC_MousePosition(float xabs, float yabs, unsigned int devid); qboolean CSQC_JoystickAxis(int axis, float value, unsigned int devid); qboolean CSQC_Accelerometer(float x, float y, float z); qboolean CSQC_Gyroscope(float x, float y, float z); int CSQC_StartSound(int entnum, int channel, char *soundname, vec3_t pos, float vol, float attenuation, float pitchmod, float timeofs, unsigned int flags); void CSQC_ParseEntities(void); void CSQC_ResetTrails(void); qboolean CSQC_DeltaPlayer(int playernum, player_state_t *state); void CSQC_DeltaStart(float time); qboolean CSQC_DeltaUpdate(entity_state_t *src); void CSQC_DeltaEnd(void); void CSQC_CvarChanged(cvar_t *var); #else #define CSQC_UnconnectedOkay(inprinciple) false #define CSQC_UnconnectedInit() false #define CSQC_UseGamecodeLoadingScreen() false #endif // // cl_pred.c // void CL_InitPrediction (void); void CL_PredictMove (void); void CL_PredictUsercmd (int seat, int entnum, player_state_t *from, player_state_t *to, usercmd_t *u); #ifdef Q2CLIENT void CLQ2_CheckPredictionError (void); #endif void CL_CalcClientTime(void); // // cl_cam.c // qboolean Cam_DrawViewModel(playerview_t *pv); int Cam_TrackNum(playerview_t *pv); void Cam_Unlock(playerview_t *pv); //revert to freecam or so, because that entity failed. void Cam_Lock(playerview_t *pv, int playernum); //attempt to lock on to the given player. void Cam_NowLocked(playerview_t *pv); //player was located, track them now void Cam_SelfTrack(playerview_t *pv); void Cam_Track(playerview_t *pv, usercmd_t *cmd); void Cam_TrackCrosshairedPlayer(playerview_t *pv); void Cam_SetModAutoTrack(int userid); void Cam_FinishMove(playerview_t *pv, usercmd_t *cmd); void Cam_Reset(void); void Cam_TrackPlayer(int seat, char *cmdname, char *plrarg); void CL_InitCam(void); void Cam_AutoTrack_Update(const char *mode); //reset autotrack setting (because we started a new map or whatever) // //zqtp.c // #define TPM_UNKNOWN 0 #define TPM_NORMAL 1 #define TPM_TEAM 2 #define TPM_SPECTATOR 4 #define TPM_FAKED 16 #define TPM_OBSERVEDTEAM 32 #define TPM_QTV 64 //should only be qtv_say_game/qtv_say_team_game void CL_Say (qboolean team, char *extra); int TP_CategorizeMessage (char *s, int *offset, player_info_t **plr); void TP_CheckPickupSound(char *s, vec3_t org, int seat); qboolean TP_CheckSoundTrigger (char *str); int TP_CountPlayers (void); char* TP_EnemyName (void); char* TP_EnemyTeam (void); void TP_ExecTrigger (char *s, qboolean indemos); qboolean TP_FilterMessage (char *s); void TP_Init(void); char* TP_LocationName (vec3_t location); char* TP_MapName (void); void TP_NewMap (void); void TP_ParsePlayerInfo(player_state_t *oldstate, player_state_t *state, player_info_t *info); qboolean TP_IsPlayerVisible(vec3_t origin); char* TP_PlayerName (void); char* TP_PlayerTeam (void); void TP_SearchForMsgTriggers (char *s, int level); qboolean TP_SoundTrigger(char *message); void TP_StatChanged (int stat, int value); qboolean TP_SuppressMessage(char *buf); colourised_t *TP_FindColours(char *name); void TP_UpdateAutoStatus(void); // // skin.c // typedef struct { char manufacturer; char version; char encoding; char bits_per_pixel; unsigned short xmin,ymin,xmax,ymax; unsigned short hres,vres; unsigned char palette[48]; char reserved; char color_planes; unsigned short bytes_per_line; unsigned short palette_type; char filler[58]; // unsigned char data; // unbounded } pcx_t; qbyte *ReadPCXData(qbyte *buf, int length, int width, int height, qbyte *result); qwskin_t *Skin_Lookup (char *fullname); char *Skin_FindName (player_info_t *sc); void Skin_Find (player_info_t *sc); qbyte *Skin_Cache8 (qwskin_t *skin); void Skin_Skins_f (void); void Skin_FlushSkin(char *name); void Skin_AllSkins_f (void); void Skin_NextDownload (void); void Skin_FlushPlayers(void); void Skin_FlushAll(void); #define RSSHOT_WIDTH 320 #define RSSHOT_HEIGHT 200 //valid.c void RulesetLatch(cvar_t *cvar); void Validation_Apply_Ruleset(void); void Validation_FlushFileList(void); void Validation_CheckIfResponse(char *text); void Validation_DelatchRulesets(void); void InitValidation(void); void Validation_IncludeFile(char *filename, char *file, int filelen); void Validation_Auto_Response(int playernum, char *s); extern qboolean f_modified_particles; extern qboolean care_f_modified; //random files (fixme: clean up) #ifdef Q2CLIENT unsigned int CLQ2_GatherSounds(vec3_t *positions, unsigned int *entnums, sfx_t **sounds, unsigned int max); void CLQ2_ParseTEnt (void); void CLQ2_AddEntities (void); void CLQ2_ParseBaseline (void); void CLQ2_ClearParticleState(void); void CLR1Q2_ParsePlayerUpdate(void); void CLQ2_ParseFrame (int extrabits); void CLQ2_RunMuzzleFlash2 (int ent, int flash_number); int CLQ2_RegisterTEntModels (void); void CLQ2_WriteDemoBaselines(sizebuf_t *buf); #endif #ifdef HLCLIENT //networking void CLHL_LoadClientGame(void); int CLHL_ParseGamePacket(void); int CLHL_AnimateViewEntity(entity_t *ent); //screen int CLHL_DrawHud(void); //inputs int CLHL_GamecodeDoesMouse(void); int CLHL_MouseEvent(unsigned int buttonmask); void CLHL_SetMouseActive(int activate); int CLHL_BuildUserInput(int msecs, usercmd_t *cmd); #endif #ifdef NQPROT void CLNQ_ParseEntity(unsigned int bits); void NQ_P_ParseParticleEffect (void); void CLNQ_SignonReply (void); void NQ_BeginConnect(char *to); void NQ_ContinueConnect(char *to); int CLNQ_GetMessage (void); #endif void CL_BeginServerReconnect(void); void SV_User_f (void); //called by client version of the function void SV_Serverinfo_f (void); void SV_ConSay_f(void); #ifdef TEXTEDITOR extern console_t *editormodal; void Editor_Draw(void); void Editor_Init(void); struct pubprogfuncs_s; void Editor_ProgsKilled(struct pubprogfuncs_s *dead); #endif void SCR_StringToRGB (char *rgbstring, float *rgb, float rgbinputscale); struct model_s; void CL_AddVWeapModel(entity_t *player, struct model_s *model); typedef struct cin_s cin_t; #ifdef HAVE_MEDIA_DECODER /*q2 cinematics*/ struct cinematics_s; void CIN_StopCinematic (struct cinematics_s *cin); struct cinematics_s *CIN_PlayCinematic (char *arg); int CIN_RunCinematic (struct cinematics_s *cin, float playbacktime, qbyte **outdata, int *outwidth, int *outheight, qbyte **outpalette); void CIN_Rewind(struct cinematics_s *cin); typedef enum { CINSTATE_INVALID, //also reported for not playing CINSTATE_PLAY, CINSTATE_LOOP, CINSTATE_PAUSE, CINSTATE_ENDED, CINSTATE_FLUSHED, //video will restart from beginning } cinstates_t; /*media playing system*/ qboolean Media_PlayingFullScreen(void); qboolean Media_PlayFilm(char *name, qboolean enqueue); qboolean Media_StopFilm(qboolean all); struct cin_s *Media_StartCin(char *name); texid_tf Media_UpdateForShader(cin_t *cin); void Media_ShutdownCin(cin_t *cin); //these accept NULL for cin to mean the current fullscreen video void Media_Send_Command(cin_t *cin, const char *command); void Media_Send_MouseMove(cin_t *cin, float x, float y); void Media_Send_Resize(cin_t *cin, int x, int y); void Media_Send_GetSize(cin_t *cin, int *x, int *y, float *aspect); void Media_Send_KeyEvent(cin_t *cin, int button, int unicode, int event); void Media_Send_Reset(cin_t *cin); void Media_SetState(cin_t *cin, cinstates_t newstate); cinstates_t Media_GetState(cin_t *cin); const char *Media_Send_GetProperty(cin_t *cin, const char *key); #else #define Media_Playing() false #define Media_PlayingFullScreen() false #define Media_PlayFilm(n,e) false #define Media_StopFilm(a) (void)true #endif void Media_Init(void); qboolean Media_NamedTrack(const char *initialtrack, const char *looptrack); //new background music interface void Media_NumberedTrack(unsigned int initialtrack, unsigned int looptrack); //legacy cd interface for protocols that only support numbered tracks. void Media_EndedTrack(void); //cd is no longer running, media code needs to pick a new track (cd track or faketrack) void MVD_Interpolate(void); int Stats_GetKills(int playernum); int Stats_GetTKills(int playernum); int Stats_GetDeaths(int playernum); int Stats_GetTouches(int playernum); int Stats_GetCaptures(int playernum); qboolean Stats_HaveFlags(int mode); qboolean Stats_HaveKills(void); float Stats_GetLastOwnFrag(int seat, char *res, int reslen); void VARGS Stats_Message(char *msg, ...) LIKEPRINTF(1); qboolean Stats_ParsePrintLine(const char *line); qboolean Stats_ParsePickups(const char *line); void Stats_NewMap(void); void Stats_Clear(void); void Stats_Init(void); enum uploadfmt; typedef struct { size_t structsize; const char *drivername; void *(VARGS *createdecoder)(const char *name); qboolean (VARGS *decodeframe)(void *ctx, qboolean nosound, qboolean forcevideo, double mediatime, void (QDECL *uploadtexture)(void *ectx, uploadfmt_t fmt, int width, int height, void *data, void *palette), void *ectx); void (VARGS *shutdown)(void *ctx); void (VARGS *rewind)(void *ctx); //these are any interactivity functions you might want... void (VARGS *cursormove) (void *ctx, float posx, float posy); //pos is 0-1 void (VARGS *key) (void *ctx, int code, int unicode, int event); qboolean (VARGS *setsize) (void *ctx, int width, int height); void (VARGS *getsize) (void *ctx, int *width, int *height); void (VARGS *changestream) (void *ctx, const char *streamname); qboolean (VARGS *getproperty) (void *ctx, const char *field, char *out, size_t *outsize); //if out is null, returns required buffer size. returns 0 on failure / buffer too small } media_decoder_funcs_t; typedef struct { size_t structsize; const char *drivername; const char *description; const char *defaultextension; void *(VARGS *capture_begin) (char *streamname, int videorate, int width, int height, int *sndkhz, int *sndchannels, int *sndbits); void (VARGS *capture_video) (void *ctx, int frame, void *data, int stride, int width, int height, enum uploadfmt fmt); void (VARGS *capture_audio) (void *ctx, void *data, int bytes); void (VARGS *capture_end) (void *ctx); } media_encoder_funcs_t; extern struct plugin_s *currentplug; qboolean Media_RegisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs); qboolean Media_UnregisterDecoder(struct plugin_s *plug, media_decoder_funcs_t *funcs); qboolean Media_RegisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs); qboolean Media_UnregisterEncoder(struct plugin_s *plug, media_encoder_funcs_t *funcs);