// LordHavoc: 256 dynamic lights
#define MAX_DLIGHTS 256
-// this is the maximum number of input packets that can be lost without a
-// misprediction
-#define CL_MAX_USERCMDS 16
+// this is the maximum number of input packets that can be predicted
+#define CL_MAX_USERCMDS 256
// flags for rtlight rendering
#define LIGHTFLAG_NORMALMODE 1
{
int active;
vec3_t origin;
- float starttime;
+ double starttime;
float framerate;
int modelindex;
int startframe;
// rendering properties, updated each time a light is rendered
// this is rtlight->color * d_lightstylevalue
vec3_t currentcolor;
+ // used by corona updates, due to occlusion query
+ float corona_visibility;
+ unsigned int corona_queryindex_visiblepixels;
+ unsigned int corona_queryindex_allpixels;
// this is R_Shadow_Cubemap(rtlight->cubemapname)
rtexture_t *currentcubemap;
// 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;
+ shadowmesh_t *static_meshchain_shadow_zpass;
+ shadowmesh_t *static_meshchain_shadow_zfail;
// used for visibility testing (more exact than bbox)
int static_numleafs;
int static_numleafpvsbytes;
float scale;
// NULL = no model
- model_t *model;
+ dp_model_t *model;
// 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
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)
vec_t cursor_fraction;
int cursor_entitynumber;
- double time;
- double receivetime;
- int msec; // for qw moves
+ double time; // time the move is executed for (cl_movement: clienttime, non-cl_movement: receivetime)
+ double receivetime; // time the move was received at
+ double clienttime; // time to which server state the move corresponds to
+ int msec; // for predicted moves
int buttons;
int impulse;
int sequence;
qboolean applied; // if false we're still accumulating a move
qboolean predicted; // if true the sequence should be sent as 0
+
+ // derived properties
+ double frametime;
+ qboolean canjump;
+ qboolean jump;
+ qboolean crouch;
} usercmd_t;
typedef struct lightstyle_s
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
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
fs_offset_t videofile_ix_master_video_inuse_offset;
fs_offset_t videofile_ix_master_video_start_offset;
fs_offset_t videofile_ix_movistart;
+ fs_offset_t position;
qfile_t *videofile;
qboolean active;
qboolean realtime;
qboolean error;
+ qboolean canseek;
capturevideoformat_t format;
int soundrate;
int frame;
sizebuf_t riffindexbuffer;
int riffstacklevel;
fs_offset_t riffstackstartoffset[4];
+ fs_offset_t riffstacksizehint[4];
+ const char *riffstackfourcc[4];
short rgbtoyuvscaletable[3][3][256];
unsigned char yuvnormalizetable[3][256];
char basename[64];
}
cl_downloadack_t;
+typedef struct cl_soundstats_s
+{
+ int mixedsounds;
+ int totalsounds;
+ int latency_milliseconds;
+}
+cl_soundstats_t;
+
//
// the client_static_t structure is persistent through an arbitrary number
// of server connections
// list of demos in loop
char demos[MAX_DEMOS][MAX_DEMONAME];
// the actively playing demo (set by CL_PlayDemo_f)
- char demoname[64];
+ 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;
+ fs_offset_t demo_lastcsprogssize;
+ int demo_lastcsprogscrc;
qboolean demoplayback;
qboolean timedemo;
// -1 = use normal cd track
int td_frames; // total frames parsed
double td_onesecondnexttime;
double td_onesecondframes;
- double td_onesecondminframes;
- double td_onesecondmaxframes;
- double td_onesecondavgframes;
+ double td_onesecondrealtime;
+ double td_onesecondminfps;
+ double td_onesecondmaxfps;
+ double td_onesecondavgfps;
int td_onesecondavgcount;
// LordHavoc: pausedemo
qboolean demopaused;
+ // sound mixer statistics for showsound display
+ cl_soundstats_t soundstats;
+
qboolean connect_trying;
int connect_remainingtries;
double connect_nextsendtime;
double qw_downloadspeedtime;
int qw_downloadspeedcount;
int qw_downloadspeedrate;
+ qboolean qw_download_deflate;
// current file upload buffer (for uploading screenshots to server)
unsigned char *qw_uploaddata;
PARTICLE_BILLBOARD = 0,
PARTICLE_SPARK = 1,
PARTICLE_ORIENTED_DOUBLESIDED = 2,
- PARTICLE_BEAM = 3
+ PARTICLE_BEAM = 3,
+ PARTICLE_INVALID = -1
}
porientation_t;
{
PBLEND_ALPHA = 0,
PBLEND_ADD = 1,
- PBLEND_MOD = 2
+ PBLEND_INVMOD = 2,
+ PBLEND_INVALID = -1
}
pblend_t;
typedef struct decal_s
{
+ // fields used by rendering: (40 bytes)
unsigned short typeindex;
unsigned short texnum;
vec3_t org;
vec3_t normal;
float size;
float alpha; // 0-255
- float time2; // used for snow fluttering and decal fade
- unsigned char color[4];
+ unsigned char color[3];
+ unsigned char unused1;
+
+ // fields not used by rendering: (36 bytes in 32bit, 40 bytes in 64bit)
+ float time2; // used for decal fade
unsigned int owner; // decal stuck to this entity
- model_t *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
+ dp_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 relativenormal; // decal oriented this way relative to entity's coordinate space
}
typedef struct particle_s
{
- unsigned short typeindex;
- unsigned short texnum;
+ // fields used by rendering: (40 bytes)
+ unsigned char typeindex;
+ pblend_t blendmode;
+ porientation_t 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 sizeincrease; // rate of size change per second
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
+
+ // 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)
- unsigned char color[4];
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
qboolean movement_predicted;
// if true the CL_ClientMovement_Replay function will update origin, etc
qboolean movement_replay;
- // this is set true by svc_time parsing and causes a new movement to be
- // queued for prediction purposes
- qboolean movement_needupdate;
- // timestamps of latest two predicted moves for interpolation
- double movement_time[4];
// 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];
// whether the replay should allow a jump at the first sequence
qboolean movement_replay_canjump;
int gametype;
// models and sounds used by engine code (particularly cl_parse.c)
- model_t *model_bolt;
- model_t *model_bolt2;
- model_t *model_bolt3;
- model_t *model_beam;
+ dp_model_t *model_bolt;
+ dp_model_t *model_bolt2;
+ dp_model_t *model_bolt3;
+ dp_model_t *model_beam;
sfx_t *sfx_wizhit;
sfx_t *sfx_knighthit;
sfx_t *sfx_tink1;
int num_decals;
int num_showlmps;
+ double particles_updatetime;
+ double decals_updatetime;
int free_particle;
int free_decal;
// use cl.scores[cl.playerentity-1].qw_spectator instead
//qboolean qw_spectator;
+ // last time an input packet was sent
+ double lastpackettime;
+
// movement parameters for client prediction
float movevars_wallfriction;
float movevars_waterfriction;
float movevars_friction;
- float movevars_ticrate;
float movevars_timescale;
float movevars_gravity;
float movevars_stopspeed;
void CL_MoveLerpEntityStates(entity_t *ent);
void CL_LerpUpdate(entity_t *e);
void CL_ParseTEnt (void);
-void CL_NewBeam (int ent, vec3_t start, vec3_t end, model_t *m, int lightning);
+void CL_NewBeam (int ent, vec3_t start, vec3_t end, dp_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_render_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_ReadDemoMessage(void);
void CL_WriteDemoMessage(sizebuf_t *mesage);
+void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
+void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
+
void CL_NextDemo(void);
void CL_Stop_f(void);
void CL_Record_f(void);
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_MoveDecals(void);
-void CL_MoveParticles(void);
-void R_MoveExplosions(void);
void R_NewExplosion(const vec3_t org);
-void Debug_PolygonBegin(const char *picname, int flags, qboolean draw2d, float linewidth);
+void Debug_PolygonBegin(const char *picname, int flags);
void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a);
void Debug_PolygonEnd(void);
typedef struct r_refdef_stats_s
{
+ int renders;
int entities;
int entities_surfaces;
int entities_triangles;
// 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;
// whether to draw r_showtris and such, this is only true for the main
// view render, all secondary renders (HDR, mirrors, portals, cameras,
// these define which values to use in GL_CullFace calls to request frontface or backface culling
int cullface_front;
int cullface_back;
+
+ // render quality (0 to 1) - affects r_drawparticles_drawdistance and others
+ float quality;
}
r_refdef_view_t;
entity_render_t *worldentity;
// same as worldentity->model
- model_t *worldmodel;
+ dp_model_t *worldmodel;
// renderable entities (excluding world)
entity_render_t **entities;
int maxtempentities;
// renderable dynamic lights
- rtlight_t lights[MAX_DLIGHTS];
+ rtlight_t *lights[MAX_DLIGHTS];
+ rtlight_t templights[MAX_DLIGHTS];
int numlights;
// intensities for light styles right now, controls rtlights
// 8.8bit fixed point intensities for light styles
// controls intensity lightmap layers
unsigned short lightstylevalue[256]; // 8.8 fraction of base light value
+
+ float ambient;
+
+ qboolean rtworld;
+ qboolean rtworldshadows;
+ qboolean rtdlight;
+ qboolean rtdlightshadows;
} r_refdef_scene_t;
typedef struct r_refdef_s
// (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;