Repo created

libs/drape_frontend/traffic_generator.hpp

@@ -0,0 +1,243 @@
+#pragma once
+
+#include "drape_frontend/batchers_pool.hpp"
+#include "drape_frontend/color_constants.hpp"
+#include "drape_frontend/render_state_extension.hpp"
+#include "drape_frontend/tile_key.hpp"
+
+#include "drape/color.hpp"
+#include "drape/glsl_types.hpp"
+#include "drape/render_bucket.hpp"
+#include "drape/texture_manager.hpp"
+
+#include "traffic/traffic_info.hpp"
+
+#include "indexer/feature_decl.hpp"
+
+#include "geometry/polyline2d.hpp"
+
+#include <array>
+#include <functional>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+namespace dp
+{
+class GraphicsContext;
+}  // namespace dp
+
+namespace df
+{
+enum class RoadClass : uint8_t
+{
+  Class0,
+  Class1,
+  Class2
+};
+
+int constexpr kRoadClass0ZoomLevel = 10;
+int constexpr kRoadClass1ZoomLevel = 12;
+int constexpr kRoadClass2ZoomLevel = 15;
+
+struct TrafficSegmentID
+{
+  MwmSet::MwmId m_mwmId;
+  traffic::TrafficInfo::RoadSegmentId m_segmentId;
+
+  TrafficSegmentID(MwmSet::MwmId const & mwmId, traffic::TrafficInfo::RoadSegmentId const & segmentId)
+    : m_mwmId(mwmId)
+    , m_segmentId(segmentId)
+  {}
+
+  inline bool operator<(TrafficSegmentID const & r) const
+  {
+    if (m_mwmId == r.m_mwmId)
+      return m_segmentId < r.m_segmentId;
+    return m_mwmId < r.m_mwmId;
+  }
+
+  inline bool operator==(TrafficSegmentID const & r) const
+  {
+    return (m_mwmId == r.m_mwmId && m_segmentId == r.m_segmentId);
+  }
+
+  inline bool operator!=(TrafficSegmentID const & r) const { return !(*this == r); }
+};
+
+struct TrafficSegmentGeometry
+{
+  m2::PolylineD m_polyline;
+  RoadClass m_roadClass;
+
+  TrafficSegmentGeometry(m2::PolylineD && polyline, RoadClass const & roadClass)
+    : m_polyline(std::move(polyline))
+    , m_roadClass(roadClass)
+  {}
+};
+
+using TrafficSegmentsGeometryValue =
+    std::vector<std::pair<traffic::TrafficInfo::RoadSegmentId, TrafficSegmentGeometry>>;
+using TrafficSegmentsGeometry = std::map<MwmSet::MwmId, TrafficSegmentsGeometryValue>;
+using TrafficSegmentsColoring = std::map<MwmSet::MwmId, traffic::TrafficInfo::Coloring>;
+
+struct TrafficRenderData
+{
+  dp::RenderState m_state;
+  drape_ptr<dp::RenderBucket> m_bucket;
+  TileKey m_tileKey;
+  MwmSet::MwmId m_mwmId;
+  RoadClass m_roadClass = RoadClass::Class0;
+
+  explicit TrafficRenderData(dp::RenderState const & state) : m_state(state) {}
+
+  bool operator<(TrafficRenderData const & renderData) const
+  {
+    if (m_roadClass != renderData.m_roadClass)
+      return m_roadClass > renderData.m_roadClass;
+    return m_state < renderData.m_state;
+  }
+};
+
+struct TrafficStaticVertex
+{
+  using TPosition = glsl::vec3;
+  using TNormal = glsl::vec4;
+  using TTexCoord = glsl::vec4;
+
+  TrafficStaticVertex() = default;
+  TrafficStaticVertex(TPosition const & position, TNormal const & normal, TTexCoord const & colorTexCoord)
+    : m_position(position)
+    , m_normal(normal)
+    , m_colorTexCoord(colorTexCoord)
+  {}
+
+  TPosition m_position;
+  TNormal m_normal;
+  TTexCoord m_colorTexCoord;
+};
+
+struct TrafficLineStaticVertex
+{
+  using TPosition = glsl::vec3;
+  using TTexCoord = glsl::vec2;
+
+  TrafficLineStaticVertex() = default;
+  TrafficLineStaticVertex(TPosition const & position, TTexCoord const & colorTexCoord)
+    : m_position(position)
+    , m_colorTexCoord(colorTexCoord)
+  {}
+
+  TPosition m_position;
+  TTexCoord m_colorTexCoord;
+};
+
+struct TrafficCircleStaticVertex
+{
+  using TPosition = glsl::vec4;
+  using TNormal = glsl::vec4;
+  using TTexCoord = glsl::vec2;
+
+  TrafficCircleStaticVertex() = default;
+  TrafficCircleStaticVertex(TPosition const & position, TNormal const & normal, TTexCoord const & colorTexCoord)
+    : m_position(position)
+    , m_normal(normal)
+    , m_colorTexCoord(colorTexCoord)
+  {}
+
+  TPosition m_position;
+  TNormal m_normal;
+  TTexCoord m_colorTexCoord;
+};
+
+using TrafficTexCoords = std::unordered_map<size_t, glsl::vec2>;
+
+class TrafficGenerator final
+{
+public:
+  using FlushRenderDataFn = std::function<void(TrafficRenderData && renderData)>;
+
+  explicit TrafficGenerator(FlushRenderDataFn flushFn)
+    : m_flushRenderDataFn(std::move(flushFn))
+    , m_providerTriangles(1 /* stream count */, 0 /* vertices count*/)
+    , m_providerLines(1 /* stream count */, 0 /* vertices count*/)
+    , m_providerCircles(1 /* stream count */, 0 /* vertices count*/)
+  {}
+
+  void Init();
+  void ClearContextDependentResources();
+
+  void FlushSegmentsGeometry(ref_ptr<dp::GraphicsContext> context, TileKey const & tileKey,
+                             TrafficSegmentsGeometry const & geom, ref_ptr<dp::TextureManager> textures);
+  void UpdateColoring(TrafficSegmentsColoring const & coloring);
+
+  void ClearCache();
+  void ClearCache(MwmSet::MwmId const & mwmId);
+  void InvalidateTexturesCache();
+
+  static void SetSimplifiedColorSchemeEnabled(bool enabled);
+  static traffic::SpeedGroup CheckColorsSimplification(traffic::SpeedGroup speedGroup);
+  static df::ColorConstant GetColorBySpeedGroup(traffic::SpeedGroup speedGroup, bool route);
+
+private:
+  struct TrafficBatcherKey
+  {
+    TrafficBatcherKey() = default;
+    TrafficBatcherKey(MwmSet::MwmId const & mwmId, TileKey const & tileKey, RoadClass const & roadClass)
+      : m_mwmId(mwmId)
+      , m_tileKey(tileKey)
+      , m_roadClass(roadClass)
+    {}
+
+    MwmSet::MwmId m_mwmId;
+    TileKey m_tileKey;
+    RoadClass m_roadClass;
+  };
+
+  struct TrafficBatcherKeyComparator
+  {
+    bool operator()(TrafficBatcherKey const & lhs, TrafficBatcherKey const & rhs) const
+    {
+      if (lhs.m_mwmId == rhs.m_mwmId)
+      {
+        if (lhs.m_tileKey.EqualStrict(rhs.m_tileKey))
+          return lhs.m_roadClass < rhs.m_roadClass;
+        return lhs.m_tileKey.LessStrict(rhs.m_tileKey);
+      }
+      return lhs.m_mwmId < rhs.m_mwmId;
+    }
+  };
+
+  void GenerateSegment(RoadClass roadClass, dp::TextureManager::ColorRegion const & colorRegion,
+                       m2::PolylineD const & polyline, m2::PointD const & tileCenter, bool generateCircles, float depth,
+                       float vOffset, float minU, bool isLeftHand, std::vector<TrafficStaticVertex> & staticGeometry,
+                       std::vector<TrafficCircleStaticVertex> & circlesGeometry);
+  void GenerateLineSegment(dp::TextureManager::ColorRegion const & colorRegion, m2::PolylineD const & polyline,
+                           m2::PointD const & tileCenter, float depth,
+                           std::vector<TrafficLineStaticVertex> & staticGeometry);
+  void FillColorsCache(ref_ptr<dp::TextureManager> textures);
+
+  void FlushGeometry(TrafficBatcherKey const & key, dp::RenderState const & state,
+                     drape_ptr<dp::RenderBucket> && buffer);
+  void GenerateSegmentsGeometry(ref_ptr<dp::GraphicsContext> context, MwmSet::MwmId const & mwmId,
+                                TileKey const & tileKey, TrafficSegmentsGeometryValue const & geometry,
+                                traffic::TrafficInfo::Coloring const & coloring,
+                                ref_ptr<dp::TextureManager> texturesMgr);
+
+  TrafficSegmentsColoring m_coloring;
+
+  std::array<dp::TextureManager::ColorRegion, static_cast<size_t>(traffic::SpeedGroup::Count)> m_colorsCache;
+  bool m_colorsCacheValid = false;
+
+  using BatcherPoolType = BatchersPool<TrafficBatcherKey, TrafficBatcherKeyComparator>;
+  drape_ptr<BatcherPoolType> m_batchersPool;
+  drape_ptr<dp::Batcher> m_circlesBatcher;
+  FlushRenderDataFn m_flushRenderDataFn;
+
+  dp::AttributeProvider m_providerTriangles;
+  dp::AttributeProvider m_providerLines;
+  dp::AttributeProvider m_providerCircles;
+
+  static bool m_simplifiedColorScheme;
+};
+}  // namespace df