blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-30 18:30:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove GlContext from MapContext, layers receive MapContext from Initialize/Render

Browse source
This commit is contained in:
Dan Paulat 2025-05-08 23:15:46 -05:00
parent 2d4ad2737e
commit 44a864f50f
25 changed files with 446 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

23
scwx-qt/source/scwx/qt/map/alert_layer.cpp
View file

@ -136,13 +136,13 @@ public:
}; };
explicit Impl(AlertLayer* self, explicit Impl(AlertLayer* self,
std::shared_ptr<gl::GlContext> context, const std::shared_ptr<gl::GlContext>& glContext,
awips::Phenomenon phenomenon) : awips::Phenomenon phenomenon) :
self_ {self}, self_ {self},
phenomenon_ {phenomenon}, phenomenon_ {phenomenon},
ibw_ {awips::ibw::GetImpactBasedWarningInfo(phenomenon)}, ibw_ {awips::ibw::GetImpactBasedWarningInfo(phenomenon)},
geoLines_ {{false, std::make_shared<gl::draw::GeoLines>(context)}, geoLines_ {{false, std::make_shared<gl::draw::GeoLines>(glContext)},
{true, std::make_shared<gl::draw::GeoLines>(context)}} {true, std::make_shared<gl::draw::GeoLines>(glContext)}}
{ {
UpdateLineData(); UpdateLineData();
ConnectSignals(); ConnectSignals();
@ -245,12 +245,12 @@ public:
std::vector<boost::signals2::scoped_connection> connections_ {}; std::vector<boost::signals2::scoped_connection> connections_ {};
}; };
AlertLayer::AlertLayer(const std::shared_ptr<MapContext>& context, AlertLayer::AlertLayer(const std::shared_ptr<gl::GlContext>& glContext,
awips::Phenomenon phenomenon) : awips::Phenomenon phenomenon) :
DrawLayer( DrawLayer(
context, glContext,
fmt::format("AlertLayer {}", awips::GetPhenomenonText(phenomenon))), fmt::format("AlertLayer {}", awips::GetPhenomenonText(phenomenon))),
p(std::make_unique<Impl>(this, context->gl_context(), phenomenon)) p(std::make_unique<Impl>(this, glContext, phenomenon))
{ {
for (auto alertActive : {false, true}) for (auto alertActive : {false, true})
{ {
@ -274,11 +274,11 @@ void AlertLayer::InitializeHandler()
} }
} }
void AlertLayer::Initialize() void AlertLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize: {}", awips::GetPhenomenonText(p->phenomenon_)); logger_->debug("Initialize: {}", awips::GetPhenomenonText(p->phenomenon_));
DrawLayer::Initialize(); DrawLayer::Initialize(mapContext);
auto& alertLayerHandler = AlertLayerHandler::Instance(); auto& alertLayerHandler = AlertLayerHandler::Instance();
@ -296,16 +296,17 @@ void AlertLayer::Initialize()
p->ConnectAlertHandlerSignals(); p->ConnectAlertHandlerSignals();
} }
void AlertLayer::Render(const QMapLibre::CustomLayerRenderParameters& params) void AlertLayer::Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
for (auto alertActive : {false, true}) for (auto alertActive : {false, true})
{ {
p->geoLines_.at(alertActive)->set_selected_time(p->selectedTime_); p->geoLines_.at(alertActive)->set_selected_time(p->selectedTime_);
} }
DrawLayer::Render(params); DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR(); SCWX_GL_CHECK_ERROR();
} }

9
scwx-qt/source/scwx/qt/map/alert_layer.hpp
View file

@ -16,13 +16,14 @@ class AlertLayer : public DrawLayer
Q_DISABLE_COPY_MOVE(AlertLayer) Q_DISABLE_COPY_MOVE(AlertLayer)
public: public:
explicit AlertLayer(const std::shared_ptr<MapContext>& context, explicit AlertLayer(const std::shared_ptr<gl::GlContext>& glContext,
scwx::awips::Phenomenon phenomenon); scwx::awips::Phenomenon phenomenon);
~AlertLayer(); ~AlertLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
static void InitializeHandler(); static void InitializeHandler();

60
scwx-qt/source/scwx/qt/map/color_table_layer.cpp
View file

@ -20,44 +20,40 @@ namespace scwx::qt::map
static const std::string logPrefix_ = "scwx::qt::map::color_table_layer"; static const std::string logPrefix_ = "scwx::qt::map::color_table_layer";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class ColorTableLayerImpl class ColorTableLayer::Impl
{ {
public: public:
explicit ColorTableLayerImpl() : explicit Impl() = default;
shaderProgram_(nullptr), ~Impl() = default;
uMVPMatrixLocation_(GL_INVALID_INDEX),
vbo_ {GL_INVALID_INDEX},
vao_ {GL_INVALID_INDEX},
texture_ {GL_INVALID_INDEX},
colorTable_ {},
colorTableNeedsUpdate_ {true}
{
}
~ColorTableLayerImpl() = default;
std::shared_ptr<gl::ShaderProgram> shaderProgram_; Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
GLint uMVPMatrixLocation_; std::shared_ptr<gl::ShaderProgram> shaderProgram_ {nullptr};
std::array<GLuint, 2> vbo_;
GLuint vao_;
GLuint texture_;
std::vector<boost::gil::rgba8_pixel_t> colorTable_; GLint uMVPMatrixLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
std::array<GLuint, 2> vbo_ {GL_INVALID_INDEX};
GLuint vao_ {GL_INVALID_INDEX};
GLuint texture_ {GL_INVALID_INDEX};
bool colorTableNeedsUpdate_; std::vector<boost::gil::rgba8_pixel_t> colorTable_ {};
bool colorTableNeedsUpdate_ {true};
}; };
ColorTableLayer::ColorTableLayer(const std::shared_ptr<MapContext>& context) : ColorTableLayer::ColorTableLayer(std::shared_ptr<gl::GlContext> glContext) :
GenericLayer(context), p(std::make_unique<ColorTableLayerImpl>()) GenericLayer(std::move(glContext)), p(std::make_unique<Impl>())
{ {
} }
ColorTableLayer::~ColorTableLayer() = default; ColorTableLayer::~ColorTableLayer() = default;
void ColorTableLayer::Initialize() void ColorTableLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
auto glContext = context()->gl_context(); auto glContext = gl_context();
gl::OpenGLFunctions& gl = glContext->gl(); gl::OpenGLFunctions& gl = glContext->gl();
@ -107,20 +103,20 @@ void ColorTableLayer::Initialize()
gl.glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, static_cast<void*>(0)); gl.glVertexAttribPointer(1, 1, GL_FLOAT, GL_FALSE, 0, static_cast<void*>(0));
gl.glEnableVertexAttribArray(1); gl.glEnableVertexAttribArray(1);
connect(context()->radar_product_view().get(), connect(mapContext->radar_product_view().get(),
&view::RadarProductView::ColorTableLutUpdated, &view::RadarProductView::ColorTableLutUpdated,
this, this,
[this]() { p->colorTableNeedsUpdate_ = true; }); [this]() { p->colorTableNeedsUpdate_ = true; });
} }
void ColorTableLayer::Render( void ColorTableLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
auto radarProductView = context()->radar_product_view(); auto radarProductView = mapContext->radar_product_view();
if (context()->radar_product_view() == nullptr || if (radarProductView == nullptr || !radarProductView->IsInitialized())
!context()->radar_product_view()->IsInitialized())
{ {
// Defer rendering until view is initialized // Defer rendering until view is initialized
return; return;
@ -180,11 +176,11 @@ void ColorTableLayer::Render(
gl.glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices); gl.glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
gl.glDrawArrays(GL_TRIANGLES, 0, 6); gl.glDrawArrays(GL_TRIANGLES, 0, 6);
context()->set_color_table_margins(QMargins {0, 0, 0, 10}); mapContext->set_color_table_margins(QMargins {0, 0, 0, 10});
} }
else else
{ {
context()->set_color_table_margins(QMargins {}); mapContext->set_color_table_margins(QMargins {});
} }
SCWX_GL_CHECK_ERROR(); SCWX_GL_CHECK_ERROR();
@ -194,7 +190,7 @@ void ColorTableLayer::Deinitialize()
{ {
logger_->debug("Deinitialize()"); logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_); gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(2, p->vbo_.data()); gl.glDeleteBuffers(2, p->vbo_.data());
@ -204,8 +200,6 @@ void ColorTableLayer::Deinitialize()
p->vao_ = GL_INVALID_INDEX; p->vao_ = GL_INVALID_INDEX;
p->vbo_ = {GL_INVALID_INDEX}; p->vbo_ = {GL_INVALID_INDEX};
p->texture_ = GL_INVALID_INDEX; p->texture_ = GL_INVALID_INDEX;
context()->set_color_table_margins(QMargins {});
} }
} // namespace scwx::qt::map } // namespace scwx::qt::map

16
scwx-qt/source/scwx/qt/map/color_table_layer.hpp
View file

