BVB Source Codes

CRYENGINE Show SegmentedWorld.h Source code

Return Download CRYENGINE: download SegmentedWorld.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   SegmentedWorld.h
  5. //  Version:     v1.00
  6. //  Created:     4/11/2011 by Allen Chen
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef __Segmented_World_h__
  15. #define __Segmented_World_h__
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include "SegmentNode.h"
  22. #include "ILevelSystem.h"
  23. #include <CryMemory/PoolAllocator.h>
  24.  
  25. // Helper struct for storing a position which will be automatically
  26. // adjusted when the world is shifted.
  27. // The main idea for this struct to serve as an abstraction to the game
  28. // code from the shifts triggered by when the segmented world loads/unloads
  29. // new segments, when it comes to storing positions in world coordinates.
  30. struct SegmentedWorldLocation : public Vec3, public ISystemEventListener
  31. {
  32. public:
  33.         SegmentedWorldLocation(const Vec3& vec3) : Vec3(vec3)
  34.         {
  35.                 gEnv->pSystem->GetISystemEventDispatcher()->RegisterListener(this);
  36.         }
  37.  
  38.         ~SegmentedWorldLocation()
  39.         {
  40.                 gEnv->pSystem->GetISystemEventDispatcher()->RemoveListener(this);
  41.         }
  42.  
  43.         virtual void OnSystemEvent(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam)
  44.         {
  45.                 if (event == ESYSTEM_EVENT_SW_SHIFT_WORLD)
  46.                 {
  47.                         Vec3* offset = (Vec3*)wparam;
  48.                         *this += *offset;
  49.                 }
  50.         }
  51.  
  52. private:
  53.         SegmentedWorldLocation() {}
  54. };
  55.  
  56. class CSegmentedWorld : public ISegmentsManager, public ILevelSystemListener
  57. {
  58. public:
  59.         CSegmentedWorld();
  60.         ~CSegmentedWorld();
  61.  
  62.         void Update();
  63.         void PostUpdate();
  64.         bool IsInsideSegmentedWorld(const Vec3& pt);
  65.         bool MoveToSegment(int x, int y);
  66.  
  67.         // Convert position from world space to screen space
  68.         inline Vec3 WorldToScreenPosition(const Vec3& InPos)
  69.         {
  70.                 Vec3 OutPos;
  71.                 OutPos.x = InPos.x * m_invSegmentSizeMeters;
  72.                 OutPos.y = InPos.y * m_invSegmentSizeMeters;
  73.                 OutPos.z = 0;
  74.                 return OutPos;
  75.         }
  76.  
  77.         // Convert position from world space to grid space
  78.         inline Vec2i WorldToGridPosition(const Vec3& InPos)
  79.         {
  80.                 Vec3 ScreenPos = WorldToScreenPosition(InPos);
  81.                 Vec2i OutPos((int)floorf(ScreenPos.x), (int)floorf(ScreenPos.y));
  82.                 return OutPos;
  83.         }
  84.  
  85.         // Convert position from grid space to world space with zero height
  86.         inline Vec3 GridToWorldPosition(int x, int y) const
  87.         {
  88.                 Vec3 OutPos((float)(x * m_segmentSizeMeters), (float)(y * m_segmentSizeMeters), 0);
  89.                 return OutPos;
  90.         }
  91.  
  92.         inline Vec3 GridToWorldPosition(const Vec2i& InPos) const
  93.         {
  94.                 return GridToWorldPosition(InPos.x, InPos.y);
  95.         }
  96.  
  97.         // ISegmentsManager
  98.         virtual bool CreateSegments(ITerrain* pTerrain)
  99.         {
  100.                 if (!gEnv->p3DEngine->GetITerrain())
  101.                         return false;
  102.  
  103.                 return true;
  104.         }
  105.         virtual bool DeleteSegments(ITerrain* pTerrain) { return true; }
  106.         virtual bool FindSegment(ITerrain* pTerrain, const Vec3& pt, int& nSID);
  107.         virtual bool FindSegmentCoordByID(int nSID, int& x, int& y);
  108.         virtual void GetTerrainSizeInMeters(int& x, int& y);
  109.         virtual int  GetSegmentSizeInMeters() { return m_segmentSizeMeters; }
  110.         virtual void ForceLoadSegments(unsigned int flags)
  111.         {
  112.                 ForceLoadSegments(m_segmentsMin, m_segmentsMax + Vec2i(1, 1), flags);
  113.         }
  114.         virtual Vec3 LocalToAbsolutePosition(Vec3 const& vPos, f32 fDir = 1.f) const
  115.         {
  116.                 Vec3 vOff = GridToWorldPosition(m_accSegmentOffset);
  117.                 vOff *= fDir;
  118.                 return vPos + vOff;
  119.         }
  120.         virtual void WorldVecToGlobalSegVec(const Vec3& inPos, Vec3& outPos, Vec2& outAbsCoords)
  121.         {
  122.                 outAbsCoords = WorldToGridPosition(inPos);
  123.                 outPos = inPos - GridToWorldPosition(outAbsCoords);
  124.         }
  125.         virtual void GlobalSegVecToLocalSegVec(const Vec3& inPos, const Vec2& inAbsCoords, Vec3& outPos)
  126.         {
  127. #if USE_RELATIVE_COORD
  128.                 Vec2i offset = inAbsCoords - m_neededSegmentsMin;
  129. #else
  130.                 Vec2i offset = inAbsCoords;
  131. #endif
  132.                 outPos = inPos + GridToWorldPosition(offset);
  133.         }
  134.         virtual Vec3 WorldVecToLocalSegVec(const Vec3& inPos)
  135.         {
  136.                 return inPos - GridToWorldPosition(m_neededSegmentsMin);
  137.         }
  138.         // ~ISegmentsManager
  139.  
  140.         // ILevelSystemListener
  141.         virtual void OnLevelNotFound(const char* levelName) {};
  142.         virtual void OnLoadingStart(ILevelInfo* pLevel);
  143.         virtual void OnLoadingComplete(ILevelInfo* pLevel);
  144.         virtual void OnLoadingError(ILevelInfo* pLevel, const char* error)     {};
  145.         virtual void OnLoadingProgress(ILevelInfo* pLevel, int progressAmount) {};
  146.         virtual void OnUnloadComplete(ILevelInfo* pLevel);
  147.         // ~ILevelSystemListener
  148.  
  149.         CSegmentNode* FindSegNodeByWorldPos(const Vec3& pos);
  150.  
  151.         virtual bool  PushEntityToSegment(unsigned int id, bool bLocal = true);
  152.  
  153. protected:
  154.         // Reset the data structures and variables
  155.         void Reset();
  156.  
  157.         // Load the segment data in the background and returns its segment id.
  158.         CSegmentNode* PreloadSegment(int wx, int wy);
  159.  
  160.         // Remove a segment from the world and frees all associated memory.
  161.         void DeleteSegment(int wx, int wy);
  162.  
  163.         // Update boundary info of active segments
  164.         void UpdateActiveSegmentBound(const Vec2i& offset);
  165.  
  166.         // Load the initial segmented world based on the specified point in world space
  167.         bool LoadInitialWorld(const Vec3& pos);
  168.  
  169.         // Load segments data within the given boundary
  170.         void ForceLoadSegments(const Vec2i& segmentsMin, const Vec2i& segmentsMax, unsigned int flags = ISegmentsManager::slfAll);
  171.  
  172.         // Update all the activated segments according to the focal point
  173.         void UpdateSegment(int wx, int wy);
  174.  
  175.         // Determine whether a segment needs to be updated with the given coordinate
  176.         bool NeedToUpdateSegment(int wx, int wy);
  177.  
  178.         // Select a segment to update with the highest priority according to the focal point
  179.         Vec2i SelectSegmentToUpdate(const Vec2i& focalPointWC);
  180.  
  181.         //adjust Entity position with GlobalInSW.
  182.         void AdjustGlobalObjects();
  183.  
  184.         // Helper functions
  185.         CSegmentNode* FindSegmentByID(int nSID);
  186.         CSegmentNode* FindSegmentByWorldCoords(int wx, int wy);
  187.         CSegmentNode* FindSegmentByLocalCoords(int lx, int ly);
  188.  
  189.         // Draw debug info
  190.         void DrawDebugInfo();
  191.         void DrawSegmentGrid(const Vec2& origin, float size);
  192.         void PrintSegmentInfo(const Vec2& origin, float size);
  193.         void PrintMemoryInfo(const Vec2& origin, float size);
  194.  
  195.         std::vector<CSegmentNode*>         m_arrSegments;
  196.  
  197.         Vec3                               m_worldFocalPoint;
  198.         Vec2                               m_neededSegmentsHalfSizeMeters;
  199.         Vec2i                              m_gridFocalPointWC;
  200.         Vec2i                              m_gridFocalPointLC;
  201.         Vec2i                              m_neededSegmentsMin;
  202.         Vec2i                              m_neededSegmentsMax;
  203.         Vec2i                              m_neededSegmentsCenter;
  204.         Vec2i                              m_segmentsMin;
  205.         Vec2i                              m_segmentsMax;
  206.         Vec2i                              m_accSegmentOffset;
  207.         int                                m_segmentSizeMeters;
  208.         float                              m_invSegmentSizeMeters;
  209.  
  210.         stl::TPoolAllocator<CSegmentNode>* m_pPoolAllocator;
  211.  
  212.         bool                               m_bInitialWorldReady;
  213.  
  214. public:
  215.         static string     s_levelName;
  216.         static XmlNodeRef s_levelSurfaceTypes;
  217.         static XmlNodeRef s_levelObjects;
  218. };
  219.  
  220. #endif // __Segmented_World_h__
  221.  
downloadSegmentedWorld.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