#include "vkpt.h"
#include "../../client/client.h"

Functions
void	vkpt_freecam_reset ()

static void	vkpt_freecam_mousemove ()

void	vkpt_freecam_update (float frame_time)

qboolean	R_InterceptKey_RTX (unsigned key, qboolean down)

Variables
static vec3_t	freecam_vieworg = { 0.f }

static vec3_t	freecam_viewangles = { 0.f }

static float	freecam_zoom = 1.f

static qboolean	freecam_keystate [6] = { 0 }

static qboolean	freecam_active = qfalse

static int	freecam_player_model = 0

float	autosens_x

float	autosens_y

cvar_t *	m_accel

cvar_t *	m_autosens

cvar_t *	m_pitch

cvar_t *	m_invert

cvar_t *	m_yaw

cvar_t *	sensitivity

cvar_t *	cvar_pt_dof

cvar_t *	cvar_pt_aperture

cvar_t *	cvar_pt_focus

cvar_t *	cvar_pt_freecam

Function Documentation

◆ R_InterceptKey_RTX()

qboolean R_InterceptKey_RTX	(	unsigned	key,
		qboolean	down
	)

Definition at line 185 of file freecam.c.

 {
     if (cl_paused->integer != 2 || !sv_paused->integer)
         return qfalse;
  
     const char* kb = Key_GetBindingForKey(key);
     if (kb && strstr(kb, "pause"))
         return qfalse;
  
     if (cvar_pt_dof->integer != 0 && down && (key == K_MWHEELUP || key == K_MWHEELDOWN))
     {
         cvar_t* var;
         float minvalue;
         float maxvalue;
  
         if (Key_IsDown(K_SHIFT))
         {
             var = cvar_pt_aperture;
             minvalue = 0.01f;
             maxvalue = 10.f;
         }
         else
         {
             var = cvar_pt_focus;
             minvalue = 1.f;
             maxvalue = 10000.f;
         }
  
         float factor = Key_IsDown(K_CTRL) ? 1.01f : 1.1f;
  
         if (key == K_MWHEELDOWN)
             factor = 1.f / factor;
  
         float value = var->value;
         value *= factor;
         value = max(minvalue, min(maxvalue, value));
         Cvar_SetByVar(var, va("%f", value), FROM_CONSOLE);
  
         return qtrue;
     }
  
     switch (key)
     {
     case 'w': freecam_keystate[0] = down; return qtrue;
     case 's': freecam_keystate[1] = down; return qtrue;
     case 'd': freecam_keystate[2] = down; return qtrue;
     case 'a': freecam_keystate[3] = down; return qtrue;
     case 'e': freecam_keystate[4] = down; return qtrue;
     case 'q': freecam_keystate[5] = down; return qtrue;
  
     // make sure that other keys that control the freecam mode don't
     // interfere with the game, for example MOUSE1 usually maps to fire
     case K_CTRL:
     case K_SHIFT:
     case K_MWHEELDOWN:
     case K_MWHEELUP:
     case K_MOUSE1:
     case K_MOUSE2:
         return qtrue;
     }
  
     return qfalse;
 }

Referenced by R_RegisterFunctionsRTX().

◆ vkpt_freecam_mousemove()

static void vkpt_freecam_mousemove ( )

static

Definition at line 64 of file freecam.c.

 {
     int dx, dy;
     float mx, my;
     float speed;
  
     const inputAPI_t* api = IN_GetAPI();
  
     if (!api->GetMotion)
         return;
  
     if (!api->GetMotion(&dx, &dy))
         return;
  
     mx = dx;
     my = dy;
  
     if (!mx && !my) {
         return;
     }
  
     if (Key_IsDown(K_MOUSE1) && Key_IsDown(K_MOUSE2))
     {
         mx *= sensitivity->value;
         freecam_viewangles[ROLL] += m_yaw->value * mx;
     }
     else if (Key_IsDown(K_MOUSE1))
     {
         Cvar_ClampValue(m_accel, 0, 1);
  
         speed = sqrt(mx * mx + my * my);
         speed = sensitivity->value + speed * m_accel->value;
  
         mx *= speed;
         my *= speed;
  
         if (m_autosens->integer) {
             mx *= cl.fov_x * autosens_x;
             my *= cl.fov_y * autosens_y;
         }
  
         mx /= freecam_zoom;
         my /= freecam_zoom;
  
         freecam_viewangles[YAW] -= m_yaw->value * mx;
         freecam_viewangles[PITCH] += m_pitch->value * my * (m_invert->integer ? -1.f : 1.f);
  
         freecam_viewangles[PITCH] = max(-90.f, min(90.f, freecam_viewangles[PITCH]));
     }
     else if (Key_IsDown(K_MOUSE2))
     {
         freecam_zoom *= powf(0.5f, my * m_pitch->value * 0.1f);
         freecam_zoom = max(0.5f, min(20.f, freecam_zoom));
     }
 }