@ -5,20 +5,22 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class ColorTableLayerImpl;
class ColorTableLayer : public GenericLayer class ColorTableLayer : public GenericLayer
{ {
Q_DISABLE_COPY_MOVE(ColorTableLayer)
public: public:
explicit ColorTableLayer(const std::shared_ptr<MapContext>& context); explicit ColorTableLayer(std::shared_ptr<gl::GlContext> glContext);
~ColorTableLayer(); ~ColorTableLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
private: private:
std::unique_ptr<ColorTableLayerImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

53
scwx-qt/source/scwx/qt/map/draw_layer.cpp
View file

@ -1,10 +1,11 @@
#include <ranges>
#include <scwx/qt/manager/font_manager.hpp> #include <scwx/qt/manager/font_manager.hpp>
#include <scwx/qt/map/draw_layer.hpp> #include <scwx/qt/map/draw_layer.hpp>
#include <scwx/qt/model/imgui_context_model.hpp> #include <scwx/qt/model/imgui_context_model.hpp>
#include <scwx/qt/gl/shader_program.hpp> #include <scwx/qt/gl/shader_program.hpp>
#include <scwx/util/logger.hpp> #include <scwx/util/logger.hpp>
#include <ranges>
#include <backends/imgui_impl_opengl3.h> #include <backends/imgui_impl_opengl3.h>
#include <backends/imgui_impl_qt.hpp> #include <backends/imgui_impl_qt.hpp>
#include <utility> #include <utility>
@ -17,12 +18,12 @@ namespace scwx::qt::map
static const std::string logPrefix_ = "scwx::qt::map::draw_layer"; static const std::string logPrefix_ = "scwx::qt::map::draw_layer";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class DrawLayerImpl class DrawLayer::Impl
{ {
public: public:
explicit DrawLayerImpl(std::shared_ptr<MapContext> context, explicit Impl(std::shared_ptr<gl::GlContext> glContext,
const std::string& imGuiContextName) : const std::string& imGuiContextName) :
context_ {std::move(context)}, drawList_ {} glContext_ {std::move(glContext)}
{ {
static size_t currentLayerId_ {0u}; static size_t currentLayerId_ {0u};
imGuiContextName_ = imGuiContextName_ =
@ -35,7 +36,7 @@ public:
// Initialize ImGui Qt backend // Initialize ImGui Qt backend
ImGui_ImplQt_Init(); ImGui_ImplQt_Init();
} }
~DrawLayerImpl() ~Impl()
{ {
// Set ImGui Context // Set ImGui Context
ImGui::SetCurrentContext(imGuiContext_); ImGui::SetCurrentContext(imGuiContext_);
@ -51,13 +52,14 @@ public:
model::ImGuiContextModel::Instance().DestroyContext(imGuiContextName_); model::ImGuiContextModel::Instance().DestroyContext(imGuiContextName_);
} }
DrawLayerImpl(const DrawLayerImpl&) = delete; Impl(const Impl&) = delete;
DrawLayerImpl& operator=(const DrawLayerImpl&) = delete; Impl& operator=(const Impl&) = delete;
DrawLayerImpl(const DrawLayerImpl&&) = delete; Impl(const Impl&&) = delete;
DrawLayerImpl& operator=(const DrawLayerImpl&&) = delete; Impl& operator=(const Impl&&) = delete;
std::shared_ptr<MapContext> context_; std::shared_ptr<gl::GlContext> glContext_;
std::vector<std::shared_ptr<gl::draw::DrawItem>> drawList_;
std::vector<std::shared_ptr<gl::draw::DrawItem>> drawList_ {};
GLuint textureAtlas_ {GL_INVALID_INDEX}; GLuint textureAtlas_ {GL_INVALID_INDEX};
std::uint64_t textureAtlasBuildCount_ {}; std::uint64_t textureAtlasBuildCount_ {};
@ -67,27 +69,27 @@ public:
bool imGuiRendererInitialized_ {}; bool imGuiRendererInitialized_ {};
}; };
DrawLayer::DrawLayer(const std::shared_ptr<MapContext>& context, DrawLayer::DrawLayer(std::shared_ptr<gl::GlContext> glContext,
const std::string& imGuiContextName) : const std::string& imGuiContextName) :
GenericLayer(context), GenericLayer(glContext),
p(std::make_unique<DrawLayerImpl>(context, imGuiContextName)) p(std::make_unique<Impl>(std::move(glContext), imGuiContextName))
{ {
} }
DrawLayer::~DrawLayer() = default; DrawLayer::~DrawLayer() = default;
void DrawLayer::Initialize() void DrawLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
p->textureAtlas_ = p->context_->gl_context()->GetTextureAtlas(); p->textureAtlas_ = p->glContext_->GetTextureAtlas();
for (auto& item : p->drawList_) for (auto& item : p->drawList_)
{ {
item->Initialize(); item->Initialize();
} }
ImGuiInitialize(); ImGuiInitialize(mapContext);
} }
void DrawLayer::ImGuiFrameStart() void DrawLayer::ImGuiFrameStart(const std::shared_ptr<MapContext>& mapContext)
{ {
auto defaultFont = manager::FontManager::Instance().GetImGuiFont( auto defaultFont = manager::FontManager::Instance().GetImGuiFont(
types::FontCategory::Default); types::FontCategory::Default);
@ -96,7 +98,7 @@ void DrawLayer::ImGuiFrameStart()
ImGui::SetCurrentContext(p->imGuiContext_); ImGui::SetCurrentContext(p->imGuiContext_);
// Start ImGui Frame // Start ImGui Frame
ImGui_ImplQt_NewFrame(p->context_->widget()); ImGui_ImplQt_NewFrame(mapContext->widget());
ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplOpenGL3_NewFrame();
ImGui::NewFrame(); ImGui::NewFrame();
ImGui::PushFont(defaultFont->font()); ImGui::PushFont(defaultFont->font());
@ -112,10 +114,10 @@ void DrawLayer::ImGuiFrameEnd()
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
} }
void DrawLayer::ImGuiInitialize() void DrawLayer::ImGuiInitialize(const std::shared_ptr<MapContext>& mapContext)
{ {
ImGui::SetCurrentContext(p->imGuiContext_); ImGui::SetCurrentContext(p->imGuiContext_);
ImGui_ImplQt_RegisterWidget(p->context_->widget()); ImGui_ImplQt_RegisterWidget(mapContext->widget());
ImGui_ImplOpenGL3_Init(); ImGui_ImplOpenGL3_Init();
p->imGuiRendererInitialized_ = true; p->imGuiRendererInitialized_ = true;
} }
@ -123,7 +125,7 @@ void DrawLayer::ImGuiInitialize()
void DrawLayer::RenderWithoutImGui( void DrawLayer::RenderWithoutImGui(
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
auto glContext = p->context_->gl_context(); auto& glContext = p->glContext_;
gl::OpenGLFunctions& gl = glContext->gl(); gl::OpenGLFunctions& gl = glContext->gl();
p->textureAtlas_ = glContext->GetTextureAtlas(); p->textureAtlas_ = glContext->GetTextureAtlas();
@ -146,14 +148,16 @@ void DrawLayer::RenderWithoutImGui(
p->textureAtlasBuildCount_ = newTextureAtlasBuildCount; p->textureAtlasBuildCount_ = newTextureAtlasBuildCount;
} }
void DrawLayer::ImGuiSelectContext() void DrawLayer::ImGuiSelectContext()
{ {
ImGui::SetCurrentContext(p->imGuiContext_); ImGui::SetCurrentContext(p->imGuiContext_);
} }
void DrawLayer::Render(const QMapLibre::CustomLayerRenderParameters& params) void DrawLayer::Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{ {
ImGuiFrameStart(); ImGuiFrameStart(mapContext);
RenderWithoutImGui(params); RenderWithoutImGui(params);
ImGuiFrameEnd(); ImGuiFrameEnd();
} }
@ -169,6 +173,7 @@ void DrawLayer::Deinitialize()
} }
bool DrawLayer::RunMousePicking( bool DrawLayer::RunMousePicking(
const std::shared_ptr<MapContext>& /* mapContext */,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,

25
scwx-qt/source/scwx/qt/map/draw_layer.hpp
View file

@ -6,21 +6,23 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class DrawLayerImpl;
class DrawLayer : public GenericLayer class DrawLayer : public GenericLayer
{ {
Q_DISABLE_COPY_MOVE(DrawLayer)
public: public:
explicit DrawLayer(const std::shared_ptr<MapContext>& context, explicit DrawLayer(std::shared_ptr<gl::GlContext> glContext,
const std::string& imGuiContextName); const std::string& imGuiContextName);
virtual ~DrawLayer(); virtual ~DrawLayer();
virtual void Initialize() override; void Initialize(const std::shared_ptr<MapContext>& mapContext) override;
virtual void Render(const QMapLibre::CustomLayerRenderParameters&) override; void Render(const std::shared_ptr<MapContext>& mapContext,
virtual void Deinitialize() override; const QMapLibre::CustomLayerRenderParameters&) override;
void Deinitialize() override;
virtual bool bool
RunMousePicking(const QMapLibre::CustomLayerRenderParameters& params, RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
@ -29,15 +31,16 @@ public:
protected: protected:
void AddDrawItem(const std::shared_ptr<gl::draw::DrawItem>& drawItem); void AddDrawItem(const std::shared_ptr<gl::draw::DrawItem>& drawItem);
void ImGuiFrameStart(); void ImGuiFrameStart(const std::shared_ptr<MapContext>& mapContext);
void ImGuiFrameEnd(); void ImGuiFrameEnd();
void ImGuiInitialize(); void ImGuiInitialize(const std::shared_ptr<MapContext>& mapContext);
void void
RenderWithoutImGui(const QMapLibre::CustomLayerRenderParameters& params); RenderWithoutImGui(const QMapLibre::CustomLayerRenderParameters& params);
void ImGuiSelectContext(); void ImGuiSelectContext();
private: private:
std::unique_ptr<DrawLayerImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

24
scwx-qt/source/scwx/qt/map/generic_layer.cpp
View file

@ -3,26 +3,32 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class GenericLayerImpl class GenericLayer::Impl
{ {
public: public:
explicit GenericLayerImpl(std::shared_ptr<MapContext> context) : explicit Impl(std::shared_ptr<gl::GlContext> glContext) :
context_ {std::move(context)} glContext_ {std::move(glContext)}
{ {
} }
~GenericLayerImpl() {} ~Impl() = default;
std::shared_ptr<MapContext> context_; Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::shared_ptr<gl::GlContext> glContext_;
}; };
GenericLayer::GenericLayer(const std::shared_ptr<MapContext>& context) : GenericLayer::GenericLayer(std::shared_ptr<gl::GlContext> glContext) :
p(std::make_unique<GenericLayerImpl>(context)) p(std::make_unique<Impl>(std::move(glContext)))
{ {
} }
GenericLayer::~GenericLayer() = default; GenericLayer::~GenericLayer() = default;
bool GenericLayer::RunMousePicking( bool GenericLayer::RunMousePicking(
const std::shared_ptr<MapContext>& /* mapContext */,
const QMapLibre::CustomLayerRenderParameters& /* params */, const QMapLibre::CustomLayerRenderParameters& /* params */,
const QPointF& /* mouseLocalPos */, const QPointF& /* mouseLocalPos */,
const QPointF& /* mouseGlobalPos */, const QPointF& /* mouseGlobalPos */,
@ -34,9 +40,9 @@ bool GenericLayer::RunMousePicking(
return false; return false;
} }
std::shared_ptr<MapContext> GenericLayer::context() const std::shared_ptr<gl::GlContext> GenericLayer::gl_context() const
{ {
return p->context_; return p->glContext_;
} }
} // namespace scwx::qt::map } // namespace scwx::qt::map

20
scwx-qt/source/scwx/qt/map/generic_layer.hpp
View file

@ -1,5 +1,6 @@
#pragma once #pragma once
#include <scwx/qt/gl/gl_context.hpp>
#include <scwx/qt/map/map_context.hpp> #include <scwx/qt/map/map_context.hpp>
#include <scwx/qt/types/event_types.hpp> #include <scwx/qt/types/event_types.hpp>
#include <scwx/common/geographic.hpp> #include <scwx/common/geographic.hpp>
@ -13,23 +14,24 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class GenericLayerImpl;
class GenericLayer : public QObject class GenericLayer : public QObject
{ {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY_MOVE(GenericLayer)
public: public:
explicit GenericLayer(const std::shared_ptr<MapContext>& context); explicit GenericLayer(std::shared_ptr<gl::GlContext> glContext);
virtual ~GenericLayer(); virtual ~GenericLayer();
virtual void Initialize() = 0; virtual void Initialize(const std::shared_ptr<MapContext>& mapContext) = 0;
virtual void Render(const QMapLibre::CustomLayerRenderParameters&) = 0; virtual void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) = 0;
virtual void Deinitialize() = 0; virtual void Deinitialize() = 0;
/** /**
* @brief Run mouse picking on the layer. * @brief Run mouse picking on the layer.
* *
* @param [in] mapContext Map context
* @param [in] params Custom layer render parameters * @param [in] params Custom layer render parameters
* @param [in] mouseLocalPos Mouse cursor widget position * @param [in] mouseLocalPos Mouse cursor widget position
* @param [in] mouseGlobalPos Mouse cursor screen position * @param [in] mouseGlobalPos Mouse cursor screen position
@ -40,7 +42,8 @@ public:
* @return true if a draw item was picked, otherwise false * @return true if a draw item was picked, otherwise false
*/ */
virtual bool virtual bool
RunMousePicking(const QMapLibre::CustomLayerRenderParameters& params, RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
@ -51,10 +54,11 @@ signals:
void NeedsRendering(); void NeedsRendering();
protected: protected:
std::shared_ptr<MapContext> context() const; [[nodiscard]] std::shared_ptr<gl::GlContext> gl_context() const;
private: private:
std::unique_ptr<GenericLayerImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

24
scwx-qt/source/scwx/qt/map/layer_wrapper.cpp
View file

@ -3,21 +3,29 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class LayerWrapperImpl class LayerWrapper::Impl
{ {
public: public:
explicit LayerWrapperImpl(std::shared_ptr<GenericLayer> layer) : explicit Impl(std::shared_ptr<GenericLayer> layer,
layer_ {std::move(layer)} std::shared_ptr<MapContext> mapContext) :
layer_ {std::move(layer)}, mapContext_ {std::move(mapContext)}
{ {
} }
~LayerWrapperImpl() {} ~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
std::shared_ptr<GenericLayer> layer_; std::shared_ptr<GenericLayer> layer_;
std::shared_ptr<MapContext> mapContext_;
}; };
LayerWrapper::LayerWrapper(const std::shared_ptr<GenericLayer>& layer) : LayerWrapper::LayerWrapper(std::shared_ptr<GenericLayer> layer,
p(std::make_unique<LayerWrapperImpl>(layer)) std::shared_ptr<MapContext> mapContext) :
p(std::make_unique<Impl>(std::move(layer), std::move(mapContext)))
{ {
} }
LayerWrapper::~LayerWrapper() = default; LayerWrapper::~LayerWrapper() = default;
@ -30,7 +38,7 @@ void LayerWrapper::initialize()
auto& layer = p->layer_; auto& layer = p->layer_;
if (layer != nullptr) if (layer != nullptr)
{ {
layer->Initialize(); layer->Initialize(p->mapContext_);
} }
} }
@ -39,7 +47,7 @@ void LayerWrapper::render(const QMapLibre::CustomLayerRenderParameters& params)
auto& layer = p->layer_; auto& layer = p->layer_;
if (layer != nullptr) if (layer != nullptr)
{ {
layer->Render(params); layer->Render(p->mapContext_, params);
} }
} }

15
scwx-qt/source/scwx/qt/map/layer_wrapper.hpp
View file

@ -1,16 +1,16 @@
#pragma once #pragma once
#include <scwx/qt/map/generic_layer.hpp> #include <scwx/qt/map/generic_layer.hpp>
#include <scwx/qt/map/map_context.hpp>
namespace scwx::qt::map namespace scwx::qt::map
{ {
class LayerWrapperImpl;
class LayerWrapper : public QMapLibre::CustomLayerHostInterface class LayerWrapper : public QMapLibre::CustomLayerHostInterface
{ {
public: public:
explicit LayerWrapper(const std::shared_ptr<GenericLayer>& layer); explicit LayerWrapper(std::shared_ptr<GenericLayer> layer,
std::shared_ptr<MapContext> mapContext);
~LayerWrapper(); ~LayerWrapper();
LayerWrapper(const LayerWrapper&) = delete; LayerWrapper(const LayerWrapper&) = delete;
@ -19,12 +19,13 @@ public:
LayerWrapper(LayerWrapper&&) noexcept; LayerWrapper(LayerWrapper&&) noexcept;
LayerWrapper& operator=(LayerWrapper&&) noexcept; LayerWrapper& operator=(LayerWrapper&&) noexcept;
void initialize() override final; void initialize() final;
void render(const QMapLibre::CustomLayerRenderParameters&) override final; void render(const QMapLibre::CustomLayerRenderParameters&) final;
void deinitialize() override final; void deinitialize() final;
private: private:
std::unique_ptr<LayerWrapperImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

8
scwx-qt/source/scwx/qt/map/map_context.cpp
View file

@ -16,9 +16,6 @@ public:
~Impl() {} ~Impl() {}
std::shared_ptr<gl::GlContext> glContext_ {
std::make_shared<gl::GlContext>()};
std::weak_ptr<QMapLibre::Map> map_ {}; std::weak_ptr<QMapLibre::Map> map_ {};
MapSettings settings_ {}; MapSettings settings_ {};
float pixelRatio_ {1.0f}; float pixelRatio_ {1.0f};
@ -50,11 +47,6 @@ MapContext::~MapContext() = default;
MapContext::MapContext(MapContext&&) noexcept = default; MapContext::MapContext(MapContext&&) noexcept = default;
MapContext& MapContext::operator=(MapContext&&) noexcept = default; MapContext& MapContext::operator=(MapContext&&) noexcept = default;
std::shared_ptr<gl::GlContext> MapContext::gl_context() const
{
return p->glContext_;
}
std::weak_ptr<QMapLibre::Map> MapContext::map() const std::weak_ptr<QMapLibre::Map> MapContext::map() const
{ {
return p->map_; return p->map_;

3
scwx-qt/source/scwx/qt/map/map_context.hpp
View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <scwx/qt/gl/gl_context.hpp>
#include <scwx/qt/map/map_provider.hpp> #include <scwx/qt/map/map_provider.hpp>
#include <scwx/common/geographic.hpp> #include <scwx/common/geographic.hpp>
#include <scwx/common/products.hpp> #include <scwx/common/products.hpp>
@ -35,8 +34,6 @@ public:
MapContext(MapContext&&) noexcept; MapContext(MapContext&&) noexcept;
MapContext& operator=(MapContext&&) noexcept; MapContext& operator=(MapContext&&) noexcept;
[[nodiscard]] std::shared_ptr<gl::GlContext> gl_context() const;
[[nodiscard]] std::weak_ptr<QMapLibre::Map> map() const; [[nodiscard]] std::weak_ptr<QMapLibre::Map> map() const;
[[nodiscard]] std::string map_copyrights() const; [[nodiscard]] std::string map_copyrights() const;
[[nodiscard]] MapProvider map_provider() const; [[nodiscard]] MapProvider map_provider() const;

34
scwx-qt/source/scwx/qt/map/map_widget.cpp
View file

@ -73,7 +73,6 @@ public:
const QMapLibre::Settings& settings) : const QMapLibre::Settings& settings) :
id_ {id}, id_ {id},
uuid_ {boost::uuids::random_generator()()}, uuid_ {boost::uuids::random_generator()()},
context_ {std::make_shared<MapContext>()},
widget_ {widget}, widget_ {widget},
settings_(settings), settings_(settings),
map_(), map_(),
@ -155,7 +154,7 @@ public:
types::LayerDescription description, types::LayerDescription description,
const std::string& before = {}); const std::string& before = {});
void AddLayer(const std::string& id, void AddLayer(const std::string& id,
std::shared_ptr<GenericLayer> layer, const std::shared_ptr<GenericLayer>& layer,
const std::string& before = {}); const std::string& before = {});
void AddLayers(); void AddLayers();
void AddPlacefileLayer(const std::string& placefileName, void AddPlacefileLayer(const std::string& placefileName,
@ -194,7 +193,9 @@ public:
std::size_t id_; std::size_t id_;
boost::uuids::uuid uuid_; boost::uuids::uuid uuid_;
std::shared_ptr<MapContext> context_; std::shared_ptr<MapContext> context_ {std::make_shared<MapContext>()};
std::shared_ptr<gl::GlContext> glContext_ {
std::make_shared<gl::GlContext>()};
MapWidget* widget_; MapWidget* widget_;
QMapLibre::Settings settings_; QMapLibre::Settings settings_;
@ -1239,7 +1240,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
// If there is a radar product view, create the radar product layer // If there is a radar product view, create the radar product layer
if (radarProductView != nullptr) if (radarProductView != nullptr)
{ {
radarProductLayer_ = std::make_shared<RadarProductLayer>(context_); radarProductLayer_ = std::make_shared<RadarProductLayer>(glContext_);
AddLayer(layerName, radarProductLayer_, before); AddLayer(layerName, radarProductLayer_, before);
} }
} }
@ -1248,7 +1249,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
auto phenomenon = std::get<awips::Phenomenon>(description); auto phenomenon = std::get<awips::Phenomenon>(description);
std::shared_ptr<AlertLayer> alertLayer = std::shared_ptr<AlertLayer> alertLayer =
std::make_shared<AlertLayer>(context_, phenomenon); std::make_shared<AlertLayer>(glContext_, phenomenon);
AddLayer(fmt::format("alert.{}", awips::GetPhenomenonCode(phenomenon)), AddLayer(fmt::format("alert.{}", awips::GetPhenomenonCode(phenomenon)),
alertLayer, alertLayer,
before); before);
@ -1272,7 +1273,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
{ {
// Create the map overlay layer // Create the map overlay layer
case types::InformationLayer::MapOverlay: case types::InformationLayer::MapOverlay:
overlayLayer_ = std::make_shared<OverlayLayer>(context_); overlayLayer_ = std::make_shared<OverlayLayer>(glContext_);
AddLayer(layerName, overlayLayer_, before); AddLayer(layerName, overlayLayer_, before);
break; break;
@ -1280,14 +1281,14 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
case types::InformationLayer::ColorTable: case types::InformationLayer::ColorTable:
if (radarProductView != nullptr) if (radarProductView != nullptr)
{ {
colorTableLayer_ = std::make_shared<ColorTableLayer>(context_); colorTableLayer_ = std::make_shared<ColorTableLayer>(glContext_);
AddLayer(layerName, colorTableLayer_, before); AddLayer(layerName, colorTableLayer_, before);
} }
break; break;
// Create the radar site layer // Create the radar site layer
case types::InformationLayer::RadarSite: case types::InformationLayer::RadarSite:
radarSiteLayer_ = std::make_shared<RadarSiteLayer>(context_); radarSiteLayer_ = std::make_shared<RadarSiteLayer>(glContext_);
AddLayer(layerName, radarSiteLayer_, before); AddLayer(layerName, radarSiteLayer_, before);
connect( connect(
radarSiteLayer_.get(), radarSiteLayer_.get(),
@ -1303,7 +1304,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
// Create the location marker layer // Create the location marker layer
case types::InformationLayer::Markers: case types::InformationLayer::Markers:
markerLayer_ = std::make_shared<MarkerLayer>(context_); markerLayer_ = std::make_shared<MarkerLayer>(glContext_);
AddLayer(layerName, markerLayer_, before); AddLayer(layerName, markerLayer_, before);
break; break;
@ -1320,7 +1321,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
if (radarProductView != nullptr) if (radarProductView != nullptr)
{ {
overlayProductLayer_ = overlayProductLayer_ =
std::make_shared<OverlayProductLayer>(context_); std::make_shared<OverlayProductLayer>(glContext_);
AddLayer(layerName, overlayProductLayer_, before); AddLayer(layerName, overlayProductLayer_, before);
} }
break; break;
@ -1350,7 +1351,7 @@ void MapWidgetImpl::AddPlacefileLayer(const std::string& placefileName,
const std::string& before) const std::string& before)
{ {
std::shared_ptr<PlacefileLayer> placefileLayer = std::shared_ptr<PlacefileLayer> placefileLayer =
std::make_shared<PlacefileLayer>(context_, placefileName); std::make_shared<PlacefileLayer>(glContext_, placefileName);
placefileLayers_.push_back(placefileLayer); placefileLayers_.push_back(placefileLayer);
AddLayer(GetPlacefileLayerName(placefileName), placefileLayer, before); AddLayer(GetPlacefileLayerName(placefileName), placefileLayer, before);
@ -1368,12 +1369,12 @@ MapWidgetImpl::GetPlacefileLayerName(const std::string& placefileName)
} }
void MapWidgetImpl::AddLayer(const std::string& id, void MapWidgetImpl::AddLayer(const std::string& id,
std::shared_ptr<GenericLayer> layer, const std::shared_ptr<GenericLayer>& layer,
const std::string& before) const std::string& before)
{ {
// QMapLibre::addCustomLayer will take ownership of the std::unique_ptr // QMapLibre::addCustomLayer will take ownership of the std::unique_ptr
std::unique_ptr<QMapLibre::CustomLayerHostInterface> pHost = std::unique_ptr<QMapLibre::CustomLayerHostInterface> pHost =
std::make_unique<LayerWrapper>(layer); std::make_unique<LayerWrapper>(layer, context_);
try try
{ {
@ -1542,7 +1543,7 @@ void MapWidget::initializeGL()
makeCurrent(); makeCurrent();
p->context_->gl_context()->Initialize(); p->glContext_->Initialize();
// Lock ImGui font atlas prior to new ImGui frame // Lock ImGui font atlas prior to new ImGui frame
std::shared_lock imguiFontAtlasLock { std::shared_lock imguiFontAtlasLock {
@ -1596,7 +1597,7 @@ void MapWidget::paintGL()
p->frameDraws_++; p->frameDraws_++;
p->context_->gl_context()->StartFrame(); p->glContext_->StartFrame();
// Handle hotkey updates // Handle hotkey updates
p->HandleHotkeyUpdates(); p->HandleHotkeyUpdates();
@ -1705,7 +1706,8 @@ void MapWidgetImpl::RunMousePicking()
for (auto it = genericLayers_.rbegin(); it != genericLayers_.rend(); ++it) for (auto it = genericLayers_.rbegin(); it != genericLayers_.rend(); ++it)
{ {
// Run mouse picking for each layer // Run mouse picking for each layer
if ((*it)->RunMousePicking(params, if ((*it)->RunMousePicking(context_,
params,
lastPos_, lastPos_,
lastGlobalPos_, lastGlobalPos_,
mouseScreenCoordinate, mouseScreenCoordinate,

31
scwx-qt/source/scwx/qt/map/marker_layer.cpp
View file

@ -5,11 +5,11 @@
#include <scwx/qt/types/marker_types.hpp> #include <scwx/qt/types/marker_types.hpp>
#include <scwx/qt/ui/edit_marker_dialog.hpp> #include <scwx/qt/ui/edit_marker_dialog.hpp>
#include <string>
#include <QGeoPositionInfo> #include <QGeoPositionInfo>
#include <QMouseEvent> #include <QMouseEvent>
#include <string>
namespace scwx::qt::map namespace scwx::qt::map
{ {
@ -19,15 +19,21 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class MarkerLayer::Impl class MarkerLayer::Impl
{ {
public: public:
explicit Impl(MarkerLayer* self, std::shared_ptr<gl::GlContext> context) : explicit Impl(MarkerLayer* self,
const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self}, self_ {self},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(context)}, geoIcons_ {std::make_shared<gl::draw::GeoIcons>(glContext)},
editMarkerDialog_ {std::make_shared<ui::EditMarkerDialog>()} editMarkerDialog_ {std::make_shared<ui::EditMarkerDialog>()}
{ {
ConnectSignals(); ConnectSignals();
} }
~Impl() = default; ~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void ReloadMarkers(); void ReloadMarkers();
void ConnectSignals(); void ConnectSignals();
@ -124,19 +130,19 @@ void MarkerLayer::Impl::ReloadMarkers()
Q_EMIT self_->NeedsRendering(); Q_EMIT self_->NeedsRendering();
} }
MarkerLayer::MarkerLayer(const std::shared_ptr<MapContext>& context) : MarkerLayer::MarkerLayer(const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(context, "MarkerLayer"), DrawLayer(glContext, "MarkerLayer"),
p(std::make_unique<MarkerLayer::Impl>(this, context->gl_context())) p(std::make_unique<MarkerLayer::Impl>(this, glContext))
{ {
AddDrawItem(p->geoIcons_); AddDrawItem(p->geoIcons_);
} }
MarkerLayer::~MarkerLayer() = default; MarkerLayer::~MarkerLayer() = default;
void MarkerLayer::Initialize() void MarkerLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
DrawLayer::Initialize(); DrawLayer::Initialize(mapContext);
p->set_icon_sheets(); p->set_icon_sheets();
p->ReloadMarkers(); p->ReloadMarkers();
@ -156,11 +162,12 @@ void MarkerLayer::Impl::set_icon_sheets()
geoIcons_->FinishIconSheets(); geoIcons_->FinishIconSheets();
} }
void MarkerLayer::Render(const QMapLibre::CustomLayerRenderParameters& params) void MarkerLayer::Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
DrawLayer::Render(params); DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR(); SCWX_GL_CHECK_ERROR();
} }

10
scwx-qt/source/scwx/qt/map/marker_layer.hpp
View file

@ -8,14 +8,16 @@ namespace scwx::qt::map
class MarkerLayer : public DrawLayer class MarkerLayer : public DrawLayer
{ {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY_MOVE(MarkerLayer)
public: public:
explicit MarkerLayer(const std::shared_ptr<MapContext>& context); explicit MarkerLayer(const std::shared_ptr<gl::GlContext>& context);
~MarkerLayer(); ~MarkerLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
private: private:
class Impl; class Impl;

87
scwx-qt/source/scwx/qt/map/overlay_layer.cpp
View file

@ -32,16 +32,16 @@ namespace scwx::qt::map
static const std::string logPrefix_ = "scwx::qt::map::overlay_layer"; static const std::string logPrefix_ = "scwx::qt::map::overlay_layer";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class OverlayLayerImpl class OverlayLayer::Impl
{ {
public: public:
explicit OverlayLayerImpl(OverlayLayer* self, explicit Impl(OverlayLayer* self,
std::shared_ptr<gl::GlContext> context) : const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self}, self_ {self},
activeBoxOuter_ {std::make_shared<gl::draw::Rectangle>(context)}, activeBoxOuter_ {std::make_shared<gl::draw::Rectangle>(glContext)},
activeBoxInner_ {std::make_shared<gl::draw::Rectangle>(context)}, activeBoxInner_ {std::make_shared<gl::draw::Rectangle>(glContext)},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(context)}, geoIcons_ {std::make_shared<gl::draw::GeoIcons>(glContext)},
icons_ {std::make_shared<gl::draw::Icons>(context)}, icons_ {std::make_shared<gl::draw::Icons>(glContext)},
renderMutex_ {} renderMutex_ {}
{ {
auto& generalSettings = settings::GeneralSettings::Instance(); auto& generalSettings = settings::GeneralSettings::Instance();
@ -71,7 +71,7 @@ public:
[this](const bool&) { Q_EMIT self_->NeedsRendering(); }); [this](const bool&) { Q_EMIT self_->NeedsRendering(); });
} }
~OverlayLayerImpl() ~Impl()
{ {
auto& generalSettings = settings::GeneralSettings::Instance(); auto& generalSettings = settings::GeneralSettings::Instance();
@ -87,6 +87,11 @@ public:
showMapLogoCallbackUuid_); showMapLogoCallbackUuid_);
} }
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void SetupGeoIcons(); void SetupGeoIcons();
void SetCusorLocation(common::Coordinate coordinate); void SetCusorLocation(common::Coordinate coordinate);
@ -151,9 +156,9 @@ public:
bool sweepTimePicked_ {false}; bool sweepTimePicked_ {false};
}; };
OverlayLayer::OverlayLayer(const std::shared_ptr<MapContext>& context) : OverlayLayer::OverlayLayer(const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(context, "OverlayLayer"), DrawLayer(glContext, "OverlayLayer"),
p(std::make_unique<OverlayLayerImpl>(this, context->gl_context())) p(std::make_unique<Impl>(this, glContext))
{ {
AddDrawItem(p->activeBoxOuter_); AddDrawItem(p->activeBoxOuter_);
AddDrawItem(p->activeBoxInner_); AddDrawItem(p->activeBoxInner_);
@ -168,13 +173,13 @@ OverlayLayer::~OverlayLayer()
p->cursorScaleConnection_.disconnect(); p->cursorScaleConnection_.disconnect();
} }
void OverlayLayerImpl::SetCusorLocation(common::Coordinate coordinate) void OverlayLayer::Impl::SetCusorLocation(common::Coordinate coordinate)
{ {
geoIcons_->SetIconLocation( geoIcons_->SetIconLocation(
cursorIcon_, coordinate.latitude_, coordinate.longitude_); cursorIcon_, coordinate.latitude_, coordinate.longitude_);
} }
void OverlayLayerImpl::SetupGeoIcons() void OverlayLayer::Impl::SetupGeoIcons()
{ {
const std::unique_lock lock {renderMutex_}; const std::unique_lock lock {renderMutex_};
@ -208,13 +213,13 @@ void OverlayLayerImpl::SetupGeoIcons()
geoIcons_->FinishIcons(); geoIcons_->FinishIcons();
} }
void OverlayLayer::Initialize() void OverlayLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
DrawLayer::Initialize(); DrawLayer::Initialize(mapContext);
auto radarProductView = context()->radar_product_view(); auto radarProductView = mapContext->radar_product_view();
if (radarProductView != nullptr) if (radarProductView != nullptr)
{ {
@ -251,7 +256,7 @@ void OverlayLayer::Initialize()
p->icons_->SetIconTexture(p->compassIcon_, p->cardinalPointIconName_, 0); p->icons_->SetIconTexture(p->compassIcon_, p->cardinalPointIconName_, 0);
gl::draw::Icons::RegisterEventHandler( gl::draw::Icons::RegisterEventHandler(
p->compassIcon_, p->compassIcon_,
[this](QEvent* ev) [this, mapContext](QEvent* ev)
{ {
switch (ev->type()) switch (ev->type())
{ {
@ -276,7 +281,7 @@ void OverlayLayer::Initialize()
if (mouseEvent->buttons() == Qt::MouseButton::LeftButton && if (mouseEvent->buttons() == Qt::MouseButton::LeftButton &&
p->lastBearing_ != 0.0) p->lastBearing_ != 0.0)
{ {
auto map = context()->map().lock(); auto map = mapContext->map().lock();
if (map != nullptr) if (map != nullptr)
{ {
map->setBearing(0.0); map->setBearing(0.0);
@ -295,11 +300,11 @@ void OverlayLayer::Initialize()
p->icons_->SetIconTexture(p->mapCenterIcon_, p->mapCenterIconName_, 0); p->icons_->SetIconTexture(p->mapCenterIcon_, p->mapCenterIconName_, 0);
p->mapLogoIcon_ = p->icons_->AddIcon(); p->mapLogoIcon_ = p->icons_->AddIcon();
if (context()->map_provider() == MapProvider::Mapbox) if (mapContext->map_provider() == MapProvider::Mapbox)
{ {
p->icons_->SetIconTexture(p->mapLogoIcon_, p->mapboxLogoImageName_, 0); p->icons_->SetIconTexture(p->mapLogoIcon_, p->mapboxLogoImageName_, 0);
} }
else if (context()->map_provider() == MapProvider::MapTiler) else if (mapContext->map_provider() == MapProvider::MapTiler)
{ {
p->icons_->SetIconTexture(p->mapLogoIcon_, p->mapTilerLogoImageName_, 0); p->icons_->SetIconTexture(p->mapLogoIcon_, p->mapTilerLogoImageName_, 0);
} }
@ -328,16 +333,17 @@ void OverlayLayer::Initialize()
}); });
} }
void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params) void OverlayLayer::Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{ {
const std::unique_lock lock {p->renderMutex_}; const std::unique_lock lock {p->renderMutex_};
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
auto radarProductView = context()->radar_product_view(); auto radarProductView = mapContext->radar_product_view();
auto& settings = context()->settings(); auto& settings = mapContext->settings();
const float pixelRatio = context()->pixel_ratio(); const float pixelRatio = mapContext->pixel_ratio();
ImGuiFrameStart(); ImGuiFrameStart(mapContext);
p->sweepTimePicked_ = false; p->sweepTimePicked_ = false;
@ -383,7 +389,7 @@ void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params)
p->geoIcons_->SetIconVisible(p->cursorIcon_, cursorIconVisible); p->geoIcons_->SetIconVisible(p->cursorIcon_, cursorIconVisible);
if (cursorIconVisible) if (cursorIconVisible)
{ {
p->SetCusorLocation(context()->mouse_coordinate()); p->SetCusorLocation(mapContext->mouse_coordinate());
} }
// Location Icon // Location Icon
@ -507,7 +513,7 @@ void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params)
p->icons_->SetIconVisible(p->mapCenterIcon_, p->icons_->SetIconVisible(p->mapCenterIcon_,
generalSettings.show_map_center().GetValue()); generalSettings.show_map_center().GetValue());
QMargins colorTableMargins = context()->color_table_margins(); QMargins colorTableMargins = mapContext->color_table_margins();
if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_) if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_)
{ {
// Draw map logo with a 10x10 indent from the bottom left // Draw map logo with a 10x10 indent from the bottom left
@ -520,7 +526,7 @@ void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params)
DrawLayer::RenderWithoutImGui(params); DrawLayer::RenderWithoutImGui(params);
auto mapCopyrights = context()->map_copyrights(); auto mapCopyrights = mapContext->map_copyrights();
if (mapCopyrights.length() > 0 && if (mapCopyrights.length() > 0 &&
generalSettings.show_map_attribution().GetValue()) generalSettings.show_map_attribution().GetValue())
{ {
@ -563,29 +569,13 @@ void OverlayLayer::Deinitialize()
DrawLayer::Deinitialize(); DrawLayer::Deinitialize();
auto radarProductView = context()->radar_product_view(); disconnect(this);
if (radarProductView != nullptr)
{
disconnect(radarProductView.get(),
&view::RadarProductView::SweepComputed,
this,
&OverlayLayer::UpdateSweepTimeNextFrame);
}
disconnect(p->positionManager_.get(),
&manager::PositionManager::LocationTrackingChanged,
this,
nullptr);
disconnect(p->positionManager_.get(),
&manager::PositionManager::PositionUpdated,
this,
nullptr);
p->locationIcon_ = nullptr; p->locationIcon_ = nullptr;
} }
bool OverlayLayer::RunMousePicking( bool OverlayLayer::RunMousePicking(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
@ -599,7 +589,8 @@ bool OverlayLayer::RunMousePicking(
return true; return true;
} }
return DrawLayer::RunMousePicking(params, return DrawLayer::RunMousePicking(mapContext,
params,
mouseLocalPos, mouseLocalPos,
mouseGlobalPos, mouseGlobalPos,
mouseCoords, mouseCoords,

19
scwx-qt/source/scwx/qt/map/overlay_layer.hpp
View file

@ -5,33 +5,34 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class OverlayLayerImpl;
class OverlayLayer : public DrawLayer class OverlayLayer : public DrawLayer
{ {
Q_DISABLE_COPY_MOVE(OverlayLayer) Q_DISABLE_COPY_MOVE(OverlayLayer)
public: public:
explicit OverlayLayer(const std::shared_ptr<MapContext>& context); explicit OverlayLayer(const std::shared_ptr<gl::GlContext>& glContext);
~OverlayLayer(); ~OverlayLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
bool RunMousePicking( bool
RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
const common::Coordinate& mouseGeoCoords, const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) override final; std::shared_ptr<types::EventHandler>& eventHandler) final;
public slots: public slots:
void UpdateSweepTimeNextFrame(); void UpdateSweepTimeNextFrame();
private: private:
std::unique_ptr<OverlayLayerImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

56
scwx-qt/source/scwx/qt/map/overlay_product_layer.cpp
View file

@ -21,9 +21,9 @@ class OverlayProductLayer::Impl
{ {
public: public:
explicit Impl(OverlayProductLayer* self, explicit Impl(OverlayProductLayer* self,
std::shared_ptr<gl::GlContext> context) : const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self}, self_ {self},
linkedVectors_ {std::make_shared<gl::draw::LinkedVectors>(context)} linkedVectors_ {std::make_shared<gl::draw::LinkedVectors>(glContext)}
{ {
auto& productSettings = settings::ProductSettings::Instance(); auto& productSettings = settings::ProductSettings::Instance();
@ -60,7 +60,8 @@ public:
stiPastEnabledCallbackUuid_); stiPastEnabledCallbackUuid_);
} }
void UpdateStormTrackingInformation(); void UpdateStormTrackingInformation(
const std::shared_ptr<MapContext>& mapContext);
static void HandleLinkedVectorPacket( static void HandleLinkedVectorPacket(
const std::shared_ptr<const wsr88d::rpg::Packet>& packet, const std::shared_ptr<const wsr88d::rpg::Packet>& packet,
@ -105,11 +106,21 @@ public:
}; };
OverlayProductLayer::OverlayProductLayer( OverlayProductLayer::OverlayProductLayer(
const std::shared_ptr<MapContext>& context) : const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(context, "OverlayProductLayer"), DrawLayer(glContext, "OverlayProductLayer"),
p(std::make_unique<Impl>(this, context->gl_context())) p(std::make_unique<Impl>(this, glContext))
{ {
auto overlayProductView = context->overlay_product_view(); AddDrawItem(p->linkedVectors_);
}
OverlayProductLayer::~OverlayProductLayer() = default;
void OverlayProductLayer::Initialize(
const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
auto overlayProductView = mapContext->overlay_product_view();
connect(overlayProductView.get(), connect(overlayProductView.get(),
&view::OverlayProductView::ProductUpdated, &view::OverlayProductView::ProductUpdated,
this, this,
@ -122,31 +133,23 @@ OverlayProductLayer::OverlayProductLayer(
} }
}); });
AddDrawItem(p->linkedVectors_); p->UpdateStormTrackingInformation(mapContext);
}
OverlayProductLayer::~OverlayProductLayer() = default; DrawLayer::Initialize(mapContext);
void OverlayProductLayer::Initialize()
{
logger_->debug("Initialize()");
p->UpdateStormTrackingInformation();
DrawLayer::Initialize();
} }
void OverlayProductLayer::Render( void OverlayProductLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
if (p->stiNeedsUpdate_) if (p->stiNeedsUpdate_)
{ {
p->UpdateStormTrackingInformation(); p->UpdateStormTrackingInformation(mapContext);
} }
DrawLayer::Render(params); DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR(); SCWX_GL_CHECK_ERROR();
} }
@ -155,16 +158,19 @@ void OverlayProductLayer::Deinitialize()
{ {
logger_->debug("Deinitialize()"); logger_->debug("Deinitialize()");
disconnect(this);
DrawLayer::Deinitialize(); DrawLayer::Deinitialize();
} }
void OverlayProductLayer::Impl::UpdateStormTrackingInformation() void OverlayProductLayer::Impl::UpdateStormTrackingInformation(
const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Update Storm Tracking Information"); logger_->debug("Update Storm Tracking Information");
stiNeedsUpdate_ = false; stiNeedsUpdate_ = false;
auto overlayProductView = self_->context()->overlay_product_view(); auto overlayProductView = mapContext->overlay_product_view();
auto radarProductManager = overlayProductView->radar_product_manager(); auto radarProductManager = overlayProductView->radar_product_manager();
auto message = overlayProductView->radar_product_message("NST"); auto message = overlayProductView->radar_product_message("NST");
@ -431,6 +437,7 @@ std::string OverlayProductLayer::Impl::BuildHoverText(
} }
bool OverlayProductLayer::RunMousePicking( bool OverlayProductLayer::RunMousePicking(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
@ -438,7 +445,8 @@ bool OverlayProductLayer::RunMousePicking(
const common::Coordinate& mouseGeoCoords, const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) std::shared_ptr<types::EventHandler>& eventHandler)
{ {
return DrawLayer::RunMousePicking(params, return DrawLayer::RunMousePicking(mapContext,
params,
mouseLocalPos, mouseLocalPos,
mouseGlobalPos, mouseGlobalPos,
mouseCoords, mouseCoords,

17
scwx-qt/source/scwx/qt/map/overlay_product_layer.hpp
View file

@ -7,21 +7,26 @@ namespace scwx::qt::map
class OverlayProductLayer : public DrawLayer class OverlayProductLayer : public DrawLayer
{ {
Q_DISABLE_COPY_MOVE(OverlayProductLayer)
public: public:
explicit OverlayProductLayer(const std::shared_ptr<MapContext>& context); explicit OverlayProductLayer(
const std::shared_ptr<gl::GlContext>& glContext);
~OverlayProductLayer(); ~OverlayProductLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
bool RunMousePicking( bool
RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
const common::Coordinate& mouseGeoCoords, const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) override final; std::shared_ptr<types::EventHandler>& eventHandler) final;
private: private:
class Impl; class Impl;

36
scwx-qt/source/scwx/qt/map/placefile_layer.cpp
View file

@ -22,24 +22,30 @@ class PlacefileLayer::Impl
{ {
public: public:
explicit Impl(PlacefileLayer* self, explicit Impl(PlacefileLayer* self,
std::shared_ptr<gl::GlContext> context, const std::shared_ptr<gl::GlContext>& glContext,
const std::string& placefileName) : const std::string& placefileName) :
self_ {self}, self_ {self},
placefileName_ {placefileName}, placefileName_ {placefileName},
placefileIcons_ {std::make_shared<gl::draw::PlacefileIcons>(context)}, placefileIcons_ {std::make_shared<gl::draw::PlacefileIcons>(glContext)},
placefileImages_ {std::make_shared<gl::draw::PlacefileImages>(context)}, placefileImages_ {
placefileLines_ {std::make_shared<gl::draw::PlacefileLines>(context)}, std::make_shared<gl::draw::PlacefileImages>(glContext)},
placefileLines_ {std::make_shared<gl::draw::PlacefileLines>(glContext)},
placefilePolygons_ { placefilePolygons_ {
std::make_shared<gl::draw::PlacefilePolygons>(context)}, std::make_shared<gl::draw::PlacefilePolygons>(glContext)},
placefileTriangles_ { placefileTriangles_ {
std::make_shared<gl::draw::PlacefileTriangles>(context)}, std::make_shared<gl::draw::PlacefileTriangles>(glContext)},
placefileText_ { placefileText_ {
std::make_shared<gl::draw::PlacefileText>(context, placefileName)} std::make_shared<gl::draw::PlacefileText>(glContext, placefileName)}
{ {
ConnectSignals(); ConnectSignals();
} }
~Impl() { threadPool_.join(); } ~Impl() { threadPool_.join(); }
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void ConnectSignals(); void ConnectSignals();
void ReloadDataSync(); void ReloadDataSync();
@ -60,11 +66,10 @@ public:
std::chrono::system_clock::time_point selectedTime_ {}; std::chrono::system_clock::time_point selectedTime_ {};
}; };
PlacefileLayer::PlacefileLayer(const std::shared_ptr<MapContext>& context, PlacefileLayer::PlacefileLayer(const std::shared_ptr<gl::GlContext>& glContext,
const std::string& placefileName) : const std::string& placefileName) :
DrawLayer(context, fmt::format("PlacefileLayer {}", placefileName)), DrawLayer(glContext, fmt::format("PlacefileLayer {}", placefileName)),
p(std::make_unique<PlacefileLayer::Impl>( p(std::make_unique<PlacefileLayer::Impl>(this, glContext, placefileName))
this, context->gl_context(), placefileName))
{ {
AddDrawItem(p->placefileImages_); AddDrawItem(p->placefileImages_);
AddDrawItem(p->placefilePolygons_); AddDrawItem(p->placefilePolygons_);
@ -114,19 +119,20 @@ void PlacefileLayer::set_placefile_name(const std::string& placefileName)
ReloadData(); ReloadData();
} }
void PlacefileLayer::Initialize() void PlacefileLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
DrawLayer::Initialize(); DrawLayer::Initialize(mapContext);
p->selectedTime_ = manager::TimelineManager::Instance()->GetSelectedTime(); p->selectedTime_ = manager::TimelineManager::Instance()->GetSelectedTime();
} }
void PlacefileLayer::Render( void PlacefileLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
std::shared_ptr<manager::PlacefileManager> placefileManager = std::shared_ptr<manager::PlacefileManager> placefileManager =
manager::PlacefileManager::Instance(); manager::PlacefileManager::Instance();
@ -153,7 +159,7 @@ void PlacefileLayer::Render(
p->placefileText_->set_selected_time(p->selectedTime_); p->placefileText_->set_selected_time(p->selectedTime_);
} }
DrawLayer::Render(params); DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR(); SCWX_GL_CHECK_ERROR();
} }

10
scwx-qt/source/scwx/qt/map/placefile_layer.hpp
View file

@ -10,9 +10,10 @@ namespace scwx::qt::map
class PlacefileLayer : public DrawLayer class PlacefileLayer : public DrawLayer
{ {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY_MOVE(PlacefileLayer)
public: public:
explicit PlacefileLayer(const std::shared_ptr<MapContext>& context, explicit PlacefileLayer(const std::shared_ptr<gl::GlContext>& glContext,
const std::string& placefileName); const std::string& placefileName);
~PlacefileLayer(); ~PlacefileLayer();
@ -20,9 +21,10 @@ public:
void set_placefile_name(const std::string& placefileName); void set_placefile_name(const std::string& placefileName);
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
void ReloadData(); void ReloadData();

121
scwx-qt/source/scwx/qt/map/radar_product_layer.cpp
View file

@ -32,67 +32,48 @@ namespace scwx::qt::map
static const std::string logPrefix_ = "scwx::qt::map::radar_product_layer"; static const std::string logPrefix_ = "scwx::qt::map::radar_product_layer";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class RadarProductLayerImpl class RadarProductLayer::Impl
{ {
public: public:
explicit RadarProductLayerImpl() : explicit Impl() = default;
shaderProgram_(nullptr), ~Impl() = default;
uMVPMatrixLocation_(GL_INVALID_INDEX),
uMapScreenCoordLocation_(GL_INVALID_INDEX),
uDataMomentOffsetLocation_(GL_INVALID_INDEX),
uDataMomentScaleLocation_(GL_INVALID_INDEX),
uCFPEnabledLocation_(GL_INVALID_INDEX),
vbo_ {GL_INVALID_INDEX},
vao_ {GL_INVALID_INDEX},
texture_ {GL_INVALID_INDEX},
numVertices_ {0},
cfpEnabled_ {false},
colorTableNeedsUpdate_ {false},
sweepNeedsUpdate_ {false}
{
}
~RadarProductLayerImpl() = default;
std::shared_ptr<gl::ShaderProgram> shaderProgram_; Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
GLint uMVPMatrixLocation_; std::shared_ptr<gl::ShaderProgram> shaderProgram_ {nullptr};
GLint uMapScreenCoordLocation_;
GLint uDataMomentOffsetLocation_;
GLint uDataMomentScaleLocation_;
GLint uCFPEnabledLocation_;
std::array<GLuint, 3> vbo_;
GLuint vao_;
GLuint texture_;
GLsizeiptr numVertices_; GLint uMVPMatrixLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
GLint uMapScreenCoordLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
GLint uDataMomentOffsetLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
GLint uDataMomentScaleLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
GLint uCFPEnabledLocation_ {static_cast<GLint>(GL_INVALID_INDEX)};
std::array<GLuint, 3> vbo_ {GL_INVALID_INDEX};
GLuint vao_ {GL_INVALID_INDEX};
GLuint texture_ {GL_INVALID_INDEX};
bool cfpEnabled_; GLsizeiptr numVertices_ {0};
bool colorTableNeedsUpdate_; bool cfpEnabled_ {false};
bool sweepNeedsUpdate_;
bool colorTableNeedsUpdate_ {false};
bool sweepNeedsUpdate_ {false};
}; };
RadarProductLayer::RadarProductLayer( RadarProductLayer::RadarProductLayer(std::shared_ptr<gl::GlContext> glContext) :
const std::shared_ptr<MapContext>& context) : GenericLayer(std::move(glContext)), p(std::make_unique<Impl>())
GenericLayer(context), p(std::make_unique<RadarProductLayerImpl>())
{ {
auto radarProductView = context->radar_product_view();
connect(radarProductView.get(),
&view::RadarProductView::ColorTableLutUpdated,
this,
[this]() { p->colorTableNeedsUpdate_ = true; });
connect(radarProductView.get(),
&view::RadarProductView::SweepComputed,
this,
[this]() { p->sweepNeedsUpdate_ = true; });
} }
RadarProductLayer::~RadarProductLayer() = default; RadarProductLayer::~RadarProductLayer() = default;
void RadarProductLayer::Initialize() void RadarProductLayer::Initialize(
const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
auto glContext = context()->gl_context(); auto glContext = gl_context();
gl::OpenGLFunctions& gl = glContext->gl(); gl::OpenGLFunctions& gl = glContext->gl();
@ -145,25 +126,36 @@ void RadarProductLayer::Initialize()
// Update radar sweep // Update radar sweep
p->sweepNeedsUpdate_ = true; p->sweepNeedsUpdate_ = true;
UpdateSweep(); UpdateSweep(mapContext);
// Create color table // Create color table
gl.glGenTextures(1, &p->texture_); gl.glGenTextures(1, &p->texture_);
p->colorTableNeedsUpdate_ = true; p->colorTableNeedsUpdate_ = true;
UpdateColorTable(); UpdateColorTable(mapContext);
gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); gl.glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
auto radarProductView = mapContext->radar_product_view();
connect(radarProductView.get(),
&view::RadarProductView::ColorTableLutUpdated,
this,
[this]() { p->colorTableNeedsUpdate_ = true; });
connect(radarProductView.get(),
&view::RadarProductView::SweepComputed,
this,
[this]() { p->sweepNeedsUpdate_ = true; });
} }
void RadarProductLayer::UpdateSweep() void RadarProductLayer::UpdateSweep(
const std::shared_ptr<MapContext>& mapContext)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
boost::timer::cpu_timer timer; boost::timer::cpu_timer timer;
std::shared_ptr<view::RadarProductView> radarProductView = std::shared_ptr<view::RadarProductView> radarProductView =
context()->radar_product_view(); mapContext->radar_product_view();
std::unique_lock sweepLock(radarProductView->sweep_mutex(), std::unique_lock sweepLock(radarProductView->sweep_mutex(),
std::try_to_lock); std::try_to_lock);
@ -258,16 +250,17 @@ void RadarProductLayer::UpdateSweep()
} }
void RadarProductLayer::Render( void RadarProductLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
p->shaderProgram_->Use(); p->shaderProgram_->Use();
// Set OpenGL blend mode for transparency // Set OpenGL blend mode for transparency
gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
const bool wireframeEnabled = context()->settings().radarWireframeEnabled_; const bool wireframeEnabled = mapContext->settings().radarWireframeEnabled_;
if (wireframeEnabled) if (wireframeEnabled)
{ {
// Set polygon mode to draw wireframe // Set polygon mode to draw wireframe
@ -276,12 +269,12 @@ void RadarProductLayer::Render(
if (p->colorTableNeedsUpdate_) if (p->colorTableNeedsUpdate_)
{ {
UpdateColorTable(); UpdateColorTable(mapContext);
} }
if (p->sweepNeedsUpdate_) if (p->sweepNeedsUpdate_)
{ {
UpdateSweep(); UpdateSweep(mapContext);
} }
const float scale = std::pow(2.0, params.zoom) * 2.0f * const float scale = std::pow(2.0, params.zoom) * 2.0f *
@ -323,7 +316,7 @@ void RadarProductLayer::Deinitialize()
{ {
logger_->debug("Deinitialize()"); logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_); gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(3, p->vbo_.data()); gl.glDeleteBuffers(3, p->vbo_.data());
@ -339,6 +332,7 @@ void RadarProductLayer::Deinitialize()
} }
bool RadarProductLayer::RunMousePicking( bool RadarProductLayer::RunMousePicking(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& /* params */, const QMapLibre::CustomLayerRenderParameters& /* params */,
const QPointF& /* mouseLocalPos */, const QPointF& /* mouseLocalPos */,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
@ -352,16 +346,16 @@ bool RadarProductLayer::RunMousePicking(
Qt::KeyboardModifier::ShiftModifier) Qt::KeyboardModifier::ShiftModifier)
{ {
std::shared_ptr<view::RadarProductView> radarProductView = std::shared_ptr<view::RadarProductView> radarProductView =
context()->radar_product_view(); mapContext->radar_product_view();
if (context()->radar_site() == nullptr) if (mapContext->radar_site() == nullptr)
{ {
return itemPicked; return itemPicked;
} }
// Get distance and altitude of point // Get distance and altitude of point
const double radarLatitude = context()->radar_site()->latitude(); const double radarLatitude = mapContext->radar_site()->latitude();
const double radarLongitude = context()->radar_site()->longitude(); const double radarLongitude = mapContext->radar_site()->longitude();
const auto distanceMeters = const auto distanceMeters =
util::GeographicLib::GetDistance(mouseGeoCoords.latitude_, util::GeographicLib::GetDistance(mouseGeoCoords.latitude_,
@ -396,7 +390,7 @@ bool RadarProductLayer::RunMousePicking(
util::GeographicLib::GetRadarBeamAltititude( util::GeographicLib::GetRadarBeamAltititude(
distanceMeters, distanceMeters,
units::angle::degrees<double>(*elevation), units::angle::degrees<double>(*elevation),
context()->radar_site()->altitude()); mapContext->radar_site()->altitude());
const std::string heightUnitName = const std::string heightUnitName =
settings::UnitSettings::Instance().echo_tops_units().GetValue(); settings::UnitSettings::Instance().echo_tops_units().GetValue();
@ -529,15 +523,16 @@ bool RadarProductLayer::RunMousePicking(
return itemPicked; return itemPicked;
} }
void RadarProductLayer::UpdateColorTable() void RadarProductLayer::UpdateColorTable(
const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("UpdateColorTable()"); logger_->debug("UpdateColorTable()");
p->colorTableNeedsUpdate_ = false; p->colorTableNeedsUpdate_ = false;
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
std::shared_ptr<view::RadarProductView> radarProductView = std::shared_ptr<view::RadarProductView> radarProductView =
context()->radar_product_view(); mapContext->radar_product_view();
const std::vector<boost::gil::rgba8_pixel_t>& colorTable = const std::vector<boost::gil::rgba8_pixel_t>& colorTable =
radarProductView->color_table_lut(); radarProductView->color_table_lut();

25
scwx-qt/source/scwx/qt/map/radar_product_layer.hpp
View file

@ -5,20 +5,22 @@
namespace scwx::qt::map namespace scwx::qt::map
{ {
class RadarProductLayerImpl;
class RadarProductLayer : public GenericLayer class RadarProductLayer : public GenericLayer
{ {
Q_DISABLE_COPY_MOVE(RadarProductLayer)
public: public:
explicit RadarProductLayer(const std::shared_ptr<MapContext>& context); explicit RadarProductLayer(std::shared_ptr<gl::GlContext> glContext);
~RadarProductLayer(); ~RadarProductLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
virtual bool bool
RunMousePicking(const QMapLibre::CustomLayerRenderParameters& params, RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
@ -26,11 +28,12 @@ public:
std::shared_ptr<types::EventHandler>& eventHandler) override; std::shared_ptr<types::EventHandler>& eventHandler) override;
private: private:
void UpdateColorTable(); void UpdateColorTable(const std::shared_ptr<MapContext>& mapContext);
void UpdateSweep(); void UpdateSweep(const std::shared_ptr<MapContext>& mapContext);
private: private:
std::unique_ptr<RadarProductLayerImpl> p; class Impl;
std::unique_ptr<Impl> p;
}; };
} // namespace scwx::qt::map } // namespace scwx::qt::map

42
scwx-qt/source/scwx/qt/map/radar_site_layer.cpp
View file

@ -22,15 +22,21 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class RadarSiteLayer::Impl class RadarSiteLayer::Impl
{ {
public: public:
explicit Impl(RadarSiteLayer* self, std::shared_ptr<gl::GlContext> context) : explicit Impl(RadarSiteLayer* self,
self_ {self}, geoLines_ {std::make_shared<gl::draw::GeoLines>(context)} const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self}, geoLines_ {std::make_shared<gl::draw::GeoLines>(glContext)}
{ {
} }
~Impl() = default; ~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void RenderRadarSite(const QMapLibre::CustomLayerRenderParameters& params, void RenderRadarSite(const QMapLibre::CustomLayerRenderParameters& params,
std::shared_ptr<config::RadarSite>& radarSite); std::shared_ptr<config::RadarSite>& radarSite);
void RenderRadarLine(); void RenderRadarLine(const std::shared_ptr<MapContext>& mapContext);
RadarSiteLayer* self_; RadarSiteLayer* self_;
@ -50,15 +56,16 @@ public:
nullptr, nullptr}; nullptr, nullptr};
}; };
RadarSiteLayer::RadarSiteLayer(const std::shared_ptr<MapContext>& context) : RadarSiteLayer::RadarSiteLayer(
DrawLayer(context, "RadarSiteLayer"), const std::shared_ptr<gl::GlContext>& glContext) :
p(std::make_unique<Impl>(this, context->gl_context())) DrawLayer(glContext, "RadarSiteLayer"),
p(std::make_unique<Impl>(this, glContext))
{ {
} }
RadarSiteLayer::~RadarSiteLayer() = default; RadarSiteLayer::~RadarSiteLayer() = default;
void RadarSiteLayer::Initialize() void RadarSiteLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{ {
logger_->debug("Initialize()"); logger_->debug("Initialize()");
@ -81,10 +88,11 @@ void RadarSiteLayer::Initialize()
AddDrawItem(p->geoLines_); AddDrawItem(p->geoLines_);
p->geoLines_->set_thresholded(false); p->geoLines_->set_thresholded(false);
DrawLayer::Initialize(); DrawLayer::Initialize(mapContext);
} }
void RadarSiteLayer::Render( void RadarSiteLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params) const QMapLibre::CustomLayerRenderParameters& params)
{ {
p->hoverText_.clear(); p->hoverText_.clear();
@ -99,7 +107,7 @@ void RadarSiteLayer::Render(
return; return;
} }
gl::OpenGLFunctions& gl = context()->gl_context()->gl(); gl::OpenGLFunctions& gl = gl_context()->gl();
// Update map screen coordinate and scale information // Update map screen coordinate and scale information
p->mapScreenCoordLocation_ = util::maplibre::LatLongToScreenCoordinate( p->mapScreenCoordLocation_ = util::maplibre::LatLongToScreenCoordinate(
@ -111,7 +119,7 @@ void RadarSiteLayer::Render(
p->halfWidth_ = params.width * 0.5f; p->halfWidth_ = params.width * 0.5f;
p->halfHeight_ = params.height * 0.5f; p->halfHeight_ = params.height * 0.5f;
ImGuiFrameStart(); ImGuiFrameStart(mapContext);
// Radar site ImGui windows shouldn't have padding // Radar site ImGui windows shouldn't have padding
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2 {0.0f, 0.0f}); ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2 {0.0f, 0.0f});
@ -122,7 +130,7 @@ void RadarSiteLayer::Render(
ImGui::PopStyleVar(); ImGui::PopStyleVar();
p->RenderRadarLine(); p->RenderRadarLine(mapContext);
DrawLayer::RenderWithoutImGui(params); DrawLayer::RenderWithoutImGui(params);
@ -192,15 +200,16 @@ void RadarSiteLayer::Impl::RenderRadarSite(
} }
} }
void RadarSiteLayer::Impl::RenderRadarLine() void RadarSiteLayer::Impl::RenderRadarLine(
const std::shared_ptr<MapContext>& mapContext)
{ {
if ((QGuiApplication::keyboardModifiers() & if ((QGuiApplication::keyboardModifiers() &
Qt::KeyboardModifier::ShiftModifier) && Qt::KeyboardModifier::ShiftModifier) &&
self_->context()->radar_site() != nullptr) mapContext->radar_site() != nullptr)
{ {
const auto& mouseCoord = self_->context()->mouse_coordinate(); const auto& mouseCoord = mapContext->mouse_coordinate();
const double radarLatitude = self_->context()->radar_site()->latitude(); const double radarLatitude = mapContext->radar_site()->latitude();
const double radarLongitude = self_->context()->radar_site()->longitude(); const double radarLongitude = mapContext->radar_site()->longitude();
geoLines_->SetLineLocation(radarSiteLines_[0], geoLines_->SetLineLocation(radarSiteLines_[0],
static_cast<float>(mouseCoord.latitude_), static_cast<float>(mouseCoord.latitude_),
@ -231,6 +240,7 @@ void RadarSiteLayer::Deinitialize()
} }
bool RadarSiteLayer::RunMousePicking( bool RadarSiteLayer::RunMousePicking(
const std::shared_ptr<MapContext>& /* mapContext */,
const QMapLibre::CustomLayerRenderParameters& /* params */, const QMapLibre::CustomLayerRenderParameters& /* params */,
const QPointF& /* mouseLocalPos */, const QPointF& /* mouseLocalPos */,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,

14
scwx-qt/source/scwx/qt/map/radar_site_layer.hpp
View file

@ -11,20 +11,22 @@ class RadarSiteLayer : public DrawLayer
Q_DISABLE_COPY_MOVE(RadarSiteLayer) Q_DISABLE_COPY_MOVE(RadarSiteLayer)
public: public:
explicit RadarSiteLayer(const std::shared_ptr<MapContext>& context); explicit RadarSiteLayer(const std::shared_ptr<gl::GlContext>& glContext);
~RadarSiteLayer(); ~RadarSiteLayer();
void Initialize() override final; void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final; void Render(const std::shared_ptr<MapContext>& mapContext,
void Deinitialize() override final; const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
bool RunMousePicking( bool
RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params, const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos, const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos, const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords, const glm::vec2& mouseCoords,
const common::Coordinate& mouseGeoCoords, const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) override final; std::shared_ptr<types::EventHandler>& eventHandler) final;
signals: signals:
void RadarSiteSelected(const std::string& id); void RadarSiteSelected(const std::string& id);