BVB Source Codes

CRYENGINE Show VehiclePartAnimatedJoint.cpp Source code

Return Download CRYENGINE: download VehiclePartAnimatedJoint.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 is the an attachment
  8.    of a parent Animated part
  9.  
  10.    -------------------------------------------------------------------------
  11.    History:
  12.    - 25:08:2005: Created by Mathieu Pinard
  13.  
  14. *************************************************************************/
  15. #include "StdAfx.h"
  16.  
  17. #include <CryAnimation/ICryAnimation.h>
  18. #include "IVehicleSystem.h"
  19. #include <CryGame/IGameTokens.h>
  20.  
  21. #include "CryAction.h"
  22. #include "Vehicle.h"
  23. #include "VehiclePartBase.h"
  24. #include "VehiclePartAnimated.h"
  25. #include "VehiclePartAnimatedJoint.h"
  26. #include "VehicleUtils.h"
  27. #include <CryExtension/CryCreateClassInstance.h>
  28.  
  29. //#pragma optimize("", off)
  30. //#pragma inline_depth(0)
  31. //------------------------------------------------------------------------
  32. CVehiclePartAnimatedJoint::CVehiclePartAnimatedJoint()
  33. {
  34.         m_pCharInstance = NULL;
  35.         m_pAnimatedPart = NULL;
  36.         m_jointId = -1;
  37.         m_localTMInvalid = false;
  38.         m_isMoveable = false;
  39.         m_isTransMoveable = false;
  40.         m_bUsePaintMaterial = false;
  41.  
  42. #ifdef VEH_USE_RPM_JOINT
  43.         m_dialsRotMax = 0.f;
  44.         m_initialRotOfs = 0.f;
  45. #endif
  46.  
  47.         m_pGeometry = 0;
  48.         m_pDestroyedGeometry = 0;
  49.         m_pMaterial = 0;
  50.  
  51.         m_baseTM.SetIdentity();
  52.         m_initialTM.SetIdentity();
  53.         m_localTM.SetIdentity();
  54.         m_nextFrameLocalTM.SetIdentity();
  55.         m_worldTM.SetIdentity();
  56. }
  57.  
  58. //------------------------------------------------------------------------
  59. CVehiclePartAnimatedJoint::~CVehiclePartAnimatedJoint()
  60. {
  61. }
  62.  
  63. //------------------------------------------------------------------------
  64. bool CVehiclePartAnimatedJoint::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
  65. {
  66.         if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_AnimatedJoint))
  67.                 return false;
  68.  
  69. #ifdef VEH_USE_RPM_JOINT
  70.         CVehicleParams animatedJointTable = table.findChild("AnimatedJoint");
  71.  
  72.         if (animatedJointTable)
  73.         {
  74.                 CVehicleParams dialsTable = animatedJointTable.findChild("Dials");
  75.                 if (dialsTable)
  76.                 {
  77.                         if (dialsTable.getAttr("rotationMax", m_dialsRotMax))
  78.                                 m_dialsRotMax = DEG2RAD(m_dialsRotMax);
  79.                         if (dialsTable.getAttr("ofs", m_initialRotOfs))
  80.                                 m_initialRotOfs = DEG2RAD(m_initialRotOfs);
  81.                 }
  82.         }
  83. #endif
  84.  
  85.         InitGeometry(table);
  86.  
  87.         m_state = eVGS_Default;
  88.  
  89.         return true;
  90. }
  91.  
  92. //------------------------------------------------------------------------
  93. void CVehiclePartAnimatedJoint::PostInit()
  94. {
  95.         CVehiclePartBase::PostInit();
  96.  
  97.         if (m_pGeometry)
  98.                 SetMaterial(m_pMaterial);
  99. }
  100.  
  101. //------------------------------------------------------------------------
  102. void CVehiclePartAnimatedJoint::Reset()
  103. {
  104.         CVehiclePartBase::Reset();
  105.  
  106.         if (m_pGeometry)
  107.                 SetMaterial(m_pMaterial);
  108.  
  109.         if (m_pCharInstance)
  110.                 m_pCharInstance->SetFlags(m_pCharInstance->GetFlags() | CS_FLAG_UPDATE);
  111. }
  112.  
  113. //------------------------------------------------------------------------
  114. void CVehiclePartAnimatedJoint::ResetLocalTM(bool recursive)
  115. {
  116.         CVehiclePartBase::ResetLocalTM(recursive);
  117.  
  118.         if (m_jointId > -1)
  119.         {
  120.                 SetLocalBaseTM(m_initialTM);
  121.         }
  122. }
  123.  
  124. //------------------------------------------------------------------------
  125. void CVehiclePartAnimatedJoint::InitGeometry(const CVehicleParams& table)
  126. {
  127.         IVehiclePart* pParent = GetParent(true);
  128.  
  129.         if (pParent)
  130.         {
  131.                 m_pAnimatedPart = CAST_VEHICLEOBJECT(CVehiclePartAnimated, pParent);
  132.         }
  133.         else
  134.         {
  135.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CVehiclePartAnimatedJoint '%s' : Parent part required.", GetName());
  136.  
  137.                 m_pAnimatedPart = NULL;
  138.         }
  139.  
  140.         if (m_pAnimatedPart)
  141.         {
  142.                 if (m_pCharInstance = m_pAnimatedPart->GetEntity()->GetCharacter(m_pAnimatedPart->GetSlot()))
  143.                 {
  144.                         IDefaultSkeleton& rIDefaultSkeleton = m_pCharInstance->GetIDefaultSkeleton();
  145.  
  146.                         m_slot = m_pAnimatedPart->GetSlot();
  147.                         m_jointId = rIDefaultSkeleton.GetJointIDByName(GetName());
  148.  
  149.                         if (m_pSharedParameters->m_useOption >= 0 && m_pSharedParameters->m_useOption <= MAX_OPTIONAL_PARTS)
  150.                         {
  151.                                 char jointName[128];
  152.                                 if (m_pSharedParameters->m_useOption > 0)
  153.                                 {
  154.                                         // store actual used name
  155.                                         cry_sprintf(jointName, "%s_option_%i", GetName(), m_pSharedParameters->m_useOption);
  156.  
  157.                                         int jointId = rIDefaultSkeleton.GetJointIDByName(jointName);
  158.                                         if (jointId != -1)
  159.                                                 m_jointId = jointId;
  160.                                 }
  161.  
  162.                                 // remove unused statobjs
  163.                                 for (int i = 0; i <= MAX_OPTIONAL_PARTS; ++i)
  164.                                 {
  165.                                         if (i == m_pSharedParameters->m_useOption)
  166.                                                 continue;
  167.  
  168.                                         if (i == 0)
  169.                                                 cry_sprintf(jointName, "%s", GetName());
  170.                                         else
  171.                                                 cry_sprintf(jointName, "%s_option_%i", GetName(), i);
  172.  
  173.                                         jointName[sizeof(jointName) - 1] = '\0';
  174.  
  175.                                         int jointId = rIDefaultSkeleton.GetJointIDByName(jointName);
  176.                                         if (jointId > -1)
  177.                                         {
  178.                                                 // remove all children this joint might have
  179.                                                 for (int n = 0, count = rIDefaultSkeleton.GetJointCount(); n < count; ++n)
  180.                                                 {
  181.                                                         if (n != jointId && rIDefaultSkeleton.GetJointParentIDByID(n) == jointId)
  182.                                                                 SetCGASlot(n, NULL);
  183.                                                 }
  184.  
  185.                                                 SetCGASlot(jointId, NULL);
  186.                                         }
  187.                                 }
  188.                         }
  189.  
  190.                         if (m_jointId != -1)
  191.                         {
  192.                                 CVehicleParams animatedJointTable = table.findChild("AnimatedJoint");
  193.                                 if (animatedJointTable)
  194.                                 {
  195.                                         string externalFile = animatedJointTable.getAttr("filename");
  196.                                         if (!externalFile.empty())
  197.                                         {
  198.                                                 if (m_pGeometry = gEnv->p3DEngine->LoadStatObj(externalFile))
  199.                                                 {
  200.                                                         SetStatObj(m_pGeometry);
  201.  
  202.                                                         animatedJointTable.getAttr("usePaintMaterial", m_bUsePaintMaterial);
  203.  
  204.                                                         externalFile = animatedJointTable.getAttr("filenameDestroyed");
  205.                                                         if (!externalFile.empty())
  206.                                                                 m_pDestroyedGeometry = gEnv->p3DEngine->LoadStatObj(externalFile);
  207.                                                 }
  208.                                         }
  209.                                 }
  210.                         }
  211.  
  212.                         if (m_jointId > -1)
  213.                         {
  214.                                 CVehicleParams animatedJointTable = table.findChild("AnimatedJoint");
  215.  
  216.                                 QuatT offsetQuat(ZERO, IDENTITY);
  217.                                 if (animatedJointTable)
  218.                                 {
  219.                                         Vec3 offsetRotation;
  220.                                         if (animatedJointTable.getAttr("offsetRotation", offsetRotation))
  221.                                         {
  222.                                                 offsetQuat.q = Quat::CreateRotationVDir(offsetRotation.GetNormalizedSafe(), 0.0f);
  223.                                         }
  224.                                 }
  225.  
  226.                                 ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  227.                                 Matrix34 tm = Matrix34((pSkeletonPose->GetRelJointByID(m_jointId) * offsetQuat));
  228.  
  229.                                 SetLocalBaseTM(tm);
  230.                                 m_initialTM = GetLocalTM(true);
  231.  
  232.                                 // NB SetMoveable may also be called by CSeatActionRotateTurret
  233. #ifdef VEH_USE_RPM_JOINT
  234.                                 CryFixedStringT<32> name = GetName();
  235.                                 if (name.substr(0, 6) == "dials_")
  236.                                 {
  237.                                         SetMoveable();
  238.                                         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_PassengerUpdate);
  239.                                 }
  240. #endif
  241.                         }
  242.                 }
  243.         }
  244. }
  245.  
  246. //------------------------------------------------------------------------
  247. void CVehiclePartAnimatedJoint::Physicalize()
  248. {
  249.         if (m_pCharInstance && m_jointId != -1)
  250.         {
  251.                 ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  252.  
  253.                 if (pSkeletonPose)
  254.                 {
  255.                         m_physId = pSkeletonPose->GetPhysIdOnJoint(m_jointId);
  256.                 }
  257.  
  258.                 m_pVehicle->RequestPhysicalization(this, false);
  259.         }
  260. }
  261.  
  262. //------------------------------------------------------------------------
  263. void CVehiclePartAnimatedJoint::SetMoveable(bool allowTranslationMovement)
  264. {
  265.         if (!m_pCharInstance)
  266.         {
  267.                 GameWarning("AnimatedJoint %s is missing CharInstance", GetName());
  268.                 return;
  269.         }
  270.  
  271.         m_isMoveable = true;
  272.         m_isTransMoveable = allowTranslationMovement;
  273.  
  274.         CryCreateClassInstance("AnimationPoseModifier_OperatorQueue", m_operatorQueue);
  275.         m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_PassengerUpdate);
  276. }
  277.  
  278. //------------------------------------------------------------------------
  279. bool CVehiclePartAnimatedJoint::ChangeState(EVehiclePartState state, int flags)
  280. {
  281.         if (!CVehiclePartBase::ChangeState(state, flags))
  282.                 return false;
  283.  
  284.         if (m_jointId != -1)
  285.         {
  286.                 bool damaging = (state > m_state && state > eVGS_Default && state < eVGS_Destroyed);
  287.                 bool repairing = (state<m_state&& m_state> eVGS_Default && m_state < eVGS_Destroyed);
  288.                 if (damaging || repairing)
  289.                 {
  290.                         CVehiclePartAnimated* pParent = CAST_VEHICLEOBJECT(CVehiclePartAnimated, GetParent(true));
  291.                         if (pParent)
  292.                         {
  293.                                 pParent->ChangeChildState(this, state, flags);
  294.                         }
  295.                 }
  296.                 else if (m_pDestroyedGeometry)
  297.                 {
  298.                         if (state == eVGS_Destroyed)
  299.                                 SetStatObj(m_pDestroyedGeometry);
  300.                         else if (state == eVGS_Default)
  301.                                 SetStatObj(m_pGeometry);
  302.                 }
  303.         }
  304.  
  305.         m_state = state;
  306.  
  307.         return true;
  308. }
  309.  
  310. //------------------------------------------------------------------------
  311. const Matrix34& CVehiclePartAnimatedJoint::GetLocalTM(bool relativeToParentPart, bool forced)
  312. {
  313.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  314.  
  315.         if (m_pCharInstance && m_jointId > -1)
  316.         {
  317.                 VALIDATE_MAT(m_localTM);
  318.  
  319.                 if (!m_isMoveable)
  320.                 {
  321.                         ISkeletonAnim* pSkeletonAnim = m_pCharInstance->GetISkeletonAnim();
  322.                         ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  323.                         if (pSkeletonAnim && (forced || pSkeletonAnim->GetNumAnimsInFIFO(0)))
  324.                         {
  325.                                 const QuatT& relJointQuat = pSkeletonPose->GetRelJointByID(m_jointId);
  326.                                 CRY_ASSERT(relJointQuat.IsValid());
  327.  
  328.                                 SetLocalBaseTM(Matrix34(relJointQuat));
  329.                         }
  330.                 }
  331.  
  332.                 if (relativeToParentPart)
  333.                 {
  334.                         return m_localTM;
  335.                 }
  336.                 else
  337.                 {
  338.                         const Matrix34& vehicleTM = LocalToVehicleTM(m_localTM);
  339.                         CRY_ASSERT(vehicleTM.IsValid());
  340.  
  341.                         return VALIDATE_MAT(vehicleTM);
  342.                 }
  343.         }
  344.  
  345.         m_localTM.SetIdentity();
  346.         return m_localTM;
  347. }
  348.  
  349. //------------------------------------------------------------------------
  350. void CVehiclePartAnimatedJoint::SetLocalTM(const Matrix34& localTM)
  351. {
  352.         if (!m_pCharInstance || m_jointId < 0)
  353.                 return;
  354.  
  355.         CRY_ASSERT(localTM.IsValid());
  356.  
  357.         m_localTM = m_nextFrameLocalTM;
  358.         m_nextFrameLocalTM = localTM;
  359.  
  360.         if (m_pAnimatedPart)
  361.                 m_pAnimatedPart->RotationChanged(this);
  362.  
  363.         InvalidateTM(true);
  364. }
  365.  
  366. //------------------------------------------------------------------------
  367. void CVehiclePartAnimatedJoint::SetLocalBaseTM(const Matrix34& baseTM)
  368. {
  369.         m_baseTM = VALIDATE_MAT(baseTM);
  370.  
  371.         SetLocalTM(m_baseTM);
  372. }
  373.  
  374. //------------------------------------------------------------------------
  375. void CVehiclePartAnimatedJoint::SerMatrix(TSerialize ser, Matrix34& mat)
  376. {
  377.         Vec3 col0 = mat.GetColumn(0);
  378.         Vec3 col1 = mat.GetColumn(1);
  379.         Vec3 col2 = mat.GetColumn(2);
  380.         Vec3 col3 = mat.GetColumn(3);
  381.         ser.ValueWithDefault("matrixCol0", col0, Vec3Constants<float>::fVec3_OneX);
  382.         ser.ValueWithDefault("matrixCol1", col1, Vec3Constants<float>::fVec3_OneY);
  383.         ser.ValueWithDefault("matrixCol2", col2, Vec3Constants<float>::fVec3_OneZ);
  384.         ser.Value("matrixCol3", col3);
  385.         if (ser.IsReading())
  386.         {
  387.                 mat.SetColumn(0, col0);
  388.                 mat.SetColumn(1, col1);
  389.                 mat.SetColumn(2, col2);
  390.                 mat.SetColumn(3, col3);
  391.         }
  392. }
  393.  
  394. //------------------------------------------------------------------------
  395. void CVehiclePartAnimatedJoint::Serialize(TSerialize ser, EEntityAspects aspects)
  396. {
  397.         MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Vehicle part animated joint serialization");
  398.  
  399.         CVehiclePartBase::Serialize(ser, aspects);
  400.  
  401.         if (ser.GetSerializationTarget() != eST_Network)
  402.         {
  403.                 ser.BeginGroup("VehiclePartJointMatrices");
  404.                 ser.Value("MatrixInvalid", m_localTMInvalid);
  405.                 Matrix34 baseTM(m_baseTM);
  406.                 SerMatrix(ser, baseTM);
  407.                 ser.EndGroup();
  408.  
  409.                 if (ser.IsReading())
  410.                 {
  411.                         SetLocalBaseTM(baseTM);
  412.                 }
  413.         }
  414. }
  415.  
  416. //------------------------------------------------------------------------
  417. const Matrix34& CVehiclePartAnimatedJoint::GetWorldTM()
  418. {
  419.         FUNCTION_PROFILER(gEnv->pSystem, PROFILE_ACTION);
  420.  
  421.         if (m_pCharInstance && m_jointId > -1)
  422.         {
  423.                 const Matrix34& localTM = GetLocalTM(false);
  424.                 m_worldTM = m_pVehicle->GetEntity()->GetWorldTM() * localTM;
  425.         }
  426.         else
  427.                 m_worldTM = GetEntity()->GetSlotWorldTM(m_slot);
  428.  
  429.         CRY_ASSERT(m_worldTM.IsValid());
  430.  
  431.         return VALIDATE_MAT(m_worldTM);
  432. }
  433.  
  434. //------------------------------------------------------------------------
  435. const AABB& CVehiclePartAnimatedJoint::GetLocalBounds()
  436. {
  437.         if (m_pCharInstance && m_jointId > -1)
  438.         {
  439.                 ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  440.                 if (IStatObj* pStatObj = pSkeletonPose->GetStatObjOnJoint(m_jointId))
  441.                         m_localBounds = pStatObj->GetAABB();
  442.                 else
  443.                         m_localBounds.Reset();
  444.  
  445.                 m_localBounds.SetTransformedAABB(GetLocalTM(false), m_localBounds);
  446.  
  447.                 return m_localBounds;
  448.         }
  449.         else
  450.         {
  451.                 GetEntity()->GetLocalBounds(m_localBounds);
  452.                 return m_localBounds;
  453.         }
  454. }
  455.  
  456. //------------------------------------------------------------------------
  457. void CVehiclePartAnimatedJoint::Update(float frameTime)
  458. {
  459.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  460.  
  461.         CVehiclePartBase::Update(frameTime);
  462.  
  463.         if (!m_pCharInstance || m_jointId < 0)
  464.                 return;
  465.  
  466.         if (ISkeletonAnim* pSkeletonAnim = m_pCharInstance->GetISkeletonAnim())
  467.         {
  468.                 if (m_operatorQueue)
  469.                 {
  470.                         m_operatorQueue->PushOrientation(m_jointId, IAnimationOperatorQueue::eOp_OverrideRelative, Quat(m_nextFrameLocalTM));
  471.                         if (m_isTransMoveable)
  472.                         {
  473.                                 m_operatorQueue->PushPosition(m_jointId, IAnimationOperatorQueue::eOp_OverrideRelative, m_nextFrameLocalTM.GetTranslation());
  474.                         }
  475.                 }
  476.                 pSkeletonAnim->PushPoseModifier(VEH_ANIM_POSE_MODIFIER_LAYER, m_operatorQueue, "VehiclePartAnimatedJoint");
  477.         }
  478.  
  479. #ifdef VEH_USE_RPM_JOINT
  480.         if (m_dialsRotMax > 0.f)
  481.         {
  482.                 if (m_pVehicle->IsPlayerDriving(true) || m_pVehicle->IsPlayerPassenger())
  483.                 {
  484.                         if (strcmp(GetName(), "dials_speedometer") == 0)
  485.                         {
  486.                                 float value = 0.0f;
  487.                                 IGameTokenSystem* pGTS = CCryAction::GetCryAction()->GetIGameTokenSystem();
  488.                                 pGTS->GetTokenValueAs("vehicle.speedNorm", value);
  489.                                 if (fabsf(m_initialRotOfs) > 0.0f)
  490.                                 {
  491.                                         float halfmeter = fabsf(m_initialRotOfs) * 0.25f;
  492.                                         if (value < halfmeter)
  493.                                                 value = halfmeter;
  494.                                 }
  495.                                 SetLocalBaseTM(m_initialTM * Matrix33::CreateRotationZ(-value * m_dialsRotMax - m_initialRotOfs));
  496.                         }
  497.                         else if (strcmp(GetName(), "dials_revometer") == 0)
  498.                         {
  499.                                 float value = 0.0f;
  500.                                 IGameTokenSystem* pGTS = CCryAction::GetCryAction()->GetIGameTokenSystem();
  501.                                 pGTS->GetTokenValueAs("vehicle.rpmNorm", value);
  502.                                 SetLocalBaseTM(m_initialTM * Matrix33::CreateRotationZ(-value * m_dialsRotMax - m_initialRotOfs));
  503.                         }
  504.                 }
  505.         }
  506. #endif
  507. }
  508.  
  509. //------------------------------------------------------------------------
  510. IStatObj* CVehiclePartAnimatedJoint::GetStatObj()
  511. {
  512.         if (m_pCharInstance && m_jointId > -1)
  513.         {
  514.                 ISkeletonPose* pSkeletonPose = m_pCharInstance->GetISkeletonPose();
  515.                 CRY_ASSERT(pSkeletonPose);
  516.                 return pSkeletonPose->GetStatObjOnJoint(m_jointId);
  517.         }
  518.  
  519.         return NULL;
  520. }
  521.  
  522. //------------------------------------------------------------------------
  523. bool CVehiclePartAnimatedJoint::SetStatObj(IStatObj* pStatObj)
  524. {
  525.         if (!m_pCharInstance || m_jointId == -1)
  526.                 return false;
  527.  
  528.         if (pStatObj)
  529.         {
  530.                 IStatObj* pOld = m_pCharInstance->GetISkeletonPose()->GetStatObjOnJoint(m_jointId);
  531.                 if (!pOld)
  532.                 {
  533.                         if (pStatObj->IsPhysicsExist())
  534.                         {
  535.                                 // if setting a StatObj (with physics) on an empty joint, need to rephysicalize parent
  536.                                 m_pVehicle->RequestPhysicalization(GetParent(true), true);
  537.                                 m_pVehicle->RequestPhysicalization(this, true);
  538.                         }
  539.                 }
  540.         }
  541.  
  542.         SetCGASlot(m_jointId, pStatObj);
  543.  
  544.         if (pStatObj && m_pGeometry)
  545.                 m_pMaterial = pStatObj->GetMaterial();
  546.  
  547.         return true;
  548. }
  549.  
  550. //------------------------------------------------------------------------
  551. IMaterial* CVehiclePartAnimatedJoint::GetMaterial()
  552. {
  553.         if (m_pCharInstance && m_jointId > -1)
  554.         {
  555.                 if (IStatObj* pStatObj = m_pCharInstance->GetISkeletonPose()->GetStatObjOnJoint(m_jointId))
  556.                 {
  557.                         return pStatObj->GetMaterial();
  558.                 }
  559.         }
  560.  
  561.         return NULL;
  562. }
  563.  
  564. //------------------------------------------------------------------------
  565. void CVehiclePartAnimatedJoint::SetMaterial(IMaterial* pMaterial)
  566. {
  567.         if (m_pCharInstance && m_jointId > -1)
  568.         {
  569.                 if (IStatObj* pStatObj = m_pCharInstance->GetISkeletonPose()->GetStatObjOnJoint(m_jointId))
  570.                 {
  571.                         if (m_pGeometry && m_pMaterial && !m_bUsePaintMaterial)
  572.                         {
  573.                                 pStatObj->SetMaterial(m_pMaterial);
  574.                                 m_pCharInstance->GetISkeletonPose()->SetMaterialOnJoint(m_jointId, m_pMaterial);
  575.                         }
  576.                         else
  577.                                 pStatObj->SetMaterial(pMaterial);
  578.                 }
  579.         }
  580. }
  581.  
  582. //------------------------------------------------------------------------
  583. void CVehiclePartAnimatedJoint::InvalidateTM(bool invalidate)
  584. {
  585.         if (invalidate && !m_localTMInvalid)
  586.         {
  587.                 // invalidate all children
  588.                 for (TVehicleChildParts::iterator it = m_children.begin(); it != m_children.end(); ++it)
  589.                         (*it)->InvalidateTM(true);
  590.         }
  591.  
  592.         m_localTMInvalid = invalidate;
  593. }
  594.  
  595. //------------------------------------------------------------------------
  596. void CVehiclePartAnimatedJoint::OnVehicleEvent(EVehicleEvent event, const SVehicleEventParams& params)
  597. {
  598.         CVehiclePartBase::OnVehicleEvent(event, params);
  599.  
  600.         switch (event)
  601.         {
  602.         case eVE_PreVehicleDeletion:
  603.                 {
  604.                         m_pAnimatedPart = 0;
  605.                         break;
  606.                 }
  607.         }
  608. }
  609.  
  610. //------------------------------------------------------------------------
  611. void CVehiclePartAnimatedJoint::OnEvent(const SVehiclePartEvent& event)
  612. {
  613.         CVehiclePartBase::OnEvent(event);
  614.  
  615.         if (!m_pCharInstance || m_jointId < 0)
  616.                 return;
  617.  
  618.         switch (event.type)
  619.         {
  620.         case eVPE_StopUsing:
  621.                 {
  622.                         m_pCharInstance->SetFlags(m_pCharInstance->GetFlags() & (~CS_FLAG_UPDATE));
  623.                         break;
  624.                 }
  625.  
  626.         case eVPE_StartUsing:
  627.                 {
  628.                         m_pCharInstance->SetFlags(m_pCharInstance->GetFlags() | CS_FLAG_UPDATE);
  629.                         break;
  630.                 }
  631.         }
  632. }
  633.  
  634. void CVehiclePartAnimatedJoint::GetMemoryUsage(ICrySizer* s) const
  635. {
  636.         s->Add(*this);
  637.         s->AddObject(m_pAnimatedPart);
  638.         CVehiclePartBase::GetMemoryUsageInternal(s);
  639. }
  640.  
  641. DEFINE_VEHICLEOBJECT(CVehiclePartAnimatedJoint);
  642.  
downloadVehiclePartAnimatedJoint.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