imp: add canvas rotation

closes #417

Author: carrotIndustries

Makefile

@@ -480,6 +480,7 @@ SRC_IMP = \
 	src/util/zmq_helper.cpp\
 	src/widgets/help_button.cpp\
 	src/util/keep_slope_util.cpp\
+	src/imp/view_angle_window.cpp\
 
 SRC_IMPC = \
 	3rd_party/footag/wiz.c\

src/canvas/canvas.hpp

@@ -71,6 +71,11 @@ class Canvas {
         return false;
     };
 
+    virtual float get_view_angle() const
+    {
+        return 0;
+    }
+
     std::pair<Coordf, Coordf> get_bbox(bool visible_only = true) const;
 
     static const int first_overlay_layer = 30000;

src/canvas/canvas_gl.cpp

@@ -414,29 +414,30 @@ void CanvasGL::request_push(PushFilter filter)
     queue_draw();
 }
 
-void CanvasGL::center_and_zoom(const Coordi &center, float sc)
+void CanvasGL::center_and_zoom(const Coordf &center, float sc)
 {
     // we want center to be at width, height/2
     if (sc > 0)
         scale = sc;
-    offset.x = -((center.x * (flip_view ? -1 : 1) * scale) - m_width / 2);
-    offset.y = -((center.y * -scale) - m_height / 2);
+    const Coordf m(m_width / 2, m_height / 2);
+    const auto c = canvas2screen(center);
+    offset -= (c - m);
     update_viewmat();
     s_signal_scale_changed.emit();
     queue_draw();
 }
 
-void CanvasGL::zoom_to_bbox(const Coordf &a, const Coordf &b)
+void CanvasGL::zoom_to_bbox(const Coordf &a_a, const Coordf &a_b)
 {
+    Placement tr;
+    tr.set_angle_rad(view_angle);
+    auto [a, b] = tr.transform_bb(std::make_pair(a_a, a_b));
     auto sc_x = m_width / abs(a.x - b.x);
     auto sc_y = m_height / abs(a.y - b.y);
     scale = std::min(sc_x, sc_y);
-    auto center = (a + b) / 2;
-    offset.x = -((center.x * (flip_view ? -1 : 1) * scale) - m_width / 2);
-    offset.y = -((center.y * -scale) - m_height / 2);
+    auto center = (a_a + a_b) / 2;
     update_viewmat();
-    s_signal_scale_changed.emit();
-    queue_draw();
+    center_and_zoom(center, scale);
 }
 
 void CanvasGL::zoom_to_bbox(const std::pair<Coordf, Coordf> &bb)
@@ -467,7 +468,8 @@ void CanvasGL::update_viewmat()
     auto scale_x = scale;
     if (flip_view)
         scale_x = -scale;
-    viewmat = glm::scale(glm::translate(glm::mat3(1), glm::vec2(offset.x, offset.y)), glm::vec2(scale_x, -scale));
+    viewmat = glm::scale(glm::rotate(glm::translate(glm::mat3(1), glm::vec2(offset.x, offset.y)), -view_angle),
+                         glm::vec2(scale_x, -scale));
     viewmat_noflip = glm::scale(glm::translate(glm::mat3(1), glm::vec2(offset.x, offset.y)), glm::vec2(scale, -scale));
 }
 
@@ -499,22 +501,51 @@ void CanvasGL::set_flip_view(bool fl)
     auto toggled = fl != flip_view;
     flip_view = fl;
     if (toggled) {
-        offset.x = m_width - offset.x;
+        // mirror offset at vertical (angle 0) line at view angle through viewport center
+        const Coordf m(m_width / 2, m_height / 2);
+        const Coordf p = offset;
+        const Coordf l(sin(view_angle), cos(view_angle));
+        const auto u = l.dot(p) - l.dot(m);
+        const auto pc = m + l * u;
+        const auto pm = pc * 2 - p;
+        offset = pm;
     }
     update_viewmat();
 }
 
+void CanvasGL::set_view_angle(float angle)
+{
+    const auto delta = angle - view_angle;
+    const Coordf m(m_width / 2, m_height / 2);
+    const auto o = offset - m;
+    const auto o2 = o.rotate(-delta);
+    offset += (o2 - o);
+    view_angle = angle;
+    update_viewmat();
+}
+
 bool CanvasGL::get_flip_view() const
 {
     return flip_view;
 }
 
+float CanvasGL::get_view_angle() const
+{
+    return view_angle;
+}
+
 Coordf CanvasGL::screen2canvas(const Coordf &p) const
 {
     auto cp = glm::inverse(viewmat) * glm::vec3(p.x, p.y, 1);
     return {cp.x, cp.y};
 }
 