Referenced by vkpt_freecam_update().

◆ vkpt_freecam_reset()

void vkpt_freecam_reset ( )

Definition at line 55 of file freecam.c.

 {
     if (!freecam_active)
         return;
  
     Cvar_SetByVar(cl_player_model, va("%d", freecam_player_model), FROM_CODE);
     freecam_active = qfalse;
 }

Referenced by R_Shutdown_RTX(), and vkpt_freecam_update().

◆ vkpt_freecam_update()

void vkpt_freecam_update ( float frame_time )

Definition at line 120 of file freecam.c.

 {
     if (cl_paused->integer != 2 || !sv_paused->integer || !cvar_pt_freecam->integer)
     {
         vkpt_freecam_reset();
         return;
     }
  
     if (!freecam_active)
     {
         VectorCopy(vkpt_refdef.fd->vieworg, freecam_vieworg);
         VectorCopy(vkpt_refdef.fd->viewangles, freecam_viewangles);
         freecam_zoom = 1.f;
         freecam_player_model = cl_player_model->integer;
         freecam_active = qtrue;
     }
  
     vec3_t prev_vieworg;
     vec3_t prev_viewangles;
     VectorCopy(freecam_vieworg, prev_vieworg);
     VectorCopy(freecam_viewangles, prev_viewangles);
     float prev_zoom = freecam_zoom;
  
     vec3_t velocity = { 0.f };
     if (freecam_keystate[0]) velocity[0] += 1.f;
     if (freecam_keystate[1]) velocity[0] -= 1.f;
     if (freecam_keystate[2]) velocity[1] += 1.f;
     if (freecam_keystate[3]) velocity[1] -= 1.f;
     if (freecam_keystate[4]) velocity[2] += 1.f;
     if (freecam_keystate[5]) velocity[2] -= 1.f;
  
     if (Key_IsDown(K_SHIFT))
         VectorScale(velocity, 5.f, velocity);
     else if (Key_IsDown(K_CTRL))
         VectorScale(velocity, 0.1f, velocity);
  
     vec3_t forward, right, up;
     AngleVectors(freecam_viewangles, forward, right, up);
     float speed = 100.f;
     VectorMA(freecam_vieworg, velocity[0] * frame_time * speed, forward, freecam_vieworg);
     VectorMA(freecam_vieworg, velocity[1] * frame_time * speed, right, freecam_vieworg);
     VectorMA(freecam_vieworg, velocity[2] * frame_time * speed, up, freecam_vieworg);
  
     vkpt_freecam_mousemove();
  
     VectorCopy(freecam_vieworg, vkpt_refdef.fd->vieworg);
     VectorCopy(freecam_viewangles, vkpt_refdef.fd->viewangles);
     vkpt_refdef.fd->fov_x = RAD2DEG(atanf(tanf(DEG2RAD(vkpt_refdef.fd->fov_x) * 0.5f) / freecam_zoom)) * 2.f;
     vkpt_refdef.fd->fov_y = RAD2DEG(atanf(tanf(DEG2RAD(vkpt_refdef.fd->fov_y) * 0.5f) / freecam_zoom)) * 2.f;
  
     if (!VectorCompare(freecam_vieworg, prev_vieworg) || !VectorCompare(freecam_viewangles, prev_viewangles))
     {
         if (freecam_player_model != CL_PLAYER_MODEL_DISABLED && cl_player_model->integer != CL_PLAYER_MODEL_THIRD_PERSON)
             Cvar_SetByVar(cl_player_model, va("%d", CL_PLAYER_MODEL_THIRD_PERSON), FROM_CODE);
  
         vkpt_reset_accumulation();
     }
  
     if (freecam_zoom != prev_zoom)
     {
         // zoom doesn't reset the player model, but does reset the accumulation
         vkpt_reset_accumulation();
     }
 }