// color and initial alpha value
float texcoord2f[3][2];
float vertex3f[3][3];
- unsigned char color4ub[3][4];
+ 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
}
beam_t;
+typedef struct rtlight_particle_s
+{
+ float origin[3];
+ float color[3];
+}
+rtlight_particle_t;
+
typedef struct rtlight_s
{
// shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin
float corona_visibility;
unsigned int corona_queryindex_visiblepixels;
unsigned int corona_queryindex_allpixels;
- /// this is R_Shadow_Cubemap(rtlight->cubemapname)
+ /// this is R_GetCubemap(rtlight->cubemapname)
rtexture_t *currentcubemap;
- /// set by R_CacheRTLight to decide whether R_DrawRTLight should draw it
+ /// set by R_Shadow_PrepareLight to decide whether R_Shadow_DrawLight should draw it
qboolean draw;
- /// these fields are set by R_CacheRTLight for later drawing
+ /// these fields are set by R_Shadow_PrepareLight for later drawing
int cached_numlightentities;
int cached_numlightentities_noselfshadow;
int cached_numshadowentities;
/// 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 photoncolor[3];
+ float photons;
}
rtlight_t;
}
dlight_t;
-#define MAX_FRAMEGROUPBLENDS 4
-typedef struct framegroupblend_s
-{
- // animation number and blend factor
- // (for most models this is the frame number)
- int frame;
- float lerp;
- // time frame began playing (for framegroup animations)
- double start;
-}
-framegroupblend_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
// skeletal animation data (if skeleton.relativetransforms is not NULL, it overrides frameblend)
skeleton_t *skeleton;
- // animation cache index
- int animcacheindex;
+ // animation cache (pointers allocated using R_FrameData_Alloc)
+ // ONLY valid during R_RenderView! may be NULL (not cached)
+ float *animcache_vertex3f;
+ float *animcache_normal3f;
+ float *animcache_svector3f;
+ float *animcache_tvector3f;
+ // interleaved arrays for rendering and dynamic vertex buffers for them
+ r_meshbuffer_t *animcache_vertex3fbuffer;
+ r_vertexmesh_t *animcache_vertexmesh;
+ r_meshbuffer_t *animcache_vertexmeshbuffer;
// current lighting from map (updated ONLY by client code, not renderer)
vec3_t modellight_ambient;
// FIELDS UPDATED BY RENDERER:
// last time visible during trace culling
double last_trace_visibility;
+
+ // user wavefunc parameters (from csqc)
+ float userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
}
entity_render_t;
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 enum capturevideoformat_e
{
CAPTUREVIDEOFORMAT_AVI_I420,
- CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
+ CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA
}
capturevideoformat_t;
const char *formatextension;
qfile_t *videofile;
// always use this:
- // cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
+ // cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
void (*endvideo) (void);
void (*videoframes) (int num);
void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
fs_offset_t demo_lastcsprogssize;
int demo_lastcsprogscrc;
qboolean demoplayback;
+ qboolean demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
qboolean timedemo;
// -1 = use normal cd track
int forcetrack;
// password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
char userinfo[MAX_USERINFO_STRING];
+ // extra user info for the "connect" command
+ char connect_userinfo[MAX_USERINFO_STRING];
+
// video capture stuff
capturevideostate_t capturevideo;
+
+ // crypto channel
+ crypto_t crypto;
+
+ // 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)
}
client_static_t;
}
particletype_t;
-typedef enum
+typedef enum ptype_e
{
pt_dead, 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
}
typedef struct particle_s
{
- // fields used by rendering: (40 bytes)
+ // for faster batch rendering, particles are rendered in groups by effect (resulting in less perfect sorting but far less state changes)
+
+ // fields used by rendering: (48 bytes)
+ vec3_t sortorigin; // sort by this group origin, not particle org
+ vec3_t org;
+ vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam
+ float size;
+ float alpha; // 0-255
+ float stretch; // only for sparks
+
+ // fields not used by rendering: (44 bytes)
+ float stainsize;
+ float stainalpha;
+ float sizeincrease; // rate of size change per second
+ 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)
+// float delayedcollisions; // time that p->bounce becomes active
+ float delayedspawn; // time that particle appears and begins moving
+ float die; // time when this particle should be removed, regardless of alpha
+
+ // short variables grouped to save memory (4 bytes)
+ short angle; // base rotation of particle
+ short spin; // geometry rotation speed around the particle center normal
+
+ // byte variables grouped to save memory (12 bytes)
+ unsigned char color[3];
+ unsigned char qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
unsigned char typeindex;
- pblend_t blendmode;
- porientation_t orientation;
+ unsigned char blendmode;
+ unsigned char orientation;
unsigned char texnum;
- vec3_t org;
- vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam
- float size;
- float alpha; // 0-255
- unsigned char color[3];
- unsigned char qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
- float stretch; // only for sparks
- int staincolor;
+ unsigned char staincolor[3];
signed char staintexnum;
- float stainsizefactor;
-
- // fields not used by rendering: (40 bytes)
- float sizeincrease; // rate of size change per second
- 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)
- float delayedcollisions; // time that p->bounce becomes active
- float delayedspawn; // time that particle appears and begins moving
- float die; // time when this particle should be removed, regardless of alpha
}
particle_t;
// whether the replay should allow a jump at the first sequence
qboolean 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;
float sensitivityscale;
csqc_vidvars_t csqc_vidvars; //[515]: these parms must be set to true by default
qboolean csqc_wantsmousemove;
+ qboolean csqc_paused; // vortex: int because could be flags
struct model_s *csqc_model_precache[MAX_MODELS];
// local amount for smoothing stepups
qboolean oldonground;
double lastongroundtime;
double hitgroundtime;
+ float bob2_smooth;
+ float bobfall_speed;
+ float bobfall_swing;
// don't change view angle, full screen, etc
int intermission;
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,
// entity database stuff
// latest received entity frame numbers
-#define LATESTFRAMENUMS 3
+#define LATESTFRAMENUMS 32
+ int latestframenumsposition;
int latestframenums[LATESTFRAMENUMS];
+ int latestsendnums[LATESTFRAMENUMS];
entityframe_database_t *entitydatabase;
entityframe4_database_t *entitydatabase4;
entityframeqw_database_t *entitydatabaseqw;
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;
// server entity number corresponding to a clientside entity
unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
qboolean csqc_loaded;
- vec3_t csqc_origin;
- vec3_t csqc_angles;
+ vec3_t csqc_vieworigin;
+ vec3_t csqc_viewangles;
+ vec3_t csqc_vieworiginfromengine;
+ vec3_t csqc_viewanglesfromengine;
+ matrix4x4_t csqc_viewmodelmatrixfromengine;
qboolean csqc_usecsqclistener;
matrix4x4_t csqc_listenermatrix;
char csqc_printtextbuf[MAX_INPUTLINE];
// 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_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;
void CL_Shutdown (void);
void CL_Init (void);
-void CL_EstablishConnection(const char *host);
+void CL_EstablishConnection(const char *host, int firstarg);
void CL_Disconnect (void);
void CL_Disconnect_f (void);
float CL_KeyState (kbutton_t *key);
-const char *Key_KeynumToString (int keynum);
+const char *Key_KeynumToString (int keynum, char *buf, size_t buflength);
int Key_StringToKeynum (const char *str);
//
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_decal_alpha;
+extern cvar_t cl_particles_blood_decal_scalemin;
+extern cvar_t cl_particles_blood_decal_scalemax;
extern cvar_t cl_particles_blood_bloodhack;
extern cvar_t cl_particles_bulletimpacts;
extern cvar_t cl_particles_explosions_sparks;
void CL_Particles_Clear(void);
void CL_Particles_Init(void);
void CL_Particles_Shutdown(void);
-particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex);
+particle_t *CL_NewParticle(const vec3_t sortorigin, unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex, float stainalpha, float stainsize, float angle, float spin, float tint[4]);
typedef enum effectnameindex_s
{
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_ParticleTrail(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, qboolean spawndlight, qboolean spawnparticles);
+void CL_ParticleTrail(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, qboolean spawndlight, qboolean spawnparticles, float tintmins[4], float tintmaxs[4]);
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);
int particles;
int drawndecals;
int totaldecals;
- int meshes;
- int meshes_elements;
+ int draws;
+ int draws_vertices;
+ int draws_elements;
int lights;
int lights_clears;
int lights_scissored;
int lights_lighttriangles;
int lights_shadowtriangles;
int lights_dynamicshadowtriangles;
+ int bouncegrid_lights;
+ int bouncegrid_particles;
+ int bouncegrid_traces;
+ int bouncegrid_hits;
+ int bouncegrid_splats;
+ int bouncegrid_bounces;
+ int collisioncache_animated;
+ int collisioncache_cached;
+ int collisioncache_traced;
int bloom;
int bloom_copypixels;
int bloom_drawpixels;
+ int indexbufferuploadcount;
+ int indexbufferuploadsize;
+ int vertexbufferuploadcount;
+ int vertexbufferuploadsize;
+ int framedatacurrent;
+ int framedatasize;
}
r_refdef_stats_t;
typedef struct r_viewport_s
{
- double m[16];
matrix4x4_t cameramatrix; // from entity (transforms from camera entity to world)
matrix4x4_t viewmatrix; // actual matrix for rendering (transforms to viewspace)
matrix4x4_t projectmatrix; // actual projection matrix (transforms from viewspace to screen)
int height;
int depth;
r_viewport_type_t type;
+ float screentodepth[2]; // used by deferred renderer to calculate linear depth from device depth coordinates
}
r_viewport_t;
int width;
int height;
int depth;
- r_viewport_t viewport;
+ r_viewport_t viewport; // note: if r_viewscale is used, the viewport.width and viewport.height may be less than width and height
// which color components to allow (for anaglyph glasses)
int colormask[4];
- // global RGB color multiplier for rendering, this is required by HDR
+ // global RGB color multiplier for rendering
float colorscale;
// whether to call R_ClearScreen before rendering stuff
qboolean clear;
// if true, don't clear or do any post process effects (bloom, etc)
qboolean isoverlay;
+ // if true, this is the MAIN view (which is, after CSQC, copied into the scene for use e.g. by r_speeds 1, showtex, prydon cursor)
+ qboolean ismain;
// whether to draw r_showtris and such, this is only true for the main
- // view render, all secondary renders (HDR, mirrors, portals, cameras,
+ // view render, all secondary renders (mirrors, portals, cameras,
// distortion effects, etc) omit such debugging information
qboolean showdebug;
entity_render_t *tempentities;
int numtempentities;
int maxtempentities;
+ qboolean expandtempentities;
// renderable dynamic lights
rtlight_t *lights[MAX_DLIGHTS];
qboolean fogenabled;
qboolean oldgl_fogenable;
- qboolean draw2dstage;
+ // new flexible texture height fog (overrides normal fog)
+ char fog_height_texturename[64]; // note: must be 64 for the sscanf code
+ unsigned char *fog_height_table1d;
+ unsigned char *fog_height_table2d;
+ int fog_height_tablesize; // enable
+ float fog_height_tablescale;
+ float fog_height_texcoordscale;
+ char fogheighttexturename[64]; // detects changes to active fog height texture
+
+ int draw2dstage; // 0 = no, 1 = yes, other value = needs setting up again
// true during envmap command capture
qboolean envmap;
float shadowpolygonfactor;
float shadowpolygonoffset;
+ // how long R_RenderView took on the previous frame
+ double lastdrawscreentime;
+
// rendering stats for r_speeds display
// (these are incremented in many places)
r_refdef_stats_t stats;
extern r_refdef_t r_refdef;
+typedef enum waterlevel_e
+{
+ WATERLEVEL_NONE,
+ WATERLEVEL_WETFEET,
+ WATERLEVEL_SWIMMING,
+ WATERLEVEL_SUBMERGED
+}
+waterlevel_t;
+
+typedef struct cl_clientmovement_state_s
+{
+ // position
+ vec3_t origin;
+ vec3_t velocity;
+ // current bounding box (different if crouched vs standing)
+ vec3_t mins;
+ vec3_t maxs;
+ // currently on the ground
+ qboolean onground;
+ // currently crouching
+ qboolean 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;
+}
+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);
+
+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 Sbar_ShowFPS(void);
+void Sbar_ShowFPS_Update(void);
+void Host_SaveConfig(void);
+void Host_LoadConfig_f(void);
+void CL_UpdateMoveVars(void);
+void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
+void V_DriftPitch(void);
+void V_FadeViewFlashs(void);
+void V_CalcViewBlend(void);
+void V_CalcRefdefUsing (const matrix4x4_t *entrendermatrix, const vec3_t clviewangles, qboolean teleported, qboolean clonground, qboolean clcmdjump, float clstatsviewheight);
+void V_CalcRefdef(void);
+void CL_Locs_Reload_f(void);
+
#endif