From c37d2baaf647fec35c28a8e639b0d4a74643537d Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Thu, 26 Jul 2018 16:39:19 +0100 Subject: common: rename GraphicElement::{style,type} enums, add _MAX members --- gui/fpgaviewwidget.cc | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'gui') diff --git a/gui/fpgaviewwidget.cc b/gui/fpgaviewwidget.cc index 6637f2b7..e9096bf4 100644 --- a/gui/fpgaviewwidget.cc +++ b/gui/fpgaviewwidget.cc @@ -320,7 +320,7 @@ void FPGAViewWidget::drawDecal(LineShaderData &out, const DecalXY &decal) offsetX = decal.x; offsetY = decal.y; - if (el.type == GraphicElement::G_BOX) { + if (el.type == GraphicElement::TYPE_BOX) { auto line = PolyLine(true); line.point(offsetX + scale * el.x1, offsetY + scale * el.y1); line.point(offsetX + scale * el.x2, offsetY + scale * el.y1); @@ -329,7 +329,7 @@ void FPGAViewWidget::drawDecal(LineShaderData &out, const DecalXY &decal) line.build(out); } - if (el.type == GraphicElement::G_LINE || el.type == GraphicElement::G_ARROW) { + if (el.type == GraphicElement::TYPE_LINE || el.type == GraphicElement::TYPE_ARROW) { PolyLine(offsetX + scale * el.x1, offsetY + scale * el.y1, offsetX + scale * el.x2, offsetY + scale * el.y2) .build(out); } @@ -345,16 +345,16 @@ void FPGAViewWidget::drawDecal(LineShaderData out[], const DecalXY &decal) offsetX = decal.x; offsetY = decal.y; - if (el.type == GraphicElement::G_BOX) { + if (el.type == GraphicElement::TYPE_BOX) { auto line = PolyLine(true); line.point(offsetX + scale * el.x1, offsetY + scale * el.y1); line.point(offsetX + scale * el.x2, offsetY + scale * el.y1); line.point(offsetX + scale * el.x2, offsetY + scale * el.y2); line.point(offsetX + scale * el.x1, offsetY + scale * el.y2); switch (el.style) { - case GraphicElement::G_FRAME: - case GraphicElement::G_INACTIVE: - case GraphicElement::G_ACTIVE: + case GraphicElement::STYLE_FRAME: + case GraphicElement::STYLE_INACTIVE: + case GraphicElement::STYLE_ACTIVE: line.build(out[el.style]); break; default: @@ -362,13 +362,13 @@ void FPGAViewWidget::drawDecal(LineShaderData out[], const DecalXY &decal) } } - if (el.type == GraphicElement::G_LINE || el.type == GraphicElement::G_ARROW) { + if (el.type == GraphicElement::TYPE_LINE || el.type == GraphicElement::TYPE_ARROW) { auto line = PolyLine(offsetX + scale * el.x1, offsetY + scale * el.y1, offsetX + scale * el.x2, offsetY + scale * el.y2); switch (el.style) { - case GraphicElement::G_FRAME: - case GraphicElement::G_INACTIVE: - case GraphicElement::G_ACTIVE: + case GraphicElement::STYLE_FRAME: + case GraphicElement::STYLE_INACTIVE: + case GraphicElement::STYLE_ACTIVE: line.build(out[el.style]); break; default: -- cgit v1.2.3 From 706fe2f3655210467d329c9a8c98f5821fb02c60 Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Thu, 26 Jul 2018 17:26:26 +0100 Subject: gui: refactor FPGAViewWidget slightly --- gui/fpgaviewwidget.cc | 272 ++++++++++++++++++++++++++------------------------ gui/fpgaviewwidget.h | 15 +-- 2 files changed, 150 insertions(+), 137 deletions(-) (limited to 'gui') diff --git a/gui/fpgaviewwidget.cc b/gui/fpgaviewwidget.cc index e9096bf4..2211c93b 100644 --- a/gui/fpgaviewwidget.cc +++ b/gui/fpgaviewwidget.cc @@ -311,69 +311,49 @@ void FPGAViewWidget::initializeGL() 0.0); } -void FPGAViewWidget::drawDecal(LineShaderData &out, const DecalXY &decal) +void FPGAViewWidget::drawGraphicElement(LineShaderData &out, const GraphicElement &el, float x, float y) { const float scale = 1.0; - float offsetX = 0.0, offsetY = 0.0; - for (auto &el : ctx_->getDecalGraphics(decal.decal)) { - offsetX = decal.x; - offsetY = decal.y; - - if (el.type == GraphicElement::TYPE_BOX) { - auto line = PolyLine(true); - line.point(offsetX + scale * el.x1, offsetY + scale * el.y1); - line.point(offsetX + scale * el.x2, offsetY + scale * el.y1); - line.point(offsetX + scale * el.x2, offsetY + scale * el.y2); - line.point(offsetX + scale * el.x1, offsetY + scale * el.y2); - line.build(out); - } + if (el.type == GraphicElement::TYPE_BOX) { + auto line = PolyLine(true); + line.point(x + scale * el.x1, y + scale * el.y1); + line.point(x + scale * el.x2, y + scale * el.y1); + line.point(x + scale * el.x2, y + scale * el.y2); + line.point(x + scale * el.x1, y + scale * el.y2); + line.build(out); + } - if (el.type == GraphicElement::TYPE_LINE || el.type == GraphicElement::TYPE_ARROW) { - PolyLine(offsetX + scale * el.x1, offsetY + scale * el.y1, offsetX + scale * el.x2, offsetY + scale * el.y2) - .build(out); - } + if (el.type == GraphicElement::TYPE_LINE || el.type == GraphicElement::TYPE_ARROW) { + PolyLine(x + scale * el.x1, y + scale * el.y1, x + scale * el.x2, y + scale * el.y2) + .build(out); } } -void FPGAViewWidget::drawDecal(LineShaderData out[], const DecalXY &decal) +void FPGAViewWidget::drawDecal(LineShaderData &out, const DecalXY &decal) { - const float scale = 1.0; - float offsetX = 0.0, offsetY = 0.0; + float offsetX = decal.x; + float offsetY = decal.y; for (auto &el : ctx_->getDecalGraphics(decal.decal)) { - offsetX = decal.x; - offsetY = decal.y; - - if (el.type == GraphicElement::TYPE_BOX) { - auto line = PolyLine(true); - line.point(offsetX + scale * el.x1, offsetY + scale * el.y1); - line.point(offsetX + scale * el.x2, offsetY + scale * el.y1); - line.point(offsetX + scale * el.x2, offsetY + scale * el.y2); - line.point(offsetX + scale * el.x1, offsetY + scale * el.y2); - switch (el.style) { - case GraphicElement::STYLE_FRAME: - case GraphicElement::STYLE_INACTIVE: - case GraphicElement::STYLE_ACTIVE: - line.build(out[el.style]); - break; - default: - break; - } - } + drawGraphicElement(out, el, offsetX, offsetY); + } +} - if (el.type == GraphicElement::TYPE_LINE || el.type == GraphicElement::TYPE_ARROW) { - auto line = PolyLine(offsetX + scale * el.x1, offsetY + scale * el.y1, offsetX + scale * el.x2, - offsetY + scale * el.y2); - switch (el.style) { - case GraphicElement::STYLE_FRAME: - case GraphicElement::STYLE_INACTIVE: - case GraphicElement::STYLE_ACTIVE: - line.build(out[el.style]); - break; - default: - break; - } +void FPGAViewWidget::drawArchDecal(LineShaderData out[GraphicElement::STYLE_MAX], const DecalXY &decal) +{ + float offsetX = decal.x; + float offsetY = decal.y; + + for (auto &el : ctx_->getDecalGraphics(decal.decal)) { + switch (el.style) { + case GraphicElement::STYLE_FRAME: + case GraphicElement::STYLE_INACTIVE: + case GraphicElement::STYLE_ACTIVE: + drawGraphicElement(out[el.style], el, offsetX, offsetY); + break; + default: + break; } } } @@ -403,24 +383,28 @@ void FPGAViewWidget::paintGL() float thick1Px = mouseToWorldCoordinates(1, 0).x(); float thick11Px = mouseToWorldCoordinates(1.1, 0).x(); - // Draw grid. + // Render grid. auto grid = LineShaderData(); for (float i = -100.0f; i < 100.0f; i += 1.0f) { PolyLine(-100.0f, i, 100.0f, i).build(grid); PolyLine(i, -100.0f, i, 100.0f).build(grid); } + // Draw grid. lineShader_.draw(grid, colors_.grid, thick1Px, matrix); rendererDataLock_.lock(); - lineShader_.draw(rendererData_->decals[0], colors_.frame, thick11Px, matrix); - lineShader_.draw(rendererData_->decals[1], colors_.hidden, thick11Px, matrix); - lineShader_.draw(rendererData_->decals[2], colors_.inactive, thick11Px, matrix); - lineShader_.draw(rendererData_->decals[3], colors_.active, thick11Px, matrix); + // Render Arch graphics. + lineShader_.draw(rendererData_->gfxByStyle[GraphicElement::STYLE_FRAME], colors_.frame, thick11Px, matrix); + lineShader_.draw(rendererData_->gfxByStyle[GraphicElement::STYLE_HIDDEN], colors_.hidden, thick11Px, matrix); + lineShader_.draw(rendererData_->gfxByStyle[GraphicElement::STYLE_INACTIVE], colors_.inactive, thick11Px, matrix); + lineShader_.draw(rendererData_->gfxByStyle[GraphicElement::STYLE_ACTIVE], colors_.active, thick11Px, matrix); + + // Draw highlighted items. for (int i = 0; i < 8; i++) - lineShader_.draw(rendererData_->highlighted[i], colors_.highlight[i], thick11Px, matrix); + lineShader_.draw(rendererData_->gfxHighlighted[i], colors_.highlight[i], thick11Px, matrix); - lineShader_.draw(rendererData_->selected, colors_.selected, thick11Px, matrix); + lineShader_.draw(rendererData_->gfxSelected, colors_.selected, thick11Px, matrix); rendererDataLock_.unlock(); } @@ -431,120 +415,148 @@ void FPGAViewWidget::renderLines(void) if (ctx_ == nullptr) return; - ctx_->lock_ui(); - - // For now, collapse any decal changes into change of all decals. - // TODO(q3k): fix this - bool decalsChanged = false; - if (ctx_->allUiReload) { - ctx_->allUiReload = false; - decalsChanged = true; - } - if (ctx_->frameUiReload) { - ctx_->frameUiReload = false; - decalsChanged = true; - } - if (ctx_->belUiReload.size() > 0) { - ctx_->belUiReload.clear(); - decalsChanged = true; - } - if (ctx_->wireUiReload.size() > 0) { - ctx_->wireUiReload.clear(); - decalsChanged = true; - } - if (ctx_->pipUiReload.size() > 0) { - ctx_->pipUiReload.clear(); - decalsChanged = true; - } - if (ctx_->groupUiReload.size() > 0) { - ctx_->groupUiReload.clear(); - decalsChanged = true; - } - - // Local copy of decals, taken as fast as possible to not block the P&R. + // Data from Context needed to render all decals. std::vector belDecals; std::vector wireDecals; std::vector pipDecals; std::vector groupDecals; - if (decalsChanged) { - for (auto bel : ctx_->getBels()) { - belDecals.push_back(ctx_->getBelDecal(bel)); + bool decalsChanged = false; + { + // Take the UI/Normal mutex on the Context, copy over all we need as + // fast as we can. + std::lock_guard lock_ui(ctx_->ui_mutex); + std::lock_guard lock(ctx_->mutex); + + // For now, collapse any decal changes into change of all decals. + // TODO(q3k): fix this + if (ctx_->allUiReload) { + ctx_->allUiReload = false; + decalsChanged = true; + } + if (ctx_->frameUiReload) { + ctx_->frameUiReload = false; + decalsChanged = true; } - for (auto wire : ctx_->getWires()) { - wireDecals.push_back(ctx_->getWireDecal(wire)); + if (ctx_->belUiReload.size() > 0) { + ctx_->belUiReload.clear(); + decalsChanged = true; } - for (auto pip : ctx_->getPips()) { - pipDecals.push_back(ctx_->getPipDecal(pip)); + if (ctx_->wireUiReload.size() > 0) { + ctx_->wireUiReload.clear(); + decalsChanged = true; } - for (auto group : ctx_->getGroups()) { - groupDecals.push_back(ctx_->getGroupDecal(group)); + if (ctx_->pipUiReload.size() > 0) { + ctx_->pipUiReload.clear(); + decalsChanged = true; + } + if (ctx_->groupUiReload.size() > 0) { + ctx_->groupUiReload.clear(); + decalsChanged = true; + } + + // Local copy of decals, taken as fast as possible to not block the P&R. + if (decalsChanged) { + for (auto bel : ctx_->getBels()) { + belDecals.push_back(ctx_->getBelDecal(bel)); + } + for (auto wire : ctx_->getWires()) { + wireDecals.push_back(ctx_->getWireDecal(wire)); + } + for (auto pip : ctx_->getPips()) { + pipDecals.push_back(ctx_->getPipDecal(pip)); + } + for (auto group : ctx_->getGroups()) { + groupDecals.push_back(ctx_->getGroupDecal(group)); + } } } - ctx_->unlock_ui(); - rendererArgsLock_.lock(); - auto selectedItems = rendererArgs_->selectedItems; - auto highlightedItems = rendererArgs_->highlightedItems; - auto highlightedOrSelectedChanged = rendererArgs_->highlightedOrSelectedChanged; - rendererArgs_->highlightedOrSelectedChanged = false; - rendererArgsLock_.unlock(); + // Arguments from the main UI thread on what we should render. + std::vector selectedDecals; + std::vector highlightedDecals[8]; + bool highlightedOrSelectedChanged; + { + // Take the renderer arguments lock, copy over all we need. + QMutexLocker lock(&rendererArgsLock_); + selectedDecals = rendererArgs_->selectedDecals; + for (int i = 0; i < 8; i++) + highlightedDecals[i] = rendererArgs_->highlightedDecals[i]; + highlightedOrSelectedChanged = rendererArgs_->highlightedOrSelectedChanged; + rendererArgs_->highlightedOrSelectedChanged = false; + } + // Render decals if necessary. if (decalsChanged) { auto data = std::unique_ptr(new FPGAViewWidget::RendererData); // Draw Bels. for (auto const &decal : belDecals) { - drawDecal(data->decals, decal); + drawArchDecal(data->gfxByStyle, decal); } // Draw Wires. for (auto const &decal : wireDecals) { - drawDecal(data->decals, decal); + drawArchDecal(data->gfxByStyle, decal); } // Draw Pips. for (auto const &decal : pipDecals) { - drawDecal(data->decals, decal); + drawArchDecal(data->gfxByStyle, decal); } // Draw Groups. for (auto const &decal : groupDecals) { - drawDecal(data->decals, decal); + drawArchDecal(data->gfxByStyle, decal); } // Swap over. - rendererDataLock_.lock(); - rendererData_ = std::move(data); - rendererDataLock_.unlock(); + { + QMutexLocker lock(&rendererDataLock_); + + // If we're not re-rendering any highlights/selections, let's + // copy them over from teh current object. + if (!highlightedOrSelectedChanged) { + data->gfxSelected = rendererData_->gfxSelected; + for (int i = 0; i < 8; i++) + data->gfxHighlighted[i] = rendererData_->gfxHighlighted[i]; + } + + rendererData_ = std::move(data); + } } - rendererDataLock_.lock(); - if (decalsChanged || highlightedOrSelectedChanged) { - rendererData_->selected.clear(); - for (auto &decal : selectedItems) { - drawDecal(rendererData_->selected, decal); + if (highlightedOrSelectedChanged) { + QMutexLocker locker(&rendererDataLock_); + + // Render selected. + rendererData_->gfxSelected.clear(); + for (auto &decal : selectedDecals) { + drawDecal(rendererData_->gfxSelected, decal); } + + // Render highlighted. for (int i = 0; i < 8; i++) { - rendererData_->highlighted[i].clear(); - for (auto &decal : highlightedItems[i]) { - drawDecal(rendererData_->highlighted[i], decal); + rendererData_->gfxHighlighted[i].clear(); + for (auto &decal : highlightedDecals[i]) { + drawDecal(rendererData_->gfxHighlighted[i], decal); } } } - rendererDataLock_.unlock(); } void FPGAViewWidget::onSelectedArchItem(std::vector decals) { - rendererArgsLock_.lock(); - rendererArgs_->selectedItems = decals; - rendererArgs_->highlightedOrSelectedChanged = true; - rendererArgsLock_.unlock(); + { + QMutexLocker locker(&rendererArgsLock_); + rendererArgs_->selectedDecals = decals; + rendererArgs_->highlightedOrSelectedChanged = true; + } pokeRenderer(); } void FPGAViewWidget::onHighlightGroupChanged(std::vector decals, int group) { - rendererArgsLock_.lock(); - rendererArgs_->highlightedItems[group] = decals; - rendererArgs_->highlightedOrSelectedChanged = true; - rendererArgsLock_.unlock(); + { + QMutexLocker locker(&rendererArgsLock_); + rendererArgs_->highlightedDecals[group] = decals; + rendererArgs_->highlightedOrSelectedChanged = true; + } pokeRenderer(); } diff --git a/gui/fpgaviewwidget.h b/gui/fpgaviewwidget.h index 46231b16..69e947cf 100644 --- a/gui/fpgaviewwidget.h +++ b/gui/fpgaviewwidget.h @@ -277,8 +277,6 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE; void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE; void wheelEvent(QWheelEvent *event) Q_DECL_OVERRIDE; - void drawDecal(LineShaderData &data, const DecalXY &decal); - void drawDecal(LineShaderData out[], const DecalXY &decal); public Q_SLOTS: void newContext(Context *ctx); @@ -291,6 +289,9 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions void zoomOutbound(); private: + void drawGraphicElement(LineShaderData &out, const GraphicElement &el, float x, float y); + void drawArchDecal(LineShaderData out[GraphicElement::STYLE_MAX], const DecalXY &decal); + void drawDecal(LineShaderData &out, const DecalXY &decal); void renderLines(void); void zoom(int level); @@ -326,15 +327,15 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions struct RendererData { - LineShaderData decals[4]; - LineShaderData selected; - LineShaderData highlighted[8]; + LineShaderData gfxByStyle[GraphicElement::STYLE_MAX]; + LineShaderData gfxSelected; + LineShaderData gfxHighlighted[8]; }; struct RendererArgs { - std::vector selectedItems; - std::vector highlightedItems[8]; + std::vector selectedDecals; + std::vector highlightedDecals[8]; bool highlightedOrSelectedChanged; }; -- cgit v1.2.3 From ba5395d89fea3a0a646d9bf3df643dac8c8bdec4 Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Thu, 26 Jul 2018 17:33:19 +0100 Subject: gui: refactor FPGAViewWidget even more slightly --- gui/fpgaviewwidget.cc | 16 +++++++++------- gui/fpgaviewwidget.h | 40 +++++++++++++++++++--------------------- 2 files changed, 28 insertions(+), 28 deletions(-) (limited to 'gui') diff --git a/gui/fpgaviewwidget.cc b/gui/fpgaviewwidget.cc index 2211c93b..d87c26a3 100644 --- a/gui/fpgaviewwidget.cc +++ b/gui/fpgaviewwidget.cc @@ -242,9 +242,11 @@ void LineShader::draw(const LineShaderData &line, const QColor &color, float thi vao_.release(); } -FPGAViewWidget::FPGAViewWidget(QWidget *parent) - : QOpenGLWidget(parent), lineShader_(this), zoom_(500.f), ctx_(nullptr), paintTimer_(this), - rendererData_(new FPGAViewWidget::RendererData), rendererArgs_(new FPGAViewWidget::RendererArgs) +FPGAViewWidget::FPGAViewWidget(QWidget *parent) : + QOpenGLWidget(parent), ctx_(nullptr), paintTimer_(this), + lineShader_(this), zoom_(500.0f), + rendererData_(new FPGAViewWidget::RendererData), + rendererArgs_(new FPGAViewWidget::RendererArgs) { colors_.background = QColor("#000000"); colors_.grid = QColor("#333"); @@ -562,7 +564,7 @@ void FPGAViewWidget::onHighlightGroupChanged(std::vector decals, int gr void FPGAViewWidget::resizeGL(int width, int height) {} -void FPGAViewWidget::mousePressEvent(QMouseEvent *event) { lastPos_ = event->pos(); } +void FPGAViewWidget::mousePressEvent(QMouseEvent *event) { lastDragPos_ = event->pos(); } // Invert the projection matrix to calculate screen/mouse to world/grid // coordinates. @@ -578,9 +580,9 @@ QVector4D FPGAViewWidget::mouseToWorldCoordinates(int x, int y) void FPGAViewWidget::mouseMoveEvent(QMouseEvent *event) { - const int dx = event->x() - lastPos_.x(); - const int dy = event->y() - lastPos_.y(); - lastPos_ = event->pos(); + const int dx = event->x() - lastDragPos_.x(); + const int dy = event->y() - lastDragPos_.y(); + lastDragPos_ = event->pos(); auto world = mouseToWorldCoordinates(dx, dy); viewMove_.translate(world.x(), -world.y()); diff --git a/gui/fpgaviewwidget.h b/gui/fpgaviewwidget.h index 69e947cf..6505c555 100644 --- a/gui/fpgaviewwidget.h +++ b/gui/fpgaviewwidget.h @@ -267,16 +267,17 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions FPGAViewWidget(QWidget *parent = 0); ~FPGAViewWidget(); - QSize minimumSizeHint() const override; - QSize sizeHint() const override; - protected: + // Qt callbacks. void initializeGL() Q_DECL_OVERRIDE; void paintGL() Q_DECL_OVERRIDE; void resizeGL(int width, int height) Q_DECL_OVERRIDE; void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE; void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE; void wheelEvent(QWheelEvent *event) Q_DECL_OVERRIDE; + QSize minimumSizeHint() const override; + QSize sizeHint() const override; + public Q_SLOTS: void newContext(Context *ctx); @@ -289,30 +290,20 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions void zoomOutbound(); private: - void drawGraphicElement(LineShaderData &out, const GraphicElement &el, float x, float y); - void drawArchDecal(LineShaderData out[GraphicElement::STYLE_MAX], const DecalXY &decal); - void drawDecal(LineShaderData &out, const DecalXY &decal); - void renderLines(void); - void zoom(int level); - - QPoint lastPos_; - LineShader lineShader_; - QMatrix4x4 viewMove_; - float zoom_; - QMatrix4x4 getProjection(void); - QVector4D mouseToWorldCoordinates(int x, int y); - const float zoomNear_ = 1.0f; // do not zoom closer than this const float zoomFar_ = 10000.0f; // do not zoom further than this - const float zoomLvl1_ = 100.0f; const float zoomLvl2_ = 50.0f; Context *ctx_; QTimer paintTimer_; - std::unique_ptr renderRunner_; + QPoint lastDragPos_; + LineShader lineShader_; + QMatrix4x4 viewMove_; + float zoom_; + struct { QColor background; @@ -331,6 +322,8 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions LineShaderData gfxSelected; LineShaderData gfxHighlighted[8]; }; + std::unique_ptr rendererData_; + QMutex rendererDataLock_; struct RendererArgs { @@ -338,11 +331,16 @@ class FPGAViewWidget : public QOpenGLWidget, protected QOpenGLFunctions std::vector highlightedDecals[8]; bool highlightedOrSelectedChanged; }; - - std::unique_ptr rendererData_; - QMutex rendererDataLock_; std::unique_ptr rendererArgs_; QMutex rendererArgsLock_; + + void zoom(int level); + void renderLines(void); + void drawGraphicElement(LineShaderData &out, const GraphicElement &el, float x, float y); + void drawDecal(LineShaderData &out, const DecalXY &decal); + void drawArchDecal(LineShaderData out[GraphicElement::STYLE_MAX], const DecalXY &decal); + QVector4D mouseToWorldCoordinates(int x, int y); + QMatrix4x4 getProjection(void); }; NEXTPNR_NAMESPACE_END -- cgit v1.2.3 From 16acc6ea43f4c45dfb0e9550d731a2fba3f32618 Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Thu, 26 Jul 2018 17:37:24 +0100 Subject: gui: move polyline/lineshader to gui/lineshader.{h,cc} --- gui/fpgaviewwidget.cc | 211 -------------------------------------------------- gui/fpgaviewwidget.h | 175 +---------------------------------------- 2 files changed, 1 insertion(+), 385 deletions(-) (limited to 'gui') diff --git a/gui/fpgaviewwidget.cc b/gui/fpgaviewwidget.cc index d87c26a3..de73e27b 100644 --- a/gui/fpgaviewwidget.cc +++ b/gui/fpgaviewwidget.cc @@ -31,217 +31,6 @@ NEXTPNR_NAMESPACE_BEGIN -void PolyLine::buildPoint(LineShaderData *building, const QVector2D *prev, const QVector2D *cur, - const QVector2D *next) const -{ - // buildPoint emits two vertices per line point, along with normals to move - // them the right directio when rendering and miter to compensate for - // bends. - - if (cur == nullptr) { - // BUG - return; - } - - if (prev == nullptr && next == nullptr) { - // BUG - return; - } - - // TODO(q3k): fast path for vertical/horizontal lines? - - // TODO(q3k): consider moving some of the linear algebra to the GPU, - // they're better at this than poor old CPUs. - - // Build two unit vectors pointing in the direction of the two segments - // defined by (prev, cur) and (cur, next) - QVector2D dprev, dnext; - if (prev == nullptr) { - dnext = *next - *cur; - dprev = dnext; - } else if (next == nullptr) { - dprev = *cur - *prev; - dnext = dprev; - } else { - dprev = *cur - *prev; - dnext = *next - *cur; - } - dprev.normalize(); - dnext.normalize(); - - // Calculate tangent unit vector. - QVector2D tangent(dprev + dnext); - tangent.normalize(); - - // Calculate normal to tangent - this is the line on which the vectors need - // to be pushed to build a thickened line. - const QVector2D tangent_normal = QVector2D(-tangent.y(), tangent.x()); - - // Calculate normal to one of the lines. - const QVector2D dprev_normal = QVector2D(-dprev.y(), dprev.x()); - // https://people.eecs.berkeley.edu/~sequin/CS184/IMGS/Sweep_PolyLine.jpg - // (the ^-1 is performed in the shader) - const float miter = QVector2D::dotProduct(tangent_normal, dprev_normal); - - const float x = cur->x(); - const float y = cur->y(); - const float mx = tangent_normal.x(); - const float my = tangent_normal.y(); - - // Push back 'left' vertex. - building->vertices.push_back(Vertex2DPOD(x, y)); - building->normals.push_back(Vertex2DPOD(mx, my)); - building->miters.push_back(miter); - - // Push back 'right' vertex. - building->vertices.push_back(Vertex2DPOD(x, y)); - building->normals.push_back(Vertex2DPOD(mx, my)); - building->miters.push_back(-miter); -} - -void PolyLine::build(LineShaderData &target) const -{ - if (points_.size() < 2) { - return; - } - const QVector2D *first = &points_.front(); - const QVector2D *last = &points_.back(); - - // Index number of vertices, used to build the index buffer. - unsigned int startIndex = target.vertices.size(); - unsigned int index = startIndex; - - // For every point on the line, call buildPoint with (prev, point, next). - // If we're building a closed line, prev/next wrap around. Otherwise - // they are passed as nullptr and buildPoint interprets that accordinglu. - const QVector2D *prev = nullptr; - - // Loop iterator used to ensure next is valid. - unsigned int i = 0; - for (const QVector2D &point : points_) { - const QVector2D *next = nullptr; - if (++i < points_.size()) { - next = (&point + 1); - } - - // If the line is closed, wrap around. Otherwise, pass nullptr. - if (prev == nullptr && closed_) { - buildPoint(&target, last, &point, next); - } else if (next == nullptr && closed_) { - buildPoint(&target, prev, &point, first); - } else { - buildPoint(&target, prev, &point, next); - } - - // If we have a prev point relative to cur, build a pair of triangles - // to render vertices into lines. - if (prev != nullptr) { - target.indices.push_back(index); - target.indices.push_back(index + 1); - target.indices.push_back(index + 2); - - target.indices.push_back(index + 2); - target.indices.push_back(index + 1); - target.indices.push_back(index + 3); - - index += 2; - } - prev = &point; - } - - // If we're closed, build two more vertices that loop the line around. - if (closed_) { - target.indices.push_back(index); - target.indices.push_back(index + 1); - target.indices.push_back(startIndex); - - target.indices.push_back(startIndex); - target.indices.push_back(index + 1); - target.indices.push_back(startIndex + 1); - } -} - -bool LineShader::compile(void) -{ - program_ = new QOpenGLShaderProgram(parent_); - program_->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource_); - program_->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource_); - if (!program_->link()) { - printf("could not link program: %s\n", program_->log().toStdString().c_str()); - return false; - } - - if (!vao_.create()) - log_abort(); - vao_.bind(); - - if (!buffers_.position.create()) - log_abort(); - if (!buffers_.normal.create()) - log_abort(); - if (!buffers_.miter.create()) - log_abort(); - if (!buffers_.index.create()) - log_abort(); - - attributes_.position = program_->attributeLocation("position"); - attributes_.normal = program_->attributeLocation("normal"); - attributes_.miter = program_->attributeLocation("miter"); - uniforms_.thickness = program_->uniformLocation("thickness"); - uniforms_.projection = program_->uniformLocation("projection"); - uniforms_.color = program_->uniformLocation("color"); - - vao_.release(); - return true; -} - -void LineShader::draw(const LineShaderData &line, const QColor &color, float thickness, const QMatrix4x4 &projection) -{ - auto gl = QOpenGLContext::currentContext()->functions(); - if (line.vertices.size() == 0) - return; - vao_.bind(); - program_->bind(); - - buffers_.position.bind(); - buffers_.position.allocate(&line.vertices[0], sizeof(Vertex2DPOD) * line.vertices.size()); - - buffers_.normal.bind(); - buffers_.normal.allocate(&line.normals[0], sizeof(Vertex2DPOD) * line.normals.size()); - - buffers_.miter.bind(); - buffers_.miter.allocate(&line.miters[0], sizeof(GLfloat) * line.miters.size()); - - buffers_.index.bind(); - buffers_.index.allocate(&line.indices[0], sizeof(GLuint) * line.indices.size()); - - program_->setUniformValue(uniforms_.projection, projection); - program_->setUniformValue(uniforms_.thickness, thickness); - program_->setUniformValue(uniforms_.color, color.redF(), color.greenF(), color.blueF(), color.alphaF()); - - buffers_.position.bind(); - program_->enableAttributeArray("position"); - gl->glVertexAttribPointer(attributes_.position, 2, GL_FLOAT, GL_FALSE, 0, (void *)0); - - buffers_.normal.bind(); - program_->enableAttributeArray("normal"); - gl->glVertexAttribPointer(attributes_.normal, 2, GL_FLOAT, GL_FALSE, 0, (void *)0); - - buffers_.miter.bind(); - program_->enableAttributeArray("miter"); - gl->glVertexAttribPointer(attributes_.miter, 1, GL_FLOAT, GL_FALSE, 0, (void *)0); - - buffers_.index.bind(); - gl->glDrawElements(GL_TRIANGLES, line.indices.size(), GL_UNSIGNED_INT, (void *)0); - - program_->disableAttributeArray("miter"); - program_->disableAttributeArray("normal"); - program_->disableAttributeArray("position"); - - program_->release(); - vao_.release(); -} - FPGAViewWidget::FPGAViewWidget(QWidget *parent) : QOpenGLWidget(parent), ctx_(nullptr), paintTimer_(this), lineShader_(this), zoom_(500.0f), diff --git a/gui/fpgaviewwidget.h b/gui/fpgaviewwidget.h index 6505c555..260ebf05 100644 --- a/gui/fpgaviewwidget.h +++ b/gui/fpgaviewwidget.h @@ -33,183 +33,10 @@ #include #include "nextpnr.h" +#include "lineshader.h" NEXTPNR_NAMESPACE_BEGIN -// Vertex2DPOD is a structure of X, Y coordinates that can be passed to OpenGL -// directly. -NPNR_PACKED_STRUCT(struct Vertex2DPOD { - GLfloat x; - GLfloat y; - - Vertex2DPOD(GLfloat X, GLfloat Y) : x(X), y(Y) {} -}); - -// LineShaderData is a built set of vertices that can be rendered by the -// LineShader. -// Each LineShaderData can have its' own color and thickness. -struct LineShaderData -{ - std::vector vertices; - std::vector normals; - std::vector miters; - std::vector indices; - - LineShaderData(void) {} - - void clear(void) - { - vertices.clear(); - normals.clear(); - miters.clear(); - indices.clear(); - } -}; - -// PolyLine is a set of segments defined by points, that can be built to a -// ShaderLine for GPU rendering. -class PolyLine -{ - private: - std::vector points_; - bool closed_; - - void buildPoint(LineShaderData *building, const QVector2D *prev, const QVector2D *cur, const QVector2D *next) const; - - public: - // Create an empty PolyLine. - PolyLine(bool closed = false) : closed_(closed) {} - - // Create a non-closed polyline consisting of one segment. - PolyLine(float x0, float y0, float x1, float y1) : closed_(false) - { - point(x0, y0); - point(x1, y1); - } - - // Add a point to the PolyLine. - void point(float x, float y) { points_.push_back(QVector2D(x, y)); } - - // Built PolyLine to shader data. - void build(LineShaderData &target) const; - - // Set whether line is closed (ie. a loop). - void setClosed(bool closed) { closed_ = closed; } -}; - -// LineShader is an OpenGL shader program that renders LineShaderData on the -// GPU. -// The LineShader expects two vertices per line point. It will push those -// vertices along the given normal * miter. This is used to 'stretch' the line -// to be as wide as the given thickness. The normal and miter are calculated -// by the PolyLine build method in order to construct a constant thickness line -// with miter edge joints. -// -// +------+------+ -// -// | -// PolyLine.build() -// | -// V -// -// ^ ^ ^ -// | | | <--- normal vectors (x2, pointing in the same -// +/+----+/+----+/+ direction) -// -// | -// vertex shader -// | -// V -// -// +------+------+ ^ by normal * miter * thickness/2 -// | | | -// +------+------+ V by normal * miter * thickness/2 -// -// (miter is flipped for every second vertex generated) -class LineShader -{ - private: - QObject *parent_; - QOpenGLShaderProgram *program_; - - // GL attribute locations. - struct - { - // original position of line vertex - GLuint position; - // normal by which vertex should be translated - GLuint normal; - // scalar defining: - // - how stretched the normal vector should be to - // compensate for bends - // - which way the normal should be applied (+1 for one vertex, -1 - // for the other) - GLuint miter; - } attributes_; - - // GL buffers - struct - { - QOpenGLBuffer position; - QOpenGLBuffer normal; - QOpenGLBuffer miter; - QOpenGLBuffer index; - } buffers_; - - // GL uniform locations. - struct - { - // combines m/v/p matrix to apply - GLuint projection; - // desired thickness of line - GLuint thickness; - // color of line - GLuint color; - } uniforms_; - - QOpenGLVertexArrayObject vao_; - - public: - LineShader(QObject *parent) : parent_(parent), program_(nullptr) - { - buffers_.position = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); - buffers_.position.setUsagePattern(QOpenGLBuffer::StaticDraw); - - buffers_.normal = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); - buffers_.normal.setUsagePattern(QOpenGLBuffer::StaticDraw); - - buffers_.miter = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); - buffers_.miter.setUsagePattern(QOpenGLBuffer::StaticDraw); - - buffers_.index = QOpenGLBuffer(QOpenGLBuffer::IndexBuffer); - buffers_.index.setUsagePattern(QOpenGLBuffer::StaticDraw); - } - - static constexpr const char *vertexShaderSource_ = - "#version 110\n" - "attribute highp vec2 position;\n" - "attribute highp vec2 normal;\n" - "attribute highp float miter;\n" - "uniform highp float thickness;\n" - "uniform highp mat4 projection;\n" - "void main() {\n" - " vec2 p = position.xy + vec2(normal * thickness/2.0 / miter);\n" - " gl_Position = projection * vec4(p, 0.0, 1.0);\n" - "}\n"; - - static constexpr const char *fragmentShaderSource_ = "#version 110\n" - "uniform lowp vec4 color;\n" - "void main() {\n" - " gl_FragColor = color;\n" - "}\n"; - - // Must be called on initialization. - bool compile(void); - - // Render a LineShaderData with a given M/V/P transformation. - void draw(const LineShaderData &data, const QColor &color, float thickness, const QMatrix4x4 &projection); -}; - class PeriodicRunner : public QThread { Q_OBJECT -- cgit v1.2.3 From ae6eeb9d810c647ca1684459627b8dd20870f993 Mon Sep 17 00:00:00 2001 From: Sergiusz Bazanski Date: Thu, 26 Jul 2018 17:39:22 +0100 Subject: gui: include linshader.{cc,h} --- gui/lineshader.cc | 236 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ gui/lineshader.h | 209 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 445 insertions(+) create mode 100644 gui/lineshader.cc create mode 100644 gui/lineshader.h (limited to 'gui') diff --git a/gui/lineshader.cc b/gui/lineshader.cc new file mode 100644 index 00000000..94a7a010 --- /dev/null +++ b/gui/lineshader.cc @@ -0,0 +1,236 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2018 Serge Bazanski + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "log.h" +#include "lineshader.h" + +NEXTPNR_NAMESPACE_BEGIN + +void PolyLine::buildPoint(LineShaderData *building, const QVector2D *prev, const QVector2D *cur, + const QVector2D *next) const +{ + // buildPoint emits two vertices per line point, along with normals to move + // them the right directio when rendering and miter to compensate for + // bends. + + if (cur == nullptr) { + // BUG + return; + } + + if (prev == nullptr && next == nullptr) { + // BUG + return; + } + + // TODO(q3k): fast path for vertical/horizontal lines? + + // TODO(q3k): consider moving some of the linear algebra to the GPU, + // they're better at this than poor old CPUs. + + // Build two unit vectors pointing in the direction of the two segments + // defined by (prev, cur) and (cur, next) + QVector2D dprev, dnext; + if (prev == nullptr) { + dnext = *next - *cur; + dprev = dnext; + } else if (next == nullptr) { + dprev = *cur - *prev; + dnext = dprev; + } else { + dprev = *cur - *prev; + dnext = *next - *cur; + } + dprev.normalize(); + dnext.normalize(); + + // Calculate tangent unit vector. + QVector2D tangent(dprev + dnext); + tangent.normalize(); + + // Calculate normal to tangent - this is the line on which the vectors need + // to be pushed to build a thickened line. + const QVector2D tangent_normal = QVector2D(-tangent.y(), tangent.x()); + + // Calculate normal to one of the lines. + const QVector2D dprev_normal = QVector2D(-dprev.y(), dprev.x()); + // https://people.eecs.berkeley.edu/~sequin/CS184/IMGS/Sweep_PolyLine.jpg + // (the ^-1 is performed in the shader) + const float miter = QVector2D::dotProduct(tangent_normal, dprev_normal); + + const float x = cur->x(); + const float y = cur->y(); + const float mx = tangent_normal.x(); + const float my = tangent_normal.y(); + + // Push back 'left' vertex. + building->vertices.push_back(Vertex2DPOD(x, y)); + building->normals.push_back(Vertex2DPOD(mx, my)); + building->miters.push_back(miter); + + // Push back 'right' vertex. + building->vertices.push_back(Vertex2DPOD(x, y)); + building->normals.push_back(Vertex2DPOD(mx, my)); + building->miters.push_back(-miter); +} + +void PolyLine::build(LineShaderData &target) const +{ + if (points_.size() < 2) { + return; + } + const QVector2D *first = &points_.front(); + const QVector2D *last = &points_.back(); + + // Index number of vertices, used to build the index buffer. + unsigned int startIndex = target.vertices.size(); + unsigned int index = startIndex; + + // For every point on the line, call buildPoint with (prev, point, next). + // If we're building a closed line, prev/next wrap around. Otherwise + // they are passed as nullptr and buildPoint interprets that accordinglu. + const QVector2D *prev = nullptr; + + // Loop iterator used to ensure next is valid. + unsigned int i = 0; + for (const QVector2D &point : points_) { + const QVector2D *next = nullptr; + if (++i < points_.size()) { + next = (&point + 1); + } + + // If the line is closed, wrap around. Otherwise, pass nullptr. + if (prev == nullptr && closed_) { + buildPoint(&target, last, &point, next); + } else if (next == nullptr && closed_) { + buildPoint(&target, prev, &point, first); + } else { + buildPoint(&target, prev, &point, next); + } + + // If we have a prev point relative to cur, build a pair of triangles + // to render vertices into lines. + if (prev != nullptr) { + target.indices.push_back(index); + target.indices.push_back(index + 1); + target.indices.push_back(index + 2); + + target.indices.push_back(index + 2); + target.indices.push_back(index + 1); + target.indices.push_back(index + 3); + + index += 2; + } + prev = &point; + } + + // If we're closed, build two more vertices that loop the line around. + if (closed_) { + target.indices.push_back(index); + target.indices.push_back(index + 1); + target.indices.push_back(startIndex); + + target.indices.push_back(startIndex); + target.indices.push_back(index + 1); + target.indices.push_back(startIndex + 1); + } +} + +bool LineShader::compile(void) +{ + program_ = new QOpenGLShaderProgram(parent_); + program_->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource_); + program_->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource_); + if (!program_->link()) { + printf("could not link program: %s\n", program_->log().toStdString().c_str()); + return false; + } + + if (!vao_.create()) + log_abort(); + vao_.bind(); + + if (!buffers_.position.create()) + log_abort(); + if (!buffers_.normal.create()) + log_abort(); + if (!buffers_.miter.create()) + log_abort(); + if (!buffers_.index.create()) + log_abort(); + + attributes_.position = program_->attributeLocation("position"); + attributes_.normal = program_->attributeLocation("normal"); + attributes_.miter = program_->attributeLocation("miter"); + uniforms_.thickness = program_->uniformLocation("thickness"); + uniforms_.projection = program_->uniformLocation("projection"); + uniforms_.color = program_->uniformLocation("color"); + + vao_.release(); + return true; +} + +void LineShader::draw(const LineShaderData &line, const QColor &color, float thickness, const QMatrix4x4 &projection) +{ + auto gl = QOpenGLContext::currentContext()->functions(); + if (line.vertices.size() == 0) + return; + vao_.bind(); + program_->bind(); + + buffers_.position.bind(); + buffers_.position.allocate(&line.vertices[0], sizeof(Vertex2DPOD) * line.vertices.size()); + + buffers_.normal.bind(); + buffers_.normal.allocate(&line.normals[0], sizeof(Vertex2DPOD) * line.normals.size()); + + buffers_.miter.bind(); + buffers_.miter.allocate(&line.miters[0], sizeof(GLfloat) * line.miters.size()); + + buffers_.index.bind(); + buffers_.index.allocate(&line.indices[0], sizeof(GLuint) * line.indices.size()); + + program_->setUniformValue(uniforms_.projection, projection); + program_->setUniformValue(uniforms_.thickness, thickness); + program_->setUniformValue(uniforms_.color, color.redF(), color.greenF(), color.blueF(), color.alphaF()); + + buffers_.position.bind(); + program_->enableAttributeArray("position"); + gl->glVertexAttribPointer(attributes_.position, 2, GL_FLOAT, GL_FALSE, 0, (void *)0); + + buffers_.normal.bind(); + program_->enableAttributeArray("normal"); + gl->glVertexAttribPointer(attributes_.normal, 2, GL_FLOAT, GL_FALSE, 0, (void *)0); + + buffers_.miter.bind(); + program_->enableAttributeArray("miter"); + gl->glVertexAttribPointer(attributes_.miter, 1, GL_FLOAT, GL_FALSE, 0, (void *)0); + + buffers_.index.bind(); + gl->glDrawElements(GL_TRIANGLES, line.indices.size(), GL_UNSIGNED_INT, (void *)0); + + program_->disableAttributeArray("miter"); + program_->disableAttributeArray("normal"); + program_->disableAttributeArray("position"); + + program_->release(); + vao_.release(); +} + +NEXTPNR_NAMESPACE_END diff --git a/gui/lineshader.h b/gui/lineshader.h new file mode 100644 index 00000000..3f4c4057 --- /dev/null +++ b/gui/lineshader.h @@ -0,0 +1,209 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2018 Serge Bazanski + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef LINESHADER_H +#define LINESHADER_H + +#include +#include +#include +#include +#include + +#include "nextpnr.h" + +NEXTPNR_NAMESPACE_BEGIN + +// Vertex2DPOD is a structure of X, Y coordinates that can be passed to OpenGL +// directly. +NPNR_PACKED_STRUCT(struct Vertex2DPOD { + GLfloat x; + GLfloat y; + + Vertex2DPOD(GLfloat X, GLfloat Y) : x(X), y(Y) {} +}); + +// LineShaderData is a built set of vertices that can be rendered by the +// LineShader. +// Each LineShaderData can have its' own color and thickness. +struct LineShaderData +{ + std::vector vertices; + std::vector normals; + std::vector miters; + std::vector indices; + + LineShaderData(void) {} + + void clear(void) + { + vertices.clear(); + normals.clear(); + miters.clear(); + indices.clear(); + } +}; + +// PolyLine is a set of segments defined by points, that can be built to a +// ShaderLine for GPU rendering. +class PolyLine +{ + private: + std::vector points_; + bool closed_; + + void buildPoint(LineShaderData *building, const QVector2D *prev, const QVector2D *cur, const QVector2D *next) const; + + public: + // Create an empty PolyLine. + PolyLine(bool closed = false) : closed_(closed) {} + + // Create a non-closed polyline consisting of one segment. + PolyLine(float x0, float y0, float x1, float y1) : closed_(false) + { + point(x0, y0); + point(x1, y1); + } + + // Add a point to the PolyLine. + void point(float x, float y) { points_.push_back(QVector2D(x, y)); } + + // Built PolyLine to shader data. + void build(LineShaderData &target) const; + + // Set whether line is closed (ie. a loop). + void setClosed(bool closed) { closed_ = closed; } +}; + +// LineShader is an OpenGL shader program that renders LineShaderData on the +// GPU. +// The LineShader expects two vertices per line point. It will push those +// vertices along the given normal * miter. This is used to 'stretch' the line +// to be as wide as the given thickness. The normal and miter are calculated +// by the PolyLine build method in order to construct a constant thickness line +// with miter edge joints. +// +// +------+------+ +// +// | +// PolyLine.build() +// | +// V +// +// ^ ^ ^ +// | | | <--- normal vectors (x2, pointing in the same +// +/+----+/+----+/+ direction) +// +// | +// vertex shader +// | +// V +// +// +------+------+ ^ by normal * miter * thickness/2 +// | | | +// +------+------+ V by normal * miter * thickness/2 +// +// (miter is flipped for every second vertex generated) +class LineShader +{ + private: + QObject *parent_; + QOpenGLShaderProgram *program_; + + // GL attribute locations. + struct + { + // original position of line vertex + GLuint position; + // normal by which vertex should be translated + GLuint normal; + // scalar defining: + // - how stretched the normal vector should be to + // compensate for bends + // - which way the normal should be applied (+1 for one vertex, -1 + // for the other) + GLuint miter; + } attributes_; + + // GL buffers + struct + { + QOpenGLBuffer position; + QOpenGLBuffer normal; + QOpenGLBuffer miter; + QOpenGLBuffer index; + } buffers_; + + // GL uniform locations. + struct + { + // combines m/v/p matrix to apply + GLuint projection; + // desired thickness of line + GLuint thickness; + // color of line + GLuint color; + } uniforms_; + + QOpenGLVertexArrayObject vao_; + + public: + LineShader(QObject *parent) : parent_(parent), program_(nullptr) + { + buffers_.position = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); + buffers_.position.setUsagePattern(QOpenGLBuffer::StaticDraw); + + buffers_.normal = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); + buffers_.normal.setUsagePattern(QOpenGLBuffer::StaticDraw); + + buffers_.miter = QOpenGLBuffer(QOpenGLBuffer::VertexBuffer); + buffers_.miter.setUsagePattern(QOpenGLBuffer::StaticDraw); + + buffers_.index = QOpenGLBuffer(QOpenGLBuffer::IndexBuffer); + buffers_.index.setUsagePattern(QOpenGLBuffer::StaticDraw); + } + + static constexpr const char *vertexShaderSource_ = + "#version 110\n" + "attribute highp vec2 position;\n" + "attribute highp vec2 normal;\n" + "attribute highp float miter;\n" + "uniform highp float thickness;\n" + "uniform highp mat4 projection;\n" + "void main() {\n" + " vec2 p = position.xy + vec2(normal * thickness/2.0 / miter);\n" + " gl_Position = projection * vec4(p, 0.0, 1.0);\n" + "}\n"; + + static constexpr const char *fragmentShaderSource_ = "#version 110\n" + "uniform lowp vec4 color;\n" + "void main() {\n" + " gl_FragColor = color;\n" + "}\n"; + + // Must be called on initialization. + bool compile(void); + + // Render a LineShaderData with a given M/V/P transformation. + void draw(const LineShaderData &data, const QColor &color, float thickness, const QMatrix4x4 &projection); +}; + +NEXTPNR_NAMESPACE_END + +#endif -- cgit v1.2.3