Draw tunnels transparent:

- set special layer flag when generating;
 - add additional id (transparent) for drawing rule;

generator/osm2type.cpp

@@ -509,6 +509,7 @@ namespace ftype {
     {
       size_t & m_count;
       FeatureParams & m_params;
+      bool m_tunnel;
 
       class get_lang
       {
@@ -534,10 +535,16 @@ namespace ftype {
       typedef bool result_type;
 
       do_find_name(size_t & count, FeatureParams & params)
-        : m_count(count), m_params(params)
+        : m_count(count), m_params(params), m_tunnel(false)
       {
         m_count = 0;
       }
+      ~do_find_name()
+      {
+        if (m_tunnel && m_params.layer < 0)
+          m_params.layer = feature::LAYER_TRANSPARENT_TUNNEL;
+      }
+
       bool operator() (string const & k, string const & v)
       {
         ++m_count;
@@ -581,6 +588,10 @@ namespace ftype {
             m_params.rank = static_cast<uint8_t>(log(double(n)) / log(1.1));
         }
 
+        // set 'tunnel' flag
+        if (k == "tunnel")
+          m_tunnel = true;
+
         return false;
       }
     };

indexer/drawing_rules.hpp

@@ -19,20 +19,26 @@ namespace drule
   class BaseRule
   {
     string m_class;
+    mutable uint32_t m_id1, m_id2;
     char m_type;
 
-    mutable uint32_t m_id;
-
   public:
     static uint32_t const empty_id = 0xFFFFFFFF;
 
-    BaseRule() : m_id(empty_id) {}
+    BaseRule() : m_id1(empty_id), m_id2(empty_id) {}
 
     virtual ~BaseRule() {}
 
-    uint32_t GetID() const { return m_id; }
-    void SetID(uint32_t id) const { m_id = id; }
-    void MakeEmptyID() { m_id = empty_id; }
+    /// @todo Rewrite this. Make an array of IDs.
+    //@{
+    uint32_t GetID() const { return m_id1; }
+    void SetID(uint32_t id) const { m_id1 = id; }
+    void MakeEmptyID() { m_id1 = empty_id; }
+
+    uint32_t GetID2() const { return m_id2; }
+    void SetID2(uint32_t id) const { m_id2 = id; }
+    void MakeEmptyID2() { m_id2 = empty_id; }
+    //@}
 
     void SetClassName(string const & cl) { m_class = cl; }
     void SetType(char type) { m_type = type; }

indexer/feature_data.cpp

@@ -13,7 +13,7 @@ bool FeatureParamsBase::operator == (FeatureParamsBase const & rhs) const
 
 bool FeatureParamsBase::CheckValid() const
 {
-   CHECK(layer >= -10 && layer <= 10, ());
+   CHECK(layer > LAYER_LOW && layer < LAYER_HIGH, ());
    return true;
 }
 

indexer/feature_data.hpp

@@ -35,6 +35,16 @@ namespace feature
   };
 
   static const int max_types_count = HEADER_TYPE_MASK + 1;
+
+  enum ELayerFlags
+  {
+    LAYER_LOW = -11,
+
+    LAYER_EMPTY = 0,
+    LAYER_TRANSPARENT_TUNNEL = 11,    // draw transparent road (tunnels)
+
+    LAYER_HIGH = 12
+  };
 }
 
 /// Feature description struct.

indexer/feature_visibility.cpp

@@ -10,7 +10,6 @@
 #include "../base/start_mem_debug.hpp"
 
 
-
 namespace
 {
   bool NeedProcessParent(ClassifObject const * p)

map/drawer_yg.cpp

@@ -22,6 +22,16 @@ DrawerYG::Params::Params()
 {
 }
 
+uint32_t di::DrawRule::GetID() const
+{
+  return (m_transparent ? m_rule->GetID2() : m_rule->GetID());
+}
+
+void di::DrawRule::SetID(uint32_t id) const
+{
+  m_transparent ? m_rule->SetID2(id) : m_rule->SetID(id);
+}
+
 DrawerYG::DrawerYG(string const & skinName, params_t const & params)
 {
   m_pScreen = shared_ptr<yg::gl::Screen>(new yg::gl::Screen(params));
@@ -48,6 +58,8 @@ namespace
     {
       if ((p->GetID() & 0xFF000000) == m_pageIDMask)
         p->MakeEmptyID();
+      if ((p->GetID2() & 0xFF000000) == m_pageIDMask)
+        p->MakeEmptyID2();
     }
   };
 }
@@ -141,7 +153,7 @@ void DrawerYG::drawPath(vector<m2::PointD> const & pts, di::DrawRule const * rul
   bool flag = false;
   for (size_t i = 0; i < count; ++i)
   {
-    if (rules[i].m_rule->GetID() == drule::BaseRule::empty_id)
+    if (rules[i].GetID() == drule::BaseRule::empty_id)
     {
       flag = true;
       break;
@@ -164,9 +176,10 @@ void DrawerYG::drawPath(vector<m2::PointD> const & pts, di::DrawRule const * rul
       for (size_t j = 0; j < pattern.size(); ++j)
         pattern[j] *= m_scale * m_visualScale;
 
-      penInfos[i] = yg::PenInfo (yg::Color::fromXRGB(pRule->GetColor(), pRule->GetAlpha()),
-                                 max(pRule->GetWidth() * m_scale, 1.0) * m_visualScale,
-                                 pattern.empty() ? 0 : &pattern[0], pattern.size(), offset * m_scale);
+      penInfos[i] = yg::PenInfo(
+            yg::Color::fromXRGB(pRule->GetColor(), rules[i].m_transparent ? 100 : pRule->GetAlpha()),
+            max(pRule->GetWidth() * m_scale, 1.0) * m_visualScale,
+            pattern.empty() ? 0 : &pattern[0], pattern.size(), offset * m_scale);
       styleIDs[i] = m_pSkin->invalidHandle();
     }
 
@@ -174,7 +187,7 @@ void DrawerYG::drawPath(vector<m2::PointD> const & pts, di::DrawRule const * rul
     if (m_pSkin->mapPenInfo(&penInfos[0], &styleIDs[0], count))
     {
       for (size_t i = 0; i < count; ++i)
-        rules[i].m_rule->SetID(styleIDs[i]);
+        rules[i].SetID(styleIDs[i]);
     }
     else
     {
@@ -185,7 +198,7 @@ void DrawerYG::drawPath(vector<m2::PointD> const & pts, di::DrawRule const * rul
 
   // draw path with array of rules
   for (size_t i = 0; i < count; ++i)
-    m_pScreen->drawPath(&pts[0], pts.size(), 0, rules[i].m_rule->GetID(), rules[i].m_depth);
+    m_pScreen->drawPath(&pts[0], pts.size(), 0, rules[i].GetID(), rules[i].m_depth);
 }
 
 void DrawerYG::drawArea(vector<m2::PointD> const & pts, rule_ptr_t pRule, int depth)

map/drawer_yg.hpp

@@ -49,9 +49,13 @@ namespace di
 
     rule_ptr_t m_rule;
     int m_depth;
+    bool m_transparent;
 
     DrawRule() : m_rule(0) {}
-    DrawRule(rule_ptr_t p, int d) : m_rule(p), m_depth(d) {}
+    DrawRule(rule_ptr_t p, int d, bool tr) : m_rule(p), m_depth(d), m_transparent(tr) {}
+
+    uint32_t GetID() const;
+    void SetID(uint32_t id) const;
   };
 }
 

map/framework.cpp

@@ -146,7 +146,13 @@ namespace fwork
     buffer_vector<di::DrawRule, reserve_rules_count> rules;
     rules.resize(count);
 
-    int const layer = f.GetLayer();
+    int layer = f.GetLayer();
+    bool isTransparent = false;
+    if (layer == feature::LAYER_TRANSPARENT_TUNNEL)
+    {
+      layer = 0;
+      isTransparent = true;
+    }
 
     for (size_t i = 0; i < count; ++i)
     {
@@ -154,7 +160,7 @@ namespace fwork
       if (layer != 0)
         depth = (layer * drule::layer_base_priority) + (depth % drule::layer_base_priority);
 
-      rules[i] = di::DrawRule(drule::rules().Find(m_keys[i]), depth);
+      rules[i] = di::DrawRule(drule::rules().Find(m_keys[i]), depth, isTransparent);
     }
 
     sort(rules.begin(), rules.end(), less_depth());

yg/path_renderer.cpp

@@ -26,8 +26,9 @@ namespace yg
         return;
 
       ASSERT_GREATER_OR_EQUAL(pointsCount, 2, ());
-      ResourceStyle const * style(skin()->fromID(styleID));
+      ASSERT_NOT_EQUAL(styleID, uint32_t(-1), ());
 
+      ResourceStyle const * style(skin()->fromID(styleID));
       if (style == 0)
       {
         LOG(LINFO, ("drawPath: styleID=", styleID, " wasn't found on current skin"));
@@ -35,8 +36,8 @@ namespace yg
       }
 
       ASSERT(style->m_cat == ResourceStyle::ELineStyle, ());
-      LineStyle const * lineStyle = static_cast<LineStyle const *>(style);
 
+      LineStyle const * lineStyle = static_cast<LineStyle const *>(style);
       if (lineStyle->m_isSolid)
       {
         drawSolidPath(points, pointsCount, styleID, depth);