Added outline for houses

14 files changed, 208 insertions, 106 deletions

diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index 0710a5716f..4acaa2810c 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -1,5 +1,4 @@
 #include "drape_frontend/apply_feature_functors.hpp"
-#include "drape_frontend/shape_view_params.hpp"
 #include "drape_frontend/visual_params.hpp"
 
 #include "drape_frontend/area_shape.hpp"
@@ -424,12 +423,12 @@ void ApplyPointFeature::Finish()
 
 ApplyAreaFeature::ApplyAreaFeature(m2::PointD const & tileCenter,
                                    TInsertShapeFn const & insertShape, FeatureID const & id,
-                                   m2::RectD const & clipRect, float minPosZ,
+                                   m2::RectD const & clipRect, bool isBuilding, float minPosZ,
                                    float posZ, int minVisibleScale, uint8_t rank,
                                    CaptionDescription const & captions)
   : TBase(tileCenter, insertShape, id, minVisibleScale, rank, captions, posZ)
   , m_minPosZ(minPosZ)
-  , m_isBuilding(posZ > 0.0f)
+  , m_isBuilding(isBuilding)
   , m_clipRect(clipRect)
 {}
 
@@ -497,19 +496,13 @@ void ApplyAreaFeature::ProcessBuildingPolygon(m2::PointD const & p1, m2::PointD
 
 int ApplyAreaFeature::GetIndex(m2::PointD const & pt)
 {
-  int maxIndex = -1;
-  for (auto it = m_indices.begin(); it != m_indices.end(); ++it)
+  for (size_t i = 0; i < m_points.size(); i++)
   {
-    if (it->first > maxIndex)
-      maxIndex = it->first;
-
-    if (pt.EqualDxDy(it->second, 1e-7))
-      return it->first;
+    if (pt.EqualDxDy(m_points[i], 1e-7))
+      return static_cast<int>(i);
   }
-
-  int const newIndex = maxIndex + 1;
-  m_indices.insert(make_pair(newIndex, pt));
-  return newIndex;
+  m_points.push_back(pt);
+  return static_cast<int>(m_points.size()) - 1;
 }
 
 bool ApplyAreaFeature::EqualEdges(TEdge const & edge1, TEdge const & edge2) const
@@ -561,17 +554,27 @@ void ApplyAreaFeature::BuildEdges(int vertexIndex1, int vertexIndex2, int vertex
     m_edges.push_back(make_pair(move(edge3), vertexIndex2));
 }
 
-void ApplyAreaFeature::CalculateBuildingEdges(vector<BuildingEdge> & edges)
+void ApplyAreaFeature::CalculateBuildingOutline(bool calculateNormals, BuildingOutline & outline)
 {
+  outline.m_vertices = move(m_points);
+  outline.m_indices.reserve(m_edges.size() * 2);
+  if (calculateNormals)
+    outline.m_normals.reserve(m_edges.size());
+
   for (auto & e : m_edges)
   {
     if (e.second < 0)
       continue;
-    BuildingEdge edge;
-    edge.m_startVertex = m_indices[e.first.first];
-    edge.m_endVertex = m_indices[e.first.second];
-    edge.m_normal = CalculateNormal(edge.m_startVertex, edge.m_endVertex, m_indices[e.second]);
-    edges.push_back(move(edge));
+
+    outline.m_indices.push_back(e.first.first);
+    outline.m_indices.push_back(e.first.second);
+
+    if (calculateNormals)
+    {
+      outline.m_normals.emplace_back(CalculateNormal(outline.m_vertices[e.first.first],
+                                                     outline.m_vertices[e.first.second],
+                                                     outline.m_vertices[e.second]));
+    }
   }
 }
 
@@ -592,17 +595,18 @@ void ApplyAreaFeature::ProcessRule(Stylist::TRuleWrapper const & rule)
     params.m_minPosZ = m_minPosZ;
     params.m_posZ = m_posZ;
 
-    vector<BuildingEdge> edges;
+    BuildingOutline outline;
+    bool const calculateNormals = m_posZ > 0.0;
     if (m_isBuilding)
-    {
-      edges.reserve(m_edges.size());
-      CalculateBuildingEdges(edges);
-    }
+      CalculateBuildingOutline(calculateNormals, outline);
+    params.m_is3D = !outline.m_indices.empty() && calculateNormals;
 
-    m_insertShape(make_unique_dp<AreaShape>(move(m_triangles), move(edges), params));
+    m_insertShape(make_unique_dp<AreaShape>(move(m_triangles), move(outline), params));
   }
   else
