1 /*
2 cl_chase.c
3
4 chase camera support
5
6 Copyright (C) 1996-1997 Id Software, Inc.
7
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2
11 of the License, or (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16
17 See the GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to:
21
22 Free Software Foundation, Inc.
23 59 Temple Place - Suite 330
24 Boston, MA 02111-1307, USA
25
26 */
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #ifdef HAVE_STRING_H
32 # include <string.h>
33 #endif
34 #ifdef HAVE_STRINGS_H
35 # include <strings.h>
36 #endif
37
38 #include "QF/cvar.h"
39 #include "QF/keys.h"
40 #include "QF/input.h"
41 #include "QF/mathlib.h"
42
43 #include "QF/plugin/vid_render.h"
44
45 #include "chase.h"
46 #include "cl_input.h"
47 #include "client.h"
48 #include "world.h"
49
50 vec3_t camera_origin = {0,0,0};
51 vec3_t camera_angles = {0,0,0};
52 vec3_t player_origin = {0,0,0};
53 vec3_t player_angles = {0,0,0};
54
55 vec3_t chase_angles;
56 vec3_t chase_dest;
57 vec3_t chase_dest_angles;
58 vec3_t chase_pos;
59
60 cvar_t *chase_back;
61 cvar_t *chase_up;
62 cvar_t *chase_right;
63 cvar_t *chase_active;
64
65
66 void
Chase_Init_Cvars(void)67 Chase_Init_Cvars (void)
68 {
69 chase_back = Cvar_Get ("chase_back", "100", CVAR_NONE, NULL, "None");
70 chase_up = Cvar_Get ("chase_up", "16", CVAR_NONE, NULL, "None");
71 chase_right = Cvar_Get ("chase_right", "0", CVAR_NONE, NULL, "None");
72 chase_active = Cvar_Get ("chase_active", "0", CVAR_NONE, NULL, "None");
73 }
74
75 void
Chase_Reset(void)76 Chase_Reset (void)
77 {
78 // for respawning and teleporting
79 // start position 12 units behind head
80 }
81
82 static inline void
TraceLine(vec3_t start,vec3_t end,vec3_t impact)83 TraceLine (vec3_t start, vec3_t end, vec3_t impact)
84 {
85 trace_t trace;
86
87 memset (&trace, 0, sizeof (trace));
88 trace.fraction = 1;
89 MOD_TraceLine (cl.worldmodel->hulls, 0, start, end, &trace);
90
91 VectorCopy (trace.endpos, impact);
92 }
93
94 void
Chase_Update(void)95 Chase_Update (void)
96 {
97 float pitch, yaw, fwd;
98 int i;
99 usercmd_t cmd; // movement direction
100 vec3_t forward, up, right, stop, dir;
101
102 // lazy camera, look toward player entity
103
104 if (chase_active->int_val == 2 || chase_active->int_val == 3) {
105 // control camera angles with key/mouse/joy-look
106
107 camera_angles[PITCH] += cl.viewangles[PITCH] - player_angles[PITCH];
108 camera_angles[YAW] += cl.viewangles[YAW] - player_angles[YAW];
109 camera_angles[ROLL] += cl.viewangles[ROLL] - player_angles[ROLL];
110
111 if (chase_active->int_val == 2) {
112 if (camera_angles[PITCH] < -60)
113 camera_angles[PITCH] = -60;
114 if (camera_angles[PITCH] > 60)
115 camera_angles[PITCH] = 60;
116 }
117
118 // move camera, it's not enough to just change the angles because
119 // the angles are automatically changed to look toward the player
120
121 if (chase_active->int_val == 3)
122 VectorCopy (r_data->refdef->vieworg, player_origin);
123
124 AngleVectors (camera_angles, forward, right, up);
125 VectorScale (forward, chase_back->value, forward);
126 VectorSubtract (player_origin, forward, camera_origin);
127
128 if (chase_active->int_val == 2) {
129 VectorCopy (r_data->refdef->vieworg, player_origin);
130
131 // don't let camera get too low
132 if (camera_origin[2] < player_origin[2] + chase_up->value)
133 camera_origin[2] = player_origin[2] + chase_up->value;
134 }
135
136 // don't let camera get too far from player
137
138 VectorSubtract (camera_origin, player_origin, dir);
139 VectorCopy (dir, forward);
140 VectorNormalize (forward);
141
142 if (VectorLength (dir) > chase_back->value) {
143 VectorScale (forward, chase_back->value, dir);
144 VectorAdd (player_origin, dir, camera_origin);
145 }
146
147 // check for walls between player and camera
148
149 VectorScale (forward, 8, forward);
150 VectorAdd (camera_origin, forward, camera_origin);
151 TraceLine (player_origin, camera_origin, stop);
152 if (VectorLength (stop) != 0)
153 VectorSubtract (stop, forward, camera_origin);
154
155 VectorSubtract (camera_origin, r_data->refdef->vieworg, dir);
156 VectorCopy (dir, forward);
157 VectorNormalize (forward);
158
159 if (chase_active->int_val == 2) {
160 if (dir[1] == 0 && dir[0] == 0) {
161 // look straight up or down
162 // camera_angles[YAW] = r_data->refdef->viewangles[YAW];
163 if (dir[2] > 0)
164 camera_angles[PITCH] = 90;
165 else
166 camera_angles[PITCH] = 270;
167 } else {
168 yaw = (atan2 (dir[1], dir[0]) * 180 / M_PI);
169 if (yaw < 0)
170 yaw += 360;
171 if (yaw < 180)
172 yaw += 180;
173 else
174 yaw -= 180;
175 camera_angles[YAW] = yaw;
176
177 fwd = sqrt (dir[0] * dir[0] + dir[1] * dir[1]);
178 pitch = (atan2 (dir[2], fwd) * 180 / M_PI);
179 if (pitch < 0)
180 pitch += 360;
181 camera_angles[PITCH] = pitch;
182 }
183 }
184
185 VectorCopy (camera_angles, r_data->refdef->viewangles);// rotate camera
186 VectorCopy (camera_origin, r_data->refdef->vieworg); // move camera
187
188 // get basic movement from keyboard
189
190 memset (&cmd, 0, sizeof (cmd));
191 // VectorCopy (cl.viewangles, cmd.angles);
192
193 if (in_strafe.state & 1) {
194 cmd.sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
195 cmd.sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
196 }
197 cmd.sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
198 cmd.sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
199
200 if (!(in_klook.state & 1)) {
201 cmd.forwardmove += cl_forwardspeed->value
202 * CL_KeyState (&in_forward);
203 cmd.forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
204 }
205 if (in_speed.state & 1) {
206 cmd.forwardmove *= cl_movespeedkey->value;
207 cmd.sidemove *= cl_movespeedkey->value;
208 }
209
210 // mouse and joystick controllers add to movement
211 VectorSet (0, cl.viewangles[1] - camera_angles[1], 0, dir);
212 AngleVectors (dir, forward, right, up);
213 VectorScale (forward, viewdelta.position[2] * m_forward->value,
214 forward);
215 VectorScale (right, viewdelta.position[0] * m_side->value, right);
216 VectorAdd (forward, right, dir);
217 cmd.forwardmove += dir[0];
218 cmd.sidemove -= dir[1];
219
220 VectorSet (0, camera_angles[1], 0, dir);
221 AngleVectors (dir, forward, right, up);
222
223 VectorScale (forward, cmd.forwardmove, forward);
224 VectorScale (right, cmd.sidemove, right);
225 VectorAdd (forward, right, dir);
226
227 if (dir[1] || dir[0]) {
228 cl.viewangles[YAW] = (atan2 (dir[1], dir[0]) * 180 / M_PI);
229 if (cl.viewangles[YAW] < 0) cl.viewangles[YAW] += 360;
230 // if (cl.viewangles[YAW] < 180)
231 // cl.viewangles[YAW] += 180;
232 // else
233 // cl.viewangles[YAW] -= 180;
234 }
235
236 cl.viewangles[PITCH] = 0;
237
238 // remember the new angle to calculate the difference next frame
239 VectorCopy (cl.viewangles, player_angles);
240
241 return;
242 }
243
244 // regular camera, faces same direction as player
245
246 AngleVectors (cl.viewangles, forward, right, up);
247
248 // calc exact destination
249 for (i = 0; i < 3; i++)
250 camera_origin[i] = r_data->refdef->vieworg[i]
251 - forward[i] * chase_back->value - right[i] * chase_right->value;
252 camera_origin[2] += chase_up->value;
253
254 // check for walls between player and camera
255 TraceLine (r_data->refdef->vieworg, camera_origin, stop);
256 if (VectorLength (stop) != 0)
257 for (i = 0; i < 3; i++)
258 camera_origin[i] = stop[i] + forward[i] * 8;
259
260 VectorCopy (camera_origin, r_data->refdef->vieworg);
261 }
262