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

Merge pull request #440 from dpaulat/feature/gl-cleanup

Browse source 
Share GL resources between maps
This commit is contained in:
Dan Paulat 2025-05-10 20:32:43 -05:00 • committed by GitHub
commit d6e574c877
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
32 changed files with 578 additions and 667 deletions
Download patch file Download diff file Expand all files Collapse all files

45
scwx-qt/source/scwx/qt/main/main_window.cpp
View file

@ -1,6 +1,7 @@
#include "main_window.hpp"
#include "./ui_main_window.h"
#include <scwx/qt/gl/gl_context.hpp>
#include <scwx/qt/main/application.hpp>
#include <scwx/qt/main/versions.hpp>
#include <scwx/qt/manager/alert_manager.hpp>
@ -776,6 +777,8 @@ void MainWindowImpl::ConfigureMapLayout()
}
};
auto glContext = std::make_shared<gl::GlContext>();
for (int64_t y = 0; y < gridHeight; y++)
{
QSplitter* hs = new QSplitter(vs);
@ -785,7 +788,9 @@ void MainWindowImpl::ConfigureMapLayout()
{
if (maps_.at(mapIndex) == nullptr)
{
maps_[mapIndex] = new map::MapWidget(mapIndex, settings_);
// NOLINTNEXTLINE(cppcoreguidelines-owning-memory): Owned by parent
maps_[mapIndex] =
new map::MapWidget(mapIndex, settings_, glContext);
}
hs->addWidget(maps_[mapIndex]);
@ -818,9 +823,9 @@ void MainWindowImpl::ConfigureMapStyles()
if ((customStyleAvailable_ && styleName == "Custom") ||
std::find_if(mapProviderInfo.mapStyles_.cbegin(),
mapProviderInfo.mapStyles_.cend(),
[&](const auto& mapStyle) {
return mapStyle.name_ == styleName;
}) != mapProviderInfo.mapStyles_.cend())
[&](const auto& mapStyle)
{ return mapStyle.name_ == styleName; }) !=
mapProviderInfo.mapStyles_.cend())
{
// Initialize map style from settings
maps_.at(i)->SetInitialMapStyle(styleName);
@ -1154,22 +1159,22 @@ void MainWindowImpl::ConnectOtherSignals()
mapSettings.radar_product(i).StageValue(map->GetRadarProductName());
}
});
connect(level2ProductsWidget_,
&ui::Level2ProductsWidget::RadarProductSelected,
mainWindow_,
[&](common::RadarProductGroup group,
const std::string& productName,
int16_t productCode) {
SelectRadarProduct(activeMap_, group, productName, productCode);
});
connect(level3ProductsWidget_,
&ui::Level3ProductsWidget::RadarProductSelected,
mainWindow_,
[&](common::RadarProductGroup group,
const std::string& productName,
int16_t productCode) {
SelectRadarProduct(activeMap_, group, productName, productCode);
});
connect(
level2ProductsWidget_,
&ui::Level2ProductsWidget::RadarProductSelected,
mainWindow_,
[&](common::RadarProductGroup group,
const std::string& productName,
int16_t productCode)
{ SelectRadarProduct(activeMap_, group, productName, productCode); });
connect(
level3ProductsWidget_,
&ui::Level3ProductsWidget::RadarProductSelected,
mainWindow_,
[&](common::RadarProductGroup group,
const std::string& productName,
int16_t productCode)
{ SelectRadarProduct(activeMap_, group, productName, productCode); });
connect(level2SettingsWidget_,
&ui::Level2SettingsWidget::ElevationSelected,
mainWindow_,

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<MapContext> 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, 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();
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();
}

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