+  {
     TBase::ProcessRule(rule);
+  }
 }
 
 ApplyLineFeature::ApplyLineFeature(m2::PointD const & tileCenter, double currentScaleGtoP,
diff --git a/drape_frontend/apply_feature_functors.hpp b/drape_frontend/apply_feature_functors.hpp
index e95efe075c..c41d4ff9a9 100644
--- a/drape_frontend/apply_feature_functors.hpp
+++ b/drape_frontend/apply_feature_functors.hpp
@@ -2,6 +2,7 @@
 
 #include "drape_frontend/stylist.hpp"
 #include "drape_frontend/tile_key.hpp"
+#include "drape_frontend/shape_view_params.hpp"
 
 #include "drape/pointers.hpp"
 
@@ -24,7 +25,7 @@ namespace df
 
 struct TextViewParams;
 class MapShape;
-struct BuildingEdge;
+struct BuildingOutline;
 
 using TInsertShapeFn = function<void(drape_ptr<MapShape> && shape)>;
 
@@ -99,7 +100,7 @@ class ApplyAreaFeature : public ApplyPointFeature
 public:
   ApplyAreaFeature(m2::PointD const & tileCenter,
                    TInsertShapeFn const & insertShape, FeatureID const & id,
-                   m2::RectD const & clipRect, float minPosZ,
+                   m2::RectD const & clipRect, bool isBuilding, float minPosZ,
                    float posZ, int minVisibleScale, uint8_t rank,
                    CaptionDescription const & captions);
 
@@ -112,7 +113,7 @@ private:
   using TEdge = pair<int, int>;
 
   void ProcessBuildingPolygon(m2::PointD const & p1, m2::PointD const & p2, m2::PointD const & p3);
-  void CalculateBuildingEdges(vector<BuildingEdge> & edges);
+  void CalculateBuildingOutline(bool calculateNormals, BuildingOutline & outline);
   int GetIndex(m2::PointD const & pt);
   void BuildEdges(int vertexIndex1, int vertexIndex2, int vertexIndex3);
   bool EqualEdges(TEdge const & edge1, TEdge const & edge2) const;
@@ -121,8 +122,8 @@ private:
 
   vector<m2::PointD> m_triangles;
 
-  unordered_map<int, m2::PointD> m_indices;
-  vector<pair<TEdge, int>> m_edges;
+  buffer_vector<m2::PointD, kBuildingOutlineSize> m_points;
+  buffer_vector<pair<TEdge, int>, kBuildingOutlineSize> m_edges;
   float const m_minPosZ;
   bool const m_isBuilding;
   m2::RectD m_clipRect;
diff --git a/drape_frontend/area_shape.cpp b/drape_frontend/area_shape.cpp
index 44c7f9b459..d6ab5b0b65 100644
--- a/drape_frontend/area_shape.cpp
+++ b/drape_frontend/area_shape.cpp
@@ -15,72 +15,137 @@
 namespace df
 {
 
-AreaShape::AreaShape(vector<m2::PointD> && triangleList, vector<BuildingEdge> && buildingEdges,
+AreaShape::AreaShape(vector<m2::PointD> && triangleList, BuildingOutline && buildingOutline,
                      AreaViewParams const & params)
   : m_vertexes(move(triangleList))
-  , m_buildingEdges(move(buildingEdges))
+  , m_buildingOutline(move(buildingOutline))
   , m_params(params)
-{
-}
+{}
 
 void AreaShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
 {
   dp::TextureManager::ColorRegion region;
   textures->GetColorRegion(m_params.m_color, region);
-  glsl::vec2 const colorPoint = glsl::ToVec2(region.GetTexRect().Center());
+  dp::TextureManager::ColorRegion outlineRegion;
+  textures->GetColorRegion(m_params.m_color * 0.75, outlineRegion);
+  ASSERT_EQUAL(region.GetTexture(), outlineRegion.GetTexture(), ());
+
+  if (m_params.m_is3D)
+    DrawArea3D(batcher, region.GetTexRect().Center(), outlineRegion.GetTexRect().Center(), region.GetTexture());
+  else
+    DrawArea(batcher, region.GetTexRect().Center(), outlineRegion.GetTexRect().Center(), region.GetTexture());
+}
+
+void AreaShape::DrawArea(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorUv, m2::PointD const & outlineUv,
+                         ref_ptr<dp::Texture> texture) const
+{
+  glsl::vec2 const uv = glsl::ToVec2(colorUv);
 
-  if (!m_buildingEdges.empty())
+  buffer_vector<gpu::AreaVertex, 128> vertexes;
+  vertexes.resize(m_vertexes.size());
+  transform(m_vertexes.begin(), m_vertexes.end(), vertexes.begin(), [&uv, this](m2::PointF const & vertex)
   {
-    vector<gpu::Area3dVertex> vertexes;
-    vertexes.reserve(m_vertexes.size() + m_buildingEdges.size() * 6);
+    return gpu::AreaVertex(glsl::vec3(glsl::ToVec2(ConvertToLocal(vertex, m_params.m_tileCenter, kShapeCoordScalar)),
+                                      m_params.m_depth), uv);
+  });
 
-    for (auto const & edge : m_buildingEdges)
-    {
-      glsl::vec2 const startPt = glsl::ToVec2(ConvertToLocal(edge.m_startVertex, m_params.m_tileCenter, kShapeCoordScalar));
-      glsl::vec2 const endPt = glsl::ToVec2(ConvertToLocal(edge.m_endVertex, m_params.m_tileCenter, kShapeCoordScalar));
+  dp::GLState state(gpu::AREA_PROGRAM, dp::GLState::GeometryLayer);
+  state.SetColorTexture(texture);
 
-      glsl::vec3 normal(glsl::ToVec2(edge.m_normal), 0.0f);
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_minPosZ), normal, colorPoint));
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_minPosZ), normal, colorPoint));
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_posZ), normal, colorPoint));
+  dp::AttributeProvider provider(1, m_vertexes.size());
+  provider.InitStream(0, gpu::AreaVertex::GetBindingInfo(), make_ref(vertexes.data()));
+  batcher->InsertTriangleList(state, make_ref(&provider));
 
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_posZ), normal, colorPoint));
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_minPosZ), normal, colorPoint));
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_posZ), normal, colorPoint));
-    }
+  // Generate outline.
+  if (!m_buildingOutline.m_indices.empty())
+  {
+    glsl::vec2 const ouv = glsl::ToVec2(outlineUv);
 
-    glsl::vec3 normal(0.0f, 0.0f, -1.0f);
-    for (auto const & vertex : m_vertexes)
+    vector<gpu::AreaVertex> vertices;
+    vertices.reserve(m_buildingOutline.m_vertices.size());
+    for (size_t i = 0; i < m_buildingOutline.m_vertices.size(); i++)
     {
-      glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(vertex, m_params.m_tileCenter, kShapeCoordScalar));
-      vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(pt, -m_params.m_posZ), normal, colorPoint));
+      glsl::vec2 const pos = glsl::ToVec2(ConvertToLocal(m_buildingOutline.m_vertices[i],
+                                                         m_params.m_tileCenter, kShapeCoordScalar));
+      vertices.emplace_back(gpu::AreaVertex(glsl::vec3(pos, m_params.m_depth), ouv));
     }
 
