#define CLIENT_H
#include "matrixlib.h"
+#include "snd_main.h"
// LordHavoc: 256 dynamic lights
#define MAX_DLIGHTS 256
{
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;
}
dlight_t;
-typedef struct frameblend_s
+#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
+// framegroups at once
+#define MAX_FRAMEBLENDS MAX_FRAMEGROUPBLENDS
+typedef struct frameblend_s
+{
+ int subframe;
+ float lerp;
}
frameblend_t;
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
// colormod tinting of models
float colormod[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];
+ // 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];
// current lighting from map (updated ONLY by client code, not renderer)
vec3_t modellight_ambient;
vec_t cursor_fraction;
int cursor_entitynumber;
- double time;
- double receivetime;
+ 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;
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 capturevideoformat_e
{
- CAPTUREVIDEOFORMAT_AVI_I420
+ CAPTUREVIDEOFORMAT_AVI_I420,
+ CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
}
capturevideoformat_t;
typedef struct capturevideostate_s
{
- double starttime;
+ double startrealtime;
double framerate;
- // for AVI saving some values have to be written after capture ends
- fs_offset_t videofile_firstchunkframes_offset;
- fs_offset_t videofile_totalframes_offset1;
- fs_offset_t videofile_totalframes_offset2;
- fs_offset_t videofile_totalsampleframes_offset;
- int videofile_ix_master_audio_inuse;
- fs_offset_t videofile_ix_master_audio_inuse_offset;
- fs_offset_t videofile_ix_master_audio_start_offset;
- int videofile_ix_master_video_inuse;
- fs_offset_t videofile_ix_master_video_inuse_offset;
- fs_offset_t videofile_ix_master_video_start_offset;
- fs_offset_t videofile_ix_movistart;
- qfile_t *videofile;
qboolean active;
qboolean realtime;
qboolean error;
- capturevideoformat_t format;
int soundrate;
+ int soundchannels;
int frame;
- int soundsampleframe; // for AVI saving
+ double starttime;
+ double lastfpstime;
+ int lastfpsframe;
+ int soundsampleframe;
unsigned char *screenbuffer;
unsigned char *outbuffer;
- sizebuf_t riffbuffer;
- unsigned char riffbufferdata[128];
- // note: riffindex buffer has an allocated ->data member, not static like most!
- sizebuf_t riffindexbuffer;
- int riffstacklevel;
- fs_offset_t riffstackstartoffset[4];
+ char basename[MAX_QPATH];
+ int width, height;
+
+ // precomputed RGB to YUV tables
+ // converts the RGB values to YUV (see cap_avi.c for how to use them)
short rgbtoyuvscaletable[3][3][256];
unsigned char yuvnormalizetable[3][256];
- char basename[64];
- int width, height;
+
+ // precomputed gamma ramp (only needed if the capturevideo module uses RGB output)
+ // note: to map from these values to RGB24, you have to multiply by 255.0/65535.0, then add 0.5, then cast to integer
+ unsigned short vidramp[256 * 3];
+
+ // stuff to be filled in by the video format module
+ capturevideoformat_t format;
+ 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);
+ void (*endvideo) ();
+ void (*videoframes) (int num);
+ void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
+
+ // format specific data
+ void *formatspecific;
}
capturevideostate_t;
// 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
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)
+ // fields used by rendering: (44 bytes)
unsigned short typeindex;
unsigned short texnum;
vec3_t org;
float alpha; // 0-255
unsigned char color[3];
unsigned char unused1;
+ int clusterindex; // cheap culling by pvs
// 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
{
// fields used by rendering: (40 bytes)
- unsigned short typeindex;
- unsigned short texnum;
+ 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 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
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;
float movevars_stepheight;
float movevars_airaccel_qw;
float movevars_airaccel_sideways_friction;
+ float movevars_airstopaccelerate;
+ float movevars_airstrafeaccelerate;
+ float movevars_maxairstrafespeed;
+ float movevars_aircontrol;
// models used by qw protocol
int qw_modelindex_spike;
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_Parse_ErrorCleanUp(void);
void QW_CL_StartUpload(unsigned char *data, int size);
extern cvar_t qport;
+void CL_KeepaliveMessage(qboolean readmessages); // call this during loading of large content
//
// view
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
projects / xonotic / darkplaces.git / blobdiff