diff -r c7241f504117 -r 6d95c1a41e6e src/document.cpp --- a/src/document.cpp Mon Jun 13 02:18:25 2022 +0300 +++ b/src/document.cpp Tue Jun 14 17:55:50 2022 +0300 @@ -17,65 +17,193 @@ */ #include -#include -#include +#include #include "document.h" #include "model.h" #include "ui/objecteditor.h" +#include "gl/partrenderer.h" -EditTools::EditTools( - Model* model, - const ColorTable& colorTable, - QObject* parent) : +EditTools::EditTools(QObject* parent) : QObject{parent}, - colorTable{colorTable}, - model{model}, - vertexMap{model} + RenderLayer{} { -#if 0 - connect(this->canvas, &Canvas::mouseClick, this, &EditTools::canvasMouseClick); - connect(this->canvas, &Canvas::mouseMove, this, &EditTools::canvasMouseMove); - connect(this->canvas, &Canvas::newStatusText, this, &EditTools::newStatusText); - connect(this->model, &Model::dataChanged, this->canvas, qOverload<>(&Canvas::update)); - connect(&this->vertexMap, &VertexMap::verticesChanged, [&]() - { - this->canvas->rebuildVertices(&this->vertexMap); - }); - this->canvas->drawState = &this->drawState; -#endif } EditTools::~EditTools() { } -void EditTools::applyToVertices(VertexMap::ApplyFunction fn) const -{ - this->vertexMap.apply(fn); -} - void EditTools::setEditMode(EditingMode mode) { - this->drawState.mode = mode; + this->mode = mode; +} + +void EditTools::setGridMatrix(const glm::mat4& gridMatrix) +{ + this->gridMatrix = gridMatrix; + this->gridPlane = planeFromTriangle({ + this->gridMatrix * glm::vec4{0, 0, 0, 1}, + this->gridMatrix * glm::vec4{1, 0, 0, 1}, + this->gridMatrix * glm::vec4{0, 1, 0, 1}, + }); +} + +void EditTools::mvpMatrixChanged(const glm::mat4& matrix) +{ + this->mvpMatrix = matrix; +} + +void EditTools::mouseMoved(const QMouseEvent* event) +{ + this->worldPosition = this->renderer->screenToModelCoordinates(event->pos(), this->gridPlane); + if (this->worldPosition.has_value()) + { + // Snap the position to grid. This procedure is basically the "change of basis" and almost follows the + // A⁻¹ × M × A formula which is used to perform a transformation in some other coordinate system, except + // we actually use the inverted matrix first and the regular one last to perform the transformation of + // grid coordinates in our XY coordinate system. Also, we're rounding the coordinates which is obviously + // not a linear transformation, but fits the pattern anyway. + // First transform the coordinates to the XY plane... + this->worldPosition = glm::inverse(this->gridMatrix) * glm::vec4{*this->worldPosition, 1}; + // Then round the coordinates to integer precision... + this->worldPosition = glm::round(*this->worldPosition); + // And finally transform it back to grid coordinates by transforming it with the + // grid matrix. + this->worldPosition = this->gridMatrix * glm::vec4{*this->worldPosition, 1}; + } + this->updatePreviewPolygon(); +} + +static QVector convertWorldPointsToScreenPoints( + const std::vector &worldPoints, + const PartRenderer* renderer) +{ + QVector points2d; + points2d.reserve(worldPoints.size()); + for (const glm::vec3& point : worldPoints) + { + points2d.push_back(renderer->modelToScreenCoordinates(point)); + } + return points2d; +} + +static Winding worldPolygonWinding( + const std::vector &points, + const PartRenderer* renderer) +{ + return winding(QPolygonF{convertWorldPointsToScreenPoints(points, renderer)}); +} + +static void drawWorldPoint( + QPainter* painter, + const glm::vec3& worldPoint, + const PartRenderer* renderer) +{ + const QPointF center = renderer->modelToScreenCoordinates(worldPoint); + painter->drawEllipse(inscribe(CircleF{center, 5})); } -void updatePreviewPolygon(DrawState* drawState) +static void drawWorldPolyline( + QPainter *painter, + const std::vector &points, + const PartRenderer* renderer) +{ + painter->drawPolyline(QPolygonF{convertWorldPointsToScreenPoints(points, renderer)}); +} + +static void drawWorldPolygon( + QPainter* painter, + const std::vector &points, + const PartRenderer* renderer) +{ + painter->drawPolygon(QPolygonF{convertWorldPointsToScreenPoints(points, renderer)}); +} + +void EditTools::overpaint(QPainter* painter) { - drawState->previewPolygon = drawState->polygon; - drawState->previewPolygon.resize(drawState->polygon.size() + 1); - drawState->previewPolygon.back() = drawState->previewPoint; - if (drawState->previewPolygon.size() > 2) + struct Pens { - drawState->isconcave = not isConvex(drawState->previewPolygon); + const QBrush pointBrush; + const QPen pointPen; + const QPen polygonPen; + const QPen badPolygonPen; + const QBrush greenPolygonBrush; + const QBrush redPolygonBrush; + }; + static const Pens brightPens{ + .pointBrush = {Qt::white}, + .pointPen = {QBrush{Qt::black}, 2.0}, + .polygonPen = {QBrush{Qt::black}, 2.0, Qt::DashLine}, + .badPolygonPen = {QBrush{Qt::red}, 2.0, Qt::DashLine}, + .greenPolygonBrush = {QColor{64, 255, 128, 192}}, + .redPolygonBrush = {QColor{255, 96, 96, 192}}, + }; + static const Pens darkPens{ + .pointBrush = {Qt::black}, + .pointPen = {QBrush{Qt::white}, 2.0}, + .polygonPen = {QBrush{Qt::white}, 2.0, Qt::DashLine}, + .badPolygonPen = {QBrush{Qt::red}, 2.0, Qt::DashLine}, + .greenPolygonBrush = {QColor{64, 255, 128, 192}}, + .redPolygonBrush = {QColor{255, 96, 96, 192}}, + }; + const Pens& pens = (this->renderer->isDark() ? darkPens : brightPens); + switch(this->mode) { + case SelectMode: + break; + case DrawMode: + { + painter->setPen(this->isconcave ? pens.badPolygonPen : pens.polygonPen); + if (this->previewPolygon.size() > 2 and not this->isconcave) + { + if (worldPolygonWinding(this->previewPolygon, this->renderer) == Winding::Clockwise) { + painter->setBrush(pens.greenPolygonBrush); + } + else { + painter->setBrush(pens.redPolygonBrush); + } + drawWorldPolygon(painter, this->previewPolygon, this->renderer); + } + else { + drawWorldPolyline(painter, this->previewPolygon, this->renderer); + } + painter->setBrush(pens.pointBrush); + painter->setPen(pens.pointPen); + for (const glm::vec3& point : this->polygon) { + drawWorldPoint(painter, point, this->renderer); + } + } + break; + } + if (this->worldPosition.has_value()) + { + painter->setRenderHint(QPainter::Antialiasing); + painter->setPen(Qt::white); + painter->setBrush(Qt::green); + const QPointF pos = this->renderer->modelToScreenCoordinates(*this->worldPosition); + painter->drawEllipse(pos, 5, 5); + painter->drawText(pos + QPointF{5, 5}, vectorToString(*this->worldPosition)); } } -void removeLastPoint(DrawState* drawState) +void EditTools::updatePreviewPolygon() { - if (drawState->polygon.size() > 0) + this->previewPolygon = this->polygon; + if (this->worldPosition.has_value()) { + this->previewPolygon.resize(this->polygon.size() + 1); + this->previewPolygon.back() = *this->worldPosition; + } + if (this->previewPolygon.size() > 2) { - drawState->polygon.erase(drawState->polygon.end() - 1); - updatePreviewPolygon(drawState); + this->isconcave = not isConvex(this->previewPolygon); + } +} + +void EditTools::removeLastPoint() +{ + if (this->polygon.size() > 0) + { + this->polygon.erase(this->polygon.end() - 1); + this->updatePreviewPolygon(); } } @@ -84,106 +212,51 @@ return any(points, std::bind(isclose, std::placeholders::_1, pos)); } -void EditTools::canvasMouseClick(QMouseEvent*) +EditingMode EditTools::currentEditingMode() const { -#if 0 - switch(this->drawState.mode) - { + return this->mode; +} + +void EditTools::mouseClick(const QMouseEvent* event) +{ + switch(this->mode) { case SelectMode: - if (event->button() == Qt::LeftButton) - { - const ModelId highlighted = this->canvas->getHighlightedObject(); - QSet selected; - if (highlighted != ModelId{0}) { - selected.insert(highlighted); - } - //this->select(selected); - event->accept(); + if (event->button() == Qt::LeftButton) { + const ModelId highlighted = this->renderer->pick(event->pos()); + Q_EMIT this->select({highlighted}, false); } break; case DrawMode: - if (event->button() == Qt::LeftButton) { - if (isCloseToExistingPoints(this->drawState.polygon, worldPosition)) { + if (event->button() == Qt::LeftButton and this->worldPosition.has_value()) { + if (isCloseToExistingPoints(this->polygon, *this->worldPosition)) { this->closeShape(); } else { - this->drawState.polygon.push_back(pos); - updatePreviewPolygon(&this->drawState); + this->polygon.push_back(*this->worldPosition); + this->updatePreviewPolygon(); } - event->accept(); } else if (true and event->button() == Qt::RightButton - and this->drawState.polygon.size() > 0 + and this->polygon.size() > 0 ) { - this->drawState.polygon.erase(this->drawState.polygon.end() - 1); - updatePreviewPolygon(&this->drawState); - event->accept(); + this->polygon.erase(this->polygon.end() - 1); + updatePreviewPolygon(); } break; } -#endif } -void EditTools::canvasMouseMove(QMouseEvent*) -{ -#if 0 - switch(this->drawState.mode) - { - case SelectMode: - break; - case DrawMode: - if (this->canvas->worldPosition.has_value()) - { - this->drawState.previewPoint = this->canvas->worldPosition.value(); - updatePreviewPolygon(&this->drawState); - this->update(); - } - event->accept(); - break; - } -#endif -} -#if 0 -/* -void EditorTabWidget::select(const QSet &selected) -{ - QItemSelectionModel* selectionModel = this->ui.listView->selectionModel(); - QItemSelection itemSelection; - for (const ModelId id : selected) - { - const std::optional row = this->model->find(id); - if (row.has_value()) - { - const QModelIndex qindex = this->model->index(*row); - itemSelection.select(qindex, qindex); - } - } - selectionModel->select(itemSelection, QItemSelectionModel::ClearAndSelect); -} -*/ -const QSet EditTools::selectedObjects() const -{ - return this->canvas->selectedObjects(); -} -#endif -EditingMode EditTools::currentEditingMode() const -{ - return this->drawState.mode; -} -#if 0 void EditTools::closeShape() { - if (this->drawState.polygon.size() >= 2 and this->drawState.polygon.size() <= 4) - { - switch (this->drawState.polygon.size()) - { + if (this->polygon.size() >= 2 and this->polygon.size() <= 4) { + switch (this->polygon.size()) { case 2: Q_EMIT this->modelAction(AppendToModel{ .newElement = Colored{ LineSegment{ - .p1 = this->drawState.polygon[0], - .p2 = this->drawState.polygon[1], + .p1 = this->polygon[0], + .p2 = this->polygon[1], }, EDGE_COLOR, } @@ -193,9 +266,9 @@ Q_EMIT this->modelAction(AppendToModel{ .newElement = Colored{ Triangle{ - .p1 = this->drawState.polygon[0], - .p2 = this->drawState.polygon[1], - .p3 = this->drawState.polygon[2], + .p1 = this->polygon[0], + .p2 = this->polygon[1], + .p3 = this->polygon[2], }, MAIN_COLOR, } @@ -205,10 +278,10 @@ Q_EMIT this->modelAction(AppendToModel{ .newElement = Colored{ Quadrilateral{ - .p1 = this->drawState.polygon[0], - .p2 = this->drawState.polygon[1], - .p3 = this->drawState.polygon[2], - .p4 = this->drawState.polygon[3], + .p1 = this->polygon[0], + .p2 = this->polygon[1], + .p3 = this->polygon[2], + .p4 = this->polygon[3], }, MAIN_COLOR, } @@ -216,8 +289,6 @@ break; } } - this->drawState.polygon.clear(); - updatePreviewPolygon(&this->drawState); + this->polygon.clear(); + this->updatePreviewPolygon(); } - -#endif