-    dp::GLState state(gpu::AREA_3D_PROGRAM, dp::GLState::GeometryLayer);
-    state.SetColorTexture(region.GetTexture());
-    state.SetBlending(dp::Blending(false /* isEnabled */));
+    dp::GLState state(gpu::AREA_OUTLINE_PROGRAM, dp::GLState::GeometryLayer);
+    state.SetColorTexture(texture);
+    state.SetDrawAsLine(true);
 
-    dp::AttributeProvider provider(1, vertexes.size());
-    provider.InitStream(0, gpu::Area3dVertex::GetBindingInfo(), make_ref(vertexes.data()));
-    batcher->InsertTriangleList(state, make_ref(&provider));
+    dp::AttributeProvider outlineProvider(1, vertices.size());
+    outlineProvider.InitStream(0, gpu::AreaVertex::GetBindingInfo(), make_ref(vertices.data()));
+    batcher->InsertLineRaw(state, make_ref(&outlineProvider), m_buildingOutline.m_indices);
   }
-  else
+}
+
+void AreaShape::DrawArea3D(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorUv, m2::PointD const & outlineUv,
+                           ref_ptr<dp::Texture> texture) const
+{
+  ASSERT(!m_buildingOutline.m_indices.empty(), ());
+  ASSERT(!m_buildingOutline.m_normals.empty(), ());
+
+  glsl::vec2 const uv = glsl::ToVec2(colorUv);
+
+  vector<gpu::Area3dVertex> vertexes;
+  vertexes.reserve(m_vertexes.size() + m_buildingOutline.m_normals.size() * 6);
+
+  for (size_t i = 0; i < m_buildingOutline.m_normals.size(); i++)
   {
-    buffer_vector<gpu::AreaVertex, 128> vertexes;
-    vertexes.resize(m_vertexes.size());
-    transform(m_vertexes.begin(), m_vertexes.end(), vertexes.begin(), [&colorPoint, this](m2::PointF const & vertex)
-    {
-      return gpu::AreaVertex(glsl::vec3(glsl::ToVec2(ConvertToLocal(vertex, m_params.m_tileCenter, kShapeCoordScalar)),
-                                        m_params.m_depth), colorPoint);
-    });
+    size_t const startIndex = m_buildingOutline.m_indices[i * 2];
+    size_t const endIndex = m_buildingOutline.m_indices[i * 2 + 1];
+
+    glsl::vec2 const startPt = glsl::ToVec2(ConvertToLocal(m_buildingOutline.m_vertices[startIndex],
+                                                           m_params.m_tileCenter, kShapeCoordScalar));
+    glsl::vec2 const endPt = glsl::ToVec2(ConvertToLocal(m_buildingOutline.m_vertices[endIndex],
+                                                         m_params.m_tileCenter, kShapeCoordScalar));
+
+    glsl::vec3 normal(glsl::ToVec2(m_buildingOutline.m_normals[i]), 0.0f);
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_minPosZ), normal, uv));
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_minPosZ), normal, uv));
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_posZ), normal, uv));
+
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(startPt, -m_params.m_posZ), normal, uv));
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_minPosZ), normal, uv));
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(endPt, -m_params.m_posZ), normal, uv));
+  }
 
