blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-31 04:30:05 +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

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

@ -135,14 +135,14 @@ public:
std::size_t lineWidth_ {};
};
explicit Impl(AlertLayer* self,
std::shared_ptr<gl::GlContext> context,
awips::Phenomenon phenomenon) :
explicit Impl(AlertLayer* self,
const std::shared_ptr<gl::GlContext>& glContext,
awips::Phenomenon phenomenon) :
self_ {self},
phenomenon_ {phenomenon},
ibw_ {awips::ibw::GetImpactBasedWarningInfo(phenomenon)},
geoLines_ {{false, std::make_shared<gl::draw::GeoLines>(context)},
{true, std::make_shared<gl::draw::GeoLines>(context)}}
geoLines_ {{false, std::make_shared<gl::draw::GeoLines>(glContext)},
{true, std::make_shared<gl::draw::GeoLines>(glContext)}}
{
UpdateLineData();
ConnectSignals();
@ -245,12 +245,12 @@ public:
std::vector<boost::signals2::scoped_connection> connections_ {};
};
AlertLayer::AlertLayer(const std::shared_ptr<MapContext>& context,
awips::Phenomenon phenomenon) :
AlertLayer::AlertLayer(const std::shared_ptr<gl::GlContext>& glContext,
awips::Phenomenon phenomenon) :
DrawLayer(
context,
glContext,
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})
{
@ -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_));
DrawLayer::Initialize();
DrawLayer::Initialize(mapContext);
auto& alertLayerHandler = AlertLayerHandler::Instance();
@ -296,16 +296,17 @@ void AlertLayer::Initialize()
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})
{
p->geoLines_.at(alertActive)->set_selected_time(p->selectedTime_);
}
DrawLayer::Render(params);
DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR();
}

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

