2611 lines
80 KiB
C
2611 lines
80 KiB
C
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
#include "../game/q_shared.h"
|
|
#include "tr_types.h"
|
|
#include "../game/bg_public.h"
|
|
#include "cg_public.h"
|
|
|
|
// The entire cgame module is unloaded and reloaded on each level change,
|
|
// so there is NO persistant data between levels on the client side.
|
|
// If you absolutely need something stored, it can either be kept
|
|
// by the server in the server stored userinfos, or stashed in a cvar.
|
|
|
|
#ifndef __LCC__
|
|
#define CGAME_INLINE ID_INLINE
|
|
#else
|
|
#define CGAME_INLINE //none
|
|
#endif
|
|
|
|
#define NULL_HANDLE ((qhandle_t) 0)
|
|
#define NULL_SOUND ((sfxHandle_t) 0)
|
|
#define NULL_FX ((fxHandle_t) 0)
|
|
|
|
#define POWERUP_BLINKS 5
|
|
|
|
#define POWERUP_BLINK_TIME 1000
|
|
#define FADE_TIME 200
|
|
#define PULSE_TIME 200
|
|
#define DAMAGE_DEFLECT_TIME 100
|
|
#define DAMAGE_RETURN_TIME 400
|
|
#define DAMAGE_TIME 500
|
|
#define LAND_DEFLECT_TIME 150
|
|
#define LAND_RETURN_TIME 300
|
|
#define STEP_TIME 200
|
|
#define DUCK_TIME 100
|
|
#define PAIN_TWITCH_TIME 200
|
|
#define WEAPON_SELECT_TIME 1400
|
|
#define ITEM_SCALEUP_TIME 1000
|
|
|
|
// Zoom vars
|
|
#define ZOOM_TIME 150 // not currently used?
|
|
#define MAX_ZOOM_FOV 3.0f
|
|
#define ZOOM_IN_TIME 1500.0f
|
|
#define ZOOM_OUT_TIME 100.0f
|
|
#define ZOOM_START_PERCENT 0.3f
|
|
|
|
#define ITEM_BLOB_TIME 200
|
|
#define MUZZLE_FLASH_TIME 20
|
|
#define SINK_TIME 1000 // time for fragments to sink into ground before going away
|
|
#define ATTACKER_HEAD_TIME 10000
|
|
#define REWARD_TIME 3000
|
|
|
|
#define PULSE_SCALE 1.5 // amount to scale up the icons when activating
|
|
|
|
#define MAX_STEP_CHANGE 32
|
|
|
|
#define MAX_VERTS_ON_POLY 10
|
|
#define MAX_MARK_POLYS 256
|
|
|
|
#define STAT_MINUS 10 // num frame for '-' stats digit
|
|
|
|
#define ICON_SIZE 48
|
|
#define CHAR_WIDTH 32
|
|
#define CHAR_HEIGHT 48
|
|
#define TEXT_ICON_SPACE 4
|
|
|
|
// very large characters
|
|
#define GIANT_WIDTH 32
|
|
#define GIANT_HEIGHT 48
|
|
|
|
#define NUM_FONT_BIG 1
|
|
#define NUM_FONT_SMALL 2
|
|
#define NUM_FONT_CHUNKY 3
|
|
|
|
#define NUM_CROSSHAIRS 9
|
|
|
|
#define TEAM_OVERLAY_MAXNAME_WIDTH 32
|
|
#define TEAM_OVERLAY_MAXLOCATION_WIDTH 64
|
|
|
|
#define WAVE_AMPLITUDE 1
|
|
#define WAVE_FREQUENCY 0.4
|
|
|
|
#define DEFAULT_MODEL "kyle"
|
|
|
|
#define DEFAULT_FORCEPOWERS "5-1-000000000000000000"
|
|
//"rank-side-heal.lev.speed.push.pull.tele.grip.lightning.rage.protect.absorb.teamheal.teamforce.drain.see"
|
|
|
|
#define DEFAULT_REDTEAM_NAME "Empire"
|
|
#define DEFAULT_BLUETEAM_NAME "Rebellion"
|
|
|
|
typedef enum {
|
|
FOOTSTEP_STONEWALK,
|
|
FOOTSTEP_STONERUN,
|
|
FOOTSTEP_METALWALK,
|
|
FOOTSTEP_METALRUN,
|
|
FOOTSTEP_PIPEWALK,
|
|
FOOTSTEP_PIPERUN,
|
|
FOOTSTEP_SPLASH,
|
|
FOOTSTEP_WADE,
|
|
FOOTSTEP_SWIM,
|
|
FOOTSTEP_SNOWWALK,
|
|
FOOTSTEP_SNOWRUN,
|
|
FOOTSTEP_SANDWALK,
|
|
FOOTSTEP_SANDRUN,
|
|
FOOTSTEP_GRASSWALK,
|
|
FOOTSTEP_GRASSRUN,
|
|
FOOTSTEP_DIRTWALK,
|
|
FOOTSTEP_DIRTRUN,
|
|
FOOTSTEP_MUDWALK,
|
|
FOOTSTEP_MUDRUN,
|
|
FOOTSTEP_GRAVELWALK,
|
|
FOOTSTEP_GRAVELRUN,
|
|
FOOTSTEP_RUGWALK,
|
|
FOOTSTEP_RUGRUN,
|
|
FOOTSTEP_WOODWALK,
|
|
FOOTSTEP_WOODRUN,
|
|
|
|
FOOTSTEP_TOTAL
|
|
} footstep_t;
|
|
|
|
typedef enum {
|
|
IMPACTSOUND_DEFAULT,
|
|
IMPACTSOUND_METAL,
|
|
IMPACTSOUND_FLESH
|
|
} impactSound_t;
|
|
|
|
//=================================================
|
|
|
|
// player entities need to track more information
|
|
// than any other type of entity.
|
|
|
|
// note that not every player entity is a client entity,
|
|
// because corpses after respawn are outside the normal
|
|
// client numbering range
|
|
|
|
// when changing animation, set animationTime to frameTime + lerping time
|
|
// The current lerp will finish out, then it will lerp to the new animation
|
|
typedef struct {
|
|
int oldFrame;
|
|
int oldFrameTime; // time when ->oldFrame was exactly on
|
|
|
|
int frame;
|
|
int frameTime; // time when ->frame will be exactly on
|
|
|
|
float backlerp;
|
|
|
|
qboolean lastFlip; //if does not match torsoFlip/legsFlip, restart the anim.
|
|
|
|
int lastForcedFrame;
|
|
|
|
float yawAngle;
|
|
qboolean yawing;
|
|
float pitchAngle;
|
|
qboolean pitching;
|
|
|
|
float yawSwingDif;
|
|
|
|
int animationNumber;
|
|
animation_t *animation;
|
|
int animationTime; // time when the first frame of the animation will be exact
|
|
|
|
float animationSpeed; // scale the animation speed
|
|
float animationTorsoSpeed;
|
|
|
|
qboolean torsoYawing;
|
|
} lerpFrame_t;
|
|
|
|
|
|
typedef struct {
|
|
lerpFrame_t legs, torso, flag;
|
|
int painTime;
|
|
int painDirection; // flip from 0 to 1
|
|
int lightningFiring;
|
|
|
|
// machinegun spinning
|
|
float barrelAngle;
|
|
int barrelTime;
|
|
qboolean barrelSpinning;
|
|
} playerEntity_t;
|
|
|
|
//=================================================
|
|
|
|
// each client has an associated clientInfo_t
|
|
// that contains media references necessary to present the
|
|
// client model and other color coded effects
|
|
// this is regenerated each time a client's configstring changes,
|
|
// usually as a result of a userinfo (name, model, etc) change
|
|
#define MAX_CUSTOM_COMBAT_SOUNDS 40
|
|
#define MAX_CUSTOM_EXTRA_SOUNDS 40
|
|
#define MAX_CUSTOM_JEDI_SOUNDS 40
|
|
//#define MAX_CUSTOM_SIEGE_SOUNDS..defined in bg_public.h
|
|
#define MAX_CUSTOM_DUEL_SOUNDS 40
|
|
|
|
#define MAX_CUSTOM_SOUNDS 40 //rww - Note that for now these must all be the same, because of the way I am
|
|
//cycling through them and comparing for custom sounds.
|
|
|
|
typedef struct {
|
|
qboolean infoValid;
|
|
|
|
float colorOverride[3];
|
|
|
|
saberInfo_t saber[MAX_SABERS];
|
|
void *ghoul2Weapons[MAX_SABERS];
|
|
|
|
char saberName[64];
|
|
char saber2Name[64];
|
|
|
|
char name[MAX_QPATH];
|
|
team_t team;
|
|
|
|
int duelTeam;
|
|
|
|
int botSkill; // 0 = not bot, 1-5 = bot
|
|
|
|
int frame;
|
|
|
|
vec3_t color1;
|
|
vec3_t color2;
|
|
|
|
int icolor1;
|
|
int icolor2;
|
|
|
|
int score; // updated by score servercmds
|
|
int location; // location index for team mode
|
|
int health; // you only get this info about your teammates
|
|
int armor;
|
|
int curWeapon;
|
|
|
|
int handicap;
|
|
int wins, losses; // in tourney mode
|
|
|
|
int teamTask; // task in teamplay (offence/defence)
|
|
qboolean teamLeader; // true when this is a team leader
|
|
|
|
int powerups; // so can display quad/flag status
|
|
|
|
int medkitUsageTime;
|
|
|
|
int breathPuffTime;
|
|
|
|
// when clientinfo is changed, the loading of models/skins/sounds
|
|
// can be deferred until you are dead, to prevent hitches in
|
|
// gameplay
|
|
char modelName[MAX_QPATH];
|
|
char skinName[MAX_QPATH];
|
|
// char headModelName[MAX_QPATH];
|
|
// char headSkinName[MAX_QPATH];
|
|
char forcePowers[MAX_QPATH];
|
|
char redTeam[MAX_TEAMNAME];
|
|
char blueTeam[MAX_TEAMNAME];
|
|
|
|
char teamName[MAX_TEAMNAME];
|
|
|
|
int corrTime;
|
|
|
|
vec3_t lastHeadAngles;
|
|
int lookTime;
|
|
|
|
int brokenLimbs;
|
|
|
|
qboolean deferred;
|
|
|
|
qboolean newAnims; // true if using the new mission pack animations
|
|
qboolean fixedlegs; // true if legs yaw is always the same as torso yaw
|
|
qboolean fixedtorso; // true if torso never changes yaw
|
|
|
|
vec3_t headOffset; // move head in icon views
|
|
//footstep_t footsteps;
|
|
gender_t gender; // from model
|
|
|
|
qhandle_t legsModel;
|
|
qhandle_t legsSkin;
|
|
|
|
qhandle_t torsoModel;
|
|
qhandle_t torsoSkin;
|
|
|
|
//qhandle_t headModel;
|
|
//qhandle_t headSkin;
|
|
|
|
void *ghoul2Model;
|
|
|
|
qhandle_t modelIcon;
|
|
|
|
qhandle_t bolt_rhand;
|
|
qhandle_t bolt_lhand;
|
|
|
|
qhandle_t bolt_head;
|
|
|
|
qhandle_t bolt_motion;
|
|
|
|
qhandle_t bolt_llumbar;
|
|
|
|
int siegeIndex;
|
|
int siegeDesiredTeam;
|
|
|
|
sfxHandle_t sounds[MAX_CUSTOM_SOUNDS];
|
|
sfxHandle_t combatSounds[MAX_CUSTOM_COMBAT_SOUNDS];
|
|
sfxHandle_t extraSounds[MAX_CUSTOM_EXTRA_SOUNDS];
|
|
sfxHandle_t jediSounds[MAX_CUSTOM_JEDI_SOUNDS];
|
|
sfxHandle_t siegeSounds[MAX_CUSTOM_SIEGE_SOUNDS];
|
|
sfxHandle_t duelSounds[MAX_CUSTOM_DUEL_SOUNDS];
|
|
|
|
int legsAnim;
|
|
int torsoAnim;
|
|
|
|
float facial_blink; // time before next blink. If a minus value, we are in blink mode
|
|
float facial_frown; // time before next frown. If a minus value, we are in frown mode
|
|
float facial_aux; // time before next aux. If a minus value, we are in aux mode
|
|
|
|
int superSmoothTime; //do crazy amount of smoothing
|
|
|
|
#ifdef _XBOX
|
|
int friendshipStatus;
|
|
#endif
|
|
|
|
} clientInfo_t;
|
|
|
|
//rww - cheap looping sound struct
|
|
#ifdef _XBOX
|
|
#define MAX_CG_LOOPSOUNDS 2
|
|
#else
|
|
#define MAX_CG_LOOPSOUNDS 8
|
|
#endif
|
|
|
|
typedef struct cgLoopSound_s {
|
|
int entityNum;
|
|
vec3_t origin;
|
|
vec3_t velocity;
|
|
sfxHandle_t sfx;
|
|
} cgLoopSound_t;
|
|
|
|
// centity_t have a direct corespondence with gentity_t in the game, but
|
|
// only the entityState_t is directly communicated to the cgame
|
|
typedef struct centity_s {
|
|
// This comment below is correct, but now m_pVehicle is the first thing in bg shared entity, so it goes first. - AReis
|
|
//rww - entstate must be first, to correspond with the bg shared entity structure
|
|
entityState_t currentState; // from cg.frame
|
|
playerState_t *playerState; //ptr to playerstate if applicable (for bg ents)
|
|
Vehicle_t *m_pVehicle; //vehicle data
|
|
void *ghoul2; //g2 instance
|
|
int localAnimIndex; //index locally (game/cgame) to anim data for this skel
|
|
vec3_t modelScale; //needed for g2 collision
|
|
|
|
//from here up must be unified with bgEntity_t -rww
|
|
|
|
entityState_t nextState; // from cg.nextFrame, if available
|
|
qboolean interpolate; // true if next is valid to interpolate to
|
|
qboolean currentValid; // true if cg.frame holds this entity
|
|
|
|
int muzzleFlashTime; // move to playerEntity?
|
|
int previousEvent;
|
|
// int teleportFlag;
|
|
|
|
int trailTime; // so missile trails can handle dropped initial packets
|
|
int dustTrailTime;
|
|
int miscTime;
|
|
|
|
vec3_t damageAngles;
|
|
int damageTime;
|
|
|
|
int snapShotTime; // last time this entity was found in a snapshot
|
|
|
|
playerEntity_t pe;
|
|
|
|
// int errorTime; // decay the error from this time
|
|
// vec3_t errorOrigin;
|
|
// vec3_t errorAngles;
|
|
|
|
// qboolean extrapolated; // false if origin / angles is an interpolation
|
|
// vec3_t rawOrigin;
|
|
vec3_t rawAngles;
|
|
|
|
vec3_t beamEnd;
|
|
|
|
// exact interpolated position of entity on this frame
|
|
vec3_t lerpOrigin;
|
|
vec3_t lerpAngles;
|
|
|
|
#if 0
|
|
//add up bone offsets until next client frame before adding them in
|
|
qboolean hasRagOffset;
|
|
vec3_t ragOffsets;
|
|
int ragOffsetTime;
|
|
#endif
|
|
|
|
vec3_t ragLastOrigin;
|
|
int ragLastOriginTime;
|
|
|
|
qboolean noLumbar; //if true only do anims and things on model_root instead of lower_lumbar, this will be the case for some NPCs.
|
|
qboolean noFace;
|
|
|
|
//For keeping track of the current surface status in relation to the entitystate surface fields.
|
|
int npcLocalSurfOn;
|
|
int npcLocalSurfOff;
|
|
|
|
int eventAnimIndex;
|
|
|
|
clientInfo_t *npcClient; //dynamically allocated - always free it, and never stomp over it.
|
|
|
|
int weapon;
|
|
|
|
void *ghoul2weapon; //rww - pointer to ghoul2 instance of the current 3rd person weapon
|
|
|
|
float radius;
|
|
int boltInfo;
|
|
|
|
//sometimes used as a bolt index, but these values are also used as generic values for clientside entities
|
|
//at times
|
|
int bolt1;
|
|
int bolt2;
|
|
int bolt3;
|
|
int bolt4;
|
|
|
|
float bodyHeight;
|
|
|
|
int torsoBolt;
|
|
|
|
vec3_t turAngles;
|
|
|
|
vec3_t frame_minus1;
|
|
vec3_t frame_minus2;
|
|
|
|
int frame_minus1_refreshed;
|
|
int frame_minus2_refreshed;
|
|
|
|
void *frame_hold; //pointer to a ghoul2 instance
|
|
|
|
int frame_hold_time;
|
|
int frame_hold_refreshed;
|
|
|
|
void *grip_arm; //pointer to a ghoul2 instance
|
|
|
|
int trickAlpha;
|
|
int trickAlphaTime;
|
|
|
|
int teamPowerEffectTime;
|
|
qboolean teamPowerType; //0 regen, 1 heal, 2 drain, 3 absorb
|
|
|
|
qboolean isRagging;
|
|
qboolean ownerRagging;
|
|
int overridingBones;
|
|
|
|
int bodyFadeTime;
|
|
vec3_t pushEffectOrigin;
|
|
|
|
cgLoopSound_t loopingSound[MAX_CG_LOOPSOUNDS];
|
|
int numLoopingSounds;
|
|
|
|
int serverSaberHitIndex;
|
|
int serverSaberHitTime;
|
|
qboolean serverSaberFleshImpact; //true if flesh, false if anything else.
|
|
|
|
qboolean ikStatus;
|
|
|
|
qboolean saberWasInFlight;
|
|
|
|
float smoothYaw;
|
|
|
|
int uncloaking;
|
|
qboolean cloaked;
|
|
|
|
int vChatTime;
|
|
} centity_t;
|
|
|
|
|
|
//======================================================================
|
|
|
|
// local entities are created as a result of events or predicted actions,
|
|
// and live independently from all server transmitted entities
|
|
|
|
typedef struct markPoly_s {
|
|
struct markPoly_s *prevMark, *nextMark;
|
|
int time;
|
|
qhandle_t markShader;
|
|
qboolean alphaFade; // fade alpha instead of rgb
|
|
float color[4];
|
|
poly_t poly;
|
|
polyVert_t verts[MAX_VERTS_ON_POLY];
|
|
} markPoly_t;
|
|
|
|
|
|
typedef enum {
|
|
LE_MARK,
|
|
LE_EXPLOSION,
|
|
LE_SPRITE_EXPLOSION,
|
|
LE_FADE_SCALE_MODEL, // currently only for Demp2 shock sphere
|
|
LE_FRAGMENT,
|
|
LE_PUFF,
|
|
LE_MOVE_SCALE_FADE,
|
|
LE_FALL_SCALE_FADE,
|
|
LE_FADE_RGB,
|
|
LE_SCALE_FADE,
|
|
LE_SCOREPLUM,
|
|
LE_OLINE,
|
|
LE_SHOWREFENTITY,
|
|
LE_LINE
|
|
} leType_t;
|
|
|
|
typedef enum {
|
|
LEF_PUFF_DONT_SCALE = 0x0001, // do not scale size over time
|
|
LEF_TUMBLE = 0x0002, // tumble over time, used for ejecting shells
|
|
LEF_FADE_RGB = 0x0004, // explicitly fade
|
|
LEF_NO_RANDOM_ROTATE= 0x0008 // MakeExplosion adds random rotate which could be bad in some cases
|
|
} leFlag_t;
|
|
|
|
typedef enum {
|
|
LEMT_NONE,
|
|
LEMT_BURN,
|
|
LEMT_BLOOD
|
|
} leMarkType_t; // fragment local entities can leave marks on walls
|
|
|
|
typedef enum {
|
|
LEBS_NONE,
|
|
LEBS_BLOOD,
|
|
LEBS_BRASS,
|
|
LEBS_METAL,
|
|
LEBS_ROCK
|
|
} leBounceSoundType_t; // fragment local entities can make sounds on impacts
|
|
|
|
typedef struct localEntity_s {
|
|
struct localEntity_s *prev, *next;
|
|
leType_t leType;
|
|
int leFlags;
|
|
|
|
int startTime;
|
|
int endTime;
|
|
int fadeInTime;
|
|
|
|
float lifeRate; // 1.0 / (endTime - startTime)
|
|
|
|
trajectory_t pos;
|
|
trajectory_t angles;
|
|
|
|
float bounceFactor; // 0.0 = no bounce, 1.0 = perfect
|
|
int bounceSound; // optional sound index to play upon bounce
|
|
|
|
float alpha;
|
|
float dalpha;
|
|
|
|
int forceAlpha;
|
|
|
|
float color[4];
|
|
|
|
float radius;
|
|
|
|
float light;
|
|
vec3_t lightColor;
|
|
|
|
leMarkType_t leMarkType; // mark to leave on fragment impact
|
|
leBounceSoundType_t leBounceSoundType;
|
|
|
|
union {
|
|
struct {
|
|
float radius;
|
|
float dradius;
|
|
vec3_t startRGB;
|
|
vec3_t dRGB;
|
|
} sprite;
|
|
struct {
|
|
float width;
|
|
float dwidth;
|
|
float length;
|
|
float dlength;
|
|
vec3_t startRGB;
|
|
vec3_t dRGB;
|
|
} trail;
|
|
struct {
|
|
float width;
|
|
float dwidth;
|
|
// Below are bezier specific.
|
|
vec3_t control1; // initial position of control points
|
|
vec3_t control2;
|
|
vec3_t control1_velocity; // initial velocity of control points
|
|
vec3_t control2_velocity;
|
|
vec3_t control1_acceleration; // constant acceleration of control points
|
|
vec3_t control2_acceleration;
|
|
} line;
|
|
struct {
|
|
float width;
|
|
float dwidth;
|
|
float width2;
|
|
float dwidth2;
|
|
vec3_t startRGB;
|
|
vec3_t dRGB;
|
|
} line2;
|
|
struct {
|
|
float width;
|
|
float dwidth;
|
|
float width2;
|
|
float dwidth2;
|
|
float height;
|
|
float dheight;
|
|
} cylinder;
|
|
struct {
|
|
float width;
|
|
float dwidth;
|
|
} electricity;
|
|
struct
|
|
{
|
|
// fight the power! open and close brackets in the same column!
|
|
float radius;
|
|
float dradius;
|
|
qboolean (*thinkFn)(struct localEntity_s *le);
|
|
vec3_t dir; // magnitude is 1, but this is oldpos - newpos right before the
|
|
//particle is sent to the renderer
|
|
// may want to add something like particle::localEntity_s *le (for the particle's think fn)
|
|
} particle;
|
|
struct
|
|
{
|
|
qboolean dontDie;
|
|
vec3_t dir;
|
|
float variance;
|
|
int delay;
|
|
int nextthink;
|
|
qboolean (*thinkFn)(struct localEntity_s *le);
|
|
int data1;
|
|
int data2;
|
|
} spawner;
|
|
struct
|
|
{
|
|
float radius;
|
|
} fragment;
|
|
} data;
|
|
|
|
refEntity_t refEntity;
|
|
} localEntity_t;
|
|
|
|
//======================================================================
|
|
|
|
|
|
typedef struct {
|
|
int client;
|
|
int score;
|
|
int ping;
|
|
int time;
|
|
int scoreFlags;
|
|
int powerUps;
|
|
int accuracy;
|
|
int impressiveCount;
|
|
int excellentCount;
|
|
int guantletCount;
|
|
int defendCount;
|
|
int assistCount;
|
|
int captures;
|
|
qboolean perfect;
|
|
int team;
|
|
} score_t;
|
|
|
|
|
|
// each WP_* weapon enum has an associated weaponInfo_t
|
|
// that contains media references necessary to present the
|
|
// weapon and its effects
|
|
typedef struct weaponInfo_s {
|
|
qboolean registered;
|
|
gitem_t *item;
|
|
|
|
qhandle_t handsModel; // the hands don't actually draw, they just position the weapon
|
|
qhandle_t weaponModel; // this is the pickup model
|
|
qhandle_t viewModel; // this is the in-view model used by the player
|
|
qhandle_t barrelModel;
|
|
qhandle_t flashModel;
|
|
|
|
vec3_t weaponMidpoint; // so it will rotate centered instead of by tag
|
|
|
|
float flashDlight;
|
|
vec3_t flashDlightColor;
|
|
|
|
qhandle_t weaponIcon;
|
|
qhandle_t ammoIcon;
|
|
|
|
qhandle_t ammoModel;
|
|
|
|
sfxHandle_t flashSound[4]; // fast firing weapons randomly choose
|
|
sfxHandle_t firingSound;
|
|
sfxHandle_t chargeSound;
|
|
fxHandle_t muzzleEffect;
|
|
qhandle_t missileModel;
|
|
sfxHandle_t missileSound;
|
|
void (*missileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
|
|
float missileDlight;
|
|
vec3_t missileDlightColor;
|
|
int missileRenderfx;
|
|
sfxHandle_t missileHitSound;
|
|
|
|
sfxHandle_t altFlashSound[4];
|
|
sfxHandle_t altFiringSound;
|
|
sfxHandle_t altChargeSound;
|
|
fxHandle_t altMuzzleEffect;
|
|
qhandle_t altMissileModel;
|
|
sfxHandle_t altMissileSound;
|
|
void (*altMissileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
|
|
float altMissileDlight;
|
|
vec3_t altMissileDlightColor;
|
|
int altMissileRenderfx;
|
|
sfxHandle_t altMissileHitSound;
|
|
|
|
sfxHandle_t selectSound;
|
|
|
|
sfxHandle_t readySound;
|
|
float trailRadius;
|
|
float wiTrailTime;
|
|
|
|
} weaponInfo_t;
|
|
|
|
|
|
// each IT_* item has an associated itemInfo_t
|
|
// that constains media references necessary to present the
|
|
// item and its effects
|
|
typedef struct {
|
|
qboolean registered;
|
|
qhandle_t models[MAX_ITEM_MODELS];
|
|
qhandle_t icon;
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
void *g2Models[MAX_ITEM_MODELS];
|
|
float radius[MAX_ITEM_MODELS];
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
} itemInfo_t;
|
|
|
|
|
|
typedef struct {
|
|
int itemNum;
|
|
} powerupInfo_t;
|
|
|
|
|
|
#define MAX_SKULLTRAIL 10
|
|
|
|
typedef struct {
|
|
vec3_t positions[MAX_SKULLTRAIL];
|
|
int numpositions;
|
|
} skulltrail_t;
|
|
|
|
|
|
#define MAX_REWARDSTACK 10
|
|
#define MAX_SOUNDBUFFER 20
|
|
|
|
//======================================================================
|
|
|
|
// all cg.stepTime, cg.duckTime, cg.landTime, etc are set to cg.time when the action
|
|
// occurs, and they will have visible effects for #define STEP_TIME or whatever msec after
|
|
|
|
#define MAX_PREDICTED_EVENTS 16
|
|
|
|
|
|
#define MAX_CHATBOX_ITEMS 5
|
|
typedef struct chatBoxItem_s
|
|
{
|
|
char string[MAX_SAY_TEXT];
|
|
int time;
|
|
int lines;
|
|
} chatBoxItem_t;
|
|
|
|
typedef struct {
|
|
int clientFrame; // incremented each frame
|
|
|
|
int clientNum;
|
|
|
|
qboolean demoPlayback;
|
|
qboolean levelShot; // taking a level menu screenshot
|
|
int deferredPlayerLoading;
|
|
qboolean loading; // don't defer players at initial startup
|
|
qboolean intermissionStarted; // don't play voice rewards, because game will end shortly
|
|
|
|
// there are only one or two snapshot_t that are relevent at a time
|
|
int latestSnapshotNum; // the number of snapshots the client system has received
|
|
int latestSnapshotTime; // the time from latestSnapshotNum, so we don't need to read the snapshot yet
|
|
|
|
snapshot_t *snap; // cg.snap->serverTime <= cg.time
|
|
snapshot_t *nextSnap; // cg.nextSnap->serverTime > cg.time, or NULL
|
|
// snapshot_t activeSnapshots[2];
|
|
|
|
float frameInterpolation; // (float)( cg.time - cg.frame->serverTime ) / (cg.nextFrame->serverTime - cg.frame->serverTime)
|
|
|
|
qboolean mMapChange;
|
|
|
|
qboolean thisFrameTeleport;
|
|
qboolean nextFrameTeleport;
|
|
|
|
int frametime; // cg.time - cg.oldTime
|
|
|
|
int time; // this is the time value that the client
|
|
// is rendering at.
|
|
int oldTime; // time at last frame, used for missile trails and prediction checking
|
|
|
|
int physicsTime; // either cg.snap->time or cg.nextSnap->time
|
|
|
|
int timelimitWarnings; // 5 min, 1 min, overtime
|
|
int fraglimitWarnings;
|
|
|
|
qboolean mapRestart; // set on a map restart to set back the weapon
|
|
|
|
qboolean mInRMG; //rwwRMG - added
|
|
qboolean mRMGWeather; //rwwRMG - added
|
|
|
|
qboolean renderingThirdPerson; // during deaths, chasecams, etc
|
|
|
|
// prediction state
|
|
qboolean hyperspace; // true if prediction has hit a trigger_teleport
|
|
playerState_t predictedPlayerState;
|
|
playerState_t predictedVehicleState;
|
|
|
|
//centity_t predictedPlayerEntity;
|
|
//rww - I removed this and made it use cg_entities[clnum] directly.
|
|
|
|
qboolean validPPS; // clear until the first call to CG_PredictPlayerState
|
|
int predictedErrorTime;
|
|
vec3_t predictedError;
|
|
|
|
int eventSequence;
|
|
int predictableEvents[MAX_PREDICTED_EVENTS];
|
|
|
|
float stepChange; // for stair up smoothing
|
|
int stepTime;
|
|
|
|
float duckChange; // for duck viewheight smoothing
|
|
int duckTime;
|
|
|
|
float landChange; // for landing hard
|
|
int landTime;
|
|
|
|
// input state sent to server
|
|
int weaponSelect;
|
|
|
|
int forceSelect;
|
|
int itemSelect;
|
|
|
|
// auto rotating items
|
|
vec3_t autoAngles;
|
|
vec3_t autoAxis[3];
|
|
vec3_t autoAnglesFast;
|
|
vec3_t autoAxisFast[3];
|
|
|
|
// view rendering
|
|
refdef_t refdef;
|
|
|
|
#ifdef _XBOX
|
|
qboolean widescreen;
|
|
#endif
|
|
|
|
// zoom key
|
|
qboolean zoomed;
|
|
int zoomTime;
|
|
float zoomSensitivity;
|
|
|
|
// information screen text during loading
|
|
char infoScreenText[MAX_STRING_CHARS];
|
|
|
|
// scoreboard
|
|
int scoresRequestTime;
|
|
int numScores;
|
|
int selectedScore;
|
|
int teamScores[2];
|
|
score_t scores[MAX_CLIENTS];
|
|
qboolean showScores;
|
|
qboolean scoreBoardShowing;
|
|
int scoreFadeTime;
|
|
char killerName[MAX_NAME_LENGTH];
|
|
char spectatorList[MAX_STRING_CHARS]; // list of names
|
|
int spectatorLen; // length of list
|
|
float spectatorWidth; // width in device units
|
|
int spectatorTime; // next time to offset
|
|
int spectatorPaintX; // current paint x
|
|
int spectatorPaintX2; // current paint x
|
|
int spectatorOffset; // current offset from start
|
|
int spectatorPaintLen; // current offset from start
|
|
|
|
// skull trails
|
|
skulltrail_t skulltrails[MAX_CLIENTS];
|
|
|
|
// centerprinting
|
|
int centerPrintTime;
|
|
int centerPrintCharWidth;
|
|
int centerPrintY;
|
|
char centerPrint[1024];
|
|
int centerPrintLines;
|
|
|
|
// low ammo warning state
|
|
int lowAmmoWarning; // 1 = low, 2 = empty
|
|
|
|
// kill timers for carnage reward
|
|
int lastKillTime;
|
|
|
|
// crosshair client ID
|
|
int crosshairClientNum;
|
|
int crosshairClientTime;
|
|
|
|
int crosshairVehNum;
|
|
int crosshairVehTime;
|
|
|
|
// powerup active flashing
|
|
int powerupActive;
|
|
int powerupTime;
|
|
|
|
// attacking player
|
|
int attackerTime;
|
|
int voiceTime;
|
|
|
|
// reward medals
|
|
int rewardStack;
|
|
int rewardTime;
|
|
int rewardCount[MAX_REWARDSTACK];
|
|
qhandle_t rewardShader[MAX_REWARDSTACK];
|
|
qhandle_t rewardSound[MAX_REWARDSTACK];
|
|
|
|
// sound buffer mainly for announcer sounds
|
|
int soundBufferIn;
|
|
int soundBufferOut;
|
|
int soundTime;
|
|
qhandle_t soundBuffer[MAX_SOUNDBUFFER];
|
|
|
|
// for voice chat buffer
|
|
int voiceChatTime;
|
|
int voiceChatBufferIn;
|
|
int voiceChatBufferOut;
|
|
|
|
// warmup countdown
|
|
int warmup;
|
|
int warmupCount;
|
|
|
|
//==========================
|
|
|
|
int itemPickup;
|
|
int itemPickupTime;
|
|
int itemPickupBlendTime; // the pulse around the crosshair is timed seperately
|
|
|
|
int weaponSelectTime;
|
|
int weaponAnimation;
|
|
int weaponAnimationTime;
|
|
|
|
// blend blobs
|
|
float damageTime;
|
|
float damageX, damageY, damageValue;
|
|
|
|
// status bar head
|
|
float headYaw;
|
|
float headEndPitch;
|
|
float headEndYaw;
|
|
int headEndTime;
|
|
float headStartPitch;
|
|
float headStartYaw;
|
|
int headStartTime;
|
|
|
|
// view movement
|
|
float v_dmg_time;
|
|
float v_dmg_pitch;
|
|
float v_dmg_roll;
|
|
|
|
vec3_t kick_angles; // weapon kicks
|
|
int kick_time;
|
|
vec3_t kick_origin;
|
|
|
|
// temp working variables for player view
|
|
float bobfracsin;
|
|
int bobcycle;
|
|
float xyspeed;
|
|
int nextOrbitTime;
|
|
|
|
//qboolean cameraMode; // if rendering from a loaded camera
|
|
int loadLCARSStage;
|
|
|
|
int forceHUDTotalFlashTime;
|
|
int forceHUDNextFlashTime;
|
|
qboolean forceHUDActive; // Flag to show force hud is off/on
|
|
|
|
// development tool
|
|
refEntity_t testModelEntity;
|
|
char testModelName[MAX_QPATH];
|
|
qboolean testGun;
|
|
|
|
int VHUDFlashTime;
|
|
qboolean VHUDTurboFlag;
|
|
|
|
// HUD stuff
|
|
float HUDTickFlashTime;
|
|
qboolean HUDArmorFlag;
|
|
qboolean HUDHealthFlag;
|
|
qboolean iconHUDActive;
|
|
float iconHUDPercent;
|
|
float iconSelectTime;
|
|
float invenSelectTime;
|
|
float forceSelectTime;
|
|
|
|
vec3_t lastFPFlashPoint;
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
int testModel;
|
|
// had to be moved so we wouldn't wipe these out with the memset - these have STL in them and shouldn't be cleared that way
|
|
snapshot_t activeSnapshots[2];
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
char sharedBuffer[MAX_CG_SHARED_BUFFER_SIZE];
|
|
|
|
short radarEntityCount;
|
|
short radarEntities[MAX_CLIENTS+16];
|
|
|
|
short bracketedEntityCount;
|
|
short bracketedEntities[MAX_CLIENTS+16];
|
|
|
|
float distanceCull;
|
|
|
|
chatBoxItem_t chatItems[MAX_CHATBOX_ITEMS];
|
|
int chatItemActive;
|
|
|
|
#if 0
|
|
int snapshotTimeoutTime;
|
|
#endif
|
|
|
|
} cg_t;
|
|
|
|
#define MAX_TICS 14
|
|
|
|
typedef struct forceTicPos_s
|
|
{
|
|
int x;
|
|
int y;
|
|
int width;
|
|
int height;
|
|
char *file;
|
|
qhandle_t tic;
|
|
} forceTicPos_t;
|
|
extern forceTicPos_t forceTicPos[];
|
|
extern forceTicPos_t ammoTicPos[];
|
|
|
|
typedef struct cgscreffects_s
|
|
{
|
|
float FOV;
|
|
float FOV2;
|
|
|
|
float shake_intensity;
|
|
int shake_duration;
|
|
int shake_start;
|
|
|
|
float music_volume_multiplier;
|
|
int music_volume_time;
|
|
qboolean music_volume_set;
|
|
} cgscreffects_t;
|
|
|
|
extern cgscreffects_t cgScreenEffects;
|
|
|
|
void CGCam_Shake( float intensity, int duration );
|
|
void CGCam_SetMusicMult( float multiplier, int duration );
|
|
|
|
typedef enum
|
|
{
|
|
CHUNK_METAL1 = 0,
|
|
CHUNK_METAL2,
|
|
CHUNK_ROCK1,
|
|
CHUNK_ROCK2,
|
|
CHUNK_ROCK3,
|
|
CHUNK_CRATE1,
|
|
CHUNK_CRATE2,
|
|
CHUNK_WHITE_METAL,
|
|
NUM_CHUNK_TYPES
|
|
};
|
|
#define NUM_CHUNK_MODELS 4
|
|
|
|
// all of the model, shader, and sound references that are
|
|
// loaded at gamestate time are stored in cgMedia_t
|
|
// Other media that can be tied to clients, weapons, or items are
|
|
// stored in the clientInfo_t, itemInfo_t, weaponInfo_t, and powerupInfo_t
|
|
typedef struct {
|
|
qhandle_t charsetShader;
|
|
qhandle_t whiteShader;
|
|
|
|
qhandle_t loadBarLED;
|
|
qhandle_t loadBarLEDCap;
|
|
qhandle_t loadBarLEDSurround;
|
|
|
|
qhandle_t bryarFrontFlash;
|
|
qhandle_t greenFrontFlash;
|
|
qhandle_t lightningFlash;
|
|
|
|
qhandle_t itemHoloModel;
|
|
qhandle_t redFlagModel;
|
|
qhandle_t blueFlagModel;
|
|
|
|
qhandle_t flagPoleModel;
|
|
qhandle_t flagFlapModel;
|
|
|
|
qhandle_t redFlagBaseModel;
|
|
qhandle_t blueFlagBaseModel;
|
|
qhandle_t neutralFlagBaseModel;
|
|
|
|
qhandle_t teamStatusBar;
|
|
|
|
qhandle_t deferShader;
|
|
|
|
qhandle_t radarShader;
|
|
qhandle_t siegeItemShader;
|
|
qhandle_t mAutomapPlayerIcon;
|
|
qhandle_t mAutomapRocketIcon;
|
|
|
|
qhandle_t wireframeAutomapFrame_left;
|
|
qhandle_t wireframeAutomapFrame_right;
|
|
qhandle_t wireframeAutomapFrame_top;
|
|
qhandle_t wireframeAutomapFrame_bottom;
|
|
|
|
//Chunks
|
|
qhandle_t chunkModels[NUM_CHUNK_TYPES][4];
|
|
sfxHandle_t chunkSound;
|
|
sfxHandle_t grateSound;
|
|
sfxHandle_t rockBreakSound;
|
|
sfxHandle_t rockBounceSound[2];
|
|
sfxHandle_t metalBounceSound[2];
|
|
sfxHandle_t glassChunkSound;
|
|
sfxHandle_t crateBreakSound[2];
|
|
|
|
qhandle_t hackerIconShader;
|
|
|
|
// Saber shaders
|
|
//-----------------------------
|
|
qhandle_t forceCoronaShader;
|
|
|
|
qhandle_t redSaberGlowShader;
|
|
qhandle_t redSaberCoreShader;
|
|
qhandle_t orangeSaberGlowShader;
|
|
qhandle_t orangeSaberCoreShader;
|
|
qhandle_t yellowSaberGlowShader;
|
|
qhandle_t yellowSaberCoreShader;
|
|
qhandle_t greenSaberGlowShader;
|
|
qhandle_t greenSaberCoreShader;
|
|
qhandle_t blueSaberGlowShader;
|
|
qhandle_t blueSaberCoreShader;
|
|
qhandle_t purpleSaberGlowShader;
|
|
qhandle_t purpleSaberCoreShader;
|
|
qhandle_t saberBlurShader;
|
|
|
|
qhandle_t yellowDroppedSaberShader;
|
|
|
|
qhandle_t rivetMarkShader;
|
|
|
|
qhandle_t teamRedShader;
|
|
qhandle_t teamBlueShader;
|
|
|
|
qhandle_t powerDuelAllyShader;
|
|
|
|
qhandle_t balloonShader;
|
|
qhandle_t vchatShader;
|
|
qhandle_t connectionShader;
|
|
|
|
qhandle_t crosshairShader[NUM_CROSSHAIRS];
|
|
qhandle_t lagometerShader;
|
|
qhandle_t backTileShader;
|
|
|
|
qhandle_t numberShaders[11];
|
|
qhandle_t smallnumberShaders[11];
|
|
qhandle_t chunkyNumberShaders[11];
|
|
|
|
qhandle_t electricBodyShader;
|
|
qhandle_t electricBody2Shader;
|
|
|
|
qhandle_t fsrMarkShader;
|
|
qhandle_t fslMarkShader;
|
|
qhandle_t fshrMarkShader;
|
|
qhandle_t fshlMarkShader;
|
|
|
|
qhandle_t refractionShader;
|
|
|
|
qhandle_t cloakedShader;
|
|
|
|
qhandle_t boltShader;
|
|
|
|
qhandle_t shadowMarkShader;
|
|
|
|
//glass shard shader
|
|
qhandle_t glassShardShader;
|
|
|
|
// wall mark shaders
|
|
qhandle_t wakeMarkShader;
|
|
|
|
// Pain view shader
|
|
qhandle_t viewPainShader;
|
|
qhandle_t viewPainShader_Shields;
|
|
qhandle_t viewPainShader_ShieldsAndHealth;
|
|
|
|
qhandle_t itemRespawningPlaceholder;
|
|
qhandle_t itemRespawningRezOut;
|
|
|
|
qhandle_t playerShieldDamage;
|
|
qhandle_t protectShader;
|
|
qhandle_t forceSightBubble;
|
|
qhandle_t forceShell;
|
|
qhandle_t sightShell;
|
|
|
|
// Disruptor zoom graphics
|
|
qhandle_t disruptorMask;
|
|
qhandle_t disruptorInsert;
|
|
qhandle_t disruptorLight;
|
|
qhandle_t disruptorInsertTick;
|
|
qhandle_t disruptorChargeShader;
|
|
|
|
// Binocular graphics
|
|
qhandle_t binocularCircle;
|
|
qhandle_t binocularMask;
|
|
qhandle_t binocularArrow;
|
|
qhandle_t binocularTri;
|
|
qhandle_t binocularStatic;
|
|
qhandle_t binocularOverlay;
|
|
|
|
// weapon effect models
|
|
qhandle_t lightningExplosionModel;
|
|
|
|
// explosion assets
|
|
qhandle_t explosionModel;
|
|
qhandle_t surfaceExplosionShader;
|
|
|
|
qhandle_t disruptorShader;
|
|
|
|
qhandle_t solidWhite;
|
|
|
|
qhandle_t heartShader;
|
|
|
|
// All the player shells
|
|
qhandle_t ysaliredShader;
|
|
qhandle_t ysaliblueShader;
|
|
qhandle_t ysalimariShader;
|
|
qhandle_t boonShader;
|
|
qhandle_t endarkenmentShader;
|
|
qhandle_t enlightenmentShader;
|
|
qhandle_t invulnerabilityShader;
|
|
|
|
#ifdef JK2AWARDS
|
|
// medals shown during gameplay
|
|
qhandle_t medalImpressive;
|
|
qhandle_t medalExcellent;
|
|
qhandle_t medalGauntlet;
|
|
qhandle_t medalDefend;
|
|
qhandle_t medalAssist;
|
|
qhandle_t medalCapture;
|
|
#endif
|
|
|
|
// sounds
|
|
sfxHandle_t selectSound;
|
|
sfxHandle_t footsteps[FOOTSTEP_TOTAL][4];
|
|
|
|
sfxHandle_t winnerSound;
|
|
sfxHandle_t loserSound;
|
|
|
|
sfxHandle_t crackleSound;
|
|
|
|
sfxHandle_t grenadeBounce1;
|
|
sfxHandle_t grenadeBounce2;
|
|
|
|
sfxHandle_t teamHealSound;
|
|
sfxHandle_t teamRegenSound;
|
|
|
|
sfxHandle_t teleInSound;
|
|
sfxHandle_t teleOutSound;
|
|
sfxHandle_t respawnSound;
|
|
sfxHandle_t talkSound;
|
|
sfxHandle_t landSound;
|
|
sfxHandle_t fallSound;
|
|
|
|
sfxHandle_t oneMinuteSound;
|
|
sfxHandle_t fiveMinuteSound;
|
|
|
|
sfxHandle_t threeFragSound;
|
|
sfxHandle_t twoFragSound;
|
|
sfxHandle_t oneFragSound;
|
|
|
|
#ifdef JK2AWARDS
|
|
sfxHandle_t impressiveSound;
|
|
sfxHandle_t excellentSound;
|
|
sfxHandle_t deniedSound;
|
|
sfxHandle_t humiliationSound;
|
|
sfxHandle_t defendSound;
|
|
#endif
|
|
|
|
/*
|
|
sfxHandle_t takenLeadSound;
|
|
sfxHandle_t tiedLeadSound;
|
|
sfxHandle_t lostLeadSound;
|
|
*/
|
|
|
|
sfxHandle_t rollSound;
|
|
|
|
sfxHandle_t watrInSound;
|
|
sfxHandle_t watrOutSound;
|
|
sfxHandle_t watrUnSound;
|
|
|
|
sfxHandle_t noforceSound;
|
|
|
|
sfxHandle_t deploySeeker;
|
|
sfxHandle_t medkitSound;
|
|
|
|
// teamplay sounds
|
|
#ifdef JK2AWARDS
|
|
sfxHandle_t captureAwardSound;
|
|
#endif
|
|
sfxHandle_t redScoredSound;
|
|
sfxHandle_t blueScoredSound;
|
|
sfxHandle_t redLeadsSound;
|
|
sfxHandle_t blueLeadsSound;
|
|
sfxHandle_t teamsTiedSound;
|
|
|
|
sfxHandle_t redFlagReturnedSound;
|
|
sfxHandle_t blueFlagReturnedSound;
|
|
sfxHandle_t redTookFlagSound;
|
|
sfxHandle_t blueTookFlagSound;
|
|
|
|
sfxHandle_t redYsalReturnedSound;
|
|
sfxHandle_t blueYsalReturnedSound;
|
|
sfxHandle_t redTookYsalSound;
|
|
sfxHandle_t blueTookYsalSound;
|
|
|
|
sfxHandle_t drainSound;
|
|
|
|
//music blips
|
|
sfxHandle_t happyMusic;
|
|
sfxHandle_t dramaticFailure;
|
|
|
|
// tournament sounds
|
|
sfxHandle_t count3Sound;
|
|
sfxHandle_t count2Sound;
|
|
sfxHandle_t count1Sound;
|
|
sfxHandle_t countFightSound;
|
|
|
|
// new stuff
|
|
qhandle_t patrolShader;
|
|
qhandle_t assaultShader;
|
|
qhandle_t campShader;
|
|
qhandle_t followShader;
|
|
qhandle_t defendShader;
|
|
qhandle_t teamLeaderShader;
|
|
qhandle_t retrieveShader;
|
|
qhandle_t escortShader;
|
|
qhandle_t flagShaders[3];
|
|
|
|
qhandle_t halfShieldModel;
|
|
qhandle_t halfShieldShader;
|
|
|
|
qhandle_t demp2Shell;
|
|
qhandle_t demp2ShellShader;
|
|
|
|
qhandle_t cursor;
|
|
qhandle_t selectCursor;
|
|
qhandle_t sizeCursor;
|
|
|
|
//weapon icons
|
|
qhandle_t weaponIcons[WP_NUM_WEAPONS];
|
|
qhandle_t weaponIcons_NA[WP_NUM_WEAPONS];
|
|
|
|
//holdable inventory item icons
|
|
qhandle_t invenIcons[HI_NUM_HOLDABLE];
|
|
|
|
//force power icons
|
|
qhandle_t forcePowerIcons[NUM_FORCE_POWERS];
|
|
|
|
qhandle_t rageRecShader;
|
|
|
|
//other HUD parts
|
|
int currentBackground;
|
|
qhandle_t weaponIconBackground;
|
|
qhandle_t forceIconBackground;
|
|
qhandle_t inventoryIconBackground;
|
|
|
|
sfxHandle_t holocronPickup;
|
|
|
|
// Zoom
|
|
sfxHandle_t zoomStart;
|
|
sfxHandle_t zoomLoop;
|
|
sfxHandle_t zoomEnd;
|
|
sfxHandle_t disruptorZoomLoop;
|
|
|
|
qhandle_t bdecal_bodyburn1;
|
|
qhandle_t bdecal_saberglow;
|
|
qhandle_t bdecal_burn1;
|
|
qhandle_t mSaberDamageGlow;
|
|
|
|
// For vehicles only now
|
|
sfxHandle_t noAmmoSound;
|
|
|
|
} cgMedia_t;
|
|
|
|
|
|
// Stored FX handles
|
|
//--------------------
|
|
typedef struct
|
|
{
|
|
//concussion
|
|
fxHandle_t concussionShotEffect;
|
|
fxHandle_t concussionImpactEffect;
|
|
|
|
// BRYAR PISTOL
|
|
fxHandle_t bryarShotEffect;
|
|
fxHandle_t bryarPowerupShotEffect;
|
|
fxHandle_t bryarWallImpactEffect;
|
|
fxHandle_t bryarWallImpactEffect2;
|
|
fxHandle_t bryarWallImpactEffect3;
|
|
fxHandle_t bryarFleshImpactEffect;
|
|
fxHandle_t bryarDroidImpactEffect;
|
|
|
|
// BLASTER
|
|
fxHandle_t blasterShotEffect;
|
|
fxHandle_t blasterWallImpactEffect;
|
|
fxHandle_t blasterFleshImpactEffect;
|
|
fxHandle_t blasterDroidImpactEffect;
|
|
|
|
// DISRUPTOR
|
|
fxHandle_t disruptorRingsEffect;
|
|
fxHandle_t disruptorProjectileEffect;
|
|
fxHandle_t disruptorWallImpactEffect;
|
|
fxHandle_t disruptorFleshImpactEffect;
|
|
fxHandle_t disruptorAltMissEffect;
|
|
fxHandle_t disruptorAltHitEffect;
|
|
|
|
// BOWCASTER
|
|
fxHandle_t bowcasterShotEffect;
|
|
fxHandle_t bowcasterImpactEffect;
|
|
|
|
// REPEATER
|
|
fxHandle_t repeaterProjectileEffect;
|
|
fxHandle_t repeaterAltProjectileEffect;
|
|
fxHandle_t repeaterWallImpactEffect;
|
|
fxHandle_t repeaterFleshImpactEffect;
|
|
fxHandle_t repeaterAltWallImpactEffect;
|
|
|
|
// DEMP2
|
|
fxHandle_t demp2ProjectileEffect;
|
|
fxHandle_t demp2WallImpactEffect;
|
|
fxHandle_t demp2FleshImpactEffect;
|
|
|
|
// FLECHETTE
|
|
fxHandle_t flechetteShotEffect;
|
|
fxHandle_t flechetteAltShotEffect;
|
|
fxHandle_t flechetteWallImpactEffect;
|
|
fxHandle_t flechetteFleshImpactEffect;
|
|
|
|
// ROCKET
|
|
fxHandle_t rocketShotEffect;
|
|
fxHandle_t rocketExplosionEffect;
|
|
|
|
// THERMAL
|
|
fxHandle_t thermalExplosionEffect;
|
|
fxHandle_t thermalShockwaveEffect;
|
|
|
|
// TRIPMINE
|
|
fxHandle_t tripmineLaserFX;
|
|
fxHandle_t tripmineGlowFX;
|
|
|
|
//FORCE
|
|
fxHandle_t forceLightning;
|
|
fxHandle_t forceLightningWide;
|
|
|
|
fxHandle_t forceDrain;
|
|
fxHandle_t forceDrainWide;
|
|
fxHandle_t forceDrained;
|
|
|
|
//TURRET
|
|
fxHandle_t turretShotEffect;
|
|
|
|
//Whatever
|
|
fxHandle_t itemCone;
|
|
|
|
fxHandle_t mSparks;
|
|
fxHandle_t mSaberCut;
|
|
fxHandle_t mTurretMuzzleFlash;
|
|
fxHandle_t mSaberBlock;
|
|
fxHandle_t mSaberBloodSparks;
|
|
fxHandle_t mSaberBloodSparksSmall;
|
|
fxHandle_t mSaberBloodSparksMid;
|
|
fxHandle_t mSpawn;
|
|
fxHandle_t mJediSpawn;
|
|
fxHandle_t mBlasterDeflect;
|
|
fxHandle_t mBlasterSmoke;
|
|
fxHandle_t mForceConfustionOld;
|
|
fxHandle_t mDisruptorDeathSmoke;
|
|
fxHandle_t mSparkExplosion;
|
|
fxHandle_t mTurretExplode;
|
|
fxHandle_t mEmplacedExplode;
|
|
fxHandle_t mEmplacedDeadSmoke;
|
|
fxHandle_t mTripmineExplosion;
|
|
fxHandle_t mDetpackExplosion;
|
|
fxHandle_t mFlechetteAltBlow;
|
|
fxHandle_t mStunBatonFleshImpact;
|
|
fxHandle_t mAltDetonate;
|
|
fxHandle_t mSparksExplodeNoSound;
|
|
fxHandle_t mTripMineLaster;
|
|
fxHandle_t mEmplacedMuzzleFlash;
|
|
fxHandle_t mConcussionAltRing;
|
|
fxHandle_t mHyperspaceStars;
|
|
fxHandle_t mBlackSmoke;
|
|
fxHandle_t mShipDestDestroyed;
|
|
fxHandle_t mShipDestBurning;
|
|
fxHandle_t mBobaJet;
|
|
|
|
//footstep effects
|
|
fxHandle_t footstepMud;
|
|
fxHandle_t footstepSand;
|
|
fxHandle_t footstepSnow;
|
|
fxHandle_t footstepGravel;
|
|
//landing effects
|
|
fxHandle_t landingMud;
|
|
fxHandle_t landingSand;
|
|
fxHandle_t landingDirt;
|
|
fxHandle_t landingSnow;
|
|
fxHandle_t landingGravel;
|
|
//splashes
|
|
fxHandle_t waterSplash;
|
|
fxHandle_t lavaSplash;
|
|
fxHandle_t acidSplash;
|
|
} cgEffects_t;
|
|
|
|
|
|
// The client game static (cgs) structure hold everything
|
|
// loaded or calculated from the gamestate. It will NOT
|
|
// be cleared when a tournement restart is done, allowing
|
|
// all clients to begin playing instantly
|
|
typedef struct {
|
|
gameState_t gameState; // gamestate from server
|
|
glconfig_t glconfig; // rendering configuration
|
|
float screenXScale; // derived from glconfig
|
|
float screenYScale;
|
|
float screenXBias;
|
|
|
|
int serverCommandSequence; // reliable command stream counter
|
|
int processedSnapshotNum;// the number of snapshots cgame has requested
|
|
|
|
qboolean localServer; // detected on startup by checking sv_running
|
|
|
|
// parsed from serverinfo
|
|
int siegeTeamSwitch;
|
|
int showDuelHealths;
|
|
gametype_t gametype;
|
|
int debugMelee;
|
|
int stepSlideFix;
|
|
int noSpecMove;
|
|
int dmflags;
|
|
int teamflags;
|
|
int fraglimit;
|
|
int duel_fraglimit;
|
|
int capturelimit;
|
|
int timelimit;
|
|
int maxclients;
|
|
qboolean needpass;
|
|
qboolean jediVmerc;
|
|
int wDisable;
|
|
int fDisable;
|
|
|
|
char mapname[MAX_QPATH];
|
|
char redTeam[MAX_QPATH];
|
|
char blueTeam[MAX_QPATH];
|
|
|
|
int voteTime;
|
|
int voteYes;
|
|
int voteNo;
|
|
qboolean voteModified; // beep whenever changed
|
|
char voteString[MAX_STRING_TOKENS];
|
|
|
|
int teamVoteTime[2];
|
|
int teamVoteYes[2];
|
|
int teamVoteNo[2];
|
|
qboolean teamVoteModified[2]; // beep whenever changed
|
|
char teamVoteString[2][MAX_STRING_TOKENS];
|
|
|
|
int levelStartTime;
|
|
|
|
int scores1, scores2; // from configstrings
|
|
int jediMaster;
|
|
int duelWinner;
|
|
int duelist1;
|
|
int duelist2;
|
|
int duelist3;
|
|
// nmckenzie: DUEL_HEALTH. hmm.
|
|
int duelist1health;
|
|
int duelist2health;
|
|
int duelist3health;
|
|
|
|
int redflag, blueflag; // flag status from configstrings
|
|
int flagStatus;
|
|
|
|
qboolean newHud;
|
|
|
|
//
|
|
// locally derived information from gamestate
|
|
//
|
|
qhandle_t gameModels[MAX_MODELS];
|
|
sfxHandle_t gameSounds[MAX_SOUNDS];
|
|
fxHandle_t gameEffects[MAX_FX];
|
|
qhandle_t gameIcons[MAX_ICONS];
|
|
|
|
int numInlineModels;
|
|
qhandle_t inlineDrawModel[MAX_MODELS];
|
|
vec3_t inlineModelMidpoints[MAX_MODELS];
|
|
|
|
clientInfo_t clientinfo[MAX_CLIENTS];
|
|
|
|
int cursorX;
|
|
int cursorY;
|
|
qboolean eventHandling;
|
|
qboolean mouseCaptured;
|
|
qboolean sizingHud;
|
|
void *capturedItem;
|
|
qhandle_t activeCursor;
|
|
|
|
// media
|
|
cgMedia_t media;
|
|
|
|
// effects
|
|
cgEffects_t effects;
|
|
|
|
} cgs_t;
|
|
|
|
typedef struct siegeExtended_s
|
|
{
|
|
int health;
|
|
int maxhealth;
|
|
int ammo;
|
|
int weapon;
|
|
int lastUpdated;
|
|
} siegeExtended_t;
|
|
|
|
//keep an entry available for each client
|
|
extern siegeExtended_t cg_siegeExtendedData[MAX_CLIENTS];
|
|
|
|
//==============================================================================
|
|
|
|
extern cgs_t cgs;
|
|
extern cg_t cg;
|
|
extern centity_t cg_entities[MAX_GENTITIES];
|
|
|
|
extern centity_t *cg_permanents[MAX_GENTITIES];
|
|
extern int cg_numpermanents;
|
|
|
|
extern weaponInfo_t cg_weapons[MAX_WEAPONS];
|
|
extern itemInfo_t cg_items[MAX_ITEMS];
|
|
extern markPoly_t cg_markPolys[MAX_MARK_POLYS];
|
|
|
|
extern vmCvar_t cg_centertime;
|
|
extern vmCvar_t cg_runpitch;
|
|
extern vmCvar_t cg_runroll;
|
|
extern vmCvar_t cg_bobup;
|
|
extern vmCvar_t cg_bobpitch;
|
|
extern vmCvar_t cg_bobroll;
|
|
//extern vmCvar_t cg_swingSpeed;
|
|
extern vmCvar_t cg_shadows;
|
|
extern vmCvar_t cg_renderToTextureFX;
|
|
extern vmCvar_t cg_drawTimer;
|
|
extern vmCvar_t cg_drawFPS;
|
|
extern vmCvar_t cg_drawSnapshot;
|
|
extern vmCvar_t cg_draw3dIcons;
|
|
extern vmCvar_t cg_drawIcons;
|
|
extern vmCvar_t cg_drawAmmoWarning;
|
|
extern vmCvar_t cg_drawCrosshair;
|
|
extern vmCvar_t cg_drawCrosshairNames;
|
|
extern vmCvar_t cg_drawRadar;
|
|
extern vmCvar_t cg_drawAutomap;
|
|
extern vmCvar_t cg_drawScores;
|
|
extern vmCvar_t cg_dynamicCrosshair;
|
|
extern vmCvar_t cg_dynamicCrosshairPrecision;
|
|
extern vmCvar_t cg_drawRewards;
|
|
extern vmCvar_t cg_drawTeamOverlay;
|
|
extern vmCvar_t cg_teamOverlayUserinfo;
|
|
extern vmCvar_t cg_crosshairX;
|
|
extern vmCvar_t cg_crosshairY;
|
|
extern vmCvar_t cg_crosshairSize;
|
|
extern vmCvar_t cg_crosshairHealth;
|
|
extern vmCvar_t cg_drawStatus;
|
|
extern vmCvar_t cg_draw2D;
|
|
extern vmCvar_t cg_animSpeed;
|
|
extern vmCvar_t cg_debugAnim;
|
|
extern vmCvar_t cg_debugPosition;
|
|
extern vmCvar_t cg_debugEvents;
|
|
extern vmCvar_t cg_errorDecay;
|
|
extern vmCvar_t cg_nopredict;
|
|
extern vmCvar_t cg_noPlayerAnims;
|
|
extern vmCvar_t cg_showmiss;
|
|
extern vmCvar_t cg_showVehMiss;
|
|
extern vmCvar_t cg_footsteps;
|
|
extern vmCvar_t cg_addMarks;
|
|
extern vmCvar_t cg_gun_frame;
|
|
extern vmCvar_t cg_gun_x;
|
|
extern vmCvar_t cg_gun_y;
|
|
extern vmCvar_t cg_gun_z;
|
|
extern vmCvar_t cg_drawGun;
|
|
extern vmCvar_t cg_viewsize;
|
|
extern vmCvar_t cg_autoswitch;
|
|
extern vmCvar_t cg_ignore;
|
|
extern vmCvar_t cg_simpleItems;
|
|
extern vmCvar_t cg_fov;
|
|
extern vmCvar_t cg_zoomFov;
|
|
|
|
extern vmCvar_t cg_swingAngles;
|
|
|
|
extern vmCvar_t cg_oldPainSounds;
|
|
|
|
extern vmCvar_t cg_ragDoll;
|
|
|
|
extern vmCvar_t cg_jumpSounds;
|
|
|
|
extern vmCvar_t cg_autoMap;
|
|
extern vmCvar_t cg_autoMapX;
|
|
extern vmCvar_t cg_autoMapY;
|
|
extern vmCvar_t cg_autoMapW;
|
|
extern vmCvar_t cg_autoMapH;
|
|
|
|
extern vmCvar_t bg_fighterAltControl;
|
|
|
|
extern vmCvar_t cg_chatBox;
|
|
extern vmCvar_t cg_chatBoxHeight;
|
|
|
|
extern vmCvar_t cg_saberModelTraceEffect;
|
|
|
|
extern vmCvar_t cg_saberClientVisualCompensation;
|
|
|
|
extern vmCvar_t cg_g2TraceLod;
|
|
|
|
extern vmCvar_t cg_fpls;
|
|
|
|
extern vmCvar_t cg_ghoul2Marks;
|
|
|
|
extern vmCvar_t cg_saberDynamicMarks;
|
|
extern vmCvar_t cg_saberDynamicMarkTime;
|
|
|
|
extern vmCvar_t cg_saberContact;
|
|
extern vmCvar_t cg_saberTrail;
|
|
|
|
extern vmCvar_t cg_duelHeadAngles;
|
|
|
|
extern vmCvar_t cg_speedTrail;
|
|
extern vmCvar_t cg_auraShell;
|
|
|
|
extern vmCvar_t cg_repeaterOrb;
|
|
|
|
extern vmCvar_t cg_animBlend;
|
|
|
|
extern vmCvar_t cg_dismember;
|
|
|
|
extern vmCvar_t cg_thirdPersonSpecialCam;
|
|
|
|
extern vmCvar_t cg_thirdPerson;
|
|
extern vmCvar_t cg_thirdPersonRange;
|
|
extern vmCvar_t cg_thirdPersonAngle;
|
|
extern vmCvar_t cg_thirdPersonPitchOffset;
|
|
extern vmCvar_t cg_thirdPersonVertOffset;
|
|
extern vmCvar_t cg_thirdPersonCameraDamp;
|
|
extern vmCvar_t cg_thirdPersonTargetDamp;
|
|
|
|
extern vmCvar_t cg_thirdPersonAlpha;
|
|
extern vmCvar_t cg_thirdPersonHorzOffset;
|
|
|
|
extern vmCvar_t cg_stereoSeparation;
|
|
extern vmCvar_t cg_lagometer;
|
|
extern vmCvar_t cg_drawEnemyInfo;
|
|
extern vmCvar_t cg_synchronousClients;
|
|
extern vmCvar_t cg_stats;
|
|
extern vmCvar_t cg_forceModel;
|
|
extern vmCvar_t cg_buildScript;
|
|
extern vmCvar_t cg_paused;
|
|
extern vmCvar_t cg_blood;
|
|
extern vmCvar_t cg_predictItems;
|
|
extern vmCvar_t cg_deferPlayers;
|
|
extern vmCvar_t cg_drawFriend;
|
|
extern vmCvar_t cg_teamChatsOnly;
|
|
extern vmCvar_t cg_noVoiceChats;
|
|
extern vmCvar_t cg_noVoiceText;
|
|
extern vmCvar_t cg_scorePlum;
|
|
extern vmCvar_t cg_hudFiles;
|
|
extern vmCvar_t cg_smoothClients;
|
|
|
|
#include "../namespace_begin.h"
|
|
extern vmCvar_t pmove_fixed;
|
|
extern vmCvar_t pmove_msec;
|
|
#include "../namespace_end.h"
|
|
|
|
//extern vmCvar_t cg_pmove_fixed;
|
|
extern vmCvar_t cg_cameraOrbit;
|
|
extern vmCvar_t cg_cameraOrbitDelay;
|
|
extern vmCvar_t cg_timescaleFadeEnd;
|
|
extern vmCvar_t cg_timescaleFadeSpeed;
|
|
extern vmCvar_t cg_timescale;
|
|
extern vmCvar_t cg_cameraMode;
|
|
extern vmCvar_t cg_smallFont;
|
|
extern vmCvar_t cg_bigFont;
|
|
extern vmCvar_t cg_noTaunt;
|
|
extern vmCvar_t cg_noProjectileTrail;
|
|
extern vmCvar_t cg_trueLightning;
|
|
|
|
extern vmCvar_t cg_redTeamName;
|
|
extern vmCvar_t cg_blueTeamName;
|
|
extern vmCvar_t cg_currentSelectedPlayer;
|
|
extern vmCvar_t cg_currentSelectedPlayerName;
|
|
extern vmCvar_t cg_singlePlayer;
|
|
extern vmCvar_t cg_enableDust;
|
|
extern vmCvar_t cg_enableBreath;
|
|
extern vmCvar_t cg_singlePlayerActive;
|
|
extern vmCvar_t cg_recordSPDemo;
|
|
extern vmCvar_t cg_recordSPDemoName;
|
|
|
|
extern vmCvar_t ui_myteam;
|
|
extern vmCvar_t cg_snapshotTimeout;
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
extern vmCvar_t cg_debugBB;
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
//
|
|
// cg_main.c
|
|
//
|
|
void CG_DrawMiscEnts(void);
|
|
|
|
const char *CG_ConfigString( int index );
|
|
const char *CG_Argv( int arg );
|
|
|
|
void QDECL CG_Printf( const char *msg, ... );
|
|
void QDECL CG_Error( const char *msg, ... );
|
|
|
|
void CG_StartMusic( qboolean bForceStart );
|
|
|
|
void CG_UpdateCvars( void );
|
|
|
|
int CG_CrosshairPlayer( void );
|
|
int CG_LastAttacker( void );
|
|
void CG_LoadMenus(const char *menuFile);
|
|
void CG_KeyEvent(int key, qboolean down);
|
|
void CG_MouseEvent(int x, int y);
|
|
void CG_EventHandling(int type);
|
|
void CG_RankRunFrame( void );
|
|
void CG_SetScoreSelection(void *menu);
|
|
void CG_BuildSpectatorString(void);
|
|
void CG_NextInventory_f(void);
|
|
void CG_PrevInventory_f(void);
|
|
void CG_NextForcePower_f(void);
|
|
void CG_PrevForcePower_f(void);
|
|
|
|
//
|
|
// cg_view.c
|
|
//
|
|
void CG_TestModel_f (void);
|
|
void CG_TestGun_f (void);
|
|
void CG_TestModelNextFrame_f (void);
|
|
void CG_TestModelPrevFrame_f (void);
|
|
void CG_TestModelNextSkin_f (void);
|
|
void CG_TestModelPrevSkin_f (void);
|
|
void CG_ZoomDown_f( void );
|
|
void CG_ZoomUp_f( void );
|
|
void CG_AddBufferedSound( sfxHandle_t sfx);
|
|
|
|
void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback );
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
void CG_TestG2Model_f (void);
|
|
void CG_TestModelSurfaceOnOff_f(void);
|
|
void CG_ListModelSurfaces_f (void);
|
|
void CG_ListModelBones_f (void);
|
|
void CG_TestModelSetAnglespre_f(void);
|
|
void CG_TestModelSetAnglespost_f(void);
|
|
void CG_TestModelAnimate_f(void);
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
//
|
|
// cg_drawtools.c
|
|
//
|
|
void CG_FillRect( float x, float y, float width, float height, const float *color );
|
|
void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader );
|
|
void CG_DrawRotatePic( float x, float y, float width, float height,float angle, qhandle_t hShader );
|
|
void CG_DrawRotatePic2( float x, float y, float width, float height,float angle, qhandle_t hShader );
|
|
void CG_DrawString( float x, float y, const char *string,
|
|
float charWidth, float charHeight, const float *modulate );
|
|
|
|
void CG_DrawNumField (int x, int y, int width, int value,int charWidth,int charHeight,int style,qboolean zeroFill);
|
|
|
|
void CG_DrawStringExt( int x, int y, const char *string, const float *setColor,
|
|
qboolean forceColor, qboolean shadow, int charWidth, int charHeight, int maxChars );
|
|
void CG_DrawBigString( int x, int y, const char *s, float alpha );
|
|
void CG_DrawBigStringColor( int x, int y, const char *s, vec4_t color );
|
|
void CG_DrawSmallString( int x, int y, const char *s, float alpha );
|
|
void CG_DrawSmallStringColor( int x, int y, const char *s, vec4_t color );
|
|
|
|
int CG_DrawStrlen( const char *str );
|
|
|
|
float *CG_FadeColor( int startMsec, int totalMsec );
|
|
float *CG_TeamColor( int team );
|
|
void CG_TileClear( void );
|
|
void CG_ColorForHealth( vec4_t hcolor );
|
|
void CG_GetColorForHealth( int health, int armor, vec4_t hcolor );
|
|
|
|
void UI_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color );
|
|
void UI_DrawScaledProportionalString( int x, int y, const char* str, int style, vec4_t color, float scale);
|
|
void CG_DrawRect( float x, float y, float width, float height, float size, const float *color );
|
|
void CG_DrawSides(float x, float y, float w, float h, float size);
|
|
void CG_DrawTopBottom(float x, float y, float w, float h, float size);
|
|
|
|
//
|
|
// cg_draw.c, cg_newDraw.c
|
|
//
|
|
extern int sortedTeamPlayers[TEAM_MAXOVERLAY];
|
|
extern int numSortedTeamPlayers;
|
|
extern char systemChat[256];
|
|
|
|
void CG_AddLagometerFrameInfo( void );
|
|
void CG_AddLagometerSnapshotInfo( snapshot_t *snap );
|
|
void CG_CenterPrint( const char *str, int y, int charWidth );
|
|
void CG_DrawHead( float x, float y, float w, float h, int clientNum, vec3_t headAngles );
|
|
void CG_DrawActive( stereoFrame_t stereoView );
|
|
void CG_DrawFlagModel( float x, float y, float w, float h, int team, qboolean force2D );
|
|
void CG_DrawTeamBackground( int x, int y, int w, int h, float alpha, int team );
|
|
void CG_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle,int font);
|
|
void CG_Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont);
|
|
int CG_Text_Width(const char *text, float scale, int iMenuFont);
|
|
int CG_Text_Height(const char *text, float scale, int iMenuFont);
|
|
float CG_GetValue(int ownerDraw);
|
|
qboolean CG_OwnerDrawVisible(int flags);
|
|
void CG_RunMenuScript(char **args);
|
|
qboolean CG_DeferMenuScript(char **args);
|
|
void CG_ShowResponseHead(void);
|
|
void CG_GetTeamColor(vec4_t *color);
|
|
const char *CG_GetGameStatusText(void);
|
|
const char *CG_GetKillerText(void);
|
|
void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, void *ghoul2, int g2radius, qhandle_t skin, vec3_t origin, vec3_t angles );
|
|
void CG_Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader);
|
|
const char *CG_GameTypeString(void);
|
|
qboolean CG_YourTeamHasFlag(void);
|
|
qboolean CG_OtherTeamHasFlag(void);
|
|
qhandle_t CG_StatusHandle(int task);
|
|
|
|
|
|
|
|
//
|
|
// cg_player.c
|
|
//
|
|
qboolean CG_RagDoll(centity_t *cent, vec3_t forcedAngles);
|
|
qboolean CG_G2TraceCollide(trace_t *tr, const vec3_t mins, const vec3_t maxs, const vec3_t lastValidStart, const vec3_t lastValidEnd);
|
|
void CG_AddGhoul2Mark(int shader, float size, vec3_t start, vec3_t end, int entnum,
|
|
vec3_t entposition, float entangle, void *ghoul2, vec3_t scale, int lifeTime);
|
|
|
|
void CG_CreateNPCClient(clientInfo_t **ci);
|
|
void CG_DestroyNPCClient(clientInfo_t **ci);
|
|
|
|
void CG_Player( centity_t *cent );
|
|
void CG_ResetPlayerEntity( centity_t *cent );
|
|
void CG_AddRefEntityWithPowerups( refEntity_t *ent, entityState_t *state, int team );
|
|
void CG_NewClientInfo( int clientNum, qboolean entitiesInitialized );
|
|
sfxHandle_t CG_CustomSound( int clientNum, const char *soundName );
|
|
void CG_PlayerShieldHit(int entitynum, vec3_t angles, int amount);
|
|
|
|
|
|
//
|
|
// cg_predict.c
|
|
//
|
|
void CG_BuildSolidList( void );
|
|
int CG_PointContents( const vec3_t point, int passEntityNum );
|
|
void CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
|
|
int skipNumber, int mask );
|
|
void CG_G2Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
|
|
int skipNumber, int mask );
|
|
void CG_PredictPlayerState( void );
|
|
void CG_LoadDeferredPlayers( void );
|
|
|
|
|
|
//
|
|
// cg_events.c
|
|
//
|
|
void CG_CheckEvents( centity_t *cent );
|
|
const char *CG_PlaceString( int rank );
|
|
void CG_EntityEvent( centity_t *cent, vec3_t position );
|
|
void CG_PainEvent( centity_t *cent, int health );
|
|
void CG_ReattachLimb(centity_t *source);
|
|
|
|
|
|
//
|
|
// cg_ents.c
|
|
//
|
|
|
|
void CG_S_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx);
|
|
void CG_S_AddRealLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx);
|
|
void CG_S_StopLoopingSound(int entityNum, sfxHandle_t sfx);
|
|
void CG_S_UpdateLoopingSounds(int entityNum);
|
|
|
|
void CG_SetEntitySoundPosition( centity_t *cent );
|
|
void CG_AddPacketEntities( qboolean isPortal );
|
|
void CG_ManualEntityRender(centity_t *cent);
|
|
void CG_Beam( centity_t *cent );
|
|
void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out );
|
|
|
|
void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent,
|
|
qhandle_t parentModel, char *tagName );
|
|
void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent,
|
|
qhandle_t parentModel, char *tagName );
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
void ScaleModelAxis(refEntity_t *ent);
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
//
|
|
// cg_turret.c
|
|
//
|
|
void TurretClientRun(centity_t *ent);
|
|
|
|
//
|
|
// cg_weapons.c
|
|
//
|
|
void CG_GetClientWeaponMuzzleBoltPoint(int clIndex, vec3_t to);
|
|
|
|
void CG_NextWeapon_f( void );
|
|
void CG_PrevWeapon_f( void );
|
|
void CG_Weapon_f( void );
|
|
void CG_WeaponClean_f( void );
|
|
|
|
void CG_RegisterWeapon( int weaponNum);
|
|
void CG_RegisterItemVisuals( int itemNum );
|
|
|
|
void CG_FireWeapon( centity_t *cent, qboolean alt_fire );
|
|
void CG_MissileHitWall(int weapon, int clientNum, vec3_t origin, vec3_t dir, impactSound_t soundType, qboolean alt_fire, int charge);
|
|
void CG_MissileHitPlayer( int weapon, vec3_t origin, vec3_t dir, int entityNum, qboolean alt_fire);
|
|
|
|
void CG_AddViewWeapon (playerState_t *ps);
|
|
void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson );
|
|
void CG_DrawWeaponSelect( void );
|
|
void CG_DrawIconBackground(void);
|
|
|
|
void CG_OutOfAmmoChange( int oldWeapon ); // should this be in pmove?
|
|
|
|
//
|
|
// cg_marks.c
|
|
//
|
|
void CG_InitMarkPolys( void );
|
|
void CG_AddMarks( void );
|
|
void CG_ImpactMark( qhandle_t markShader,
|
|
const vec3_t origin, const vec3_t dir,
|
|
float orientation,
|
|
float r, float g, float b, float a,
|
|
qboolean alphaFade,
|
|
float radius, qboolean temporary );
|
|
|
|
//
|
|
// cg_localents.c
|
|
//
|
|
void CG_InitLocalEntities( void );
|
|
localEntity_t *CG_AllocLocalEntity( void );
|
|
void CG_AddLocalEntities( void );
|
|
|
|
//
|
|
// cg_effects.c
|
|
//
|
|
localEntity_t *CG_SmokePuff( const vec3_t p,
|
|
const vec3_t vel,
|
|
float radius,
|
|
float r, float g, float b, float a,
|
|
float duration,
|
|
int startTime,
|
|
int fadeInTime,
|
|
int leFlags,
|
|
qhandle_t hShader );
|
|
void CG_BubbleTrail( vec3_t start, vec3_t end, float spacing );
|
|
void CG_GlassShatter(int entnum, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards);
|
|
void CG_ScorePlum( int client, vec3_t org, int score );
|
|
|
|
void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs,
|
|
float speed, int numChunks, material_t chunkType, int customChunk, float baseScale );
|
|
void CG_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType );
|
|
|
|
void CG_Bleed( vec3_t origin, int entityNum );
|
|
|
|
localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir,
|
|
qhandle_t hModel, int numframes, qhandle_t shader, int msec,
|
|
qboolean isSprite, float scale, int flags );// Overloaded in single player
|
|
|
|
void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke );
|
|
|
|
void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius);
|
|
|
|
void CG_InitGlass( void );
|
|
|
|
//
|
|
// cg_snapshot.c
|
|
//
|
|
void CG_ProcessSnapshots( void );
|
|
|
|
//
|
|
// cg_info.c
|
|
//
|
|
void CG_LoadingString( const char *s );
|
|
void CG_LoadingItem( int itemNum );
|
|
void CG_LoadingClient( int clientNum );
|
|
void CG_DrawInformation( void );
|
|
|
|
//
|
|
// cg_scoreboard.c
|
|
//
|
|
qboolean CG_DrawOldScoreboard( void );
|
|
void CG_DrawOldTourneyScoreboard( void );
|
|
|
|
//
|
|
// cg_consolecmds.c
|
|
//
|
|
qboolean CG_ConsoleCommand( void );
|
|
void CG_InitConsoleCommands( void );
|
|
|
|
//
|
|
// cg_servercmds.c
|
|
//
|
|
void CG_ExecuteNewServerCommands( int latestSequence );
|
|
void CG_ParseServerinfo( void );
|
|
void CG_SetConfigValues( void );
|
|
void CG_ShaderStateChanged(void);
|
|
|
|
//
|
|
// cg_playerstate.c
|
|
//
|
|
int CG_IsMindTricked(int trickIndex1, int trickIndex2, int trickIndex3, int trickIndex4, int client);
|
|
void CG_Respawn( void );
|
|
void CG_TransitionPlayerState( playerState_t *ps, playerState_t *ops );
|
|
void CG_CheckChangedPredictableEvents( playerState_t *ps );
|
|
|
|
|
|
//
|
|
// cg_siege.c
|
|
//
|
|
void CG_InitSiegeMode(void);
|
|
void CG_SiegeRoundOver(centity_t *ent, int won);
|
|
void CG_SiegeObjectiveCompleted(centity_t *ent, int won, int objectivenum);
|
|
|
|
|
|
|
|
//===============================================
|
|
|
|
//
|
|
// system traps
|
|
// These functions are how the cgame communicates with the main game system
|
|
//
|
|
|
|
#include "../namespace_begin.h"
|
|
|
|
// print message on the local console
|
|
void trap_Print( const char *fmt );
|
|
|
|
// abort the game
|
|
void trap_Error( const char *fmt );
|
|
|
|
// milliseconds should only be used for performance tuning, never
|
|
// for anything game related. Get time from the CG_DrawActiveFrame parameter
|
|
int trap_Milliseconds( void );
|
|
|
|
//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
|
|
//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
|
|
void trap_PrecisionTimer_Start(void **theNewTimer);
|
|
int trap_PrecisionTimer_End(void *theTimer);
|
|
|
|
// console variable interaction
|
|
void trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
|
|
void trap_Cvar_Update( vmCvar_t *vmCvar );
|
|
void trap_Cvar_Set( const char *var_name, const char *value );
|
|
void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
|
|
int trap_Cvar_GetHiddenVarValue(const char *name);
|
|
|
|
// ServerCommand and ConsoleCommand parameter access
|
|
int trap_Argc( void );
|
|
void trap_Argv( int n, char *buffer, int bufferLength );
|
|
void trap_Args( char *buffer, int bufferLength );
|
|
|
|
// filesystem access
|
|
// returns length of file
|
|
int trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
|
|
void trap_FS_Read( void *buffer, int len, fileHandle_t f );
|
|
void trap_FS_Write( const void *buffer, int len, fileHandle_t f );
|
|
void trap_FS_FCloseFile( fileHandle_t f );
|
|
int trap_FS_GetFileList( const char *path, const char *extension, char *listbuf, int bufsize );
|
|
|
|
// add commands to the local console as if they were typed in
|
|
// for map changing, etc. The command is not executed immediately,
|
|
// but will be executed in order the next time console commands
|
|
// are processed
|
|
void trap_SendConsoleCommand( const char *text );
|
|
|
|
// register a command name so the console can perform command completion.
|
|
// FIXME: replace this with a normal console command "defineCommand"?
|
|
void trap_AddCommand( const char *cmdName );
|
|
|
|
// send a string to the server over the network
|
|
void trap_SendClientCommand( const char *s );
|
|
|
|
// force a screen update, only used during gamestate load
|
|
void trap_UpdateScreen( void );
|
|
|
|
// model collision
|
|
void trap_CM_LoadMap( const char *mapname, qboolean SubBSP );
|
|
int trap_CM_NumInlineModels( void );
|
|
clipHandle_t trap_CM_InlineModel( int index ); // 0 = world, 1+ = bmodels
|
|
clipHandle_t trap_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs );
|
|
int trap_CM_PointContents( const vec3_t p, clipHandle_t model );
|
|
int trap_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles );
|
|
void trap_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
|
|
const vec3_t mins, const vec3_t maxs,
|
|
clipHandle_t model, int brushmask );
|
|
void trap_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
|
|
const vec3_t mins, const vec3_t maxs,
|
|
clipHandle_t model, int brushmask,
|
|
const vec3_t origin, const vec3_t angles );
|
|
|
|
// Returns the projection of a polygon onto the solid brushes in the world
|
|
int trap_CM_MarkFragments( int numPoints, const vec3_t *points,
|
|
const vec3_t projection,
|
|
int maxPoints, vec3_t pointBuffer,
|
|
int maxFragments, markFragment_t *fragmentBuffer );
|
|
|
|
// normal sounds will have their volume dynamically changed as their entity
|
|
// moves and the listener moves
|
|
int trap_S_GetVoiceVolume( int entityNum );
|
|
void trap_S_MuteSound( int entityNum, int entchannel );
|
|
void trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
|
|
void trap_S_StopLoopingSound(int entnum);
|
|
|
|
// a local sound is always played full volume
|
|
void trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum );
|
|
void trap_S_ClearLoopingSounds( void );
|
|
void trap_S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
|
|
void trap_S_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
|
|
void trap_S_UpdateEntityPosition( int entityNum, const vec3_t origin );
|
|
|
|
// repatialize recalculates the volumes of sound as they should be heard by the
|
|
// given entityNum and position
|
|
void trap_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater );
|
|
void trap_S_ShutUp(qboolean shutUpFactor);
|
|
sfxHandle_t trap_S_RegisterSound( const char *sample); // returns buzz if not found
|
|
void trap_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bReturnWithoutStarting); // empty name stops music
|
|
void trap_S_StopBackgroundTrack( void );
|
|
|
|
void trap_S_UpdateAmbientSet( const char *name, vec3_t origin );
|
|
void trap_AS_ParseSets( void );
|
|
void trap_AS_AddPrecacheEntry( const char *name );
|
|
int trap_S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time );
|
|
sfxHandle_t trap_AS_GetBModelSound( const char *name, int stage );
|
|
|
|
void trap_R_LoadWorldMap( const char *mapname );
|
|
|
|
// all media should be registered during level startup to prevent
|
|
// hitches during gameplay
|
|
qhandle_t trap_R_RegisterModel( const char *name ); // returns rgb axis if not found
|
|
qhandle_t trap_R_RegisterSkin( const char *name ); // returns all white if not found
|
|
qhandle_t trap_R_RegisterShader( const char *name ); // returns all white if not found
|
|
qhandle_t trap_R_RegisterShaderNoMip( const char *name ); // returns all white if not found
|
|
qhandle_t trap_R_RegisterFont( const char *name );
|
|
int trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale);
|
|
int trap_R_Font_StrLenChars(const char *text);
|
|
int trap_R_Font_HeightPixels(const int iFontIndex, const float scale);
|
|
void trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
|
|
qboolean trap_Language_IsAsian(void);
|
|
qboolean trap_Language_UsesSpaces(void);
|
|
unsigned trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ );
|
|
|
|
|
|
// a scene is built up by calls to R_ClearScene and the various R_Add functions.
|
|
// Nothing is drawn until R_RenderScene is called.
|
|
void trap_R_ClearScene( void );
|
|
void trap_R_ClearDecals ( void );
|
|
void trap_R_AddRefEntityToScene( const refEntity_t *re );
|
|
|
|
// polys are intended for simple wall marks, not really for doing
|
|
// significant construction
|
|
void trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts );
|
|
void trap_R_AddPolysToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts, int numPolys );
|
|
void trap_R_AddDecalToScene ( qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary );
|
|
void trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
|
|
int trap_R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
|
|
void trap_R_RenderScene( const refdef_t *fd );
|
|
void trap_R_SetColor( const float *rgba ); // NULL = 1,1,1,1
|
|
void trap_R_DrawStretchPic( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2, qhandle_t hShader );
|
|
void trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs );
|
|
int trap_R_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame,
|
|
float frac, const char *tagName );
|
|
// Does weird, barely controllable rotation behaviour
|
|
void trap_R_DrawRotatePic( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
|
|
// rotates image around exact center point of passed in coords
|
|
void trap_R_DrawRotatePic2( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
|
|
|
|
void trap_R_SetRangeFog(float range);
|
|
|
|
void trap_R_SetRefractProp(float alpha, float stretch, qboolean prepost, qboolean negate);
|
|
|
|
void trap_R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset );
|
|
|
|
void trap_R_GetLightStyle(int style, color4ub_t color);
|
|
void trap_R_SetLightStyle(int style, int color);
|
|
|
|
void trap_R_GetBModelVerts(int bmodelIndex, vec3_t *verts, vec3_t normal );
|
|
|
|
void trap_R_GetDistanceCull(float *f);
|
|
|
|
void trap_R_GetRealRes(int *w, int *h); //get screen resolution -rww
|
|
void trap_R_AutomapElevAdj(float newHeight); //automap elevation setting -rww
|
|
qboolean trap_R_InitWireframeAutomap(void); //initialize automap -rww
|
|
|
|
|
|
void trap_FX_AddLine( const vec3_t start, const vec3_t end, float size1, float size2, float sizeParm,
|
|
float alpha1, float alpha2, float alphaParm,
|
|
const vec3_t sRGB, const vec3_t eRGB, float rgbParm,
|
|
int killTime, qhandle_t shader, int flags);
|
|
|
|
// The glconfig_t will not change during the life of a cgame.
|
|
// If it needs to change, the entire cgame will be restarted, because
|
|
// all the qhandle_t are then invalid.
|
|
void trap_GetGlconfig( glconfig_t *glconfig );
|
|
|
|
// the gamestate should be grabbed at startup, and whenever a
|
|
// configstring changes
|
|
void trap_GetGameState( gameState_t *gamestate );
|
|
|
|
// cgame will poll each frame to see if a newer snapshot has arrived
|
|
// that it is interested in. The time is returned seperately so that
|
|
// snapshot latency can be calculated.
|
|
void trap_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime );
|
|
|
|
// a snapshot get can fail if the snapshot (or the entties it holds) is so
|
|
// old that it has fallen out of the client system queue
|
|
qboolean trap_GetSnapshot( int snapshotNumber, snapshot_t *snapshot );
|
|
|
|
|
|
qboolean trap_GetDefaultState(int entityIndex, entityState_t *state );
|
|
|
|
// retrieve a text command from the server stream
|
|
// the current snapshot will hold the number of the most recent command
|
|
// qfalse can be returned if the client system handled the command
|
|
// argc() / argv() can be used to examine the parameters of the command
|
|
qboolean trap_GetServerCommand( int serverCommandNumber );
|
|
|
|
// returns the most recent command number that can be passed to GetUserCmd
|
|
// this will always be at least one higher than the number in the current
|
|
// snapshot, and it may be quite a few higher if it is a fast computer on
|
|
// a lagged connection
|
|
int trap_GetCurrentCmdNumber( void );
|
|
|
|
qboolean trap_GetUserCmd( int cmdNumber, usercmd_t *ucmd );
|
|
|
|
// used for the weapon select and zoom
|
|
void trap_SetUserCmdValue( int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride, float mSensitivityOverride, int fpSel, int invenSel, qboolean fighterControls );
|
|
|
|
void trap_SetClientForceAngle(int time, vec3_t angle);
|
|
void trap_SetClientTurnExtent(float turnAdd, float turnSub, int turnTime);
|
|
|
|
void trap_OpenUIMenu(int menuID);
|
|
|
|
// aids for VM testing
|
|
void testPrintInt( char *string, int i );
|
|
void testPrintFloat( char *string, float f );
|
|
|
|
int trap_MemoryRemaining( void );
|
|
qboolean trap_Key_IsDown( int keynum );
|
|
int trap_Key_GetCatcher( void );
|
|
void trap_Key_SetCatcher( int catcher );
|
|
int trap_Key_GetKey( const char *binding );
|
|
|
|
void BG_CycleInven(playerState_t *ps, int direction);
|
|
int BG_ProperForceIndex(int power);
|
|
void BG_CycleForce(playerState_t *ps, int direction);
|
|
|
|
#include "../namespace_end.h"
|
|
|
|
|
|
typedef enum {
|
|
SYSTEM_PRINT,
|
|
CHAT_PRINT,
|
|
TEAMCHAT_PRINT
|
|
} q3print_t; // bk001201 - warning: useless keyword or type name in empty declaration
|
|
|
|
#include "../namespace_begin.h"
|
|
|
|
int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits);
|
|
e_status trap_CIN_StopCinematic(int handle);
|
|
e_status trap_CIN_RunCinematic (int handle);
|
|
void trap_CIN_DrawCinematic (int handle);
|
|
void trap_CIN_SetExtents (int handle, int x, int y, int w, int h);
|
|
|
|
void trap_SnapVector( float *v );
|
|
|
|
qboolean trap_loadCamera(const char *name);
|
|
void trap_startCamera(int time);
|
|
qboolean trap_getCameraInfo(int time, vec3_t *origin, vec3_t *angles);
|
|
|
|
qboolean trap_GetEntityToken( char *buffer, int bufferSize );
|
|
qboolean trap_R_inPVS( const vec3_t p1, const vec3_t p2, byte *mask );
|
|
|
|
int trap_FX_InitSystem ( refdef_t* );
|
|
void trap_FX_SetRefDef ( refdef_t* refdef );
|
|
int trap_FX_RegisterEffect ( const char *file);
|
|
void trap_FX_PlayEffect ( const char *file, vec3_t org, vec3_t fwd, int vol, int rad ); // builds arbitrary perp. right vector, does a cross product to define up
|
|
void trap_FX_PlayEntityEffect ( const char *file, vec3_t org, vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad );
|
|
void trap_FX_PlayEffectID ( int id, vec3_t org, vec3_t fwd, int vol, int rad ); // builds arbitrary perp. right vector, does a cross product to define up
|
|
void trap_FX_PlayPortalEffectID ( int id, vec3_t org, vec3_t fwd, int vol, int rad ); // builds arbitrary perp. right vector, does a cross product to define up
|
|
void trap_FX_PlayEntityEffectID ( int id, vec3_t org, vec3_t axis[3], const int boltInfo, const int pGhoul2, int vol, int rad );
|
|
void trap_FX_PlayBoltedEffectID ( int id, vec3_t org, void *pGhoul2, const int boltNum, const int entNum, const int modelNum, int iLooptime, qboolean isRelative );
|
|
void trap_FX_AddScheduledEffects ( qboolean skyPortal );
|
|
void trap_FX_Draw2DEffects ( float screenXScale, float screenYScale );
|
|
qboolean trap_FX_FreeSystem ( void );
|
|
void trap_FX_AdjustTime ( int time );
|
|
void trap_FX_Reset ( void );
|
|
|
|
//rww - additional funcs for adding custom incode stuff
|
|
void trap_FX_AddPoly( addpolyArgStruct_t *p );
|
|
void trap_FX_AddBezier( addbezierArgStruct_t *p );
|
|
void trap_FX_AddPrimitive( effectTrailArgStruct_t *p );
|
|
void trap_FX_AddSprite( addspriteArgStruct_t *p );
|
|
void trap_FX_AddElectricity( addElectricityArgStruct_t *p );
|
|
|
|
//void trap_SP_Print(const unsigned ID, byte *Data);
|
|
int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength);
|
|
|
|
void trap_CG_RegisterSharedMemory(char *memory);
|
|
|
|
int trap_CM_RegisterTerrain(const char *config);
|
|
void trap_RMG_Init(int terrainID, const char *terrainInfo);
|
|
void trap_RE_InitRendererTerrain( const char *info );
|
|
void trap_R_WeatherContentsOverride( int contents );
|
|
void trap_R_WorldEffectCommand(const char *cmd);
|
|
void trap_WE_AddWeatherZone( const vec3_t mins, const vec3_t maxs );
|
|
|
|
qboolean trap_ROFF_Clean( void );
|
|
void trap_ROFF_UpdateEntities( void );
|
|
int trap_ROFF_Cache( char *file );
|
|
qboolean trap_ROFF_Play( int entID, int roffID, qboolean doTranslation );
|
|
qboolean trap_ROFF_Purge_Ent( int entID );
|
|
|
|
//rww - dynamic vm memory allocation!
|
|
void trap_TrueMalloc(void **ptr, int size);
|
|
void trap_TrueFree(void **ptr);
|
|
|
|
#include "../namespace_end.h"
|
|
|
|
void CG_ClearParticles (void);
|
|
void CG_AddParticles (void);
|
|
void CG_ParticleSnow (qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum);
|
|
void CG_ParticleSmoke (qhandle_t pshader, centity_t *cent);
|
|
void CG_AddParticleShrapnel (localEntity_t *le);
|
|
void CG_ParticleSnowFlurry (qhandle_t pshader, centity_t *cent);
|
|
void CG_ParticleBulletDebris (vec3_t org, vec3_t vel, int duration);
|
|
void CG_ParticleSparks (vec3_t org, vec3_t vel, int duration, float x, float y, float speed);
|
|
void CG_ParticleDust (centity_t *cent, vec3_t origin, vec3_t dir);
|
|
void CG_ParticleMisc (qhandle_t pshader, vec3_t origin, int size, int duration, float alpha);
|
|
void CG_ParticleExplosion (char *animStr, vec3_t origin, vec3_t vel, int duration, int sizeStart, int sizeEnd);
|
|
const char *CG_GetStringEdString(char *refSection, char *refName);
|
|
extern qboolean initparticles;
|
|
int CG_NewParticleArea ( int num );
|
|
|
|
void FX_TurretProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_TurretHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_TurretHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
|
|
void FX_ConcussionHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_ConcussionHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
void FX_ConcussionProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_ConcAltShot( vec3_t start, vec3_t end );
|
|
|
|
//-----------------------------
|
|
// Effects related prototypes
|
|
//-----------------------------
|
|
|
|
// Environmental effects
|
|
void CG_Spark( vec3_t origin, vec3_t dir );
|
|
|
|
// Weapon prototypes
|
|
void FX_BryarHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
|
|
void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
|
|
void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
|
|
|
|
void FX_ForceDrained(vec3_t origin, vec3_t dir);
|
|
|
|
|
|
//-----------------------------
|
|
// Effects related prototypes
|
|
//-----------------------------
|
|
|
|
// Environmental effects
|
|
void CG_Spark( vec3_t origin, vec3_t dir );
|
|
|
|
// Weapon prototypes
|
|
void FX_BryarHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
|
|
void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
|
|
void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
|
|
void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
|
|
void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
|
|
|
|
#include "../namespace_begin.h"
|
|
|
|
void trap_G2API_CollisionDetect ( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,int frameNumber, int entNum, const vec3_t rayStart, const vec3_t rayEnd, const vec3_t scale, int traceFlags, int useLod, float fRadius );
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
// CG specific API access
|
|
void trap_G2_ListModelSurfaces(void *ghlInfo);
|
|
void trap_G2_ListModelBones(void *ghlInfo, int frame);
|
|
void trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList);
|
|
qboolean trap_G2_HaveWeGhoul2Models(void *ghoul2);
|
|
qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
|
|
const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
|
|
qboolean trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
|
|
const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
|
|
qboolean trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
|
|
const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
|
|
int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
|
|
qhandle_t customShader, int modelFlags, int lodBias);
|
|
qboolean trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin);
|
|
|
|
int trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex);
|
|
void trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo);
|
|
void trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To);
|
|
qboolean trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex);
|
|
qboolean trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex);
|
|
|
|
qboolean trap_G2API_SkinlessModel(void *ghlInfo, int modelIndex);
|
|
|
|
//rww - for adding gore (or whatever) shaders to the g2 model
|
|
int trap_G2API_GetNumGoreMarks(void *ghlInfo, int modelIndex);
|
|
void trap_G2API_AddSkinGore(void *ghlInfo,SSkinGoreData *gore);
|
|
void trap_G2API_ClearSkinGore ( void* ghlInfo );
|
|
|
|
int trap_G2API_Ghoul2Size ( void* ghlInfo );
|
|
|
|
int trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
|
|
void trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo);
|
|
qboolean trap_G2API_AttachEnt(int *boltInfo, void *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum);
|
|
|
|
void trap_G2API_CleanGhoul2Models(void **ghoul2Ptr);
|
|
qboolean trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
|
|
const int up, const int right, const int forward, qhandle_t *modelList,
|
|
int blendTime , int currentTime );
|
|
void trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf);
|
|
qboolean trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
|
|
const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
|
|
qboolean trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame,
|
|
int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
|
|
qboolean trap_G2API_GetBoneFrame(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex);
|
|
|
|
qboolean trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName);
|
|
qboolean trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags);
|
|
qboolean trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex);
|
|
qboolean trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName);
|
|
int trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName);
|
|
|
|
int trap_G2API_GetTime(void);
|
|
void trap_G2API_SetTime(int time, int clock);
|
|
|
|
void trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status);
|
|
|
|
void trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
|
|
void trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);
|
|
|
|
//additional ragdoll options -rww
|
|
qboolean trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max); //override default pcj bonee constraints
|
|
qboolean trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed); //override the default gradient movespeed for a pcj bone
|
|
qboolean trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos); //override an effector bone's goal position (world coordinates)
|
|
qboolean trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale); //current position of said bone is put into pos (world coordinates)
|
|
qboolean trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity); //add velocity to a rag bone
|
|
qboolean trap_G2API_RagForceSolve(void *ghoul2, qboolean force); //make sure we are actively performing solve/settle routines, if desired
|
|
|
|
qboolean trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
|
|
qboolean trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);
|
|
|
|
//for removing bones so they no longer have their own seperate animation hierarchy. Or whatever reason you may have. -rww
|
|
qboolean trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex);
|
|
|
|
void trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server);
|
|
void trap_G2API_ClearAttachedInstance(int entityNum);
|
|
void trap_G2API_CleanEntAttachments(void);
|
|
qboolean trap_G2API_OverrideServer(void *serverInstance);
|
|
|
|
void trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf);
|
|
|
|
#include "../namespace_end.h"
|
|
|
|
void CG_Init_CG(void);
|
|
void CG_Init_CGents(void);
|
|
|
|
|
|
void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent);
|
|
void CG_CreateBBRefEnts(entityState_t *s1, vec3_t origin );
|
|
|
|
void CG_InitG2Weapons(void);
|
|
void CG_ShutDownG2Weapons(void);
|
|
void CG_CopyG2WeaponInstance(centity_t *cent, int weaponNum, void *toGhoul2);
|
|
void *CG_G2WeaponInstance(centity_t *cent, int weapon);
|
|
void CG_CheckPlayerG2Weapons(playerState_t *ps, centity_t *cent);
|
|
|
|
void CG_SetSiegeTimerCvar( int msec );
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|