]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - client.h
CPMA-style cl_movement physics settings possible! Variables for it:
[xonotic/darkplaces.git] / client.h
index 3a5a563503d944c46bbfcae4dd43d13c6b880ae6..e470b9a5a4a8d7459bce12f2269e1fec2830b983 100644 (file)
--- 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 256
 
 // 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;
@@ -110,6 +110,10 @@ typedef struct rtlight_s
        // 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;
 
@@ -119,7 +123,8 @@ typedef struct rtlight_s
        // 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;
@@ -217,10 +222,27 @@ 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;
 
@@ -248,7 +270,7 @@ typedef struct entity_render_s
        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
@@ -266,25 +288,18 @@ 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];
 
        // current lighting from map (updated ONLY by client code, not renderer)
        vec3_t modellight_ambient;
@@ -356,14 +371,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
@@ -391,7 +413,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
@@ -434,46 +457,51 @@ 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_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;
 
@@ -511,11 +539,13 @@ 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
@@ -580,6 +610,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;
@@ -624,7 +655,8 @@ typedef enum
        PARTICLE_BILLBOARD = 0,
        PARTICLE_SPARK = 1,
        PARTICLE_ORIENTED_DOUBLESIDED = 2,
-       PARTICLE_BEAM = 3
+       PARTICLE_BEAM = 3,
+       PARTICLE_INVALID = -1
 }
 porientation_t;
 
@@ -632,7 +664,8 @@ typedef enum
 {
        PBLEND_ALPHA = 0,
        PBLEND_ADD = 1,
-       PBLEND_MOD = 2
+       PBLEND_INVMOD = 2,
+       PBLEND_INVALID = -1
 }
 pblend_t;
 
@@ -652,7 +685,7 @@ ptype_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;
@@ -661,11 +694,12 @@ typedef struct decal_s
        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
 }
@@ -674,14 +708,17 @@ decal_t;
 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
@@ -794,18 +831,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;
 
@@ -882,10 +910,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;
@@ -1030,6 +1058,10 @@ 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;
 
        // models used by qw protocol
        int qw_modelindex_spike;
@@ -1184,13 +1216,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_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);
 
@@ -1216,6 +1248,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);
@@ -1232,6 +1267,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
@@ -1412,6 +1448,8 @@ typedef struct r_refdef_view_s
 
        // 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,
@@ -1460,7 +1498,7 @@ typedef struct r_refdef_scene_s {
        entity_render_t *worldentity;
 
        // same as worldentity->model
-       model_t *worldmodel;
+       dp_model_t *worldmodel;
 
        // renderable entities (excluding world)
        entity_render_t **entities;
@@ -1473,7 +1511,8 @@ typedef struct r_refdef_scene_s {
        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