From 55b61e842f167a3fa8d14f650c94cbd8895c9443 Mon Sep 17 00:00:00 2001 From: Daria Volvenkova Date: Tue, 27 Jun 2017 16:26:33 +0300 Subject: [PATCH] User lines rendering. --- drape_frontend/backend_renderer.cpp | 3 +- drape_frontend/drape_engine.cpp | 31 +++++++++++--- drape_frontend/frontend_renderer.cpp | 6 +-- drape_frontend/message_subclasses.hpp | 12 ++++-- drape_frontend/render_group.cpp | 2 +- drape_frontend/render_group.hpp | 2 +- drape_frontend/user_mark_generator.cpp | 31 +++++++------- drape_frontend/user_mark_shapes.cpp | 58 +++++++------------------- drape_frontend/user_mark_shapes.hpp | 35 ++++++++++------ drape_frontend/user_marks_provider.hpp | 16 ++++--- map/bookmark.cpp | 5 ++- map/track.cpp | 9 +--- map/track.hpp | 5 +-- 13 files changed, 105 insertions(+), 110 deletions(-) diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp index b45b1f7cde..50a6c775b9 100644 --- a/drape_frontend/backend_renderer.cpp +++ b/drape_frontend/backend_renderer.cpp @@ -264,7 +264,8 @@ void BackendRenderer::AcceptMessage(ref_ptr message) { ref_ptr msg = message; size_t const layerId = msg->GetLayerId(); - m_userMarkGenerator->SetUserMarks(static_cast(layerId), msg->AcceptRenderParams()); + m_userMarkGenerator->SetUserMarks(static_cast(layerId), msg->AcceptMarkRenderParams()); + m_userMarkGenerator->SetUserLines(static_cast(layerId), msg->AcceptLineRenderParams()); m_commutator->PostMessage(ThreadsCommutator::RenderThread, make_unique_dp(layerId), MessagePriority::Normal); diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp index d4a3b0bf57..6b5ef4ce58 100644 --- a/drape_frontend/drape_engine.cpp +++ b/drape_frontend/drape_engine.cpp @@ -209,11 +209,11 @@ void DrapeEngine::ChangeVisibilityUserMarksLayer(size_t layerId, bool isVisible) void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provider) { - auto renderCollection = make_unique_dp(); - renderCollection->reserve(provider->GetUserPointCount()); - for (size_t i = 0, sz = provider->GetUserPointCount(); i < sz; ++i) + auto marksRenderCollection = make_unique_dp(); + marksRenderCollection->reserve(provider->GetUserPointCount()); + for (size_t pointIndex = 0, sz = provider->GetUserPointCount(); pointIndex < sz; ++pointIndex) { - UserPointMark const * mark = provider->GetUserPointMark(i); + UserPointMark const * mark = provider->GetUserPointMark(pointIndex); UserMarkRenderParams renderInfo; renderInfo.m_anchor = mark->GetAnchor(); renderInfo.m_depth = mark->GetDepth(); @@ -222,10 +222,29 @@ void DrapeEngine::UpdateUserMarksLayer(size_t layerId, UserMarksProvider * provi renderInfo.m_pixelOffset = mark->GetPixelOffset(); renderInfo.m_runCreationAnim = mark->RunCreationAnim(); renderInfo.m_symbolName = mark->GetSymbolName(); - renderCollection->emplace_back(std::move(renderInfo)); + marksRenderCollection->emplace_back(std::move(renderInfo)); + } + + auto linesRenderCollection = make_unique_dp(); + linesRenderCollection->reserve(provider->GetUserLineCount()); + for (size_t lineIndex = 0, sz = provider->GetUserLineCount(); lineIndex < sz; ++lineIndex) + { + UserLineMark const * mark = provider->GetUserLineMark(lineIndex); + UserLineRenderParams renderInfo; + renderInfo.m_spline = m2::SharedSpline(mark->GetPoints()); + renderInfo.m_layers.reserve(mark->GetLayerCount()); + for (size_t layerIndex = 0, sz = mark->GetLayerCount(); layerIndex < sz; ++layerIndex) + { + renderInfo.m_layers.emplace_back(LineLayer(mark->GetColor(layerIndex), + mark->GetWidth(layerIndex), + mark->GetLayerDepth(layerIndex))); + } + linesRenderCollection->emplace_back(std::move(renderInfo)); } m_threadCommutator->PostMessage(ThreadsCommutator::ResourceUploadThread, - make_unique_dp(layerId, std::move(renderCollection)), + make_unique_dp(layerId, + std::move(marksRenderCollection), + std::move(linesRenderCollection)), MessagePriority::Normal); } diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp index 67f7c661dc..37fe55b2cf 100755 --- a/drape_frontend/frontend_renderer.cpp +++ b/drape_frontend/frontend_renderer.cpp @@ -1274,11 +1274,7 @@ void FrontendRenderer::RenderUserMarksLayer(ScreenBase const & modelView) { RenderLayer & userMarks = m_layers[RenderLayer::UserMarkID]; for (drape_ptr & group : userMarks.m_renderGroups) - { - // TODO: Remove after user lines complete realization. - //if (!group->CanBeClipped()) - RenderSingleGroup(modelView, make_ref(group)); - } + RenderSingleGroup(modelView, make_ref(group)); } void FrontendRenderer::BuildOverlayTree(ScreenBase const & modelView) diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp index bc39ac6724..ca949d7dff 100644 --- a/drape_frontend/message_subclasses.hpp +++ b/drape_frontend/message_subclasses.hpp @@ -237,17 +237,21 @@ private: class UpdateUserMarkLayerMessage : public BaseUserMarkLayerMessage { public: - UpdateUserMarkLayerMessage(size_t layerId, drape_ptr && renderParams) + UpdateUserMarkLayerMessage(size_t layerId, drape_ptr && marksRenderParams, + drape_ptr && linesRenderParams) : BaseUserMarkLayerMessage(layerId) - , m_renderParams(std::move(renderParams)) + , m_marksRenderParams(std::move(marksRenderParams)) + , m_linesRenderParams(std::move(linesRenderParams)) {} Type GetType() const override { return Message::UpdateUserMarkLayer; } - drape_ptr && AcceptRenderParams() { return std::move(m_renderParams); } + drape_ptr && AcceptMarkRenderParams() { return std::move(m_marksRenderParams); } + drape_ptr && AcceptLineRenderParams() { return std::move(m_linesRenderParams); } private: - drape_ptr m_renderParams; + drape_ptr m_marksRenderParams; + drape_ptr m_linesRenderParams; }; class FlushUserMarksMessage : public BaseUserMarkLayerMessage diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp index be6a47c370..40de7e3c73 100755 --- a/drape_frontend/render_group.cpp +++ b/drape_frontend/render_group.cpp @@ -223,7 +223,7 @@ void UserMarkRenderGroup::UpdateAnimation() m_uniforms.SetFloatValue("u_interpolationT", m_mapping.GetValue(t)); } -bool UserMarkRenderGroup::CanBeClipped() const +bool UserMarkRenderGroup::IsUserPoint() const { return m_state.GetProgramIndex() != gpu::LINE_PROGRAM; } diff --git a/drape_frontend/render_group.hpp b/drape_frontend/render_group.hpp index 4bf8122399..6ec6102120 100755 --- a/drape_frontend/render_group.hpp +++ b/drape_frontend/render_group.hpp @@ -101,7 +101,7 @@ public: void UpdateAnimation() override; - bool CanBeClipped() const; + bool IsUserPoint() const; private: unique_ptr m_animation; diff --git a/drape_frontend/user_mark_generator.cpp b/drape_frontend/user_mark_generator.cpp index 561d942638..e1f817a517 100644 --- a/drape_frontend/user_mark_generator.cpp +++ b/drape_frontend/user_mark_generator.cpp @@ -1,6 +1,8 @@ #include "drape_frontend/user_mark_generator.hpp" #include "drape_frontend/tile_utils.hpp" +#include "geometry/rect_intersect.hpp" + #include "indexer/scales.hpp" namespace df @@ -47,9 +49,10 @@ void UserMarkGenerator::UpdateMarksIndex(uint32_t groupId) UserMarksRenderCollection & marks = *m_marks[groupId]; for (size_t markIndex = 0; markIndex < marks.size(); ++markIndex) { - for (int zoomLevel = 1; zoomLevel <= scales::GetUpperScale(); ++zoomLevel) + UserMarkRenderParams const & params = marks[markIndex]; + for (int zoomLevel = params.m_minZoom; zoomLevel <= scales::GetUpperScale(); ++zoomLevel) { - TileKey const tileKey = GetTileKeyByPoint(marks[markIndex].m_pivot, zoomLevel); + TileKey const tileKey = GetTileKeyByPoint(params.m_pivot, zoomLevel); ref_ptr groupIndexes = GetIndexesCollection(tileKey, groupId); groupIndexes->m_markIndexes.push_back(static_cast(markIndex)); } @@ -73,19 +76,19 @@ void UserMarkGenerator::UpdateLinesIndex(uint32_t groupId) UserLinesRenderCollection & lines = *m_lines[groupId]; for (size_t lineIndex = 0; lineIndex < lines.size(); ++lineIndex) { - for (int zoomLevel = 1; zoomLevel <= scales::GetUpperScale(); ++zoomLevel) + UserLineRenderParams const & params = lines[lineIndex]; + m2::RectD rect; + for (m2::PointD const & point : params.m_spline->GetPath()) + rect.Add(point); + + for (int zoomLevel = params.m_minZoom; zoomLevel <= scales::GetUpperScale(); ++zoomLevel) { - // TODO: Calculate tiles for the line properly. - std::set tiles; - for (size_t i = 0, sz = lines[lineIndex].m_points.size(); i < sz; ++i) - { - tiles.insert(GetTileKeyByPoint(lines[lineIndex].m_points[i], zoomLevel)); - } - for (auto const & tileKey : tiles) + CalcTilesCoverage(rect, zoomLevel, [&](int tileX, int tileY) { + TileKey const tileKey(tileX, tileY, zoomLevel); ref_ptr groupIndexes = GetIndexesCollection(tileKey, groupId); groupIndexes->m_lineIndexes.push_back(static_cast(lineIndex)); - } + }); } } @@ -163,15 +166,13 @@ void UserMarkGenerator::GenerateUserMarksGeometry(TileKey const & tileKey, ref_p for (auto & groupPair : indexesGroups) { GroupID groupId = groupPair.first; - UserMarksRenderCollection const & renderParams = *m_marks[groupId]; - MarkIndexesCollection const & indexes = groupPair.second->m_markIndexes; if (m_groupsVisibility.find(groupId) == m_groupsVisibility.end()) continue; TUserMarksRenderData renderData; - CacheUserMarks(tileKey, textures, renderParams, indexes, renderData); - + CacheUserMarks(tileKey, textures, *m_marks[groupId], groupPair.second->m_markIndexes, renderData); + CacheUserLines(tileKey, textures, *m_lines[groupId], groupPair.second->m_lineIndexes, renderData); m_flushFn(groupId, std::move(renderData)); } } diff --git a/drape_frontend/user_mark_shapes.cpp b/drape_frontend/user_mark_shapes.cpp index 3030dcec31..1be5eabf95 100644 --- a/drape_frontend/user_mark_shapes.cpp +++ b/drape_frontend/user_mark_shapes.cpp @@ -8,8 +8,9 @@ #include "drape/utils/vertex_decl.hpp" #include "drape/attribute_provider.hpp" +#include "drape/batcher.hpp" -#include "geometry/spline.hpp" +#include "geometry/clipping.hpp" namespace df { @@ -146,64 +147,37 @@ void CacheUserLines(TileKey const & tileKey, ref_ptr texture UserLinesRenderCollection const & renderParams, LineIndexesCollection const & indexes, TUserMarksRenderData & renderData) { - // TODO: Refactor old caching to the new scheme. -} - -/* -void CacheUserLines(UserMarksProvider const * provider, ref_ptr textures, - TUserMarkShapes & outShapes) -{ - int const kZoomLevel = 10; - map>> userLines; - for (size_t i = 0; i < provider->GetUserLineCount(); ++i) + uint32_t const kBatchSize = 5000; + for (auto lineIndex : indexes) { - UserLineMark const * line = provider->GetUserLineMark(i); - size_t const pointCount = line->GetPointCount(); + UserLineRenderParams const & renderInfo = renderParams[lineIndex]; - vector points; - m2::RectD rect; - points.reserve(pointCount); - for (size_t i = 0; i < pointCount; ++i) - { - points.push_back(line->GetPoint(i)); - rect.Add(points.back()); - } - - TileKey const tileKey = GetTileKeyByPoint(rect.Center(), kZoomLevel); - userLines[tileKey].push_back(make_pair(line, m2::SharedSpline(points))); - } - - int const kBatchSize = 5000; - for (auto it = userLines.begin(); it != userLines.end(); ++it) - { - TileKey const & key = it->first; dp::Batcher batcher(kBatchSize, kBatchSize); - dp::SessionGuard guard(batcher, [&key, &outShapes](dp::GLState const & state, + dp::SessionGuard guard(batcher, [&tileKey, &renderData](dp::GLState const & state, drape_ptr && b) { - outShapes.emplace_back(UserMarksRenderData(state, move(b), key)); + renderData.emplace_back(UserMarkRenderData(state, move(b), tileKey)); }); - for (auto const & lineData : it->second) + + std::vector const splines = m2::ClipSplineByRect(tileKey.GetGlobalRect(), renderInfo.m_spline); + for (auto const & spline : splines) { - UserLineMark const * line = lineData.first; - for (size_t layerIndex = 0; layerIndex < line->GetLayerCount(); ++layerIndex) + for (auto const & layer : renderInfo.m_layers) { LineViewParams params; - params.m_tileCenter = key.GetGlobalRect().Center(); + params.m_tileCenter = tileKey.GetGlobalRect().Center(); params.m_baseGtoPScale = 1.0f; params.m_cap = dp::RoundCap; params.m_join = dp::RoundJoin; - params.m_color = line->GetColor(layerIndex); - params.m_depth = line->GetLayerDepth(layerIndex); - params.m_width = line->GetWidth(layerIndex); + params.m_color = layer.m_color; + params.m_depth = layer.m_depth; + params.m_width = layer.m_width; params.m_minVisibleScale = 1; params.m_rank = 0; - LineShape(lineData.second, params).Draw(make_ref(&batcher), textures); + LineShape(spline, params).Draw(make_ref(&batcher), textures); } } } } -*/ - } // namespace df diff --git a/drape_frontend/user_mark_shapes.hpp b/drape_frontend/user_mark_shapes.hpp index c9d03a0a44..a315647918 100644 --- a/drape_frontend/user_mark_shapes.hpp +++ b/drape_frontend/user_mark_shapes.hpp @@ -1,40 +1,49 @@ #pragma once #include "tile_key.hpp" -#include "user_marks_provider.hpp" -#include "drape/batcher.hpp" +#include "drape/glstate.hpp" +#include "drape/render_bucket.hpp" #include "drape/texture_manager.hpp" -#include "geometry/point2d.hpp" +#include "geometry/spline.hpp" -#include "std/function.hpp" +#include namespace df { struct UserMarkRenderParams { - m2::PointD m_pivot; - m2::PointD m_pixelOffset; + int m_minZoom = 1; + m2::PointD m_pivot = m2::PointD(0.0, 0.0); + m2::PointD m_pixelOffset = m2::PointD(0.0, 0.0); std::string m_symbolName; - dp::Anchor m_anchor; - float m_depth; - bool m_runCreationAnim; - bool m_isVisible; + dp::Anchor m_anchor = dp::Center; + float m_depth = 0.0; + bool m_runCreationAnim = false; + bool m_isVisible = true; }; struct LineLayer { + LineLayer() = default; + LineLayer(dp::Color color, float width, float depth) + : m_color(color) + , m_width(width) + , m_depth(depth) + {} + dp::Color m_color; - float m_width; - float m_depth; + float m_width = 0.0; + float m_depth = 0.0; }; struct UserLineRenderParams { + int m_minZoom = 1; std::vector m_layers; - std::vector m_points; + m2::SharedSpline m_spline; }; using UserMarksRenderCollection = std::vector; diff --git a/drape_frontend/user_marks_provider.hpp b/drape_frontend/user_marks_provider.hpp index ea8efe2cb0..1874622a78 100644 --- a/drape_frontend/user_marks_provider.hpp +++ b/drape_frontend/user_marks_provider.hpp @@ -2,11 +2,12 @@ #include "drape/drape_global.hpp" -#include "geometry/point2d.hpp" +#include "geometry/polyline2d.hpp" #include "base/mutex.hpp" -#include "std/atomic.hpp" +#include +#include namespace df { @@ -17,7 +18,7 @@ public: virtual ~UserPointMark() {} virtual m2::PointD const & GetPivot() const = 0; virtual m2::PointD GetPixelOffset() const = 0; - virtual string GetSymbolName() const = 0; + virtual std::string GetSymbolName() const = 0; virtual dp::Anchor GetAnchor() const = 0; virtual float GetDepth() const = 0; virtual bool RunCreationAnim() const = 0; @@ -33,10 +34,7 @@ public: virtual dp::Color const & GetColor(size_t layerIndex) const = 0; virtual float GetWidth(size_t layerIndex) const = 0; virtual float GetLayerDepth(size_t layerIndex) const = 0; - - /// Line geometry enumeration - virtual size_t GetPointCount() const = 0; - virtual m2::PointD const & GetPoint(size_t pointIndex) const = 0; + virtual std::vector const & GetPoints() const = 0; }; class UserMarksProvider @@ -77,8 +75,8 @@ private: threads::Mutex m_mutex; bool m_isDirty = false; - atomic m_pendingOnDelete; - atomic m_counter; + std::atomic m_pendingOnDelete; + std::atomic m_counter; }; } // namespace df diff --git a/map/bookmark.cpp b/map/bookmark.cpp index 644f91beec..9563dc98df 100644 --- a/map/bookmark.cpp +++ b/map/bookmark.cpp @@ -181,7 +181,8 @@ namespace string const kStyleUrl = "styleUrl"; string const kPair = "Pair"; - dp::Color const kDefaultTrackColor = dp::Extract(0xFF33CCFF); + dp::Color const kDefaultTrackColor = dp::Extract(0xFF1E96F0); + float const kDefaultTrackWidth = 15.0f; string PointToString(m2::PointD const & org) { @@ -410,7 +411,7 @@ namespace else if (GEOMETRY_TYPE_LINE == m_geometryType) { Track::Params params; - params.m_colors.push_back({ 5.0f, m_trackColor }); + params.m_colors.push_back({ kDefaultTrackWidth, m_trackColor }); params.m_name = m_name; /// @todo Add description, style, timestamp diff --git a/map/track.cpp b/map/track.cpp index f521c2ead6..7a921e9ef5 100644 --- a/map/track.cpp +++ b/map/track.cpp @@ -62,12 +62,7 @@ float Track::GetLayerDepth(size_t layerIndex) const return 0 + layerIndex * 10; } -size_t Track::GetPointCount() const +std::vector const & Track::GetPoints() const { - return m_polyline.GetSize(); -} - -m2::PointD const & Track::GetPoint(size_t pointIndex) const -{ - return m_polyline.GetPoint(pointIndex); + return m_polyline.GetPoints(); } diff --git a/map/track.hpp b/map/track.hpp index d3ac8ef85c..2a9d21fed8 100644 --- a/map/track.hpp +++ b/map/track.hpp @@ -43,10 +43,7 @@ public: dp::Color const & GetColor(size_t layerIndex) const override; float GetWidth(size_t layerIndex) const override; float GetLayerDepth(size_t layerIndex) const override; - - /// Line geometry enumeration - size_t GetPointCount() const override; - m2::PointD const & GetPoint(size_t pointIndex) const override; + std::vector const & GetPoints() const override; private: PolylineD m_polyline;