BVB Source Codes

CRYENGINE Show VehicleDamageBehaviorIndicator.cpp Source code

Return Download CRYENGINE: download VehicleDamageBehaviorIndicator.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "VehicleDamageBehaviorIndicator.h"
  5.  
  6. #include "Vehicle.h"
  7.  
  8. // all damage lights use same min/max frequency for consistency
  9. float CVehicleDamageBehaviorIndicator::m_frequencyMin = 0.5f;
  10. float CVehicleDamageBehaviorIndicator::m_frequencyMax = 4.f;
  11.  
  12. //------------------------------------------------------------------------
  13. CVehicleDamageBehaviorIndicator::CVehicleDamageBehaviorIndicator()
  14.         : m_pVehicle(nullptr)
  15.         , m_isActive(false)
  16.         , m_ratioMin(1.0f)
  17.         , m_ratioMax(1.0f)
  18.         , m_currentDamageRatio(0.0f)
  19.         , m_pSubMtl(nullptr)
  20.         , m_soundRatioMin(1.0f)
  21.         , m_pHelper(nullptr)
  22.         , m_soundsPlayed(0)
  23.         , m_lastDamageRatio(0.0f)
  24.         , m_lightUpdate(0.0f)
  25.         , m_lightTimer(0.0f)
  26.         , m_lightOn(false)
  27. {}
  28.  
  29. //------------------------------------------------------------------------
  30. bool CVehicleDamageBehaviorIndicator::Init(IVehicle* pVehicle, const CVehicleParams& table)
  31. {
  32.         m_pVehicle = (CVehicle*) pVehicle;
  33.  
  34.         table.getAttr("damageRatioMin", m_ratioMin);
  35.  
  36.         CVehicleParams indicatorParams = table.findChild("Indicator");
  37.         if (!indicatorParams)
  38.                 return false;
  39.  
  40.         if (CVehicleParams params = indicatorParams.findChild("Light"))
  41.         {
  42.                 m_material = params.getAttr("material");
  43.                 m_sound = params.getAttr("sound");
  44.                 m_sound.MakeLower();
  45.  
  46.                 m_soundRatioMin = m_ratioMin;
  47.                 params.getAttr("soundRatioMin", m_soundRatioMin);
  48.  
  49.                 if (params.haveAttr("helper"))
  50.                 {
  51.                         m_pHelper = m_pVehicle->GetHelper(params.getAttr("helper"));
  52.                 }
  53.         }
  54.  
  55.         return true;
  56. }
  57.  
  58. //------------------------------------------------------------------------
  59. void CVehicleDamageBehaviorIndicator::Reset()
  60. {
  61.         m_currentDamageRatio = 0.f;
  62.         m_lastDamageRatio = 0.f;
  63.         m_soundsPlayed = 0;
  64.         m_lightOn = false;
  65.  
  66.         EnableLight(false);
  67.  
  68.         if (m_isActive)
  69.         {
  70.                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  71.                 m_isActive = false;
  72.         }
  73. }
  74.  
  75. //------------------------------------------------------------------------
  76. void CVehicleDamageBehaviorIndicator::SetActive(bool activate)
  77. {
  78.         if (activate && !m_isActive)
  79.         {
  80.                 if (!m_pSubMtl && m_frequencyMin > 0.f)
  81.                 {
  82.                         // first time, get material
  83.                         GetMaterial();
  84.                 }
  85.  
  86.                 if (m_pSubMtl || !m_sound.empty())
  87.                 {
  88.                         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  89.                         m_isActive = true;
  90.                 }
  91.  
  92.                 m_soundsPlayed = 0;
  93.         }
  94.         else if (!activate && m_isActive)
  95.         {
  96.                 m_isActive = false;
  97.                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  98.         }
  99. }
  100.  
  101. //------------------------------------------------------------------------
  102. void CVehicleDamageBehaviorIndicator::EnableLight(bool enable)
  103. {
  104.         if (m_pSubMtl)
  105.         {
  106.                 float glow = (enable) ? 1.f : 0.f;
  107.                 m_pSubMtl->SetGetMaterialParamFloat("emissive_intensity", glow, false);
  108.         }
  109.  
  110.         m_lightOn = enable;
  111. }
  112.  
  113. //------------------------------------------------------------------------
  114. void CVehicleDamageBehaviorIndicator::OnDamageEvent(EVehicleDamageBehaviorEvent event, const SVehicleDamageBehaviorEventParams& behaviorParams)
  115. {
  116.         if (event == eVDBE_Hit || event == eVDBE_Repair)
  117.         {
  118.                 if (behaviorParams.componentDamageRatio >= m_ratioMin && behaviorParams.componentDamageRatio < m_ratioMax)
  119.                 {
  120.                         if (!m_isActive)
  121.                         {
  122.                                 SetActive(true);
  123.                         }
  124.  
  125.                         if (m_isActive && behaviorParams.componentDamageRatio != m_currentDamageRatio)
  126.                         {
  127.                                 m_currentDamageRatio = behaviorParams.componentDamageRatio;
  128.  
  129.                                 float ratio = (m_currentDamageRatio - m_ratioMin) / (m_ratioMax - m_ratioMin);
  130.                                 CRY_ASSERT(ratio >= 0.f && ratio <= 1.f);
  131.                                 m_lightUpdate = 0.5f / (m_frequencyMin + ratio * (m_frequencyMax - m_frequencyMin));
  132.                         }
  133.                 }
  134.                 else
  135.                 {
  136.                         bool glow = false;
  137.  
  138.                         if (behaviorParams.componentDamageRatio >= m_ratioMax)
  139.                         {
  140.                                 // set steady glow
  141.                                 glow = true;
  142.  
  143.                                 if (!m_isActive)
  144.                                 {
  145.                                         SetActive(true);
  146.                                 }
  147.                         }
  148.  
  149.                         EnableLight(glow);
  150.  
  151.                         // disable
  152.                         SetActive(false);
  153.                 }
  154.         }
  155. }
  156.  
  157. //------------------------------------------------------------------------
  158. void CVehicleDamageBehaviorIndicator::Update(const float deltaTime)
  159. {
  160.         if (m_isActive && m_lightUpdate > 0.f && m_pVehicle->IsPlayerPassenger())
  161.         {
  162.                 m_lightTimer += deltaTime;
  163.  
  164.                 if (m_lightTimer >= 2.f * m_lightUpdate)
  165.                 {
  166.                         // off
  167.                         EnableLight(false);
  168.                         m_lightTimer = 0.f;
  169.                 }
  170.                 else if (!m_lightOn && m_lightTimer >= m_lightUpdate)
  171.                 {
  172.                         // on
  173.                         EnableLight(true);
  174.                         REINST("report damage ratio?");
  175.                         //      if (!m_sound.empty() && m_currentDamageRatio >= m_soundRatioMin)
  176.                         //      {
  177.                         //        IEntityAudioComponent* pIEntityAudioComponent = m_pVehicle->GetEntity()->GetComponent<IEntityAudioComponent>();
  178.                         //        if (pIEntityAudioComponent)
  179.                         //        {
  180.                         //          if (m_lastDamageRatio != m_currentDamageRatio)
  181.                         //            m_soundsPlayed = 0;
  182.                         //          else
  183.                         //            ++m_soundsPlayed;
  184.                         //
  185.                         //          /*if (ISound* pSound = pIEntityAudioComponent->GetSound(m_soundId))
  186.                         //          {
  187.                         //            if (pSound->IsPlaying())
  188.                         //              pSound->Stop();
  189.                         //          } */
  190.                         //
  191.                         //          Vec3 offset(ZERO);
  192.                         //
  193.                         //          if (m_pHelper)
  194.                         //                                              offset = m_pHelper->GetVehicleSpaceTranslation();
  195.                         //
  196.                         //         m_soundId = pIEntityAudioComponent->PlaySound(m_sound.c_str(), offset, Vec3Constants<float>::fVec3_OneY, FLAG_SOUND_DEFAULT_3D, 0, eSoundSemantic_Vehicle);
  197.                         //
  198.                         //          const int nSoundsMaxVol = 6;
  199.                         //          const int nSoundsMinVol = 10;
  200.                         ////          const static float fMinVol = 0.5f;
  201.                         //
  202.                         //          if (m_soundsPlayed > nSoundsMaxVol)
  203.                         //          {
  204.                         //            // reduce volume after n sounds
  205.                         //            if (ISound* pSound = pIEntityAudioComponent->GetSound(m_soundId))
  206.                         //            {
  207.                         //              float vol = 1.f - 0.5f*min(1.f, float(m_soundsPlayed-nSoundsMaxVol)/float(nSoundsMinVol-nSoundsMaxVol));
  208.                         //              pSound->GetInterfaceExtended()->SetVolume(vol);
  209.                         //            }
  210.                         //          }
  211.                         //        }
  212.                         //      }
  213.                 }
  214.                 m_lastDamageRatio = m_currentDamageRatio;
  215.         }
  216. }
  217.  
  218. //------------------------------------------------------------------------
  219. void CVehicleDamageBehaviorIndicator::GetMaterial()
  220. {
  221.         if (!m_material.empty())
  222.         {
  223.                 IEntityRender* pIEntityRender = m_pVehicle->GetEntity()->GetRenderInterface();
  224.                
  225.                 {
  226.                         // use slot 0 here. if necessary, part can be added as attribute
  227.                         IMaterial* pMtl = pIEntityRender->GetRenderMaterial(0);
  228.                         if (pMtl)
  229.                         {
  230.                                 for (int i = 0; i < pMtl->GetSubMtlCount(); ++i)
  231.                                 {
  232.                                         IMaterial* pSubMtl = pMtl->GetSubMtl(i);
  233.                                         if (pSubMtl && 0 == _stricmp(pSubMtl->GetName(), m_material.c_str()))
  234.                                         {
  235.                                                 m_pSubMtl = pSubMtl;
  236.                                                 break;
  237.                                         }
  238.                                 }
  239.                         }
  240.                 }
  241.         }
  242. }
  243.  
  244. //------------------------------------------------------------------------
  245. void CVehicleDamageBehaviorIndicator::Serialize(TSerialize ser, EEntityAspects aspects)
  246. {
  247.         if (ser.GetSerializationTarget() != eST_Network)
  248.         {
  249.                 bool active = m_isActive;
  250.                 ser.Value("isActive", m_isActive);
  251.  
  252.                 if (active != m_isActive)
  253.                         SetActive(m_isActive);
  254.  
  255.                 ser.Value("damageRatio", m_currentDamageRatio);
  256.                 ser.Value("nSoundsPlayed", m_soundsPlayed);
  257.                 ser.Value("lastRatio", m_lastDamageRatio);
  258.                 ser.Value("lightTimer", m_lightTimer);
  259.  
  260.                 bool light = m_lightOn;
  261.                 ser.Value("lightOn", light);
  262.  
  263.                 if (ser.IsReading())
  264.                 {
  265.                         if (light != m_lightOn)
  266.                                 EnableLight(light);
  267.                 }
  268.         }
  269. }
  270.  
  271. void CVehicleDamageBehaviorIndicator::GetMemoryUsage(ICrySizer* s) const
  272. {
  273.         s->AddObject(this, sizeof(*this));
  274.         s->AddObject(m_material);
  275. }
  276.  
  277. DEFINE_VEHICLEOBJECT(CVehicleDamageBehaviorIndicator);
  278.  
downloadVehicleDamageBehaviorIndicator.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