celisej567/HL2Overcharged
1
0
Fork 0
mirror of https://github.com/Gigaslav/HL2Overcharged.git synced 2026-01-01 09:48:38 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
develop
HL2Overcharged/game/shared/baseviewmodel_shared.cpp
Gigaslav 9a283535e7 Init comit
2025-05-21 21:20:08 +03:00

2070 lines
66 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "baseviewmodel_shared.h"
#include "datacache/imdlcache.h"
//#include "basecombatweapon_shared.h"
#include "in_buttons.h"//
#if defined( CLIENT_DLL )
#include "iprediction.h"
#include "prediction.h"
#include "client_virtualreality.h"
#include "sourcevr/isourcevirtualreality.h"
// cin: 070105 - ironsight mode changes
#include "convar.h"
#include "c_baseplayer.h"
#include "input.h"//
//#include "iinput.h"//
#include "view.h"
#include "c_cam_attachment.h"
#include "c_te_legacytempents.h"
#else
#include "vguiscreen.h"
#endif
#if defined( CLIENT_DLL ) && defined( SIXENSE )
#include "sixense/in_sixense.h"
#include "sixense/sixense_convars_extern.h"
#endif
#ifdef SIXENSE
extern ConVar in_forceuser;
#include "iclientmode.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define VIEWMODEL_ANIMATION_PARITY_BITS 3
#define SCREEN_OVERLAY_MATERIAL "vgui/screens/vgui_overlay"
#if defined( CLIENT_DLL )
ConVar oc_viewbob_move_speed("oc_viewbob_move_speed", "0.01", FCVAR_ARCHIVE);
void AdjustWpnTestOffset(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetScope(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetMove(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetWall(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetRT(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetRTIron(ConVar *pConVar, char *pszString);
void AdjustWpnTestOffsetIronSight(ConVar *pConVar, char *pszString);
ConVar oc_adjust_weapon_rtscope_offset("oc_adjust_weapon_rtscope_offset", "0", 0, "Tests weapon offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetRT));
ConVar oc_adjust_weapon_irrtscope_offset("oc_adjust_weapon_irrtscope_offset", "0", 0, "Tests weapon offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetRTIron));
ConVar oc_adjust_weapon_rtscope_offset_x("oc_adjust_weapon_rtscope_offset_x", "0");
ConVar oc_adjust_weapon_rtscope_offset_y("oc_adjust_weapon_rtscope_offset_y", "0");
ConVar oc_adjust_weapon_rtscope_offset_z("oc_adjust_weapon_rtscope_offset_z", "0");
ConVar oc_adjust_weapon_irrtscope_offset_x("oc_adjust_weapon_irrtscope_offset_x", "0");
ConVar oc_adjust_weapon_irrtscope_offset_y("oc_adjust_weapon_irrtscope_offset_y", "0");
ConVar oc_adjust_weapon_irrtscope_offset_z("oc_adjust_weapon_irrtscope_offset_z", "0");
ConVar oc_adjust_weapon_offset("oc_adjust_weapon_offset", "0", FCVAR_CHEAT, "Standart weapon offsets", ((FnChangeCallback_t)AdjustWpnTestOffset));
ConVar oc_adjust_weapon_offset_x("oc_adjust_weapon_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_offset_y("oc_adjust_weapon_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_offset_z("oc_adjust_weapon_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_offset_angle_x("oc_adjust_weapon_offset_angle_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_offset_angle_y("oc_adjust_weapon_offset_angle_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_offset_angle_z("oc_adjust_weapon_offset_angle_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset("oc_adjust_weapon_ironsight_offset", "0", FCVAR_CHEAT, "Tests weapon offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetIronSight));
ConVar oc_adjust_weapon_ironsight_offset_x("oc_adjust_weapon_ironsight_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset_y("oc_adjust_weapon_ironsight_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset_z("oc_adjust_weapon_ironsight_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset_angle_x("oc_adjust_weapon_ironsight_offset_angle_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset_angle_y("oc_adjust_weapon_ironsight_offset_angle_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_ironsight_offset_angle_z("oc_adjust_weapon_ironsight_offset_angle_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset("oc_adjust_weapon_scope_offset", "0", 0, "Tests weapon offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetScope));
ConVar oc_adjust_weapon_scope_offset_x("oc_adjust_weapon_scope_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset_y("oc_adjust_weapon_scope_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset_z("oc_adjust_weapon_scope_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset_angle_x("oc_adjust_weapon_scope_offset_angle_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset_angle_y("oc_adjust_weapon_scope_offset_angle_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_weapon_scope_offset_angle_z("oc_adjust_weapon_scope_offset_angle_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset("oc_adjust_wall_offset", "0", FCVAR_CHEAT, "Tests weapon wall offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetWall));
ConVar oc_adjust_wall_offset_x("oc_adjust_wall_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset_y("oc_adjust_wall_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset_z("oc_adjust_wall_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset_angle_x("oc_adjust_wall_offset_angle_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset_angle_y("oc_adjust_wall_offset_angle_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_offset_angle_z("oc_adjust_wall_offset_angle_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_wall_distance_to("oc_adjust_wall_distance_to", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset("oc_adjust_moveForward_offset", "0", 0, "Tests weapon run offsets", ((FnChangeCallback_t)AdjustWpnTestOffsetMove));
ConVar oc_adjust_moveForward_offset_x("oc_adjust_moveForward_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset_y("oc_adjust_moveForward_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset_z("oc_adjust_moveForward_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset_angle_x("oc_adjust_moveForward_offset_angle_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset_angle_y("oc_adjust_moveForward_offset_angle_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveForward_offset_angle_z("oc_adjust_moveForward_offset_angle_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_offset_x("oc_adjust_moveBackward_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_offset_y("oc_adjust_moveBackward_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_offset_z("oc_adjust_moveBackward_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_ori_offset_x("oc_adjust_moveBackward_ori_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_ori_offset_y("oc_adjust_moveBackward_ori_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveBackward_ori_offset_z("oc_adjust_moveBackward_ori_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_offset_x("oc_adjust_moveLeft_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_offset_y("oc_adjust_moveLeft_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_offset_z("oc_adjust_moveLeft_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_ori_offset_x("oc_adjust_moveLeft_ori_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_ori_offset_y("oc_adjust_moveLeft_ori_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveLeft_ori_offset_z("oc_adjust_moveLeft_ori_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_offset_x("oc_adjust_moveRight_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_offset_y("oc_adjust_moveRight_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_offset_z("oc_adjust_moveRight_offset_z", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_ori_offset_x("oc_adjust_moveRight_ori_offset_x", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_ori_offset_y("oc_adjust_moveRight_ori_offset_y", "0", FCVAR_CHEAT);
ConVar oc_adjust_moveRight_ori_offset_z("oc_adjust_moveRight_ori_offset_z", "0", FCVAR_CHEAT);
ConVar oc_viewmodel_lag_type("oc_viewmodel_lag_type", "0", FCVAR_ARCHIVE);
ConVar oc_viewmodel_bob_enable("oc_viewmodel_bob_enable", "0", FCVAR_ARCHIVE);
ConVar oc_viewmodel_movement_type("oc_viewmodel_movement_type", "0", FCVAR_ARCHIVE);
ConVar oc_viewmodel_move_fwd_bwd_change_speed_type0("oc_viewmodel_move_fwd_bwd_change_speed_type0", "0.051", FCVAR_ARCHIVE);
ConVar oc_viewmodel_move_fwd_bwd_change_speed_type1("oc_viewmodel_move_fwd_bwd_change_speed_type1", "0.0079", FCVAR_ARCHIVE);
ConVar oc_viewmodel_move_wall_change_speed("oc_viewmodel_move_wall_change_speed", "0.06255", FCVAR_ARCHIVE);
ConVar oc_viewmodel_ironsight_move_speed("oc_viewmodel_ironsight_move_speed", "0.08", FCVAR_ARCHIVE);
ConVar oc_viewmodel_secondfire_move_speed("oc_viewmodel_secondfire_move_speed", "0.5", FCVAR_ARCHIVE);
ConVar oc_viewmodel_move_wall_type("oc_viewmodel_move_wall_type", "1", FCVAR_ARCHIVE);
ConVar oc_viewmodel_lag_change_speed("oc_viewmodel_lag_change_speed", "1.5", FCVAR_ARCHIVE);
ConVar oc_viewmodel_dynamic_FOV("oc_viewmodel_dynamic_FOV", "0");
ConVar oc_viewmodel_dynamic_FOV_sighted("oc_viewmodel_dynamic_FOV_sighted", "0");
ConVar oc_viewmodel_dynamic_FOV_unsighted("oc_viewmodel_dynamic_FOV_unsighted", "0");
ConVar oc_weapon_free_aim_movemax_viewmodel_change_time("oc_weapon_free_aim_movemax_viewmodel_change_time", "1.02", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_koef("oc_weapon_free_aim_movemax_viewmodel_koef", "0.02", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_tracers_koef("oc_weapon_free_aim_movemax_viewmodel_tracers_koef", "0.06", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_y("oc_weapon_free_aim_movemax_viewmodel_y", "-0.23", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_x("oc_weapon_free_aim_movemax_viewmodel_x", "-0.23", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_tracers_y("oc_weapon_free_aim_movemax_viewmodel_tracers_y", "0.7", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_tracers_x("oc_weapon_free_aim_movemax_viewmodel_tracers_x", "0.3", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_movemax_viewmodel_tracers_fov("oc_weapon_free_aim_movemax_viewmodel_tracers_fov", "0.3", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_up_roll_range("oc_weapon_free_aim_up_roll_range", "0.7", FCVAR_ARCHIVE);
ConVar oc_weapon_free_aim_down_roll_range("oc_weapon_free_aim_down_roll_range", "0.3", FCVAR_ARCHIVE);
void AdjustWpnTestOffset(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
oc_adjust_wall_distance_to.SetValue(pWeapon->GetWpnData().DistanceToWall);
if (cvar->FindVar("oc_player_draw_body")->GetInt() && cvar->FindVar("oc_player_true_firstperson_vm")->GetInt())
{
oc_adjust_weapon_offset_x.SetValue(pWeapon->GetWpnData().m_expOffsetTP.x);
oc_adjust_weapon_offset_y.SetValue(pWeapon->GetWpnData().m_expOffsetTP.y);
oc_adjust_weapon_offset_z.SetValue(pWeapon->GetWpnData().m_expOffsetTP.z);
oc_adjust_weapon_offset_angle_x.SetValue(pWeapon->GetWpnData().m_expOriOffsetTP.x);
oc_adjust_weapon_offset_angle_y.SetValue(pWeapon->GetWpnData().m_expOriOffsetTP.y);
oc_adjust_weapon_offset_angle_z.SetValue(pWeapon->GetWpnData().m_expOriOffsetTP.z);
}
else
{
oc_adjust_weapon_offset_x.SetValue(pWeapon->GetWpnData().m_expOffset.x);
oc_adjust_weapon_offset_y.SetValue(pWeapon->GetWpnData().m_expOffset.y);
oc_adjust_weapon_offset_z.SetValue(pWeapon->GetWpnData().m_expOffset.z);
oc_adjust_weapon_offset_angle_x.SetValue(pWeapon->GetWpnData().m_expOriOffset.x);
oc_adjust_weapon_offset_angle_y.SetValue(pWeapon->GetWpnData().m_expOriOffset.y);
oc_adjust_weapon_offset_angle_z.SetValue(pWeapon->GetWpnData().m_expOriOffset.z);
}
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
oc_adjust_weapon_ironsight_offset_x.SetValue(pWeapon->GetWpnData().m_expOffset2.x);
oc_adjust_weapon_ironsight_offset_y.SetValue(pWeapon->GetWpnData().m_expOffset2.y);
oc_adjust_weapon_ironsight_offset_z.SetValue(pWeapon->GetWpnData().m_expOffset2.z);
oc_adjust_weapon_ironsight_offset_angle_x.SetValue(pWeapon->GetWpnData().m_expOriOffset2.x);
oc_adjust_weapon_ironsight_offset_angle_y.SetValue(pWeapon->GetWpnData().m_expOriOffset2.y);
oc_adjust_weapon_ironsight_offset_angle_z.SetValue(pWeapon->GetWpnData().m_expOriOffset2.z);
oc_adjust_wall_offset_x.SetValue(pWeapon->GetWpnData().PositionWall.x);
oc_adjust_wall_offset_y.SetValue(pWeapon->GetWpnData().PositionWall.y);
oc_adjust_wall_offset_z.SetValue(pWeapon->GetWpnData().PositionWall.z);
oc_adjust_wall_offset_angle_x.SetValue(pWeapon->GetWpnData().AngleWall.x);
oc_adjust_wall_offset_angle_y.SetValue(pWeapon->GetWpnData().AngleWall.y);
oc_adjust_wall_offset_angle_z.SetValue(pWeapon->GetWpnData().AngleWall.z);
}
}
}
void AdjustWpnTestOffsetIronSight(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
oc_adjust_weapon_ironsight_offset_x.SetValue(pWeapon->GetWpnData().m_expOffset2.x);
oc_adjust_weapon_ironsight_offset_y.SetValue(pWeapon->GetWpnData().m_expOffset2.y);
oc_adjust_weapon_ironsight_offset_z.SetValue(pWeapon->GetWpnData().m_expOffset2.z);
oc_adjust_weapon_ironsight_offset_angle_x.SetValue(pWeapon->GetWpnData().m_expOriOffset2.x);
oc_adjust_weapon_ironsight_offset_angle_y.SetValue(pWeapon->GetWpnData().m_expOriOffset2.y);
oc_adjust_weapon_ironsight_offset_angle_z.SetValue(pWeapon->GetWpnData().m_expOriOffset2.z);
}
}
}
void AdjustWpnTestOffsetScope(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Scope
oc_adjust_weapon_scope_offset_x.SetValue(pWeapon->GetWpnData().m_expOffsetScope.x);
oc_adjust_weapon_scope_offset_y.SetValue(pWeapon->GetWpnData().m_expOffsetScope.y);
oc_adjust_weapon_scope_offset_z.SetValue(pWeapon->GetWpnData().m_expOffsetScope.z);
oc_adjust_weapon_scope_offset_angle_x.SetValue(pWeapon->GetWpnData().m_expOriOffsetScope.x);
oc_adjust_weapon_scope_offset_angle_y.SetValue(pWeapon->GetWpnData().m_expOriOffsetScope.y);
oc_adjust_weapon_scope_offset_angle_z.SetValue(pWeapon->GetWpnData().m_expOriOffsetScope.z);
}
}
}
void AdjustWpnTestOffsetMove(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
oc_adjust_moveForward_offset_x.SetValue(pWeapon->GetWpnData().PositionFwd.x);
oc_adjust_moveForward_offset_y.SetValue(pWeapon->GetWpnData().PositionFwd.y);
oc_adjust_moveForward_offset_z.SetValue(pWeapon->GetWpnData().PositionFwd.z);
oc_adjust_moveForward_offset_angle_x.SetValue(pWeapon->GetWpnData().AngleFwd.x);
oc_adjust_moveForward_offset_angle_y.SetValue(pWeapon->GetWpnData().AngleFwd.y);
oc_adjust_moveForward_offset_angle_z.SetValue(pWeapon->GetWpnData().AngleFwd.z);
}
}
}
void AdjustWpnTestOffsetWall(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
oc_adjust_wall_offset_x.SetValue(0);
oc_adjust_wall_offset_y.SetValue(0);
oc_adjust_wall_offset_z.SetValue(0);
oc_adjust_wall_offset_angle_x.SetValue(0);
oc_adjust_wall_offset_angle_y.SetValue(0);
oc_adjust_wall_offset_angle_z.SetValue(0);
}
}
}
void AdjustWpnTestOffsetRT(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> RenderTargets
oc_adjust_weapon_rtscope_offset_x.SetValue(pWeapon->GetWpnData().RT_Offset.x);
oc_adjust_weapon_rtscope_offset_y.SetValue(pWeapon->GetWpnData().RT_Offset.y);
oc_adjust_weapon_rtscope_offset_z.SetValue(pWeapon->GetWpnData().RT_Offset.z);
}
}
}
void AdjustWpnTestOffsetRTIron(ConVar *pConVar, char *pszString)
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(engine->GetLocalPlayer());
if (pPlayer)
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if (pWeapon)
{
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> RenderTargets
oc_adjust_weapon_irrtscope_offset_x.SetValue(pWeapon->GetWpnData().RT_OffsetIron.x);
oc_adjust_weapon_irrtscope_offset_y.SetValue(pWeapon->GetWpnData().RT_OffsetIron.y);
oc_adjust_weapon_irrtscope_offset_z.SetValue(pWeapon->GetWpnData().RT_OffsetIron.z);
}
}
}
void CalcExpWpnOffsets(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
// this is a simple test mode to help determine the proper values
// to place in the weapon script
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
if (oc_adjust_weapon_offset.GetBool())
{
ang.x += oc_adjust_weapon_offset_angle_x.GetFloat();
ang.y += oc_adjust_weapon_offset_angle_y.GetFloat();
ang.z += oc_adjust_weapon_offset_angle_z.GetFloat();
offset.Init(oc_adjust_weapon_offset_x.GetFloat(),
oc_adjust_weapon_offset_y.GetFloat(),
oc_adjust_weapon_offset_z.GetFloat());
}
else
{
if (cvar->FindVar("oc_player_draw_body")->GetInt() && cvar->FindVar("oc_player_true_firstperson_vm")->GetInt())
{
ang += pWeapon->GetWpnData().m_expOriOffsetTP;
offset = pWeapon->GetWpnData().m_expOffsetTP;
}
else
{
ang += pWeapon->GetWpnData().m_expOriOffset;
offset = pWeapon->GetWpnData().m_expOffset;
}
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnOffsets2(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
if (oc_adjust_weapon_ironsight_offset.GetBool())
{
ang.x += oc_adjust_weapon_ironsight_offset_angle_x.GetFloat();
ang.y += oc_adjust_weapon_ironsight_offset_angle_y.GetFloat();
ang.z += oc_adjust_weapon_ironsight_offset_angle_z.GetFloat();
offset.Init(oc_adjust_weapon_ironsight_offset_x.GetFloat(),
oc_adjust_weapon_ironsight_offset_y.GetFloat(),
oc_adjust_weapon_ironsight_offset_z.GetFloat());
}
else
{
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
ang += pWeapon->GetWpnData().m_expOriOffset2;
offset = pWeapon->GetWpnData().m_expOffset2;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnOffsetsScope(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
if (oc_adjust_weapon_scope_offset.GetBool())
{
ang.x += oc_adjust_weapon_scope_offset_angle_x.GetFloat();
ang.y += oc_adjust_weapon_scope_offset_angle_y.GetFloat();
ang.z += oc_adjust_weapon_scope_offset_angle_z.GetFloat();
offset.Init(oc_adjust_weapon_scope_offset_x.GetFloat(),
oc_adjust_weapon_scope_offset_y.GetFloat(),
oc_adjust_weapon_scope_offset_z.GetFloat());
}
else
{
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
ang += pWeapon->GetWpnData().m_expOriOffsetScope;
offset = pWeapon->GetWpnData().m_expOffsetScope;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnMoveWallOffsets(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
if (oc_adjust_wall_offset.GetBool())
{
ang.x += oc_adjust_wall_offset_angle_x.GetFloat();
ang.y += oc_adjust_wall_offset_angle_y.GetFloat();
ang.z += oc_adjust_wall_offset_angle_z.GetFloat();
offset.Init(oc_adjust_wall_offset_x.GetFloat(),
oc_adjust_wall_offset_y.GetFloat(),
oc_adjust_wall_offset_z.GetFloat());
}
else
{
ang += pWeapon->GetWpnData().AngleWall;
offset = pWeapon->GetWpnData().PositionWall;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnMoveFwdOffsets(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
if (oc_adjust_moveForward_offset.GetBool())
{
ang.x += oc_adjust_moveForward_offset_angle_x.GetFloat();
ang.y += oc_adjust_moveForward_offset_angle_y.GetFloat();
ang.z += oc_adjust_moveForward_offset_angle_z.GetFloat();
offset.Init(oc_adjust_moveForward_offset_x.GetFloat(),
oc_adjust_moveForward_offset_y.GetFloat(),
oc_adjust_moveForward_offset_z.GetFloat());
}
else
{
ang += pWeapon->GetWpnData().AngleFwd;
offset = pWeapon->GetWpnData().PositionFwd;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnOffsetsRT(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
// this is a simple test mode to help determine the proper values
// to place in the weapon script
if (oc_adjust_weapon_rtscope_offset.GetBool())
{
offset.Init(oc_adjust_weapon_rtscope_offset_x.GetFloat(),
oc_adjust_weapon_rtscope_offset_y.GetFloat(),
oc_adjust_weapon_rtscope_offset_z.GetFloat());
}
else
{
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
offset = pWeapon->GetWpnData().RT_Offset;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
void CalcExpWpnOffsetsRTIron(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
// this is a simple test mode to help determine the proper values
// to place in the weapon script
if (oc_adjust_weapon_irrtscope_offset.GetBool())
{
offset.Init(oc_adjust_weapon_irrtscope_offset_x.GetFloat(),
oc_adjust_weapon_irrtscope_offset_y.GetFloat(),
oc_adjust_weapon_irrtscope_offset_z.GetFloat());
}
else
{
CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)
{
offset = pWeapon->GetWpnData().RT_OffsetIron;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
/*ConVar oc_adjust_leg_offset("oc_adjust_leg_offset", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_x("oc_adjust_leg_offset_x", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_y("oc_adjust_leg_offset_y", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_z("oc_adjust_leg_offset_z", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_angle_x("oc_adjust_leg_offset_angle_x", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_angle_y("oc_adjust_leg_offset_angle_y", "0", FCVAR_ARCHIVE);
ConVar oc_adjust_leg_offset_angle_z("oc_adjust_leg_offset_angle_z", "0", FCVAR_ARCHIVE);*/
void CalcLegOffsets(CBasePlayer *owner, Vector &pos, QAngle &ang)
{
Vector forward, right, up, offset;
float x = 3.f;
float y = 2.f;
float z = -5.f;
float x_ang = 0.f;
float y_ang = 0.f;
float z_ang = 0.f;
{
/*CBaseCombatWeapon *pWeapon = owner->GetActiveWeapon();
if (pWeapon)*/
{
ang += QAngle(x_ang, y_ang, z_ang);
offset.x = x;
offset.y = y;
offset.z = z;
}
}
// get eye direction angles
AngleVectors(ang, &forward, &right, &up);
// apply the offsets
pos += forward * offset.x;
pos += right * offset.y;
pos += up * offset.z;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseViewModel::CBaseViewModel()
{
#if defined( CLIENT_DLL )
// NOTE: We do this here because the color is never transmitted for the view model.
m_nOldAnimationParity = 0;
m_EntClientFlags |= ENTCLIENTFLAG_ALWAYS_INTERPOLATE;
#endif
SetRenderColor( 255, 255, 255, 255 );
// View model of this weapon
m_sVMName = NULL_STRING;
// Prefix of the animations that should be used by the player carrying this weapon
m_sAnimationPrefix = NULL_STRING;
m_nViewModelIndex = 0;
m_nAnimationParity = 0;
#if defined( CLIENT_DLL )
fov1 = oc_viewmodel_dynamic_FOV_unsighted.GetInt();
fov2 = oc_viewmodel_dynamic_FOV_sighted.GetInt();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBaseViewModel::~CBaseViewModel()
{
}
void CBaseViewModel::UpdateOnRemove( void )
{
BaseClass::UpdateOnRemove();
DestroyControlPanels();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseViewModel::Precache( void )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseViewModel::Spawn(void)
{
Precache();
SetSize(Vector(-8, -4, -2), Vector(8, 4, 2));
SetSolid(SOLID_NONE);
#ifdef CLIENT_DLL
lagScale = 1.f;
m_bExpSighted = false;
alreadyInIronSight = false;
m_bExpScope = false;
m_bIsLeg = false;
IsNearWall = false;
delta = 0.f;
wasIronSighted = false;
toggled_do_once = false;
m_expFactor = 0.0f;
m_expFactor2 = 0.0f;
m_flNextLagScale = gpGlobals->curtime;
lagScale = 1.0f;
#else
#endif
}
#if defined ( CSTRIKE_DLL ) && !defined ( CLIENT_DLL )
#define VGUI_CONTROL_PANELS
#endif
#if defined ( TF_DLL )
#define VGUI_CONTROL_PANELS
#endif
#ifdef INVASION_DLL
#define VGUI_CONTROL_PANELS
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseViewModel::SetControlPanelsActive( bool bState )
{
#if defined( VGUI_CONTROL_PANELS )
// Activate control panel screens
for ( int i = m_hScreens.Count(); --i >= 0; )
{
if (m_hScreens[i].Get())
{
m_hScreens[i]->SetActive( bState );
}
}
#endif
}
//-----------------------------------------------------------------------------
// This is called by the base object when it's time to spawn the control panels
//-----------------------------------------------------------------------------
void CBaseViewModel::SpawnControlPanels()
{
#if defined( VGUI_CONTROL_PANELS )
char buf[64];
// Destroy existing panels
DestroyControlPanels();
CBaseCombatWeapon *weapon = m_hWeapon.Get();
if ( weapon == NULL )
{
return;
}
MDLCACHE_CRITICAL_SECTION();
// FIXME: Deal with dynamically resizing control panels?
// If we're attached to an entity, spawn control panels on it instead of use
CBaseAnimating *pEntityToSpawnOn = this;
char *pOrgLL = "controlpanel%d_ll";
char *pOrgUR = "controlpanel%d_ur";
char *pAttachmentNameLL = pOrgLL;
char *pAttachmentNameUR = pOrgUR;
/*
if ( IsBuiltOnAttachment() )
{
pEntityToSpawnOn = dynamic_cast<CBaseAnimating*>((CBaseEntity*)m_hBuiltOnEntity.Get());
if ( pEntityToSpawnOn )
{
char sBuildPointLL[64];
char sBuildPointUR[64];
Q_snprintf( sBuildPointLL, sizeof( sBuildPointLL ), "bp%d_controlpanel%%d_ll", m_iBuiltOnPoint );
Q_snprintf( sBuildPointUR, sizeof( sBuildPointUR ), "bp%d_controlpanel%%d_ur", m_iBuiltOnPoint );
pAttachmentNameLL = sBuildPointLL;
pAttachmentNameUR = sBuildPointUR;
}
else
{
pEntityToSpawnOn = this;
}
}
*/
Assert( pEntityToSpawnOn );
// Lookup the attachment point...
int nPanel;
for ( nPanel = 0; true; ++nPanel )
{
Q_snprintf( buf, sizeof( buf ), pAttachmentNameLL, nPanel );
int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
{
// Try and use my panels then
pEntityToSpawnOn = this;
Q_snprintf( buf, sizeof( buf ), pOrgLL, nPanel );
nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nLLAttachmentIndex <= 0)
return;
}
Q_snprintf( buf, sizeof( buf ), pAttachmentNameUR, nPanel );
int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
{
// Try and use my panels then
Q_snprintf( buf, sizeof( buf ), pOrgUR, nPanel );
nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
if (nURAttachmentIndex <= 0)
return;
}
const char *pScreenName;
weapon->GetControlPanelInfo( nPanel, pScreenName );
if (!pScreenName)
continue;
const char *pScreenClassname;
weapon->GetControlPanelClassName( nPanel, pScreenClassname );
if ( !pScreenClassname )
continue;
// Compute the screen size from the attachment points...
matrix3x4_t panelToWorld;
pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
matrix3x4_t worldToPanel;
MatrixInvert( panelToWorld, worldToPanel );
// Now get the lower right position + transform into panel space
Vector lr, lrlocal;
pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
MatrixGetColumn( panelToWorld, 3, lr );
VectorTransform( lr, worldToPanel, lrlocal );
float flWidth = lrlocal.x;
float flHeight = lrlocal.y;
CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
pScreen->ChangeTeam( GetTeamNumber() );
pScreen->SetActualSize( flWidth, flHeight );
pScreen->SetActive( false );
pScreen->MakeVisibleOnlyToTeammates( false );
#ifdef INVASION_DLL
pScreen->SetOverlayMaterial( SCREEN_OVERLAY_MATERIAL );
#endif
pScreen->SetAttachedToViewModel( true );
int nScreen = m_hScreens.AddToTail( );
m_hScreens[nScreen].Set( pScreen );
}
#endif
}
void CBaseViewModel::DestroyControlPanels()
{
#if defined( VGUI_CONTROL_PANELS )
// Kill the control panels
int i;
for ( i = m_hScreens.Count(); --i >= 0; )
{
DestroyVGuiScreen( m_hScreens[i].Get() );
}
m_hScreens.RemoveAll();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
//-----------------------------------------------------------------------------
void CBaseViewModel::SetOwner( CBaseEntity *pEntity )
{
m_hOwner = pEntity;
#if !defined( CLIENT_DLL )
// Make sure we're linked into hierarchy
//SetParent( pEntity );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nIndex -
//-----------------------------------------------------------------------------
void CBaseViewModel::SetIndex( int nIndex )
{
m_nViewModelIndex = nIndex;
Assert( m_nViewModelIndex < (1 << VIEWMODEL_INDEX_BITS) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseViewModel::ViewModelIndex( ) const
{
return m_nViewModelIndex;
}
//-----------------------------------------------------------------------------
// Purpose: Pass our visibility on to our child screens
//-----------------------------------------------------------------------------
void CBaseViewModel::AddEffects( int nEffects )
{
if ( nEffects & EF_NODRAW )
{
SetControlPanelsActive( false );
}
BaseClass::AddEffects( nEffects );
}
//-----------------------------------------------------------------------------
// Purpose: Pass our visibility on to our child screens
//-----------------------------------------------------------------------------
void CBaseViewModel::RemoveEffects( int nEffects )
{
if ( nEffects & EF_NODRAW )
{
SetControlPanelsActive( true );
}
BaseClass::RemoveEffects( nEffects );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *modelname -
//-----------------------------------------------------------------------------
void CBaseViewModel::SetWeaponModel(const char *modelname, CBaseCombatWeapon *weapon)
{
m_hWeapon = weapon;
#if defined( CLIENT_DLL )
if (cvar->FindVar("oc_player_draw_body")->GetInt() && cvar->FindVar("oc_player_true_firstperson_vm")->GetInt())
{
PrecacheModel(cvar->FindVar("oc_playermodel_suit")->GetString());
SetModel(cvar->FindVar("oc_playermodel_suit")->GetString());
int bg_rl = FindBodygroupByName("right_leg");
int bg_ll = FindBodygroupByName("left_leg");
int bg_t = FindBodygroupByName("torso");
int bg_h = FindBodygroupByName("head");
SetBodygroup(bg_rl, 1);
SetBodygroup(bg_ll, 1);
SetBodygroup(bg_t, 1);
SetBodygroup(bg_h, 1);
}
else
{
PrecacheModel(modelname);
SetModel(modelname);
}
#else
string_t str;
if ( modelname != NULL )
{
str = MAKE_STRING( modelname );
}
else
{
str = NULL_STRING;
}
if ( str != m_sVMName )
{
// Msg( "SetWeaponModel %s at %f\n", modelname, gpGlobals->curtime );
m_sVMName = str;
if (cvar->FindVar("oc_player_draw_body")->GetInt() && cvar->FindVar("oc_player_true_firstperson_vm")->GetInt())
{
PrecacheModel(cvar->FindVar("oc_playermodel_suit")->GetString());
SetModel(cvar->FindVar("oc_playermodel_suit")->GetString());
int bg_rh = FindBodygroupByName("right_hand");
int bg_lh = FindBodygroupByName("left_hand");
SetBodygroup(bg_rh, 0);
SetBodygroup(bg_lh, 0);
int bg_rl = FindBodygroupByName("right_leg");
int bg_ll = FindBodygroupByName("left_leg");
int bg_t = FindBodygroupByName("torso");
int bg_h = FindBodygroupByName("head");
SetBodygroup(bg_rl, 1);
SetBodygroup(bg_ll, 1);
SetBodygroup(bg_t, 1);
SetBodygroup(bg_h, 1);
}
else
{
PrecacheModel(m_sVMName.ToCStr());
SetModel(STRING(m_sVMName));
}
// Create any vgui control panels associated with the weapon
SpawnControlPanels();
bool showControlPanels = weapon && weapon->ShouldShowControlPanels();
SetControlPanelsActive( showControlPanels );
}
#endif
}
CStudioHdr *CBaseViewModel::OnNewModel()
{
//SetBodygroup(0, 0);
return BaseClass::OnNewModel();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CBaseCombatWeapon
//-----------------------------------------------------------------------------
CBaseCombatWeapon *CBaseViewModel::GetOwningWeapon( void )
{
return m_hWeapon.Get();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : sequence -
//-----------------------------------------------------------------------------
void CBaseViewModel::SendViewModelMatchingSequence( int sequence )
{
// since all we do is send a sequence number down to the client,
// set this here so other weapons code knows which sequence is playing.
SetSequence(sequence);
m_nAnimationParity = (m_nAnimationParity + 1) & ((1 << VIEWMODEL_ANIMATION_PARITY_BITS) - 1);
#if defined( CLIENT_DLL )
m_nOldAnimationParity = m_nAnimationParity;
// Force frame interpolation to start at exactly frame zero
m_flAnimTime = gpGlobals->curtime;
#else
CBaseCombatWeapon *weapon = m_hWeapon.Get();
bool showControlPanels = weapon && weapon->ShouldShowControlPanels();
SetControlPanelsActive( showControlPanels );
#endif
// Restart animation at frame 0
SetCycle(0);
ResetSequenceInfo();
}
#if defined( CLIENT_DLL )
#include "ivieweffects.h"
#endif
extern void ScreenToWorld(int mousex, int mousey, float fov, const Vector& vecRenderOrigin, const QAngle& vecRenderAngles, Vector& vecPickingRay);
float yy = 0;
bool F = false;
bool D = false;
float alpha = 0.0f;
float Wfwd = 0.0f;//FORWARD
float fwd = 0.0f;//FORWARD
float deltaFwd = 0.0f;
float fwd0 = 0.0f;
float bwd0 = 0.0f;//BACKWARD
void CBaseViewModel::CalcViewModelView(CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles)
{
#if defined( CLIENT_DLL )
QAngle vmangoriginal = eyeAngles;
QAngle vmangles = eyeAngles;
Vector vmorigin = eyePosition;
if (m_bIsLeg)
{
CalcLegOffsets(owner, vmorigin, vmangles);
SetLocalOrigin(vmorigin);
SetLocalAngles(vmangles);
return;
}
Vector RTOrigin = eyePosition;
Vector RTIronOrigin = eyePosition;
QAngle vmanglesW = eyeAngles;
Vector vmoriginW = eyePosition;
QAngle vmanglesM = eyeAngles;
Vector vmoriginM = eyePosition;
QAngle vmangles2 = eyeAngles;
Vector vmorigin2 = eyePosition;
QAngle vmanglesScope = eyeAngles;
Vector vmoriginScope = eyePosition;
C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
if (pPlayer == NULL)
return;
CBaseCombatWeapon *pWeapon = m_hWeapon.Get();
//Allow weapon lagging
C_BaseCombatWeapon *pWeapon_ = m_hWeapon.Get();
if (pWeapon != NULL)
{
m_bExpSighted = (bool)pWeapon->IsIronSighted();
}
if (::input->CAM_IsFreeAiming())
{
QAngle Ang, vmangles2;
trace_t tr;
const Vector eyePos = pPlayer->EyePosition();
Vector vecForward = MainViewForward();//vmorigin;
Vector2D vec_AimPos = ::input->CAM_GetFreeAimCursor();
int screen_x, screen_y;
engine->GetScreenSize(screen_x, screen_y);
screen_x *= vec_AimPos.x * oc_weapon_free_aim_movemax_viewmodel_y.GetFloat() + 0.5f;
screen_y *= vec_AimPos.y * oc_weapon_free_aim_movemax_viewmodel_x.GetFloat() + 0.5f;
ScreenToWorld(screen_x, screen_y, pPlayer->GetFOV(), MainViewOrigin(), vmangles, vecForward);
UTIL_TraceLine(MainViewOrigin(), MainViewOrigin() + vecForward * MAX_TRACE_LENGTH, MASK_SHOT, pPlayer, COLLISION_GROUP_NONE, &tr);
VectorAngles(vecForward, vmangles);
}
int speed = 0;
Vector velocity;
if (pPlayer->GetFlags() & FL_ONGROUND)
{
pPlayer->EstimateAbsVelocity(velocity);
speed = velocity.NormalizeInPlace();///Normalized
}
else
{
speed = cvar->FindVar("hl2_normspeed")->GetInt();
}
cvar->FindVar("oc_state_player_velocity")->SetValue(speed);
bool wallBump = cvar->FindVar("oc_weapons_allow_wall_bump")->GetInt();
bool wallBump2 = cvar->FindVar("oc_weapons_allow_wall_bump")->GetInt() ? /*cvar->FindVar("oc_state_near_wall_standing")->GetInt() == 0*/ !IsNearWall : true;
bool wallBump3 = cvar->FindVar("oc_weapons_allow_wall_bump")->GetInt() ? /*cvar->FindVar("oc_state_near_wall_standing")->GetInt() == 1*/ IsNearWall : false;
bool sprintLower = cvar->FindVar("oc_weapons_allow_sprint_lower")->GetInt() ? true : false;
if (pWeapon != NULL)
{
if (pWeapon->letViewModelBob &&
!m_bExpSighted &&
wallBump2 &&
!m_bExpScope)//cvar->FindVar("oc_state_InSecondFire")->GetInt() == 0)
{
if (lagScale <= 1.f)
{
/*if (m_flNextLagScale < gpGlobals->curtime)
{
m_flNextLagScale = gpGlobals->curtime + 1.f;
}
if (gpGlobals->curtime < m_flNextLagScale && lagScale <= 1.f)
{
lagScale = 1.01f-(m_flNextLagScale - gpGlobals->curtime);
}*/
lagScale += oc_viewmodel_lag_change_speed.GetFloat() * gpGlobals->frametime;
}
}
else
{
if (lagScale > 0)
{
lagScale -= oc_viewmodel_lag_change_speed.GetFloat() * gpGlobals->frametime;
}
/*if (m_flNextLagScale < gpGlobals->curtime && lagScale >= 1.f)
{
m_flNextLagScale = gpGlobals->curtime + 1.f;
}
if (gpGlobals->curtime < m_flNextLagScale && lagScale >= 0.f)
{
lagScale = m_flNextLagScale - gpGlobals->curtime;
}*/
}
if (pWeapon->m_bWeaponBlockWall)
{
wallBump = wallBump2 = wallBump3 = false;
}
//DevMsg("lagScale: %.2f \n", lagScale);
/*#if defined( CLIENT_DLL )
if (!prediction->InPrediction())
#endif*/
//{
CalcViewModelLag(vmorigin, vmangles, vmangoriginal, oc_viewmodel_lag_type.GetInt(), lagScale);
CalcViewModelLag(vmoriginM, vmangles, vmangoriginal, oc_viewmodel_lag_type.GetInt(), lagScale);
//}
if (oc_viewmodel_bob_enable.GetInt())
{
if (pWeapon->GetWpnData().ViewModelShake)
{
pWeapon->AddViewmodelBob(this, vmorigin, vmangles, lagScale);
pWeapon->AddViewmodelBob(this, vmoriginM, vmanglesM, lagScale);
}
}
}
CalcExpWpnOffsets(owner, vmorigin, vmangles);
CalcExpWpnOffsetsRT(owner, RTOrigin, vmangles);
CalcExpWpnOffsetsRTIron(owner, RTIronOrigin, vmangles2);
if (wallBump3)
{
CalcExpWpnMoveWallOffsets(owner, vmoriginW, vmanglesW);
}
CalcExpWpnMoveFwdOffsets(owner, vmoriginM, vmanglesM);
CalcExpWpnOffsets2(owner, vmorigin2, vmangles2);
CalcExpWpnOffsetsScope(owner, vmoriginScope, vmangles2);
Vector difPos(vmorigin - eyePosition);
Vector RTdifPos(RTOrigin - eyePosition);
Vector RTIdifPos(RTIronOrigin - eyePosition);
Vector difPosW(vmoriginW - eyePosition);
Vector difPosM(vmoriginM - eyePosition);
Vector difPos2(vmorigin2 - eyePosition);
Vector difPosScope(vmoriginScope - eyePosition);
if (pWeapon != NULL)
{
/*trace_t tr, m_trHit;
Vector vecDir, vecStop, vecSrc, vForward, vRight, vUp;
pPlayer->EyeVectors(&vForward, &vRight, &vUp);
QAngle Angle = pPlayer->EyeAngles();
Vector res = pPlayer->EyePosition();
res += vForward;
res += vRight;
res += vUp;
vecSrc = res;
AngleVectors(Angle, &vecDir);
vecStop = vecSrc + vecDir * MAX_TRACE_LENGTH;
UTIL_TraceLine(vecSrc, vecStop, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
float Dist = pWeapon_->GetWpnData().DistanceToWall;*/
//if (tr.m_pEnt != NULL ? !FClassnameIs(tr.m_pEnt, "physics_prop_ragdoll") && !FClassnameIs(tr.m_pEnt, "prop_ragdoll") && !FClassnameIs(tr.m_pEnt, "prop_ragdoll_attached") : true)
{
if (wallBump)
{
if ((oc_viewmodel_move_wall_type.GetInt() == 1)
&& !pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC() && !(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
F = true;
D = false;
alpha = oc_viewmodel_move_wall_change_speed.GetFloat() * gpGlobals->frametime;
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
D = true;
F = false;
alpha = oc_viewmodel_move_wall_change_speed.GetFloat() * gpGlobals->frametime;
}
if ((!D) && (!F))
{
alpha = 0.0f;
}
else if ((D) && (F))
{
alpha = 0.0f;
}
//Vector Pos = m_bExpSighted ? difPos2 : difPos;
if ((!D) && (F))
{
if ((yy < 1.0f) && ((!D) && (F)))
Wfwd = Wfwd + alpha;
yy = (yy < 1.0f - alpha) ? Wfwd : 1.0f;
difPos = Lerp(yy, difPos, difPosW);
vmangles = Lerp(yy, vmangles, vmanglesW);
vmorigin = eyePosition + difPos;
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
if ((D) && (!F))
{
if ((yy > 0.0f) && ((D) && (!F)))
Wfwd = Wfwd - alpha;
yy = (yy > 0.0f + alpha) ? Wfwd : 0.0f;
difPos = Lerp(yy, difPos, difPosW);
vmangles = Lerp(yy, vmangles, vmanglesW);
vmorigin = eyePosition + difPos;
if (yy == 0.0f)
{
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
}
else if ((oc_viewmodel_move_wall_type.GetInt() == 1) &&
!pPlayer->IsReloadingWeapon() &&
pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC()) && (!(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
if ((oc_viewmodel_move_wall_type.GetInt() == 0)
&& !pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
trace_t tr, m_trHit;
Vector vecDir, vecStop, vecSrc, vForward, vRight, vUp;
pPlayer->EyeVectors(&vForward, &vRight, &vUp);
QAngle Angle = pPlayer->EyeAngles();
Vector res = pPlayer->EyePosition();
res += vForward;
res += vRight;
res += vUp;
vecSrc = res;
AngleVectors(Angle, &vecDir);
vecStop = vecSrc + vecDir * MAX_TRACE_LENGTH;
UTIL_TraceLine(vecSrc, vecStop, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
float Dist = pWeapon_->GetWpnData().DistanceToWall;
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC()) && (!(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
//alpha = (1 / (1 / (tr.endpos.DistTo(vecSrc)))) * (tr.endpos.DistTo(vecSrc));
alpha = abs(((tr.endpos.DistTo(vecSrc)) / (tr.endpos.DistTo(vecSrc))) - ((1 / (tr.endpos.DistTo(vecSrc))*((Dist * 5) / (tr.endpos.DistTo(vecSrc))))));
//alpha = abs(((pWeapon->distanceToWall) / (pWeapon->distanceToWall)) - ((1 / (pWeapon->distanceToWall)*((Dist * 5) / (pWeapon->distanceToWall)))));
//DevMsg("Alpha: %.2f \n", alpha);
Clamp(alpha, 0.0f, 1.0f);
difPos = Lerp(alpha, difPosW, difPos);
vmangles = Lerp(alpha, vmanglesW, vmangles);
vmorigin = eyePosition + difPos;
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
alpha = 0.0f;
difPos = Lerp(alpha, difPos, difPosW);
vmangles = Lerp(alpha, vmangles, vmanglesW);
vmorigin = eyePosition + difPos;
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
else if ((oc_viewmodel_move_wall_type.GetInt() == 0) &&
!pPlayer->IsReloadingWeapon() &&
pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC()) && (!(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
if ((oc_viewmodel_move_wall_type.GetInt() == 2)
&& !pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
trace_t tr, m_trHit;
Vector vecDir, vecStop, vecSrc, vForward, vRight, vUp;
pPlayer->EyeVectors(&vForward, &vRight, &vUp);
QAngle Angle = pPlayer->EyeAngles();
Vector res = pPlayer->EyePosition();
res += vForward;
res += vRight;
res += vUp;
vecSrc = res;
AngleVectors(Angle, &vecDir);
vecStop = vecSrc + vecDir * MAX_TRACE_LENGTH;
UTIL_TraceLine(vecSrc, vecStop, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr);
float Dist = pWeapon_->GetWpnData().DistanceToWall;
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC()) && (!(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
alpha = abs(((tr.endpos.DistTo(vecSrc)) / (tr.endpos.DistTo(vecSrc))) - ((1 / (tr.endpos.DistTo(vecSrc))*((Dist * 5) / (tr.endpos.DistTo(vecSrc))))));
//alpha = abs(((pWeapon->distanceToWall) / (pWeapon->distanceToWall)) - ((1 / (pWeapon->distanceToWall)*((Dist * 5) / (pWeapon->distanceToWall)))));
Clamp(alpha, 0.0f, 1.0f);
difPos = Lerp(alpha, difPosW, difPos);
vmangles = Lerp(alpha, vmanglesW, vmangles);
vmorigin = eyePosition + difPos;
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
alpha = 0.0f;
difPos = Lerp(alpha, difPos, difPosW);
vmangles = Lerp(alpha, vmangles, vmanglesW);
vmorigin = eyePosition + difPos;
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
else if ((oc_viewmodel_move_wall_type.GetInt() == 2) &&
!pPlayer->IsReloadingWeapon() &&
pWeapon_->GetWpnData().animData[pWeapon_->m_bFireMode].WallAnimation)
{
//if ((tr.endpos.DistTo(vecSrc) < Dist) && (!tr.m_pEnt->IsNPC()) && (!(tr.surface.flags & (SURF_TRIGGER | SURF_WARP | SURF_HITBOX))))
if (pWeapon->clipNearWall)
{
IsNearWall = true;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(1);
}
//if (tr.endpos.DistTo(vecSrc) >= Dist)
else
{
IsNearWall = false;
cvar->FindVar("oc_state_near_wall_standing")->SetValue(0);
}
}
}
}
if (m_bExpSighted)
{
wasIronSighted = true;
if (delta < 1.0f)
{
delta = Clamp((delta + (oc_viewmodel_ironsight_move_speed.GetFloat() * gpGlobals->frametime)), 0.f, 1.f);
}
else
{
delta = 1.f;
alreadyInIronSight = true;
}
m_expFactor2 = delta;
difPos = Lerp(m_expFactor2, difPos, difPos2);
RTdifPos = Lerp(m_expFactor2, RTdifPos, RTIdifPos);
vmangles = Lerp(m_expFactor2, vmangles, vmangles2);
vmorigin = eyePosition + difPos;
RTOrigin = eyePosition + RTdifPos;
}
if (m_bExpScope)
{
wasIronSighted = false;
if (delta < 1.0f)
delta = Clamp((float)(delta + (oc_viewmodel_secondfire_move_speed.GetFloat() * gpGlobals->frametime * 2.5)), 0.f, 1.f);
else
delta = 1.f;
m_expFactor2 = delta;
difPos = Lerp(m_expFactor2, difPos, difPosScope);
RTdifPos = Lerp(m_expFactor2, RTdifPos, RTIdifPos);
vmangles = Lerp(m_expFactor2, vmangles, vmangles2);
vmorigin = eyePosition + difPos;
RTOrigin = eyePosition + RTdifPos;
}
if (!m_bExpSighted && !m_bExpScope)
{
cvar->FindVar("oc_state_IRsight_bytime")->SetValue(0);
if (wasIronSighted)
{
if (delta > 0.0f)
delta = delta - (oc_viewmodel_ironsight_move_speed.GetFloat() * gpGlobals->frametime);
else
{
delta = 0.f;
}
alreadyInIronSight = false;
m_expFactor2 = delta;
difPos = Lerp(m_expFactor2, difPos, difPos2);
RTdifPos = Lerp(m_expFactor2, RTdifPos, RTIdifPos);
vmangles = Lerp(m_expFactor2, vmangles, vmangles2);
vmorigin = eyePosition + difPos;
RTOrigin = eyePosition + RTdifPos;
if (delta <= 0.0f)
{
cvar->FindVar("oc_state_IRsight_on")->SetValue(0);
}
}
else
{
if (delta > 0.0f)
delta = delta - (oc_viewmodel_secondfire_move_speed.GetFloat() * gpGlobals->frametime * 3);
else
delta = 0.f;
m_expFactor2 = delta;
if (delta <= 0.0f)
{
cvar->FindVar("oc_state_IRsight_on")->SetValue(0);
}
vmorigin = eyePosition + difPos;
RTOrigin = eyePosition + RTdifPos;
}
}
if (sprintLower && !m_bExpScope && !pWeapon->IsInReload() )//&& !m_bExpSighted)
{
/*if (speed >= cvar->FindVar("hl2_sprintspeed")->GetInt() - 10)
{
cvar->FindVar("oc_state_is_running")->SetValue(1);
}
if (speed < cvar->FindVar("hl2_sprintspeed")->GetInt() - 10)
{
cvar->FindVar("oc_state_is_running")->SetValue(0);
}*/
if (oc_viewmodel_movement_type.GetInt() == 1)
{
if ((speed >= cvar->FindVar("hl2_sprintspeed")->GetInt() - 10))
{
if (deltaFwd < 1.0f)
fwd = fwd + (oc_viewmodel_move_fwd_bwd_change_speed_type0.GetFloat() * gpGlobals->frametime);
else
fwd = 1.0f;
deltaFwd = (deltaFwd < 1.0f - (oc_viewmodel_move_fwd_bwd_change_speed_type0.GetFloat() * gpGlobals->frametime)) ? fwd : 1.0f;
difPos = Lerp(deltaFwd, difPos, difPosM);
vmangles = Lerp(deltaFwd, vmangles, vmanglesM);
cvar->FindVar("oc_state_is_runningLAG")->SetValue(1);
vmorigin = eyePosition + difPos;
/*if (deltaFwd > 0.0f)
cvar->FindVar("oc_state_is_running")->SetValue(1);*/
}
//Original
else if ((speed < cvar->FindVar("hl2_sprintspeed")->GetInt() - 10))
{
if (deltaFwd > 0.0f)
fwd = fwd - (oc_viewmodel_move_fwd_bwd_change_speed_type0.GetFloat() * gpGlobals->frametime);
deltaFwd = (deltaFwd > 0.0f + (oc_viewmodel_move_fwd_bwd_change_speed_type0.GetFloat() * gpGlobals->frametime)) ? fwd : 0.0f;
if ((fwd0 != 2) && (fwd0 != 3))
{
difPos = Lerp(deltaFwd, difPos, difPosM);
vmangles = Lerp(deltaFwd, vmangles, vmanglesM);
}
if (fwd0 == 2)
{
difPos = Lerp(deltaFwd, difPos, difPosM);
vmangles = Lerp(deltaFwd, vmangles, vmanglesM);
}
if (fwd0 == 3)
{
difPos = Lerp(deltaFwd, difPos, difPosM);
vmangles = Lerp(deltaFwd, vmangles, vmanglesM);
}
cvar->FindVar("oc_state_is_runningLAG")->SetValue(0);
vmorigin = eyePosition + difPos;
if (deltaFwd == 0.0f)
{
fwd0 = 0;
//cvar->FindVar("oc_state_is_running")->SetValue(0);
}
}
}
}
/*else
{
if (cvar->FindVar("oc_state_is_running")->GetInt())
cvar->FindVar("oc_state_is_running")->SetValue(0);
}*/
}
//DevMsg("vmangles yaw: %.2f\n vmangoriginal yaw: %.2f\n", vmangles[YAW], vmangoriginal[YAW]);
SetLocalOrigin(vmorigin);
SetLocalAngles(vmangles);
//engine->ServerCmd(VarArgs("MuzzleAngles %f %f %f\n", vmangles.x, vmangles.y, vmangles.z), false);
cvar->FindVar("oc_muzzle_angle_x")->SetValue(vmangles.x);
cvar->FindVar("oc_muzzle_angle_y")->SetValue(vmangles.y);
cvar->FindVar("oc_muzzle_angle_z")->SetValue(vmangles.z);
cvar->FindVar("oc_RT_vector_x")->SetValue(RTOrigin.x);
cvar->FindVar("oc_RT_vector_y")->SetValue(RTOrigin.y);
cvar->FindVar("oc_RT_vector_z")->SetValue(RTOrigin.z);
#endif
}
ConVar oc_viewbob_vectorma_flspeed("oc_viewbob_vectorma_flspeed", "5.5", FCVAR_REPLICATED);
ConVar oc_viewbob_maxviewmodellag("oc_viewbob_maxviewmodellag", "3.0", FCVAR_REPLICATED);
ConVar oc_viewbob_scale("oc_viewbob_scale", "-0.017", FCVAR_REPLICATED);//-0.052
ConVar oc_viewbob_dest("oc_viewbob_dest", "1.3", FCVAR_REPLICATED);//2.5
ConVar oc_viewbob_scale2("oc_viewbob_scale2", "-0.052", FCVAR_REPLICATED);//-0.052
ConVar oc_viewbob_dest2("oc_viewbob_dest2", "1.3", FCVAR_REPLICATED);//2.5
ConVar oc_test_y("oc_test_y", "200.0", FCVAR_REPLICATED);
void CBaseViewModel::CalcViewModelLag(Vector& origin, QAngle& angles, QAngle& original_angles, int state, float lagScale)
{
CBasePlayer *pPlayer = ToBasePlayer(GetOwner());
if (pPlayer == NULL)
return;
//bool wallBump = cvar->FindVar("oc_weapons_allow_wall_bump")->GetInt() ? cvar->FindVar("oc_state_near_wall_standing")->GetInt() == 0 : true;
//DevMsg("mouseX: %i\n mouseY: %i\n", input->mouseX, input->mouseY);
//DevMsg("GetLookSpring: %.2f\n Joystick_GetSide: %.2f\n", input->GetLookSpring(), input->Joystick_GetSide());
/*#if defined( CLIENT_DLL )
DevMsg("mouseX: %.2f\n mouseY: %.2f\n", input->mouseX, input->mouseY);
#endif*/
float lag = lagScale;
lag = Clamp(lag, 0.02f, 1.0f);
QAngle AnglesEyes = pPlayer->EyeAngles();
Vector vOriginalOrigin = origin, origin2;
QAngle vOriginalAngles = angles;
Vector forward;
AngleVectors(angles, &forward, NULL, NULL);
float g_fMaxViewModelLag = oc_viewbob_maxviewmodellag.GetFloat();
float scale = oc_viewbob_scale.GetFloat();
float scale2 = oc_viewbob_scale2.GetFloat();
float dest = oc_viewbob_dest.GetFloat();
float dest2 = oc_viewbob_dest2.GetFloat();
Vector vDifference;
float scaleConst = 5.0f;
float diff = -1.0f;
scaleConst = scaleConst*lag;
diff = diff*lag;
scale2 = scale2*lag;
scale = scale*lag;
dest2 = dest2*lag;
dest = dest*lag;
float dif = abs(AnglesEyes.x) * 0.01f;
//DevMsg("dif: %.2f\n", dif);
float destDif = 1.0f - dif;
//DevMsg("dif dest: %.2f\n", destDif);
dest2 *= destDif;
if (!(abs(AnglesEyes.x) <= 86.0f))
{
dest2 *= 0.05f;
//VectorMA(m_vecLastFacing, 0.f, vDifference*dest2, m_vecLastFacing);
scale2 *= dest2;
vDifference *= dest2;
}
if (state == 0)//Default
{
if (gpGlobals->frametime != 0.0f)
{
VectorSubtract(forward, m_vecLastFacing, vDifference);
float flSpeed = (oc_viewbob_vectorma_flspeed.GetFloat());
float flDiff = vDifference.Length();
if ((flDiff > g_fMaxViewModelLag) && (g_fMaxViewModelLag > 0.0f))
{
float flScale = abs(flDiff / g_fMaxViewModelLag);
flSpeed *= flScale;
}
scale2 = oc_viewbob_scale2.GetFloat();
// FIXME: Needs to be predictable?
VectorMA(m_vecLastFacing, flSpeed * gpGlobals->frametime, vDifference, m_vecLastFacing);
// Make sure it doesn't grow out of control!!!
VectorNormalize(m_vecLastFacing);
VectorMA(origin, scaleConst, vDifference * diff, origin);
AngleVectors(angles, &origin2, NULL, NULL);
}
}
else if (state == 1)
{
if (gpGlobals->frametime != 0.0f)
{
VectorSubtract(forward, m_vecLastFacing, vDifference);
float flSpeed = (oc_viewbob_vectorma_flspeed.GetFloat());
float flDiff = vDifference.Length();
if ((flDiff > g_fMaxViewModelLag) && (g_fMaxViewModelLag > 0.0f))
{
float flScale = abs(flDiff / g_fMaxViewModelLag);
flSpeed *= flScale;
}
if (!((AnglesEyes.x <= 88.0f) && (AnglesEyes.x >= -88.0f)))
{
flDiff = 0.f;
flSpeed = 0.f;
}
scale2 = oc_viewbob_scale2.GetFloat();
VectorMA(m_vecLastFacing, flSpeed * gpGlobals->frametime, vDifference, m_vecLastFacing);
VectorNormalize(m_vecLastFacing);
VectorMA(origin, -scale2, vDifference * dest2, origin);
//if (((AnglesEyes.x <= 88.0f) && (AnglesEyes.x >= -88.0f)))
{
AngleVectors(angles, &origin2, NULL, NULL);
VectorMA(origin2, -scale2, vDifference * dest2, origin2);
VectorAngles(origin2, angles);
/*QAngle angles2 = angles;
AngleVectors(angles2, &origin2, NULL, &origin2);*/
/*angles.x = angles2.x;
angles.y = angles2.y;
angles.z = angles2.z + 180;*/
/*VectorMA(origin2, -scale2, vDifference * dest2, origin2);
VectorAngles(origin2, angles);
angles.x += 180;*/
}
}
}
else if (state == 2)
{
if (gpGlobals->frametime != 0.0f)
{
VectorSubtract(forward, m_vecLastFacing, vDifference);
float flSpeed = (oc_viewbob_vectorma_flspeed.GetFloat());
float flDiff = vDifference.Length();
if ((flDiff > g_fMaxViewModelLag) && (g_fMaxViewModelLag > 0.0f))
{
float flScale = abs(flDiff / g_fMaxViewModelLag);
flSpeed *= flScale;
}
if (!((AnglesEyes.x <= 88.0f) && (AnglesEyes.x >= -88.0f)))
{
flDiff = 0.f;
flSpeed = 0.f;
}
scale = oc_viewbob_scale.GetFloat();
VectorMA(m_vecLastFacing, flSpeed * gpGlobals->frametime, vDifference, m_vecLastFacing);
VectorNormalize(m_vecLastFacing);
VectorMA(origin, scale2, vDifference * dest2, origin);
//if (((AnglesEyes.x <= 88.0f) && (AnglesEyes.x >= -88.0f)))
{
AngleVectors(angles, &origin2, NULL, NULL);
VectorMA(origin2, scale2, vDifference * dest2, origin2);
VectorAngles(origin2, angles);
}
}
}
Vector right, up;
AngleVectors(original_angles, &forward, &right, &up);
float pitch = original_angles[PITCH];
if (pitch > 180.0f)
pitch -= 360.0f;
else if (pitch < -180.0f)
pitch += 360.0f;
if (g_fMaxViewModelLag == 0.0f)
{
origin = vOriginalOrigin;
angles = vOriginalAngles;
}
VectorMA(origin, -pitch * 0.001f, forward, origin);
//VectorMA(origin, -pitch * 0.001f, right, origin);
if (cvar->FindVar("oc_player_draw_body")->GetInt())
VectorMA(origin, pitch * 0.025f, up, origin);
else
VectorMA(origin, -pitch * 0.001f, up, origin);
}
//-----------------------------------------------------------------------------
// Stub to keep networking consistent for DEM files
//-----------------------------------------------------------------------------
#if defined( CLIENT_DLL )
extern void RecvProxy_EffectFlags( const CRecvProxyData *pData, void *pStruct, void *pOut );
void RecvProxy_SequenceNum( const CRecvProxyData *pData, void *pStruct, void *pOut );
#endif
//-----------------------------------------------------------------------------
// Purpose: Resets anim cycle when the server changes the weapon on us
//-----------------------------------------------------------------------------
#if defined( CLIENT_DLL )
static void RecvProxy_Weapon( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
CBaseViewModel *pViewModel = ((CBaseViewModel*)pStruct);
CBaseCombatWeapon *pOldWeapon = pViewModel->GetOwningWeapon();
// Chain through to the default recieve proxy ...
RecvProxy_IntToEHandle( pData, pStruct, pOut );
// ... and reset our cycle index if the server is switching weapons on us
CBaseCombatWeapon *pNewWeapon = pViewModel->GetOwningWeapon();
if ( pNewWeapon != pOldWeapon )
{
// Restart animation at frame 0
pViewModel->SetCycle( 0 );
pViewModel->m_flAnimTime = gpGlobals->curtime;
}
}
#endif
LINK_ENTITY_TO_CLASS( viewmodel, CBaseViewModel );
IMPLEMENT_NETWORKCLASS_ALIASED( BaseViewModel, DT_BaseViewModel )
BEGIN_NETWORK_TABLE_NOBASE(CBaseViewModel, DT_BaseViewModel)
#if !defined( CLIENT_DLL )
SendPropModelIndex(SENDINFO(m_nModelIndex)),
SendPropInt (SENDINFO(m_nBody), 8),
SendPropInt (SENDINFO(m_nSkin), 10),
SendPropInt (SENDINFO(m_nSequence), 8, SPROP_UNSIGNED),
SendPropInt (SENDINFO(m_nViewModelIndex), VIEWMODEL_INDEX_BITS, SPROP_UNSIGNED),
SendPropFloat (SENDINFO(m_flPlaybackRate), 8, SPROP_ROUNDUP, -4.0, 12.0f),
SendPropInt (SENDINFO(m_fEffects), 10, SPROP_UNSIGNED),
SendPropInt (SENDINFO(m_nAnimationParity), 3, SPROP_UNSIGNED ),
SendPropEHandle (SENDINFO(m_hWeapon)),
SendPropEHandle (SENDINFO(m_hOwner)),
SendPropInt( SENDINFO( m_nNewSequenceParity ), EF_PARITY_BITS, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nResetEventsParity ), EF_PARITY_BITS, SPROP_UNSIGNED ),
SendPropInt( SENDINFO( m_nMuzzleFlashParity ), EF_MUZZLEFLASH_BITS, SPROP_UNSIGNED ),
//SendPropFloat (SENDINFO(tracerOrig_X)),
//SendPropFloat (SENDINFO(tracerOrig_Y)),
//SendPropFloat (SENDINFO(tracerOrig_Z)),
SendPropBool(SENDINFO(m_bExpSighted)),
SendPropBool(SENDINFO(m_bExpScope)),
SendPropBool(SENDINFO(m_bIsLeg)),
SendPropBool(SENDINFO(m_bDefRenderGroup)),
SendPropBool(SENDINFO(IsNearWall)),
#if !defined( INVASION_DLL ) && !defined( INVASION_CLIENT_DLL )
SendPropArray (SendPropFloat(SENDINFO_ARRAY(m_flPoseParameter), 8, 0, 0.0f, 1.0f), m_flPoseParameter),
#endif
#else
RecvPropInt (RECVINFO(m_nModelIndex)),
RecvPropInt (RECVINFO(m_nSkin)),
RecvPropInt (RECVINFO(m_nBody)),
RecvPropInt (RECVINFO(m_nSequence), 0, RecvProxy_SequenceNum ),
RecvPropInt (RECVINFO(m_nViewModelIndex)),
RecvPropFloat (RECVINFO(m_flPlaybackRate)),
RecvPropInt (RECVINFO(m_fEffects), 0, RecvProxy_EffectFlags ),
RecvPropInt (RECVINFO(m_nAnimationParity)),
RecvPropEHandle (RECVINFO(m_hWeapon), RecvProxy_Weapon ),
RecvPropEHandle (RECVINFO(m_hOwner)),
RecvPropInt( RECVINFO( m_nNewSequenceParity )),
RecvPropInt( RECVINFO( m_nResetEventsParity )),
RecvPropInt( RECVINFO( m_nMuzzleFlashParity )),
//RecvPropFloat(RECVINFO(tracerOrig_X)),
//RecvPropFloat(RECVINFO(tracerOrig_Y)),
//RecvPropFloat(RECVINFO(tracerOrig_Z)),
RecvPropBool(RECVINFO(m_bExpSighted)),
RecvPropBool(RECVINFO(m_bExpScope)),
RecvPropBool(RECVINFO(m_bIsLeg)),
RecvPropBool(RECVINFO(m_bDefRenderGroup)),
RecvPropBool(RECVINFO(IsNearWall)),
#if !defined( INVASION_DLL ) && !defined( INVASION_CLIENT_DLL )
RecvPropArray(RecvPropFloat(RECVINFO(m_flPoseParameter[0]) ), m_flPoseParameter ),
#endif
#endif
END_NETWORK_TABLE()
/*#ifndef CLIENT_DLL
BEGIN_PREDICTION_DATA(CBaseViewModel)
DEFINE_FIELD(m_bExpSighted, FIELD_BOOLEAN)
END_PREDICTION_DATA()
#endif*/
#ifdef CLIENT_DLL
BEGIN_PREDICTION_DATA( CBaseViewModel )
// Networked
DEFINE_PRED_FIELD( m_nModelIndex, FIELD_SHORT, FTYPEDESC_INSENDTABLE | FTYPEDESC_MODELINDEX ),
DEFINE_PRED_FIELD( m_nSkin, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nBody, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nSequence, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_nViewModelIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_flPlaybackRate, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.125f ),
DEFINE_PRED_FIELD( m_fEffects, FIELD_INTEGER, FTYPEDESC_INSENDTABLE | FTYPEDESC_OVERRIDE ),
DEFINE_PRED_FIELD( m_nAnimationParity, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_hWeapon, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_flAnimTime, FIELD_FLOAT, 0 ),
DEFINE_FIELD( m_hOwner, FIELD_EHANDLE ),
DEFINE_FIELD( m_flTimeWeaponIdle, FIELD_FLOAT ),
DEFINE_FIELD( m_Activity, FIELD_INTEGER ),
DEFINE_PRED_FIELD(m_bExpSighted, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE),
DEFINE_PRED_FIELD(m_bExpScope, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE),
DEFINE_PRED_FIELD(m_bIsLeg, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE),
DEFINE_PRED_FIELD(IsNearWall, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE),
DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
//DEFINE_PRED_FIELD(tracerOrig_X, FIELD_FLOAT, FTYPEDESC_INSENDTABLE),
//DEFINE_PRED_FIELD(tracerOrig_Y, FIELD_FLOAT, FTYPEDESC_INSENDTABLE),
//DEFINE_PRED_FIELD(tracerOrig_Z, FIELD_FLOAT, FTYPEDESC_INSENDTABLE),
END_PREDICTION_DATA()
void RecvProxy_SequenceNum( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
CBaseViewModel *model = (CBaseViewModel *)pStruct;
if (pData->m_Value.m_Int != model->GetSequence())
{
MDLCACHE_CRITICAL_SECTION();
model->SetSequence(pData->m_Value.m_Int);
model->m_flAnimTime = gpGlobals->curtime;
model->SetCycle(0);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBaseViewModel::LookupAttachment( const char *pAttachmentName )
{
if ( m_hWeapon.Get() && m_hWeapon.Get()->WantsToOverrideViewmodelAttachments() )
return m_hWeapon.Get()->LookupAttachment( pAttachmentName );
return BaseClass::LookupAttachment( pAttachmentName );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseViewModel::GetAttachment( int number, matrix3x4_t &matrix )
{
if ( m_hWeapon.Get() && m_hWeapon.Get()->WantsToOverrideViewmodelAttachments() )
return m_hWeapon.Get()->GetAttachment( number, matrix );
return BaseClass::GetAttachment( number, matrix );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseViewModel::GetAttachment( int number, Vector &origin )
{
if ( m_hWeapon.Get() && m_hWeapon.Get()->WantsToOverrideViewmodelAttachments() )
return m_hWeapon.Get()->GetAttachment( number, origin );
return BaseClass::GetAttachment( number, origin );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseViewModel::GetAttachment( int number, Vector &origin, QAngle &angles )
{
if ( m_hWeapon.Get() && m_hWeapon.Get()->WantsToOverrideViewmodelAttachments() )
return m_hWeapon.Get()->GetAttachment( number, origin, angles );
return BaseClass::GetAttachment( number, origin, angles );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBaseViewModel::GetAttachmentVelocity( int number, Vector &originVel, Quaternion &angleVel )
{
if ( m_hWeapon.Get() && m_hWeapon.Get()->WantsToOverrideViewmodelAttachments() )
return m_hWeapon.Get()->GetAttachmentVelocity( number, originVel, angleVel );
return BaseClass::GetAttachmentVelocity( number, originVel, angleVel );
}
#endif
Reference in New Issue View Git Blame Copy Permalink