BVB Source Codes

CRYENGINE Show SurfaceTypeManager.cpp Source code

Return Download CRYENGINE: download SurfaceTypeManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   SurfaceManager.cpp
  5. //  Version:     v1.00
  6. //  Created:     29/9/2004 by Timur.
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15. #include "SurfaceTypeManager.h"
  16. #include <CryAction/IMaterialEffects.h>
  17.  
  18. #include <CryScriptSystem/IScriptSystem.h>
  19. #include <CrySystem/File/ICryPak.h>
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  23.  
  24. #define BASE_DYNAMIC_SURFACE_ID 100
  25. #define DEFAULT_MATERIAL_NAME   "mat_default"
  26.  
  27. //////////////////////////////////////////////////////////////////////////
  28. template<class TMap>
  29. class CSurfaceTypeEnumerator : public ISurfaceTypeEnumerator
  30. {
  31.         std::vector<ISurfaceType*> m_items;
  32.         typename std::vector<ISurfaceType*>::iterator m_iterator;
  33.  
  34. public:
  35.         CSurfaceTypeEnumerator(TMap* pMap)
  36.         {
  37.                 assert(pMap);
  38.                 m_items.reserve(pMap->size());
  39.                 for (typename TMap::iterator it = pMap->begin(); it != pMap->end(); ++it)
  40.                 {
  41.                         m_items.push_back(it->second->pSurfaceType);
  42.                 }
  43.                 m_iterator = m_items.begin();
  44.         }
  45.         virtual void          Release() { delete this; };
  46.         virtual ISurfaceType* GetFirst()
  47.         {
  48.                 m_iterator = m_items.begin();
  49.                 if (m_iterator == m_items.end())
  50.                         return 0;
  51.                 return *m_iterator;
  52.         }
  53.         virtual ISurfaceType* GetNext()
  54.         {
  55.                 if (m_iterator != m_items.end())
  56.                         ++m_iterator;
  57.                 if (m_iterator == m_items.end())
  58.                         return 0;
  59.                 return *m_iterator;
  60.         }
  61. };
  62.  
  63. //////////////////////////////////////////////////////////////////////////
  64. //
  65. //////////////////////////////////////////////////////////////////////////
  66. class CMaterialSurfaceType : public ISurfaceType
  67. {
  68. public:
  69.         string                          m_name;
  70.         string                          m_typename;
  71.         int                             m_nId;
  72.         int                             m_nFlags;
  73.         SSurfaceTypeAIParams*           m_aiParams;
  74.         SPhysicalParams                 m_physParams;
  75.         SBreakable2DParams*             m_pBreakable2DParams;
  76.         std::vector<SBreakageParticles> m_breakageParticles;
  77.  
  78.         CMaterialSurfaceType(const char* name)
  79.         {
  80.                 m_name = name;
  81.                 m_nId = -1;
  82.                 m_nFlags = 0;
  83.                 m_aiParams = 0;
  84.                 m_pBreakable2DParams = 0;
  85.                 memset(&m_physParams, 0, sizeof(m_physParams));
  86.         }
  87.         ~CMaterialSurfaceType()
  88.         {
  89.                 delete m_pBreakable2DParams;
  90.                 delete m_aiParams;
  91.         }
  92.  
  93.         void Reset()
  94.         {
  95.                 SAFE_DELETE(m_aiParams);
  96.                 SAFE_DELETE(m_pBreakable2DParams);
  97.                 stl::free_container(m_breakageParticles);
  98.                 stl::free_container(m_typename);
  99.         }
  100.  
  101.         //////////////////////////////////////////////////////////////////////////
  102.         // ISurfaceType interface
  103.         //////////////////////////////////////////////////////////////////////////
  104.         virtual void                        Release()                                  { delete this; }
  105.         virtual uint16                      GetId() const                              { return m_nId; }
  106.         virtual const char*                 GetName() const                            { return m_name; }
  107.         virtual const char*                 GetType() const                            { return m_typename; };
  108.         virtual int                         GetFlags() const                           { return m_nFlags; };
  109.         virtual void                        Execute(SSurfaceTypeExecuteParams& params) {};
  110.         virtual bool                        Load(int nId)                              { m_nId = nId; return true; };
  111.         virtual int                         GetBreakability() const                    { return m_physParams.iBreakability; }
  112.         virtual int                         GetHitpoints() const                       { return (int)m_physParams.hit_points; }
  113.         virtual float                       GetBreakEnergy() const                     { return (float)m_physParams.break_energy; }
  114.         virtual const SSurfaceTypeAIParams* GetAIParams()                              { return m_aiParams; };
  115.         virtual const SPhysicalParams& GetPhyscalParams()                         { return m_physParams; };
  116.         virtual SBreakable2DParams*    GetBreakable2DParams()                     { return m_pBreakable2DParams; };
  117.         virtual SBreakageParticles*    GetBreakageParticles(const char* sType, bool bLookInDefault = true);
  118.         //////////////////////////////////////////////////////////////////////////
  119. };
  120.  
  121. CMaterialSurfaceType* g_pDefaultSurfaceType = NULL;
  122.  
  123. //////////////////////////////////////////////////////////////////////////
  124. CMaterialSurfaceType::SBreakageParticles* CMaterialSurfaceType::GetBreakageParticles(const char* sType, bool bLookInDefault)
  125. {
  126.         for (int i = 0, num = m_breakageParticles.size(); i < num; i++)
  127.         {
  128.                 if (strcmp(sType, m_breakageParticles[i].type) == 0)
  129.                 {
  130.                         return &m_breakageParticles[i];
  131.                 }
  132.         }
  133.         if (bLookInDefault && g_pDefaultSurfaceType)
  134.         {
  135.                 for (int i = 0, num = g_pDefaultSurfaceType->m_breakageParticles.size(); i < num; i++)
  136.                 {
  137.                         if (strcmp(sType, g_pDefaultSurfaceType->m_breakageParticles[i].type) == 0)
  138.                         {
  139.                                 return &g_pDefaultSurfaceType->m_breakageParticles[i];
  140.                         }
  141.                 }
  142.         }
  143.         return 0;
  144. }
  145.  
  146. //////////////////////////////////////////////////////////////////////////
  147. static void ReloadSurfaceTypes(IConsoleCmdArgs* pArgs)
  148. {
  149.         CSurfaceTypeManager* pMgr = (CSurfaceTypeManager*)(gEnv->p3DEngine->GetMaterialManager()->GetSurfaceTypeManager());
  150.         pMgr->LoadSurfaceTypes();
  151.  
  152. }
  153.  
  154. //////////////////////////////////////////////////////////////////////////
  155. // SurfaceManager implementation.
  156. //////////////////////////////////////////////////////////////////////////
  157. CSurfaceTypeManager::CSurfaceTypeManager()
  158. {
  159.         m_lastSurfaceId = BASE_DYNAMIC_SURFACE_ID;
  160.         memset(m_idToSurface, 0, sizeof(m_idToSurface));
  161.  
  162.         m_pDefaultSurfaceType = new CMaterialSurfaceType(DEFAULT_MATERIAL_NAME);
  163.         m_pDefaultSurfaceType->m_nId = 0;
  164.         RegisterSurfaceType(m_pDefaultSurfaceType, true);
  165.         g_pDefaultSurfaceType = m_pDefaultSurfaceType;
  166.  
  167.         REGISTER_COMMAND("e_ReloadSurfaces", &ReloadSurfaceTypes, VF_NULL, "Reload physical properties of all materials");
  168. }
  169.  
  170. //////////////////////////////////////////////////////////////////////////
  171. CSurfaceTypeManager::~CSurfaceTypeManager()
  172. {
  173.         g_pDefaultSurfaceType = NULL;
  174.         RemoveAll();
  175.         m_pDefaultSurfaceType->Release();
  176. }
  177.  
  178. //////////////////////////////////////////////////////////////////////////
  179. void CSurfaceTypeManager::RemoveAll()
  180. {
  181.         // Release all materials.
  182.         for (NameToSurfaceMap::iterator it = m_nameToSurface.begin(); it != m_nameToSurface.end(); ++it)
  183.         {
  184.                 SSurfaceRecord* pRec = it->second;
  185.                 if (pRec->pSurfaceType && pRec->pSurfaceType != m_pDefaultSurfaceType)
  186.                         pRec->pSurfaceType->Release();
  187.                 delete pRec;
  188.         }
  189.  
  190.         if (m_pDefaultSurfaceType)
  191.         {
  192.                 m_pDefaultSurfaceType->Reset();
  193.         }
  194.  
  195.         stl::free_container(m_nameToSurface);
  196.         memset(m_idToSurface, 0, sizeof(m_idToSurface));
  197. }
  198.  
  199. //////////////////////////////////////////////////////////////////////////
  200. ISurfaceType* CSurfaceTypeManager::GetSurfaceTypeByName(const char* sName, const char* sWhy, bool warn)
  201. {
  202.         if (!sName || *sName == 0 || m_nameToSurface.size() == 1)
  203.         {
  204.                 // Empty surface type.
  205.                 return m_pDefaultSurfaceType;
  206.         }
  207.  
  208.         NameToSurfaceMap::iterator it = m_nameToSurface.find(CONST_TEMP_STRING(sName));
  209.  
  210.         SSurfaceRecord* pRec = 0;
  211.  
  212.         if (it != m_nameToSurface.end())
  213.                 pRec = it->second;
  214.  
  215.         if (!pRec || !pRec->pSurfaceType)
  216.         {
  217.                 if (!sWhy)
  218.                         sWhy = "";
  219.                 if (warn)
  220.                         Warning("'%s' undefined surface type, using mat_default (%s)", sName, sWhy);
  221.                 return m_pDefaultSurfaceType;
  222.         }
  223.  
  224.         if (!pRec->bLoaded)
  225.         {
  226.                 pRec->pSurfaceType->Load(pRec->pSurfaceType->GetId());
  227.                 pRec->bLoaded = true;
  228.         }
  229.         return pRec->pSurfaceType;
  230. }
  231.  
  232. //////////////////////////////////////////////////////////////////////////
  233. ISurfaceType* CSurfaceTypeManager::GetSurfaceTypeFast(int nSurfaceId, const char* sWhy)
  234. {
  235.         if (nSurfaceId <= 0 || nSurfaceId >= MAX_SURFACE_ID)
  236.                 return m_pDefaultSurfaceType;
  237.         SSurfaceRecord* pRec = m_idToSurface[nSurfaceId];
  238.         if (!pRec || !pRec->pSurfaceType)
  239.         {
  240.                 //Warning( "'%d' undefined surface type id, using mat_default (%s)",nSurfaceId,sWhy );
  241.                 return m_pDefaultSurfaceType;
  242.         }
  243.  
  244.         if (!pRec->bLoaded)
  245.         {
  246.                 pRec->pSurfaceType->Load(pRec->pSurfaceType->GetId());
  247.                 pRec->bLoaded = true;
  248.         }
  249.  
  250.         return pRec->pSurfaceType;
  251. }
  252.  
  253. //////////////////////////////////////////////////////////////////////////
  254. ISurfaceType* CSurfaceTypeManager::GetSurfaceType(int nSurfaceId, const char* sWhy)
  255. {
  256.         return GetSurfaceTypeFast(nSurfaceId, sWhy);
  257. }
  258.  
  259. //////////////////////////////////////////////////////////////////////////
  260. ISurfaceTypeEnumerator* CSurfaceTypeManager::GetEnumerator()
  261. {
  262.         return new CSurfaceTypeEnumerator<NameToSurfaceMap>(&m_nameToSurface);
  263. }
  264.  
  265. //////////////////////////////////////////////////////////////////////////
  266. bool CSurfaceTypeManager::RegisterSurfaceType(ISurfaceType* pSurfaceType, bool bDefault)
  267. {
  268.         assert(pSurfaceType);
  269.  
  270.         int nSurfTypeId = pSurfaceType->GetId();
  271.  
  272.         SSurfaceRecord* pRecord = NULL;
  273.  
  274.         if (nSurfTypeId >= 0 && nSurfTypeId <= MAX_SURFACE_ID)
  275.         {
  276.                 pRecord = m_idToSurface[nSurfTypeId];
  277.                 if (pRecord)
  278.                         return true; // Already registered.
  279.         }
  280.  
  281.         int nId = m_lastSurfaceId;
  282.         if (nId > MAX_SURFACE_ID)
  283.                 return false;
  284.  
  285.         if (bDefault)
  286.         {
  287.                 nId = 0;
  288.                 //m_pDefaultSurfaceType = pSurfaceType;
  289.         }
  290.         if (!pSurfaceType->Load(nId))
  291.                 return false;
  292.  
  293.         if (!bDefault)
  294.         {
  295.                 m_lastSurfaceId++;
  296.         }
  297.  
  298.         pRecord = new SSurfaceRecord;
  299.         pRecord->bLoaded = true;
  300.         pRecord->pSurfaceType = pSurfaceType;
  301.  
  302.         m_idToSurface[nId] = pRecord;
  303.         m_nameToSurface[pSurfaceType->GetName()] = pRecord;
  304.  
  305.         return true;
  306. }
  307.  
  308. //////////////////////////////////////////////////////////////////////////
  309. void CSurfaceTypeManager::UnregisterSurfaceType(ISurfaceType* pSurfaceType)
  310. {
  311.         assert(pSurfaceType);
  312.  
  313.         assert(pSurfaceType->GetId() <= MAX_SURFACE_ID);
  314.  
  315.         SSurfaceRecord* pRecord = m_idToSurface[pSurfaceType->GetId()];
  316.         if (pRecord)
  317.         {
  318.                 m_idToSurface[pSurfaceType->GetId()] = 0;
  319.                 m_nameToSurface.erase(pSurfaceType->GetName());
  320.                 delete pRecord;
  321.         }
  322. }
  323.  
  324. //////////////////////////////////////////////////////////////////////////
  325. void CSurfaceTypeManager::LoadSurfaceTypes()
  326. {
  327.         XmlNodeRef root = GetISystem()->LoadXmlFromFile("Libs/MaterialEffects/SurfaceTypes.xml");
  328.         if (!root)
  329.                 return;
  330.  
  331.         RemoveAll();
  332.  
  333.         m_lastSurfaceId = BASE_DYNAMIC_SURFACE_ID;
  334.         RegisterSurfaceType(m_pDefaultSurfaceType, true);
  335.  
  336.         for (int i = 0, nChilds = root->getChildCount(); i < nChilds; i++)
  337.         {
  338.                 SLICE_AND_SLEEP();
  339.  
  340.                 XmlNodeRef matNode = root->getChild(i);
  341.                 if (!matNode->isTag("SurfaceType"))
  342.                         continue;
  343.  
  344.                 const char* sName = matNode->getAttr("name");
  345.                 NameToSurfaceMap::iterator it = m_nameToSurface.find(CONST_TEMP_STRING(sName));
  346.                 CMaterialSurfaceType* pSurfaceType = 0;
  347.                 if (it != m_nameToSurface.end())
  348.                 {
  349.                         pSurfaceType = (CMaterialSurfaceType*)it->second->pSurfaceType;
  350.                 }
  351.                 if (strcmp(sName, DEFAULT_MATERIAL_NAME) == 0)
  352.                 {
  353.                         pSurfaceType = m_pDefaultSurfaceType;
  354.                 }
  355.  
  356.                 if (!pSurfaceType)
  357.                 {
  358.                         pSurfaceType = new CMaterialSurfaceType(sName);
  359.                         bool bDefault = false;
  360.                         if (!RegisterSurfaceType(pSurfaceType, bDefault))
  361.                                 continue;
  362.                 }
  363.  
  364.                 int bManuallyBreakable = 0;
  365.                 bool bNoCollide = false;
  366.                 bool vehicle_only_collisions = false;
  367.                 bool nBreakable2d = 0;
  368.                 bool can_shatter = false;
  369.  
  370.                 ISurfaceType::SPhysicalParams& physParams = pSurfaceType->m_physParams;
  371.  
  372.                 pSurfaceType->m_typename = matNode->getAttr("type");
  373.                 if (pSurfaceType->m_typename.empty())
  374.                 {
  375.                         // typename will be name with mat_ prefix.
  376.                         pSurfaceType->m_typename = pSurfaceType->m_name;
  377.                         if (pSurfaceType->m_typename.find("mat_") == 0)
  378.                         {
  379.                                 pSurfaceType->m_typename = pSurfaceType->m_typename.substr(4);
  380.                         }
  381.                 }
  382.  
  383.                 XmlNodeRef physNode = matNode->findChild("Physics");
  384.                 physParams.friction = 0.7f;
  385.                 physParams.breakable_id = -1;
  386.                 physParams.collType = 1 << 31; // means "use default"
  387.                 physParams.sound_obstruction = 0.0f;
  388.  
  389.                 if (physNode)
  390.                 {
  391.                         physNode->getAttr("friction", physParams.friction);
  392.                         physNode->getAttr("elasticity", physParams.bouncyness);
  393.                         physNode->getAttr("breakable_id", physParams.breakable_id);
  394.                         physNode->getAttr("pierceability", physParams.pierceability = 0);
  395.                         physNode->getAttr("damage_reduction", physParams.damage_reduction = 0);
  396.                         physNode->getAttr("ricochet_angle", physParams.ric_angle = 0);
  397.                         physNode->getAttr("ric_dam_reduction", physParams.ric_dam_reduction = 0);
  398.                         physNode->getAttr("ric_vel_reduction", physParams.ric_vel_reduction = 0);
  399.                         physNode->getAttr("no_collide", bNoCollide = 0);
  400.                         physNode->getAttr("break_energy", physParams.break_energy = 0);
  401.                         physNode->getAttr("hit_points", physParams.hit_points = 0);
  402.                         physNode->getAttr("hit_radius", physParams.hit_radius = 10000.0f);
  403.                         physNode->getAttr("hit_maxdmg", physParams.hit_maxdmg = 1000);
  404.                         physNode->getAttr("hit_lifetime", physParams.hit_lifetime = 10.0f);
  405.                         physNode->getAttr("hole_size", physParams.hole_size);
  406.                         physNode->getAttr("hole_size_explosion", physParams.hole_size_explosion = 0.0f);
  407.                         physNode->getAttr("breakable_2d", nBreakable2d);
  408.                         physNode->getAttr("hit_points_secondary", physParams.hit_points_secondary = nBreakable2d ? 1.0f : physParams.hit_points);
  409.                         physNode->getAttr("vehicle_only_collisions", vehicle_only_collisions);
  410.                         physNode->getAttr("can_shatter", can_shatter);
  411.                         physNode->getAttr("sound_obstruction", physParams.sound_obstruction);
  412.  
  413.                         string collTypeStr = physNode->getAttr("coll_types");
  414.                         if (collTypeStr.length())
  415.                         {
  416.                                 physParams.collType = geom_floats;
  417.                                 for (const char* ptr = collTypeStr.c_str(); *ptr; )
  418.                                 {
  419.                                         for (; *ptr && (unsigned char)(*ptr - '0') > 9u; ptr++)
  420.                                                 ;
  421.                                         const char* ptr0 = ptr;
  422.                                         int num = 0;
  423.                                         for (; (unsigned char)(*ptr - '0') <= 9u; (num *= 10) += *ptr++ - '0')
  424.                                                 ;
  425.                                         if (ptr > ptr0)
  426.                                                 if (ptr0 > collTypeStr.c_str() && (ptr0[-1] == '-' || ptr0[-1] == '~'))
  427.                                                         physParams.collType &= ~(1 << num);
  428.                                                 else
  429.                                                         physParams.collType |= 1 << num;
  430.                                 }
  431.                                 const char* collNames[] = { "default", "all", "player", "vehicle", "explosion", "ray", "float", "water" };
  432.                                 const int collVals[] = { geom_colltype0, geom_collides, geom_colltype_player, geom_colltype_vehicle, geom_colltype_explosion, geom_colltype_ray, geom_floats, geom_floats };
  433.                                 for (int j = 0; j < CRY_ARRAY_COUNT(collVals); j++)
  434.                                         if (const char* name = strstr(collTypeStr.c_str(), collNames[j]))
  435.                                                 if (name > collTypeStr.c_str() && (name[-1] == '-' || name[-1] == '~'))
  436.                                                         physParams.collType &= ~collVals[j];
  437.                                                 else
  438.                                                         physParams.collType |= collVals[j];
  439.                         }
  440.                         else
  441.                                 physParams.collType = 1 << 31;
  442.  
  443.                         //Clamp pierceability
  444.                         physParams.pierceability = max(0, min(15, physParams.pierceability));
  445.  
  446.                         // only assign if the object is not the same, otherwise the compiler
  447.                         // will invoke a memcpy with the same source and destination
  448.                         if (&pSurfaceType->m_physParams != &physParams)
  449.                                 pSurfaceType->m_physParams = physParams;
  450.  
  451.                         if (physParams.break_energy != 0)
  452.                         {
  453.                                 physParams.iBreakability = nBreakable2d ? 1 : 2;
  454.                                 bManuallyBreakable = sf_manually_breakable;
  455.                         }
  456.  
  457.                         if (bNoCollide)
  458.                                 pSurfaceType->m_nFlags |= SURFACE_TYPE_NO_COLLIDE;
  459.                         if (vehicle_only_collisions)
  460.                                 pSurfaceType->m_nFlags |= SURFACE_TYPE_VEHICLE_ONLY_COLLISION;
  461.                         if (can_shatter)
  462.                                 pSurfaceType->m_nFlags |= SURFACE_TYPE_CAN_SHATTER;
  463.  
  464.                         if (gEnv->pPhysicalWorld)
  465.                         {
  466.                                 gEnv->pPhysicalWorld->SetSurfaceParameters(pSurfaceType->GetId(), physParams.bouncyness, physParams.friction, physParams.damage_reduction,
  467.                                                                            physParams.ric_angle, physParams.ric_dam_reduction, physParams.ric_vel_reduction,
  468.                                                                            sf_pierceability(physParams.pierceability) | sf_matbreakable(physParams.breakable_id) | bManuallyBreakable);
  469.                         }
  470.                 }
  471.  
  472.                 XmlNodeRef break2dNode = matNode->findChild("breakable_2d");
  473.                 if (break2dNode)
  474.                 {
  475.                         ISurfaceType::SBreakable2DParams break2dParams;
  476.                         break2dNode->getAttr("blast_radius", break2dParams.blast_radius = 0.2f);
  477.                         if (!break2dNode->getAttr("blast_radius_first", break2dParams.blast_radius_first = 0.2f))
  478.                                 break2dParams.blast_radius_first = break2dParams.blast_radius;
  479.                         break2dNode->getAttr("vert_size_spread", break2dParams.vert_size_spread = 0.0f);
  480.                         break2dNode->getAttr("rigid_body", break2dParams.rigid_body = 0);
  481.                         break2dNode->getAttr("lifetime", break2dParams.life_time = 4.0f);
  482.                         break2dParams.particle_effect = break2dNode->getAttr("particle_effect");
  483.  
  484.                         break2dNode->getAttr("cell_size", break2dParams.cell_size = 0.1f);
  485.                         break2dNode->getAttr("max_patch_tris", break2dParams.max_patch_tris = 6);
  486.                         break2dNode->getAttr("filter_angle", break2dParams.filter_angle = 0.0f);
  487.                         break2dNode->getAttr("shard_density", break2dParams.shard_density = 1200.0f);
  488.  
  489.                         break2dNode->getAttr("crack_decal_scale", break2dParams.crack_decal_scale = 0.0f);
  490.                         break2dParams.crack_decal_mtl = break2dNode->getAttr("crack_decal_mtl");
  491.                         break2dNode->getAttr("max_fracture", break2dParams.max_fracture = 1.0f);
  492.                         break2dParams.full_fracture_fx = break2dNode->getAttr("full_fracture_fx");
  493.                         break2dNode->getAttr("use_edge_alpha", break2dParams.use_edge_alpha = 0);
  494.                         break2dParams.fracture_fx = break2dNode->getAttr("fracture_fx");
  495.                         break2dNode->getAttr("no_procedural_full_fracture", break2dParams.no_procedural_full_fracture = 0);
  496.                         break2dParams.broken_mtl = break2dNode->getAttr("broken_mtl");
  497.                         if (break2dParams.broken_mtl.length())
  498.                                 gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(break2dParams.broken_mtl, false);
  499.                         break2dNode->getAttr("destroy_timeout", break2dParams.destroy_timeout = 0);
  500.                         break2dNode->getAttr("destroy_timeout_spread", break2dParams.destroy_timeout_spread = 0);
  501.  
  502.                         SAFE_DELETE(pSurfaceType->m_pBreakable2DParams);
  503.                         pSurfaceType->m_pBreakable2DParams = new ISurfaceType::SBreakable2DParams;
  504.                         *pSurfaceType->m_pBreakable2DParams = break2dParams;
  505.                 }
  506.  
  507.                 {
  508.                         size_t nBreakageParticles = 0;
  509.                         for (int n = 0; n < matNode->getChildCount(); n++)
  510.                         {
  511.                                 XmlNodeRef breakageNode = matNode->getChild(n);
  512.                                 if (breakageNode->isTag("BreakageParticles"))
  513.                                         ++nBreakageParticles;
  514.                         }
  515.                         pSurfaceType->m_breakageParticles.reserve(nBreakageParticles);
  516.  
  517.                         // Load Breakage particles.
  518.                         for (int n = 0; n < matNode->getChildCount(); n++)
  519.                         {
  520.                                 XmlNodeRef breakageNode = matNode->getChild(n);
  521.                                 if (breakageNode->isTag("BreakageParticles"))
  522.                                 {
  523.                                         ISurfaceType::SBreakageParticles params;
  524.                                         breakageNode->getAttr("scale", params.scale);
  525.                                         breakageNode->getAttr("count_scale", params.count_scale);
  526.                                         breakageNode->getAttr("count_per_unit", params.count_per_unit);
  527.                                         params.type = breakageNode->getAttr("type");
  528.                                         params.particle_effect = breakageNode->getAttr("effect");
  529.  
  530.                                         pSurfaceType->m_breakageParticles.push_back(params);
  531.                                 }
  532.                         }
  533.                 }
  534.  
  535.                 XmlNodeRef aiNode = matNode->findChild("AI");
  536.                 if (aiNode)
  537.                 {
  538.                         ISurfaceType::SSurfaceTypeAIParams aiParams;
  539.                         aiNode->getAttr("fImpactRadius", aiParams.fImpactRadius);
  540.                         aiNode->getAttr("fImpactSoundRadius", aiParams.fImpactSoundRadius);
  541.                         aiNode->getAttr("fFootStepRadius", aiParams.fFootStepRadius);
  542.                         aiNode->getAttr("proneMult", aiParams.proneMult);
  543.                         aiNode->getAttr("crouchMult", aiParams.crouchMult);
  544.                         aiNode->getAttr("movingMult", aiParams.movingMult);
  545.  
  546.                         SAFE_DELETE(pSurfaceType->m_aiParams);
  547.                         pSurfaceType->m_aiParams = new ISurfaceType::SSurfaceTypeAIParams;
  548.                         *pSurfaceType->m_aiParams = aiParams;
  549.                 }
  550.         }
  551. }
  552.  
downloadSurfaceTypeManager.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