some renderer/client separation cleanup, migrated some things to r_refdef to eliminat...
[divverent/darkplaces.git] / view.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // view.c -- player eye positioning
21
22 #include "quakedef.h"
23 #include "cl_collision.h"
24
25 /*
26
27 The view is allowed to move slightly from it's true position for bobbing,
28 but if it exceeds 8 pixels linear distance (spherical, not box), the list of
29 entities sent from the server may not include everything in the pvs, especially
30 when crossing a water boudnary.
31
32 */
33
34 cvar_t  cl_rollspeed = {0, "cl_rollspeed", "200"};
35 cvar_t  cl_rollangle = {0, "cl_rollangle", "2.0"};
36
37 cvar_t  cl_bob = {0, "cl_bob","0.02"};
38 cvar_t  cl_bobcycle = {0, "cl_bobcycle","0.6"};
39 cvar_t  cl_bobup = {0, "cl_bobup","0.5"};
40
41 cvar_t  v_kicktime = {0, "v_kicktime", "0.5"};
42 cvar_t  v_kickroll = {0, "v_kickroll", "0.6"};
43 cvar_t  v_kickpitch = {0, "v_kickpitch", "0.6"};
44
45 cvar_t  v_iyaw_cycle = {0, "v_iyaw_cycle", "2"};
46 cvar_t  v_iroll_cycle = {0, "v_iroll_cycle", "0.5"};
47 cvar_t  v_ipitch_cycle = {0, "v_ipitch_cycle", "1"};
48 cvar_t  v_iyaw_level = {0, "v_iyaw_level", "0.3"};
49 cvar_t  v_iroll_level = {0, "v_iroll_level", "0.1"};
50 cvar_t  v_ipitch_level = {0, "v_ipitch_level", "0.3"};
51
52 cvar_t  v_idlescale = {0, "v_idlescale", "0"};
53
54 cvar_t  crosshair = {CVAR_SAVE, "crosshair", "0"};
55
56 cvar_t  v_centermove = {0, "v_centermove", "0.15"};
57 cvar_t  v_centerspeed = {0, "v_centerspeed","500"};
58
59 cvar_t cl_stairsmoothspeed = {CVAR_SAVE, "cl_stairsmoothspeed", "160"};
60
61 cvar_t chase_back = {CVAR_SAVE, "chase_back", "48"};
62 cvar_t chase_up = {CVAR_SAVE, "chase_up", "24"};
63 cvar_t chase_active = {CVAR_SAVE, "chase_active", "0"};
64 // GAME_GOODVSBAD2
65 cvar_t chase_stevie = {0, "chase_stevie", "0"};
66
67 float   v_dmg_time, v_dmg_roll, v_dmg_pitch;
68
69
70 /*
71 ===============
72 V_CalcRoll
73
74 Used by view and sv_user
75 ===============
76 */
77 float V_CalcRoll (vec3_t angles, vec3_t velocity)
78 {
79         vec3_t  right;
80         float   sign;
81         float   side;
82         float   value;
83
84         AngleVectors (angles, NULL, right, NULL);
85         side = DotProduct (velocity, right);
86         sign = side < 0 ? -1 : 1;
87         side = fabs(side);
88
89         value = cl_rollangle.value;
90
91         if (side < cl_rollspeed.value)
92                 side = side * value / cl_rollspeed.value;
93         else
94                 side = value;
95
96         return side*sign;
97
98 }
99
100 void V_StartPitchDrift (void)
101 {
102         if (cl.laststop == cl.time)
103                 return;         // something else is keeping it from drifting
104
105         if (cl.nodrift || !cl.pitchvel)
106         {
107                 cl.pitchvel = v_centerspeed.value;
108                 cl.nodrift = false;
109                 cl.driftmove = 0;
110         }
111 }
112
113 void V_StopPitchDrift (void)
114 {
115         cl.laststop = cl.time;
116         cl.nodrift = true;
117         cl.pitchvel = 0;
118 }
119
120 /*
121 ===============
122 V_DriftPitch
123
124 Moves the client pitch angle towards cl.idealpitch sent by the server.
125
126 If the user is adjusting pitch manually, either with lookup/lookdown,
127 mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.
128
129 Drifting is enabled when the center view key is hit, mlook is released and
130 lookspring is non 0, or when
131 ===============
132 */
133 void V_DriftPitch (void)
134 {
135         float           delta, move;
136
137         if (noclip_anglehack || !cl.onground || cls.demoplayback )
138         {
139                 cl.driftmove = 0;
140                 cl.pitchvel = 0;
141                 return;
142         }
143
144 // don't count small mouse motion
145         if (cl.nodrift)
146         {
147                 if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed.value)
148                         cl.driftmove = 0;
149                 else
150                         cl.driftmove += cl.frametime;
151
152                 if ( cl.driftmove > v_centermove.value)
153                 {
154                         V_StartPitchDrift ();
155                 }
156                 return;
157         }
158
159         delta = cl.idealpitch - cl.viewangles[PITCH];
160
161         if (!delta)
162         {
163                 cl.pitchvel = 0;
164                 return;
165         }
166
167         move = cl.frametime * cl.pitchvel;
168         cl.pitchvel += cl.frametime * v_centerspeed.value;
169
170         if (delta > 0)
171         {
172                 if (move > delta)
173                 {
174                         cl.pitchvel = 0;
175                         move = delta;
176                 }
177                 cl.viewangles[PITCH] += move;
178         }
179         else if (delta < 0)
180         {
181                 if (move > -delta)
182                 {
183                         cl.pitchvel = 0;
184                         move = -delta;
185                 }
186                 cl.viewangles[PITCH] -= move;
187         }
188 }
189
190
191 /*
192 ==============================================================================
193
194                                                 SCREEN FLASHES
195
196 ==============================================================================
197 */
198
199
200 /*
201 ===============
202 V_ParseDamage
203 ===============
204 */
205 void V_ParseDamage (void)
206 {
207         int armor, blood;
208         vec3_t from;
209         //vec3_t forward, right;
210         vec3_t localfrom;
211         entity_t *ent;
212         //float side;
213         float count;
214
215         armor = MSG_ReadByte ();
216         blood = MSG_ReadByte ();
217         MSG_ReadVector(from, cl.protocol);
218
219         count = blood*0.5 + armor*0.5;
220         if (count < 10)
221                 count = 10;
222
223         cl.faceanimtime = cl.time + 0.2;                // put sbar face into pain frame
224
225         cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
226         if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
227                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
228         if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
229                 cl.cshifts[CSHIFT_DAMAGE].percent = 150;
230
231         if (armor > blood)
232         {
233                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
234                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
235                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
236         }
237         else if (armor)
238         {
239                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
240                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
241                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
242         }
243         else
244         {
245                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
246                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
247                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
248         }
249
250         // calculate view angle kicks
251         if (cl.viewentity >= 0 && cl.viewentity < MAX_EDICTS && cl_entities[cl.viewentity].state_current.active)
252         {
253                 ent = &cl_entities[cl.viewentity];
254                 Matrix4x4_Transform(&ent->render.inversematrix, from, localfrom);
255                 VectorNormalize(localfrom);
256                 v_dmg_pitch = count * localfrom[0] * v_kickpitch.value;
257                 v_dmg_roll = count * localfrom[1] * v_kickroll.value;
258                 v_dmg_time = v_kicktime.value;
259         }
260 }
261
262 static cshift_t v_cshift;
263
264 /*
265 ==================
266 V_cshift_f
267 ==================
268 */
269 static void V_cshift_f (void)
270 {
271         v_cshift.destcolor[0] = atoi(Cmd_Argv(1));
272         v_cshift.destcolor[1] = atoi(Cmd_Argv(2));
273         v_cshift.destcolor[2] = atoi(Cmd_Argv(3));
274         v_cshift.percent = atoi(Cmd_Argv(4));
275 }
276
277
278 /*
279 ==================
280 V_BonusFlash_f
281
282 When you run over an item, the server sends this command
283 ==================
284 */
285 static void V_BonusFlash_f (void)
286 {
287         cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
288         cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
289         cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
290         cl.cshifts[CSHIFT_BONUS].percent = 50;
291 }
292
293 /*
294 ==============================================================================
295
296                                                 VIEW RENDERING
297
298 ==============================================================================
299 */
300
301 extern matrix4x4_t viewmodelmatrix;
302
303 #include "cl_collision.h"
304
305 /*
306 ==================
307 V_CalcRefdef
308
309 ==================
310 */
311 void V_CalcRefdef (void)
312 {
313         static float oldz;
314         entity_t *ent;
315         float vieworg[3], viewangles[3];
316         Matrix4x4_CreateIdentity(&viewmodelmatrix);
317         Matrix4x4_CreateIdentity(&r_refdef.viewentitymatrix);
318         if (cls.state == ca_connected && cls.signon == SIGNONS)
319         {
320                 // ent is the view entity (visible when out of body)
321                 ent = &cl_entities[cl.viewentity];
322                 if (cl.intermission)
323                 {
324                         // entity is a fixed camera, just copy the matrix
325                         Matrix4x4_Copy(&r_refdef.viewentitymatrix, &ent->render.matrix);
326                         Matrix4x4_Copy(&viewmodelmatrix, &ent->render.matrix);
327                 }
328                 else
329                 {
330                         // player can look around, so take the origin from the entity,
331                         // and the angles from the input system
332                         Matrix4x4_OriginFromMatrix(&ent->render.matrix, vieworg);
333                         VectorCopy(cl.viewangles, viewangles);
334
335                         // stair smoothing
336                         //Con_Printf("cl.onground %i oldz %f newz %f\n", cl.onground, oldz, vieworg[2]);
337                         if (cl.onground && oldz < vieworg[2])
338                         {
339                                 oldz += (cl.time - cl.oldtime) * cl_stairsmoothspeed.value;
340                                 oldz = vieworg[2] = bound(vieworg[2] - 16, oldz, vieworg[2]);
341                         }
342                         else if (cl.onground && oldz > vieworg[2])
343                         {
344                                 oldz -= (cl.time - cl.oldtime) * cl_stairsmoothspeed.value;
345                                 oldz = vieworg[2] = bound(vieworg[2], oldz, vieworg[2] + 16);
346                         }
347                         else
348                                 oldz = vieworg[2];
349
350                         if (chase_active.value)
351                         {
352                                 // observing entity from third person
353                                 vec_t camback, camup, dist, forward[3], stop[3], chase_dest[3], normal[3];
354
355                                 camback = bound(0, chase_back.value, 128);
356                                 if (chase_back.value != camback)
357                                         Cvar_SetValueQuick(&chase_back, camback);
358                                 camup = bound(-48, chase_up.value, 96);
359                                 if (chase_up.value != camup)
360                                         Cvar_SetValueQuick(&chase_up, camup);
361
362                                 // this + 22 is to match view_ofs for compatibility with older versions
363                                 camup += 22;
364
365                                 if (gamemode == GAME_GOODVSBAD2 && chase_stevie.integer)
366                                 {
367                                         // look straight down from high above
368                                         viewangles[0] = 90;
369                                         camback = 2048;
370                                 }
371                                 AngleVectors(viewangles, forward, NULL, NULL);
372
373                                 // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
374                                 dist = -camback - 8;
375                                 chase_dest[0] = vieworg[0] + forward[0] * dist;
376                                 chase_dest[1] = vieworg[1] + forward[1] * dist;
377                                 chase_dest[2] = vieworg[2] + forward[2] * dist + camup;
378                                 CL_TraceLine(vieworg, chase_dest, stop, normal, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY);
379                                 vieworg[0] = stop[0] + forward[0] * 8 + normal[0] * 4;
380                                 vieworg[1] = stop[1] + forward[1] * 8 + normal[1] * 4;
381                                 vieworg[2] = stop[2] + forward[2] * 8 + normal[2] * 4;
382                         }
383                         else
384                         {
385                                 // first person view from entity
386                                 // angles
387                                 if (cl.stats[STAT_HEALTH] <= 0 && gamemode != GAME_FNIGGIUM)
388                                         viewangles[ROLL] = 80;  // dead view angle
389                                 VectorAdd(viewangles, cl.punchangle, viewangles);
390                                 viewangles[ROLL] += V_CalcRoll(cl.viewangles, cl.velocity);
391                                 if (v_dmg_time > 0)
392                                 {
393                                         viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
394                                         viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
395                                         v_dmg_time -= cl.frametime;
396                                 }
397                                 // origin
398                                 VectorAdd(vieworg, cl.punchvector, vieworg);
399                                 vieworg[2] += cl.stats[STAT_VIEWHEIGHT];
400                                 if (cl.stats[STAT_HEALTH] > 0 && cl_bob.value && cl_bobcycle.value)
401                                 {
402                                         double bob, cycle;
403                                         // LordHavoc: this code is *weird*, but not replacable (I think it
404                                         // should be done in QC on the server, but oh well, quake is quake)
405                                         // LordHavoc: figured out bobup: the time at which the sin is at 180
406                                         // degrees (which allows lengthening or squishing the peak or valley)
407                                         cycle = cl.time / cl_bobcycle.value;
408                                         cycle -= (int) cycle;
409                                         if (cycle < cl_bobup.value)
410                                                 cycle = sin(M_PI * cycle / cl_bobup.value);
411                                         else
412                                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
413                                         // bob is proportional to velocity in the xy plane
414                                         // (don't count Z, or jumping messes it up)
415                                         bob = sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]) * cl_bob.value;
416                                         bob = bob*0.3 + bob*0.7*cycle;
417                                         vieworg[2] += bound(-7, bob, 4);
418                                 }
419                         }
420                         // calculate a view matrix for rendering the scene
421                         if (v_idlescale.value)
422                                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0] + v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value, viewangles[1] + v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value, viewangles[2] + v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value, 1);
423                         else
424                                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.viewentitymatrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2] + v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value, 1);
425                         // calculate a viewmodel matrix for use in view-attached entities
426                         Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2], 0.3);
427                 }
428         }
429 }
430
431 void V_FadeViewFlashs(void)
432 {
433         // drop the damage value
434         cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*150;
435         if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
436                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
437         // drop the bonus value
438         cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*100;
439         if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
440                 cl.cshifts[CSHIFT_BONUS].percent = 0;
441 }
442
443 void V_CalcViewBlend(void)
444 {
445         float a2;
446         int j;
447         r_refdef.viewblend[0] = 0;
448         r_refdef.viewblend[1] = 0;
449         r_refdef.viewblend[2] = 0;
450         r_refdef.viewblend[3] = 0;
451         r_refdef.fovscale_x = cl.viewzoom;
452         r_refdef.fovscale_y = cl.viewzoom;
453         if (cls.state == ca_connected && cls.signon == SIGNONS && gl_polyblend.value > 0)
454         {
455                 // set contents color
456                 int supercontents;
457                 vec3_t vieworigin;
458                 Matrix4x4_OriginFromMatrix(&r_refdef.viewentitymatrix, vieworigin);
459                 supercontents = CL_PointSuperContents(vieworigin);
460                 if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
461                 {
462                         r_refdef.fovscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
463                         r_refdef.fovscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
464                         if (supercontents & SUPERCONTENTS_LAVA)
465                         {
466                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
467                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
468                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
469                         }
470                         else if (supercontents & SUPERCONTENTS_SLIME)
471                         {
472                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
473                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
474                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
475                         }
476                         else
477                         {
478                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
479                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
480                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
481                         }
482                         cl.cshifts[CSHIFT_CONTENTS].percent = 150 >> 1;
483                 }
484                 else
485                 {
486                         cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
487                         cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
488                         cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
489                         cl.cshifts[CSHIFT_CONTENTS].percent = 0;
490                 }
491
492                 if (gamemode != GAME_TRANSFUSION)
493                 {
494                         if (cl.stats[STAT_ITEMS] & IT_QUAD)
495                         {
496                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
497                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
498                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
499                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
500                         }
501                         else if (cl.stats[STAT_ITEMS] & IT_SUIT)
502                         {
503                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
504                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
505                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
506                                 cl.cshifts[CSHIFT_POWERUP].percent = 20;
507                         }
508                         else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
509                         {
510                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
511                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
512                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
513                                 cl.cshifts[CSHIFT_POWERUP].percent = 100;
514                         }
515                         else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
516                         {
517                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
518                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
519                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
520                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
521                         }
522                         else
523                                 cl.cshifts[CSHIFT_POWERUP].percent = 0;
524                 }
525
526                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
527                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
528                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
529                 cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
530
531                 // LordHavoc: fixed V_CalcBlend
532                 for (j = 0;j < NUM_CSHIFTS;j++)
533                 {
534                         a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
535                         if (a2 > 0)
536                         {
537                                 VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
538                                 r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply...  took a while to find it on the web
539                         }
540                 }
541                 // saturate color (to avoid blending in black)
542                 if (r_refdef.viewblend[3])
543                 {
544                         a2 = 1 / r_refdef.viewblend[3];
545                         VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
546                 }
547
548                 r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0] * (1.0f/255.0f), 1.0f);
549                 r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1] * (1.0f/255.0f), 1.0f);
550                 r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2] * (1.0f/255.0f), 1.0f);
551                 r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
552         }
553 }
554
555 //============================================================================
556
557 /*
558 =============
559 V_Init
560 =============
561 */
562 void V_Init (void)
563 {
564         Cmd_AddCommand ("v_cshift", V_cshift_f);
565         Cmd_AddCommand ("bf", V_BonusFlash_f);
566         Cmd_AddCommand ("centerview", V_StartPitchDrift);
567
568         Cvar_RegisterVariable (&v_centermove);
569         Cvar_RegisterVariable (&v_centerspeed);
570
571         Cvar_RegisterVariable (&v_iyaw_cycle);
572         Cvar_RegisterVariable (&v_iroll_cycle);
573         Cvar_RegisterVariable (&v_ipitch_cycle);
574         Cvar_RegisterVariable (&v_iyaw_level);
575         Cvar_RegisterVariable (&v_iroll_level);
576         Cvar_RegisterVariable (&v_ipitch_level);
577
578         Cvar_RegisterVariable (&v_idlescale);
579         Cvar_RegisterVariable (&crosshair);
580
581         Cvar_RegisterVariable (&cl_rollspeed);
582         Cvar_RegisterVariable (&cl_rollangle);
583         Cvar_RegisterVariable (&cl_bob);
584         Cvar_RegisterVariable (&cl_bobcycle);
585         Cvar_RegisterVariable (&cl_bobup);
586
587         Cvar_RegisterVariable (&v_kicktime);
588         Cvar_RegisterVariable (&v_kickroll);
589         Cvar_RegisterVariable (&v_kickpitch);
590
591         Cvar_RegisterVariable (&cl_stairsmoothspeed);
592
593         Cvar_RegisterVariable (&chase_back);
594         Cvar_RegisterVariable (&chase_up);
595         Cvar_RegisterVariable (&chase_active);
596         if (gamemode == GAME_GOODVSBAD2)
597                 Cvar_RegisterVariable (&chase_stevie);
598 }
599