OpenMoHAA 0.82.0
Loading...
Searching...
No Matches
cg_local.h
1/*
2===========================================================================
3Copyright (C) 2023 the OpenMoHAA team
4
5This file is part of OpenMoHAA source code.
6
7OpenMoHAA source code is free software; you can redistribute it
8and/or modify it under the terms of the GNU General Public License as
9published by the Free Software Foundation; either version 2 of the License,
10or (at your option) any later version.
11
12OpenMoHAA source code is distributed in the hope that it will be
13useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with OpenMoHAA source code; if not, write to the Free Software
19Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20===========================================================================
21*/
22
23// DESCRIPTION:
24// The entire cgame module is unloaded and reloaded on each level change,
25// so there is NO persistant data between levels on the client side.
26// If you absolutely need something stored, it can either be kept
27// by the server in the server stored userinfos, or stashed in a cvar.
28
29#pragma once
30
31#include "q_shared.h"
32#include "tr_types.h"
33#include "../fgame/bg_public.h"
34#include "cm_public.h"
35#include "cg_public.h"
36
37#ifdef __cplusplus
38class MemArchiver;
39
40extern "C" {
41#endif
42
43 typedef struct {
44 int anim;
45 int frame;
46 int oldanim;
47 int oldframe;
48 int starttime;
49 float framelerp;
50 } lerpstate_t;
51
52 typedef struct {
53 lerpstate_t base;
54
55 // crossblend variables
56 lerpstate_t crossblend;
57 int crossblend_totaltime;
58 float crossblend_lerp;
59
60 // global variables
61 int numframes;
62 int time_per_frame;
63 qboolean driven;
64
65 // non-driven variables
66 int next_evaluate_time;
67
68 // driven variables
69 int last_driven_time;
70 vec3_t last_origin;
71 vec3_t frame_delta; // normalized frame delta
72 float frame_distance; // float distance till next frame
73 float current_distance; // current distance traveled
74
75 // command variables
76 qboolean has_commands;
77 int last_cmd_frame;
78 int last_cmd_anim;
79 int last_cmd_time;
80 } animstate_t;
81
82 //=================================================
83
84#define CF_UPDATESWIPE 0x0000001
85#define CF_COMMANDS_PROCESSED 0x0000002
86
87 // centity_t have a direct corespondence with gentity_t in the game, but
88 // not all of the gentity_t will be communicated to the client
89 typedef struct centity_s {
90 entityState_t currentState; // from cg.frame
91 entityState_t nextState; // from cg.nextFrame, if available
92 qboolean teleported; // true if the entity was just teleported
93 qboolean interpolate; // true if next is valid to interpolate to
94 qboolean currentValid; // true if cg.frame holds this entity
95
96 int miscTime;
97 int snapShotTime;
98
99 int errorTime; // decay the error from this time
100 vec3_t errorOrigin;
101 vec3_t errorAngles;
102
103 qboolean extrapolated; // false if origin / angles is an interpolation
104 vec3_t rawOrigin;
105 vec3_t rawAngles;
106
107 vec3_t beamEnd;
108
109 // exact interpolated position of entity on this frame
110 vec3_t lerpOrigin;
111 vec3_t lerpAngles;
112
113 sfxHandle_t tikiLoopSound;
114 float tikiLoopSoundVolume;
115 float tikiLoopSoundMinDist;
116 float tikiLoopSoundMaxDist;
117 float tikiLoopSoundPitch;
118 int tikiLoopSoundFlags;
119
120 float color[4];
121 float client_color[4]; // the color set by client commands
122 int clientFlags;
123
124 int splash_last_spawn_time;
125 int splash_still_count;
126
127 quat_t bone_quat[NUM_BONE_CONTROLLERS];
128 float animLastTimes[MAX_FRAMEINFOS];
129 int animLast[MAX_FRAMEINFOS];
130 int animLastWeight;
131 int usageIndexLast;
132 qboolean bFootOnGround_Right;
133 qboolean bFootOnGround_Left;
134 int iNextLandTime;
135 } centity_t;
136
137 //======================================================================
138
139 // local entities are created as a result of events or predicted actions,
140 // and live independantly from all server transmitted entities
141
142#define MAX_VERTS_ON_POLY 8
143#define MAX_MARK_POLYS 64
144#define MAX_TREAD_MARKS 16
145
146 typedef struct markPoly_s {
147 struct markPoly_s* nextPoly;
148 int numVerts;
149 polyVert_t verts[MAX_VERTS_ON_POLY];
150 int iIndex;
151 } markPoly_t;
152
153 typedef struct markObj_s {
154 struct markObj_s* prevMark;
155 struct markObj_s* nextMark;
156 int time;
157 int lastVisTime;
158 int leafnum;
159 vec3_t pos;
160 float radius;
161 int markShader;
162 int alphaFade;
163 int fadein;
164 markPoly_t* markPolys;
165 } markObj_t;
166
167#define MAX_CUSTOM_SOUNDS 32
168
169 typedef struct {
170 int team;
171 char name[64];
172 } clientInfo_t;
173
174 typedef struct cobjective_s {
175 char text[MAX_STRING_CHARS];
176 int flags;
177 } cobjective_t;
178
179#define MAX_RAIN_SHADERS 16
180
181 typedef struct crain_s {
182 float density;
183 float speed;
184 int speed_vary;
185 int slant;
186 float length;
187 float min_dist;
188 float width;
189 char shader[MAX_RAIN_SHADERS][MAX_STRING_CHARS];
190 char currentShader[MAX_STRING_CHARS];
191 int numshaders;
192 } crain_t;
193
194 //======================================================================
195
196 // all cg.stepTime, cg.duckTime, cg.landTime, etc are set to cg.time when the action
197 // occurs, and they will have visible effects for #define STEP_TIME or whatever msec after
198
199 typedef struct {
200 int clientFrame; // incremented each frame
201 int clientNum;
202
203 qboolean demoPlayback;
204 qboolean levelShot; // taking a level menu screenshot
205
206 // there are only one or two snapshot_t that are relevent at a time
207 int latestSnapshotNum; // the number of snapshots the client system has received
208 int latestSnapshotTime; // the time from latestSnapshotNum, so we don't need to read the snapshot yet
209 snapshot_t *snap; // cg.snap->serverTime <= cg.time
210 snapshot_t *nextSnap; // cg.nextSnap->serverTime > cg.time, or NULL
211 snapshot_t activeSnapshots[2];
212
213 float
214 frameInterpolation; // (float)( cg.time - cg.frame->serverTime ) / (cg.nextFrame->serverTime - cg.frame->serverTime)
215
216 qboolean thisFrameTeleport;
217 qboolean nextFrameTeleport;
218 qboolean nextFrameCameraCut;
219
220 int frametime; // cg.time - cg.oldTime
221
222 int time; // this is the time value that the client
223 // is rendering at.
224
225 int physicsTime; // either cg.snap->time or cg.nextSnap->time
226
227 qboolean renderingThirdPerson; // during deaths, chasecams, etc
228
229 // prediction state
230 qboolean hyperspace; // true if prediction has hit a trigger_teleport
231 playerState_t predicted_player_state;
232 qboolean validPPS; // clear until the first call to CG_PredictPlayerState
233 int predictedErrorTime;
234 vec3_t predictedError;
235
236 // input state sent to server
237 int iWeaponCommand;
238 int iWeaponCommandSend;
239
240 // auto rotating items
241 vec3_t autoAngles;
242 vec3_t autoAxis[3];
243 vec3_t autoAnglesSlow;
244 vec3_t autoAxisSlow[3];
245 vec3_t autoAnglesFast;
246 vec3_t autoAxisFast[3];
247
248 // view rendering
249 refdef_t refdef;
250 vec3_t playerHeadPos; // position of the players head
251 vec3_t refdefViewAngles; // will be converted to refdef.viewaxis
252 vec3_t currentViewPos; // current position of the camera
253 vec3_t currentViewAngles; // current angles of the camera
254
255 float fRefFovXSin;
256 float fRefFovXCos;
257 float fRefFovYSin;
258 float fRefFovYCos;
259 float fCurrentViewHeight;
260 float fCurrentViewBobPhase;
261 float fCurrentViewBobAmp;
262
263 // player model
264 dtiki_t *pLastPlayerWorldModel;
265 dtiki_t *pPlayerFPSModel;
266 qhandle_t hPlayerFPSModelHandle;
267 qboolean bFPSModelLastFrame;
268 qboolean bFPSOnGround;
269 dtiki_t *pAlliedPlayerModel;
270 qhandle_t hAlliedPlayerModelHandle;
271 dtiki_t *pAxisPlayerModel;
272 qhandle_t hAxisPlayerModelHandle;
273 qboolean serverAlliedModelValid;
274 qboolean serverAxisModelValid;
275
276 // view eyes
277 vec3_t vOffsetViewAngles;
278 vec3_t vLastHeadAngles;
279 vec3_t vLastViewAngles;
280 vec3_t vEyeOffsetMax;
281 float fEyeOffsetFrac;
282
283 float SoundOrg[3]; // position from where sound should be played
284 vec3_t SoundAxis[3]; // axis from where sound should be played
285
286 vec3_t camera_origin; // lerped camera_origin
287 vec3_t camera_angles; // lerped camera_angles
288 float camera_fov; // lerped camera_fov
289
290 // zoom key
291 float zoomSensitivity;
292
293 // information screen text during loading
294 qboolean bIntermissionDisplay;
295
296 // scoreboard
297 int scoresRequestTime;
298 qboolean showScores;
299 char scoresMenuName[MAX_STRING_TOKENS];
300 int iInstaMessageMenu;
301
302 // centerprinting
303 int centerPrintTime;
304 int centerPrintCharWidth;
305 int centerPrintY;
306 char centerPrint[1024];
307 int centerPrintLines;
308
309 // gameplay
310 int matchStartTime;
311
312 // development tool
313 refEntity_t testModelEntity;
314 char testModelName[MAX_QPATH];
315 qboolean testGun;
316
317 // farplane parameters
318 float farplane_distance;
319 float farplane_bias;
320 vec3_t farplane_color;
321 qboolean farplane_cull;
322 float skyboxFarplane;
323 qboolean renderTerrain;
324 float farclipOverride;
325 vec3_t farplaneColorOverride;
326
327 // portal sky parameters
328 qboolean sky_portal;
329 float sky_alpha;
330 vec3_t sky_origin;
331 vec3_t sky_axis[3]; // rotation vectors
332 float skyboxSpeed;
333
334 // weapon viewkick recoil
335 float viewkick[2];
336 float viewkickRecenter;
337 float viewkickMinDecay;
338 float viewkickMaxDecay;
339
340 // objectives
341 cobjective_t Objectives[20];
342 float ObjectivesAlphaTime;
343 float ObjectivesBaseAlpha;
344 float ObjectivesDesiredAlpha;
345 float ObjectivesCurrentAlpha;
346 int ObjectivesCurrentIndex;
347
348 // misc
349 crain_t rain;
350 clientInfo_t clientinfo[MAX_CLIENTS];
351 radarClient_t radars[MAX_CLIENTS];
352 qhandle_t radarShaders[2];
353 } cg_t;
354
355 typedef struct {
356 qhandle_t backTileShader;
357 qhandle_t lagometerShader;
358 qhandle_t shadowMarkShader;
359 qhandle_t footShadowMarkShader;
360 qhandle_t wakeMarkShader;
361 qhandle_t pausedShader;
362 qhandle_t levelExitShader;
363 qhandle_t zoomOverlayShader;
364 qhandle_t kar98TopOverlayShader;
365 qhandle_t kar98BottomOverlayShader;
366 qhandle_t binocularsOverlayShader;
367 fontheader_t *hudDrawFont;
368 fontheader_t *attackerFont;
369 fontheader_t *objectiveFont;
370 qhandle_t objectivesBackShader;
371 qhandle_t checkedBoxShader;
372 qhandle_t uncheckedBoxShader;
373 } media_t;
374
375 // The client game static (cgs) structure hold everything
376 // loaded or calculated from the gamestate. It will NOT
377 // be cleared when a tournement restart is done, allowing
378 // all clients to begin playing instantly
379 typedef struct {
380 gameState_t gameState; // gamestate from server
381 glconfig_t glconfig; // rendering configuration
382 float screenXScale; // derived from glconfig
383 float screenYScale;
384 float screenXBias;
385 vec2_t uiHiResScale;
386
387 int serverCommandSequence; // reliable command stream counter
388 int processedSnapshotNum; // the number of snapshots cgame has requested
389
390 qboolean localServer; // detected on startup by checking sv_running
391 int levelStartTime; // time that game was started
392
393 // parsed from serverinfo
394 int matchEndTime;
395 int serverLagTime;
396 gametype_t gametype;
397 int dmflags;
398 int teamflags;
399 int fraglimit;
400 int timelimit;
401 int maxclients;
402 int cinematic;
403 int mapChecksum;
404 qboolean useMapChecksum;
405 char mapname[MAX_QPATH];
406
407 //
408 // vote
409 //
410 int voteTime;
411 int numVotesYes;
412 int numVotesNo;
413 int numUndecidedVotes;
414 qboolean voteRefreshed;
415 char voteString[1024];
416
417 //
418 // locally derived information from gamestate
419 //
420 qhandle_t model_draw[MAX_MODELS];
421 sfxHandle_t sound_precache[MAX_SOUNDS];
422 int numInlineModels;
423 qhandle_t inlineDrawModel[MAX_MODELS];
424 vec3_t inlineModelMidpoints[MAX_MODELS];
425
426 media_t media;
427 } cgs_t;
428
429 //==============================================================================
430
431 extern cvar_t *paused;
432 extern cvar_t *developer;
433
434 extern cgs_t cgs;
435 extern cg_t cg;
436 extern clientGameImport_t cgi;
437 extern target_game_e cg_target_game;
438 extern int cg_protocol;
439 extern centity_t cg_entities[MAX_GENTITIES];
440 extern markPoly_t *cg_markPolys;
441
442 extern cvar_t *cg_animSpeed;
443 extern cvar_t *cg_debugAnim;
444 extern cvar_t *cg_debugAnimWatch;
445 extern cvar_t *cg_errorDecay;
446 extern cvar_t *cg_nopredict;
447 extern cvar_t *cg_showmiss;
448 extern cvar_t *cg_addMarks;
449 extern cvar_t *cg_maxMarks;
450 extern cvar_t *cg_viewsize;
451 extern cvar_t *cg_3rd_person;
452 extern cvar_t *cg_drawviewmodel;
453 extern cvar_t *cg_synchronousClients;
454 extern cvar_t *cg_stereoSeparation;
455 extern cvar_t *cg_stats;
456 extern cvar_t *cg_lagometer;
457 extern cvar_t *r_lerpmodels;
458 extern cvar_t *cg_cameraheight;
459 extern cvar_t *cg_cameradist;
460 extern cvar_t *cg_cameraverticaldisplacement;
461 extern cvar_t *cg_camerascale;
462 extern cvar_t *cg_shadows;
463 extern cvar_t *cg_hidetempmodels;
464 extern cvar_t *cg_traceinfo;
465 extern cvar_t *cg_debugFootsteps;
466 extern cvar_t *cg_smoothClients;
467 extern cvar_t *cg_smoothClientsTime;
468 extern cvar_t *pmove_fixed;
469 extern cvar_t *pmove_msec;
470 extern cvar_t *cg_pmove_msec;
471 extern cvar_t *dm_playermodel;
472 extern cvar_t *dm_playergermanmodel;
473 extern cvar_t *cg_forceModel;
474 extern cvar_t *cg_animationviewmodel;
475 extern cvar_t *cg_hitmessages;
476 extern cvar_t *cg_acidtrip;
477 extern cvar_t *cg_hud;
478 extern cvar_t *cg_huddraw_force;
479 extern cvar_t *cg_drawsvlag;
480 extern cvar_t *cg_crosshair;
481 extern cvar_t *cg_crosshair_friend;
482 extern cvar_t *ui_crosshair;
483 extern cvar_t *vm_offset_max;
484 extern cvar_t *vm_offset_speed;
485 extern cvar_t *vm_sway_front;
486 extern cvar_t *vm_sway_side;
487 extern cvar_t *vm_sway_up;
488 extern cvar_t *vm_offset_air_front;
489 extern cvar_t *vm_offset_air_side;
490 extern cvar_t *vm_offset_air_up;
491 extern cvar_t *vm_offset_crouch_front;
492 extern cvar_t *vm_offset_crouch_side;
493 extern cvar_t *vm_offset_crouch_up;
494 extern cvar_t *vm_offset_rocketcrouch_front;
495 extern cvar_t *vm_offset_rocketcrouch_side;
496 extern cvar_t *vm_offset_rocketcrouch_up;
497 extern cvar_t *vm_offset_shotguncrouch_front;
498 extern cvar_t *vm_offset_shotguncrouch_side;
499 extern cvar_t *vm_offset_shotguncrouch_up;
500 extern cvar_t *vm_offset_vel_base;
501 extern cvar_t *vm_offset_vel_front;
502 extern cvar_t *vm_offset_vel_side;
503 extern cvar_t *vm_offset_vel_up;
504 extern cvar_t *vm_offset_upvel;
505 extern cvar_t *vm_lean_lower;
506 extern cvar_t *voiceChat;
507 extern cvar_t *cg_shadowscount;
508 extern cvar_t *cg_shadowdebug;
509 extern cvar_t *ui_timemessage;
510
511 //
512 // Added in OPM
513 //
514 extern cvar_t *cg_fov;
515 extern cvar_t *cg_cheats;
516
517 //
518 // cg_main.c
519 //
520 qboolean CG_UseLargeLightmaps(const char* mapName);
521 void CG_ProcessConfigString(int num, qboolean modelOnly);
522 const char *CG_ConfigString(int index);
523 void CG_AddToTeamChat(const char *str);
524 void CG_NewClientinfo(int clientNum);
525 sfxHandle_t CG_CustomSound(int entityNum, const char *soundName);
526 int CG_CrosshairPlayer(void);
527 int CG_LastAttacker(void);
528 void CG_Init(clientGameImport_t *imported, int serverMessageNum, int serverCommandSequence, int clientNum);
529 void CG_Shutdown(void);
530 void CG_ServerRestarted(void);
531 void CG_ParseFogInfo(const char *str);
532
533 //
534 // cg_modelanim.cpp
535 //
536 void CG_ProcessPlayerModel();
537 void CG_ServerModelLoaded(const char* name, qhandle_t handle);
538 void CG_ServerModelUnloaded(qhandle_t handle);
539 void CG_ModelAnim(centity_t *cent, qboolean bDoShaderTime);
540 void CG_AttachEntity(
541 refEntity_t *entity, refEntity_t *parent, dtiki_t *tiki, int tagnum, qboolean use_angles, vec3_t attach_offset
542 );
543
544 //
545 // cg_commands.cpp
546 //
547 void CG_Event(centity_t *cent);
548 void CG_UpdateEntityEmitters(int entnum, refEntity_t *ent, centity_t *cent);
549 void CG_RemoveClientEntity(int number, dtiki_t *tiki, centity_t *cent);
550 void CG_UpdateTestEmitter(void);
551 void CG_InitializeCommandManager(void);
552 void CG_ProcessInitCommands(dtiki_t *tiki, refEntity_t *ent);
553 void CG_ProcessCacheInitCommands(dtiki_t *tiki);
554 void CG_EndTiki(dtiki_t *tiki);
555 qboolean CG_Command_ProcessFile(const char *filename, qboolean quiet, dtiki_t *curTiki);
556 void CG_RestartCommandManager();
557 void CG_CleanUpTempModels();
558 qboolean CG_ProcessEntityCommands(int frame, int anim, int entnum, refEntity_t *ent, centity_t *cent);
559 void CG_ClientCommands(refEntity_t *ent, centity_t *cent, int slot);
560 float RandomizeRange(float start, float end);
561
562 //
563 // cg_tempmodels.cpp
564 //
565 extern cvar_t *cg_showtempmodels;
566 extern cvar_t *cg_max_tempmodels;
567 extern cvar_t *cg_reserve_tempmodels;
568 extern cvar_t *cg_detail;
569 extern cvar_t *cg_effectdetail;
570 extern cvar_t *cg_effect_physicsrate;
571
572 void CG_AddTempModels(void);
573 void CG_ResetTempModels(void);
574
575 void CG_Splash(centity_t *cent);
576
577 void CG_EventList_f(void);
578 void CG_EventHelp_f(void);
579 void CG_DumpEventHelp_f(void);
580 void CG_PendingEvents_f(void);
581 void CG_ClassList_f(void);
582 void CG_ClassTree_f(void);
583 void CG_ClassEvents_f(void);
584 void CG_DumpClassEvents_f(void);
585 void CG_DumpAllClasses_f(void);
586
587 void L_InitEvents(void);
588 void L_ShutdownEvents(void);
589
590 //
591 // cg_view.c
592 //
593 void CG_TestModel_f(void);
594 void CG_TestGun_f(void);
595 void CG_TestModelNextFrame_f(void);
596 void CG_TestModelPrevFrame_f(void);
597 void CG_TestModelNextSkin_f(void);
598 void CG_TestModelPrevSkin_f(void);
599
600 void CG_ZoomDown_f(void);
601 void CG_ZoomUp_f(void);
602
603 void CG_EyePosition(vec3_t *o_vPos);
604 void CG_EyeOffset(vec3_t *o_vOfs);
605 void CG_EyeAngles(vec3_t *o_vAngles);
606 float CG_SensitivityScale();
607 void CG_AddLightShow();
608 qboolean CG_FrustumCullSphere(const vec3_t vPos, float fRadius);
609 void CG_OffsetFirstPersonView(refEntity_t *pREnt, qboolean bUseWorldPosition);
610 void CG_DrawActiveFrame(int serverTime, int frameTime, stereoFrame_t stereoView, qboolean demoPlayback);
611
612 //
613 // cg_viewmodelanim.c
614 //
615 int CG_GetVMAnimPrefixIndex();
616 void CG_ViewModelAnimation(refEntity_t *pModel);
617 void CG_CalcViewModelMovement(float fViewBobPhase, float fViewBobAmp, vec_t *vVelocity, vec_t *vMovement);
618
619 //
620 // cg_drawtools.c
621 //
622 void CG_AdjustFrom640(float *x, float *y, float *w, float *h);
623 void CG_TileClear(void);
624 void CG_DrawOverlayTopBottom(qhandle_t handleTop, qhandle_t handleBottom, float fAlpha);
625 void CG_DrawOverlayMiddle(qhandle_t handle, float fAlpha);
626 void CG_DrawOverlayFullScreen(qhandle_t handle, float fAlpha);
627 void CG_DrawZoomOverlay();
628 void CG_HudDrawShader(int iInfo);
629 void CG_HudDrawFont(int iInfo);
630 void CG_RefreshHudDrawElements();
631 void CG_HudDrawElements();
632 void CG_InitializeObjectives();
633 void CG_DrawObjectives();
634 void CG_Draw2D(void);
635
636 //
637 // cg_draw.c
638 //
639 void CG_AddLagometerFrameInfo(void);
640 void CG_AddLagometerSnapshotInfo(snapshot_t *snap);
641 void CG_CenterPrint(const char *str, int y, int charWidth);
642 void CG_DrawHead(float x, float y, float w, float h, int clientNum, vec3_t headAngles);
643 void CG_DrawActive(stereoFrame_t stereoView);
644 void CG_DrawFlagModel(float x, float y, float w, float h, int team);
645
646 //
647 // cg_predict.c
648 //
649 void CG_BuildSolidList(void);
650 int CG_GetBrushEntitiesInBounds(int iMaxEnts, centity_t** pEntList, const vec3_t vMins, const vec3_t vMaxs);
651 int CG_PointContents(const vec3_t point, int passEntityNum);
652 void CG_ClipMoveToEntities(
653 const vec3_t start,
654 const vec3_t mins,
655 const vec3_t maxs,
656 const vec3_t end,
657 int skipNumber,
658 int mask,
659 trace_t *tr,
660 qboolean cylinder
661 );
662 void CG_Trace(
663 trace_t *result,
664 const vec3_t start,
665 const vec3_t mins,
666 const vec3_t maxs,
667 const vec3_t end,
668 int skipNumber,
669 int mask,
670 qboolean cylinder,
671 qboolean cliptoentities,
672 const char *description
673 );
674 void CG_PredictPlayerState(void);
675
676 //
677 // cg_ents.c
678 //
679 void BG_EvaluateTrajectory(const trajectory_t *tr, int atTime, const vec3_t base, vec3_t result);
680 void CG_SetEntitySoundPosition(centity_t *cent);
681 void CG_AddPacketEntities(void);
682 void CG_Beam(centity_t *cent);
683 void CG_AdjustPositionForMover(const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out);
684
685 void CG_PositionEntityOnTag(refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName);
686 void
687 CG_PositionRotatedEntityOnTag(refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName);
688 void CG_GetOrigin(centity_t *cent, vec3_t origin);
689 void CG_EntityEffects(centity_t *cent);
690
691 //
692 // cg_marks.c
693 //
694 void CG_InitMarks(void);
695 void CG_AddMarks(void);
696 void CG_ImpactMark(
697 qhandle_t markShader,
698 const vec3_t origin,
699 const vec3_t dir,
700 float orientation,
701 float fSScale,
702 float fTScale,
703 float red,
704 float green,
705 float blue,
706 float alpha,
707 qboolean alphaFade,
708 qboolean temporary,
709 qboolean dolighting,
710 qboolean fadein,
711 float fSCenter,
712 float fTCenter
713 );
714 void CG_ImpactMarkSimple(
715 qhandle_t markShader,
716 const vec3_t origin,
717 const vec3_t dir,
718 float orientation,
719 float fRadius,
720 float red,
721 float green,
722 float blue,
723 float alpha,
724 qboolean alphaFade,
725 qboolean temporary,
726 qboolean dolighting,
727 qboolean fadein
728 );
729 void CG_AssembleFinalMarks(
730 vec3_t *markPoints,
731 markFragment_t *markFragments,
732 int numFragments,
733 qboolean (*PerPolyCallback)(const vec3_t* markPoints, markFragment_t* mf, polyVert_t* verts, void* pCustom),
734 int (*GetLeafCallback)(markFragment_t* mf, void* pCustom),
735 void *pCustom,
736 vec3_t pos,
737 float radius,
738 qhandle_t markShader,
739 qboolean fadein,
740 qboolean alphaFade
741 );
742 qboolean CG_CheckMakeMarkOnEntity(int iEntIndex);
743 void CG_InitTestTreadMark();
744 void CG_AddTreadMarks();
745 int CG_PermanentMark(
746 vec3_t origin,
747 vec3_t dir,
748 float orientation,
749 float fSScale,
750 float fTScale,
751 float red,
752 float green,
753 float blue,
754 float alpha,
755 qboolean dolighting,
756 float fSCenter,
757 float fTCenter,
758 markFragment_t *pMarkFragments,
759 void *pVoidPolyVerts
760 );
761
762 int CG_PermanentTreadMarkDecal(
763 treadMark_t *pTread,
764 qboolean bStartSegment,
765 qboolean dolighting,
766 markFragment_t *pMarkFragments,
767 void *pVoidPolyVerts
768 );
769
770 int CG_PermanentUpdateTreadMark(
771 treadMark_t *pTread, float fAlpha, float fMinSegment, float fMaxSegment, float fMaxOffset, float fTexScale
772 );
773
774 //
775 // cg_snapshot.c
776 //
777 void CG_ProcessSnapshots(void);
778
779 //
780 // cg_consolecmds.c
781 //
782 qboolean CG_ConsoleCommand(void);
783 void CG_InitConsoleCommands(void);
784 void CG_AddTestModel(void);
785 void CG_Mapinfo_f();
786 void CG_PushMenuTeamSelect_f(void);
787 void CG_PushMenuWeaponSelect_f(void);
788 void CG_UseWeaponClass_f(void);
789 void CG_NextWeapon_f(void);
790 void CG_PrevWeapon_f(void);
791 void CG_UseLastWeapon_f(void);
792 void CG_HolsterWeapon_f(void);
793 void CG_DropWeapon_f(void);
794 void CG_ToggleItem_f(void);
795 int CG_WeaponCommandButtonBits(void);
796 void CG_ScoresDown_f(void);
797 void CG_ScoresUp_f(void);
798
799 //
800 // cg_servercmds.c
801 //
802 void CG_ExecuteNewServerCommands(int latestSequence, qboolean differentServer);
803 void CG_ParseServerinfo(void);
804
805 //
806 // cg_playerstate.c
807 //
808 void CG_TransitionPlayerState(playerState_t *ps, playerState_t *ops);
809
810 //
811 // cg_player.cpp
812 //
813 void CG_ResetPlayerEntity(centity_t *cent);
814 void CG_Player(centity_t *cent);
815
816 //
817 // cg_sound.cpp
818 //
819 void CG_ProcessSound(server_sound_t *sound);
820
821 //
822 // cg_beam.cpp
823 //
824 void CG_AddBeams(void);
825 void CG_MultiBeamBegin(void);
826 void CG_MultiBeamAddPoints(
827 vec3_t start, vec3_t end, int numsegments, int flags, float minoffset, float maxoffset, qboolean addstartpoint
828 );
829 void CG_MultiBeamEnd(
830 float scale, int renderfx, const char *beamshadername, byte modulate[4], int flags, int owner, float life
831 );
832 void CG_CreateBeam(
833 const vec3_t start,
834 const vec3_t dir,
835 int owner,
836 qhandle_t hModel,
837 float alpha,
838 float scale,
839 int flags,
840 float length,
841 int life,
842 qboolean create,
843 const vec3_t endpointvec,
844 int min_offset,
845 int max_offset,
846 int overlap,
847 int subdivisions,
848 int delay,
849 const char *beamshader,
850 float modulate[4],
851 int numspherebeams,
852 float sphereradius,
853 int toggledelay,
854 float endalpha,
855 int renderfx,
856 const char *name
857 );
858
859 void CG_KillBeams(int entity_number);
860 void CG_Rope(centity_t *cent);
861 void CG_RestartBeams(int timedelta);
862
863 //
864 // cg_nature.cpp
865 //
866 void CG_Emitter(centity_t *cent);
867 void CG_Rain(centity_t *cent);
868
869 //
870 // cg_testemitter.cpp
871 void CG_UpdateTestEmitter(void);
872 void CG_SortEffectCommands();
873 void CG_TriggerTestEmitter_f(void);
874 void CG_DumpEmitter_f(void);
875 void CG_LoadEmitter_f(void);
876 void CG_PrevEmitterCommand_f(void);
877 void CG_NextEmitterCommand_f(void);
878 void CG_NewEmitterCommand_f(void);
879 void CG_DeleteEmitterCommand_f(void);
880 void CG_InitTestEmitter(void);
881 void CG_TestEmitter_f(void);
882 void CG_DumpEmitter_f(void);
883
884 //
885 // cg_beam.cpp
886 void RemoveBeamList(int owner);
887 void CG_MultiBeam(centity_t *cent);
888
889 //
890 // cg_lightstyles.cpp
891 void CG_SetLightStyle(int num, const char *s);
892#ifdef __cplusplus
893 qboolean CG_LightStyleColor(int style, int realtime, vec4_t color, qboolean clamp = qfalse);
894#else
895qboolean CG_LightStyleColor(int style, int realtime, vec4_t color, qboolean clamp);
896#endif
897 void CG_ClearLightStyles(void);
898 int CG_RegisterLightStyle(const char *name);
899
900 //
901 // cg_scoreboard.cpp
902 void CG_GetScoreBoardColor(float *fR, float *fG, float *fB, float *fA);
903 void CG_GetScoreBoardFontColor(float *fR, float *fG, float *fB, float *fA);
904 void CG_GetScoreBoardPosition(float *fX, float *fY, float *fW, float *fH);
905 int CG_GetScoreBoardDrawHeader();
906 //const char* CG_GetColumnName(int iColumnNum, int* iColumnWidth);
907 void CG_PrepScoreBoardInfo();
908 void CG_ParseScores();
909 void CG_InitScoresAPI(clientGameExport_t *cge);
910
911 //
912 // cg_specialfx.cpp
913 void CG_Footstep(const char *szTagName, centity_t *ent, refEntity_t *pREnt, int iRunning, int iEquipment);
914 void CG_MeleeImpact(vec3_t vStart, vec3_t vEnd);
915 void CG_LandingSound(centity_t *ent, refEntity_t *pREnt, float volume, int iEquipment);
916 void CG_BodyFallSound(centity_t *ent, refEntity_t *pREnt, float volume);
917 void CG_InitializeSpecialEffectsManager();
918 void CG_AddPendingEffects();
919
920 //
921 // cg_swipe.cpp
922 void CG_ClearSwipes(void);
923
924 //
925 // cg_ui.cpp
926 void CG_MessageMode_f(void);
927 void CG_MessageMode_All_f(void);
928 void CG_MessageMode_Team_f(void);
929 void CG_MessageMode_Private_f(void);
930 void CG_MessageSingleAll_f(void);
931 void CG_MessageSingleTeam_f(void);
932 void CG_MessageSingleClient_f(void);
933 void CG_InstaMessageMain_f(void);
934 void CG_InstaMessageGroupA_f(void);
935 void CG_InstaMessageGroupB_f(void);
936 void CG_InstaMessageGroupC_f(void);
937 void CG_InstaMessageGroupD_f(void);
938 void CG_InstaMessageGroupE_f(void);
939 void CG_HudPrint_f(void);
940
941 qboolean CG_CheckCaptureKey(int key, qboolean down, unsigned int time);
942
943 //
944 // cg_vehicle.cpp
945 void CG_Vehicle(centity_t *cent);
946
947 //
948 // cg_volumetricsmoke.cpp
949 void CG_ResetVSSSources(void);
950#ifdef __cplusplus
951 void CG_ArchiveVSSGlobals(MemArchiver& archiver);
952#endif
953 void CG_AddVSSSources(void);
954
955 extern cvar_t *vss_draw;
956 extern cvar_t *vss_physics_fps;
957 extern cvar_t *vss_repulsion_fps;
958 extern cvar_t *vss_maxcount;
959 extern cvar_t *vss_color;
960 extern cvar_t *vss_showsources;
961 extern cvar_t *vss_wind_x;
962 extern cvar_t *vss_wind_y;
963 extern cvar_t *vss_wind_z;
964 extern cvar_t *vss_wind_strength;
965 extern cvar_t *vss_movement_dampen;
966 extern cvar_t *vss_maxvisible;
967 extern cvar_t *vss_gridsize;
968 extern cvar_t *vss_default_r;
969 extern cvar_t *vss_default_g;
970 extern cvar_t *vss_default_b;
971 extern cvar_t *vss_lighting_fps;
972
973#ifdef __cplusplus
974}
975#endif
MemArchiver
Definition memarchiver.h:36
str
Definition str.h:77
animstate_t
Definition cg_local.h:52
centity_s
Definition cg_local.h:89
cg_t
Definition cg_local.h:199
cgs_t
Definition cg_local.h:379
clientGameExport_t
Definition cg_public.h:455
clientGameImport_t
Definition cg_public.h:97
clientInfo_t
Definition cg_local.h:169
cobjective_s
Definition cg_local.h:174
crain_s
Definition cg_local.h:181
gameState_t
Definition q_shared.h:1693
glconfig_t
Definition tr_types.h:244
lerpstate_t
Definition cg_local.h:43
markFragment_t
Definition q_shared.h:1493
markObj_s
Definition cg_local.h:153
markPoly_s
Definition cg_local.h:146
media_t
Definition cg_local.h:355
polyVert_t
Definition tr_types.h:67
radarClient_t
Definition q_shared.h:2223
refEntity_t
Definition tr_types.h:95
refdef_t
Definition tr_types.h:162
snapshot_t
Definition cg_public.h:48
trace_t
Definition q_shared.h:1452
trajectory_t
Definition q_shared.h:1979