X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=client.h;h=f6a8a4d67e3a22a44c7b1964fd8b43b02c24a083;hb=7005b675fc7c9bc7bddac999caec0f47385c32d9;hp=83e488466986fbaf4e41a9e59278295b342cf02f;hpb=ff8d70aa70289d8978b991f0214de17b0c5e1aed;p=xonotic%2Fdarkplaces.git diff --git a/client.h b/client.h index 83e48846..f6a8a4d6 100644 --- a/client.h +++ b/client.h @@ -23,13 +23,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #define CLIENT_H #include "matrixlib.h" +#include "snd_main.h" // 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 128 // flags for rtlight rendering #define LIGHTFLAG_NORMALMODE 1 @@ -39,7 +39,7 @@ typedef struct effect_s { int active; vec3_t origin; - float starttime; + double starttime; float framerate; int modelindex; int startframe; @@ -69,37 +69,37 @@ typedef struct rtlight_s // note that the world to light matrices are inversely scaled (divided) by lightradius // core properties - // matrix for transforming light filter coordinates to world coordinates + /// matrix for transforming light filter coordinates to world coordinates matrix4x4_t matrix_lighttoworld; - // matrix for transforming world coordinates to light filter coordinates + /// 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 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 shadow volumes vec3_t shadoworigin; - // culling + /// culling vec3_t cullmins; vec3_t cullmaxs; // culling @@ -110,35 +110,40 @@ typedef struct rtlight_s // 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_Shadow_Cubemap(rtlight->cubemapname) rtexture_t *currentcubemap; - // static light info - // true if this light should be compiled as a static light + /// 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) + /// premade shadow volumes to render for world entity + 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; 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. + /// 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) + /// 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; } @@ -217,15 +222,38 @@ typedef struct dlight_s } 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; // LordHavoc: 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 @@ -242,14 +270,10 @@ typedef struct entity_render_s float scale; // NULL = no model - model_t *model; - // current uninterpolated animation frame (for things which do not use interpolation) - int frame; + dp_model_t *model; // number of the entity represents, or 0 for non-network entities int entitynumber; - // entity shirt and pants colors (-1 if not colormapped) - int colormap; - // literal colors for renderer + // 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 @@ -264,31 +288,28 @@ typedef struct entity_render_s // 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]; + + // animation cache index + int animcacheindex; - // current lighting from map + // current lighting from map (updated ONLY by client code, not renderer) vec3_t modellight_ambient; vec3_t modellight_diffuse; // q3bsp vec3_t modellight_lightdir; // q3bsp + // FIELDS UPDATED BY RENDERER: // last time visible during trace culling double last_trace_visibility; } @@ -353,14 +374,21 @@ typedef struct usercmd_s 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 @@ -388,7 +416,8 @@ typedef struct scoreboard_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 @@ -412,6 +441,7 @@ typedef struct cshift_s 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 @@ -430,36 +460,53 @@ qw_downloadtype_t; 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_totalframes_offset1; - fs_offset_t videofile_totalframes_offset2; - fs_offset_t videofile_totalsampleframes_offset; - qfile_t *videofile; + int framestep; + int framestepframe; qboolean active; qboolean realtime; qboolean error; - capturevideoformat_t format; int soundrate; + int soundchannels; int frame; - int soundsampleframe; // for AVI saving - unsigned char *buffer; - 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]; + double starttime; + double lastfpstime; + int lastfpsframe; + int soundsampleframe; + unsigned char *screenbuffer; + unsigned char *outbuffer; + 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]; + + // 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); + void (*videoframes) (int num); + void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length); + + // format specific data + void *formatspecific; } capturevideostate_t; @@ -471,6 +518,14 @@ typedef struct cl_downloadack_s } 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 @@ -489,31 +544,34 @@ typedef struct client_static_s // 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 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) double td_starttime; + 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; @@ -557,6 +615,7 @@ typedef struct client_static_s 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; @@ -601,7 +660,9 @@ typedef enum PARTICLE_BILLBOARD = 0, PARTICLE_SPARK = 1, PARTICLE_ORIENTED_DOUBLESIDED = 2, - PARTICLE_BEAM = 3 + PARTICLE_VBEAM = 3, + PARTICLE_HBEAM = 4, + PARTICLE_INVALID = -1 } porientation_t; @@ -609,7 +670,8 @@ typedef enum { PBLEND_ALPHA = 0, PBLEND_ADD = 1, - PBLEND_MOD = 2 + PBLEND_INVMOD = 2, + PBLEND_INVALID = -1 } pblend_t; @@ -623,33 +685,61 @@ particletype_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 + 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 } ptype_t; +typedef struct decal_s +{ + // fields used by rendering: (44 bytes) + unsigned short typeindex; + unsigned short texnum; + vec3_t org; + vec3_t normal; + float size; + 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 + 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 +} +decal_t; + typedef struct particle_s { - 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 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) - 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 - 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 + // 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 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; + 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; @@ -671,6 +761,16 @@ typedef struct cl_locnode_s } cl_locnode_t; +typedef struct showlmp_s +{ + qboolean 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 @@ -740,18 +840,9 @@ typedef struct client_state_s 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; @@ -798,6 +889,12 @@ typedef struct client_state_s // 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; + + // 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; @@ -816,6 +913,11 @@ typedef struct client_state_s 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; @@ -823,10 +925,10 @@ typedef struct client_state_s 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; @@ -883,35 +985,41 @@ typedef struct client_state_s int max_entities; 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_decals; + int max_showlmps; entity_t *entities; unsigned char *entities_active; 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; + decal_t *decals; + showlmp_t *showlmps; int num_entities; 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; @@ -921,6 +1029,7 @@ typedef struct client_state_s int downloadsound_current; int loadsound_total; qboolean downloadcsqc; + qboolean loadcsqc; qboolean loadbegun; qboolean loadfinished; @@ -939,12 +1048,18 @@ typedef struct client_state_s int qw_teamplay; // unused: indicates whether the player is spectating - // use cl.scores[cl.playerentity].qw_spectator instead + // 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_ticrate; - float movevars_slowmo; + unsigned int moveflags; + float movevars_wallfriction; + float movevars_waterfriction; + float movevars_friction; + float movevars_timescale; float movevars_gravity; float movevars_stopspeed; float movevars_maxspeed; @@ -952,8 +1067,6 @@ typedef struct client_state_s float movevars_accelerate; float movevars_airaccelerate; float movevars_wateraccelerate; - float movevars_friction; - float movevars_waterfriction; float movevars_entgravity; float movevars_jumpvelocity; float movevars_edgefriction; @@ -961,6 +1074,16 @@ typedef struct client_state_s float movevars_stepheight; float movevars_airaccel_qw; float movevars_airaccel_sideways_friction; + float movevars_airstopaccelerate; + float movevars_airstrafeaccelerate; + float movevars_maxairstrafespeed; + float movevars_aircontrol; + float movevars_warsowbunny_airforwardaccel; + float movevars_warsowbunny_accel; + float movevars_warsowbunny_topspeed; + float movevars_warsowbunny_turnaccel; + float movevars_warsowbunny_backtosideratio; + float movevars_ticrate; // models used by qw protocol int qw_modelindex_spike; @@ -999,6 +1122,11 @@ typedef struct client_state_s // 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; } client_state_t; @@ -1086,6 +1214,7 @@ void CL_Disconnect (void); void CL_Disconnect_f (void); void CL_UpdateRenderEntity(entity_render_t *ent); +void CL_SetEntityColormapColors(entity_render_t *ent, int colormap); void CL_UpdateViewEntities(void); // @@ -1109,13 +1238,13 @@ void CL_ValidateState(entity_state_t *s); 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_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); @@ -1127,7 +1256,7 @@ void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allo void CL_UpdateWorld (void); void CL_WriteToServer (void); void CL_Input (void); -extern qboolean cl_ignoremousemove; +extern int cl_ignoremousemoves; float CL_KeyState (kbutton_t *key); @@ -1141,6 +1270,9 @@ void CL_StopPlayback(void); 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); @@ -1157,6 +1289,7 @@ void CL_Parse_DumpPacket(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 @@ -1181,7 +1314,6 @@ 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_smoke; extern cvar_t cl_particles_explosions_sparks; extern cvar_t cl_particles_explosions_shell; extern cvar_t cl_particles_rain; @@ -1251,11 +1383,9 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in 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); -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); @@ -1263,20 +1393,24 @@ void Debug_PolygonEnd(void); extern qboolean sb_showscores; -#define NUMCROSSHAIRS 32 -extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1]; - float FogPoint_World(const vec3_t p); float FogPoint_Model(const vec3_t p); +float FogForDistance(vec_t dist); typedef struct r_refdef_stats_s { + int renders; int entities; int entities_surfaces; int entities_triangles; int world_leafs; int world_portals; + int world_surfaces; + int world_triangles; + int lightmapupdates; + int lightmapupdatepixels; int particles; + int decals; int meshes; int meshes_elements; int lights; @@ -1291,49 +1425,183 @@ typedef struct r_refdef_stats_s } r_refdef_stats_t; -typedef struct r_refdef_s +typedef enum r_viewport_type_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) + R_VIEWPORTTYPE_ORTHO, + R_VIEWPORTTYPE_PERSPECTIVE, + R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP, + R_VIEWPORTTYPE_PERSPECTIVECUBESIDE, + R_VIEWPORTTYPE_TOTAL +} +r_viewport_type_t; - // these are set for water warping before - // frustum_x/frustum_y are calculated - float frustumscale_x, frustumscale_y; +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 x; + int y; + int z; + int width; + int height; + int depth; + r_viewport_type_t type; +} +r_viewport_t; - // 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; +typedef struct r_refdef_view_s +{ + // view information (changes multiple times per frame) + // if any of these variables change then r_refdef.viewcache must be regenerated + // by calling R_View_Update + // (which also updates viewport, scissor, colormask) - // fullscreen color blend - float viewblend[4]; + // 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, inverse_matrix; + vec3_t origin; + vec3_t forward; + vec3_t left; + vec3_t right; + vec3_t up; + int numfrustumplanes; + mplane_t frustum[6]; + qboolean useclipplane; + qboolean usecustompvs; // uses r_refdef.viewcache.pvsbits as-is rather than computing it + mplane_t clipplane; + float frustum_x, frustum_y; + vec3_t frustumcorner[4]; + // if turned off it renders an ortho view + int useperspective; + float ortho_x, ortho_y; + + // screen area to render in + int x; + int y; + int z; + int width; + int height; + int depth; + r_viewport_t viewport; + // which color components to allow (for anaglyph glasses) + int colormask[4]; + + // global RGB color multiplier for rendering, this is required by HDR + 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; + + // whether to draw r_showtris and such, this is only true for the main + // view render, all secondary renders (HDR, mirrors, portals, cameras, + // distortion effects, etc) omit such debugging information + qboolean showdebug; + + // 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; + +typedef struct r_refdef_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.scene.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.scene.worldmodel->brush.num_clusters + unsigned char world_pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps + // TODO: dynamic resize according to r_refdef.scene.worldmodel->brush.num_leafs + unsigned char world_leafvisible[32768]; // FIXME: buffer overflow on huge maps + // TODO: dynamic resize according to r_refdef.scene.worldmodel->num_surfaces + unsigned char world_surfacevisible[262144]; // FIXME: buffer overflow on huge maps + // if true, the view is currently in a leaf without pvs data + qboolean world_novis; +} +r_refdef_viewcache_t; + +// TODO: really think about which fields should go into scene and which one should stay in refdef [1/7/2008 Black] +// maybe also refactor some of the functions to support different setting sources (ie. fogenabled, etc.) for different scenes +typedef struct r_refdef_scene_s { // whether to call S_ExtraUpdate during render to reduce sound chop qboolean extraupdate; - // client gameworld time for rendering time based effects + // (client gameworld) time for rendering time based effects double time; // the world entity_render_t *worldentity; // same as worldentity->model - model_t *worldmodel; + dp_model_t *worldmodel; // renderable entities (excluding world) entity_render_t **entities; int numentities; int maxentities; + // field of temporary entities that is reset each (client) frame + entity_render_t *tempentities; + int numtempentities; + 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 + float rtlightstylevalue[256]; // float fraction of base light value // 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 + // 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 +{ + // 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; + + // current view settings (these get reset a few times during rendering because of water rendering, reflections, etc) + r_refdef_view_t view; + r_refdef_viewcache_t viewcache; + + // 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]; + + r_refdef_scene_t scene; vec3_t fogcolor; vec_t fogrange; @@ -1341,10 +1609,14 @@ typedef struct r_refdef_s vec_t fogmasktabledistmultiplier; #define FOGMASKTABLEWIDTH 1024 float fogmasktable[FOGMASKTABLEWIDTH]; + float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density; float fog_density; float fog_red; float fog_green; float fog_blue; + float fog_alpha; + float fog_start; + float fog_end; qboolean fogenabled; qboolean oldgl_fogenable; @@ -1357,10 +1629,6 @@ 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; @@ -1372,67 +1640,7 @@ typedef struct r_refdef_s } r_refdef_t; -typedef struct r_view_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; - vec3_t origin; - vec3_t forward; - vec3_t left; - vec3_t right; - vec3_t up; - mplane_t frustum[5]; - float frustum_x, frustum_y; - vec3_t frustumcorner[4]; - - // 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; -} -r_viewcache_t; - extern r_refdef_t r_refdef; -extern r_view_t r_view; -extern r_viewcache_t r_viewcache; #endif