BVB Source Codes

CRYENGINE Show VehiclePartTread.cpp Source code

Return Download CRYENGINE: download VehiclePartTread.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 part for vehicles which uses animated characters
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 24:08:2005: Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15.  
  16. #include <CryAnimation/ICryAnimation.h>
  17. #include "IVehicleSystem.h"
  18.  
  19. #include "CryAction.h"
  20. #include "Vehicle.h"
  21. #include "VehicleComponent.h"
  22. #include "VehiclePartSubPartWheel.h"
  23. #include "VehiclePartTread.h"
  24. #include "VehicleUtils.h"
  25. #include <CryRenderer/IShader.h>
  26. #include <CryExtension/CryCreateClassInstance.h>
  27.  
  28. //------------------------------------------------------------------------
  29. CVehiclePartTread::CVehiclePartTread()
  30. {
  31.         m_pCharInstance = NULL;
  32.         m_slot = -1;
  33.         m_lastWheelIndex = 0;
  34.         m_pMaterial = 0;
  35.         m_damageRatio = 0.0f;
  36.  
  37.         m_uvSpeedMultiplier = 0.0f;
  38.         m_bForceSetU = true;
  39.         m_wantedU = 0.0f;
  40.         m_currentU = m_wantedU + 1.0f;
  41.  
  42.         m_pShaderResources = NULL;
  43.         m_pMaterial = NULL;
  44.         CryCreateClassInstance("AnimationPoseModifier_OperatorQueue", m_operatorQueue);
  45. }
  46.  
  47. //------------------------------------------------------------------------
  48. bool CVehiclePartTread::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
  49. {
  50.         if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Tread))
  51.                 return false;
  52.  
  53.         CVehicleParams subTable = table.findChild("Tread"); // Tread subtable
  54.         if (!subTable)
  55.                 return false;
  56.  
  57.         string filename = subTable.getAttr("filename");
  58.         if (filename.empty())
  59.                 return false;
  60.  
  61.         subTable.getAttr("uvSpeedMultiplier", m_uvSpeedMultiplier);
  62.  
  63.         if (table.haveAttr("component"))
  64.         {
  65.                 if (CVehicleComponent* pComponent = static_cast<CVehicleComponent*>(m_pVehicle->GetComponent(table.getAttr("component"))))
  66.                         pComponent->AddPart(this);
  67.         }
  68.  
  69.         m_slot = GetEntity()->LoadCharacter(m_slot, filename);
  70.  
  71.         m_pCharInstance = GetEntity()->GetCharacter(m_slot);
  72.         if (!m_pCharInstance)
  73.                 return false;
  74.  
  75.         if (subTable.haveAttr("materialName"))
  76.         {
  77.                 string materialName = subTable.getAttr("materialName");
  78.                 materialName.MakeLower();
  79.  
  80.                 IMaterial* pMaterial = 0;
  81.                 const char* subMtlName = 0;
  82.                 int subMtlSlot = -1;
  83.  
  84.                 // find tread material
  85.                 IEntityRender* pIEntityRender = GetEntity()->GetRenderInterface();
  86.                
  87.                 {
  88.                         pMaterial = pIEntityRender->GetRenderMaterial(m_slot);
  89.                         if (pMaterial)
  90.                         {
  91.                                 // if matname doesn't fit, look in submaterials
  92.                                 if (string(pMaterial->GetName()).MakeLower().find(materialName) == string::npos)
  93.                                 {
  94.                                         for (int i = 0; i < pMaterial->GetSubMtlCount(); ++i)
  95.                                         {
  96.                                                 if (string(pMaterial->GetSubMtl(i)->GetName()).MakeLower().find(materialName) != string::npos)
  97.                                                 {
  98.                                                         subMtlName = pMaterial->GetSubMtl(i)->GetName();
  99.                                                         subMtlSlot = i;
  100.                                                         break;
  101.                                                 }
  102.                                         }
  103.                                 }
  104.                         }
  105.                 }
  106.  
  107.                 if (pMaterial)
  108.                 {
  109.                         // clone
  110.                         IMaterial* pCloned = pMaterial->GetMaterialManager()->CloneMultiMaterial(pMaterial, subMtlName);
  111.                         if (pCloned)
  112.                         {
  113.                                 pIEntityRender->SetSlotMaterial(m_slot, pCloned);
  114.                                 pMaterial = pCloned;
  115.                                 m_pMaterial = pMaterial;
  116.                         }
  117.  
  118.                         if (subMtlSlot > -1)
  119.                                 m_pShaderResources = pMaterial->GetShaderItem(subMtlSlot).m_pShaderResources;
  120.                         else
  121.                                 m_pShaderResources = pMaterial->GetShaderItem().m_pShaderResources;
  122.                 }
  123.  
  124.                 if (m_pShaderResources)
  125.                 {
  126.                         for (int i = 0; i < EFTT_MAX; ++i)
  127.                         {
  128.                                 if (!m_pShaderResources->GetTexture(i))
  129.                                         continue;
  130.  
  131.                                 SEfTexModificator& modif = *m_pShaderResources->GetTexture(i)->AddModificator();
  132.  
  133.                                 modif.SetMember("m_eMoveType[0]", 1.0f);  // ETMM_Fixed: u = m_OscRate[0] + sourceU
  134.  
  135.                                 modif.SetMember("m_OscRate[0]", 0.0f);
  136.                         }
  137.                 }
  138.         }
  139.  
  140.         char wheelName[256];
  141.  
  142.         IDefaultSkeleton& rIDefaultSkeleton = m_pCharInstance->GetIDefaultSkeleton();
  143.         for (int i = 0; i < rIDefaultSkeleton.GetJointCount(); ++i)
  144.         {
  145.                 const char* boneName = rIDefaultSkeleton.GetJointNameByID(i);
  146.                 if (0 != boneName)
  147.                 {
  148.                         // extract wheel name
  149.                         const size_t len = strcspn(boneName, "_");
  150.                         if (len < strlen(boneName) && len < sizeof(wheelName))
  151.                         {
  152.                                 cry_strcpy(wheelName, boneName, len);
  153.  
  154.                                 CVehiclePartSubPartWheel* pWheel = (CVehiclePartSubPartWheel*)m_pVehicle->GetPart(wheelName);
  155.                                 if (pWheel)
  156.                                 {
  157.                                         SWheelInfo wheelInfo;
  158.                                         wheelInfo.slot = pWheel->m_slot;
  159.                                         wheelInfo.jointId = i;
  160.                                         wheelInfo.pWheel = pWheel;
  161.                                         m_wheels.push_back(wheelInfo);
  162.  
  163.                                         m_lastWheelIndex = pWheel->GetWheelIndex();
  164.                                 }
  165.                         }
  166.                 }
  167.         }
  168.  
  169.         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
  170.  
  171.         m_state = eVGS_Default;
  172.         return true;
  173. }
  174.  
  175. //------------------------------------------------------------------------
  176. void CVehiclePartTread::Reset()
  177. {
  178.         m_bForceSetU = false;
  179.         m_wantedU = 0.0f;
  180.         m_currentU = m_wantedU + 1.0f;
  181.         UpdateU();
  182.  
  183.         if (m_pCharInstance)
  184.                 m_pCharInstance->GetISkeletonPose()->SetForceSkeletonUpdate(0);
  185.  
  186.         CVehiclePartBase::Reset();
  187. }
  188.  
  189. //------------------------------------------------------------------------
  190. bool CVehiclePartTread::ChangeState(EVehiclePartState state, int flags /* =0 */)
  191. {
  192.         const EVehiclePartState previousState = m_state;
  193.         const bool stateChanged = CVehiclePartBase::ChangeState(state, flags);
  194.         m_state = state;
  195.  
  196.         if (stateChanged)
  197.         {
  198.                 if (m_state == IVehiclePart::eVGS_Destroyed)
  199.                 {
  200.                         Hide(true);
  201.                 }
  202.                 else if (previousState == IVehiclePart::eVGS_Destroyed)
  203.                 {
  204.                         Hide(false);
  205.                 }
  206.  
  207.                 if (const auto pMovement = m_pVehicle->GetMovement())
  208.                 {
  209.                         if (m_state == IVehiclePart::eVGS_Damaged1)
  210.                         {
  211.                                 SVehicleMovementEventParams params;
  212.                                 pMovement->OnEvent(IVehicleMovement::eVME_TireBlown, params);
  213.                         }
  214.                         else if (m_state == eVGS_Default)
  215.                         {
  216.                                 SVehicleMovementEventParams params;
  217.                                 pMovement->OnEvent(IVehicleMovement::eVME_TireRestored, params);
  218.                         }
  219.                 }
  220.         }
  221.  
  222.         return stateChanged;
  223. }
  224.  
  225. //------------------------------------------------------------------------
  226. void CVehiclePartTread::InitGeometry()
  227. {
  228. }
  229.  
  230. //------------------------------------------------------------------------
  231. void CVehiclePartTread::Physicalize()
  232. {
  233.         Update(1.0f);
  234. }
  235.  
  236. //------------------------------------------------------------------------
  237. const Matrix34& CVehiclePartTread::GetLocalTM(bool relativeToParentPart, bool forced)
  238. {
  239.         return GetEntity()->GetSlotLocalTM(m_slot, relativeToParentPart);
  240. }
  241.  
  242. //------------------------------------------------------------------------
  243. const Matrix34& CVehiclePartTread::GetWorldTM()
  244. {
  245.         return GetEntity()->GetSlotWorldTM(m_slot);
  246. }
  247.  
  248. //------------------------------------------------------------------------
  249. const AABB& CVehiclePartTread::GetLocalBounds()
  250. {
  251.         if (m_pCharInstance)
  252.         {
  253.                 m_bounds = m_pCharInstance->GetAABB();
  254.                 m_bounds.SetTransformedAABB(GetEntity()->GetSlotLocalTM(m_slot, false), m_bounds);
  255.         }
  256.         else
  257.                 GetEntity()->GetLocalBounds(m_bounds);
  258.  
  259.         return m_bounds;
  260. }
  261.  
  262. //------------------------------------------------------------------------
  263. void CVehiclePartTread::Update(const float frameTime)
  264. {
  265.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  266.  
  267.         if (!m_pCharInstance)
  268.                 return;
  269.  
  270.         if (m_bForceSetU)
  271.         {
  272.                 m_bForceSetU = false;
  273.                 m_currentU = m_wantedU + 1.0f;
  274.                 UpdateU();
  275.         }
  276.  
  277.         ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  278.  
  279.         pSkeletonPose->SetForceSkeletonUpdate(0);
  280.  
  281.         if (VehicleCVars().v_staticTreadDeform == 0 && m_pVehicle->GetStatus().speed < 0.001f)
  282.         {
  283.                 return;
  284.         }
  285.  
  286.         if (frameTime > 0.f &&
  287.             (m_damageRatio >= 1.f || !m_pVehicle->GetGameObject()->IsProbablyVisible() || m_pVehicle->IsProbablyDistant()))
  288.         {
  289.                 return;
  290.         }
  291.  
  292.         // we need a tread update in next frame
  293.         pSkeletonPose->SetForceSkeletonUpdate(1);
  294.         m_pVehicle->NeedsUpdate();
  295.  
  296.         // animate the UV texture according to the wheels speed
  297.         if (m_uvSpeedMultiplier != 0.0f && frameTime > 0.0f)
  298.         {
  299.                 IPhysicalEntity* pPhysics = GetEntity()->GetPhysics();
  300.                 pe_status_wheel wheelStatus;
  301.                 wheelStatus.iWheel = m_lastWheelIndex;
  302.  
  303.                 if (pPhysics && pPhysics->GetStatus(&wheelStatus) != 0)
  304.                 {
  305.                         m_wantedU += m_uvSpeedMultiplier * (wheelStatus.w * wheelStatus.r * frameTime);
  306.                         m_wantedU -= std::floor(m_wantedU);
  307.                         UpdateU();
  308.                 }
  309.         }
  310.  
  311.         // deform the tread to follow the wheels
  312.         QuatT absRoot = pSkeletonPose->GetAbsJointByID(0);
  313.  
  314.         for (TWheelInfoVector::const_iterator ite = m_wheels.begin(), end = m_wheels.end(); ite != end; ++ite)
  315.         {
  316.                 const SWheelInfo& wheelInfo = *ite;
  317.                 const Matrix34& slotTM = GetEntity()->GetSlotLocalTM(wheelInfo.slot, true);
  318.                 VALIDATE_MAT(slotTM);
  319.  
  320.                 if (m_operatorQueue)
  321.                 {
  322.                         m_operatorQueue->PushPosition(wheelInfo.jointId,
  323.                                                       IAnimationOperatorQueue::eOp_Override, slotTM.GetTranslation());
  324.                 }
  325.  
  326. #if ENABLE_VEHICLE_DEBUG
  327.                 if (VehicleCVars().v_debugdraw == 4)
  328.                 {
  329.                         Vec3 local = GetEntity()->GetWorldTM().GetInverted() * slotTM.GetTranslation();
  330.                         gEnv->pRenderer->GetIRenderAuxGeom()->DrawSphere(GetEntity()->GetWorldTM() * (local + Vec3((float)sgn(local.x) * 0.5f, 0.f, 0.f)), 0.1f, ColorB(0, 0, 255, 255));
  331.                 }
  332. #endif
  333.         }
  334.         ISkeletonAnim* pSkeletonAnim = m_pCharInstance->GetISkeletonAnim();
  335.         pSkeletonAnim->PushPoseModifier(VEH_ANIM_POSE_MODIFIER_LAYER, m_operatorQueue, "VehiclePartAnimatedJoint");
  336. }
  337.  
  338. //------------------------------------------------------------------------
  339. void CVehiclePartTread::UpdateU()
  340. {
  341.         if (!m_pShaderResources || m_currentU == m_wantedU)
  342.         {
  343.                 return;
  344.         }
  345.  
  346.         m_currentU = m_wantedU;
  347.  
  348.         for (int i = 0; i < EFTT_MAX; ++i)
  349.         {
  350.                 if (!m_pShaderResources->GetTexture(i))
  351.                 {
  352.                         continue;
  353.                 }
  354.  
  355.                 SEfTexModificator& modif = *m_pShaderResources->GetTexture(i)->AddModificator();
  356.  
  357.                 modif.SetMember("m_OscRate[0]", m_wantedU);
  358.         }
  359. }
  360.  
  361. DEFINE_VEHICLEOBJECT(CVehiclePartTread);
  362.  
downloadVehiclePartTread.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