typedef struct
{
int entity;
+ // draw this as lightning polygons, or a model?
+ int lightning;
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;
-typedef struct
+typedef struct rtlight_s
{
+ // shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin
+
+ // note that the world to light matrices are inversely scaled (divided) by lightradius
+
+ // core properties
+ // matrix for transforming world coordinates to light filter coordinates
+ matrix4x4_t matrix_worldtolight;
+ // based on worldtolight this transforms -1 to +1 to 0 to 1 for purposes
+ // of attenuation texturing in full 3D (Z result often ignored)
+ matrix4x4_t matrix_worldtoattenuationxyz;
+ // this transforms only the Z to S, and T is always 0.5
+ matrix4x4_t matrix_worldtoattenuationz;
+ // typically 1 1 1, can be lower (dim) or higher (overbright)
+ vec3_t color;
+ // size of the light (remove?)
+ vec_t radius;
+ // light filter
+ char cubemapname[64];
+ // whether light should render shadows
+ int shadow;
+ // intensity of corona to render
+ vec_t corona;
+ // light style to monitor for brightness
+ int style;
+
+ // generated properties
+ // used only for shadow volumes
+ vec3_t shadoworigin;
+ // culling
+ vec3_t cullmins;
+ vec3_t cullmaxs;
+ // culling
+ //vec_t cullradius;
+ // squared cullradius
+ //vec_t cullradius2;
+
+ // lightmap renderer stuff (remove someday!)
+ // the size of the light
+ vec_t lightmap_cullradius;
+ // the size of the light, squared
+ vec_t lightmap_cullradius2;
+ // the brightness of the light
+ vec3_t lightmap_light;
+ // to avoid sudden brightness change at cullradius, subtract this
+ vec_t lightmap_subtract;
+
+ // 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
+ int compiled;
+ // premade shadow volumes and lit surfaces to render for world entity
+ shadowmesh_t *static_meshchain_shadow;
+ shadowmesh_t *static_meshchain_light;
+ // used for visibility testing (more exact than bbox)
+ int static_numclusters;
+ int static_numclusterpvsbytes;
+ int *static_clusterlist;
+ qbyte *static_clusterpvs;
+}
+rtlight_t;
+
+typedef struct dlight_s
+{
+ // destroy light after this time
+ // (dlight only)
+ vec_t die;
+ // the entity that owns this light (can be NULL)
+ // (dlight only)
+ struct entity_render_s *ent;
// location
- vec3_t origin;
- // stop lighting after this time
- float die;
+ // (worldlight: saved to .rtlights file)
+ vec3_t origin;
+ // worldlight orientation
+ // (worldlight only)
+ // (worldlight: saved to .rtlights file)
+ vec3_t angles;
+ // dlight orientation/scaling/location
+ // (dlight only)
+ matrix4x4_t matrix;
// color of light
- vec3_t color;
+ // (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
+ // (worldlight only)
+ int selected;
// brightness (not really radius anymore)
- float radius;
- // drop this each second
- float decay;
- // the entity that owns this light (can be NULL)
- struct entity_render_s *ent;
+ // (worldlight: saved to .rtlights file)
+ vec_t radius;
+ // drop radius this much each second
+ // (dlight only)
+ vec_t decay;
+ // light style which controls intensity of this light
+ // (worldlight: saved to .rtlights file)
+ int style;
+ // cast shadows
+ // (worldlight: saved to .rtlights file)
+ int shadow;
+ // corona intensity
+ // (worldlight: saved to .rtlights file)
+ vec_t corona;
+ // linked list of world lights
+ // (worldlight only)
+ struct dlight_s *next;
+ // embedded rtlight struct for renderer
+ // (renderer only)
+ rtlight_t rtlight;
}
dlight_t;
}
frameblend_t;
-// LordHavoc: disregard the following warning, entlights stuff is semi-persistent...
-// LordHavoc: nothing in this structure is persistent, it may be overwritten by the client every frame, for persistent data use entity_lerp_t.
+// LordHavoc: this struct is intended for the renderer but some fields are
+// used by the client.
typedef struct entity_render_s
{
// location
// render flags
int flags;
- // these are copied from the persistent data
+ // interpolated animation
// frame that the model is interpolating from
int frame1;
// frame that the model is interpolating to
int frame2;
// interpolation factor, usually computed from frame2time
- double framelerp;
+ float framelerp;
// time frame1 began playing (for framegroup animations)
double frame1time;
// time frame2 began playing (for framegroup animations)
typedef struct entity_persistent_s
{
- // particles
+ int linkframe;
- // trail rendering
vec3_t trail_origin;
- float trail_time;
- // effects
+ // particle trail
+ float trail_time;
// muzzleflash fading
float muzzleflash;
float oldangles[3];
float neworigin[3];
float newangles[3];
-
- // interpolated animation
-
- // lerp resets when model changes
- int modelindex;
- // frame that the model is interpolating from
- int frame1;
- // frame that the model is interpolating to
- int frame2;
- // interpolation factor, usually computed from frame2time
- double framelerp;
- // time frame1 began playing (for framegroup animations)
- double frame1time;
- // time frame2 began playing (for framegroup animations)
- double frame2time;
}
entity_persistent_t;
typedef struct
{
char name[MAX_SCOREBOARDNAME];
- float entertime;
int frags;
int colors; // two 4 bit fields
} scoreboard_t;
#define CSHIFT_DAMAGE 1
#define CSHIFT_BONUS 2
#define CSHIFT_POWERUP 3
-#define NUM_CSHIFTS 4
+#define CSHIFT_VCSHIFT 4
+#define NUM_CSHIFTS 5
#define NAME_LENGTH 64
int demonum;
// list of demos in loop
char demos[MAX_DEMOS][MAX_DEMONAME];
+ // the actively playing demo (set by CL_PlayDemo_f)
+ char demoname[64];
// demo recording info must be here, because record is started before
// entering a map (and clearing client_state_t)
qboolean timedemo;
// -1 = use normal cd track
int forcetrack;
- QFile *demofile;
+ 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;
+ // LordHavoc: for measuring maxfps
+ double td_minframetime;
+ // LordHavoc: for measuring minfps
+ double td_maxframetime;
// LordHavoc: pausedemo
qboolean demopaused;
+ qboolean connect_trying;
+ int connect_remainingtries;
+ double connect_nextsendtime;
+ lhnetsocket_t *connect_mysocket;
+ lhnetaddress_t connect_address;
// connection information
// 0 to SIGNONS
int signon;
- // network socket
- struct qsocket_s *netcon;
+ // network connection
+ netconn_t *netcon;
// writing buffer to send to server
sizebuf_t message;
}
//
typedef struct
{
+ // 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;
int items;
// cl.time of acquiring item, for blinking
float item_gettime[32];
+ // cl.time of changing STAT_ACTIVEWEAPON
+ float weapontime;
// use pain anim frame if cl.time < this
float faceanimtime;
// [cl.maxclients]
scoreboard_t *scores;
- // used by view code for setting up eye position
- vec3_t viewentorigin;
// LordHavoc: sniping zoom, QC controlled
float viewzoom;
// for interpolation
float viewzoomold, viewzoomnew;
+ // protocol version of the server we're connected to
+ int protocol;
+
// entity database stuff
- vec3_t viewentoriginold, viewentoriginnew;
- entity_database_t entitydatabase;
+ // latest received entity frame number
+ int latestframenum;
+ entityframe_database_t *entitydatabase;
+ entityframe4_database_t *entitydatabase4;
}
client_state_t;
//
extern cvar_t cl_name;
extern cvar_t cl_color;
+extern cvar_t cl_rate;
extern cvar_t cl_pmodel;
extern cvar_t cl_upspeed;
extern cvar_t r_draweffects;
-extern cvar_t cl_explosions;
+extern cvar_t cl_explosions_alpha_start;
+extern cvar_t cl_explosions_alpha_end;
+extern cvar_t cl_explosions_size_start;
+extern cvar_t cl_explosions_size_end;
+extern cvar_t cl_explosions_lifetime;
extern cvar_t cl_stainmaps;
+extern cvar_t cl_stainmapsclearonload;
// these are updated by CL_ClearState
extern int cl_num_entities;
extern int cl_num_temp_entities;
extern int cl_num_brushmodel_entities;
+extern mempool_t *cl_entities_mempool;
extern entity_t *cl_entities;
extern qbyte *cl_entities_active;
extern entity_t *cl_static_entities;
extern client_state_t cl;
-extern void CL_AllocDlight (entity_render_t *ent, vec3_t org, float radius, float red, float green, float blue, float decay, float lifetime);
+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);
extern void CL_DecayLights (void);
//=============================================================================
void CL_Init (void);
-void CL_EstablishConnection (char *host);
+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;
+
//
// cl_input
//
extern kbutton_t in_speed;
void CL_InitInput (void);
-void CL_SendCmd (void);
+void CL_SendCmd (usercmd_t *cmd);
void CL_SendMove (usercmd_t *cmd);
+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_RelinkBeams (void);
float CL_KeyState (kbutton_t *key);
-char *Key_KeynumToString (int keynum);
+const char *Key_KeynumToString (int keynum);
//
// cl_demo.c
//
-void CL_StopPlayback (void);
-int CL_GetMessage (void);
+void CL_StopPlayback(void);
+void CL_ReadDemoMessage(void);
+void CL_WriteDemoMessage(void);
-void CL_NextDemo (void);
-void CL_Stop_f (void);
-void CL_Record_f (void);
-void CL_PlayDemo_f (void);
-void CL_TimeDemo_f (void);
+void CL_NextDemo(void);
+void CL_Stop_f(void);
+void CL_Record_f(void);
+void CL_PlayDemo_f(void);
+void CL_TimeDemo_f(void);
//
// cl_parse.c
void CL_ParseParticleEffect (void);
void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count);
-void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent);
-void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent);
+void CL_RocketTrail (vec3_t start, vec3_t end, int type, int color, entity_t *ent);
void CL_SparkShower (vec3_t org, vec3_t dir, int count);
void CL_PlasmaBurn (vec3_t org);
void CL_BloodPuff (vec3_t org, vec3_t vel, int count);
int x, y, width, height;
float fov_x, fov_y;
- // view point
- vec3_t vieworg;
- vec3_t viewangles;
+ // these are set for water warping before
+ // fov_x/fov_y are calculated
+ float fovscale_x, fovscale_y;
+
+ // view transform
+ matrix4x4_t viewentitymatrix;
+
+ // which color components to allow (for anaglyph glasses)
+ int colormask[4];
// fullscreen color blend
float viewblend[4];
#include "cgamevm.h"
-void Host_PerformSpawnServerAndLoadGame(void);
-
#endif