BVB Source Codes

CRYENGINE Show VehicleViewBase.cpp Source code

Return Download CRYENGINE: download VehicleViewBase.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Implements a base class for the vehicle views
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 06:07:2006: Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15.  
  16. #include <CryAnimation/ICryAnimation.h>
  17. #include "IViewSystem.h"
  18. #include "IVehicleSystem.h"
  19. #include "VehicleViewBase.h"
  20. #include "VehicleSeat.h"
  21. #include "Vehicle.h"
  22. #include "VehiclePartBase.h"
  23.  
  24. #define SEND_ACTION(aamVar, actionId, value)            \
  25.   {                                                     \
  26.     pMovement->OnAction(actionId, eAAM_OnPress, value); \
  27.     aamVar = eAAM_OnPress;                              \
  28.   }
  29.  
  30. #define RELEASE_ACTION(aamVar, actionId)                   \
  31.   {                                                        \
  32.     if (aamVar == eAAM_OnPress)                            \
  33.     {                                                      \
  34.       pMovement->OnAction(actionId, eAAM_OnRelease, 0.0f); \
  35.       aamVar = eAAM_OnRelease;                             \
  36.     }                                                      \
  37.   }
  38.  
  39. //------------------------------------------------------------------------
  40. CVehicleViewBase::CVehicleViewBase()
  41.         : m_pVehicle(nullptr)
  42.         , m_pSeat(nullptr)
  43.         , m_isRotating(false)
  44.         , m_relaxDelayMax(0.0f)
  45.         , m_relaxTimeMax(0.0f)
  46.         , m_velLenMin(0.0f)
  47.         , m_velLenMax(0.0f)
  48.         , m_isSendingActionOnRotation(false)
  49.         , m_rotationBoundsActionMult(0.0f)
  50.         , m_rotationValRateX(0.0f)
  51.         , m_rotationValRateZ(0.0f)
  52.         , m_rotationTimeAcc(0.0f)
  53.         , m_rotationTimeDec(0.0f)
  54.         , m_isRelaxEnabled(false)
  55.         , m_relaxDelay(0.0f)
  56.         , m_relaxTime(0.0f)
  57.         , m_yawLeftActionOnBorderAAM(0)
  58.         , m_yawRightActionOnBorderAAM(0)
  59.         , m_pitchUpActionOnBorderAAM(0)
  60.         , m_pitchDownActionOnBorderAAM(0)
  61.         , m_pitchVal(0.0f)
  62.         , m_yawVal(0.0f)
  63.         , m_hidePlayer(false)
  64.         , m_isEnabled(true)
  65.         , m_isDebugView(false)
  66.         , m_isAvailableRemotely(false)
  67.         , m_playerViewThirdOnExit(false)
  68. {
  69. }
  70.  
  71. //------------------------------------------------------------------------
  72. bool CVehicleViewBase::Init(IVehicleSeat* pSeat, const CVehicleParams& table)
  73. {
  74.         m_pSeat = static_cast<CVehicleSeat*>(pSeat);
  75.         m_pVehicle = pSeat->GetVehicle();
  76.         m_rotationInit.zero();
  77.  
  78.         if (table.getAttr("rotationBoundsActionMult", m_rotationBoundsActionMult) && !iszero(m_rotationBoundsActionMult))
  79.                 m_isSendingActionOnRotation = true;
  80.         else
  81.         {
  82.                 m_isSendingActionOnRotation = false;
  83.                 m_rotationBoundsActionMult = 0.0f;
  84.         }
  85.  
  86.         if (table.getAttr("rotationMax", m_rotationMax))
  87.         {
  88.                 m_rotationMax = DEG2RAD(m_rotationMax);
  89.  
  90.                 if (table.getAttr("rotationMin", m_rotationMin))
  91.                         m_rotationMin = DEG2RAD(m_rotationMin);
  92.                 else
  93.                         m_rotationMin = -m_rotationMax;
  94.         }
  95.         else
  96.         {
  97.                 m_rotationMax.zero();
  98.                 m_rotationMin.zero();
  99.         }
  100.  
  101.         if (!table.getAttr("delayTimeMax", m_relaxDelayMax))
  102.                 m_relaxDelayMax = 0.3f;
  103.  
  104.         if (!table.getAttr("relaxTimeMax", m_relaxTimeMax))
  105.                 m_relaxTimeMax = 0.4f;
  106.  
  107.         if (table.getAttr("rotationInit", m_rotationInit))
  108.                 m_rotationInit = DEG2RAD(m_rotationInit);
  109.  
  110.         if (!table.getAttr("canRotate", m_isRotating))
  111.                 m_isRotating = false;
  112.  
  113.         if (table.getAttr("rotationVelMax", m_velLenMax))
  114.         {
  115.                 if (!table.getAttr("rotationVelMin", m_velLenMin))
  116.                         m_velLenMin = m_velLenMax;
  117.         }
  118.         else
  119.         {
  120.                 m_velLenMax = 1.0f;
  121.                 m_velLenMin = 1.0f;
  122.         }
  123.  
  124.         if (!table.getAttr("rotationTimeAcc", m_rotationTimeAcc))
  125.                 m_rotationTimeAcc = 0;
  126.         if (!table.getAttr("rotationTimeDec", m_rotationTimeDec))
  127.                 m_rotationTimeDec = 0;
  128.  
  129.         if (m_velLenMax == m_velLenMin)
  130.                 m_velLenMax += 1.0f;
  131.  
  132.         m_rotation = Ang3(ZERO);
  133.  
  134.         if (!IsThirdPerson())
  135.         {
  136.                 if (m_rotationMax.IsZero())
  137.                 {
  138.                         m_rotationMax.x = DEG2RAD(85.0f);
  139.                         m_rotationMax.y = DEG2RAD(0.0f);
  140.                         m_rotationMax.z = DEG2RAD(85.0f);
  141.                 }
  142.         }
  143.  
  144.         if (m_rotationMin.IsZero() && !m_rotationMax.IsZero())
  145.                 m_rotationMin = -m_rotationMax;
  146.  
  147.         m_viewAngleOffset.Set(0.f, 0.f, 0.f);
  148.  
  149.         if (!table.getAttr("hidePlayer", m_hidePlayer))
  150.                 m_hidePlayer = false;
  151.  
  152.         table.getAttr("isAvailableRemotely", m_isAvailableRemotely);
  153.         m_isRelaxEnabled = false;
  154.         table.getAttr("relaxEnabled", m_isRelaxEnabled);
  155.  
  156.         if (CVehicleParams hideTable = table.findChild("HideParts"))
  157.         {
  158.                 int i = 0;
  159.                 int c = hideTable.getChildCount();
  160.  
  161.                 for (; i < c; i++)
  162.                 {
  163.                         CVehicleParams partRef = hideTable.getChild(i);
  164.                         m_hideParts.push_back(partRef.getAttr("value"));
  165.                 }
  166.         }
  167.  
  168.         return true;
  169. }
  170.  
  171. //------------------------------------------------------------------------
  172. bool CVehicleViewBase::Init(CVehicleSeat* pSeat)
  173. {
  174.         m_pSeat = pSeat;
  175.         m_pVehicle = pSeat->GetVehicle();
  176.  
  177.         m_isSendingActionOnRotation = false;
  178.         m_rotationBoundsActionMult = 0.0f;
  179.  
  180.         m_isRotating = true;
  181.         m_isRelaxEnabled = false;
  182.         m_relaxDelayMax = 0.0f;
  183.         m_relaxTimeMax = 0.0f;
  184.  
  185.         m_rotationMax.zero();
  186.         m_rotationMin.zero();
  187.  
  188.         m_velLenMax = 2.0f;
  189.         m_velLenMin = 1.0f;
  190.  
  191.         m_rotation = Ang3(ZERO);
  192.         m_rotationInit.zero();
  193.  
  194.         m_rotationCurrentSpeed.zero();
  195.  
  196.         m_viewAngleOffset.Set(0.f, 0.f, 0.f);
  197.         m_hidePlayer = false;
  198.         m_rotationValRateX = m_rotationValRateZ = 0;
  199.  
  200.         return true;
  201. }
  202.  
  203. //------------------------------------------------------------------------
  204. void CVehicleViewBase::Reset()
  205. {
  206.         m_rotatingAction.zero();
  207.         m_rotationCurrentSpeed.zero();
  208.         m_rotationValRateX = m_rotationValRateZ = 0;
  209.         m_rotation = Ang3(m_rotationInit);
  210.         m_viewAngleOffset.Set(0.f, 0.f, 0.f);
  211.  
  212.         m_relaxTime = 0.0f;
  213.         m_relaxDelay = 0.0f;
  214. }
  215.  
  216. //------------------------------------------------------------------------
  217. void CVehicleViewBase::OnStartUsing(EntityId playerId)
  218. {
  219.         //if (VehicleCVars().v_debugdraw == eVDB_View)
  220.         //CryLog("StartUsing: %s %s", m_pSeat->GetName().c_str(), IsThirdPerson()?"(tp)":"");
  221.  
  222.         Reset();
  223.  
  224.         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  225.  
  226.         IActor* pActor = m_pSeat->GetPassengerActor(true);
  227.         if (pActor)
  228.         {
  229.                 if (!m_pSeat->IsRemoteControlled())
  230.                 {
  231.                         m_playerViewThirdOnExit = pActor->IsThirdPerson();
  232.                         if (pActor->IsThirdPerson() != this->IsThirdPerson())
  233.                         {
  234.                                 pActor->ToggleThirdPerson();
  235.                         }
  236.                 }
  237.                 else
  238.                 {
  239.                         //remote control vehicles should make the actor third person
  240.                         if (!pActor->IsThirdPerson())
  241.                         {
  242.                                 pActor->ToggleThirdPerson();
  243.                         }
  244.                 }
  245.         }
  246.  
  247.         // hide vehicle parts we don't want to see. NB there is a hide-count in vehicle part base, so we can safely
  248.         // hide and unhide from here without upsetting anything
  249.         for (int i = 0; i < m_hideParts.size(); ++i)
  250.         {
  251.                 if (CVehiclePartBase* pPart = static_cast<CVehiclePartBase*>(m_pVehicle->GetPart(m_hideParts[i].c_str())))
  252.                 {
  253.                         pPart->Hide(true);
  254.                 }
  255.         }
  256. }
  257.  
  258. //------------------------------------------------------------------------
  259. void CVehicleViewBase::OnStopUsing()
  260. {
  261.         //if (VehicleCVars().v_debugdraw == eVDB_View)
  262.         //CryLog("StopUsing: %s %s", m_pSeat->GetName().c_str(), IsThirdPerson()?"(tp)":"");
  263.  
  264.         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  265.  
  266.         IVehicleMovement* pMovement = m_pVehicle->GetMovement();
  267.  
  268. #define CLEAR_ACTION(aamvar, actionid)                          \
  269.   if (aamvar == eAAM_OnPress)                                   \
  270.   {                                                             \
  271.     aamvar = eAAM_OnRelease;                                    \
  272.     if (pMovement) pMovement->OnAction(actionid, aamvar, 0.0f); \
  273.   }
  274.  
  275.         CLEAR_ACTION(m_yawLeftActionOnBorderAAM, eVAI_TurnLeft);
  276.         CLEAR_ACTION(m_yawRightActionOnBorderAAM, eVAI_TurnRight);
  277.         CLEAR_ACTION(m_pitchUpActionOnBorderAAM, eVAI_PitchUp);
  278.         CLEAR_ACTION(m_pitchDownActionOnBorderAAM, eVAI_PitchDown);
  279.  
  280.         m_pitchVal = 0.0f;
  281.         m_yawVal = 0.0f;
  282.  
  283.         // unhide vehicle parts we hid while using
  284.         for (int i = 0; i < m_hideParts.size(); ++i)
  285.         {
  286.                 if (CVehiclePartBase* pPart = static_cast<CVehiclePartBase*>(m_pVehicle->GetPart(m_hideParts[i].c_str())))
  287.                 {
  288.                         pPart->Hide(false);
  289.                 }
  290.         }
  291.  
  292.         // Reset the player's view mode to one used, when he got in the vehicle
  293.         IActor* pActor = m_pSeat->GetPassengerActor(true);
  294.         if (pActor)
  295.         {
  296.                 if (m_playerViewThirdOnExit != pActor->IsThirdPerson())
  297.                 {
  298.                         pActor->ToggleThirdPerson();
  299.                 }
  300.         }
  301. }
  302.  
  303. //------------------------------------------------------------------------
  304. void CVehicleViewBase::OnAction(const TVehicleActionId actionId, int activationMode, float value)
  305. {
  306.         if (actionId == eVAI_RotateYaw)
  307.         {
  308.                 m_rotatingAction.z += value;
  309.         }
  310.         else if (actionId == eVAI_RotatePitch)
  311.         {
  312.                 m_rotatingAction.x += value;
  313.         }
  314.         else if (actionId == eVAI_ViewOption)
  315.         {
  316.                 m_isRotating = !m_isRotating;
  317.                 m_isSendingActionOnRotation = !m_isSendingActionOnRotation;
  318.  
  319.                 if (!m_isSendingActionOnRotation)
  320.                 {
  321.                         m_yawVal = 0.0f;
  322.                         m_pitchVal = 0.0f;
  323.  
  324.                         if (m_pSeat->IsDriver())
  325.                         {
  326.                                 if (IVehicleMovement* pMovement = m_pVehicle->GetMovement())
  327.                                 {
  328.                                         RELEASE_ACTION(m_pitchDownActionOnBorderAAM, eVAI_PitchDown);
  329.                                         RELEASE_ACTION(m_pitchUpActionOnBorderAAM, eVAI_PitchUp);
  330.                                 }
  331.                         }
  332.                 }
  333.         }
  334. }
  335.  
  336. //------------------------------------------------------------------------
  337. void CVehicleViewBase::Update(const float frameTime)
  338. {
  339.         const float recenterSpeed = 4.25f;
  340.  
  341.         IActor* pActor = CCryAction::GetCryAction()->GetIActorSystem()->GetActor(m_pSeat->GetPassenger());
  342.         /*
  343.            if (false && pActor)
  344.             m_viewAngleOffset = Ang3(pActor->GetViewAngleOffset());
  345.          */
  346.         bool isRelaxWanted = (!iszero(m_rotationBoundsActionMult));
  347.         float rotMaxVelMult = 1.0f;
  348.  
  349.         if (!iszero(m_velLenMax) && !iszero(m_velLenMin))
  350.         {
  351.                 if (IPhysicalEntity* pPhysEntity = m_pVehicle->GetEntity()->GetPhysics())
  352.                 {
  353.                         pe_status_dynamics dyn;
  354.                         pPhysEntity->GetStatus(&dyn);
  355.  
  356.                         float velLen = dyn.v.GetLength2D();
  357.  
  358.                         if (velLen > m_velLenMin)
  359.                         {
  360.                                 rotMaxVelMult = (min(m_velLenMax, velLen) + (m_velLenMin - min(m_velLenMax, velLen)))
  361.                                                 / (m_velLenMax - m_velLenMin);
  362.  
  363.                                 rotMaxVelMult = min(1.0f, rotMaxVelMult);
  364.  
  365.                                 isRelaxWanted = true;
  366.                         }
  367.                 }
  368.         }
  369.  
  370.         Vec3 rotationMin;
  371.         Vec3 rotationMax;
  372.  
  373.         if (m_isRotating)
  374.         {
  375.                 rotationMin = m_rotationMin * rotMaxVelMult;
  376.                 rotationMax = m_rotationMax * rotMaxVelMult;
  377.  
  378.         }
  379.         else
  380.         {
  381.                 rotationMin.zero();
  382.                 rotationMax.zero();
  383.  
  384.                 if (!Vec3(m_rotation).IsZero())
  385.                 {
  386.                         m_rotation.x -= m_rotation.x * recenterSpeed * frameTime;
  387.                         m_rotation.y -= m_rotation.y * recenterSpeed * frameTime;
  388.                         m_rotation.z -= m_rotation.z * recenterSpeed * frameTime;
  389.                 }
  390.         }
  391.  
  392.         if (!m_rotatingAction.IsZero())
  393.         {
  394.                 float targetSpeedZ = m_rotatingAction.z;
  395.                 float targetSpeedX = m_rotatingAction.x;
  396.  
  397.                 SmoothCD(m_rotationCurrentSpeed.z, m_rotationValRateZ, frameTime, targetSpeedZ, m_rotationTimeAcc);
  398.                 SmoothCD(m_rotationCurrentSpeed.x, m_rotationValRateX, frameTime, targetSpeedX, m_rotationTimeAcc);
  399.         }
  400.         else
  401.         {
  402.                 SmoothCD(m_rotationCurrentSpeed.z, m_rotationValRateZ, frameTime, 0.f, m_rotationTimeDec);
  403.                 SmoothCD(m_rotationCurrentSpeed.x, m_rotationValRateX, frameTime, 0.f, m_rotationTimeDec);
  404.         }
  405.  
  406.         if (m_isRotating && !m_rotationCurrentSpeed.IsZero())
  407.         {
  408.  
  409.                 m_rotation.x -= m_rotationCurrentSpeed.x * frameTime;
  410.                 m_rotation.z -= m_rotationCurrentSpeed.z * frameTime;
  411.  
  412.                 if (!rotationMax.IsZero() && !rotationMin.IsZero())
  413.                 {
  414.                         m_rotation.x = min(max(m_rotation.x, rotationMin.x), rotationMax.x);
  415.                         m_rotation.z = min(max(m_rotation.z, rotationMin.z), rotationMax.z);
  416.                 }
  417.  
  418.                 m_relaxTime = 0.0f;
  419.                 m_relaxDelay = 0.0f;
  420.         }
  421.         else
  422.         {
  423.                 if (m_isRelaxEnabled && !Vec3(m_rotation).IsZero() && isRelaxWanted)
  424.                 {
  425.                         m_relaxDelay += frameTime;
  426.  
  427.                         if (m_relaxDelay > m_relaxDelayMax)
  428.                         {
  429.                                 m_relaxTime += frameTime;
  430.  
  431.                                 Ang3 m_subStraction = m_rotation;
  432.                                 float mult = min(2.0f, (m_relaxTime / m_relaxTimeMax));
  433.                                 m_subStraction *= mult;
  434.                                 m_subStraction *= frameTime;
  435.                                 m_rotation -= m_subStraction;
  436.                         }
  437.                 }
  438.         }
  439.  
  440.         IVehicleMovement* pMovement = NULL;
  441.         if (m_pSeat->IsDriver())
  442.                 pMovement = m_pVehicle->GetMovement();
  443.  
  444.         if (pMovement && m_isSendingActionOnRotation)
  445.         {
  446.                 if (m_rotation.z >= rotationMax.z && m_rotatingAction.z > 0.0f)
  447.                 {
  448.                         if (m_yawRightActionOnBorderAAM != eAAM_OnPress)
  449.                                 m_yawVal = 0.0f;
  450.  
  451.                         m_yawVal += m_rotationBoundsActionMult;
  452.                         if (m_rotation.z != 0.0f)
  453.                                 m_yawVal *= m_rotation.z / (m_rotation.x + m_rotation.z);
  454.  
  455.                         m_yawVal = min(m_yawVal, 1.0f);
  456.  
  457.                         RELEASE_ACTION(m_yawLeftActionOnBorderAAM, eVAI_TurnLeft);
  458.                         SEND_ACTION(m_yawRightActionOnBorderAAM, eVAI_TurnRight, m_yawVal);
  459.                 }
  460.                 else if (m_rotation.z <= rotationMin.z && m_rotatingAction.z < 0.0f)
  461.                 {
  462.                         if (m_yawLeftActionOnBorderAAM != eAAM_OnPress)
  463.                                 m_yawVal = 0.0f;
  464.  
  465.                         m_yawVal += m_rotationBoundsActionMult;
  466.                         if (m_rotation.z != 0.0f)
  467.                                 m_yawVal *= m_rotation.z / (m_rotation.x + m_rotation.z);
  468.  
  469.                         m_yawVal = min(m_yawVal, 1.0f);
  470.  
  471.                         RELEASE_ACTION(m_yawRightActionOnBorderAAM, eVAI_TurnRight);
  472.                         SEND_ACTION(m_yawLeftActionOnBorderAAM, eVAI_TurnLeft, m_yawVal);
  473.                 }
  474.                 else
  475.                 {
  476.                         m_yawVal = 0.0f;
  477.  
  478.                         RELEASE_ACTION(m_yawRightActionOnBorderAAM, eVAI_TurnRight);
  479.                         RELEASE_ACTION(m_yawLeftActionOnBorderAAM, eVAI_TurnLeft);
  480.                 }
  481.  
  482.                 if (m_rotation.x >= rotationMax.x && m_rotatingAction.x > 0.0f)
  483.                 {
  484.                         if (m_pitchDownActionOnBorderAAM != eAAM_OnPress)
  485.                                 m_pitchVal = 0.0f;
  486.  
  487.                         m_pitchVal += m_rotationBoundsActionMult;
  488.                         if (m_rotation.x != 0.0f)
  489.                                 m_pitchVal *= m_rotation.x / (m_rotation.x + m_rotation.z);
  490.  
  491.                         m_pitchVal = min(m_pitchVal, 1.0f);
  492.  
  493.                         RELEASE_ACTION(m_pitchUpActionOnBorderAAM, eVAI_PitchUp);
  494.                         SEND_ACTION(m_pitchDownActionOnBorderAAM, eVAI_PitchDown, m_pitchVal);
  495.                 }
  496.                 else if (m_rotation.x <= rotationMin.x && m_rotatingAction.x < 0.0f)
  497.                 {
  498.                         if (m_pitchUpActionOnBorderAAM != eAAM_OnPress)
  499.                                 m_pitchVal = 0.0f;
  500.  
  501.                         m_pitchVal += m_rotationBoundsActionMult;
  502.                         if (m_rotation.x != 0.0f)
  503.                                 m_pitchVal *= m_rotation.x / (m_rotation.x + m_rotation.z);
  504.  
  505.                         m_pitchVal = min(m_pitchVal, 1.0f);
  506.  
  507.                         RELEASE_ACTION(m_pitchDownActionOnBorderAAM, eVAI_PitchDown);
  508.                         SEND_ACTION(m_pitchUpActionOnBorderAAM, eVAI_PitchUp, m_pitchVal);
  509.                 }
  510.                 else
  511.                 {
  512.                         m_yawVal = 0.0f;
  513.                         m_pitchVal = 0.0f;
  514.  
  515.                         RELEASE_ACTION(m_pitchDownActionOnBorderAAM, eVAI_PitchDown);
  516.                         RELEASE_ACTION(m_pitchUpActionOnBorderAAM, eVAI_PitchUp);
  517.                 }
  518.         }
  519.  
  520.         m_rotatingAction.zero();
  521. }
  522.  
  523. //------------------------------------------------------------------------
  524. void CVehicleViewBase::Serialize(TSerialize serialize, EEntityAspects aspects)
  525. {
  526.         if (serialize.GetSerializationTarget() != eST_Network)
  527.         {
  528.                 serialize.Value("rotation", m_rotation);
  529.         }
  530. }
  531.  
downloadVehicleViewBase.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top