BVB Source Codes

CRYENGINE Show VehiclePartSubPartWheel.cpp Source code

Return Download CRYENGINE: download VehiclePartSubPartWheel.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 wheel vehicle part
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 26: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 "VehiclePartBase.h"
  22. #include "VehiclePartSubPartWheel.h"
  23. #include "VehicleUtils.h"
  24.  
  25. #define THREAD_SAFE 1
  26.  
  27. //------------------------------------------------------------------------
  28. CVehiclePartSubPartWheel::CVehiclePartSubPartWheel()
  29. {
  30.         m_physGeomParams.bCanBrake = 1;
  31.         m_physGeomParams.bCanSteer = 1;
  32.         m_physGeomParams.kStiffnessWeight = 1.f;
  33.         m_physGeomParams.kStiffness = 0.f;
  34.         m_physGeomParams.minFriction = m_physGeomParams.maxFriction = 1.f;
  35.         m_physGeomParams.kLatFriction = 1.f;
  36.         m_physGeomParams.pivot.zero();
  37. }
  38.  
  39. //------------------------------------------------------------------------
  40. bool CVehiclePartSubPartWheel::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
  41. {
  42.         if (!CVehiclePartSubPart::Init(pVehicle, table, parent, initInfo, eVPT_Wheel))
  43.                 return false;
  44.  
  45.         CVehicleParams subTable = table.findChild("SubPartWheel");
  46.         if (!subTable)
  47.                 return false;
  48.  
  49.         bool bTemp = false;
  50.  
  51.         subTable.getAttr("axle", m_physGeomParams.iAxle);
  52.         subTable.getAttr("density", m_physGeomParams.density);
  53.         subTable.getAttr("damping", m_physGeomParams.kDamping);
  54.         subTable.getAttr("lenInit", m_physGeomParams.lenInitial);
  55.         subTable.getAttr("lenMax", m_physGeomParams.lenMax);
  56.         subTable.getAttr("maxFriction", m_physGeomParams.maxFriction);
  57.         subTable.getAttr("minFriction", m_physGeomParams.minFriction);
  58.         subTable.getAttr("latFriction", m_physGeomParams.kLatFriction);
  59.         subTable.getAttr("stiffness", m_physGeomParams.kStiffness);
  60.         subTable.getAttr("surfaceId", m_physGeomParams.surface_idx);
  61.  
  62.         // If a stiffness weight is supplied force kStiffness = 0 so suspension is autocalculated
  63.         if (subTable.getAttr("stiffnessWeight"))
  64.         {
  65.                 subTable.getAttr("stiffnessWeight", m_physGeomParams.kStiffnessWeight);
  66.                 m_physGeomParams.kStiffness = 0.f;
  67.         }
  68.  
  69.         if (subTable.getAttr("canBrake", bTemp))
  70.                 m_physGeomParams.bCanBrake = bTemp;
  71.         if (subTable.getAttr("driving", bTemp))
  72.                 m_physGeomParams.bDriving = bTemp;
  73.         if (subTable.getAttr("rayCast", bTemp))
  74.                 m_physGeomParams.bRayCast = bTemp;
  75.         if (subTable.getAttr("canSteer", bTemp))
  76.                 m_physGeomParams.bCanSteer = bTemp;
  77.  
  78.         m_physGeomParams.mass = m_pSharedParameters->m_mass;
  79.  
  80.         // wheel index is saved in the shared params, so just update the vehicle properties here
  81.         reinterpret_cast<CVehicle*>(pVehicle)->m_wheelCount++;
  82.  
  83.         InitGeometry();
  84.  
  85.         return true;
  86. }
  87.  
  88. //------------------------------------------------------------------------
  89. void CVehiclePartSubPartWheel::Reset()
  90. {
  91.         CVehiclePartSubPart::Reset();
  92. }
  93.  
  94. //------------------------------------------------------------------------
  95. void CVehiclePartSubPartWheel::OnEvent(const SVehiclePartEvent& event)
  96. {
  97.         CVehiclePartSubPart::OnEvent(event);
  98. }
  99.  
  100. //------------------------------------------------------------------------
  101. void CVehiclePartSubPartWheel::InitGeometry()
  102. {
  103.         if (m_slot == -1)
  104.         {
  105.                 m_slot = 0;
  106.  
  107.                 while (GetEntity()->IsSlotValid(m_slot))
  108.                         m_slot++;
  109.         }
  110.  
  111.         ChangeState(eVGS_Default);
  112. }
  113.  
  114. //------------------------------------------------------------------------
  115. bool CVehiclePartSubPartWheel::ChangeState(EVehiclePartState state, int flags)
  116. {
  117.         EVehiclePartState old = m_state;
  118.  
  119.         if (state == eVGS_Default)
  120.         {
  121.                 if (IPhysicalEntity* pPhysics = m_pVehicle->GetEntity()->GetPhysics())
  122.                 {
  123.                         pe_params_car params_car;
  124.  
  125.                         if (pPhysics->GetParams(&params_car))
  126.                         {
  127.                                 if (m_pSharedParameters->m_wheelIndex < params_car.nWheels)
  128.                                 {
  129.                                         pe_params_wheel wheelParams;
  130.  
  131.                                         wheelParams.iWheel = m_pSharedParameters->m_wheelIndex;
  132.                                         wheelParams.suspLenMax = m_physGeomParams.lenMax;
  133.                                         wheelParams.suspLenInitial = m_pSharedParameters->m_suspLength;
  134.  
  135.                                         pPhysics->SetParams(&wheelParams, THREAD_SAFE);
  136.                                 }
  137.                                 else
  138.                                 {
  139.                                         CRY_ASSERT_MESSAGE(false, "Wheel index exceeds number of wheels");
  140.                                 }
  141.                         }
  142.                 }
  143.         }
  144.  
  145.         if (state == eVGS_Destroyed)
  146.         {
  147.                 if (IPhysicalEntity* pPhysics = m_pVehicle->GetEntity()->GetPhysics())
  148.                 {
  149.                         pe_params_car params_car;
  150.  
  151.                         if (pPhysics->GetParams(&params_car))
  152.                         {
  153.                                 if (m_pSharedParameters->m_wheelIndex < params_car.nWheels)
  154.                                 {
  155.                                         pe_params_wheel wheelParams;
  156.  
  157.                                         wheelParams.iWheel = m_pSharedParameters->m_wheelIndex;
  158.                                         wheelParams.suspLenMax = 0.0f;
  159.                                         wheelParams.suspLenInitial = 0.0f;
  160.  
  161.                                         pPhysics->SetParams(&wheelParams, THREAD_SAFE);
  162.                                 }
  163.                                 else
  164.                                 {
  165.                                         CRY_ASSERT_MESSAGE(false, "Wheel index exceeds number of wheels");
  166.                                 }
  167.                         }
  168.                 }
  169.         }
  170.  
  171.         if (!CVehiclePartSubPart::ChangeState(state, flags))
  172.                 return false;
  173.  
  174.         if (old == eVGS_Damaged1 && m_state == eVGS_Default)
  175.         {
  176.                 // tire repaired
  177.                 if (IPhysicalEntity* pPhysics = m_pVehicle->GetEntity()->GetPhysics())
  178.                 {
  179.                         pe_action_impulse imp;
  180.                         imp.impulse = m_pVehicle->GetEntity()->GetWorldRotation() * Vec3(0.f, 0.f, m_pVehicle->GetMass() / m_pVehicle->GetWheelCount());
  181.                         imp.point = GetWorldTM().GetTranslation();
  182.                         pPhysics->Action(&imp);
  183.                 }
  184.         }
  185.  
  186.         return true;
  187. }
  188.  
  189. //------------------------------------------------------------------------
  190. void CVehiclePartSubPartWheel::GetGeometryName(EVehiclePartState state, string& name)
  191. {
  192.         if (state == eVGS_Damaged1)
  193.         {
  194.                 name = GetName();
  195.                 name.append("_rim");
  196.                 return;
  197.         }
  198.         else
  199.                 CVehiclePartSubPart::GetGeometryName(state, name);
  200. }
  201.  
  202. //------------------------------------------------------------------------
  203. void CVehiclePartSubPartWheel::Physicalize()
  204. {
  205.         IPhysicalEntity* pPhysics = GetEntity()->GetPhysics();
  206.         if (!pPhysics)
  207.                 return;
  208.  
  209.         IStatObj* pStatObj = GetEntity()->GetStatObj(m_slot);
  210.         phys_geometry* pPhysGeom = pStatObj ? pStatObj->GetPhysGeom() : 0;
  211.         bool updated = false;
  212.  
  213.         if (m_slot != -1 && m_physId != -1)
  214.         {
  215.                 pe_status_pos status;
  216.                 status.partid = m_physId;
  217.                 if (pPhysics->GetStatus(&status))
  218.                 {
  219.                         if (pStatObj && pPhysGeom)
  220.                         {
  221.                                 Matrix34 tm(m_savedTM);
  222.                                 pe_params_part params;
  223.                                 params.partid = m_physId;
  224.                                 params.pPhysGeom = pPhysGeom;
  225.                                 params.pMtx3x4 = &tm;
  226.                                 pPhysics->SetParams(&params);
  227.                         }
  228.                         else
  229.                         {
  230.                                 pPhysics->RemoveGeometry(m_physId);
  231.                                 m_physId = -1;
  232.                         }
  233.  
  234.                         updated = true;
  235.                 }
  236.         }
  237.  
  238.         if (!updated && pStatObj && pPhysGeom)
  239.         {
  240.                 Matrix34 slotTM = VALIDATE_MAT(m_savedTM);
  241.  
  242.                 m_physGeomParams.pMtx3x4 = &slotTM;
  243.                 m_physGeomParams.pivot = slotTM.GetTranslation();
  244.                 m_physGeomParams.lenInitial = m_pSharedParameters->m_suspLength;
  245.                 m_physGeomParams.flags &= ~geom_floats;
  246.  
  247.                 if (m_pVehicle->GetMass() >= VEHICLE_MASS_COLLTYPE_HEAVY)
  248.                 {
  249.                         m_physGeomParams.flags &= ~geom_colltype_debris;
  250.                         m_physGeomParams.flagsCollider = geom_colltype_vehicle;
  251.                 }
  252.  
  253.                 m_physGeomParams.flagsCollider |= geom_colltype6; // vehicle-only colltype
  254.  
  255.                 // use copy, physics eventually writes to the passed struct
  256.                 pe_cargeomparams params;
  257.                 memcpy(&params, &m_physGeomParams, sizeof(params));
  258.                 m_physId = pPhysics->AddGeometry(pPhysGeom, &params, m_slot);
  259.  
  260.                 if (m_physId < 0)
  261.                         GameWarning("AddGeometry failed on <%s> (part %s)", m_pVehicle->GetEntity()->GetName(), GetName());
  262.         }
  263.  
  264.         if (m_physId != -1)
  265.         {
  266.                 pe_params_wheel wp;
  267.                 wp.iWheel = m_pSharedParameters->m_wheelIndex;
  268.                 wp.Tscale = m_pSharedParameters->m_torqueScale;
  269.                 pPhysics->SetParams(&wp);
  270.         }
  271.  
  272. #if ENABLE_VEHICLE_DEBUG
  273.         if (IsDebugParts())
  274.                 CryLog("[CVehicleSubPartWheel]: <%s> got physId %i", GetName(), m_physId);
  275. #endif
  276. }
  277.  
  278. //------------------------------------------------------------------------
  279. void CVehiclePartSubPartWheel::Serialize(TSerialize ser, EEntityAspects aspects)
  280. {
  281.         CVehiclePartBase::Serialize(ser, aspects);
  282.  
  283.         if (ser.GetSerializationTarget() != eST_Network)
  284.         {
  285.                 IPhysicalEntity* pPhysics = GetEntity()->GetPhysics();
  286.                 if (!pPhysics)
  287.                         return;
  288.  
  289.                 float maxFrictionRatio = 0.0f, minFrictionRatio = 0.0f;
  290.  
  291.                 if (ser.IsWriting())
  292.                 {
  293.                         pe_params_wheel wheelParams;
  294.                         wheelParams.iWheel = m_pSharedParameters->m_wheelIndex;
  295.                         if (pPhysics->GetParams(&wheelParams))
  296.                         {
  297.                                 if (m_physGeomParams.maxFriction != 0.f)
  298.                                         maxFrictionRatio = wheelParams.maxFriction / m_physGeomParams.maxFriction;
  299.                                 if (m_physGeomParams.minFriction != 0.f)
  300.                                         minFrictionRatio = wheelParams.minFriction / m_physGeomParams.minFriction;
  301.  
  302.                                 ser.Value("maxFrictionRatio", maxFrictionRatio, 'vWFr');
  303.                                 ser.Value("minFrictionRatio", minFrictionRatio, 'vWFr');
  304.                         }
  305.                 }
  306.                 else if (ser.IsReading())
  307.                 {
  308.                         ser.Value("maxFrictionRatio", maxFrictionRatio, 'vWFr');
  309.                         ser.Value("minFrictionRatio", minFrictionRatio, 'vWFr');
  310.  
  311.                         pe_params_wheel wheelParams;
  312.                         wheelParams.iWheel = m_pSharedParameters->m_wheelIndex;
  313.                         wheelParams.maxFriction = m_physGeomParams.maxFriction * maxFrictionRatio;
  314.                         wheelParams.minFriction = m_physGeomParams.minFriction * minFrictionRatio;
  315.                         pPhysics->SetParams(&wheelParams);
  316.                 }
  317.         }
  318. }
  319.  
  320. //------------------------------------------------------------------------
  321. void CVehiclePartSubPartWheel::PostSerialize()
  322. {
  323.         CVehiclePartBase::PostSerialize();
  324. }
  325.  
  326. //------------------------------------------------------------------------
  327. float CVehiclePartSubPartWheel::GetSlipFrictionMod(float slip) const
  328. {
  329.         if (GetState() != eVGS_Default) // 0 for damaged wheels
  330.                 return 0.f;
  331.  
  332.         float mod = IsFront() ? VehicleCVars().v_slipFrictionModFront : VehicleCVars().v_slipFrictionModRear;
  333.         if (mod <= 0.f)
  334.                 mod = m_pSharedParameters->m_slipFrictionMod;
  335.  
  336.         float slope = IsFront() ? VehicleCVars().v_slipSlopeFront : VehicleCVars().v_slipSlopeRear;
  337.         if (slope <= 0.f)
  338.                 slope = m_pSharedParameters->m_slipSlope;
  339.  
  340.         return (slip * mod) / (slip + mod * slope);
  341. }
  342.  
  343. DEFINE_VEHICLEOBJECT(CVehiclePartSubPartWheel);
  344.  
downloadVehiclePartSubPartWheel.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