@ -6,14 +6,8 @@
#include <scwx/qt/types/text_event_key.hpp>
#include <memory>
#include <string>
#include <vector>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class AlertLayer : public DrawLayer
@ -22,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();
@ -40,6 +35,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -14,58 +14,52 @@
# pragma warning(pop)
#endif
namespace scwx
{
namespace qt
{
namespace map
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(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()");
gl::OpenGLFunctions& gl = context()->gl();
auto glContext = gl_context();
gl::OpenGLFunctions& gl = glContext->gl();
// Load and configure overlay shader
p->shaderProgram_ =
context()->GetShaderProgram(":/gl/texture1d.vert", ":/gl/texture1d.frag");
glContext->GetShaderProgram(":/gl/texture1d.vert", ":/gl/texture1d.frag");
p->uMVPMatrixLocation_ =
gl.glGetUniformLocation(p->shaderProgram_->id(), "uMVPMatrix");
@ -109,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();
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;
@ -182,11 +176,17 @@ 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});
static constexpr int kLeftMargin_ = 0;
static constexpr int kTopMargin_ = 0;
static constexpr int kRightMargin_ = 0;
static constexpr int kBottomMargin_ = 10;
mapContext->set_color_table_margins(
QMargins {kLeftMargin_, kTopMargin_, kRightMargin_, kBottomMargin_});
}
else
{
context()->set_color_table_margins(QMargins {});
mapContext->set_color_table_margins(QMargins {});
}
SCWX_GL_CHECK_ERROR();
@ -196,7 +196,7 @@ void ColorTableLayer::Deinitialize()
{
logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(2, p->vbo_.data());
@ -206,10 +206,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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,29 +2,25 @@
#include <scwx/qt/map/generic_layer.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace map
{
class ColorTableLayerImpl;
class ColorTableLayer : public GenericLayer
{
Q_DISABLE_COPY_MOVE(ColorTableLayer)
public:
explicit ColorTableLayer(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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

67
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_->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,13 +125,15 @@ void DrawLayer::ImGuiInitialize()
void DrawLayer::RenderWithoutImGui(
const QMapLibre::CustomLayerRenderParameters& params)
{
gl::OpenGLFunctions& gl = p->context_->gl();
p->textureAtlas_ = p->context_->GetTextureAtlas();
auto& glContext = p->glContext_;
gl::OpenGLFunctions& gl = glContext->gl();
p->textureAtlas_ = glContext->GetTextureAtlas();
// Determine if the texture atlas changed since last render
std::uint64_t newTextureAtlasBuildCount =
p->context_->texture_buffer_count();
bool textureAtlasChanged =
const std::uint64_t newTextureAtlasBuildCount =
glContext->texture_buffer_count();
const bool textureAtlasChanged =
newTextureAtlasBuildCount != p->textureAtlasBuildCount_;
// Set OpenGL blend mode for transparency
@ -145,14 +149,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();
}
@ -168,6 +174,7 @@ void DrawLayer::Deinitialize()
}
bool DrawLayer::RunMousePicking(
const std::shared_ptr<MapContext>& /* mapContext */,
const QMapLibre::CustomLayerRenderParameters& params,
const QPointF& mouseLocalPos,
const QPointF& mouseGlobalPos,

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

@ -3,28 +3,26 @@
#include <scwx/qt/gl/draw/draw_item.hpp>
#include <scwx/qt/map/generic_layer.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace 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,
@ -33,17 +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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -1,32 +1,34 @@
#include <scwx/qt/map/generic_layer.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class GenericLayerImpl
class GenericLayer::Impl
{
public:
explicit GenericLayerImpl(std::shared_ptr<MapContext> context) :
context_ {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(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 */,
@ -38,11 +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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

32
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>
@ -10,30 +11,27 @@
#include <glm/gtc/type_ptr.hpp>
#include <qmaplibre.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace map
{
class GenericLayerImpl;
class GenericLayer : public QObject
{
Q_OBJECT
Q_DISABLE_COPY_MOVE(GenericLayer)
public:
explicit GenericLayer(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
@ -44,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,
@ -55,12 +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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -1,27 +1,31 @@
#include <scwx/qt/map/layer_wrapper.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class LayerWrapperImpl
class LayerWrapper::Impl
{
public:
explicit LayerWrapperImpl(std::shared_ptr<GenericLayer> layer) :
layer_ {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(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;
@ -34,7 +38,7 @@ void LayerWrapper::initialize()
auto& layer = p->layer_;
if (layer != nullptr)
{
layer->Initialize();
layer->Initialize(p->mapContext_);
}
}
@ -43,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);
}
}
@ -58,6 +62,4 @@ void LayerWrapper::deinitialize()
}
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -1,20 +1,16 @@
#pragma once
#include <scwx/qt/map/generic_layer.hpp>
#include <scwx/qt/map/map_context.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace map
{
class LayerWrapperImpl;
class LayerWrapper : public QMapLibre::CustomLayerHostInterface
{
public:
explicit LayerWrapper(std::shared_ptr<GenericLayer> layer);
explicit LayerWrapper(std::shared_ptr<GenericLayer> layer,
std::shared_ptr<MapContext> mapContext);
~LayerWrapper();
LayerWrapper(const LayerWrapper&) = delete;
@ -23,14 +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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -3,11 +3,7 @@
#include <scwx/qt/view/overlay_product_view.hpp>
#include <scwx/qt/view/radar_product_view.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class MapContext::Impl
@ -25,9 +21,9 @@ public:
float pixelRatio_ {1.0f};
common::RadarProductGroup radarProductGroup_ {
common::RadarProductGroup::Unknown};
std::string radarProduct_ {"???"};
int16_t radarProductCode_ {0};
std::shared_ptr<config::RadarSite> radarSite_ {nullptr};
std::string radarProduct_ {"???"};
int16_t radarProductCode_ {0};
std::shared_ptr<config::RadarSite> radarSite_ {nullptr};
MapProvider mapProvider_ {MapProvider::Unknown};
std::string mapCopyrights_ {};
@ -190,6 +186,4 @@ void MapContext::set_widget(QWidget* widget)
p->widget_ = widget;
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

16
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>
@ -9,27 +8,25 @@
#include <qmaplibre.hpp>
#include <QMargins>
namespace scwx::qt
{
namespace view
namespace scwx::qt::view
{
class OverlayProductView;
class RadarProductView;
} // namespace view
} // namespace scwx::qt::view
namespace map
namespace scwx::qt::map
{
struct MapSettings;
class MapContext : public gl::GlContext
class MapContext
{
public:
explicit MapContext(
std::shared_ptr<view::RadarProductView> radarProductView = nullptr);
~MapContext() override;
~MapContext();
MapContext(const MapContext&) = delete;
MapContext& operator=(const MapContext&) = delete;
@ -76,5 +73,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace scwx::qt
} // namespace scwx::qt::map

10
scwx-qt/source/scwx/qt/map/map_provider.cpp
View file

@ -5,11 +5,7 @@
#include <boost/algorithm/string.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::unordered_map<MapProvider, std::string> mapProviderName_ {
@ -243,6 +239,4 @@ const MapProviderInfo& GetMapProviderInfo(MapProvider mapProvider)
return mapProviderInfo_.at(mapProvider);
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -6,11 +6,7 @@
#include <QMapLibre/Settings>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
enum class MapProvider
@ -19,9 +15,8 @@ enum class MapProvider
MapTiler,
Unknown
};
typedef scwx::util::
Iterator<MapProvider, MapProvider::Mapbox, MapProvider::MapTiler>
MapProviderIterator;
using MapProviderIterator = scwx::util::
Iterator<MapProvider, MapProvider::Mapbox, MapProvider::MapTiler>;
struct MapStyle
{
@ -29,7 +24,7 @@ struct MapStyle
std::string url_;
std::vector<std::string> drawBelow_;
bool IsValid() const;
[[nodiscard]] bool IsValid() const;
};
struct MapProviderInfo
@ -45,6 +40,4 @@ std::string GetMapProviderName(MapProvider mapProvider);
std::string GetMapProviderApiKey(MapProvider mapProvider);
const MapProviderInfo& GetMapProviderInfo(MapProvider mapProvider);
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -1,10 +1,6 @@
#pragma once
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
struct MapSettings
@ -22,6 +18,4 @@ struct MapSettings
bool radarWireframeEnabled_ {false};
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -1,4 +1,3 @@
#include <ranges>
#include <scwx/qt/map/map_widget.hpp>
#include <scwx/qt/gl/gl.hpp>
#include <scwx/qt/manager/font_manager.hpp>
@ -32,7 +31,9 @@
#include <scwx/util/time.hpp>
#include <algorithm>
#include <ranges>
#include <set>
#include <utility>
#include <backends/imgui_impl_opengl3.h>
#include <backends/imgui_impl_qt.hpp>
@ -57,11 +58,7 @@
#include <QString>
#include <QTextDocument>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::map_widget";
@ -72,14 +69,15 @@ class MapWidgetImpl : public QObject
Q_OBJECT
public:
explicit MapWidgetImpl(MapWidget* widget,
std::size_t id,
const QMapLibre::Settings& settings) :
explicit MapWidgetImpl(MapWidget* widget,
std::size_t id,
QMapLibre::Settings settings,
std::shared_ptr<gl::GlContext> glContext) :
id_ {id},
uuid_ {boost::uuids::random_generator()()},
context_ {std::make_shared<MapContext>()},
glContext_ {std::move(glContext)},
widget_ {widget},
settings_(settings),
settings_(std::move(settings)),
map_(),
layerList_ {},
imGuiRendererInitialized_ {false},
@ -158,9 +156,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);
@ -198,7 +196,8 @@ 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_;
MapWidget* widget_;
QMapLibre::Settings settings_;
@ -283,8 +282,10 @@ public slots:
void Update();
};
MapWidget::MapWidget(std::size_t id, const QMapLibre::Settings& settings) :
p(std::make_unique<MapWidgetImpl>(this, id, settings))
MapWidget::MapWidget(std::size_t id,
const QMapLibre::Settings& settings,
std::shared_ptr<gl::GlContext> glContext) :
p(std::make_unique<MapWidgetImpl>(this, id, settings, std::move(glContext)))
{
if (settings::GeneralSettings::Instance().anti_aliasing_enabled().GetValue())
{
@ -1243,7 +1244,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);
}
}
@ -1252,7 +1253,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);
@ -1276,7 +1277,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;
@ -1284,14 +1285,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(),
@ -1307,7 +1308,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;
@ -1324,7 +1325,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;
@ -1354,7 +1355,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);
@ -1371,13 +1372,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
{
@ -1545,7 +1546,8 @@ void MapWidget::initializeGL()
logger_->debug("initializeGL()");
makeCurrent();
p->context_->Initialize();
p->glContext_->Initialize();
// Lock ImGui font atlas prior to new ImGui frame
std::shared_lock imguiFontAtlasLock {
@ -1599,7 +1601,7 @@ void MapWidget::paintGL()
p->frameDraws_++;
p->context_->StartFrame();
p->glContext_->StartFrame();
// Handle hotkey updates
p->HandleHotkeyUpdates();
@ -1708,7 +1710,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,
@ -2251,8 +2254,6 @@ void MapWidgetImpl::CheckLevel3Availability()
}
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map
#include "map_widget.moc"

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

@ -22,11 +22,12 @@ class QKeyEvent;
class QMouseEvent;
class QWheelEvent;
namespace scwx
namespace scwx::qt::gl
{
namespace qt
{
namespace map
class GlContext;
}
namespace scwx::qt::map
{
class MapWidgetImpl;
@ -36,7 +37,9 @@ class MapWidget : public QOpenGLWidget
Q_OBJECT
public:
explicit MapWidget(std::size_t id, const QMapLibre::Settings&);
explicit MapWidget(std::size_t id,
const QMapLibre::Settings&,
std::shared_ptr<gl::GlContext> glContext);
~MapWidget();
void DumpLayerList() const;
@ -188,6 +191,4 @@ signals:
void IncomingLevel2ElevationChanged(std::optional<float> incomingElevation);
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -5,16 +5,12 @@
#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
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::marker_layer";
@ -23,15 +19,21 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class MarkerLayer::Impl
{
public:
explicit Impl(MarkerLayer* self, std::shared_ptr<MapContext> 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();
@ -42,7 +44,7 @@ public:
MarkerLayer* self_;
std::shared_ptr<gl::draw::GeoIcons> geoIcons_;
std::shared_ptr<gl::draw::GeoIcons> geoIcons_;
std::shared_ptr<ui::EditMarkerDialog> editMarkerDialog_;
};
@ -128,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))
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();
@ -160,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();
gl::OpenGLFunctions& gl = gl_context()->gl();
DrawLayer::Render(params);
DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR();
}
@ -176,6 +179,4 @@ void MarkerLayer::Deinitialize()
DrawLayer::Deinitialize();
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,32 +2,26 @@
#include <scwx/qt/map/draw_layer.hpp>
#include <string>
namespace scwx
{
namespace qt
{
namespace map
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;
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -26,26 +26,22 @@
# pragma warning(pop)
#endif
namespace scwx
{
namespace qt
{
namespace map
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<MapContext> 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();
@ -75,7 +71,7 @@ public:
[this](const bool&) { Q_EMIT self_->NeedsRendering(); });
}
~OverlayLayerImpl()
~Impl()
{
auto& generalSettings = settings::GeneralSettings::Instance();
@ -91,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);
@ -155,9 +156,9 @@ public:
bool sweepTimePicked_ {false};
};
OverlayLayer::OverlayLayer(std::shared_ptr<MapContext> context) :
DrawLayer(context, "OverlayLayer"),
p(std::make_unique<OverlayLayerImpl>(this, 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_);
@ -172,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_};
@ -212,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)
{
@ -255,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())
{
@ -280,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);
@ -299,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);
}
@ -332,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();
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;
@ -387,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
@ -511,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();
const QMargins colorTableMargins = mapContext->color_table_margins();
if (colorTableMargins != p->lastColorTableMargins_ || p->firstRender_)
{
// Draw map logo with a 10x10 indent from the bottom left
@ -524,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())
{
@ -567,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,
@ -603,7 +589,8 @@ bool OverlayLayer::RunMousePicking(
return true;
}
return DrawLayer::RunMousePicking(params,
return DrawLayer::RunMousePicking(mapContext,
params,
mouseLocalPos,
mouseGlobalPos,
mouseCoords,
@ -616,6 +603,4 @@ void OverlayLayer::UpdateSweepTimeNextFrame()
p->sweepTimeNeedsUpdate_ = true;
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,42 +2,37 @@
#include <scwx/qt/map/draw_layer.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace map
{
class OverlayLayerImpl;
class OverlayLayer : public DrawLayer
{
Q_DISABLE_COPY_MOVE(OverlayLayer)
public:
explicit OverlayLayer(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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -11,11 +11,7 @@
#include <scwx/util/logger.hpp>
#include <scwx/util/time.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::overlay_product_layer";
@ -24,10 +20,10 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class OverlayProductLayer::Impl
{
public:
explicit Impl(OverlayProductLayer* self,
const std::shared_ptr<MapContext>& 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();
@ -64,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,
@ -108,11 +105,22 @@ public:
std::shared_ptr<gl::draw::LinkedVectors> linkedVectors_;
};
OverlayProductLayer::OverlayProductLayer(std::shared_ptr<MapContext> context) :
DrawLayer(context, "OverlayProductLayer"),
p(std::make_unique<Impl>(this, context))
OverlayProductLayer::OverlayProductLayer(
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,
@ -125,31 +133,23 @@ OverlayProductLayer::OverlayProductLayer(std::shared_ptr<MapContext> context) :
}
});
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();
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();
}
@ -158,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");
@ -434,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,
@ -441,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,
@ -449,6 +454,4 @@ bool OverlayProductLayer::RunMousePicking(
eventHandler);
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,36 +2,35 @@
#include <scwx/qt/map/draw_layer.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class OverlayProductLayer : public DrawLayer
{
Q_DISABLE_COPY_MOVE(OverlayProductLayer)
public:
explicit OverlayProductLayer(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;
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -12,11 +12,7 @@
#include <boost/asio/post.hpp>
#include <boost/asio/thread_pool.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::placefile_layer";
@ -25,25 +21,31 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class PlacefileLayer::Impl
{
public:
explicit Impl(PlacefileLayer* self,
const std::shared_ptr<MapContext>& 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();
@ -64,10 +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, placefileName))
DrawLayer(glContext, fmt::format("PlacefileLayer {}", placefileName)),
p(std::make_unique<PlacefileLayer::Impl>(this, glContext, placefileName))
{
AddDrawItem(p->placefileImages_);
AddDrawItem(p->placefilePolygons_);
@ -117,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();
gl::OpenGLFunctions& gl = gl_context()->gl();
std::shared_ptr<manager::PlacefileManager> placefileManager =
manager::PlacefileManager::Instance();
@ -156,7 +159,7 @@ void PlacefileLayer::Render(
p->placefileText_->set_selected_time(p->selectedTime_);
}
DrawLayer::Render(params);
DrawLayer::Render(mapContext, params);
SCWX_GL_CHECK_ERROR();
}
@ -261,6 +264,4 @@ void PlacefileLayer::Impl::ReloadDataSync()
Q_EMIT self_->DataReloaded();
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -4,29 +4,27 @@
#include <string>
namespace scwx
{
namespace qt
{
namespace map
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();
@ -38,6 +36,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -26,80 +26,60 @@
# pragma warning(pop)
#endif
namespace scwx
{
namespace qt
{
namespace map
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(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()");
gl::OpenGLFunctions& gl = context()->gl();
auto glContext = gl_context();
gl::OpenGLFunctions& gl = glContext->gl();
// Load and configure radar shader
p->shaderProgram_ =
context()->GetShaderProgram(":/gl/radar.vert", ":/gl/radar.frag");
glContext->GetShaderProgram(":/gl/radar.vert", ":/gl/radar.frag");
p->uMVPMatrixLocation_ =
gl.glGetUniformLocation(p->shaderProgram_->id(), "uMVPMatrix");
@ -146,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();
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);
@ -259,16 +250,17 @@ void RadarProductLayer::UpdateSweep()
}
void RadarProductLayer::Render(
const std::shared_ptr<MapContext>& mapContext,
const QMapLibre::CustomLayerRenderParameters& params)
{
gl::OpenGLFunctions& 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
@ -277,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 *
@ -324,7 +316,7 @@ void RadarProductLayer::Deinitialize()
{
logger_->debug("Deinitialize()");
gl::OpenGLFunctions& gl = context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
gl.glDeleteVertexArrays(1, &p->vao_);
gl.glDeleteBuffers(3, p->vbo_.data());
@ -340,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,
@ -353,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_,
@ -397,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();
@ -530,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();
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();
@ -563,6 +557,4 @@ void RadarProductLayer::UpdateColorTable()
gl.glUniform1f(p->uDataMomentScaleLocation_, scale);
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,27 +2,25 @@
#include <scwx/qt/map/generic_layer.hpp>
namespace scwx
namespace scwx::qt::map
{
namespace qt
{
namespace map
{
class RadarProductLayerImpl;
class RadarProductLayer : public GenericLayer
{
Q_DISABLE_COPY_MOVE(RadarProductLayer)
public:
explicit RadarProductLayer(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,
@ -30,13 +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 map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

10
scwx-qt/source/scwx/qt/map/radar_range_layer.cpp
View file

@ -5,11 +5,7 @@
#include <glm/glm.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::radar_range_layer";
@ -98,6 +94,4 @@ GetRangeCircle(float range, QMapLibre::Coordinate center)
return rangeCircle;
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

13
scwx-qt/source/scwx/qt/map/radar_range_layer.hpp
View file

@ -2,13 +2,7 @@
#include <qmaplibre.hpp>
namespace scwx
{
namespace qt
{
namespace map
{
namespace RadarRangeLayer
namespace scwx::qt::map::RadarRangeLayer
{
void Add(std::shared_ptr<QMapLibre::Map> map,
@ -19,7 +13,4 @@ void Update(std::shared_ptr<QMapLibre::Map> map,
float range,
QMapLibre::Coordinate center);
} // namespace RadarRangeLayer
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map::RadarRangeLayer

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

@ -13,11 +13,7 @@
#include <QGuiApplication>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
static const std::string logPrefix_ = "scwx::qt::map::radar_site_layer";
@ -26,15 +22,21 @@ static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class RadarSiteLayer::Impl
{
public:
explicit Impl(RadarSiteLayer* self, std::shared_ptr<MapContext>& 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_;
@ -54,15 +56,16 @@ public:
nullptr, nullptr};
};
RadarSiteLayer::RadarSiteLayer(std::shared_ptr<MapContext> context) :
DrawLayer(context, "RadarSiteLayer"),
p(std::make_unique<Impl>(this, 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()");
@ -85,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();
@ -103,7 +107,7 @@ void RadarSiteLayer::Render(
return;
}
gl::OpenGLFunctions& gl = context()->gl();
gl::OpenGLFunctions& gl = gl_context()->gl();
// Update map screen coordinate and scale information
p->mapScreenCoordLocation_ = util::maplibre::LatLongToScreenCoordinate(
@ -115,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});
@ -126,7 +130,7 @@ void RadarSiteLayer::Render(
ImGui::PopStyleVar();
p->RenderRadarLine();
p->RenderRadarLine(mapContext);
DrawLayer::RenderWithoutImGui(params);
@ -196,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_),
@ -235,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,
@ -251,6 +257,4 @@ bool RadarSiteLayer::RunMousePicking(
return false;
}
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map

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

@ -2,11 +2,7 @@
#include <scwx/qt/map/draw_layer.hpp>
namespace scwx
{
namespace qt
{
namespace map
namespace scwx::qt::map
{
class RadarSiteLayer : public DrawLayer
@ -15,20 +11,22 @@ class RadarSiteLayer : public DrawLayer
Q_DISABLE_COPY_MOVE(RadarSiteLayer)
public:
explicit RadarSiteLayer(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);
@ -38,6 +36,4 @@ private:
std::unique_ptr<Impl> p;
};
} // namespace map
} // namespace qt
} // namespace scwx
} // namespace scwx::qt::map