[drape] new renderable class

drape_frontend/drape_frontend.pro

@@ -33,7 +33,8 @@ SOURCES += \
     apply_feature_functors.cpp \
     visual_params.cpp \
     poi_symbol_shape.cpp \
-    circle_shape.cpp
+    circle_shape.cpp \
+    render_group.cpp
 
 HEADERS += \
     engine_context.hpp \
@@ -62,4 +63,5 @@ HEADERS += \
     apply_feature_functors.hpp \
     visual_params.hpp \
     poi_symbol_shape.hpp \
-    circle_shape.hpp
+    circle_shape.hpp \
+    render_group.hpp

drape_frontend/render_group.cpp

@@ -0,0 +1,73 @@
+#include "render_group.hpp"
+
+namespace df
+{
+  RenderGroup::RenderGroup(const GLState & state, const df::TileKey & tileKey)
+    : m_state(state)
+    , m_tileKey(tileKey)
+    , m_pendingOnDelete(false)
+  {
+  }
+
+  void RenderGroup::PrepareForAdd(size_t countForAdd)
+  {
+    m_renderBuckets.reserve(m_renderBuckets.size() + countForAdd);
+  }
+
+  void RenderGroup::AddBucket(TransferPointer<RenderBucket> bucket)
+  {
+    m_renderBuckets.push_back(MasterPointer<RenderBucket>(bucket));
+  }
+
+  bool RenderGroup::IsLess(const RenderGroup & other) const
+  {
+    return m_state < other.m_state;
+  }
+
+  RenderBucketComparator::RenderBucketComparator(const set<TileKey> & activeTiles)
+    : m_activeTiles(activeTiles)
+    , m_needGroupMergeOperation(false)
+    , m_needBucketsMergeOperation(false)
+  {
+  }
+
+  void RenderBucketComparator::ResetInternalState()
+  {
+    m_needBucketsMergeOperation = false;
+    m_needGroupMergeOperation = false;
+  }
+
+  bool RenderBucketComparator::operator()(const RenderGroup & l, const RenderGroup & r)
+  {
+    GLState const & lState = l.GetState();
+    GLState const & rState = r.GetState();
+
+    TileKey const & lKey = l.GetTileKey();
+    TileKey const & rKey = r.GetTileKey();
+
+    bool lCheckDeletion = !(l.IsEmpty() || l.IsPendingOnDelete());
+    bool rCheckDeletion = !(r.IsEmpty() || r.IsPendingOnDelete());
+
+    if (lCheckDeletion || m_activeTiles.find(lKey) == m_activeTiles.end())
+      l.DeleteLater();
+
+    if (rCheckDeletion || m_activeTiles.find(rKey) == m_activeTiles.end())
+      r.DeleteLater();
+
+    bool lPendingOnDelete = l.IsPendingOnDelete();
+    bool rPendingOnDelete = r.IsPendingOnDelete();
+
+    if (lState == rState && lKey == rKey && !lPendingOnDelete)
+      m_needGroupMergeOperation = true;
+
+    if (rPendingOnDelete == lPendingOnDelete)
+      return l < r;
+
+    if (rPendingOnDelete)
+      return true;
+
+    if (lPendingOnDelete)
+      return false;
+  }
+
+}

drape_frontend/render_group.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "tile_key.hpp"
+
+#include "../drape/pointers.hpp"
+#include "../drape/glstate.hpp"
+#include "../drape/render_bucket.hpp"
+
+#include "../std/vector.hpp"
+#include "../std/set.hpp"
+
+namespace df
+{
+  class RenderGroup
+  {
+  public:
+    RenderGroup(GLState const & state, TileKey const & tileKey);
+
+    void PrepareForAdd(size_t countForAdd);
+
+    void AddBucket(TransferPointer<RenderBucket> bucket);
+
+    GLState const & GetState() const { return m_state; }
+    TileKey const & GetTileKey() const { return m_tileKey; }
+
+    bool IsEmpty() const { return m_renderBuckets.empty(); }
+    void DeleteLater() const { m_pendingOnDelete = true; }
+    bool IsPendingOnDelete() const { return m_pendingOnDelete; }
+
+    bool IsLess(RenderGroup const & other) const;
+
+  private:
+    GLState m_state;
+    TileKey m_tileKey;
+    vector<MasterPointer<RenderBucket> > m_renderBuckets;
+
+    mutable bool m_pendingOnDelete;
+  };
+
+  class RenderBucketComparator
+  {
+  public:
+    RenderBucketComparator(set<TileKey> const & activeTiles);
+
+    void ResetInternalState();
+
+    bool operator()(RenderGroup const & l, RenderGroup const & r);
+
+  private:
+    set<TileKey> const & m_activeTiles;
+    bool m_needGroupMergeOperation;
+    bool m_needBucketsMergeOperation;
+  };
+}