-    dp::GLState state(gpu::AREA_PROGRAM, dp::GLState::GeometryLayer);
-    state.SetColorTexture(region.GetTexture());
+  glsl::vec3 normal(0.0f, 0.0f, -1.0f);
+  for (auto const & vertex : m_vertexes)
+  {
+    glsl::vec2 const pt = glsl::ToVec2(ConvertToLocal(vertex, m_params.m_tileCenter, kShapeCoordScalar));
+    vertexes.emplace_back(gpu::Area3dVertex(glsl::vec3(pt, -m_params.m_posZ), normal, uv));
+  }
 
-    dp::AttributeProvider provider(1, m_vertexes.size());
-    provider.InitStream(0, gpu::AreaVertex::GetBindingInfo(), make_ref(vertexes.data()));
-    batcher->InsertTriangleList(state, make_ref(&provider));
+  dp::GLState state(gpu::AREA_3D_PROGRAM, dp::GLState::GeometryLayer);
+  state.SetColorTexture(texture);
+  state.SetBlending(dp::Blending(false /* isEnabled */));
+
+  dp::AttributeProvider provider(1, vertexes.size());
+  provider.InitStream(0, gpu::Area3dVertex::GetBindingInfo(), make_ref(vertexes.data()));
+  batcher->InsertTriangleList(state, make_ref(&provider));
+
+  // Generate outline.
+  glsl::vec2 const ouv = glsl::ToVec2(outlineUv);
+
+  dp::GLState outlineState(gpu::AREA_3D_OUTLINE_PROGRAM, dp::GLState::GeometryLayer);
+  outlineState.SetColorTexture(texture);
+  outlineState.SetBlending(dp::Blending(false /* isEnabled */));
+  outlineState.SetDrawAsLine(true);
+
+  vector<gpu::AreaVertex> vertices;
+  vertices.reserve(m_buildingOutline.m_vertices.size());
+  for (size_t i = 0; i < m_buildingOutline.m_vertices.size(); i++)
+  {
+    glsl::vec2 const pos = glsl::ToVec2(ConvertToLocal(m_buildingOutline.m_vertices[i],
+                                                       m_params.m_tileCenter, kShapeCoordScalar));
+    vertices.emplace_back(gpu::AreaVertex(glsl::vec3(pos, -m_params.m_posZ), ouv));
   }
