BVB Source Codes

CRYENGINE Show CompactSpanGrid.h Source code

Return Download CRYENGINE: download CompactSpanGrid.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __MNM_COMPACT_SPAN_GRID_H
  4. #define __MNM_COMPACT_SPAN_GRID_H
  5.  
  6. #pragma once
  7.  
  8. namespace MNM
  9. {
  10. class DynamicSpanGrid;
  11. class CompactSpanGrid
  12. {
  13. public:
  14.         struct Cell
  15.         {
  16.                 enum
  17.                 {
  18.                         MaxSpanCount = 255,
  19.                 };
  20.  
  21.                 inline Cell()
  22.                         : index(0)
  23.                         , count(0)
  24.                 {
  25.                 }
  26.  
  27.                 inline Cell(uint32 _index, uint32 _count)
  28.                         : index(_index)
  29.                         , count(_count)
  30.                 {
  31.                 }
  32.  
  33.                 inline operator bool() const
  34.                 {
  35.                         return count != 0;
  36.                 }
  37.  
  38.                 uint32 index : 24;
  39.                 uint32 count : 8;
  40.         };
  41.  
  42.         struct Span
  43.         {
  44.                 inline Span()
  45.                         : backface(0)
  46.                         , flags(0)
  47.                         , bottom(0)
  48.                         , height(0)
  49.                         , depth(0)
  50.                 {
  51.                 }
  52.  
  53.                 inline Span(uint16 _bottom, uint16 _height, uint16 _depth, bool _backface)
  54.                         : backface(_backface ? 1 : 0)
  55.                         , flags(0)
  56.                         , bottom(_bottom)
  57.                         , height(_height)
  58.                         , depth(_depth)
  59.                 {
  60.                         assert(height > 0);
  61.                 }
  62.  
  63.                 uint32 backface : 1;
  64.                 uint32 flags    : 3;
  65.                 uint32 bottom   : 9;
  66.                 uint32 height   : 9;
  67.                 uint32 depth    : 10;   // at surface
  68.         };
  69.  
  70.         inline CompactSpanGrid()
  71.                 : m_width(0)
  72.                 , m_height(0)
  73.         {
  74.         }
  75.  
  76.         inline size_t GetCellCount() const
  77.         {
  78.                 return m_cells.size();
  79.         }
  80.  
  81.         inline size_t GetSpanCount() const
  82.         {
  83.                 return m_spans.size();
  84.         }
  85.  
  86.         inline size_t GetWidth() const
  87.         {
  88.                 return m_width;
  89.         }
  90.  
  91.         inline size_t GetHeight() const
  92.         {
  93.                 return m_height;
  94.         }
  95.  
  96.         inline size_t GetMemoryUsage() const
  97.         {
  98.                 return sizeof(*this) + m_cells.capacity() * sizeof(Cell) + m_spans.capacity() * sizeof(Span);
  99.         }
  100.  
  101.         inline const Cell operator[](size_t i) const
  102.         {
  103.                 if (i < m_cells.size())
  104.                         return m_cells[i];
  105.  
  106.                 return Cell(0, 0);
  107.         }
  108.  
  109.         inline const Cell GetCell(size_t x, size_t y) const
  110.         {
  111.                 if ((x < m_width) && (y < m_height))
  112.                         return m_cells[y * m_width + x];
  113.  
  114.                 return Cell(0, 0);
  115.         }
  116.  
  117.         inline Span& GetSpan(size_t i)
  118.         {
  119.                 return m_spans[i];
  120.         }
  121.  
  122.         inline const Span& GetSpan(size_t i) const
  123.         {
  124.                 return m_spans[i];
  125.         }
  126.  
  127.         inline bool GetSpanAt(size_t x, size_t y, size_t top, size_t tolerance, size_t& outSpan) const
  128.         {
  129.                 if ((x < m_width) && (y < m_height))
  130.                 {
  131.                         if (const Cell cell = m_cells[y * m_width + x])
  132.                         {
  133.                                 size_t count = cell.count;
  134.                                 size_t index = cell.index;
  135.  
  136.                                 for (size_t s = 0; s < count; ++s)
  137.                                 {
  138.                                         const Span& span = m_spans[index + s];
  139.                                         const size_t otop = span.bottom + span.height;
  140.  
  141.                                         const int dtop = top - otop;
  142.  
  143.                                         if ((size_t)abs(dtop) <= tolerance)
  144.                                         {
  145.                                                 outSpan = index + s;
  146.  
  147.                                                 return true;
  148.                                         }
  149.                                 }
  150.                         }
  151.                 }
  152.  
  153.                 return false;
  154.         }
  155.  
  156.         inline bool GetSpanAt(size_t cellOffset, size_t top, size_t tolerance, size_t& outSpan) const
  157.         {
  158.                 if (const Cell cell = m_cells[cellOffset])
  159.                 {
  160.                         size_t count = cell.count;
  161.                         size_t index = cell.index;
  162.  
  163.                         for (size_t s = 0; s < count; ++s)
  164.                         {
  165.                                 const Span& span = m_spans[index + s];
  166.                                 const size_t otop = span.bottom + span.height;
  167.  
  168.                                 const int dtop = top - otop;
  169.  
  170.                                 if ((size_t)abs(dtop) <= tolerance)
  171.                                 {
  172.                                         outSpan = index + s;
  173.  
  174.                                         return true;
  175.                                 }
  176.                         }
  177.                 }
  178.  
  179.                 return false;
  180.         }
  181.  
  182.         void Swap(CompactSpanGrid& other);
  183.         void BuildFrom(const DynamicSpanGrid& dynGrid);
  184.         void CompactExcluding(const CompactSpanGrid& spanGrid, size_t flags, size_t newSpanCount);
  185.         void Clear();
  186.  
  187. private:
  188.         size_t m_width;
  189.         size_t m_height;
  190.  
  191.         typedef std::vector<Cell> Cells;
  192.         Cells m_cells;
  193.  
  194.         typedef std::vector<Span> Spans;
  195.         Spans m_spans;
  196. };
  197. }
  198.  
  199. #endif  // #ifndef __MNM_COMPACT_SPAN_GRID_H
  200.  
downloadCompactSpanGrid.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