]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - client.h
optimized SHOWLMP code (only used by Nehahra) to not eat any CPU time
[xonotic/darkplaces.git] / client.h
index e725a11feca351d401541d3390c3d95f9eea0726..559d0e94c3a38a4584d41f72ed4b0faf5bac357c 100644 (file)
--- 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
@@ -65,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)
@@ -122,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;
 
@@ -146,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
@@ -159,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;
@@ -190,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;
@@ -221,8 +243,8 @@ typedef struct entity_render_s
 
        // NULL = no model
        model_t *model;
-       // current uninterpolated animation frame (for things which do not use interpolation)
-       int frame;
+       // 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
@@ -230,6 +252,8 @@ typedef struct entity_render_s
        vec3_t colormap_shirtcolor;
        // light, particles, etc
        int effects;
+       // qw CTF flags and other internal-use-only effect bits
+       int internaleffects;
        // for Alias models
        int skinnum;
        // render flags
@@ -262,17 +286,19 @@ 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
        float trail_time;
+       qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
 
        // muzzleflash fading
        float muzzleflash;
@@ -293,7 +319,6 @@ entity_persistent_t;
 
 typedef struct entity_s
 {
-       qboolean csqc;
        // baseline state (default values)
        entity_state_t state_baseline;
        // previous state (interpolating from this)
@@ -328,10 +353,12 @@ typedef struct usercmd_s
 
        double time;
        double receivetime;
+       int msec; // for qw 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
 } usercmd_t;
 
 typedef struct lightstyle_s
@@ -410,9 +437,17 @@ typedef struct capturevideostate_s
        double starttime;
        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;
@@ -421,7 +456,8 @@ typedef struct capturevideostate_s
        int soundrate;
        int frame;
        int soundsampleframe; // for AVI saving
-       unsigned char *buffer;
+       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!
@@ -431,9 +467,18 @@ typedef struct capturevideostate_s
        short rgbtoyuvscaletable[3][3][256];
        unsigned char yuvnormalizetable[3][256];
        char basename[64];
+       int width, height;
 }
 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
@@ -468,10 +513,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;
 
@@ -490,6 +537,14 @@ 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
@@ -506,6 +561,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;
@@ -533,6 +592,7 @@ typedef struct client_movementqueue_s
        float move[3];
        qboolean jump;
        qboolean crouch;
+       qboolean canjump;
 }
 client_movementqueue_t;
 
@@ -544,18 +604,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,
@@ -607,6 +655,9 @@ typedef struct particle_s
        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
 }
 particle_t;
 
@@ -620,6 +671,24 @@ typedef enum cl_parsingtextmode_e
 }
 cl_parsingtextmode_t;
 
+typedef struct cl_locnode_s
+{
+       struct cl_locnode_s *next;
+       char *name;
+       vec3_t mins, maxs;
+}
+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
@@ -629,19 +698,18 @@ 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
        int stats[MAX_CL_STATS];
+       float *statsf; // points to stats[] array
        // last known inventory bit flags, for blinking
        int olditems;
        // cl.time of acquiring item, for blinking
@@ -653,7 +721,8 @@ typedef struct client_state_s
        // use pain anim frame if cl.time < this
        float faceanimtime;
        // for stair smoothing
-       float stairoffset;
+       float stairsmoothz;
+       double stairsmoothtime;
 
        // color shifts for damage, powerups
        cshift_t cshifts[NUM_CSHIFTS];
@@ -687,13 +756,13 @@ typedef struct client_state_s
        // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
        // 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;
@@ -701,8 +770,6 @@ typedef struct client_state_s
        // queue of proposed moves
        int movement_numqueue;
        client_movementqueue_t movement_queue[256];
-       int movesequence;
-       int servermovesequence;
        // whether the replay should allow a jump at the first sequence
        qboolean movement_replay_canjump;
 
@@ -743,6 +810,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)
@@ -765,6 +834,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;
@@ -783,6 +857,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
 
@@ -829,7 +905,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;
@@ -838,11 +913,10 @@ typedef struct client_state_s
        int max_lightstyle;
        int max_brushmodel_entities;
        int max_particles;
+       int max_showlmps;
 
        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;
@@ -851,9 +925,9 @@ typedef struct client_state_s
        lightstyle_t *lightstyle;
        int *brushmodel_entities;
        particle_t *particles;
+       showlmp_t *showlmps;
 
        int num_entities;
-       int num_csqcentities;   //[515]: csqc
        int num_static_entities;
        int num_temp_entities;
        int num_brushmodel_entities;
@@ -861,9 +935,22 @@ typedef struct client_state_s
        int num_beams;
        int num_dlights;
        int num_particles;
+       int num_showlmps;
 
        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 loadcsqc;
+       qboolean loadbegun;
+       qboolean loadfinished;
+
        // quakeworld stuff
 
        // local copy of the server infostring
@@ -879,20 +966,29 @@ 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;
 
        // movement parameters for client prediction