+
+  dp::AttributeProvider outlineProvider(1, vertices.size());
+  outlineProvider.InitStream(0, gpu::AreaVertex::GetBindingInfo(), make_ref(vertices.data()));
+  batcher->InsertLineRaw(outlineState, make_ref(&outlineProvider), m_buildingOutline.m_indices);
 }
 
 } // namespace df
diff --git a/drape_frontend/area_shape.hpp b/drape_frontend/area_shape.hpp
index c6ae7d1579..32e5db7ba0 100644
--- a/drape_frontend/area_shape.hpp
+++ b/drape_frontend/area_shape.hpp
@@ -11,24 +11,29 @@
 namespace df
 {
 
-struct BuildingEdge
+struct BuildingOutline
 {
-  m2::PointD m_startVertex;
-  m2::PointD m_endVertex;
-  m2::PointD m_normal;
+  buffer_vector<m2::PointD, kBuildingOutlineSize> m_vertices;
+  vector<int> m_indices;
+  vector<m2::PointD> m_normals;
 };
 
 class AreaShape : public MapShape
 {
 public:
-  AreaShape(vector<m2::PointD> && triangleList, vector<BuildingEdge> && buildingEdges,
+  AreaShape(vector<m2::PointD> && triangleList, BuildingOutline && buildingOutline,
             AreaViewParams const & params);
 
   void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
 
 private:
+  void DrawArea(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorUv,
+                m2::PointD const & outlineUv, ref_ptr<dp::Texture> texture) const;
+  void DrawArea3D(ref_ptr<dp::Batcher> batcher, m2::PointD const & colorUv,
+                  m2::PointD const & outlineUv, ref_ptr<dp::Texture> texture) const;
+
   vector<m2::PointD> m_vertexes;
-  vector<BuildingEdge> m_buildingEdges;
+  BuildingOutline m_buildingOutline;
   AreaViewParams m_params;
 };
 
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index a93ba86fda..ce46e5a973 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -113,6 +113,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
       break;
     }
+
   case Message::InvalidateReadManagerRect:
     {
       ref_ptr<InvalidateReadManagerRectMessage> msg = message;
@@ -122,11 +123,13 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
         m_readManager->Invalidate(msg->GetTilesForInvalidate());
       break;
     }
+
   case Message::ShowChoosePositionMark:
     {
       RecacheChoosePositionMark();
       break;
     }
+
   case Message::GuiRecache:
     {
       ref_ptr<GuiRecacheMessage> msg = message;
@@ -137,6 +140,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
 #endif
       break;
     }
+
   case Message::GuiLayerLayout:
     {
       ref_ptr<GuiLayerLayoutMessage> msg = message;
@@ -145,17 +149,21 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
                                 MessagePriority::Normal);
       break;
     }
+
   case Message::TileReadStarted:
     {
-      m_batchersPool->ReserveBatcher(static_cast<ref_ptr<BaseTileMessage>>(message)->GetKey());
+      ref_ptr<TileReadStartMessage> msg = message;
+      m_batchersPool->ReserveBatcher(msg->GetKey());
       break;
     }
+
   case Message::TileReadEnded:
     {
       ref_ptr<TileReadEndMessage> msg = message;
       m_batchersPool->ReleaseBatcher(msg->GetKey());
       break;
     }
+
   case Message::FinishTileRead:
     {
       ref_ptr<FinishTileReadMessage> msg = message;
@@ -164,6 +172,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
                                 MessagePriority::Normal);
       break;
     }
+
   case Message::FinishReading:
     {
       TOverlaysRenderData overlays;
@@ -176,11 +185,13 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
       break;
     }
+
   case Message::MapShapesRecache:
     {
       RecacheMapShapes();
       break;
     }
+
   case Message::MapShapeReaded:
     {
       ref_ptr<MapShapeReadedMessage> msg = message;
@@ -196,6 +207,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
       break;
     }
+
   case Message::OverlayMapShapeReaded:
     {
       ref_ptr<OverlayMapShapeReadedMessage> msg = message;
@@ -218,6 +230,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       }
       break;
     }
