#define CLIENT_H
#include "matrixlib.h"
-
-// LordHavoc: 256 dynamic lights
-#define MAX_DLIGHTS 256
+#include "snd_main.h"
+#include "view.h"
+#include "cap.h"
+#include "cl_parse.h"
+#include "cl_particles.h"
+#include "r_stats.h"
// flags for rtlight rendering
#define LIGHTFLAG_NORMALMODE 1
#define LIGHTFLAG_REALTIMEMODE 2
+typedef struct tridecal_s
+{
+ // color and initial alpha value
+ float texcoord2f[3][2];
+ float vertex3f[3][3];
+ float color4f[3][4];
+ float plane[4]; // backface culling
+ // how long this decal has lived so far (the actual fade begins at cl_decals_time)
+ float lived;
+ // if >= 0 this indicates the decal should follow an animated triangle
+ int triangleindex;
+ // for visibility culling
+ int surfaceindex;
+ // old decals are killed to obey cl_decals_max
+ unsigned int decalsequence;
+}
+tridecal_t;
+
+typedef struct decalsystem_s
+{
+ model_t *model;
+ double lastupdatetime;
+ int maxdecals;
+ int freedecal;
+ int numdecals;
+ tridecal_t *decals;
+ float *vertex3f;
+ float *texcoord2f;
+ float *color4f;
+ int *element3i;
+ unsigned short *element3s;
+}
+decalsystem_t;
+
typedef struct effect_s
{
int active;
vec3_t origin;
- float starttime;
+ double starttime;
float framerate;
- int modelindex;
+ model_t *model;
int startframe;
int endframe;
// these are for interpolation
}
beam_t;
-typedef struct rtlight_s
+typedef struct rtlight_particle_s
{
- // shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin
+ float origin[3];
+ float color[3];
+}
+rtlight_particle_t;
+typedef struct rtlight_s
+{
// note that the world to light matrices are inversely scaled (divided) by lightradius
// core properties
- // matrix for transforming world coordinates to light filter coordinates
+ /// matrix for transforming light filter coordinates to world coordinates
+ matrix4x4_t matrix_lighttoworld;
+ /// matrix for transforming world coordinates to light filter coordinates
matrix4x4_t matrix_worldtolight;
- // typically 1 1 1, can be lower (dim) or higher (overbright)
+ /// typically 1 1 1, can be lower (dim) or higher (overbright)
vec3_t color;
- // size of the light (remove?)
+ /// size of the light (remove?)
vec_t radius;
- // light filter
+ /// light filter
char cubemapname[64];
- // light style to monitor for brightness
+ /// light style to monitor for brightness
int style;
- // whether light should render shadows
+ /// whether light should render shadows (see castshadows for whether it actually does this frame)
int shadow;
- // intensity of corona to render
+ /// intensity of corona to render
vec_t corona;
- // radius scale of corona to render (1.0 means same as light radius)
+ /// radius scale of corona to render (1.0 means same as light radius)
vec_t coronasizescale;
- // ambient intensity to render
+ /// ambient intensity to render
vec_t ambientscale;
- // diffuse intensity to render
+ /// diffuse intensity to render
vec_t diffusescale;
- // specular intensity to render
+ /// specular intensity to render
vec_t specularscale;
- // LIGHTFLAG_* flags
+ /// LIGHTFLAG_* flags
int flags;
// generated properties
- // used only for shadow volumes
+ /// used only for casting shadows
vec3_t shadoworigin;
- // culling
+ /// culling
vec3_t cullmins;
vec3_t cullmaxs;
- // culling
- //vec_t cullradius;
- // squared cullradius
- //vec_t cullradius2;
+ /// when r_shadow_culllights_trace is set, this is refreshed by each successful trace.
+ double trace_timer;
// rendering properties, updated each time a light is rendered
// this is rtlight->color * d_lightstylevalue
vec3_t currentcolor;
- // this is R_Shadow_Cubemap(rtlight->cubemapname)
+ /// used by corona updates, due to occlusion query
+ float corona_visibility;
+ unsigned int corona_queryindex_visiblepixels;
+ unsigned int corona_queryindex_allpixels;
+ /// this is R_GetCubemap(rtlight->cubemapname)
rtexture_t *currentcubemap;
-
- // static light info
- // true if this light should be compiled as a static light
+ /// set by R_Shadow_PrepareLight to decide whether R_Shadow_DrawLight should draw it
+ qbool draw;
+ /// set by R_Shadow_PrepareLight to indicate whether R_Shadow_DrawShadowMaps should do anything
+ qbool castshadows;
+ /// these fields are set by R_Shadow_PrepareLight for later drawing
+ int cached_numlightentities;
+ int cached_numlightentities_noselfshadow;
+ int cached_numshadowentities;
+ int cached_numshadowentities_noselfshadow;
+ int cached_numsurfaces;
+ struct entity_render_s **cached_lightentities;
+ struct entity_render_s **cached_lightentities_noselfshadow;
+ struct entity_render_s **cached_shadowentities;
+ struct entity_render_s **cached_shadowentities_noselfshadow;
+ unsigned char *cached_shadowtrispvs;
+ unsigned char *cached_lighttrispvs;
+ int *cached_surfacelist;
+ // reduced light cullbox from GetLightInfo
+ vec3_t cached_cullmins;
+ vec3_t cached_cullmaxs;
+ // current shadow-caster culling planes based on view
+ // (any geometry outside these planes can not contribute to the visible
+ // shadows in any way, and thus can be culled safely)
+ int cached_numfrustumplanes;
+ mplane_t cached_frustumplanes[5]; // see R_Shadow_ComputeShadowCasterCullingPlanes
+
+ /// static light info
+ /// true if this light should be compiled as a static light
int isstatic;
- // true if this is a compiled world light, cleared if the light changes
+ /// true if this is a compiled world light, cleared if the light changes
int compiled;
- // premade shadow volumes to render for world entity
- shadowmesh_t *static_meshchain_shadow;
- // used for visibility testing (more exact than bbox)
+ /// the size that this light should have (assuming no scene LOD kicking in to reduce it)
+ int shadowmapsidesize;
+ /// position of this light in the shadowmap atlas
+ int shadowmapatlasposition[2];
+ /// size of one side of this light in the shadowmap atlas (for omnidirectional shadowmaps this is the min corner of a 2x3 arrangement, or a 4x3 arrangement in the case of noselfshadow entities being present)
+ int shadowmapatlassidesize;
+ /// optimized and culled mesh to render for world entity shadows
+ shadowmesh_t *static_meshchain_shadow_shadowmap;
+ /// used for visibility testing (more exact than bbox)
int static_numleafs;
int static_numleafpvsbytes;
int *static_leaflist;
unsigned char *static_leafpvs;
- // surfaces seen by light
+ /// surfaces seen by light
int static_numsurfaces;
int *static_surfacelist;
+ /// flag bits indicating which triangles of the world model should cast
+ /// shadows, and which ones should be lit
+ ///
+ /// this avoids redundantly scanning the triangles in each surface twice
+ /// for whether they should cast shadows, once in culling and once in the
+ /// actual shadowmarklist production.
+ int static_numshadowtrispvsbytes;
+ unsigned char *static_shadowtrispvs;
+ /// this allows the lighting batch code to skip backfaces andother culled
+ /// triangles not relevant for lighting
+ /// (important on big surfaces such as terrain)
+ int static_numlighttrispvsbytes;
+ unsigned char *static_lighttrispvs;
+ /// masks of all shadowmap sides that have any potential static receivers or casters
+ int static_shadowmap_receivers;
+ int static_shadowmap_casters;
+ /// particle-tracing cache for global illumination
+ int particlecache_numparticles;
+ int particlecache_maxparticles;
+ int particlecache_updateparticle;
+ rtlight_particle_t *particlecache_particles;
+
+ /// bouncegrid light info
+ float bouncegrid_photoncolor[3];
+ float bouncegrid_photons;
+ int bouncegrid_hits;
+ int bouncegrid_traces;
+ float bouncegrid_effectiveradius;
}
rtlight_t;
// color of light
// (worldlight: saved to .rtlights file)
vec3_t color;
- // cubemap number to use on this light
- // (dlight only)
- int cubemapnum;
// cubemap name to use on this light
- // (worldlight only)
// (worldlight: saved to .rtlights file)
char cubemapname[64];
// make light flash while selected
// brightness (not really radius anymore)
// (worldlight: saved to .rtlights file)
vec_t radius;
- // drop radius this much each second
+ // drop intensity this much each second
// (dlight only)
vec_t decay;
+ // intensity value which is dropped over time
+ // (dlight only)
+ vec_t intensity;
+ // initial values for intensity to modify
+ // (dlight only)
+ vec_t initialradius;
+ vec3_t initialcolor;
// light style which controls intensity of this light
// (worldlight: saved to .rtlights file)
int style;
// (worldlight only)
struct dlight_s *next;
// embedded rtlight struct for renderer
- // (renderer only)
+ // (worldlight only)
rtlight_t rtlight;
}
dlight_t;
+// this is derived from processing of the framegroupblend array
+// note: technically each framegroupblend can produce two of these, but that
+// never happens in practice because no one blends between more than 2
+// framegroups at once
+#define MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)
typedef struct frameblend_s
{
- int frame;
+ int subframe;
float lerp;
}
frameblend_t;
-// LordHavoc: this struct is intended for the renderer but some fields are
+// LadyHavoc: this struct is intended for the renderer but some fields are
// used by the client.
+//
+// The renderer should not rely on any changes to this struct to be persistent
+// across multiple frames because temp entities are wiped every frame, but it
+// is acceptable to cache things in this struct that are not critical.
+//
+// For example the r_cullentities_trace code does such caching.
typedef struct entity_render_s
{
// location
- vec3_t origin;
+ //vec3_t origin;
// orientation
- vec3_t angles;
+ //vec3_t angles;
// transform matrix for model to world
matrix4x4_t matrix;
// transform matrix for world to model
float alpha;
// size the model is shown
float scale;
+ // transparent sorting offset
+ float transparent_offset;
// NULL = no model
model_t *model;
- // current uninterpolated animation frame (for things which do not use interpolation)
- int frame;
- // entity shirt and pants colors (-1 if not colormapped)
- int colormap;
- // literal colors for renderer
+ // number of the entity represents, or 0 for non-network entities
+ int entitynumber;
+ // literal colormap colors for renderer, if both are 0 0 0 it is not colormapped
vec3_t colormap_pantscolor;
vec3_t colormap_shirtcolor;
// light, particles, etc
int effects;
+ // qw CTF flags and other internal-use-only effect bits
+ int internaleffects;
// for Alias models
int skinnum;
// render flags
// colormod tinting of models
float colormod[3];
+ float glowmod[3];
- // interpolated animation
+ // interpolated animation - active framegroups and blend factors
+ framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
- // frame that the model is interpolating from
- int frame1;
- // frame that the model is interpolating to
- int frame2;
- // interpolation factor, usually computed from frame2time
- float framelerp;
- // time frame1 began playing (for framegroup animations)
- double frame1time;
- // time frame2 began playing (for framegroup animations)
- double frame2time;
+ // time of last model change (for shader animations)
+ double shadertime;
// calculated by the renderer (but not persistent)
// calculated during R_AddModelEntities
vec3_t mins, maxs;
- // 4 frame numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use frame instead
- frameblend_t frameblend[4];
-
- // current lighting from map
- vec3_t modellight_ambient;
- vec3_t modellight_diffuse; // q3bsp
- vec3_t modellight_lightdir; // q3bsp
+ // subframe numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use subframeblend[0].subframe
+ frameblend_t frameblend[MAX_FRAMEBLENDS];
+ // skeletal animation data (if skeleton.relativetransforms is not NULL, it overrides frameblend)
+ skeleton_t *skeleton;
+
+ // animation cache (pointers allocated using R_FrameData_Alloc)
+ // ONLY valid during R_RenderView! may be NULL (not cached)
+ float *animcache_vertex3f;
+ r_meshbuffer_t *animcache_vertex3f_vertexbuffer;
+ int animcache_vertex3f_bufferoffset;
+ float *animcache_normal3f;
+ r_meshbuffer_t *animcache_normal3f_vertexbuffer;
+ int animcache_normal3f_bufferoffset;
+ float *animcache_svector3f;
+ r_meshbuffer_t *animcache_svector3f_vertexbuffer;
+ int animcache_svector3f_bufferoffset;
+ float *animcache_tvector3f;
+ r_meshbuffer_t *animcache_tvector3f_vertexbuffer;
+ int animcache_tvector3f_bufferoffset;
+ // gpu-skinning shader needs transforms in a certain format, we have to
+ // upload this to a uniform buffer for the shader to use, and also keep a
+ // backup copy in system memory for the dynamic batch fallback code
+ // if this is not NULL, the other animcache variables are NULL
+ float *animcache_skeletaltransform3x4;
+ r_meshbuffer_t *animcache_skeletaltransform3x4buffer;
+ int animcache_skeletaltransform3x4offset;
+ int animcache_skeletaltransform3x4size;
+
+ // CL_UpdateEntityShading reads these fields
+ // used only if RENDER_CUSTOMIZEDMODELLIGHT is set
+ vec3_t custommodellight_ambient;
+ vec3_t custommodellight_diffuse;
+ vec3_t custommodellight_lightdir;
+ // CSQC entities get their shading from the root of their attachment chain
+ float custommodellight_origin[3];
+
+ // derived lighting parameters (CL_UpdateEntityShading)
+
+ // used by MATERIALFLAG_FULLBRIGHT which is MATERIALFLAG_MODELLIGHT with
+ // this as ambient color, along with MATERIALFLAG_NORTLIGHT
+ float render_fullbright[3];
+ // color tint for the base pass glow textures if any
+ float render_glowmod[3];
+ // MATERIALFLAG_MODELLIGHT uses these parameters
+ float render_modellight_ambient[3];
+ float render_modellight_diffuse[3];
+ float render_modellight_lightdir_world[3];
+ float render_modellight_lightdir_local[3];
+ float render_modellight_specular[3];
+ // lightmap rendering (not MATERIALFLAG_MODELLIGHT)
+ float render_lightmap_ambient[3];
+ float render_lightmap_diffuse[3];
+ float render_lightmap_specular[3];
+ // rtlights use these colors for the materials on this entity
+ float render_rtlight_diffuse[3];
+ float render_rtlight_specular[3];
+ // ignore lightmap and use fixed lighting settings on this entity (e.g. FULLBRIGHT)
+ qbool render_modellight_forced;
+ // do not process per pixel lights on this entity at all (like MATERIALFLAG_NORTLIGHT)
+ qbool render_rtlight_disabled;
+ // use the 3D lightmap from q3bsp on this entity
+ qbool render_lightgrid;
+
+ // storage of decals on this entity
+ // (note: if allowdecals is set, be sure to call R_DecalSystem_Reset on removal!)
+ int allowdecals;
+ decalsystem_t decalsystem;
+
+ // FIELDS UPDATED BY RENDERER:
+ // last time visible during trace culling
+ double last_trace_visibility;
+
+ // user wavefunc parameters (from csqc)
+ vec_t userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
}
entity_render_t;
typedef struct entity_persistent_s
{
- int linkframe;
-
- vec3_t trail_origin;
-
- // particle trail
- float trail_time;
-
- // muzzleflash fading
- float muzzleflash;
-
- // interpolated movement
-
- // start time of move
- float lerpstarttime;
- // time difference from start to end of move
- float lerpdeltatime;
- // the move itself, start and end
- float oldorigin[3];
- float oldangles[3];
- float neworigin[3];
- float newangles[3];
+ vec3_t trail_origin; // previous position for particle trail spawning
+ vec3_t oldorigin; // lerp
+ vec3_t oldangles; // lerp
+ vec3_t neworigin; // lerp
+ vec3_t newangles; // lerp
+ vec_t lerpstarttime; // lerp
+ vec_t lerpdeltatime; // lerp
+ float muzzleflash; // muzzleflash intensity, fades over time
+ float trail_time; // residual error accumulation for particle trail spawning (to keep spacing across frames)
+ qbool trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
}
entity_persistent_t;
typedef struct entity_s
{
- qboolean csqc;
// baseline state (default values)
entity_state_t state_baseline;
// previous state (interpolating from this)
}
entity_t;
-typedef struct usercmd_s
-{
- vec3_t viewangles;
-
-// intended velocities
- float forwardmove;
- float sidemove;
- float upmove;
-
- vec3_t cursor_screen;
- vec3_t cursor_start;
- vec3_t cursor_end;
- vec3_t cursor_impact;
- vec3_t cursor_normal;
- vec_t cursor_fraction;
- int cursor_entitynumber;
-
- double time;
- double receivetime;
- int buttons;
- int impulse;
- int sequence;
- qboolean applied; // if false we're still accumulating a move
-} usercmd_t;
-
typedef struct lightstyle_s
{
int length;
float qw_entertime;
int qw_ping;
int qw_packetloss;
+ int qw_movementloss;
int qw_spectator;
char qw_team[8];
char qw_skin[MAX_QPATH];
typedef struct cshift_s
{
float destcolor[3];
- float percent; // 0-256
+ float percent; // 0-255
+ float alphafade; // (any speed)
} cshift_t;
#define CSHIFT_CONTENTS 0
#define SIGNONS 4 // signon messages to receive before connected
-#define MAX_DEMOS 8
-#define MAX_DEMONAME 16
-
typedef enum cactive_e
{
+ ca_uninitialized, // during early startup
ca_dedicated, // a dedicated server with no ability to start a client
ca_disconnected, // full screen console with no connection
ca_connected // valid netcon, talking to a server
}
qw_downloadtype_t;
-typedef enum capturevideoformat_e
+#define CL_MAX_DOWNLOADACKS 4
+
+typedef struct cl_downloadack_s
+{
+ int start, size;
+}
+cl_downloadack_t;
+
+typedef struct cl_soundstats_s
{
- CAPTUREVIDEOFORMAT_TARGA,
- CAPTUREVIDEOFORMAT_JPEG,
- CAPTUREVIDEOFORMAT_RAWRGB,
- CAPTUREVIDEOFORMAT_RAWYV12
+ int mixedsounds;
+ int totalsounds;
+ int latency_milliseconds;
}
-capturevideoformat_t;
+cl_soundstats_t;
//
// the client_static_t structure is persistent through an arbitrary number
int demonum;
// list of demos in loop
char demos[MAX_DEMOS][MAX_DEMONAME];
- // the actively playing demo (set by CL_PlayDemo_f)
- char demoname[64];
+ // the actively playing demo (set by CL_PlayDemo)
+ char demoname[MAX_QPATH];
// demo recording info must be here, because record is started before
// entering a map (and clearing client_state_t)
- qboolean demorecording;
- qboolean demoplayback;
- qboolean timedemo;
+ qbool demorecording;
+ fs_offset_t demo_lastcsprogssize;
+ int demo_lastcsprogscrc;
+ qbool demoplayback;
+ qbool demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
+ qbool timedemo;
// -1 = use normal cd track
int forcetrack;
qfile_t *demofile;
- // to meter out one message a frame
- int td_lastframe;
- // host_framecount at start
- int td_startframe;
- // realtime at second frame of timedemo (LordHavoc: changed to double)
+ // realtime at second frame of timedemo (LadyHavoc: changed to double)
double td_starttime;
- // LordHavoc: for measuring maxfps
- double td_minframetime;
- // LordHavoc: for measuring minfps
- double td_maxframetime;
- // LordHavoc: pausedemo
- qboolean demopaused;
-
- qboolean connect_trying;
+ int td_frames; // total frames parsed
+ double td_onesecondnexttime;
+ double td_onesecondframes;
+ double td_onesecondrealtime;
+ double td_onesecondminfps;
+ double td_onesecondmaxfps;
+ double td_onesecondavgfps;
+ int td_onesecondavgcount;
+ // LadyHavoc: pausedemo
+ qbool demopaused;
+
+ // sound mixer statistics for showsound display
+ cl_soundstats_t soundstats;
+
+ qbool connect_trying;
int connect_remainingtries;
double connect_nextsendtime;
lhnetsocket_t *connect_mysocket;
lhnetaddress_t connect_address;
+ lhnetaddress_t rcon_address;
// protocol version of the server we're connected to
// (kept outside client_state_t because it's used between levels)
protocolversion_t protocol;
+#define MAX_RCONS 16
+ int rcon_trying;
+ lhnetaddress_t rcon_addresses[MAX_RCONS];
+ char rcon_commands[MAX_RCONS][MAX_INPUTLINE];
+ double rcon_timeout[MAX_RCONS];
+ int rcon_ringpos;
+
// connection information
// 0 to SIGNONS
int signon;
// network connection
netconn_t *netcon;
+ // download information
+ // (note: qw_download variables are also used)
+ cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
+
+ // input sequence numbers are not reset on level change, only connect
+ unsigned int servermovesequence;
+
// quakeworld stuff below
// value of "qport" cvar at time of connection
int qw_qport;
// copied from cls.netcon->qw. variables every time they change, or set by demos (which have no cls.netcon)
- int qw_incoming_sequence;
- int qw_outgoing_sequence;
+ unsigned int qw_incoming_sequence;
+ unsigned int qw_outgoing_sequence;
// current file download buffer (only saved when file is completed)
char qw_downloadname[MAX_QPATH];
int qw_downloadnumber;
int qw_downloadpercent;
qw_downloadtype_t qw_downloadtype;
+ // transfer rate display
+ double qw_downloadspeedtime;
+ int qw_downloadspeedcount;
+ int qw_downloadspeedrate;
+ qbool qw_download_deflate;
// current file upload buffer (for uploading screenshots to server)
unsigned char *qw_uploaddata;
// password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
char userinfo[MAX_USERINFO_STRING];
- // video capture stuff
- qboolean capturevideo_active;
- capturevideoformat_t capturevideo_format;
- double capturevideo_starttime;
- double capturevideo_framerate;
- int capturevideo_soundrate;
- int capturevideo_frame;
- unsigned char *capturevideo_buffer;
- qfile_t *capturevideo_videofile;
- qfile_t *capturevideo_soundfile;
- short capturevideo_rgbtoyuvscaletable[3][3][256];
- unsigned char capturevideo_yuvnormalizetable[3][256];
- char capturevideo_basename[64];
-}
-client_static_t;
-
-extern client_static_t cls;
+ // extra user info for the "connect" command
+ char connect_userinfo[MAX_USERINFO_STRING];
-typedef struct client_movementqueue_s
-{
- double time;
- float frametime;
- int sequence;
- float viewangles[3];
- float move[3];
- qboolean jump;
- qboolean crouch;
-}
-client_movementqueue_t;
+#ifdef CONFIG_VIDEO_CAPTURE
+ // video capture stuff
+ capturevideostate_t capturevideo;
+#endif
-//[515]: csqc
-typedef struct
-{
- qboolean drawworld;
- qboolean drawenginesbar;
- qboolean drawcrosshair;
-}csqc_vidvars_t;
+ // crypto channel
+ crypto_t crypto;
-typedef struct qw_usercmd_s
-{
- vec3_t angles;
- short forwardmove, sidemove, upmove;
- unsigned char padding1[2];
- unsigned char msec;
- unsigned char buttons;
- unsigned char impulse;
- unsigned char padding2;
-}
-qw_usercmd_t;
+ // ProQuake compatibility stuff
+ int proquake_servermod; // 0 = not proquake, 1 = proquake
+ int proquake_serverversion; // actual proquake server version * 10 (3.40 = 34, etc)
+ int proquake_serverflags; // 0 (PQF_CHEATFREE not supported)
-typedef enum
-{
- PARTICLE_BILLBOARD = 0,
- PARTICLE_SPARK = 1,
- PARTICLE_ORIENTED_DOUBLESIDED = 2,
- PARTICLE_BEAM = 3
-}
-porientation_t;
+ // don't write-then-read csprogs.dat (useful for demo playback)
+ unsigned char *caughtcsprogsdata;
+ fs_offset_t caughtcsprogsdatasize;
-typedef enum
-{
- PBLEND_ALPHA = 0,
- PBLEND_ADD = 1,
- PBLEND_MOD = 2
-}
-pblend_t;
+ int r_speeds_graph_length;
+ int r_speeds_graph_current;
+ int *r_speeds_graph_data;
-typedef struct particletype_s
-{
- pblend_t blendmode;
- porientation_t orientation;
- qboolean lighting;
+ // graph scales
+ int r_speeds_graph_datamin[r_stat_count];
+ int r_speeds_graph_datamax[r_stat_count];
}
-particletype_t;
+client_static_t;
-typedef enum
-{
- pt_alphastatic, pt_static, pt_spark, pt_beam, pt_rain, pt_raindecal, pt_snow, pt_bubble, pt_blood, pt_smoke, pt_decal, pt_entityparticle, pt_total
-}
-ptype_t;
+extern client_static_t cls;
-typedef struct particle_s
+//[515]: csqc
+typedef struct
{
- particletype_t *type;
- int texnum;
- vec3_t org;
- vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam
- float size;
- float sizeincrease; // rate of size change per second
- float alpha; // 0-255
- float alphafade; // how much alpha reduces per second
- float time2; // used for snow fluttering and decal fade
- float bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical)
- float gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
- float airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
- float liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction)
- unsigned char color[4];
- unsigned short owner; // decal stuck to this entity
- model_t *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
- vec3_t relativeorigin; // decal at this location in entity's coordinate space
- vec3_t relativedirection; // decal oriented this way relative to entity's coordinate space
-}
-particle_t;
+ qbool drawworld;
+ qbool drawenginesbar;
+ qbool drawcrosshair;
+}csqc_vidvars_t;
typedef enum cl_parsingtextmode_e
{
}
cl_parsingtextmode_t;
+typedef struct cl_locnode_s
+{
+ struct cl_locnode_s *next;
+ char *name;
+ vec3_t mins, maxs;
+}
+cl_locnode_t;
+
+typedef struct showlmp_s
+{
+ qbool isactive;
+ float x;
+ float y;
+ char label[32];
+ char pic[128];
+}
+showlmp_t;
+
//
// the client_state_t structure is wiped completely at every
// server signon
// true if playing in a local game and no one else is connected
int islocalgame;
- // when connecting to the server throw out the first couple move messages
- // so the player doesn't accidentally do something the first frame
- int movemessages;
-
// send a clc_nop periodically until connected
float sendnoptime;
- // current input to send to the server
+ // current input being accumulated by mouse/joystick/etc input
usercmd_t cmd;
+ // latest moves sent to the server that have not been confirmed yet
+ usercmd_t movecmd[CL_MAX_USERCMDS];
// information for local display
// health, etc
int stats[MAX_CL_STATS];
+ float *statsf; // points to stats[] array
// last known inventory bit flags, for blinking
int olditems;
// cl.time of acquiring item, for blinking
// use pain anim frame if cl.time < this
float faceanimtime;
// for stair smoothing
- float stairoffset;
+ float stairsmoothz;
+ double stairsmoothtime;
// color shifts for damage, powerups
cshift_t cshifts[NUM_CSHIFTS];
// this is used primarily by teleporters, and when spectating players
// special checking of the old fixangle[1] is used to differentiate
// between teleporting and spectating
- qboolean fixangle[2];
+ qbool fixangle[2];
// client movement simulation
// these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
// set by CL_ClientMovement_Replay functions
- qboolean movement_predicted;
- // this is set true by svc_time parsing and causes a new movement to be
- // queued for prediction purposes
- qboolean movement_needupdate;
- // indicates the queue has been updated and should be replayed
- qboolean movement_replay;
- // timestamps of latest two predicted moves for interpolation
- double movement_time[2];
+ qbool movement_predicted;
+ // if true the CL_ClientMovement_Replay function will update origin, etc
+ qbool movement_replay;
// simulated data (this is valid even if cl.movement is false)
vec3_t movement_origin;
- vec3_t movement_oldorigin;
vec3_t movement_velocity;
- // queue of proposed moves
- int movement_numqueue;
- client_movementqueue_t movement_queue[256];
- int movesequence;
- int servermovesequence;
// whether the replay should allow a jump at the first sequence
- qboolean movement_replay_canjump;
+ qbool movement_replay_canjump;
+
+ // previous gun angles (for leaning effects)
+ vec3_t gunangles_prev;
+ vec3_t gunangles_highpass;
+ vec3_t gunangles_adjustment_lowpass;
+ vec3_t gunangles_adjustment_highpass;
+ // previous gun angles (for leaning effects)
+ vec3_t gunorg_prev;
+ vec3_t gunorg_highpass;
+ vec3_t gunorg_adjustment_lowpass;
+ vec3_t gunorg_adjustment_highpass;
// pitch drifting vars
float idealpitch;
float pitchvel;
- qboolean nodrift;
+ qbool nodrift;
float driftmove;
double laststop;
//[515]: added for csqc purposes
float sensitivityscale;
csqc_vidvars_t csqc_vidvars; //[515]: these parms must be set to true by default
- qboolean csqc_wantsmousemove;
+ qbool csqc_wantsmousemove;
struct model_s *csqc_model_precache[MAX_MODELS];
// local amount for smoothing stepups
//float crouch;
// sent by server
- qboolean paused;
- qboolean onground;
- qboolean inwater;
+ qbool paused;
+ qbool onground;
+ qbool inwater;
// used by bob
- qboolean oldonground;
+ qbool oldonground;
double lastongroundtime;
double hitgroundtime;
+ float bob2_smooth;
+ float bobfall_speed;
+ float bobfall_swing;
+ double calcrefdef_prevtime;
// don't change view angle, full screen, etc
int intermission;
// clients view of time, time should be between mtime[0] and mtime[1] to
// generate a lerp point for other data, oldtime is the previous frame's
// value of time, frametime is the difference between time and oldtime
+ // note: cl.time may be beyond cl.mtime[0] if packet loss is occuring, it
+ // is only forcefully limited when a packet is received
double time, oldtime;
// how long it has been since the previous client frame in real time
// (not game time, for that use cl.time - cl.oldtime)
double realframetime;
+ // used by cl_nettimesyncboundmode 7
+#define NUM_TS_ERRORS 32 // max 256
+ unsigned char ts_error_num;
+ float ts_error_stor[NUM_TS_ERRORS];
+
+ // fade var for fading while dead
+ float deathfade;
+
+ // motionblur alpha level variable
+ float motionbluralpha;
+
// copy of realtime from last recieved message, for net trouble icon
float last_received_message;
char sound_name[MAX_SOUNDS][MAX_QPATH];
// for display on solo scoreboard
- char levelname[40];
+ char worldmessage[40]; // map title (not related to filename)
+ // variants of map name
+ char worldbasename[MAX_QPATH]; // %s
+ char worldname[MAX_QPATH]; // maps/%s.bsp
+ char worldnamenoextension[MAX_QPATH]; // maps/%s
// cl_entitites[cl.viewentity] = player
int viewentity;
// the real player entity (normally same as viewentity,
// different than viewentity if mod uses chasecam or other tricks)
+ int realplayerentity;
+ // this is updated to match cl.viewentity whenever it is in the clients
+ // range, basically this is used in preference to cl.realplayerentity for
+ // most purposes because when spectating another player it should show
+ // their information rather than yours
int playerentity;
// max players that can be in this game
int maxclients;
sfx_t *sfx_ric2;
sfx_t *sfx_ric3;
sfx_t *sfx_r_exp3;
+ // indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages)
+ qbool foundteamchatsound;
// refresh related state
// manually, but they would still see a ping report, just a later one
// caused by the scoreboard code rather than the one they intentionally
// issued)
- qboolean parsingtextexpectingpingforscores;
+ int parsingtextexpectingpingforscores;
// entity database stuff
// latest received entity frame numbers
-#define LATESTFRAMENUMS 3
+#define LATESTFRAMENUMS 32
+ int latestframenumsposition;
int latestframenums[LATESTFRAMENUMS];
+ unsigned int latestsendnums[LATESTFRAMENUMS];
entityframe_database_t *entitydatabase;
entityframe4_database_t *entitydatabase4;
entityframeqw_database_t *entitydatabaseqw;
vec3_t playercrouchmins;
vec3_t playercrouchmaxs;
+ // old decals are killed based on this
+ unsigned int decalsequence;
+
int max_entities;
- int max_csqcentities;
+ int max_csqcrenderentities;
int max_static_entities;
- int max_temp_entities;
int max_effects;
int max_beams;
int max_dlights;
int max_lightstyle;
int max_brushmodel_entities;
int max_particles;
+ int max_showlmps;
entity_t *entities;
- entity_t *csqcentities; //[515]: csqc
+ entity_render_t *csqcrenderentities;
unsigned char *entities_active;
- unsigned char *csqcentities_active; //[515]: csqc
entity_t *static_entities;
- entity_t *temp_entities;
cl_effect_t *effects;
beam_t *beams;
dlight_t *dlights;
lightstyle_t *lightstyle;
int *brushmodel_entities;
particle_t *particles;
+ showlmp_t *showlmps;
int num_entities;
- int num_csqcentities; //[515]: csqc
int num_static_entities;
- int num_temp_entities;
int num_brushmodel_entities;
int num_effects;
int num_beams;
int num_dlights;
int num_particles;
+ int num_decals;
+ int num_showlmps;
+ double particles_updatetime;
+ double decals_updatetime;
int free_particle;
+ int free_decal;
+
+ // cl_serverextension_download feature
+ int loadmodel_current;
+ int downloadmodel_current;
+ int loadmodel_total;
+ int loadsound_current;
+ int downloadsound_current;
+ int loadsound_total;
+ qbool downloadcsqc;
+ qbool loadcsqc;
+ qbool loadbegun;
+ qbool loadfinished;
// quakeworld stuff
// updated from serverinfo
int qw_teamplay;
- // indicates whether the player is spectating
- qboolean qw_spectator;
+ // unused: indicates whether the player is spectating
+ // use cl.scores[cl.playerentity-1].qw_spectator instead
+ //qbool qw_spectator;
+
+ // time accumulated since an input packet was sent
+ float timesincepacket;
// movement parameters for client prediction
- float qw_movevars_gravity;
- float qw_movevars_stopspeed;
- float qw_movevars_maxspeed; // can change during play
- float qw_movevars_spectatormaxspeed;
- float qw_movevars_accelerate;
- float qw_movevars_airaccelerate;
- float qw_movevars_wateraccelerate;
- float qw_movevars_friction;
- float qw_movevars_waterfriction;
- float qw_movevars_entgravity; // can change during play
+ unsigned int moveflags;
+ float movevars_wallfriction;
+ float movevars_waterfriction;
+ float movevars_friction;
+ float movevars_timescale;
+ float movevars_gravity;
+ float movevars_stopspeed;
+ float movevars_maxspeed;
+ float movevars_spectatormaxspeed;
+ float movevars_accelerate;
+ float movevars_airaccelerate;
+ float movevars_wateraccelerate;
+ float movevars_entgravity;
+ float movevars_jumpvelocity;
+ float movevars_edgefriction;
+ float movevars_maxairspeed;
+ float movevars_stepheight;
+ float movevars_airaccel_qw;
+ float movevars_airaccel_qw_stretchfactor;
+ float movevars_airaccel_sideways_friction;
+ float movevars_airstopaccelerate;
+ float movevars_airstrafeaccelerate;
+ float movevars_maxairstrafespeed;
+ float movevars_airstrafeaccel_qw;
+ float movevars_aircontrol;
+ float movevars_aircontrol_power;
+ float movevars_aircontrol_penalty;
+ float movevars_warsowbunny_airforwardaccel;
+ float movevars_warsowbunny_accel;
+ float movevars_warsowbunny_topspeed;
+ float movevars_warsowbunny_turnaccel;
+ float movevars_warsowbunny_backtosideratio;
+ float movevars_ticrate;
+ float movevars_airspeedlimit_nonqw;
// models used by qw protocol
int qw_modelindex_spike;
float qw_weaponkick;
- int qw_validsequence;
-
- qw_usercmd_t qw_moves[QW_UPDATE_BACKUP];
-
- int qw_deltasequence[QW_UPDATE_BACKUP];
+ unsigned int qw_validsequence;
+
+ unsigned int qw_deltasequence[QW_UPDATE_BACKUP];
+
+ // csqc stuff:
+ // server entity number corresponding to a clientside entity
+ unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
+ qbool csqc_loaded;
+ vec3_t csqc_vieworigin;
+ vec3_t csqc_viewangles;
+ vec3_t csqc_vieworiginfromengine;
+ vec3_t csqc_viewanglesfromengine;
+ matrix4x4_t csqc_viewmodelmatrixfromengine;
+ qbool csqc_usecsqclistener;
+ matrix4x4_t csqc_listenermatrix;
+ char csqc_printtextbuf[MAX_INPUTLINE];
+
+ // collision culling data
+ world_t world;
+
+ // loc file stuff (points and boxes describing locations in the level)
+ cl_locnode_t *locnodes;
+ // this is updated to cl.movement_origin whenever health is < 1
+ // used by %d print in say/say_team messages if cl_locs_enable is on
+ vec3_t lastdeathorigin;
+
+ // processing buffer used by R_BuildLightMap, reallocated as needed,
+ // freed on each level change
+ size_t buildlightmapmemorysize;
+ unsigned char *buildlightmapmemory;
+
+ // used by EntityState5_ReadUpdate
+ skeleton_t *engineskeletonobjects;
}
client_state_t;
extern cvar_t cl_name;
extern cvar_t cl_color;
extern cvar_t cl_rate;
+extern cvar_t cl_rate_burstsize;
extern cvar_t cl_pmodel;
extern cvar_t cl_playermodel;
extern cvar_t cl_playerskin;
extern cvar_t cl_shownet;
extern cvar_t cl_nolerp;
+extern cvar_t cl_nettimesyncfactor;
+extern cvar_t cl_nettimesyncboundmode;
+extern cvar_t cl_nettimesyncboundtolerance;
extern cvar_t cl_pitchdriftspeed;
extern cvar_t lookspring;
extern cvar_t cl_autodemo;
extern cvar_t cl_autodemo_nameformat;
+extern cvar_t cl_autodemo_delete;
extern cvar_t r_draweffects;
extern cvar_t cl_stainmaps_clearonload;
extern cvar_t cl_prydoncursor;
+extern cvar_t cl_prydoncursor_notrace;
+
+extern cvar_t cl_locs_enable;
extern client_state_t cl;
-extern void CL_AllocDlight (entity_render_t *ent, matrix4x4_t *matrix, float radius, float red, float green, float blue, float decay, float lifetime, int cubemapnum, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags);
+extern void CL_AllocLightFlash (entity_render_t *ent, matrix4x4_t *matrix, float radius, float red, float green, float blue, float decay, float lifetime, char *cubemapname, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags);
+
+cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
+void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
//=============================================================================
// cl_main
//
+double CL_Frame(double time);
+
void CL_Shutdown (void);
void CL_Init (void);
-void CL_EstablishConnection(const char *host);
+void CL_StartVideo(void);
-void CL_Disconnect (void);
-void CL_Disconnect_f (void);
+void CL_EstablishConnection(const char *host, int firstarg);
-void CL_BoundingBoxForEntity(entity_render_t *ent);
+void CL_Disconnect(void);
+void CL_DisconnectEx(qbool kicked, const char *reason, ... );
+void CL_Disconnect_f(cmd_state_t *cmd);
+
+void CL_UpdateRenderEntity(entity_render_t *ent);
+void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
+void CL_UpdateViewEntities(void);
//
// cl_input
void CL_NewBeam (int ent, vec3_t start, vec3_t end, model_t *m, int lightning);
void CL_RelinkBeams (void);
void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end);
+void CL_ClientMovement_Replay(void);
void CL_ClearTempEntities (void);
-entity_t *CL_NewTempEntity (void);
+entity_render_t *CL_NewTempEntity (double shadertime);
-void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
+void CL_Effect(vec3_t org, model_t *model, int startframe, int framecount, float framerate);
void CL_ClearState (void);
void CL_ExpandEntities(int num);
-void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allowstarkey, qboolean allowmodel, qboolean quiet);
+void CL_ExpandCSQCRenderEntities(int num);
+void CL_SetInfo(const char *key, const char *value, qbool send, qbool allowstarkey, qbool allowmodel, qbool quiet);
-int CL_ReadFromServer (void);
+void CL_UpdateWorld (void);
void CL_WriteToServer (void);
-void CL_Move (void);
-extern qboolean cl_ignoremousemove;
+void CL_Input (void);
+extern int cl_ignoremousemoves;
float CL_KeyState (kbutton_t *key);
-const char *Key_KeynumToString (int keynum);
-int Key_StringToKeynum (const char *str);
//
-// cl_demo.c
+// cl_cmd.c
//
-void CL_StopPlayback(void);
-void CL_ReadDemoMessage(void);
-void CL_WriteDemoMessage(void);
+/// adds the string as a clc_stringcmd to the client message.
+/// (used when there is no reason to generate a local command to do it)
+void CL_ForwardToServer (const char *s);
-void CL_NextDemo(void);
-void CL_Stop_f(void);
-void CL_Record_f(void);
-void CL_PlayDemo_f(void);
-void CL_TimeDemo_f(void);
+/// adds the current command line as a clc_stringcmd to the client message.
+/// things like godmode, noclip, etc, are commands directed to the server,
+/// so when they are typed in at the console, they will need to be forwarded.
+void CL_ForwardToServer_f (cmd_state_t *cmd);
+void CL_InitCommands(void);
-//
-// cl_parse.c
-//
-void CL_Parse_Init(void);
-void CL_Parse_Shutdown(void);
-void CL_ParseServerMessage(void);
-void CL_Parse_DumpPacket(void);
-void CL_Parse_ErrorCleanUp(void);
-void QW_CL_StartUpload(unsigned char *data, int size);
-extern cvar_t qport;
//
-// view
+// cl_demo.c
//
-void V_StartPitchDrift (void);
-void V_StopPitchDrift (void);
-
-void V_Init (void);
-float V_CalcRoll (vec3_t angles, vec3_t velocity);
-void V_UpdateBlends (void);
-void V_ParseDamage (void);
+void CL_StopPlayback(void);
+void CL_ReadDemoMessage(void);
+void CL_WriteDemoMessage(sizebuf_t *mesage);
-//
-// cl_part
-//
+void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
+void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
-extern cvar_t cl_particles;
-extern cvar_t cl_particles_quality;
-extern cvar_t cl_particles_size;
-extern cvar_t cl_particles_quake;
-extern cvar_t cl_particles_blood;
-extern cvar_t cl_particles_blood_alpha;
-extern cvar_t cl_particles_blood_bloodhack;
-extern cvar_t cl_particles_bulletimpacts;
-extern cvar_t cl_particles_explosions_bubbles;
-extern cvar_t cl_particles_explosions_smoke;
-extern cvar_t cl_particles_explosions_sparks;
-extern cvar_t cl_particles_explosions_shell;
-extern cvar_t cl_particles_smoke;
-extern cvar_t cl_particles_smoke_alpha;
-extern cvar_t cl_particles_smoke_alphafade;
-extern cvar_t cl_particles_sparks;
-extern cvar_t cl_particles_bubbles;
-extern cvar_t cl_decals;
-extern cvar_t cl_decals_time;
-extern cvar_t cl_decals_fadetime;
-
-void CL_Particles_Clear(void);
-void CL_Particles_Init(void);
-void CL_Particles_Shutdown(void);
-
-typedef enum effectnameindex_s
-{
- EFFECT_NONE,
- EFFECT_TE_GUNSHOT,
- EFFECT_TE_GUNSHOTQUAD,
- EFFECT_TE_SPIKE,
- EFFECT_TE_SPIKEQUAD,
- EFFECT_TE_SUPERSPIKE,
- EFFECT_TE_SUPERSPIKEQUAD,
- EFFECT_TE_WIZSPIKE,
- EFFECT_TE_KNIGHTSPIKE,
- EFFECT_TE_EXPLOSION,
- EFFECT_TE_EXPLOSIONQUAD,
- EFFECT_TE_TAREXPLOSION,
- EFFECT_TE_TELEPORT,
- EFFECT_TE_LAVASPLASH,
- EFFECT_TE_SMALLFLASH,
- EFFECT_TE_FLAMEJET,
- EFFECT_EF_FLAME,
- EFFECT_TE_BLOOD,
- EFFECT_TE_SPARK,
- EFFECT_TE_PLASMABURN,
- EFFECT_TE_TEI_G3,
- EFFECT_TE_TEI_SMOKE,
- EFFECT_TE_TEI_BIGEXPLOSION,
- EFFECT_TE_TEI_PLASMAHIT,
- EFFECT_EF_STARDUST,
- EFFECT_TR_ROCKET,
- EFFECT_TR_GRENADE,
- EFFECT_TR_BLOOD,
- EFFECT_TR_WIZSPIKE,
- EFFECT_TR_SLIGHTBLOOD,
- EFFECT_TR_KNIGHTSPIKE,
- EFFECT_TR_VORESPIKE,
- EFFECT_TR_NEHAHRASMOKE,
- EFFECT_TR_NEXUIZPLASMA,
- EFFECT_TR_GLOWTRAIL,
- EFFECT_SVC_PARTICLE,
- EFFECT_TOTAL
-}
-effectnameindex_t;
-
-int CL_ParticleEffectIndexForName(const char *name);
-const char *CL_ParticleEffectNameForIndex(int i);
-void CL_ParticleEffect(int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor);
-void CL_ParseParticleEffect (void);
-void CL_ParticleCube (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, vec_t gravity, vec_t randomvel);
-void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, int type);
-void CL_EntityParticles (const entity_t *ent);
-void CL_ParticleExplosion (const vec3_t org);
-void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength);
-void CL_MoveParticles(void);
-void R_MoveExplosions(void);
-void R_NewExplosion(const vec3_t org);
-
-#include "cl_screen.h"
+void CL_PlayDemo(const char *demo);
+void CL_NextDemo(void);
+void CL_Stop_f(cmd_state_t *cmd);
+void CL_Record_f(cmd_state_t *cmd);
+void CL_PlayDemo_f(cmd_state_t *cmd);
+void CL_TimeDemo_f(cmd_state_t *cmd);
-extern qboolean sb_showscores;
+void CL_Demo_Init(void);
-#define NUMCROSSHAIRS 32
-extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1];
-#define FOGTABLEWIDTH 1024
-extern int fogtableindex;
-#define VERTEXFOGTABLE(dist) (fogtableindex = (int)((dist) * r_refdef.fogtabledistmultiplier), r_refdef.fogtable[bound(0, fogtableindex, FOGTABLEWIDTH - 1)])
+#include "cl_screen.h"
-typedef struct r_refdef_stats_s
-{
- int entities;
- int entities_surfaces;
- int entities_triangles;
- int world_leafs;
- int world_portals;
- int particles;
- int meshes;
- int meshes_elements;
- int lights;
- int lights_clears;
- int lights_scissored;
- int lights_lighttriangles;
- int lights_shadowtriangles;
- int lights_dynamicshadowtriangles;
- int bloom;
- int bloom_copypixels;
- int bloom_drawpixels;
-}
-r_refdef_stats_t;
+extern qbool sb_showscores;
-typedef struct r_refdef_s
+typedef enum waterlevel_e
{
- // these fields define the basic rendering information for the world
- // but not the view, which could change multiple times in one rendered
- // frame (for example when rendering textures for certain effects)
-
- // these are set for water warping before
- // frustum_x/frustum_y are calculated
- float frustumscale_x, frustumscale_y;
-
- // minimum visible distance (pixels closer than this disappear)
- double nearclip;
- // maximum visible distance (pixels further than this disappear in 16bpp modes,
- // in 32bpp an infinite-farclip matrix is used instead)
- double farclip;
-
- // fullscreen color blend
- float viewblend[4];
-
- // whether to call S_ExtraUpdate during render to reduce sound chop
- qboolean extraupdate;
-
- // client gameworld time for rendering time based effects
- double time;
-
- // the world
- entity_render_t *worldentity;
-
- // same as worldentity->model
- model_t *worldmodel;
-
- // renderable entities (excluding world)
- entity_render_t **entities;
- int numentities;
- int maxentities;
-
- // renderable dynamic lights
- dlight_t *lights[MAX_DLIGHTS];
- int numlights;
-
- // 8.8bit fixed point intensities for light styles
- // controls intensity of dynamic lights and lightmap layers
- unsigned short lightstylevalue[256]; // 8.8 fraction of base light value
-
- vec3_t fogcolor;
- vec_t fogrange;
- vec_t fograngerecip;
- vec_t fogtabledistmultiplier;
- float fogtable[FOGTABLEWIDTH];
- float fog_density;
- float fog_red;
- float fog_green;
- float fog_blue;
- qboolean fogenabled;
- qboolean oldgl_fogenable;
-
- qboolean draw2dstage;
-
- // true during envmap command capture
- qboolean envmap;
-
- // brightness of world lightmaps and related lighting
- // (often reduced when world rtlights are enabled)
- float lightmapintensity;
- // whether to draw world lights realtime, dlights realtime, and their shadows
- qboolean rtworld;
- qboolean rtworldshadows;
- qboolean rtdlight;
- qboolean rtdlightshadows;
- float polygonfactor;
- float polygonoffset;
- float shadowpolygonfactor;
- float shadowpolygonoffset;
-
- // rendering stats for r_speeds display
- // (these are incremented in many places)
- r_refdef_stats_t stats;
+ WATERLEVEL_NONE,
+ WATERLEVEL_WETFEET,
+ WATERLEVEL_SWIMMING,
+ WATERLEVEL_SUBMERGED
}
-r_refdef_t;
+waterlevel_t;
-typedef struct r_view_s
+typedef struct cl_clientmovement_state_s
{
- // view information (changes multiple times per frame)
- // if any of these variables change then r_viewcache must be regenerated
- // by calling R_View_Update
- // (which also updates viewport, scissor, colormask)
-
- // it is safe and expected to copy this into a structure on the stack and
- // call the renderer recursively, then restore from the stack afterward
- // (as long as R_View_Update is called)
-
- // eye position information
- matrix4x4_t matrix;
+ // entity to be ignored for movement
+ struct prvm_edict_s *self;
+ // position
vec3_t origin;
- vec3_t forward;
- vec3_t left;
- vec3_t right;
- vec3_t up;
- mplane_t frustum[5];
- float frustum_x, frustum_y;
-
- // screen area to render in
- int x;
- int y;
- int z;
- int width;
- int height;
- int depth;
-
- // which color components to allow (for anaglyph glasses)
- int colormask[4];
-
- // global RGB color multiplier for rendering, this is required by HDR
- float colorscale;
-}
-r_view_t;
-
-typedef struct r_viewcache_s
-{
- // these properties are generated by R_View_Update()
-
- // which entities are currently visible for this viewpoint
- // (the used range is 0...r_refdef.numentities)
- unsigned char entityvisible[MAX_EDICTS];
- // flag arrays used for visibility checking on world model
- // (all other entities have no per-surface/per-leaf visibility checks)
- // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_clusters
- unsigned char world_pvsbits[(32768+7)>>3];
- // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_leafs
- unsigned char world_leafvisible[32768];
- // TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces
- unsigned char world_surfacevisible[262144];
- // if true, the view is currently in a leaf without pvs data
- qboolean world_novis;
+ vec3_t velocity;
+ // current bounding box (different if crouched vs standing)
+ vec3_t mins;
+ vec3_t maxs;
+ // currently on the ground
+ qbool onground;
+ // currently crouching
+ qbool crouched;
+ // what kind of water (SUPERCONTENTS_LAVA for instance)
+ int watertype;
+ // how deep
+ waterlevel_t waterlevel;
+ // weird hacks when jumping out of water
+ // (this is in seconds and counts down to 0)
+ float waterjumptime;
+
+ // user command
+ usercmd_t cmd;
}
-r_viewcache_t;
-
-extern r_refdef_t r_refdef;
-extern r_view_t r_view;
-extern r_viewcache_t r_viewcache;
+cl_clientmovement_state_t;
+void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s);
+
+// warpzone prediction hack (CSQC builtin)
+void CL_RotateMoves(const matrix4x4_t *m);
+
+typedef enum meshname_e {
+ MESH_SCENE, // CSQC R_PolygonBegin, potentially also engine particles and debug stuff
+ MESH_UI,
+ NUM_MESHENTITIES,
+} meshname_t;
+extern entity_t cl_meshentities[NUM_MESHENTITIES];
+extern model_t cl_meshentitymodels[NUM_MESHENTITIES];
+extern const char *cl_meshentitynames[NUM_MESHENTITIES];
+#define CL_Mesh_Scene() (&cl_meshentitymodels[MESH_SCENE])
+#define CL_Mesh_UI() (&cl_meshentitymodels[MESH_UI])
+void CL_MeshEntities_Scene_Clear(void);
+void CL_MeshEntities_Scene_AddRenderEntity(void);
+void CL_MeshEntities_Scene_FinalizeRenderEntity(void);
+void CL_UpdateEntityShading(void);
+
+void CL_NewFrameReceived(int num);
+void CL_ParseEntityLump(char *entitystring);
+void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
+void CL_RelinkLightFlashes(void);
+void CL_Beam_AddPolygons(const beam_t *b);
+void CL_UpdateMoveVars(void);
+void CL_Locs_Reload_f(cmd_state_t *cmd);
#endif