BVB Source Codes

CRYENGINE Show VehicleSystem.h Source code

Return Download CRYENGINE: download VehicleSystem.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Vehicle System
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 05:10:2004   11:55 : Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #ifndef __VEHICLESYSTEM_H__
  15. #define __VEHICLESYSTEM_H__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include "IVehicleSystem.h"
  22.  
  23. typedef std::map<string, IGameObjectExtensionCreatorBase*> TVehicleClassMap;
  24. typedef std::map<EntityId, IVehicle*>                      TVehicleMap;
  25. typedef std::map<string, IVehicleMovement*(*)()>           TVehicleMovementClassMap;
  26. typedef std::map<string, IVehicleView*(*)()>               TVehicleViewClassMap;
  27. typedef std::map<string, IVehiclePart*(*)()>               TVehiclePartClassMap;
  28. typedef std::map<string, IVehicleSeatAction*(*)()>         TVehicleSeatActionClassMap;
  29. typedef std::map<string, IVehicleAction*(*)()>             TVehicleActionClassMap;
  30. typedef std::vector<IVehicleUsageEventListener*>           TVehicleUsageListenerVec;
  31. typedef std::map<EntityId, TVehicleUsageListenerVec>       TVehicleUsageEventListenerList;
  32.  
  33. #if ENABLE_VEHICLE_DEBUG
  34. typedef CryFixedStringT<32> TVehicleListenerId;
  35. #else
  36. typedef int                 TVehicleListenerId;
  37. #endif
  38.  
  39. class CVehicleCVars;
  40. class CVehicleSeat;
  41.  
  42. class CVehicleSystem :
  43.         public IVehicleSystem
  44. {
  45. public:
  46.         CVehicleSystem(ISystem* pSystem, IEntitySystem* pEntitySystem);
  47.         virtual ~CVehicleSystem();
  48.  
  49.         virtual void Release() { delete this; };
  50.  
  51.         virtual void Reset();
  52.  
  53.         virtual void RegisterFactory(const char* name, IVehicleMovement*(*func)(), bool isAI)       { RegisterVehicleMovement(name, func, isAI); };
  54.         virtual void RegisterFactory(const char* name, IVehicleView*(*func)(), bool isAI)           { RegisterVehicleView(name, func, isAI); }
  55.         virtual void RegisterFactory(const char* name, IVehiclePart*(*func)(), bool isAI)           { RegisterVehiclePart(name, func, isAI); }
  56.         virtual void RegisterFactory(const char* name, IVehicleDamageBehavior*(*func)(), bool isAI) { RegisterVehicleDamageBehavior(name, func, isAI); }
  57.         virtual void RegisterFactory(const char* name, IVehicleSeatAction*(*func)(), bool isAI)     { RegisterVehicleSeatAction(name, func, isAI); }
  58.         virtual void RegisterFactory(const char* name, IVehicleAction*(*func)(), bool isAI)         { RegisterVehicleAction(name, func, isAI); }
  59.  
  60.         // IVehicleSystem
  61.         virtual bool                             Init();
  62.         virtual IVehicle*                        CreateVehicle(uint16 channelId, const char* name, const char* vehicleClass, const Vec3& pos, const Quat& rot, const Vec3& scale, EntityId id = 0);
  63.         virtual IVehicle*                        GetVehicle(EntityId entityId);
  64.         virtual IVehicle*                        GetVehicleByChannelId(uint16 channelId);
  65.         virtual bool                             IsVehicleClass(const char* name) const;
  66.  
  67.         virtual IVehicleMovement*                CreateVehicleMovement(const string& name);
  68.         virtual IVehicleView*                    CreateVehicleView(const string& name);
  69.         virtual IVehiclePart*                    CreateVehiclePart(const string& name);
  70.         virtual IVehicleDamageBehavior*          CreateVehicleDamageBehavior(const string& name);
  71.         virtual IVehicleSeatAction*              CreateVehicleSeatAction(const string& name);
  72.         virtual IVehicleAction*                  CreateVehicleAction(const string& name);
  73.  
  74.         virtual void                             RegisterVehicles(IGameFramework* gameFramework);
  75.  
  76.         virtual IVehicleDamagesTemplateRegistry* GetDamagesTemplateRegistry() { return m_pDamagesTemplateRegistry; }
  77.  
  78.         virtual TVehicleObjectId                 AssignVehicleObjectId();
  79.         virtual TVehicleObjectId                 AssignVehicleObjectId(const string& className);
  80.         virtual TVehicleObjectId                 GetVehicleObjectId(const string& className) const;
  81.  
  82.         virtual uint32                           GetVehicleCount() { return uint32(m_vehicles.size()); }
  83.         virtual IVehicleIteratorPtr              CreateVehicleIterator();
  84.  
  85.         virtual IVehicleClient*                  GetVehicleClient() { return m_pVehicleClient; }
  86.         virtual void                             RegisterVehicleClient(IVehicleClient* pVehicleClient);
  87.  
  88.         virtual void                             RegisterVehicleUsageEventListener(const EntityId playerId, IVehicleUsageEventListener* pEventListener);
  89.         virtual void                             UnregisterVehicleUsageEventListener(const EntityId playerId, IVehicleUsageEventListener* pEventListener);
  90.         virtual void                             BroadcastVehicleUsageEvent(const EVehicleEvent eventId, const EntityId playerId, IVehicle* pVehicle);
  91.  
  92.         virtual void                             Update(float deltaTime);
  93.         // ~IVehicleSystem
  94.  
  95.         void                SetInitializingSeat(CVehicleSeat* pSeat) { m_pInitializingSeat = pSeat; };
  96.         CVehicleSeat*       GetInitializingSeat()                    { return m_pInitializingSeat; };
  97.  
  98.         void                RegisterVehicleClass(const char* name, IGameFramework::IVehicleCreator* pCreator, bool isAI);
  99.         void                AddVehicle(EntityId entityId, IVehicle* pProxy);
  100.         void                RemoveVehicle(EntityId entityId);
  101.  
  102.         void                GetVehicleImplementations(SVehicleImpls& impls);
  103.         bool                GetOptionalScript(const char* vehicleName, char* buf, size_t len);
  104.  
  105.         void                RegisterVehicleMovement(const char* name, IVehicleMovement*(*func)(), bool isAI);
  106.         void                RegisterVehicleView(const char* name, IVehicleView*(*func)(), bool isAI);
  107.         void                RegisterVehiclePart(const char* name, IVehiclePart*(*func)(), bool isAI);
  108.         void                RegisterVehicleDamageBehavior(const char* name, IVehicleDamageBehavior*(*func)(), bool isAI);
  109.         void                RegisterVehicleSeatAction(const char* name, IVehicleSeatAction*(*func)(), bool isAI);
  110.         void                RegisterVehicleAction(const char* name, IVehicleAction*(*func)(), bool isAI);
  111.  
  112.         void                RegisterVehicleObject(const string& className, TVehicleObjectId id);
  113.  
  114.         void                LoadDamageTemplates();
  115.         void                ReloadSystem();
  116.  
  117.         bool                OnStartUse(const EntityId playerId, IVehicle* pVehicle);
  118.         void                OnPrePhysicsTimeStep(float deltaTime);
  119.  
  120.         CryCriticalSection& GetCurrentVehicleLock()     { return m_currentVehicleLock; }
  121.         volatile IVehicle*  GetCurrentClientVehicle()   { return m_pCurrentClientVehicle; }
  122.         void                ClearCurrentClientVehicle() { m_pCurrentClientVehicle = NULL; }
  123.         void                GetMemoryStatistics(ICrySizer* s);
  124.  
  125. #if ENABLE_VEHICLE_DEBUG
  126.         static void DumpClasses(IConsoleCmdArgs* pArgs);
  127.  
  128.         typedef std::map<string, int> TVehicleClassCount;
  129.         static TVehicleClassCount s_classInstanceCounts;
  130. #endif
  131.  
  132. private:
  133.         //      static IEntityComponent *CreateVehicle(IEntity *pEntity, SEntitySpawnParams &params, void *pUserData);
  134.         void RegisterCVars();
  135.  
  136.         struct SSpawnUserData
  137.         {
  138.                 SSpawnUserData(const char* cls, uint16 channel) : className(cls), channelId(channel) {}
  139.                 const char* className;
  140.                 uint16      channelId;
  141.         };
  142.  
  143.         struct SVehicleUserData
  144.         {
  145.                 SVehicleUserData(const char* cls, CVehicleSystem* pNewVehicleSystem) : className(cls), pVehicleSystem(pNewVehicleSystem) {};
  146.                 CVehicleSystem* pVehicleSystem;
  147.                 string          className;
  148.         };
  149.  
  150.         class CVehicleIterator : public IVehicleIterator
  151.         {
  152.         public:
  153.                 CVehicleIterator(CVehicleSystem* pVS)
  154.                 {
  155.                         m_pVS = pVS;
  156.                         m_cur = m_pVS->m_vehicles.begin();
  157.                         m_nRefs = 0;
  158.                 }
  159.                 void AddRef()
  160.                 {
  161.                         ++m_nRefs;
  162.                 }
  163.                 void Release()
  164.                 {
  165.                         if (--m_nRefs <= 0)
  166.                         {
  167.                                 assert(std::find(m_pVS->m_iteratorPool.begin(),
  168.                                                  m_pVS->m_iteratorPool.end(), this) == m_pVS->m_iteratorPool.end());
  169.                                 // Call my own destructor before I push to the pool - avoids tripping up the STLP debugging {2008/12/09})
  170.                                 this->~CVehicleIterator();
  171.                                 m_pVS->m_iteratorPool.push_back(this);
  172.                         }
  173.                 }
  174.                 IVehicle* Next()
  175.                 {
  176.                         if (m_cur == m_pVS->m_vehicles.end())
  177.                                 return 0;
  178.                         IVehicle* pVehicle = m_cur->second;
  179.                         ++m_cur;
  180.                         return pVehicle;
  181.                 }
  182.                 size_t Count()
  183.                 {
  184.                         return m_pVS->m_vehicles.size();
  185.                 }
  186.                 CVehicleSystem*       m_pVS;
  187.                 TVehicleMap::iterator m_cur;
  188.                 int                   m_nRefs;
  189.         };
  190.  
  191.         TVehicleMap                m_vehicles;
  192.         TVehicleClassMap           m_classes;
  193.         TVehicleMovementClassMap   m_movementClasses;
  194.         TVehicleViewClassMap       m_viewClasses;
  195.         TVehiclePartClassMap       m_partClasses;
  196.         TVehicleSeatActionClassMap m_seatActionClasses;
  197.         TVehicleActionClassMap     m_actionClasses;
  198.  
  199.         typedef std::map<string, IVehicleDamageBehavior*(*)()> TVehicleDamageBehaviorClassMap;
  200.         TVehicleDamageBehaviorClassMap m_damageBehaviorClasses;
  201.  
  202.         typedef std::map<string, TVehicleObjectId> TVehicleObjectIdMap;
  203.         TVehicleObjectIdMap              m_objectIds;
  204.         TVehicleObjectId                 m_nextObjectId;
  205.  
  206.         IVehicleDamagesTemplateRegistry* m_pDamagesTemplateRegistry;
  207.  
  208.         std::vector<CVehicleIterator*>   m_iteratorPool;
  209.  
  210.         IVehicleClient*                  m_pVehicleClient;
  211.         CVehicleCVars*                   m_pCVars;
  212.  
  213.         CVehicleSeat*                    m_pInitializingSeat;
  214.         volatile IVehicle*               m_pCurrentClientVehicle; // Pointer to the vehicle the client is currently in
  215.  
  216.         TVehicleUsageEventListenerList   m_eventListeners;
  217.  
  218.         CryCriticalSection               m_currentVehicleLock;
  219. };
  220.  
  221. // Summary:
  222. //  implements SEnvironmentLayer
  223. class CEnvironmentLayer : public SEnvironmentLayer
  224. {
  225. public:
  226.         CEnvironmentLayer()
  227.         {
  228.         }
  229.         virtual ~CEnvironmentLayer(){}
  230.  
  231.         const char* GetName() const { return name.c_str(); }
  232.  
  233.         size_t      GetHelperCount() const
  234.         {
  235.                 return helpers.size();
  236.         }
  237.  
  238.         IVehicleHelper* GetHelper(int idx) const
  239.         {
  240.                 CRY_ASSERT(idx >= 0 && idx < (int)helpers.size());
  241.                 return helpers[idx];
  242.         }
  243.  
  244.         size_t GetGroupCount() const
  245.         {
  246.                 return wheelGroups.size();
  247.         }
  248.  
  249.         size_t GetWheelCount(int group) const
  250.         {
  251.                 assert(group >= 0);
  252.  
  253.                 if (group < (int)wheelGroups.size())
  254.                         return wheelGroups[group].m_wheels.size();
  255.  
  256.                 return 0;
  257.         }
  258.  
  259.         int GetWheelAt(int group, int wheel) const
  260.         {
  261.                 assert(group >= 0);
  262.                 assert(wheel >= 0);
  263.  
  264.                 if (group < (int)wheelGroups.size() && wheel < (int)wheelGroups[group].m_wheels.size())
  265.                         return wheelGroups[group].m_wheels[wheel];
  266.  
  267.                 assert(0 && "GetWheelAt: idx out of bounds");
  268.                 return 0;
  269.         }
  270.  
  271.         bool IsGroupActive(int group) const
  272.         {
  273.                 assert(group >= 0);
  274.                 if (group < (int)wheelGroups.size())
  275.                         return wheelGroups[group].active;
  276.  
  277.                 return false;
  278.         }
  279.  
  280.         void SetGroupActive(int group, bool active)
  281.         {
  282.                 if (group < (int)wheelGroups.size())
  283.                         wheelGroups[group].active = active;
  284.         }
  285.  
  286. protected:
  287.  
  288.         struct SWheelGroup
  289.         {
  290.                 std::vector<int> m_wheels;
  291.                 bool             active;
  292.  
  293.                 SWheelGroup()
  294.                 {
  295.                         active = true;
  296.                 }
  297.         };
  298.  
  299.         string                       name;
  300.         std::vector<SWheelGroup>     wheelGroups;
  301.         std::vector<IVehicleHelper*> helpers;
  302.  
  303.         friend class CVehicle;
  304. };
  305.  
  306. // Summary:
  307. // implements SEnvironmentParticles
  308. class CEnvironmentParticles : public SEnvironmentParticles
  309. {
  310. public:
  311.         size_t GetLayerCount() const
  312.         {
  313.                 return layers.size();
  314.         }
  315.         const SEnvironmentLayer& GetLayer(int idx) const
  316.         {
  317.                 return layers[idx];
  318.         }
  319.         const char* GetMFXRowName() const
  320.         {
  321.                 return mfx_rowName.c_str();
  322.         }
  323.  
  324. protected:
  325.         string                         mfx_rowName; // the row name to use to lookup effects in the material effects file (previously hardcoded to vfx_<vehicleclass> )
  326.         std::vector<CEnvironmentLayer> layers;
  327.  
  328.         friend class CVehicle;
  329. };
  330.  
  331. // Summary:
  332. // implements SExhaustParams
  333. class CExhaustParams : public SExhaustParams
  334. {
  335. public:
  336.         CExhaustParams()
  337.         {
  338.         }
  339.         size_t GetExhaustCount() const
  340.         {
  341.                 return helpers.size();
  342.         }
  343.         IVehicleHelper* GetHelper(int idx) const
  344.         {
  345.                 CRY_ASSERT(idx < (int)helpers.size());
  346.                 return helpers[idx];
  347.         }
  348.         const char* GetStartEffect() const { return startEffect.c_str(); }
  349.         const char* GetStopEffect() const  { return stopEffect.c_str(); }
  350.         const char* GetRunEffect() const   { return runEffect.c_str(); }
  351.         const char* GetBoostEffect() const { return boostEffect.c_str(); }
  352.  
  353. protected:
  354.         string                       startEffect;
  355.         string                       stopEffect;
  356.         string                       runEffect;
  357.         string                       boostEffect;
  358.  
  359.         std::vector<IVehicleHelper*> helpers; // one or more exhausts possible
  360.  
  361.         friend class CVehicle;
  362. };
  363.  
  364. // Summary:
  365. //  implements SParticleParams
  366. class CParticleParams : public SParticleParams
  367. {
  368. public:
  369.         SExhaustParams*      GetExhaustParams() { return &m_exhaustParams; }
  370.         const SDamageEffect* GetDamageEffect(const char* pName) const
  371.         {
  372.                 if (pName)
  373.                 {
  374.                         TDamageEffectMap::const_iterator iDamageEffect = damageEffects.find(pName);
  375.  
  376.                         if (iDamageEffect != damageEffects.end())
  377.                         {
  378.                                 return &iDamageEffect->second;
  379.                         }
  380.                 }
  381.  
  382.                 return NULL;
  383.         }
  384.  
  385.         SEnvironmentParticles* GetEnvironmentParticles() { return &m_envParams; }
  386.  
  387. protected:
  388.         CExhaustParams        m_exhaustParams;
  389.         TDamageEffectMap      damageEffects;
  390.         CEnvironmentParticles m_envParams;
  391.  
  392.         friend class CVehicle;
  393. };
  394.  
  395. struct pe_cargeomparams;
  396.  
  397. #endif //__VEHICLESYSTEM_H__
  398.  
downloadVehicleSystem.h 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