Horizon
canvas3d.hpp
1 #pragma once
2 #include "background.hpp"
3 #include "canvas/canvas_patch.hpp"
4 #include "canvas/appearance.hpp"
5 #include "clipper/clipper.hpp"
6 #include "common/common.hpp"
7 #include "util/msd_animator.hpp"
8 #include "cover.hpp"
9 #include "face.hpp"
10 #include "wall.hpp"
11 #include <epoxy/gl.h>
12 #include <glm/glm.hpp>
13 #include <gtkmm.h>
14 #include <unordered_map>
15 
16 namespace horizon {
17 class Canvas3D : public Gtk::GLArea, public CanvasPatch {
18 public:
19  friend CoverRenderer;
20  friend WallRenderer;
21  friend FaceRenderer;
22  friend BackgroundRenderer;
23  Canvas3D();
24 
25  float cam_azimuth = 90;
26  float cam_elevation = 45;
27  float cam_distance = 20;
28  float cam_fov = 45;
29 
30  float far;
31  float near;
32 
33  float explode = 0;
34  Color solder_mask_color = {0, .5, 0};
35  Color substrate_color = {.2, .15, 0};
36  bool show_solder_mask = true;
37  bool show_silkscreen = true;
38  bool show_substrate = true;
39  bool show_models = true;
40  bool show_solder_paste = true;
41  bool use_layer_colors = false;
42  bool smooth_zoom = false;
43  float highlight_intensity = .5;
44 
45  Color background_top_color;
46  Color background_bottom_color;
47 
48  void request_push() override;
49  void update2(const class Board &brd);
50  void prepare();
51  void update_packages();
52  void set_highlights(const std::set<UUID> &pkgs);
53  enum class Projection { PERSP, ORTHO };
54  Projection projection = Projection::PERSP;
55  void inc_cam_azimuth(float v);
56  void set_appearance(const Appearance &a);
57 
58  void set_msaa(unsigned int samples);
59 
60  void load_models_async(class Pool *pool);
61 
62  void view_all();
63 
64  void clear_3d_models();
65 
66  typedef sigc::signal<void, bool> type_signal_models_loading;
67  type_signal_models_loading signal_models_loading()
68  {
69  return s_signal_models_loading;
70  }
71 
72  class Layer3D {
73  public:
74  class Vertex {
75  public:
76  Vertex(float ix, float iy) : x(ix), y(iy)
77  {
78  }
79 
80  float x, y;
81  };
82  std::vector<Vertex> tris;
83  std::vector<Vertex> walls;
84  float offset = 0;
85  float thickness = 0.035;
86  float alpha = 1;
87  float explode_mul = 0;
88  };
89 
90  class FaceVertex {
91  public:
92  FaceVertex(float ix, float iy, float iz, uint8_t ir, uint8_t ig, uint8_t ib)
93  : x(ix), y(iy), z(iz), r(ir), g(ig), b(ib), _pad(0)
94  {
95  }
96  float x;
97  float y;
98  float z;
99 
100  uint8_t r;
101  uint8_t g;
102  uint8_t b;
103  uint8_t _pad;
104  } __attribute__((packed));
105 
107  public:
108  ModelTransform(float ix, float iy, float a, bool flip, bool highlight)
109  : x(ix), y(iy), angle(a), flags(flip | (highlight << 1))
110  {
111  }
112  float x;
113  float y;
114  uint16_t angle;
115  uint16_t flags;
116 
117  float model_x = 0;
118  float model_y = 0;
119  float model_z = 0;
120  uint16_t model_roll = 0;
121  uint16_t model_pitch = 0;
122  uint16_t model_yaw = 0;
123  } __attribute__((packed));
124 
125  int _animate_step(GdkFrameClock *frame_clock);
126 
127 private:
128  float width;
129  float height;
130  void push() override;
131  bool needs_push = false;
132  bool needs_view_all = false;
133 
134  CoverRenderer cover_renderer;
135  WallRenderer wall_renderer;
136  FaceRenderer face_renderer;
137  BackgroundRenderer background_renderer;
138 
139  Appearance appearance;
140 
141  void on_size_allocate(Gtk::Allocation &alloc) override;
142  void on_realize() override;
143  bool on_render(const Glib::RefPtr<Gdk::GLContext> &context) override;
144  bool on_button_press_event(GdkEventButton *button_event) override;
145  bool on_motion_notify_event(GdkEventMotion *motion_event) override;
146  bool on_button_release_event(GdkEventButton *button_event) override;
147  bool on_scroll_event(GdkEventScroll *scroll_event) override;
148 
149  glm::vec2 pointer_pos_orig;
150  float cam_azimuth_orig;
151  float cam_elevation_orig;
152 
153  glm::vec2 center;
154  glm::vec2 center_orig;
155  glm::vec3 cam_normal;
156 
157  std::pair<glm::vec3, glm::vec3> bbox;
158  float package_height_max = 0;
159 
160  enum class PanMode { NONE, MOVE, ROTATE };
161  PanMode pan_mode = PanMode::NONE;
162 
163  glm::mat4 viewmat;
164  glm::mat4 projmat;
165 
166  MSDAnimator zoom_animator;
167  float zoom_animation_cam_dist_orig = 1;
168 
169  GLuint renderbuffer;
170  GLuint fbo;
171  GLuint depthrenderbuffer;
172  unsigned int num_samples = 1;
173  bool needs_resize = false;
174 
175  void resize_buffers();
176 
177  void polynode_to_tris(const ClipperLib::PolyNode *node, int layer);
178 
179  void prepare_layer(int layer);
180  void prepare_soldermask(int layer);
181  void prepare_packages();
182  float get_layer_offset(int layer);
183  const class Board *brd = nullptr;
184  void add_path(int layer, const ClipperLib::Path &path);
185  bool layer_is_visible(int layer) const;
186  Color get_layer_color(int layer) const;
187  float get_layer_thickness(int layer) const;
188 
189  void load_3d_model(const std::string &filename, const std::string &filename_abs);
190  void load_models_thread(std::map<std::string, std::string> model_filenames);
191 
192  std::set<UUID> packages_highlight;
193 
194  std::unordered_map<int, Layer3D> layers;
195 
196  std::mutex models_loading_mutex;
197  std::vector<FaceVertex> face_vertex_buffer; // vertices of all models, sequentially
198  std::vector<unsigned int> face_index_buffer; // indexes face_vertex_buffer to form triangles
199  std::map<std::string, std::pair<size_t, size_t>> models; // key: filename value: first: offset in face_index_buffer
200  // second: no of indexes
201  Glib::Dispatcher models_loading_dispatcher;
202 
203  std::vector<ModelTransform> package_transforms; // position and rotation of
204  // all board packages,
205  // grouped by package
206  std::map<std::string, std::pair<size_t, size_t>>
207  package_transform_idxs; // key: model filename: value: first: offset
208  // in package_transforms second: no of items
209 
210  type_signal_models_loading s_signal_models_loading;
211 };
212 } // namespace horizon
libzip::uint8_t
zip_uint8_t uint8_t
zip_uint8_t typedef.
Definition: zip.hpp:78
horizon::Canvas3D::Layer3D
Definition: canvas3d.hpp:72
horizon::CanvasPatch
Definition: canvas_patch.hpp:6
horizon::Canvas3D
Definition: canvas3d.hpp:17
horizon::MSDAnimator
Definition: msd_animator.hpp:5
horizon::Canvas3D::FaceVertex
Definition: canvas3d.hpp:90
horizon::Board
Definition: board.hpp:31
horizon::Canvas3D::Layer3D::Vertex
Definition: canvas3d.hpp:74
horizon::CoverRenderer
Definition: cover.hpp:6
libzip::uint16_t
zip_uint16_t uint16_t
zip_uint16_t typedef.
Definition: zip.hpp:88
horizon::Color
Definition: common.hpp:213
horizon::FaceRenderer
Definition: face.hpp:6
horizon::BackgroundRenderer
Definition: background.hpp:5
ClipperLib::PolyNode
Definition: clipper.hpp:135
horizon::Appearance
Definition: appearance.hpp:7
horizon::WallRenderer
Definition: wall.hpp:6
horizon::Canvas3D::ModelTransform
Definition: canvas3d.hpp:106
horizon::Pool
Stores objects (Unit, Entity, Symbol, Part, etc.) from the pool.
Definition: pool.hpp:21