BVB Source Codes

CRYENGINE Show DynamicSpanGrid.cpp Source code

Return Download CRYENGINE: download DynamicSpanGrid.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "DynamicSpanGrid.h"
  5.  
  6. //#pragma optimize("", off)
  7. //#pragma inline_depth(0)
  8.  
  9. namespace MNM
  10. {
  11. DynamicSpanGrid::DynamicSpanGrid()
  12.         : m_width(0)
  13.         , m_height(0)
  14.         , m_count(0)
  15. {
  16. }
  17.  
  18. DynamicSpanGrid::DynamicSpanGrid(size_t width, size_t height)
  19.         : m_width(width)
  20.         , m_height(height)
  21.         , m_count(0)
  22. {
  23.         m_grid.resize(width * height, 0);
  24. }
  25.  
  26. DynamicSpanGrid::DynamicSpanGrid(const DynamicSpanGrid& other)
  27.         : m_width(other.m_width)
  28.         , m_height(other.m_height)
  29.         , m_count(other.m_count)
  30. {
  31.         const size_t gridSize = m_width * m_height;
  32.  
  33.         m_grid.resize(gridSize, 0);
  34.  
  35.         for (size_t i = 0; i < gridSize; ++i)
  36.         {
  37.                 if (other.m_grid[i])
  38.                 {
  39.                         const Element* ospan = other.m_grid[i];
  40.  
  41.                         Element* span = Construct(*ospan);
  42.                         m_grid[i] = span;
  43.  
  44.                         for (ospan = ospan->next; ospan; ospan = ospan->next)
  45.                         {
  46.                                 Element* next = Construct(*ospan);
  47.  
  48.                                 span->next = next;
  49.                                 span = next;
  50.                         }
  51.                 }
  52.         }
  53. }
  54.  
  55. void DynamicSpanGrid::Swap(DynamicSpanGrid& other)
  56. {
  57.         m_grid.swap(other.m_grid);
  58.         m_alloc.swap(other.m_alloc);
  59.  
  60.         std::swap(m_width, other.m_width);
  61.         std::swap(m_height, other.m_height);
  62.         std::swap(m_count, other.m_count);
  63. }
  64.  
  65. void DynamicSpanGrid::Reset(size_t width, size_t height)
  66. {
  67.         m_width = width;
  68.         m_height = height;
  69.         m_count = 0;
  70.  
  71.         Grid().swap(m_grid);
  72.         m_grid.resize(width * height, 0);
  73.  
  74.         Allocator().swap(m_alloc);
  75. }
  76.  
  77. DynamicSpanGrid::Element* DynamicSpanGrid::operator[](size_t i)
  78. {
  79.         return m_grid[i];
  80. }
  81.  
  82. const DynamicSpanGrid::Element* DynamicSpanGrid::operator[](size_t i) const
  83. {
  84.         return m_grid[i];
  85. }
  86.  
  87. DynamicSpanGrid::Element* DynamicSpanGrid::GetSpan(size_t x, size_t y)
  88. {
  89.         return m_grid[y * m_width + x];
  90. }
  91.  
  92. const DynamicSpanGrid::Element* DynamicSpanGrid::GetSpan(size_t x, size_t y) const
  93. {
  94.         return m_grid[y * m_width + x];
  95. }
  96.  
  97. size_t DynamicSpanGrid::GetWidth() const
  98. {
  99.         return m_width;
  100. }
  101.  
  102. size_t DynamicSpanGrid::GetHeight() const
  103. {
  104.         return m_height;
  105. }
  106.  
  107. size_t DynamicSpanGrid::GetCount() const
  108. {
  109.         return m_count;
  110. }
  111.  
  112. size_t DynamicSpanGrid::GetMemoryUsage() const
  113. {
  114.         return sizeof(*this) + (m_grid.capacity() * sizeof(Grid::value_type)) + m_alloc.get_total_memory();
  115. }
  116.  
  117. void DynamicSpanGrid::AddVoxel(size_t x, size_t y, size_t z, bool backface)
  118. {
  119.         const size_t offset = y * m_width + x;
  120.         Element* curr = m_grid[offset];
  121.         Element* last = 0;
  122.  
  123.         const uint16 z0 = static_cast<uint16>(z);
  124.         const uint16 z1 = static_cast<uint16>(z + 1);
  125.  
  126.         if (!curr)
  127.         {
  128.                 ++m_count;
  129.                 m_grid[offset] = Construct(Element(z0, z1, backface));
  130.  
  131.                 return;
  132.         }
  133.         while (curr)
  134.         {
  135.                 const uint16 bottom = curr->bottom;
  136.                 const uint16 top = curr->top;
  137.  
  138.                 /*                      if (z0 < top)
  139.                       {
  140.                         if (z0 < bottom) // add new or append at bottom
  141.                         {
  142.                           if (z1 == bottom) // append at bottom
  143.                           {
  144.                           }
  145.                           else // add new
  146.                           {
  147.                           }
  148.                         }
  149.                         else if (z0 == bottom) // append at bottom
  150.                         {
  151.                           if (curr->backface != backface) // split
  152.                           {
  153.                           }
  154.                           else // do nothing - merged
  155.                           {
  156.                           }
  157.                         }
  158.                       }
  159.                       else
  160.                       {
  161.                       }
  162.                  */
  163.                 /*
  164.                  */
  165.  
  166.                 if ((z0 >= bottom) && (z1 <= top))
  167.                 {
  168.                         if ((backface == curr->backface) || backface)
  169.                                 return;
  170.  
  171.                         if (z0 == bottom)
  172.                         {
  173.                                 if (z1 == top)
  174.                                 {
  175.                                         curr->backface = 0;
  176.  
  177.                                         TryMergeNext(curr, z1, backface);
  178.                                         TryMergePrev(curr, last, z0, backface);
  179.                                 }
  180.                                 else
  181.                                 {
  182.                                         curr->bottom = z1;
  183.  
  184.                                         ++m_count;
  185.                                         Element* newSpan = Construct(Element(z0, z1, backface));
  186.                                         newSpan->next = curr;
  187.  
  188.                                         if (last)
  189.                                         {
  190.                                                 last->next = newSpan;
  191.  
  192.                                                 TryMergePrev(newSpan, last, z0, backface);
  193.                                         }
  194.                                         else
  195.                                                 m_grid[offset] = newSpan;
  196.                                 }
  197.  
  198.                                 return;
  199.                         }
  200.                         else if (z1 == top)   // insert at top
  201.                         {
  202.                                 curr->top = z0;
  203.  
  204.                                 ++m_count;
  205.                                 Element* newSpan = Construct(Element(z0, z1, backface));
  206.                                 newSpan->next = curr->next;
  207.                                 curr->next = newSpan;
  208.  
  209.                                 TryMergeNext(newSpan, z1, backface);
  210.                         }
  211.                         else   // insert in the middle
  212.                         {
  213.                                 curr->top = z0;
  214.  
  215.                                 ++m_count;
  216.                                 Element* newSpanTop = Construct(Element(z1, top, curr->backface));
  217.                                 newSpanTop->next = curr->next;
  218.  
  219.                                 ++m_count;
  220.                                 Element* newSpanMiddle = Construct(Element(z0, z1, backface));
  221.                                 newSpanMiddle->next = newSpanTop;
  222.                                 curr->next = newSpanMiddle;
  223.                         }
  224.  
  225.                         return;
  226.                 }
  227.                 else if (z0 == top)
  228.                 {
  229.                         if (!curr->next || (curr->next->bottom > z0))
  230.                         {
  231.                                 if (backface == curr->backface)
  232.                                         curr->top = z1;
  233.                                 else
  234.                                 {
  235.                                         ++m_count;
  236.                                         Element* newSpan = Construct(Element(z0, z1, backface));
  237.                                         newSpan->next = curr->next;
  238.                                         curr->next = newSpan;
  239.                                 }
  240.  
  241.                                 TryMergeNext(curr, z1, backface);
  242.  
  243.                                 return;
  244.                         }
  245.                 }
  246.                 else if (z1 == bottom)
  247.                 {
  248.                         if (backface == curr->backface)
  249.                                 curr->bottom = z0;
  250.                         else
  251.                         {
  252.                                 ++m_count;
  253.                                 Element* newSpan = Construct(Element(z0, z1, backface));
  254.                                 newSpan->next = curr;
  255.  
  256.                                 if (last)
  257.                                         last->next = newSpan;
  258.                                 else
  259.                                         m_grid[offset] = newSpan;
  260.                         }
  261.  
  262.                         TryMergePrev(curr, last, z0, backface);
  263.  
  264.                         return;
  265.                 }
  266.                 else if (z1 < bottom)
  267.                 {
  268.                         ++m_count;
  269.                         Element* newSpan = Construct(Element(z0, z1, backface));
  270.  
  271.                         newSpan->next = curr;
  272.  
  273.                         if (last)
  274.                                 last->next = newSpan;
  275.                         else
  276.                                 m_grid[offset] = newSpan;
  277.  
  278.                         return;
  279.                 }
  280.  
  281.                 last = curr;
  282.                 curr = curr->next;
  283.         }
  284.  
  285.         if (!curr)
  286.         {
  287.                 ++m_count;
  288.                 Element* newSpan = Construct(Element(z0, z1, backface));
  289.  
  290.                 last->next = newSpan;
  291.         }
  292. }
  293. }
  294.  
downloadDynamicSpanGrid.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