BVB Source Codes

CRYENGINE Show VehiclePartBase.cpp Source code

Return Download CRYENGINE: download VehiclePartBase.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 vehicle parts
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 23:08:2005: Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15.  
  16. #include <CryAnimation/ICryAnimation.h>
  17. #include "CryAction.h"
  18. #include "Vehicle.h"
  19. #include "VehiclePartBase.h"
  20. #include "VehicleComponent.h"
  21. #include "VehicleSeat.h"
  22. #include "VehicleSeatSerializer.h"
  23. #include "VehicleUtils.h"
  24. #include "PersistantDebug.h"
  25.  
  26. DEFINE_SHARED_PARAMS_TYPE_INFO(CVehiclePartBase::SSharedParams_Parts)
  27.  
  28. const char* CVehiclePartBase::ms_geometryDestroyedSuffixes[eVGS_Last] =
  29. {
  30.         "",
  31.         "_damaged_1",
  32.         "_damaged"
  33. };
  34.  
  35. const char* CVehiclePartBase::ms_nullGeometryDestroyedSuffix = "";
  36.  
  37. // Suppressed uninitMemberVar warnings due to use of BEGIN_SHARED_PARAMS macro
  38. // cppcheck-suppress uninitMemberVar
  39. CVehiclePartBase::CVehiclePartBase()
  40.         : m_pVehicle(nullptr)
  41.         , m_pParentPart(nullptr)
  42.         , m_pClonedMaterial(nullptr)
  43.         , m_physId(-1)
  44.         , m_state(eVGS_Last)
  45.         , m_hideMode(eVPH_NoFade)
  46.         , m_hideCount(0)
  47.         , m_slot(-1)
  48.         , m_users(0)
  49.         , m_isRotationBlocked(false)
  50.         , m_damageRatio(0.0f)
  51.         , m_hideTimeMax(0.0f)
  52.         , m_hideTimeCount(0.0f)
  53.         , m_index(-1)
  54. {}
  55.  
  56. //------------------------------------------------------------------------
  57. CVehiclePartBase::~CVehiclePartBase()
  58. {
  59. }
  60.  
  61. //------------------------------------------------------------------------
  62. bool CVehiclePartBase::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* pParent, CVehicle::SPartInitInfo& initInfo, int partType)
  63. {
  64.         m_pVehicle = (CVehicle*) pVehicle;
  65.  
  66.         if (!RegisterSharedParameters(pVehicle, table, partType))
  67.                 return false;
  68.  
  69.         bool hidden = false;
  70.         table.getAttr("isHidden", hidden);
  71.         m_hideCount = (hidden == true) ? 1 : 0;
  72.  
  73.         reinterpret_cast<CVehicle*>(pVehicle)->m_mass += m_pSharedParameters->m_mass;
  74.  
  75.         m_pParentPart = pParent;
  76.  
  77.         if (pParent)
  78.                 pParent->AddChildPart(this);
  79.  
  80.         string component = table.getAttr("component");
  81.         if (!component.empty())
  82.                 initInfo.partComponentMap.push_back(CVehicle::SPartComponentPair(this, component));
  83.  
  84.         // read optional multiple components (part->component relationship is now 1:n)
  85.         if (CVehicleParams components = table.findChild("Components"))
  86.         {
  87.                 int i = 0;
  88.                 int c = components.getChildCount();
  89.  
  90.                 for (; i < c; i++)
  91.                 {
  92.                         CVehicleParams componentRef = components.getChild(i);
  93.                         initInfo.partComponentMap.push_back(CVehicle::SPartComponentPair(this, componentRef.getAttr("value")));
  94.                 }
  95.         }
  96.  
  97.         string filename = table.getAttr("filename");
  98.         if (!filename.empty())
  99.         {
  100.                 if (filename.find("."))
  101.                         m_slot = GetEntity()->LoadGeometry(m_slot, filename);
  102.                 else
  103.                         m_slot = GetEntity()->LoadCharacter(m_slot, filename);
  104.         }
  105.  
  106.         m_isRotationBlocked = false;
  107.  
  108.         m_index = initInfo.index;
  109.  
  110.         return true;
  111. }
  112.  
  113. //------------------------------------------------------------------------
  114.  
  115. namespace
  116. {
  117. void CheckLowSpecFile(string& filename)
  118. {
  119.         // try to load _low asset on lowspec
  120.  
  121.         size_t dot = filename.rfind('.');
  122.         if (dot != ~0)
  123.         {
  124.                 string stripped = filename.substr(0, dot);
  125.                 string suffix = filename.substr(dot);
  126.  
  127.                 string lowspecFile = stripped + "_low" + suffix;
  128.  
  129.                 if (FILE* pFile = gEnv->pCryPak->FOpen(lowspecFile.c_str(), "rbx"))
  130.                 {
  131.                         filename = lowspecFile;
  132.                         gEnv->pCryPak->FClose(pFile);
  133.  
  134.                         CryLog("using lowspec file %s", lowspecFile.c_str());
  135.                 }
  136.         }
  137. }
  138. }
  139.  
  140. //------------------------------------------------------------------------
  141. bool CVehiclePartBase::RegisterSharedParameters(IVehicle* pVehicle, const CVehicleParams& table, int partType)
  142. {
  143.         string name = table.getAttr("name");
  144.         if (name.empty())
  145.                 return false;
  146.  
  147.         string sharedParamsName = pVehicle->GetEntity()->GetClass()->GetName();
  148.         const char* pModification = pVehicle->GetModification();
  149.         if (pModification != 0 && strlen(pModification))
  150.         {
  151.                 sharedParamsName.append("::");
  152.  
  153.                 sharedParamsName.append(pModification);
  154.         }
  155.         sharedParamsName.append("::Part::");
  156.         sharedParamsName.append(name);
  157.  
  158.         ISharedParamsManager* pSharedParamsManager = CCryAction::GetCryAction()->GetISharedParamsManager();
  159.  
  160.         CRY_ASSERT(pSharedParamsManager);
  161.  
  162.         m_pSharedParameters = CastSharedParamsPtr<SSharedParams_Parts>(pSharedParamsManager->Get(sharedParamsName));
  163.  
  164.         if (!m_pSharedParameters)
  165.         {
  166.                 SSharedParams_Parts sharedParams;
  167.  
  168.                 // read shared parameters from xml
  169.                 sharedParams.m_typeId = partType;
  170.  
  171.                 // base
  172.                 sharedParams.m_name = table.getAttr("name");
  173.                 table.getAttr("disableCollision", sharedParams.m_disableCollision);
  174.                 sharedParams.m_helperPosName = table.getAttr("helper");
  175.                 table.getAttr("position", sharedParams.m_position);
  176.                 table.getAttr("useOption", sharedParams.m_useOption);
  177.                 table.getAttr("mass", sharedParams.m_mass);
  178.                 table.getAttr("density", sharedParams.m_density);
  179.  
  180.                 if (table.getAttr("disablePhysics", sharedParams.m_isPhysicalized))
  181.                         sharedParams.m_isPhysicalized = !sharedParams.m_isPhysicalized;
  182.  
  183.                 // animated
  184.                 CVehicleParams animatedTable = table.findChild("Animated");
  185.                 if (animatedTable)
  186.                 {
  187.                         sharedParams.m_filename = animatedTable.getAttr("filename");
  188.                         if (!sharedParams.m_filename.empty())
  189.                         {
  190.                                 sharedParams.m_filenameDestroyed = animatedTable.getAttr("filenameDestroyed");
  191.                                 if (sharedParams.m_filenameDestroyed.empty())
  192.                                         sharedParams.m_filenameDestroyed = sharedParams.m_filename;
  193.  
  194.                                 if (VehicleCVars().v_vehicle_quality == 1)
  195.                                 {
  196.                                         CheckLowSpecFile(sharedParams.m_filename);
  197.                                         CheckLowSpecFile(sharedParams.m_filenameDestroyed);
  198.                                 }
  199.                         }
  200.                         else
  201.                         {
  202.                                 return false;
  203.                         }
  204.  
  205.                         if (animatedTable.haveAttr("destroyedSuffix"))
  206.                                 sharedParams.m_destroyedSuffix = animatedTable.getAttr("destroyedSuffix");
  207.                         else
  208.                                 sharedParams.m_destroyedSuffix.clear();
  209.                 }
  210.  
  211.                 // animated joint
  212.                 CVehicleParams animatedJointTable = table.findChild("AnimatedJoint");
  213.                 if (animatedJointTable)
  214.                 {
  215.                         animatedJointTable.getAttr("detachBaseForce", sharedParams.m_detachBaseForce);
  216.                         animatedJointTable.getAttr("detachProbability", sharedParams.m_detachProbability);
  217.                 }
  218.  
  219.                 // wheel
  220.                 CVehicleParams subTable = table.findChild("SubPartWheel");
  221.                 if (subTable)
  222.                 {
  223.                         subTable.getAttr("suspLength", sharedParams.m_suspLength);
  224.                         subTable.getAttr("slipFrictionMod", sharedParams.m_slipFrictionMod);
  225.                         subTable.getAttr("slipSlope", sharedParams.m_slipSlope);
  226.                         subTable.getAttr("rimRadius", sharedParams.m_rimRadius);
  227.                         subTable.getAttr("torqueScale", sharedParams.m_torqueScale);
  228.  
  229.                         sharedParams.m_wheelIndex = pVehicle->GetWheelCount();
  230.                 }
  231.  
  232.                 // register the read params
  233.                 m_pSharedParameters = CastSharedParamsPtr<SSharedParams_Parts>(pSharedParamsManager->Register(sharedParamsName, sharedParams));
  234.  
  235.                 CRY_ASSERT(m_pSharedParameters != 0);
  236.                 if (!m_pSharedParameters)
  237.                         return false;
  238.         }
  239.         else
  240.         {
  241.                 // additional check on requested part type
  242.                 CRY_ASSERT(m_pSharedParameters->m_typeId == partType);
  243.         }
  244.  
  245.         return true;
  246. }
  247.  
  248. //------------------------------------------------------------------------
  249. void CVehiclePartBase::PostInit()
  250. {
  251. }
  252.  
  253. //------------------------------------------------------------------------
  254. EntityId CVehiclePartBase::SpawnEntity()
  255. {
  256.         char pPartName[128];
  257.         cry_sprintf(pPartName, "%s_part_%s", m_pVehicle->GetEntity()->GetName(), GetName());
  258.  
  259.         SEntitySpawnParams params;
  260.         params.sName = pPartName;
  261.         params.nFlags = ENTITY_FLAG_CLIENT_ONLY;
  262.         params.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("VehiclePart");
  263.  
  264.         IEntity* pPartEntity = gEnv->pEntitySystem->SpawnEntity(params, true);
  265.         if (pPartEntity)
  266.         {
  267.                 if (m_pParentPart)
  268.                         m_pParentPart->GetEntity()->AttachChild(pPartEntity);
  269.                 else
  270.                         m_pVehicle->GetEntity()->AttachChild(pPartEntity);
  271.  
  272.                 pPartEntity->SetFlags(pPartEntity->GetFlags() | ENTITY_FLAG_CASTSHADOW);
  273.  
  274.                 return pPartEntity->GetId();
  275.         }
  276.  
  277.         CRY_ASSERT(0);
  278.         return 0;
  279. }
  280.  
  281. //------------------------------------------------------------------------
  282. IEntity* CVehiclePartBase::GetEntity()
  283. {
  284.         if (m_pParentPart)
  285.                 return m_pParentPart->GetEntity();
  286.         else
  287.                 return m_pVehicle->GetEntity();
  288. }
  289.  
  290. //------------------------------------------------------------------------
  291. void CVehiclePartBase::Release()
  292. {
  293.         delete this;
  294. }
  295.  
  296. //------------------------------------------------------------------------
  297. void CVehiclePartBase::Reset()
  298. {
  299.         m_damageRatio = 0.0f;
  300.  
  301.         ResetLocalTM(true);
  302.  
  303.         ChangeState(eVGS_Default);
  304. }
  305.  
  306. //------------------------------------------------------------------------
  307. void CVehiclePartBase::OnEvent(const SVehiclePartEvent& event)
  308. {
  309.         switch (event.type)
  310.         {
  311.         case eVPE_Damaged:
  312.                 {
  313.                         m_damageRatio = event.fparam;
  314.  
  315.                         const EVehiclePartState state = GetStateForDamageRatio(m_damageRatio);
  316.                         ChangeState(state, eVPSF_Physicalize);
  317.                 }
  318.                 break;
  319.         case eVPE_Repair:
  320.                 {
  321.                         float old = m_damageRatio;
  322.                         m_damageRatio = max(0.f, event.fparam);
  323.  
  324.                         if (eVPT_Base == GetType() && m_damageRatio <= COMPONENT_DAMAGE_LEVEL_RATIO && m_hideCount == 0)
  325.                                 Hide(false);
  326.  
  327.                         if (m_damageRatio <= COMPONENT_DAMAGE_LEVEL_RATIO && old > COMPONENT_DAMAGE_LEVEL_RATIO)
  328.                                 ChangeState(eVGS_Default, eVPSF_Physicalize);
  329.                 }
  330.                 break;
  331.         case eVPE_StartUsing:
  332.                 {
  333.                         m_users++;
  334.  
  335.                         if (m_users == 1)
  336.                         {
  337.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  338.                         }
  339.                 }
  340.                 break;
  341.         case eVPE_StopUsing:
  342.                 {
  343.                         if (m_users > 0)
  344.                                 --m_users;
  345.  
  346.                         if (m_users <= 0)
  347.                         {
  348.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  349.                         }
  350.                 }
  351.                 break;
  352.         case eVPE_GotDirty:
  353.                 break;
  354.         case eVPE_Fade:
  355.                 {
  356.                         if (event.bparam)
  357.                                 m_hideMode = eVPH_FadeOut;
  358.                         else
  359.                                 m_hideMode = eVPH_FadeIn;
  360.  
  361.                         m_hideTimeCount = event.fparam;
  362.                         m_hideTimeMax = event.fparam;
  363.  
  364.                         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  365.                 }
  366.                 break;
  367.         case eVPE_Hide:
  368.                 {
  369.                         Hide(event.bparam);
  370.                 }
  371.                 break;
  372.         case eVPE_BlockRotation:
  373.                 m_isRotationBlocked = event.bparam;
  374.                 break;
  375.         }
  376. }
  377.  
  378. //------------------------------------------------------------------------
  379. void CVehiclePartBase::Hide(bool hide)
  380. {
  381.         if (m_slot == -1)
  382.                 return;
  383.  
  384.         IEntity* pEntity = GetEntity();
  385.         if (!pEntity)
  386.                 return;
  387.  
  388.         if (hide)
  389.         {
  390.                 ++m_hideCount;
  391.  
  392.                 if (m_hideCount > 0)
  393.                         pEntity->SetSlotFlags(m_slot, pEntity->GetSlotFlags(m_slot) & ~ENTITY_SLOT_RENDER);
  394.         }
  395.         else
  396.         {
  397.                 --m_hideCount;
  398.  
  399.                 if (m_hideCount <= 0)
  400.                         pEntity->SetSlotFlags(m_slot, pEntity->GetSlotFlags(m_slot) | ENTITY_SLOT_RENDER);
  401.         }
  402. }
  403.  
  404. //------------------------------------------------------------------------
  405. IVehiclePart::EVehiclePartState CVehiclePartBase::GetMaxState()
  406. {
  407.         EVehiclePartState state = m_state;
  408.  
  409.         for (TVehicleChildParts::iterator it = m_children.begin(), end = m_children.end(); it != end; ++it)
  410.         {
  411.                 EVehiclePartState maxState = (*it)->GetMaxState();
  412.  
  413.                 if (maxState > state && maxState != eVGS_Last)
  414.                         state = maxState;
  415.         }
  416.  
  417.         return state;
  418. }
  419.  
  420. //------------------------------------------------------------------------
  421. IVehiclePart::EVehiclePartState CVehiclePartBase::GetStateForDamageRatio(float ratio)
  422. {
  423.         if (ratio >= 1.f && m_pVehicle->IsDestroyable())
  424.                 return m_pVehicle->IsDestroyed() ? eVGS_Destroyed : eVGS_Damaged1;
  425.  
  426.         return eVGS_Default;
  427. }
  428.  
  429. //------------------------------------------------------------------------
  430. bool CVehiclePartBase::ChangeState(EVehiclePartState state, int flags)
  431. {
  432.         if (state == m_state && !(flags & eVPSF_Force))
  433.                 return false;
  434.  
  435.         // once destroyed, we only allow to return to default state
  436.         if (m_state == eVGS_Destroyed && state != eVGS_Default && !(flags & eVPSF_Force))
  437.                 return false;
  438.  
  439.         if (eVPT_Base == GetType() && m_hideCount == 0)
  440.         {
  441.                 if (state == eVGS_Destroyed)
  442.                         Hide(true);
  443.                 else if (state == eVGS_Default)
  444.                         Hide(false);
  445.         }
  446.  
  447.         return true;
  448. }
  449.  
  450. //------------------------------------------------------------------------
  451. IStatObj* CVehiclePartBase::GetSubGeometry(CVehiclePartBase* pPart, EVehiclePartState state, Matrix34& position, bool removeFromParent)
  452. {
  453.         if (CVehiclePartBase* pParentPartBase = (CVehiclePartBase*) m_pParentPart)
  454.                 return pParentPartBase->GetSubGeometry(pPart, state, position, removeFromParent);
  455.         else
  456.                 return NULL;
  457. }
  458.  
  459. //------------------------------------------------------------------------
  460. void CVehiclePartBase::GetGeometryName(EVehiclePartState state, string& name)
  461. {
  462.         name = GetName();
  463.  
  464.         name += GetDestroyedGeometrySuffix(state);
  465. }
  466.  
  467. //------------------------------------------------------------------------
  468. const Matrix34& CVehiclePartBase::GetLocalTM(bool relativeToParentPart, bool forced)
  469. {
  470.         const Matrix34& tm = GetEntity()->GetSlotLocalTM(m_slot, relativeToParentPart);
  471.  
  472.         return VALIDATE_MAT(tm);
  473. }
  474.  
  475. //------------------------------------------------------------------------
  476. void CVehiclePartBase::SetLocalTM(const Matrix34& localTM)
  477. {
  478.         GetEntity()->SetSlotLocalTM(m_slot, localTM);
  479. }
  480.  
  481. //------------------------------------------------------------------------
  482. void CVehiclePartBase::ResetLocalTM(bool recursive)
  483. {
  484.         if (recursive)
  485.         {
  486.                 for (TVehicleChildParts::iterator it = m_children.begin(), end = m_children.end(); it != end; ++it)
  487.                         (*it)->ResetLocalTM(true);
  488.         }
  489. }
  490.  
  491. //------------------------------------------------------------------------
  492. const Matrix34& CVehiclePartBase::GetWorldTM()
  493. {
  494.         return VALIDATE_MAT(GetEntity()->GetSlotWorldTM(m_slot));
  495. }
  496.  
  497. //------------------------------------------------------------------------
  498. const Matrix34& CVehiclePartBase::LocalToVehicleTM(const Matrix34& localTM)
  499. {
  500.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  501.  
  502.         static Matrix34 tm;
  503.         tm = VALIDATE_MAT(localTM);
  504.  
  505.         IVehiclePart* pParent = GetParent();
  506.         while (pParent)
  507.         {
  508.                 tm = pParent->GetLocalTM(true) * tm;
  509.                 pParent = pParent->GetParent();
  510.         }
  511.  
  512.         return VALIDATE_MAT(tm);
  513. }
  514.  
  515. //------------------------------------------------------------------------
  516. const AABB& CVehiclePartBase::GetLocalBounds()
  517. {
  518.         if (m_slot == -1)
  519.         {
  520.                 m_bounds.Reset();
  521.         }
  522.         else
  523.         {
  524.  
  525.                 if (IStatObj* pStatObj = GetEntity()->GetStatObj(m_slot))
  526.                 {
  527.                         m_bounds = pStatObj->GetAABB();
  528.                         m_bounds.SetTransformedAABB(GetEntity()->GetSlotLocalTM(m_slot, false), m_bounds);
  529.                 }
  530.                 else if (ICharacterInstance* pCharInstance = GetEntity()->GetCharacter(m_slot))
  531.                 {
  532.                         m_bounds = pCharInstance->GetAABB();
  533.                         m_bounds.SetTransformedAABB(GetEntity()->GetSlotLocalTM(m_slot, false), m_bounds);
  534.                 }
  535.                 else
  536.                 {
  537.                         GetEntity()->GetLocalBounds(m_bounds);
  538.                 }
  539.         }
  540.  
  541.         return VALIDATE_AABB(m_bounds);
  542. }
  543.  
  544. //------------------------------------------------------------------------
  545. void CVehiclePartBase::Update(float frameTime)
  546. {
  547.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  548.  
  549.         if (m_hideMode != eVPH_NoFade)
  550.         {
  551.                 if (m_hideMode == eVPH_FadeIn)
  552.                 {
  553.                         m_hideTimeCount += frameTime;
  554.  
  555.                         if (m_hideTimeCount >= m_hideTimeMax)
  556.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  557.                 }
  558.                 else if (m_hideMode == eVPH_FadeOut)
  559.                 {
  560.                         m_hideTimeCount -= frameTime;
  561.  
  562.                         if (m_hideTimeCount <= 0.0f)
  563.                                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  564.                 }
  565.                 else
  566.                         CRY_ASSERT(0);
  567.  
  568.                 if (IMaterial* pMaterialMain = GetMaterial())
  569.                 {
  570.                         const float opacity = min(1.0f, max(0.0f, (m_hideTimeCount / m_hideTimeMax)));
  571.  
  572.                         if (IRenderShaderResources* pShaderRes = pMaterialMain->GetShaderItem().m_pShaderResources)
  573.                         {
  574.                                 pShaderRes->SetStrengthValue(EFTT_OPACITY, opacity);
  575.                         }
  576.  
  577.                         for (int i = 0; i < pMaterialMain->GetSubMtlCount(); i++)
  578.                         {
  579.                                 if (IMaterial* pMaterial = pMaterialMain->GetSubMtl(i))
  580.                                 {
  581.                                         if (IRenderShaderResources* pShaderRes = pMaterial->GetShaderItem().m_pShaderResources)
  582.                                         {
  583.                                                 pShaderRes->SetStrengthValue(EFTT_OPACITY, opacity);
  584.                                         }
  585.                                 }
  586.                         }
  587.                 }
  588.         }
  589. }
  590.  
  591. //------------------------------------------------------------------------
  592. IMaterial* CVehiclePartBase::GetMaterial()
  593. {
  594.         if (m_pClonedMaterial)
  595.                 return m_pClonedMaterial;
  596.         else
  597.                 return GetEntity()->GetMaterial();
  598. }
  599.  
  600. //------------------------------------------------------------------------
  601. void CVehiclePartBase::SetMaterial(IMaterial* pMaterial)
  602. {
  603.         // moved to CVehiclePartAnimated
  604. }
  605.  
  606. //------------------------------------------------------------------------
  607. void CVehiclePartBase::ParsePhysicsParams(SEntityPhysicalizeParams& physicalizeParams, const CVehicleParams& table)
  608. {
  609.         table.getAttr("mass", physicalizeParams.mass);
  610.         table.getAttr("density", physicalizeParams.density);
  611. }
  612.  
  613. //------------------------------------------------------------------------
  614. void CVehiclePartBase::CheckColltypeHeavy(int partid)
  615. {
  616.         if (partid < 0 || !GetEntity()->GetPhysics())
  617.                 return;
  618.  
  619.         if (!m_pSharedParameters->m_disableCollision)
  620.         {
  621.                 pe_params_part paramsPart;
  622.                 paramsPart.partid = partid;
  623.  
  624.                 if (m_pVehicle->GetMass() >= VEHICLE_MASS_COLLTYPE_HEAVY)
  625.                 {
  626.                         paramsPart.flagsAND = ~geom_colltype_debris; // light debris from breakable objs
  627.                         paramsPart.flagsColliderAND = geom_colltype3;
  628.                         paramsPart.flagsColliderOR = geom_colltype3; // for heavy vehicles
  629.                 }
  630.  
  631.                 paramsPart.flagsColliderOR |= geom_colltype6; // vehicle-only colltype
  632.  
  633.                 GetEntity()->GetPhysics()->SetParams(&paramsPart);
  634.         }
  635. }
  636.  
  637. //------------------------------------------------------------------------
  638. void CVehiclePartBase::SetFlags(int partid, int flags, bool add)
  639. {
  640.         if (partid < 0 || !GetEntity()->GetPhysics())
  641.                 return;
  642.  
  643.         pe_params_part paramsPart;
  644.         paramsPart.partid = partid;
  645.  
  646.         if (add)
  647.         {
  648.                 paramsPart.flagsOR = flags;
  649.         }
  650.         else
  651.         {
  652.                 paramsPart.flagsAND = ~flags;
  653.         }
  654.  
  655.         GetEntity()->GetPhysics()->SetParams(&paramsPart);
  656. }
  657.  
  658. //------------------------------------------------------------------------
  659. void CVehiclePartBase::SetFlagsCollider(int partid, int flagsCollider)
  660. {
  661.         if (partid < 0 || !GetEntity()->GetPhysics())
  662.                 return;
  663.  
  664.         pe_params_part paramsPart;
  665.         paramsPart.partid = partid;
  666.  
  667.         paramsPart.flagsColliderAND = 0;
  668.         paramsPart.flagsColliderOR = flagsCollider;
  669.  
  670.         GetEntity()->GetPhysics()->SetParams(&paramsPart);
  671. }
  672.  
  673. //------------------------------------------------------------------------
  674. IVehiclePart* CVehiclePartBase::GetParent(bool root /*=false*/)
  675. {
  676.         IVehiclePart* pParent = m_pParentPart;
  677.  
  678.         if (root && pParent)
  679.         {
  680.                 while (IVehiclePart* pRoot = pParent->GetParent(false))
  681.                         pParent = pRoot;
  682.         }
  683.  
  684.         return pParent;
  685. }
  686.  
  687. //------------------------------------------------------------------------
  688. void CVehiclePartBase::Serialize(TSerialize ser, EEntityAspects aspects)
  689. {
  690.         bool bSaveGame = ser.GetSerializationTarget() != eST_Network;
  691.  
  692.         if (bSaveGame)
  693.         {
  694.                 ser.BeginGroup("VehiclePart");
  695.  
  696.                 ser.Value("m_damageRatio", m_damageRatio);
  697.                 ser.EnumValue("m_hideMode", m_hideMode, eVPH_NoFade, eVPH_FadeOut);
  698.                 ser.Value("m_hideTimeCount", m_hideTimeCount);
  699.         }
  700.  
  701.         if (bSaveGame || aspects & CVehicle::ASPECT_COMPONENT_DAMAGE)
  702.         {
  703.                 NET_PROFILE_SCOPE("ComponentDamage", ser.IsReading());
  704.  
  705.                 EVehiclePartState state = m_state;
  706.                 ser.EnumValue("m_state", state, eVGS_Default, eVGS_Last);
  707.  
  708.                 if (ser.IsReading())
  709.                 {
  710.                         ChangeState(state, eVPSF_Physicalize);
  711.                 }
  712.         }
  713.  
  714.         if (!bSaveGame)
  715.         {
  716.                 if (aspects & CVehicle::ASPECT_PART_MATRIX)
  717.                 {
  718.                         NET_PROFILE_SCOPE("AspectPartMatrix", ser.IsReading());
  719.  
  720.                         Quat q;
  721.                         Matrix34 currentTM = GetLocalBaseTM();
  722.                         if (ser.IsWriting())
  723.                                 q = Quat(currentTM);
  724.  
  725.                         ser.Value("rotation", q, 'ori1');
  726.  
  727.                         if (ser.IsReading())
  728.                         {
  729.                                 Matrix34 newTM(q);
  730.                                 newTM.SetTranslation(currentTM.GetTranslation());
  731.                                 SetLocalBaseTM(newTM);
  732.                         }
  733.                 }
  734.         }
  735.  
  736.         if (bSaveGame)
  737.                 ser.EndGroup();
  738. }
  739.  
  740. //------------------------------------------------------------------------
  741. void CVehiclePartBase::CloneMaterial()
  742. {
  743.         if (m_pClonedMaterial)
  744.                 return;
  745.  
  746.         if (IMaterial* pMaterialOriginal = GetMaterial())
  747.         {
  748.                 m_pClonedMaterial = pMaterialOriginal->GetMaterialManager()->CloneMultiMaterial(pMaterialOriginal);
  749.                 if (m_pClonedMaterial)
  750.                         SetMaterial(m_pClonedMaterial);
  751.         }
  752. }
  753.  
  754. //------------------------------------------------------------------------
  755. bool CVehiclePartBase::SetCGASlot(int jointId, IStatObj* pStatObj, bool bUpdatePhys)
  756. {
  757.         CRY_ASSERT(m_slot >= 0);
  758.  
  759.         if (m_slot < 0)
  760.                 return false;
  761.  
  762.         if (ICharacterInstance* pChar = GetEntity()->GetCharacter(m_slot))
  763.                 pChar->GetISkeletonPose()->SetStatObjOnJoint(jointId, pStatObj);
  764.         else
  765.                 return false;
  766.         if (bUpdatePhys && GetEntity()->GetPhysics())
  767.         {
  768.                 if (pStatObj)
  769.                 {
  770.                         pe_params_part pp;
  771.                         pp.partid = AllocPartIdRange(GetEntity()->GetPhysicalEntityPartId0(m_slot), PARTID_MAX_SLOTS) | jointId;
  772.                         pp.pPhysGeom = pStatObj->GetPhysGeom();
  773.                         GetEntity()->GetPhysics()->SetParams(&pp);
  774.                 }
  775.                 else
  776.                         GetEntity()->GetPhysics()->RemoveGeometry(AllocPartIdRange(GetEntity()->GetPhysicalEntityPartId0(m_slot), PARTID_MAX_SLOTS) | jointId);
  777.         }
  778.         return true;
  779. }
  780.  
  781. void CVehiclePartBase::GetMemoryUsageInternal(ICrySizer* s) const
  782. {
  783.  
  784. }
  785.  
  786. DEFINE_VEHICLEOBJECT(CVehiclePartBase);
  787.  
downloadVehiclePartBase.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