+
   case Message::UpdateUserMarkLayer:
     {
       ref_ptr<UpdateUserMarkLayerMessage> msg = message;
@@ -238,6 +251,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
       msg->EndProcess();
       break;
     }
+
   case Message::AddRoute:
     {
       ref_ptr<AddRouteMessage> msg = message;
@@ -245,18 +259,21 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
                             msg->GetColor(), msg->GetPattern(), m_texMng, msg->GetRecacheId());
       break;
     }
+
   case Message::CacheRouteSign:
     {
       ref_ptr<CacheRouteSignMessage> msg = message;
       m_routeBuilder->BuildSign(msg->GetPosition(), msg->IsStart(), msg->IsValid(), m_texMng, msg->GetRecacheId());
       break;
     }
+
   case Message::CacheRouteArrows:
     {
       ref_ptr<CacheRouteArrowsMessage> msg = message;
       m_routeBuilder->BuildArrows(msg->GetRouteIndex(), msg->GetBorders(), m_texMng, msg->GetRecacheId());
       break;
     }
+
   case Message::RemoveRoute:
     {
       ref_ptr<RemoveRouteMessage> msg = message;
@@ -268,12 +285,14 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
                                 MessagePriority::Normal);
       break;
     }
+
   case Message::InvalidateTextures:
     {
       m_texMng->Invalidate(VisualParams::Instance().GetResourcePostfix());
       RecacheMapShapes();
       break;
     }
+
   case Message::CacheGpsTrackPoints:
     {
       ref_ptr<CacheGpsTrackPointsMessage> msg = message;
@@ -285,12 +304,14 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
                                 MessagePriority::Normal);
       break;
     }
+
   case Message::Allow3dBuildings:
     {
       ref_ptr<Allow3dBuildingsMessage> msg = message;
       m_readManager->Allow3dBuildings(msg->Allow3dBuildings());
       break;
     }
+
   case Message::RequestSymbolsSize:
     {
       ref_ptr<RequestSymbolsSizeMessage> msg = message;
@@ -307,6 +328,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
 
       break;
     }
+
   default:
     ASSERT(false, ());
     break;
@@ -366,8 +388,8 @@ void BackendRenderer::Routine::Do()
 
 void BackendRenderer::InitGLDependentResource()
 {
-  m_batchersPool = make_unique_dp<BatchersPool>(ReadManager::ReadCount(), bind(&BackendRenderer::FlushGeometry, this, _1));
-
+  m_batchersPool = make_unique_dp<BatchersPool>(ReadManager::ReadCount(),
+                                                bind(&BackendRenderer::FlushGeometry, this, _1));
   dp::TextureManager::Params params;
   params.m_resPostfix = VisualParams::Instance().GetResourcePostfix();
   params.m_visualScale = df::VisualParams::Instance().GetVisualScale();
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 61182eee24..9abb4d2496 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -1774,7 +1774,7 @@ FrontendRenderer::RenderLayer::RenderLayerID FrontendRenderer::RenderLayer::GetL
   if (state.GetDepthLayer() == dp::GLState::OverlayLayer)
     return OverlayID;
 
-  if (state.GetProgram3dIndex() == gpu::AREA_3D_PROGRAM)
+  if (state.GetProgram3dIndex() == gpu::AREA_3D_PROGRAM || state.GetProgram3dIndex() == gpu::AREA_3D_OUTLINE_PROGRAM)
     return Geometry3dID;
 
   return Geometry2dID;
diff --git a/drape_frontend/gps_track_renderer.cpp b/drape_frontend/gps_track_renderer.cpp
index def40a6c10..39a7e314c7 100644
--- a/drape_frontend/gps_track_renderer.cpp
+++ b/drape_frontend/gps_track_renderer.cpp
@@ -308,12 +308,13 @@ void GpsTrackRenderer::RenderTrack(ScreenBase const & screen, int zoomLevel,
   program->Bind();
 
   ASSERT_GREATER(m_renderData.size(), 0, ());
-  dp::ApplyState(m_renderData.front()->m_state, program);
+  dp::GLState const & state = m_renderData.front()->m_state;
+  dp::ApplyState(state, program);
   dp::ApplyUniforms(uniforms, program);
 
   for (size_t i = 0; i < m_renderData.size(); i++)
     if (m_handlesCache[i].second != 0)
-      m_renderData[i]->m_bucket->Render();
+      m_renderData[i]->m_bucket->Render(state.GetDrawAsLine());
 }
 
 void GpsTrackRenderer::Update()
diff --git a/drape_frontend/gui/gui_text.cpp b/drape_frontend/gui/gui_text.cpp
index c00408e332..e92b01c2f5 100644
--- a/drape_frontend/gui/gui_text.cpp
+++ b/drape_frontend/gui/gui_text.cpp
@@ -296,6 +296,7 @@ void MutableLabel::SetMaxLength(uint16_t maxLength)
 ref_ptr<dp::Texture> MutableLabel::SetAlphabet(string const & alphabet, ref_ptr<dp::TextureManager> mng)
 {
   strings::UniString str = strings::MakeUniString(alphabet + ".");
+  sort(str.begin(), str.end());
   strings::UniString::iterator it = unique(str.begin(), str.end());
   str.resize(distance(str.begin(), it));
 
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index 3499b32b31..89d496b0ae 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -120,7 +120,7 @@ void ShapeRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramMana
           info.m_buffer->ApplyMutation(nullptr, mutatorRef);
         }
 
-        info.m_buffer->Render();
+        info.m_buffer->Render(info.m_state.GetDrawAsLine());
       });
 }
 
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index ac5e7b63b2..4199936a10 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -105,13 +105,13 @@ void RenderGroup::Render(ScreenBase const & screen)
     dp::ApplyUniforms(m_uniforms, shader);
 
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render();
+      renderBucket->Render(m_state.GetDrawAsLine());
 
     m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
     m_uniforms.SetFloatValue("u_isOutlinePass", 0.0f);
     dp::ApplyUniforms(m_uniforms, shader);
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render();
+      renderBucket->Render(m_state.GetDrawAsLine());
   }
   else if (programIndex == gpu::TEXT_PROGRAM ||
            program3dIndex == gpu::TEXT_BILLBOARD_PROGRAM)
