X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=client.h;h=4252da919bfeb237c945a93d2887b8aad0f8f375;hp=dfa11cbe48d46b3dcec3b3c3ecaabb367a35ba7a;hb=4f8b0b7d14c4a3c6ef8c03abb8d94f17e376d7b7;hpb=2e220ac2a9e220560821a03f66c2fcdfa6232f16 diff --git a/client.h b/client.h index dfa11cbe..4252da91 100644 --- a/client.h +++ b/client.h @@ -27,6 +27,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // 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 + // flags for rtlight rendering #define LIGHTFLAG_NORMALMODE 1 #define LIGHTFLAG_REALTIMEMODE 2 @@ -55,12 +59,6 @@ typedef struct beam_s struct model_s *model; float endtime; vec3_t start, end; - // if this beam is owned by an entity, this is the beam start relative to - // that entity's matrix for per frame start updates - vec3_t relativestart; - vec3_t relativeend; - // indicates whether relativestart is valid - int relativestartvalid; } beam_t; @@ -71,6 +69,8 @@ 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 + 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) @@ -128,6 +128,19 @@ typedef struct rtlight_s // 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; } rtlight_t; @@ -152,11 +165,7 @@ typedef struct dlight_s // 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 @@ -165,9 +174,16 @@ typedef struct dlight_s // 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; @@ -196,7 +212,7 @@ typedef struct dlight_s // (worldlight only) struct dlight_s *next; // embedded rtlight struct for renderer - // (renderer only) + // (worldlight only) rtlight_t rtlight; } dlight_t; @@ -213,9 +229,9 @@ frameblend_t; 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 @@ -259,8 +275,6 @@ typedef struct entity_render_s // calculated by the renderer (but not persistent) - // if visframe == r_framecount, it is visible - int visframe; // 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 @@ -270,13 +284,14 @@ typedef struct entity_render_s vec3_t modellight_ambient; vec3_t modellight_diffuse; // q3bsp vec3_t modellight_lightdir; // q3bsp + + // last time visible during trace culling + double last_trace_visibility; } entity_render_t; typedef struct entity_persistent_s { - int linkframe; - vec3_t trail_origin; // particle trail @@ -301,7 +316,6 @@ entity_persistent_t; typedef struct entity_s { - qboolean csqc; // baseline state (default values) entity_state_t state_baseline; // previous state (interpolating from this) @@ -336,6 +350,7 @@ typedef struct usercmd_s double time; double receivetime; + int msec; // for qw moves int buttons; int impulse; int sequence; @@ -409,13 +424,47 @@ qw_downloadtype_t; typedef enum capturevideoformat_e { - CAPTUREVIDEOFORMAT_TARGA, - CAPTUREVIDEOFORMAT_JPEG, - CAPTUREVIDEOFORMAT_RAWRGB, - CAPTUREVIDEOFORMAT_RAWYV12 + CAPTUREVIDEOFORMAT_AVI_I420 } capturevideoformat_t; +typedef struct capturevideostate_s +{ + double starttime; + 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; + qboolean active; + qboolean realtime; + qboolean error; + capturevideoformat_t format; + int soundrate; + 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]; + short rgbtoyuvscaletable[3][3][256]; + unsigned char yuvnormalizetable[3][256]; + char basename[64]; +} +capturevideostate_t; + +#define CL_MAX_DOWNLOADACKS 4 + +typedef struct cl_downloadack_s +{ + int start, size; +} +cl_downloadack_t; + // // the client_static_t structure is persistent through an arbitrary number // of server connections @@ -450,10 +499,12 @@ typedef struct client_static_s int td_startframe; // realtime at second frame of timedemo (LordHavoc: changed to double) double td_starttime; - // LordHavoc: for measuring maxfps - double td_minframetime; - // LordHavoc: for measuring minfps - double td_maxframetime; + double td_onesecondnexttime; + double td_onesecondframes; + double td_onesecondminframes; + double td_onesecondmaxframes; + double td_onesecondavgframes; + int td_onesecondavgcount; // LordHavoc: pausedemo qboolean demopaused; @@ -472,10 +523,21 @@ typedef struct client_static_s // 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 + int movesequence; + 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; // current file download buffer (only saved when file is completed) char qw_downloadname[MAX_QPATH]; @@ -485,6 +547,10 @@ typedef struct client_static_s int qw_downloadnumber; int qw_downloadpercent; qw_downloadtype_t qw_downloadtype; + // transfer rate display + double qw_downloadspeedtime; + int qw_downloadspeedcount; + int qw_downloadspeedrate; // current file upload buffer (for uploading screenshots to server) unsigned char *qw_uploaddata; @@ -497,17 +563,7 @@ typedef struct client_static_s 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]; + capturevideostate_t capturevideo; } client_static_t; @@ -533,18 +589,6 @@ typedef struct qboolean drawcrosshair; }csqc_vidvars_t; -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; - typedef enum { PARTICLE_BILLBOARD = 0, @@ -592,13 +636,31 @@ typedef struct particle_s 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 + 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 } particle_t; +typedef enum cl_parsingtextmode_e +{ + CL_PARSETEXTMODE_NONE, + CL_PARSETEXTMODE_PING, + CL_PARSETEXTMODE_STATUS, + CL_PARSETEXTMODE_STATUS_PLAYERID, + CL_PARSETEXTMODE_STATUS_PLAYERIP +} +cl_parsingtextmode_t; + +typedef struct cl_locnode_s +{ + struct cl_locnode_s *next; + char *name; + vec3_t mins, maxs; +} +cl_locnode_t; + // // the client_state_t structure is wiped completely at every // server signon @@ -608,15 +670,13 @@ typedef struct client_state_s // 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 @@ -631,6 +691,9 @@ typedef struct client_state_s float weapontime; // use pain anim frame if cl.time < this float faceanimtime; + // for stair smoothing + float stairsmoothz; + double stairsmoothtime; // color shifts for damage, powerups cshift_t cshifts[NUM_CSHIFTS]; @@ -662,23 +725,24 @@ typedef struct client_state_s // client movement simulation // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet) - qboolean movement; + // set by CL_ClientMovement_Replay functions + 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; - // 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]; + 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[64]; - int movesequence; - int servermovesequence; + client_movementqueue_t movement_queue[256]; + // whether the replay should allow a jump at the first sequence + qboolean movement_replay_canjump; // pitch drifting vars float idealpitch; @@ -717,6 +781,8 @@ typedef struct client_state_s // 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) @@ -757,6 +823,8 @@ typedef struct client_state_s 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) + qboolean foundtalk2wav; // refresh related state @@ -774,6 +842,16 @@ typedef struct client_state_s // [cl.maxclients] scoreboard_t *scores; + // keep track of svc_print parsing state (analyzes ping reports and status reports) + cl_parsingtextmode_t parsingtextmode; + int parsingtextplayerindex; + // set by scoreboard code when sending ping command, this causes the next ping results to be hidden + // (which could eat the wrong ping report if the player issues one + // 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) + int parsingtextexpectingpingforscores; + // entity database stuff // latest received entity frame numbers #define LATESTFRAMENUMS 3 @@ -793,7 +871,6 @@ typedef struct client_state_s vec3_t playercrouchmaxs; int max_entities; - int max_csqcentities; int max_static_entities; int max_temp_entities; int max_effects; @@ -804,9 +881,7 @@ typedef struct client_state_s int max_particles; entity_t *entities; - entity_t *csqcentities; //[515]: csqc unsigned char *entities_active; - unsigned char *csqcentities_active; //[515]: csqc entity_t *static_entities; entity_t *temp_entities; cl_effect_t *effects; @@ -817,7 +892,6 @@ typedef struct client_state_s particle_t *particles; int num_entities; - int num_csqcentities; //[515]: csqc int num_static_entities; int num_temp_entities; int num_brushmodel_entities; @@ -828,6 +902,17 @@ typedef struct client_state_s int free_particle; + // cl_serverextension_download feature + int loadmodel_current; + int downloadmodel_current; + int loadmodel_total; + int loadsound_current; + int downloadsound_current; + int loadsound_total; + qboolean downloadcsqc; + qboolean loadbegun; + qboolean loadfinished; + // quakeworld stuff // local copy of the server infostring @@ -842,8 +927,9 @@ typedef struct client_state_s // 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].qw_spectator instead + //qboolean qw_spectator; // movement parameters for client prediction float qw_movevars_gravity; @@ -874,9 +960,18 @@ typedef struct client_state_s int qw_validsequence; - qw_usercmd_t qw_moves[QW_UPDATE_BACKUP]; - int qw_deltasequence[QW_UPDATE_BACKUP]; + + // csqc stuff: + + // 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; } client_state_t; @@ -907,11 +1002,11 @@ extern cvar_t cl_anglespeedkey; extern cvar_t cl_autofire; -extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat -extern cvar_t csqc_progcrc; - 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; @@ -940,9 +1035,14 @@ extern cvar_t cl_stainmaps_clearonload; extern cvar_t cl_prydoncursor; +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, int cubemapnum, 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); //============================================================================= @@ -958,11 +1058,8 @@ void CL_EstablishConnection(const char *host); void CL_Disconnect (void); void CL_Disconnect_f (void); -void CL_BoundingBoxForEntity(entity_render_t *ent); - -extern cvar_t cl_beams_polygons; -extern cvar_t cl_beams_relative; -extern cvar_t cl_beams_lightatend; +void CL_UpdateRenderEntity(entity_render_t *ent); +void CL_UpdateViewEntities(void); // // cl_input @@ -985,7 +1082,10 @@ 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_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); @@ -994,11 +1094,12 @@ void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float 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); -int CL_ReadFromServer (void); +void CL_UpdateWorld (void); void CL_WriteToServer (void); -void CL_Move (void); +void CL_Input (void); extern qboolean cl_ignoremousemove; @@ -1011,7 +1112,7 @@ int Key_StringToKeynum (const char *str); // void CL_StopPlayback(void); void CL_ReadDemoMessage(void); -void CL_WriteDemoMessage(void); +void CL_WriteDemoMessage(sizebuf_t *mesage); void CL_NextDemo(void); void CL_Stop_f(void); @@ -1053,10 +1154,11 @@ 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_rain; +extern cvar_t cl_particles_snow; extern cvar_t cl_particles_smoke; extern cvar_t cl_particles_smoke_alpha; extern cvar_t cl_particles_smoke_alphafade; @@ -1081,7 +1183,6 @@ typedef enum effectnameindex_s EFFECT_TE_SUPERSPIKEQUAD, EFFECT_TE_WIZSPIKE, EFFECT_TE_KNIGHTSPIKE, - EFFECT_TE_VORESPIKE, EFFECT_TE_EXPLOSION, EFFECT_TE_EXPLOSIONQUAD, EFFECT_TE_TAREXPLOSION, @@ -1116,6 +1217,7 @@ 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_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_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); @@ -1126,26 +1228,58 @@ 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_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a); +void Debug_PolygonEnd(void); + #include "cl_screen.h" +extern qboolean sb_showscores; + #define NUMCROSSHAIRS 32 extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1]; -typedef struct refdef_s +#define FOGTABLEWIDTH 1024 +extern int fogtableindex; +#define VERTEXFOGTABLE(dist) (fogtableindex = (int)((dist) * r_refdef.fogtabledistmultiplier), r_refdef.fogtable[bound(0, fogtableindex, FOGTABLEWIDTH - 1)]) + +typedef struct r_refdef_stats_s { - // area to render in - int x, y, width, height; - float frustum_x, frustum_y; + 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; + +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; - // view transform - matrix4x4_t viewentitymatrix; - - // which color components to allow (for anaglyph glasses) - int colormask[4]; + // 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]; @@ -1168,18 +1302,110 @@ typedef struct refdef_s int maxentities; // renderable dynamic lights - dlight_t *lights[MAX_DLIGHTS]; + rtlight_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; +} +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; } -refdef_t; +r_viewcache_t; -extern refdef_t r_refdef; +extern r_refdef_t r_refdef; +extern r_view_t r_view; +extern r_viewcache_t r_viewcache; #endif