/* cl_chase.c chase camera support Copyright (C) 1996-1997 Id Software, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #ifdef HAVE_STRING_H # include #endif #ifdef HAVE_STRINGS_H # include #endif #include "QF/cvar.h" #include "QF/keys.h" #include "QF/input.h" #include "QF/mathlib.h" #include "QF/plugin/vid_render.h" #include "QF/scene/transform.h" #include "world.h" #include "client/chase.h" #include "client/input.h" #include "client/view.h" float chase_back; static cvar_t chase_back_cvar = { .name = "chase_back", .description = "None", .default_value = "100", .flags = CVAR_NONE, .value = { .type = &cexpr_float, .value = &chase_back }, }; float chase_up; static cvar_t chase_up_cvar = { .name = "chase_up", .description = "None", .default_value = "16", .flags = CVAR_NONE, .value = { .type = &cexpr_float, .value = &chase_up }, }; float chase_right; static cvar_t chase_right_cvar = { .name = "chase_right", .description = "None", .default_value = "0", .flags = CVAR_NONE, .value = { .type = &cexpr_float, .value = &chase_right }, }; int chase_active; static cvar_t chase_active_cvar = { .name = "chase_active", .description = "None", .default_value = "0", .flags = CVAR_NONE, .value = { .type = &cexpr_int, .value = &chase_active }, }; void Chase_Init_Cvars (void) { Cvar_Register (&chase_back_cvar, 0, 0); Cvar_Register (&chase_up_cvar, 0, 0); Cvar_Register (&chase_right_cvar, 0, 0); Cvar_Register (&chase_active_cvar, 0, 0); } void Chase_Reset (void) { // for respawning and teleporting // start position 12 units behind head } static inline vec4f_t TraceLine (chasestate_t *cs, vec4f_t start, vec4f_t end) { trace_t trace; memset (&trace, 0, sizeof (trace)); trace.fraction = 1; MOD_TraceLine (cs->worldmodel->brush.hulls, 0, (vec_t*)&start, (vec_t*)&end, &trace);//FIXME return (vec4f_t) {trace.endpos[0], trace.endpos[1], trace.endpos[2], 1}; } static void check_for_walls (chasestate_t *cs, vec4f_t forward) { // check for walls between player and camera cs->camera_origin += 8 * forward; vec4f_t stop = TraceLine (cs, cs->player_origin, cs->camera_origin); if (magnitude3f (stop)[0] != 0) { cs->camera_origin = stop - forward; } } static void limit_distance (chasestate_t *cs) { // don't let camera get too far from player vec4f_t dir = cs->camera_origin - cs->player_origin; vec4f_t forward = normalf (dir); if (magnitudef (dir)[0] > chase_back) { cs->camera_origin = cs->player_origin + forward * chase_back; } } static void set_camera (chasestate_t *cs, viewstate_t *vs) { vec4f_t rotation; AngleQuat (cs->camera_angles, (vec_t*)&rotation);//FIXME Transform_SetWorldRotation (vs->camera_transform, rotation); Transform_SetWorldPosition (vs->camera_transform, cs->camera_origin); } static void cam_controls (chasestate_t *cs, viewstate_t *vs) { // FIXME this doesn't actually control the camera, but rather makes the // player face the direction of motion. It probably should not access // movement input buttons and axes directly. // get basic movement from keyboard vec4f_t move = { }; vec4f_t forward = { }; vec4f_t right = { }; vec4f_t up = { }; vec4f_t dir = { }; if (in_strafe.state & 1) { move[SIDE] += cl_sidespeed * IN_ButtonState (&in_right); move[SIDE] -= cl_sidespeed * IN_ButtonState (&in_left); } move[SIDE] += cl_sidespeed * IN_ButtonState (&in_moveright); move[SIDE] -= cl_sidespeed * IN_ButtonState (&in_moveleft); if (!(in_klook.state & 1)) { move[FORWARD] += cl_forwardspeed * IN_ButtonState (&in_forward); move[FORWARD] -= cl_backspeed * IN_ButtonState (&in_back); } if (in_speed.state & 1) { move *= cl_movespeedkey; } // mouse and joystick controllers add to movement VectorSet (0, vs->player_angles[1] - cs->camera_angles[1], 0, dir); AngleVectors ((vec_t*)&dir, (vec_t*)&forward, (vec_t*)&right, (vec_t*)&up); //FIXME forward *= IN_UpdateAxis (&in_cam_forward) * m_forward; right *= IN_UpdateAxis (&in_cam_side) * m_side; dir = forward + right; move[FORWARD] += dir[0]; move[SIDE] -= dir[1]; VectorSet (0, cs->camera_angles[1], 0, dir); AngleVectors ((vec_t*)&dir, (vec_t*)&forward, (vec_t*)&right, (vec_t*)&up); //FIXME dir = forward * move[FORWARD] + right * move[SIDE]; if (dir[1] || dir[0]) { vs->player_angles[YAW] = (atan2 (dir[1], dir[0]) * 180 / M_PI); } //vs->player_angles[PITCH] = 0; VectorCopy (vs->player_angles, cs->player_angles); } static void update_cam_frame (chasestate_t *cs, viewstate_t *vs) { vec3_t d; VectorSubtract (vs->player_angles, cs->player_angles, d); VectorAdd (cs->camera_angles, d, cs->camera_angles); // remember the new angle to calculate the difference next frame VectorCopy (vs->player_angles, cs->player_angles); } static void chase_mode_1 (chasestate_t *cs) { // regular camera, faces same direction as player viewstate_t *vs = cs->viewstate; vec4f_t forward = {}, up = {}, right = {}, stop = {}; AngleVectors (vs->player_angles, (vec_t*)&forward, (vec_t*)&right, (vec_t*)&up);//FIXME VectorCopy (vs->player_angles, cs->camera_angles); // calc exact destination cs->camera_origin = vs->player_origin - forward * chase_back - right * chase_right; // chase_up is world up cs->camera_origin[2] += chase_up; // check for walls between player and camera stop = TraceLine (cs, vs->player_origin, cs->camera_origin); if (magnitude3f (stop)[0] != 0) { cs->camera_origin = stop + forward * 8; } set_camera (cs, vs); } static void chase_mode_2 (chasestate_t *cs) { viewstate_t *vs = cs->viewstate; vec4f_t forward = {}, up = {}, right = {}, dir = {}; // lazy camera, look toward player entity update_cam_frame (cs, vs); cs->camera_angles[PITCH] = bound (-60, cs->camera_angles[PITCH], 60); // move camera, it's not enough to just change the angles because // the angles are automatically changed to look toward the player AngleVectors (cs->camera_angles, (vec_t*)&forward, (vec_t*)&right, (vec_t*)&up);//FIXME cs->camera_origin = cs->player_origin - chase_back * forward; cs->player_origin = vs->player_origin; // don't let camera get too low if (cs->camera_origin[2] < cs->player_origin[2] + chase_up) { cs->camera_origin[2] = cs->player_origin[2] + chase_up; } limit_distance (cs); check_for_walls (cs, forward); dir = vs->player_origin - cs->camera_origin; if (dir[1] == 0 && dir[0] == 0) { // look straight up or down cs->camera_angles[YAW] = vs->player_angles[YAW]; if (dir[2] > 0) cs->camera_angles[PITCH] = 90; else cs->camera_angles[PITCH] = -90; } else { float pitch, yaw, fwd; yaw = (atan2 (dir[1], dir[0]) * 180 / M_PI); cs->camera_angles[YAW] = yaw; fwd = sqrt (dir[0] * dir[0] + dir[1] * dir[1]); pitch = -(atan2 (dir[2], fwd) * 180 / M_PI); cs->camera_angles[PITCH] = pitch; } set_camera (cs, vs); cam_controls (cs, vs); } static void chase_mode_3 (chasestate_t *cs) { viewstate_t *vs = cs->viewstate; vec4f_t forward = {}, up = {}, right = {}; // lazy camera, look toward player entity update_cam_frame (cs, vs); // move camera, it's not enough to just change the angles because // the angles are automatically changed to look toward the player cs->player_origin = vs->player_origin; AngleVectors (cs->camera_angles, (vec_t*)&forward, (vec_t*)&right, (vec_t*)&up);//FIXME cs->camera_origin = cs->player_origin - chase_back * forward; limit_distance (cs); check_for_walls (cs, forward); set_camera (cs, vs); cam_controls (cs, vs); } void Chase_Update (chasestate_t *cs) { switch (chase_active) { case 1: chase_mode_1 (cs); return; case 2: chase_mode_2 (cs); return; case 3: chase_mode_3 (cs); return; } }