-       float qw_movevars_gravity;
-       float qw_movevars_stopspeed;
-       float qw_movevars_maxspeed; // can change during play
-       float qw_movevars_spectatormaxspeed;
-       float qw_movevars_accelerate;
-       float qw_movevars_airaccelerate;
-       float qw_movevars_wateraccelerate;
-       float qw_movevars_friction;
-       float qw_movevars_waterfriction;
-       float qw_movevars_entgravity; // can change during play
+       float movevars_wallfriction;
+       float movevars_waterfriction;
+       float movevars_friction;
+       float movevars_ticrate;
+       float movevars_timescale;
+       float movevars_gravity;
+       float movevars_stopspeed;
+       float movevars_maxspeed;
+       float movevars_spectatormaxspeed;
+       float movevars_accelerate;
+       float movevars_airaccelerate;
+       float movevars_wateraccelerate;
+       float movevars_entgravity;
+       float movevars_jumpvelocity;
+       float movevars_edgefriction;
+       float movevars_maxairspeed;
+       float movevars_stepheight;
+       float movevars_airaccel_qw;
+       float movevars_airaccel_sideways_friction;
 
        // models used by qw protocol
        int qw_modelindex_spike;
@@ -911,9 +1007,31 @@ typedef struct client_state_s
 
        int qw_validsequence;
 
-       qw_usercmd_t qw_moves[QW_UPDATE_BACKUP];
-
        int qw_deltasequence[QW_UPDATE_BACKUP];
+
+       // csqc stuff:
+       // 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;
+       qboolean csqc_usecsqclistener;
+       matrix4x4_t csqc_listenermatrix;
+       char csqc_printtextbuf[MAX_INPUTLINE];
+
+       // 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;
+
+       // processing buffer used by R_BuildLightMap, reallocated as needed,
+       // freed on each level change
+       size_t buildlightmapmemorysize;
+       unsigned char *buildlightmapmemory;
 }
 client_state_t;
 
@@ -946,6 +1064,9 @@ extern cvar_t cl_autofire;
 
 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;
@@ -974,9 +1095,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);
 
 //=============================================================================
 
@@ -993,6 +1119,7 @@ void CL_Disconnect (void);
 void CL_Disconnect_f (void);
 
 void CL_UpdateRenderEntity(entity_render_t *ent);
+void CL_UpdateViewEntities(void);
 
 //
 // cl_input
@@ -1018,6 +1145,7 @@ 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);
@@ -1029,9 +1157,9 @@ 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;
 
 
@@ -1044,7 +1172,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);
@@ -1086,10 +1214,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;
@@ -1148,6 +1277,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);
@@ -1158,6 +1288,10 @@ 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;
@@ -1165,9 +1299,8 @@ extern qboolean sb_showscores;
 #define NUMCROSSHAIRS 32
 extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1];
 
-#define FOGTABLEWIDTH 1024
-extern int fogtableindex;
-#define VERTEXFOGTABLE(dist) (fogtableindex = (int)((dist) * r_refdef.fogtabledistmultiplier), r_refdef.fogtable[bound(0, fogtableindex, FOGTABLEWIDTH - 1)])
+float FogPoint_World(const vec3_t p);
+float FogPoint_Model(const vec3_t p);
 
 typedef struct r_refdef_stats_s
 {
@@ -1228,7 +1361,7 @@ typedef struct r_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
@@ -1238,8 +1371,9 @@ typedef struct r_refdef_s
        vec3_t fogcolor;
        vec_t fogrange;
        vec_t fograngerecip;
-       vec_t fogtabledistmultiplier;
-       float fogtable[FOGTABLEWIDTH];
+       vec_t fogmasktabledistmultiplier;
+#define FOGMASKTABLEWIDTH 1024
+       float fogmasktable[FOGMASKTABLEWIDTH];
        float fog_density;
        float fog_red;
        float fog_green;
@@ -1283,14 +1417,22 @@ typedef struct r_view_s
        // (as long as R_View_Update is called)
 
        // eye position information
-       matrix4x4_t matrix;
+       matrix4x4_t matrix, inverse_matrix;
        vec3_t origin;
        vec3_t forward;
        vec3_t left;
        vec3_t right;
        vec3_t up;
-       mplane_t frustum[5];
+       int numfrustumplanes;
+       mplane_t frustum[6];
+       qboolean useclipplane;
+       qboolean usecustompvs; // uses r_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;
@@ -1305,6 +1447,18 @@ typedef struct r_view_s
 
        // global RGB color multiplier for rendering, this is required by HDR
        float colorscale;
+
+       // whether to call R_ClearScreen before rendering stuff
+       qboolean clear;
+
+       // 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;
 }
 r_view_t;
 
@@ -1318,11 +1472,11 @@ typedef struct r_viewcache_s
        // 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];
+       unsigned char world_pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
        // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_leafs
-       unsigned char world_leafvisible[32768];
+       unsigned char world_leafvisible[32768]; // FIXME: buffer overflow on huge maps
        // TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces
-       unsigned char world_surfacevisible[262144];
+       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;
 }