@@ -119,14 +119,14 @@ void RenderGroup::Render(ScreenBase const & screen)
     m_uniforms.SetFloatValue("u_contrastGamma", params.m_contrast, params.m_gamma);
     dp::ApplyUniforms(m_uniforms, shader);
     for(auto & renderBucket : m_renderBuckets)
-      renderBucket->Render();
+      renderBucket->Render(m_state.GetDrawAsLine());
   }
   else
   {
     dp::ApplyUniforms(m_uniforms, shader);
 
     for(drape_ptr<dp::RenderBucket> & renderBucket : m_renderBuckets)
-      renderBucket->Render();
+      renderBucket->Render(m_state.GetDrawAsLine());
   }
 
 #ifdef RENDER_DEBUG_RECTS
@@ -233,7 +233,7 @@ void UserMarkRenderGroup::Render(ScreenBase const & screen)
   if (m_renderBucket != nullptr)
   {
     m_renderBucket->GetBuffer()->Build(shader);
-    m_renderBucket->Render();
+    m_renderBucket->Render(m_state.GetDrawAsLine());
   }
 }
 
diff --git a/drape_frontend/render_node.cpp b/drape_frontend/render_node.cpp
index ffc907d963..3792708e85 100644
--- a/drape_frontend/render_node.cpp
+++ b/drape_frontend/render_node.cpp
@@ -17,13 +17,13 @@ void RenderNode::Render(ref_ptr<dp::GpuProgramManager> mng, dp::UniformValuesSto
                         dp::IndicesRange const & range)
 {
   Apply(mng, uniforms);
-  m_buffer->RenderRange(range);
+  m_buffer->RenderRange(m_state.GetDrawAsLine(), range);
 }
 
 void RenderNode::Render(ref_ptr<dp::GpuProgramManager> mng, dp::UniformValuesStorage const & uniforms)
 {
   Apply(mng, uniforms);
-  m_buffer->Render();
+  m_buffer->Render(m_state.GetDrawAsLine());
 }
 
 void RenderNode::Apply(ref_ptr<dp::GpuProgramManager> mng, dp::UniformValuesStorage const & uniforms)
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index 7c07b75c14..3dc7497cdf 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -262,7 +262,7 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, ref_ptr<dp::GpuProgra
 
     // Render buckets.
     for (drape_ptr<dp::RenderBucket> const & bucket : m_routeData->m_route.m_buckets)