+Coordf CanvasGL::canvas2screen(const Coordf &p) const
+{
+    auto cp = viewmat * glm::vec3(p.x, p.y, 1);
+    return {cp.x, cp.y};
+}
+
 std::set<SelectableRef> CanvasGL::get_selection()
 {
     std::set<SelectableRef> r;

src/canvas/canvas_gl.hpp

@@ -68,6 +68,9 @@ class CanvasGL : public Canvas, public Gtk::GLArea {
     void set_flip_view(bool fl);
     bool get_flip_view() const override;
 
+    void set_view_angle(float a);
+    float get_view_angle() const override;
+
     void set_cursor_size(float size);
     void set_cursor_size(Appearance::CursorSize);
 
@@ -118,7 +121,7 @@ class CanvasGL : public Canvas, public Gtk::GLArea {
         return s_signal_scale_changed;
     }
 
-    void center_and_zoom(const Coordi &center, float scale = -1);
+    void center_and_zoom(const Coordf &center, float scale = -1);
     void zoom_to_bbox(const Coordf &a, const Coordf &b);
     void zoom_to_bbox(const std::pair<Coordf, Coordf> &bb);
     void ensure_min_size(float w, float h);
@@ -204,7 +207,9 @@ class CanvasGL : public Canvas, public Gtk::GLArea {
     glm::mat3 viewmat;
     glm::mat3 viewmat_noflip;
     bool flip_view = false;
+    float view_angle = 0;
     void update_viewmat();
+    Coordf canvas2screen(const Coordf &p) const;
 
     Coord<float> cursor_pos;
     Coord<int64_t> cursor_pos_grid;

src/canvas/drag_selection.cpp

@@ -4,6 +4,7 @@
 #include "common/layer_provider.hpp"
 #include "common/object_descr.hpp"
 #include "gl_util.hpp"
+#include "util/util.hpp"
 #include <glm/gtc/type_ptr.hpp>
 
 namespace horizon {
@@ -387,48 +388,66 @@ void DragSelection::drag_end(GdkEventButton *button_event)
     }
 }
 
+static ClipperLib::IntPoint to_pt(const Coordf &p)
+{
+    return ClipperLib::IntPoint(p.x, p.y);
+}
+
 void DragSelection::Box::update()
 {
-    float xmin = std::min(sel_a.x, sel_b.x);
-    float xmax = std::max(sel_a.x, sel_b.x);
-    float ymin = std::min(sel_a.y, sel_b.y);
-    float ymax = std::max(sel_a.y, sel_b.y);
+    const auto sel_center = (sel_a + sel_b) / 2;
+    const auto sel_a_screen = ca.canvas2screen(sel_a);
+    const auto sel_b_screen = ca.canvas2screen(sel_b);
+    const auto sel_width = std::abs(sel_b_screen.x - sel_a_screen.x) / ca.scale;
+    const auto sel_height = std::abs(sel_b_screen.y - sel_a_screen.y) / ca.scale;
+    const auto sel_angle = (ca.flip_view ? -1 : 1) * ca.view_angle;
+    auto in_box = [sel_center, sel_width, sel_height, sel_angle](Coordf p) {
+        p -= sel_center;
+        p = p.rotate(sel_angle);
+        return std::abs(p.x) < sel_width / 2 && std::abs(p.y) < sel_height / 2;
+    };
+    auto sq = ca.selection_qualifier;
+
+    if (sq == CanvasGL::SelectionQualifier::AUTO) {
+        if (sel_a_screen.x < sel_b_screen.x)
+            sq = CanvasGL::SelectionQualifier::INCLUDE_BOX;
+        else
+            sq = CanvasGL::SelectionQualifier::TOUCH_BOX;
+    }
+
+    ClipperLib::Path clbox(4);
+    if (sq == CanvasGL::SelectionQualifier::TOUCH_BOX) {
+        const auto sz1 = Coordf(sel_width / 2, sel_height / 2).rotate(-sel_angle);
+        const auto sz2 = Coordf(sel_width / 2, sel_height / -2).rotate(-sel_angle);
+        clbox.at(0) = to_pt(sel_center + sz1);
+        clbox.at(1) = to_pt(sel_center + sz2);
+        clbox.at(2) = to_pt(sel_center - sz1);
+        clbox.at(3) = to_pt(sel_center - sz2);
+    }
+
     unsigned int i = 0;
     for (auto &it : ca.selectables.items) {
         it.set_flag(Selectable::Flag::PRELIGHT, false);
         if (ca.selection_filter.can_select(ca.selectables.items_ref[i])) {
-            auto sq = ca.selection_qualifier;
 
-            if (sq == CanvasGL::SelectionQualifier::AUTO) {
-                if (sel_a.x < sel_b.x)
-                    sq = CanvasGL::SelectionQualifier::INCLUDE_BOX;
-                else
-                    sq = CanvasGL::SelectionQualifier::TOUCH_BOX;
-            }
 
             if (sq == CanvasGL::SelectionQualifier::INCLUDE_ORIGIN) {
-                if (it.x > xmin && it.x < xmax && it.y > ymin && it.y < ymax) {
+                if (in_box({it.x, it.y})) {
                     it.set_flag(Selectable::Flag::PRELIGHT, true);
                 }
                 fill = true;
             }
             else if (sq == CanvasGL::SelectionQualifier::INCLUDE_BOX) {
                 auto corners = it.get_corners();
-                if (std::all_of(corners.begin(), corners.end(), [xmin, xmax, ymin, ymax](const auto &a) {
-                        return a.x > xmin && a.x < xmax && a.y > ymin && a.y < ymax;
+                if (std::all_of(corners.begin(), corners.end(), [in_box](const auto &a) {
+                        return in_box({a.x, a.y});
                     })) {
                     it.set_flag(Selectable::Flag::PRELIGHT, true);
                 }
                 fill = false;
             }
             else if (sq == CanvasGL::SelectionQualifier::TOUCH_BOX) {
                 // possible optimisation: don't use clipper
-                ClipperLib::Path clbox(4);
-                clbox.at(0) = ClipperLib::IntPoint(xmin, ymin);
-                clbox.at(1) = ClipperLib::IntPoint(xmin, ymax);
-                clbox.at(2) = ClipperLib::IntPoint(xmax, ymax);
-                clbox.at(3) = ClipperLib::IntPoint(xmax, ymin);
-
                 ClipperLib::Path sel(4);
                 auto corners = it.get_corners();
                 for (size_t j = 0; j < 4; j++) {

src/canvas/grid.cpp

@@ -2,6 +2,7 @@
 #include "canvas_gl.hpp"
 #include "gl_util.hpp"
 #include <glm/gtc/type_ptr.hpp>
+#include "util/bbox_accumulator.hpp"
 
 namespace horizon {
 Grid::Grid(const CanvasGL &c) : ca(c), spacing(1.25_mm, 1.25_mm), mark_size(5)
@@ -53,15 +54,17 @@ void Grid::realize()
     GET_LOC(this, grid_mod);
     GET_LOC(this, mark_size);
     GET_LOC(this, color);
+    GET_LOC(this, angle);
 }
 
 void Grid::render()
 {
     glUseProgram(program);
     glBindVertexArray(vao);
     glUniformMatrix3fv(screenmat_loc, 1, GL_FALSE, glm::value_ptr(ca.screenmat));
-    glUniformMatrix3fv(viewmat_loc, 1, GL_FALSE, glm::value_ptr(ca.viewmat_noflip));
+    glUniformMatrix3fv(viewmat_loc, 1, GL_FALSE, glm::value_ptr(ca.viewmat));
     glUniform1f(mark_size_loc, mark_size);
+    glUniform1f(angle_loc, ca.view_angle);
     auto color = ca.get_color(ColorP::GRID);
     glUniform4f(color_loc, color.r, color.g, color.b, ca.appearance.grid_opacity);
 
@@ -74,9 +77,17 @@ void Grid::render()
         sp_px = sp * ca.scale;
     }
 
+    BBoxAccumulator<Coordf::type> acc;
+    for (const auto x : {0.f, ca.m_width}) {
+        for (const auto y : {0.f, ca.m_height}) {
+            acc.accumulate(ca.screen2canvas({x, y}));
+        }
+    }
+    const auto [a, b] = acc.get();
+
     Coord<float> grid_0;
-    grid_0.x = (round(((-ca.offset.x / ca.scale) - origin.x) / sp.x) - 1) * sp.x + origin.x;
-    grid_0.y = (round(((-(ca.m_height - ca.offset.y) / ca.scale) - origin.y) / sp.y) - 1) * sp.y + origin.y;
+    grid_0.x = (round((a.x - origin.x) / sp.x) - 1) * sp.x + origin.x;
+    grid_0.y = (round((a.y - origin.y) / sp.y) - 1) * sp.y + origin.y;
 
     if (mul != newmul) {
         mul = newmul;
@@ -89,20 +100,20 @@ void Grid::render()
     auto spmin = std::min(sp.x, sp.y);
     glLineWidth(1 * ca.get_scale_factor());
     if (mark_size > 100) {
-        glUniform1f(mark_size_loc, ca.m_height * 2);
-        int n = (ca.m_width / ca.scale) / spmin + 4;
+        glUniform1f(mark_size_loc, (b.y - a.y) * ca.scale * 2);
+        int n = (b.x - a.x) / spmin + 4;
         glUniform1i(grid_mod_loc, n + 1);
         glDrawArraysInstanced(GL_LINES, 0, 2, n);
 
-        glUniform1f(mark_size_loc, ca.m_width * 2);
-        n = (ca.m_height / ca.scale) / spmin + 4;
+        glUniform1f(mark_size_loc, (b.x - a.x) * ca.scale * 2);
+        n = (b.y - a.y) / spmin + 4;
         glUniform1i(grid_mod_loc, 1);
         glDrawArraysInstanced(GL_LINES, 2, 2, n);
     }
     else {
-        int mod = ceil((ca.m_width / ca.scale) / spmin) + 2;
+        int mod = ceil((b.x - a.x) / spmin) + 2;
         glUniform1i(grid_mod_loc, mod);
-        int n = mod * ceil((ca.m_height / ca.scale) / spmin + 2);
+        int n = mod * ceil((b.y - a.y) / spmin + 2);
         glDrawArraysInstanced(GL_LINES, 0, 4, n);
     }
 
@@ -138,6 +149,7 @@ void Grid::render_cursor(Coord<int64_t> &coord)
     glUniform2f(grid_size_loc, 0, 0);
     glUniform2f(grid_0_loc, coord.x, coord.y);
     glUniform1i(grid_mod_loc, 1);
+    glUniform1f(angle_loc, 0);
 
     auto bgcolor = ca.get_color(ColorP::BACKGROUND);
     glUniform4f(color_loc, bgcolor.r, bgcolor.g, bgcolor.b, 1);

src/canvas/grid.hpp

@@ -33,5 +33,6 @@ class Grid {
     GLuint grid_mod_loc;
     GLuint mark_size_loc;
     GLuint color_loc;
+    GLuint angle_loc;
 };
 } // namespace horizon

src/canvas/render.cpp

@@ -282,8 +282,12 @@ void Canvas::render(const Track &track, bool interactive)
         set_lod_size(width);
         auto vec = (track.from.get_position() - track.to.get_position());
         auto length = sqrt(vec.mag_sq());
-        Placement p(center);
-        p.set_angle_rad(atan2(vec.y, vec.x));
+        Placement p;
+        p.set_angle_rad(get_view_angle());
+        if (get_flip_view())
+            p.invert_angle();
+        p.accumulate(Placement(center));
+        p.set_angle_rad(p.get_angle_rad() + atan2(vec.y, vec.x));
         if (get_flip_view()) {
             p.shift.x *= -1;
             p.invert_angle();
@@ -1126,7 +1130,17 @@ void Canvas::render_pad_overlay(const Pad &pad)
         text_layer = get_overlay_layer({BoardLayers::TOP_COPPER, BoardLayers::BOTTOM_COPPER}, true);
     }
 
-    Placement tr = transform;
+    Placement tr;
+    tr.set_angle_rad(get_view_angle());
+    if (get_flip_view())
+        tr.invert_angle();
+    {
+        Placement tr2 = transform;
+        if (tr2.mirror)
+            tr2.invert_angle();
+        tr2.mirror = false;
+        tr.accumulate(tr2);
+    }
     if (get_flip_view()) {
         tr.shift.x *= -1;
         tr.invert_angle();
@@ -1295,9 +1309,15 @@ void Canvas::render(const Via &via, bool interactive)
     if (show_text_in_vias && interactive && via.junction->net && via.junction->net->name.size()) {
         auto size = (bb.second.x - bb.first.x) * 1.2;
         set_lod_size(size);
-        Placement p(via.junction->position);
+        Placement p;
+        p.set_angle_rad(get_view_angle());
         if (get_flip_view())
+            p.invert_angle();
+        p.accumulate(Placement(via.junction->position));
+        if (get_flip_view()) {
             p.shift.x *= -1;
+        }
+        p.set_angle(0);
         const auto ol = get_overlay_layer({BoardLayers::BOTTOM_COPPER, BoardLayers::TOP_COPPER}, true);
         draw_bitmap_text_box(p, size, size, via.junction->net->name, ColorP::TEXT_OVERLAY, ol, TextBoxMode::FULL);
         set_lod_size(-1);