@ -16,13 +16,14 @@ class AlertLayer : public DrawLayer
Q_DISABLE_COPY_MOVE(AlertLayer)
public:
explicit AlertLayer(const std::shared_ptr<MapContext>& context,
scwx::awips::Phenomenon phenomenon);
explicit AlertLayer(const std::shared_ptr<gl::GlContext>& glContext,
scwx::awips::Phenomenon phenomenon);
~AlertLayer();
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
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 auto logger_ = scwx::util::Logger::Create(logPrefix_);
class ColorTableLayerImpl
class ColorTableLayer::Impl
{
public:
explicit ColorTableLayerImpl() :
shaderProgram_(nullptr),
uMVPMatrixLocation_(GL_INVALID_INDEX),
vbo_ {GL_INVALID_INDEX},
vao_ {GL_INVALID_INDEX},
texture_ {GL_INVALID_INDEX},
colorTable_ {},
colorTableNeedsUpdate_ {true}
{
}
~ColorTableLayerImpl() = default;
explicit Impl() = default;
~Impl() = 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::array<GLuint, 2> vbo_;
GLuint vao_;
GLuint texture_;
std::shared_ptr<gl::ShaderProgram> shaderProgram_ {nullptr};
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) :
GenericLayer(context), p(std::make_unique<ColorTableLayerImpl>())
ColorTableLayer::ColorTableLayer(std::shared_ptr<gl::GlContext> glContext) :
GenericLayer(std::move(glContext)), p(std::make_unique<Impl>())
{
}
ColorTableLayer::~ColorTableLayer() = default;
void ColorTableLayer::Initialize()
void ColorTableLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
auto glContext = context()->gl_context();
auto glContext = gl_context();
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.glEnableVertexAttribArray(1);
connect(context()->radar_product_view().get(),
connect(mapContext->radar_product_view().get(),
&view::RadarProductView::ColorTableLutUpdated,
this,
[this]() { p->colorTableNeedsUpdate_ = true; });
}
void ColorTableLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
auto radarProductView = context()->radar_product_view();
gl::OpenGLFunctions& gl = gl_context()->gl();
auto radarProductView = mapContext->radar_product_view();
if (context()->radar_product_view() == nullptr ||
!context()->radar_product_view()->IsInitialized())
if (radarProductView == nullptr || !radarProductView->IsInitialized())
{
// Defer rendering until view is initialized
return;
@ -180,11 +176,11 @@ void ColorTableLayer::Render(
gl.glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
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
{
context()->set_color_table_margins(QMargins {});
mapContext->set_color_table_margins(QMargins {});
}
SCWX_GL_CHECK_ERROR();
@ -194,7 +190,7 @@ void ColorTableLayer::Deinitialize()
{
logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(2, p->vbo_.data());
@ -204,8 +200,6 @@ void ColorTableLayer::Deinitialize()
p->vao_ = GL_INVALID_INDEX;
p->vbo_ = {GL_INVALID_INDEX};
p->texture_ = GL_INVALID_INDEX;
context()->set_color_table_margins(QMargins {});
}
} // 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
{
class ColorTableLayerImpl;
class ColorTableLayer : public GenericLayer
{
Q_DISABLE_COPY_MOVE(ColorTableLayer)
public:
explicit ColorTableLayer(const std::shared_ptr<MapContext>& context);
explicit ColorTableLayer(std::shared_ptr<gl::GlContext> glContext);
~ColorTableLayer();
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
private:
std::unique_ptr<ColorTableLayerImpl> p;
class Impl;
std::unique_ptr<Impl> p;
};
} // namespace scwx::qt::map

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

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

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

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

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

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

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

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

@ -3,21 +3,29 @@
namespace scwx::qt::map
{
class LayerWrapperImpl
class LayerWrapper::Impl
{
public:
explicit LayerWrapperImpl(std::shared_ptr<GenericLayer> layer) :
layer_ {std::move(layer)}
explicit Impl(std::shared_ptr<GenericLayer> 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<MapContext> mapContext_;
};
LayerWrapper::LayerWrapper(const std::shared_ptr<GenericLayer>& layer) :
p(std::make_unique<LayerWrapperImpl>(layer))
LayerWrapper::LayerWrapper(std::shared_ptr<GenericLayer> layer,
std::shared_ptr<MapContext> mapContext) :
p(std::make_unique<Impl>(std::move(layer), std::move(mapContext)))
{
}
LayerWrapper::~LayerWrapper() = default;
@ -30,7 +38,7 @@ void LayerWrapper::initialize()
auto& layer = p->layer_;
if (layer != nullptr)
{
layer->Initialize();
layer->Initialize(p->mapContext_);
}
}
@ -39,7 +47,7 @@ void LayerWrapper::render(const QMapLibre::CustomLayerRenderParameters& params)
auto& layer = p->layer_;
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
#include <scwx/qt/map/generic_layer.hpp>
#include <scwx/qt/map/map_context.hpp>
namespace scwx::qt::map
{
class LayerWrapperImpl;
class LayerWrapper : public QMapLibre::CustomLayerHostInterface
{
public:
explicit LayerWrapper(const std::shared_ptr<GenericLayer>& layer);
explicit LayerWrapper(std::shared_ptr<GenericLayer> layer,
std::shared_ptr<MapContext> mapContext);
~LayerWrapper();
LayerWrapper(const LayerWrapper&) = delete;
@ -19,12 +19,13 @@ public:
LayerWrapper(LayerWrapper&&) noexcept;
LayerWrapper& operator=(LayerWrapper&&) noexcept;
void initialize() override final;
void render(const QMapLibre::CustomLayerRenderParameters&) override final;
void deinitialize() override final;
void initialize() final;
void render(const QMapLibre::CustomLayerRenderParameters&) final;
void deinitialize() final;
private:
std::unique_ptr<LayerWrapperImpl> p;
class Impl;
std::unique_ptr<Impl> p;
};
} // namespace scwx::qt::map

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

@ -16,9 +16,6 @@ public:
~Impl() {}
std::shared_ptr<gl::GlContext> glContext_ {
std::make_shared<gl::GlContext>()};
std::weak_ptr<QMapLibre::Map> map_ {};
MapSettings settings_ {};
float pixelRatio_ {1.0f};
@ -50,11 +47,6 @@ MapContext::~MapContext() = default;
MapContext::MapContext(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
{
return p->map_;

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

@ -1,6 +1,5 @@
#pragma once
#include <scwx/qt/gl/gl_context.hpp>
#include <scwx/qt/map/map_provider.hpp>
#include <scwx/common/geographic.hpp>
#include <scwx/common/products.hpp>
@ -35,8 +34,6 @@ public:
MapContext(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::string map_copyrights() const;
[[nodiscard]] MapProvider map_provider() const;

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

@ -73,7 +73,6 @@ public:
const QMapLibre::Settings& settings) :
id_ {id},
uuid_ {boost::uuids::random_generator()()},
context_ {std::make_shared<MapContext>()},
widget_ {widget},
settings_(settings),
map_(),
@ -154,9 +153,9 @@ public:
void AddLayer(types::LayerType type,
types::LayerDescription description,
const std::string& before = {});
void AddLayer(const std::string& id,
std::shared_ptr<GenericLayer> layer,
const std::string& before = {});
void AddLayer(const std::string& id,
const std::shared_ptr<GenericLayer>& layer,
const std::string& before = {});
void AddLayers();
void AddPlacefileLayer(const std::string& placefileName,
const std::string& before);
@ -194,7 +193,9 @@ public:
std::size_t id_;
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_;
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 (radarProductView != nullptr)
{
radarProductLayer_ = std::make_shared<RadarProductLayer>(context_);
radarProductLayer_ = std::make_shared<RadarProductLayer>(glContext_);
AddLayer(layerName, radarProductLayer_, before);
}
}
@ -1248,7 +1249,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
auto phenomenon = std::get<awips::Phenomenon>(description);
std::shared_ptr<AlertLayer> alertLayer =
std::make_shared<AlertLayer>(context_, phenomenon);
std::make_shared<AlertLayer>(glContext_, phenomenon);
AddLayer(fmt::format("alert.{}", awips::GetPhenomenonCode(phenomenon)),
alertLayer,
before);
@ -1272,7 +1273,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
{
// Create the map overlay layer
case types::InformationLayer::MapOverlay:
overlayLayer_ = std::make_shared<OverlayLayer>(context_);
overlayLayer_ = std::make_shared<OverlayLayer>(glContext_);
AddLayer(layerName, overlayLayer_, before);
break;
@ -1280,14 +1281,14 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
case types::InformationLayer::ColorTable:
if (radarProductView != nullptr)
{
colorTableLayer_ = std::make_shared<ColorTableLayer>(context_);
colorTableLayer_ = std::make_shared<ColorTableLayer>(glContext_);
AddLayer(layerName, colorTableLayer_, before);
}
break;
// Create the radar site layer
case types::InformationLayer::RadarSite:
radarSiteLayer_ = std::make_shared<RadarSiteLayer>(context_);
radarSiteLayer_ = std::make_shared<RadarSiteLayer>(glContext_);
AddLayer(layerName, radarSiteLayer_, before);
connect(
radarSiteLayer_.get(),
@ -1303,7 +1304,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
// Create the location marker layer
case types::InformationLayer::Markers:
markerLayer_ = std::make_shared<MarkerLayer>(context_);
markerLayer_ = std::make_shared<MarkerLayer>(glContext_);
AddLayer(layerName, markerLayer_, before);
break;
@ -1320,7 +1321,7 @@ void MapWidgetImpl::AddLayer(types::LayerType type,
if (radarProductView != nullptr)
{
overlayProductLayer_ =
std::make_shared<OverlayProductLayer>(context_);
std::make_shared<OverlayProductLayer>(glContext_);
AddLayer(layerName, overlayProductLayer_, before);
}
break;
@ -1350,7 +1351,7 @@ void MapWidgetImpl::AddPlacefileLayer(const std::string& placefileName,
const std::string& before)
{
std::shared_ptr<PlacefileLayer> placefileLayer =
std::make_shared<PlacefileLayer>(context_, placefileName);
std::make_shared<PlacefileLayer>(glContext_, placefileName);
placefileLayers_.push_back(placefileLayer);
AddLayer(GetPlacefileLayerName(placefileName), placefileLayer, before);
@ -1367,13 +1368,13 @@ MapWidgetImpl::GetPlacefileLayerName(const std::string& placefileName)
return types::GetLayerName(types::LayerType::Placefile, placefileName);
}
void MapWidgetImpl::AddLayer(const std::string& id,
std::shared_ptr<GenericLayer> layer,
const std::string& before)
void MapWidgetImpl::AddLayer(const std::string& id,
const std::shared_ptr<GenericLayer>& layer,
const std::string& before)
{
// QMapLibre::addCustomLayer will take ownership of the std::unique_ptr
std::unique_ptr<QMapLibre::CustomLayerHostInterface> pHost =
std::make_unique<LayerWrapper>(layer);
std::make_unique<LayerWrapper>(layer, context_);
try
{
@ -1542,7 +1543,7 @@ void MapWidget::initializeGL()
makeCurrent();
p->context_->gl_context()->Initialize();
p->glContext_->Initialize();
// Lock ImGui font atlas prior to new ImGui frame
std::shared_lock imguiFontAtlasLock {
@ -1596,7 +1597,7 @@ void MapWidget::paintGL()
p->frameDraws_++;
p->context_->gl_context()->StartFrame();
p->glContext_->StartFrame();
// Handle hotkey updates
p->HandleHotkeyUpdates();
@ -1705,7 +1706,8 @@ void MapWidgetImpl::RunMousePicking()
for (auto it = genericLayers_.rbegin(); it != genericLayers_.rend(); ++it)
{
// Run mouse picking for each layer
if ((*it)->RunMousePicking(params,
if ((*it)->RunMousePicking(context_,
params,
lastPos_,
lastGlobalPos_,
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/ui/edit_marker_dialog.hpp>
#include <string>
#include <QGeoPositionInfo>
#include <QMouseEvent>
#include <string>
namespace scwx::qt::map
{
@ -19,15 +19,21 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class MarkerLayer::Impl
{
public:
explicit Impl(MarkerLayer* self, std::shared_ptr<gl::GlContext> context) :
explicit Impl(MarkerLayer* self,
const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(context)},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(glContext)},
editMarkerDialog_ {std::make_shared<ui::EditMarkerDialog>()}
{
ConnectSignals();
}
~Impl() = default;
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void ReloadMarkers();
void ConnectSignals();
@ -124,19 +130,19 @@ void MarkerLayer::Impl::ReloadMarkers()
Q_EMIT self_->NeedsRendering();
}
MarkerLayer::MarkerLayer(const std::shared_ptr<MapContext>& context) :
DrawLayer(context, "MarkerLayer"),
p(std::make_unique<MarkerLayer::Impl>(this, context->gl_context()))
MarkerLayer::MarkerLayer(const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(glContext, "MarkerLayer"),
p(std::make_unique<MarkerLayer::Impl>(this, glContext))
{
AddDrawItem(p->geoIcons_);
}
MarkerLayer::~MarkerLayer() = default;
void MarkerLayer::Initialize()
void MarkerLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
DrawLayer::Initialize();
DrawLayer::Initialize(mapContext);
p->set_icon_sheets();
p->ReloadMarkers();
@ -156,11 +162,12 @@ void MarkerLayer::Impl::set_icon_sheets()
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();
}

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

@ -8,14 +8,16 @@ namespace scwx::qt::map
class MarkerLayer : public DrawLayer
{
Q_OBJECT
Q_DISABLE_COPY_MOVE(MarkerLayer)
public:
explicit MarkerLayer(const std::shared_ptr<MapContext>& context);
explicit MarkerLayer(const std::shared_ptr<gl::GlContext>& context);
~MarkerLayer();
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
private:
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 auto logger_ = scwx::util::Logger::Create(logPrefix_);
class OverlayLayerImpl
class OverlayLayer::Impl
{
public:
explicit OverlayLayerImpl(OverlayLayer* self,
std::shared_ptr<gl::GlContext> context) :
explicit Impl(OverlayLayer* self,
const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self},
activeBoxOuter_ {std::make_shared<gl::draw::Rectangle>(context)},
activeBoxInner_ {std::make_shared<gl::draw::Rectangle>(context)},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(context)},
icons_ {std::make_shared<gl::draw::Icons>(context)},
activeBoxOuter_ {std::make_shared<gl::draw::Rectangle>(glContext)},
activeBoxInner_ {std::make_shared<gl::draw::Rectangle>(glContext)},
geoIcons_ {std::make_shared<gl::draw::GeoIcons>(glContext)},
icons_ {std::make_shared<gl::draw::Icons>(glContext)},
renderMutex_ {}
{
auto& generalSettings = settings::GeneralSettings::Instance();
@ -71,7 +71,7 @@ public:
[this](const bool&) { Q_EMIT self_->NeedsRendering(); });
}
~OverlayLayerImpl()
~Impl()
{
auto& generalSettings = settings::GeneralSettings::Instance();
@ -87,6 +87,11 @@ public:
showMapLogoCallbackUuid_);
}
Impl(const Impl&) = delete;
Impl& operator=(const Impl&) = delete;
Impl(const Impl&&) = delete;
Impl& operator=(const Impl&&) = delete;
void SetupGeoIcons();
void SetCusorLocation(common::Coordinate coordinate);
@ -151,9 +156,9 @@ public:
bool sweepTimePicked_ {false};
};
OverlayLayer::OverlayLayer(const std::shared_ptr<MapContext>& context) :
DrawLayer(context, "OverlayLayer"),
p(std::make_unique<OverlayLayerImpl>(this, context->gl_context()))
OverlayLayer::OverlayLayer(const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(glContext, "OverlayLayer"),
p(std::make_unique<Impl>(this, glContext))
{
AddDrawItem(p->activeBoxOuter_);
AddDrawItem(p->activeBoxInner_);
@ -168,13 +173,13 @@ OverlayLayer::~OverlayLayer()
p->cursorScaleConnection_.disconnect();
}
void OverlayLayerImpl::SetCusorLocation(common::Coordinate coordinate)
void OverlayLayer::Impl::SetCusorLocation(common::Coordinate coordinate)
{
geoIcons_->SetIconLocation(
cursorIcon_, coordinate.latitude_, coordinate.longitude_);
}
void OverlayLayerImpl::SetupGeoIcons()
void OverlayLayer::Impl::SetupGeoIcons()
{
const std::unique_lock lock {renderMutex_};
@ -208,13 +213,13 @@ void OverlayLayerImpl::SetupGeoIcons()
geoIcons_->FinishIcons();
}
void OverlayLayer::Initialize()
void OverlayLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
DrawLayer::Initialize();
DrawLayer::Initialize(mapContext);
auto radarProductView = context()->radar_product_view();
auto radarProductView = mapContext->radar_product_view();
if (radarProductView != nullptr)
{
@ -251,7 +256,7 @@ void OverlayLayer::Initialize()
p->icons_->SetIconTexture(p->compassIcon_, p->cardinalPointIconName_, 0);
gl::draw::Icons::RegisterEventHandler(
p->compassIcon_,
[this](QEvent* ev)
[this, mapContext](QEvent* ev)
{
switch (ev->type())
{
@ -276,7 +281,7 @@ void OverlayLayer::Initialize()
if (mouseEvent->buttons() == Qt::MouseButton::LeftButton &&
p->lastBearing_ != 0.0)
{
auto map = context()->map().lock();
auto map = mapContext->map().lock();
if (map != nullptr)
{
map->setBearing(0.0);
@ -295,11 +300,11 @@ void OverlayLayer::Initialize()
p->icons_->SetIconTexture(p->mapCenterIcon_, p->mapCenterIconName_, 0);
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);
}
else if (context()->map_provider() == MapProvider::MapTiler)
else if (mapContext->map_provider() == MapProvider::MapTiler)
{
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_};
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
auto radarProductView = context()->radar_product_view();
auto& settings = context()->settings();
const float pixelRatio = context()->pixel_ratio();
gl::OpenGLFunctions& gl = gl_context()->gl();
auto radarProductView = mapContext->radar_product_view();
auto& settings = mapContext->settings();
const float pixelRatio = mapContext->pixel_ratio();
ImGuiFrameStart();
ImGuiFrameStart(mapContext);
p->sweepTimePicked_ = false;
@ -383,7 +389,7 @@ void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params)
p->geoIcons_->SetIconVisible(p->cursorIcon_, cursorIconVisible);
if (cursorIconVisible)
{
p->SetCusorLocation(context()->mouse_coordinate());
p->SetCusorLocation(mapContext->mouse_coordinate());
}
// Location Icon
@ -507,7 +513,7 @@ void OverlayLayer::Render(const QMapLibre::CustomLayerRenderParameters& params)
p->icons_->SetIconVisible(p->mapCenterIcon_,
generalSettings.show_map_center().GetValue());
QMargins colorTableMargins = context()->color_table_margins();
QMargins colorTableMargins = mapContext->color_table_margins();
if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_)
{
// 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);
auto mapCopyrights = context()->map_copyrights();
auto mapCopyrights = mapContext->map_copyrights();
if (mapCopyrights.length() > 0 &&
generalSettings.show_map_attribution().GetValue())
{
@ -563,29 +569,13 @@ void OverlayLayer::Deinitialize()
DrawLayer::Deinitialize();
auto radarProductView = context()->radar_product_view();
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);
disconnect(this);
p->locationIcon_ = nullptr;
}
bool OverlayLayer::RunMousePicking(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos,
@ -599,7 +589,8 @@ bool OverlayLayer::RunMousePicking(
return true;
}
return DrawLayer::RunMousePicking(params,
return DrawLayer::RunMousePicking(mapContext,
params,
mouseLocalPos,
mouseGlobalPos,
mouseCoords,

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

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

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

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

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

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

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

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

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

@ -10,19 +10,21 @@ namespace scwx::qt::map
class PlacefileLayer : public DrawLayer
{
Q_OBJECT
Q_DISABLE_COPY_MOVE(PlacefileLayer)
public:
explicit PlacefileLayer(const std::shared_ptr<MapContext>& context,
const std::string& placefileName);
explicit PlacefileLayer(const std::shared_ptr<gl::GlContext>& glContext,
const std::string& placefileName);
~PlacefileLayer();
std::string placefile_name() const;
void set_placefile_name(const std::string& placefileName);
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
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 auto logger_ = scwx::util::Logger::Create(logPrefix_);
class RadarProductLayerImpl
class RadarProductLayer::Impl
{
public:
explicit RadarProductLayerImpl() :
shaderProgram_(nullptr),
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;
explicit Impl() = default;
~Impl() = 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_;
GLint uMapScreenCoordLocation_;
GLint uDataMomentOffsetLocation_;
GLint uDataMomentScaleLocation_;
GLint uCFPEnabledLocation_;
std::array<GLuint, 3> vbo_;
GLuint vao_;
GLuint texture_;
std::shared_ptr<gl::ShaderProgram> shaderProgram_ {nullptr};
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 sweepNeedsUpdate_;
bool cfpEnabled_ {false};
bool colorTableNeedsUpdate_ {false};
bool sweepNeedsUpdate_ {false};
};
RadarProductLayer::RadarProductLayer(
const std::shared_ptr<MapContext>& context) :
GenericLayer(context), p(std::make_unique<RadarProductLayerImpl>())
RadarProductLayer::RadarProductLayer(std::shared_ptr<gl::GlContext> glContext) :
GenericLayer(std::move(glContext)), p(std::make_unique<Impl>())
{
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;
void RadarProductLayer::Initialize()
void RadarProductLayer::Initialize(
const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
auto glContext = context()->gl_context();
auto glContext = gl_context();
gl::OpenGLFunctions& gl = glContext->gl();
@ -145,25 +126,36 @@ void RadarProductLayer::Initialize()
// Update radar sweep
p->sweepNeedsUpdate_ = true;
UpdateSweep();
UpdateSweep(mapContext);
// Create color table
gl.glGenTextures(1, &p->texture_);
p->colorTableNeedsUpdate_ = true;
UpdateColorTable();
UpdateColorTable(mapContext);
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_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;
std::shared_ptr<view::RadarProductView> radarProductView =
context()->radar_product_view();
mapContext->radar_product_view();
std::unique_lock sweepLock(radarProductView->sweep_mutex(),
std::try_to_lock);
@ -258,16 +250,17 @@ void RadarProductLayer::UpdateSweep()
}
void RadarProductLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
p->shaderProgram_->Use();
// Set OpenGL blend mode for transparency
gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
const bool wireframeEnabled = context()->settings().radarWireframeEnabled_;
const bool wireframeEnabled = mapContext->settings().radarWireframeEnabled_;
if (wireframeEnabled)
{
// Set polygon mode to draw wireframe
@ -276,12 +269,12 @@ void RadarProductLayer::Render(
if (p->colorTableNeedsUpdate_)
{
UpdateColorTable();
UpdateColorTable(mapContext);
}
if (p->sweepNeedsUpdate_)
{
UpdateSweep();
UpdateSweep(mapContext);
}
const float scale = std::pow(2.0, params.zoom) * 2.0f *
@ -323,7 +316,7 @@ void RadarProductLayer::Deinitialize()
{
logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(3, p->vbo_.data());
@ -339,6 +332,7 @@ void RadarProductLayer::Deinitialize()
}
bool RadarProductLayer::RunMousePicking(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& /* params */,
const QPointF& /* mouseLocalPos */,
const QPointF& mouseGlobalPos,
@ -352,16 +346,16 @@ bool RadarProductLayer::RunMousePicking(
Qt::KeyboardModifier::ShiftModifier)
{
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;
}
// Get distance and altitude of point
const double radarLatitude = context()->radar_site()->latitude();
const double radarLongitude = context()->radar_site()->longitude();
const double radarLatitude = mapContext->radar_site()->latitude();
const double radarLongitude = mapContext->radar_site()->longitude();
const auto distanceMeters =
util::GeographicLib::GetDistance(mouseGeoCoords.latitude_,
@ -396,7 +390,7 @@ bool RadarProductLayer::RunMousePicking(
util::GeographicLib::GetRadarBeamAltititude(
distanceMeters,
units::angle::degrees<double>(*elevation),
context()->radar_site()->altitude());
mapContext->radar_site()->altitude());
const std::string heightUnitName =
settings::UnitSettings::Instance().echo_tops_units().GetValue();
@ -529,15 +523,16 @@ bool RadarProductLayer::RunMousePicking(
return itemPicked;
}
void RadarProductLayer::UpdateColorTable()
void RadarProductLayer::UpdateColorTable(
const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("UpdateColorTable()");
p->colorTableNeedsUpdate_ = false;
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
std::shared_ptr<view::RadarProductView> radarProductView =
context()->radar_product_view();
mapContext->radar_product_view();
const std::vector<boost::gil::rgba8_pixel_t>& colorTable =
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
{
class RadarProductLayerImpl;
class RadarProductLayer : public GenericLayer
{
Q_DISABLE_COPY_MOVE(RadarProductLayer)
public:
explicit RadarProductLayer(const std::shared_ptr<MapContext>& context);
explicit RadarProductLayer(std::shared_ptr<gl::GlContext> glContext);
~RadarProductLayer();
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
virtual bool
RunMousePicking(const QMapLibre::CustomLayerRenderParameters& params,
bool
RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords,
@ -26,11 +28,12 @@ public:
std::shared_ptr<types::EventHandler>& eventHandler) override;
private:
void UpdateColorTable();
void UpdateSweep();
void UpdateColorTable(const std::shared_ptr<MapContext>& mapContext);
void UpdateSweep(const std::shared_ptr<MapContext>& mapContext);
private:
std::unique_ptr<RadarProductLayerImpl> p;
class Impl;
std::unique_ptr<Impl> p;
};
} // 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
{
public:
explicit Impl(RadarSiteLayer* self, std::shared_ptr<gl::GlContext> context) :
self_ {self}, geoLines_ {std::make_shared<gl::draw::GeoLines>(context)}
explicit Impl(RadarSiteLayer* self,
const std::shared_ptr<gl::GlContext>& glContext) :
self_ {self}, geoLines_ {std::make_shared<gl::draw::GeoLines>(glContext)}
{
}
~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,
std::shared_ptr<config::RadarSite>& radarSite);
void RenderRadarLine();
void RenderRadarLine(const std::shared_ptr<MapContext>& mapContext);
RadarSiteLayer* self_;
@ -50,15 +56,16 @@ public:
nullptr, nullptr};
};
RadarSiteLayer::RadarSiteLayer(const std::shared_ptr<MapContext>& context) :
DrawLayer(context, "RadarSiteLayer"),
p(std::make_unique<Impl>(this, context->gl_context()))
RadarSiteLayer::RadarSiteLayer(
const std::shared_ptr<gl::GlContext>& glContext) :
DrawLayer(glContext, "RadarSiteLayer"),
p(std::make_unique<Impl>(this, glContext))
{
}
RadarSiteLayer::~RadarSiteLayer() = default;
void RadarSiteLayer::Initialize()
void RadarSiteLayer::Initialize(const std::shared_ptr<MapContext>& mapContext)
{
logger_->debug("Initialize()");
@ -81,10 +88,11 @@ void RadarSiteLayer::Initialize()
AddDrawItem(p->geoLines_);
p->geoLines_->set_thresholded(false);
DrawLayer::Initialize();
DrawLayer::Initialize(mapContext);
}
void RadarSiteLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
p->hoverText_.clear();
@ -99,7 +107,7 @@ void RadarSiteLayer::Render(
return;
}
gl::OpenGLFunctions& gl = context()->gl_context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
// Update map screen coordinate and scale information
p->mapScreenCoordLocation_ = util::maplibre::LatLongToScreenCoordinate(
@ -111,7 +119,7 @@ void RadarSiteLayer::Render(
p->halfWidth_ = params.width * 0.5f;
p->halfHeight_ = params.height * 0.5f;
ImGuiFrameStart();
ImGuiFrameStart(mapContext);
// Radar site ImGui windows shouldn't have padding
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2 {0.0f, 0.0f});
@ -122,7 +130,7 @@ void RadarSiteLayer::Render(
ImGui::PopStyleVar();
p->RenderRadarLine();
p->RenderRadarLine(mapContext);
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() &
Qt::KeyboardModifier::ShiftModifier) &&
self_->context()->radar_site() != nullptr)
mapContext->radar_site() != nullptr)
{
const auto& mouseCoord = self_->context()->mouse_coordinate();
const double radarLatitude = self_->context()->radar_site()->latitude();
const double radarLongitude = self_->context()->radar_site()->longitude();
const auto& mouseCoord = mapContext->mouse_coordinate();
const double radarLatitude = mapContext->radar_site()->latitude();
const double radarLongitude = mapContext->radar_site()->longitude();
geoLines_->SetLineLocation(radarSiteLines_[0],
static_cast<float>(mouseCoord.latitude_),
@ -231,6 +240,7 @@ void RadarSiteLayer::Deinitialize()
}
bool RadarSiteLayer::RunMousePicking(
const std::shared_ptr<MapContext>& /* mapContext */,
const QMapLibre::CustomLayerRenderParameters& /* params */,
const QPointF& /* mouseLocalPos */,
const QPointF& mouseGlobalPos,

24
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)
public:
explicit RadarSiteLayer(const std::shared_ptr<MapContext>& context);
explicit RadarSiteLayer(const std::shared_ptr<gl::GlContext>& glContext);
~RadarSiteLayer();
void Initialize() override final;
void Render(const QMapLibre::CustomLayerRenderParameters&) override final;
void Deinitialize() override final;
void Initialize(const std::shared_ptr<MapContext>& mapContext) final;
void Render(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters&) final;
void Deinitialize() final;
bool RunMousePicking(
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords,
const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) override final;
bool
RunMousePicking(const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos,
const glm::vec2& mouseCoords,
const common::Coordinate& mouseGeoCoords,
std::shared_ptr<types::EventHandler>& eventHandler) final;
signals:
void RadarSiteSelected(const std::string& id);