-      bucket->Render();
+      bucket->Render(state.GetDrawAsLine());
   }
 
   // Render arrows.
@@ -282,7 +282,7 @@ void RouteRenderer::RenderRoute(ScreenBase const & screen, ref_ptr<dp::GpuProgra
     dp::ApplyState(state, prg);
     dp::ApplyUniforms(uniforms, prg);
     for (drape_ptr<dp::RenderBucket> const & bucket : m_routeArrows->m_arrows.m_buckets)
-      bucket->Render();
+      bucket->Render(state.GetDrawAsLine());
   }
 }
 
@@ -319,13 +319,13 @@ void RouteRenderer::RenderRouteSign(drape_ptr<RouteSignData> const & sign, Scree
                                                            : mng->GetProgram(state.GetProgramIndex());
   program->Bind();
 
-  dp::ApplyState(sign->m_sign.m_state, program);
+  dp::ApplyState(state, program);
   dp::ApplyUniforms(uniforms, program);
 
   for (auto const & bucket : sign->m_sign.m_buckets)
   {
     bucket->GetBuffer()->Build(program);
-    bucket->Render();
+    bucket->Render(state.GetDrawAsLine());
   }
 }
 
diff --git a/drape_frontend/rule_drawer.cpp b/drape_frontend/rule_drawer.cpp
index e65a9eeabc..84ad111adc 100644
--- a/drape_frontend/rule_drawer.cpp
+++ b/drape_frontend/rule_drawer.cpp
@@ -155,16 +155,17 @@ void RuleDrawer::operator()(FeatureType const & f)
 
   if (s.AreaStyleExists())
   {
-    bool is3dBuilding = false;
-    if (m_is3dBuidings && f.GetLayer() >= 0)
+    bool isBuilding = false;
+    if (f.GetLayer() >= 0)
     {
       // Looks like nonsense, but there are some osm objects with types
       // highway-path-bridge and building (sic!) at the same time (pedestrian crossing).
-      is3dBuilding = (ftypes::IsBuildingChecker::Instance()(f) ||
-                      ftypes::IsBuildingPartChecker::Instance()(f)) &&
-                      !ftypes::IsBridgeChecker::Instance()(f) &&
-                      !ftypes::IsTunnelChecker::Instance()(f);
+      isBuilding = (ftypes::IsBuildingChecker::Instance()(f) ||
+                    ftypes::IsBuildingPartChecker::Instance()(f)) &&
+                    !ftypes::IsBridgeChecker::Instance()(f) &&
+                    !ftypes::IsTunnelChecker::Instance()(f);
     }
+    bool const is3dBuilding = m_is3dBuidings && isBuilding;
 
     m2::PointD featureCenter;
 
@@ -221,8 +222,8 @@ void RuleDrawer::operator()(FeatureType const & f)
       minVisibleScale = feature::GetMinDrawableScale(f);
 
     ApplyAreaFeature apply(m_globalRect.Center(), insertShape, f.GetID(), m_globalRect,
-                           areaMinHeight, areaHeight, minVisibleScale, f.GetRank(),
-                           s.GetCaptionDescription());
+                           isBuilding, areaMinHeight, areaHeight, minVisibleScale,
+                           f.GetRank(), s.GetCaptionDescription());
     f.ForEachTriangle(apply, zoomLevel);
     apply.SetHotelData(ExtractHotelData(f));
     if (applyPointStyle)
diff --git a/drape_frontend/shape_view_params.hpp b/drape_frontend/shape_view_params.hpp
index 51036d8eac..f5c084c288 100644
--- a/drape_frontend/shape_view_params.hpp
+++ b/drape_frontend/shape_view_params.hpp
@@ -13,6 +13,7 @@ namespace df
 {
 
 double const kShapeCoordScalar = 1000;
+int constexpr kBuildingOutlineSize = 16;
 
 struct CommonViewParams
 {
@@ -51,6 +52,7 @@ struct AreaViewParams : CommonViewParams
   dp::Color m_color;
   float m_minPosZ = 0.0f;
   float m_posZ = 0.0f;
+  bool m_is3D = false;
 };
 
 struct LineViewParams : CommonViewParams