PrusaSlicer-NonPlainar/src/slic3r/GUI/GLCanvas3D.hpp

965 lines
30 KiB
C++
Raw Normal View History

2018-05-09 08:47:04 +00:00
#ifndef slic3r_GLCanvas3D_hpp_
#define slic3r_GLCanvas3D_hpp_
#include <stddef.h>
2018-05-09 08:47:04 +00:00
2018-09-17 10:15:11 +00:00
#include "3DScene.hpp"
#include "GLToolbar.hpp"
#include "Event.hpp"
2018-05-09 08:47:04 +00:00
2018-10-25 07:35:08 +00:00
#include <wx/timer.h>
2018-10-01 14:48:08 +00:00
class wxWindow;
2018-05-09 08:47:04 +00:00
class wxSizeEvent;
class wxIdleEvent;
class wxKeyEvent;
2018-05-28 13:23:01 +00:00
class wxMouseEvent;
class wxTimerEvent;
class wxPaintEvent;
2018-10-18 13:13:38 +00:00
class wxGLCanvas;
2018-05-09 08:47:04 +00:00
2018-05-09 08:47:04 +00:00
namespace Slic3r {
2018-05-14 12:14:19 +00:00
2018-05-23 07:57:44 +00:00
class GLShader;
2018-05-15 13:38:25 +00:00
class ExPolygon;
class BackgroundSlicingProcess;
2018-05-14 12:14:19 +00:00
2018-05-09 08:47:04 +00:00
namespace GUI {
2018-06-13 07:12:16 +00:00
class GLGizmoBase;
2018-05-15 13:38:25 +00:00
class GeometryBuffer
{
2018-06-11 08:46:32 +00:00
std::vector<float> m_vertices;
std::vector<float> m_tex_coords;
2018-05-15 13:38:25 +00:00
public:
2018-06-11 08:46:32 +00:00
bool set_from_triangles(const Polygons& triangles, float z, bool generate_tex_coords);
2018-05-15 13:38:25 +00:00
bool set_from_lines(const Lines& lines, float z);
2018-06-11 08:46:32 +00:00
const float* get_vertices() const;
const float* get_tex_coords() const;
unsigned int get_vertices_count() const;
2018-05-15 13:38:25 +00:00
};
class Size
{
int m_width;
int m_height;
public:
Size();
Size(int width, int height);
int get_width() const;
void set_width(int width);
int get_height() const;
void set_height(int height);
};
class Rect
{
float m_left;
float m_top;
float m_right;
float m_bottom;
public:
Rect();
Rect(float left, float top, float right, float bottom);
float get_left() const;
void set_left(float left);
float get_top() const;
void set_top(float top);
float get_right() const;
void set_right(float right);
float get_bottom() const;
void set_bottom(float bottom);
};
2018-10-16 14:04:19 +00:00
wxDECLARE_EVENT(EVT_GLCANVAS_OBJECT_SELECT, SimpleEvent);
using Vec2dEvent = Event<Vec2d>;
template <size_t N> using Vec2dsEvent = ArrayEvent<Vec2d, N>;
using Vec3dEvent = Event<Vec3d>;
template <size_t N> using Vec3dsEvent = ArrayEvent<Vec3d, N>;
wxDECLARE_EVENT(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_VIEWPORT_CHANGED, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_RIGHT_CLICK, Vec2dEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_MODEL_UPDATE, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_REMOVE_OBJECT, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_ARRANGE, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_INCREASE_INSTANCES, Event<int>); // data: +1 => increase, -1 => decrease
wxDECLARE_EVENT(EVT_GLCANVAS_INSTANCE_MOVED, SimpleEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_WIPETOWER_MOVED, Vec3dEvent);
wxDECLARE_EVENT(EVT_GLCANVAS_ENABLE_ACTION_BUTTONS, Event<bool>);
wxDECLARE_EVENT(EVT_GLCANVAS_UPDATE_GEOMETRY, Vec3dsEvent<2>);
2018-05-09 08:47:04 +00:00
class GLCanvas3D
{
2018-06-05 08:56:55 +00:00
struct GCodePreviewVolumeIndex
{
enum EType
{
Extrusion,
Travel,
Retraction,
Unretraction,
Shell,
Num_Geometry_Types
};
struct FirstVolume
{
EType type;
unsigned int flag;
// Index of the first volume in a GLVolumeCollection.
unsigned int id;
FirstVolume(EType type, unsigned int flag, unsigned int id) : type(type), flag(flag), id(id) {}
};
std::vector<FirstVolume> first_volumes;
void reset() { first_volumes.clear(); }
};
2018-06-01 13:54:41 +00:00
struct Camera
2018-05-09 08:47:04 +00:00
{
enum EType : unsigned char
{
2018-06-01 13:54:41 +00:00
Unknown,
// Perspective,
2018-06-01 13:54:41 +00:00
Ortho,
Num_types
2018-05-09 08:47:04 +00:00
};
2018-06-01 13:54:41 +00:00
EType type;
float zoom;
float phi;
// float distance;
Vec3d target;
2018-06-01 13:54:41 +00:00
2018-05-14 10:08:23 +00:00
private:
float m_theta;
2018-05-09 08:47:04 +00:00
2018-05-14 10:08:23 +00:00
public:
2018-05-09 08:47:04 +00:00
Camera();
2018-05-14 09:31:58 +00:00
std::string get_type_as_string() const;
2018-05-14 10:08:23 +00:00
float get_theta() const;
void set_theta(float theta);
2018-05-09 08:47:04 +00:00
};
2018-05-14 12:14:19 +00:00
class Bed
{
2018-06-11 08:46:32 +00:00
public:
enum EType : unsigned char
{
MK2,
MK3,
Custom,
Num_Types
};
private:
EType m_type;
2018-05-14 12:14:19 +00:00
Pointfs m_shape;
BoundingBoxf3 m_bounding_box;
2018-05-15 13:38:25 +00:00
Polygon m_polygon;
GeometryBuffer m_triangles;
GeometryBuffer m_gridlines;
2018-06-13 07:12:16 +00:00
mutable GLTexture m_top_texture;
mutable GLTexture m_bottom_texture;
2018-05-14 12:14:19 +00:00
public:
2018-06-11 08:46:32 +00:00
Bed();
bool is_prusa() const;
bool is_custom() const;
2018-05-14 12:14:19 +00:00
const Pointfs& get_shape() const;
// Return true if the bed shape changed, so the calee will update the UI.
bool set_shape(const Pointfs& shape);
2018-05-14 12:14:19 +00:00
const BoundingBoxf3& get_bounding_box() const;
bool contains(const Point& point) const;
Point point_projection(const Point& point) const;
2018-05-14 12:14:19 +00:00
2018-06-11 08:46:32 +00:00
void render(float theta) const;
2018-05-15 13:38:25 +00:00
2018-05-14 12:14:19 +00:00
private:
void _calc_bounding_box();
2018-05-15 13:38:25 +00:00
void _calc_triangles(const ExPolygon& poly);
void _calc_gridlines(const ExPolygon& poly, const BoundingBox& bed_bbox);
2018-06-11 08:46:32 +00:00
EType _detect_type() const;
void _render_mk2(float theta) const;
void _render_mk3(float theta) const;
void _render_prusa(float theta) const;
void _render_custom() const;
static bool _are_equal(const Pointfs& bed_1, const Pointfs& bed_2);
2018-05-14 12:14:19 +00:00
};
2018-06-01 13:54:41 +00:00
struct Axes
2018-05-18 11:02:47 +00:00
{
Vec3d origin;
2018-06-01 13:54:41 +00:00
float length;
2018-05-18 11:02:47 +00:00
Axes();
2018-06-13 11:14:17 +00:00
void render(bool depth_test) const;
2018-05-18 11:02:47 +00:00
};
2018-05-25 12:05:08 +00:00
class Shader
{
GLShader* m_shader;
public:
Shader();
~Shader();
bool init(const std::string& vertex_shader_filename, const std::string& fragment_shader_filename);
bool is_initialized() const;
bool start_using() const;
void stop_using() const;
void set_uniform(const std::string& name, float value) const;
2018-06-21 06:37:04 +00:00
void set_uniform(const std::string& name, const float* matrix) const;
const GLShader* get_shader() const;
2018-05-25 12:05:08 +00:00
private:
void _reset();
};
class LayersEditing
{
public:
enum EState : unsigned char
{
Unknown,
Editing,
Completed,
Num_States
};
private:
bool m_use_legacy_opengl;
bool m_enabled;
2018-05-25 12:05:08 +00:00
Shader m_shader;
unsigned int m_z_texture_id;
2018-06-13 07:12:16 +00:00
mutable GLTexture m_tooltip_texture;
mutable GLTexture m_reset_texture;
public:
2018-06-01 13:54:41 +00:00
EState state;
float band_width;
float strength;
int last_object_id;
float last_z;
unsigned int last_action;
LayersEditing();
~LayersEditing();
2018-05-25 12:05:08 +00:00
bool init(const std::string& vertex_shader_filename, const std::string& fragment_shader_filename);
bool is_allowed() const;
void set_use_legacy_opengl(bool use_legacy_opengl);
2018-05-25 12:05:08 +00:00
bool is_enabled() const;
2018-05-25 12:05:08 +00:00
void set_enabled(bool enabled);
unsigned int get_z_texture_id() const;
void render(const GLCanvas3D& canvas, const PrintObject& print_object, const GLVolume& volume) const;
2018-06-01 13:54:41 +00:00
int get_shader_program_id() const;
2018-05-25 12:05:08 +00:00
static float get_cursor_z_relative(const GLCanvas3D& canvas);
static bool bar_rect_contains(const GLCanvas3D& canvas, float x, float y);
static bool reset_rect_contains(const GLCanvas3D& canvas, float x, float y);
static Rect get_bar_rect_screen(const GLCanvas3D& canvas);
static Rect get_reset_rect_screen(const GLCanvas3D& canvas);
static Rect get_bar_rect_viewport(const GLCanvas3D& canvas);
static Rect get_reset_rect_viewport(const GLCanvas3D& canvas);
private:
2018-05-25 12:05:08 +00:00
bool _is_initialized() const;
void _render_tooltip_texture(const GLCanvas3D& canvas, const Rect& bar_rect, const Rect& reset_rect) const;
2018-06-13 07:12:16 +00:00
void _render_reset_texture(const Rect& reset_rect) const;
void _render_active_object_annotations(const GLCanvas3D& canvas, const GLVolume& volume, const PrintObject& print_object, const Rect& bar_rect) const;
void _render_profile(const PrintObject& print_object, const Rect& bar_rect) const;
};
2018-06-01 13:54:41 +00:00
struct Mouse
2018-05-23 11:56:54 +00:00
{
2018-06-01 13:54:41 +00:00
struct Drag
{
static const Point Invalid_2D_Point;
static const Vec3d Invalid_3D_Point;
2018-05-23 11:56:54 +00:00
2018-06-01 13:54:41 +00:00
Point start_position_2D;
Vec3d start_position_3D;
2018-06-21 06:37:04 +00:00
int move_volume_idx;
2018-05-23 11:56:54 +00:00
2018-06-01 13:54:41 +00:00
public:
Drag();
};
2018-05-23 11:56:54 +00:00
2018-06-01 13:54:41 +00:00
bool dragging;
Vec2d position;
#if ENABLE_GIZMOS_ON_TOP
Vec3d scene_position;
#endif // ENABLE_GIZMOS_ON_TOP
2018-06-01 13:54:41 +00:00
Drag drag;
#if ENABLE_GIZMOS_RESET
bool ignore_up_event;
#endif // ENABLE_GIZMOS_RESET
2018-06-01 13:54:41 +00:00
Mouse();
2018-06-01 13:54:41 +00:00
void set_start_position_2D_as_invalid();
void set_start_position_3D_as_invalid();
bool is_start_position_2D_defined() const;
bool is_start_position_3D_defined() const;
};
public:
class Selection
{
public:
typedef std::set<unsigned int> IndicesList;
enum EMode : unsigned char
{
#if ENABLE_MODELVOLUME_TRANSFORM
Volume,
Instance
#else
Volume,
Instance,
Object
#endif // ENABLE_MODELVOLUME_TRANSFORM
};
2018-10-09 13:56:34 +00:00
enum EType : unsigned char
{
Invalid,
Empty,
WipeTower,
2018-11-06 14:51:33 +00:00
SingleModifier,
MultipleModifier,
SingleVolume,
MultipleVolume,
2018-10-09 13:56:34 +00:00
SingleFullObject,
MultipleFullObject,
2018-10-09 13:56:34 +00:00
SingleFullInstance,
MultipleFullInstance,
2018-10-09 13:56:34 +00:00
Mixed
};
private:
struct VolumeCache
{
private:
#if ENABLE_MODELVOLUME_TRANSFORM
struct TransformCache
{
Vec3d position;
Vec3d rotation;
Vec3d scaling_factor;
Transform3d rotation_matrix;
Transform3d scale_matrix;
TransformCache();
explicit TransformCache(const Geometry::Transformation& transform);
};
TransformCache m_volume;
TransformCache m_instance;
#else
2018-10-09 13:56:34 +00:00
Vec3d m_position;
Vec3d m_rotation;
Vec3d m_scaling_factor;
Transform3d m_rotation_matrix;
Transform3d m_scale_matrix;
#endif // ENABLE_MODELVOLUME_TRANSFORM
public:
#if ENABLE_MODELVOLUME_TRANSFORM
VolumeCache() {}
VolumeCache(const Geometry::Transformation& volume_transform, const Geometry::Transformation& instance_transform);
#else
VolumeCache();
VolumeCache(const Vec3d& position, const Vec3d& rotation, const Vec3d& scaling_factor);
#endif // ENABLE_MODELVOLUME_TRANSFORM
#if ENABLE_MODELVOLUME_TRANSFORM
const Vec3d& get_volume_position() const { return m_volume.position; }
const Vec3d& get_volume_rotation() const { return m_volume.rotation; }
const Vec3d& get_volume_scaling_factor() const { return m_volume.scaling_factor; }
const Transform3d& get_volume_rotation_matrix() const { return m_volume.rotation_matrix; }
const Transform3d& get_volume_scale_matrix() const { return m_volume.scale_matrix; }
const Vec3d& get_instance_position() const { return m_instance.position; }
const Vec3d& get_instance_rotation() const { return m_instance.rotation; }
const Vec3d& get_instance_scaling_factor() const { return m_instance.scaling_factor; }
const Transform3d& get_instance_rotation_matrix() const { return m_instance.rotation_matrix; }
const Transform3d& get_instance_scale_matrix() const { return m_instance.scale_matrix; }
#else
2018-10-09 13:56:34 +00:00
const Vec3d& get_position() const { return m_position; }
const Vec3d& get_rotation() const { return m_rotation; }
const Vec3d& get_scaling_factor() const { return m_scaling_factor; }
const Transform3d& get_rotation_matrix() const { return m_rotation_matrix; }
const Transform3d& get_scale_matrix() const { return m_scale_matrix; }
#endif // ENABLE_MODELVOLUME_TRANSFORM
};
typedef std::map<unsigned int, VolumeCache> VolumesCache;
2018-10-09 13:56:34 +00:00
typedef std::set<int> InstanceIdxsList;
typedef std::map<int, InstanceIdxsList> ObjectIdxsToInstanceIdxsMap;
struct Cache
{
// Cache of GLVolume derived transformation matrices, valid during mouse dragging.
VolumesCache volumes_data;
// Center of the dragged selection, valid during mouse dragging.
Vec3d dragging_center;
// Map from indices of ModelObject instances in Model::objects
// to a set of indices of ModelVolume instances in ModelObject::instances
// Here the index means a position inside the respective std::vector, not ModelID.
2018-10-09 13:56:34 +00:00
ObjectIdxsToInstanceIdxsMap content;
};
// Volumes owned by GLCanvas3D.
GLVolumePtrs* m_volumes;
// Model, not owned.
Model* m_model;
bool m_valid;
EMode m_mode;
2018-10-09 13:56:34 +00:00
EType m_type;
// set of indices to m_volumes
IndicesList m_list;
Cache m_cache;
mutable BoundingBoxf3 m_bounding_box;
mutable bool m_bounding_box_dirty;
public:
Selection();
void set_volumes(GLVolumePtrs* volumes);
2018-10-18 13:13:38 +00:00
Model* get_model() const { return m_model; }
void set_model(Model* model);
EMode get_mode() const { return m_mode; }
void set_mode(EMode mode) { m_mode = mode; }
void add(unsigned int volume_idx, bool as_single_selection = true);
void remove(unsigned int volume_idx);
2018-10-11 06:26:12 +00:00
void add_object(unsigned int object_idx, bool as_single_selection = true);
void remove_object(unsigned int object_idx);
void add_instance(unsigned int object_idx, unsigned int instance_idx, bool as_single_selection = true);
void remove_instance(unsigned int object_idx, unsigned int instance_idx);
void add_volume(unsigned int object_idx, unsigned int volume_idx, int instance_idx, bool as_single_selection = true);
2018-10-11 06:26:12 +00:00
void remove_volume(unsigned int object_idx, unsigned int volume_idx);
2018-11-21 14:28:35 +00:00
void add_all();
// Update the selection based on the map from old indices to new indices after m_volumes changed.
// If the current selection is by instance, this call may select newly added volumes, if they belong to already selected instances.
void volumes_changed(const std::vector<size_t> &map_volume_old_to_new);
void clear();
2018-10-09 13:56:34 +00:00
bool is_empty() const { return m_type == Empty; }
bool is_wipe_tower() const { return m_type == WipeTower; }
2018-11-06 14:51:33 +00:00
bool is_modifier() const { return (m_type == SingleModifier) || (m_type == MultipleModifier); }
2018-11-12 07:54:22 +00:00
bool is_single_modifier() const { return m_type == SingleModifier; }
2018-10-09 13:56:34 +00:00
bool is_single_full_instance() const;
bool is_multiple_full_instance() const { return m_type == MultipleFullInstance; }
2018-10-09 13:56:34 +00:00
bool is_single_full_object() const { return m_type == SingleFullObject; }
bool is_multiple_full_object() const { return m_type == MultipleFullObject; }
bool is_single_volume() const { return m_type == SingleVolume; }
bool is_multiple_volume() const { return m_type == MultipleVolume; }
bool is_mixed() const { return m_type == Mixed; }
2018-10-09 13:56:34 +00:00
bool is_from_single_instance() const { return get_instance_idx() != -1; }
bool is_from_single_object() const { return get_object_idx() != -1; }
bool contains_volume(unsigned int volume_idx) const { return std::find(m_list.begin(), m_list.end(), volume_idx) != m_list.end(); }
2018-10-09 13:56:34 +00:00
// Returns the the object id if the selection is from a single object, otherwise is -1
int get_object_idx() const;
// Returns the instance id if the selection is from a single object and from a single instance, otherwise is -1
int get_instance_idx() const;
// Returns the indices of selected instances.
// Can only be called if selection is from a single object.
const InstanceIdxsList& get_instance_idxs() const;
const IndicesList& get_volume_idxs() const { return m_list; }
const GLVolume* get_volume(unsigned int volume_idx) const;
unsigned int volumes_count() const { return (unsigned int)m_list.size(); }
const BoundingBoxf3& get_bounding_box() const;
void start_dragging();
void translate(const Vec3d& displacement);
void rotate(const Vec3d& rotation, bool local);
void flattening_rotate(const Vec3d& normal);
void scale(const Vec3d& scale, bool local);
void mirror(Axis axis);
void translate(unsigned int object_idx, const Vec3d& displacement);
void translate(unsigned int object_idx, unsigned int instance_idx, const Vec3d& displacement);
void erase();
void render() const;
private:
2018-10-11 06:26:12 +00:00
void _update_valid();
void _update_type();
void _set_caches();
void _add_volume(unsigned int volume_idx);
void _add_instance(unsigned int object_idx, unsigned int instance_idx);
void _add_object(unsigned int object_idx);
void _remove_volume(unsigned int volume_idx);
void _remove_instance(unsigned int object_idx, unsigned int instance_idx);
void _remove_object(unsigned int object_idx);
void _calc_bounding_box() const;
void _render_selected_volumes() const;
void _render_synchronized_volumes() const;
2018-10-11 06:26:12 +00:00
void _render_bounding_box(const BoundingBoxf3& box, float* color) const;
void _synchronize_unselected_instances();
2018-11-06 14:51:33 +00:00
void _synchronize_unselected_volumes();
#if ENABLE_ENSURE_ON_BED_WHILE_SCALING
void _ensure_on_bed();
#endif // ENABLE_ENSURE_ON_BED_WHILE_SCALING
};
private:
2018-06-13 07:12:16 +00:00
class Gizmos
{
2018-06-22 07:00:01 +00:00
static const float OverlayTexturesScale;
2018-06-13 07:12:16 +00:00
static const float OverlayOffsetX;
static const float OverlayGapY;
public:
enum EType : unsigned char
{
2018-06-13 07:26:58 +00:00
Undefined,
2018-09-11 07:00:28 +00:00
Move,
2018-06-13 07:12:16 +00:00
Scale,
Rotate,
Flatten,
2018-10-18 13:13:38 +00:00
Cut,
SlaSupports,
2018-06-13 07:12:16 +00:00
Num_Types
};
private:
bool m_enabled;
typedef std::map<EType, GLGizmoBase*> GizmosMap;
GizmosMap m_gizmos;
EType m_current;
public:
Gizmos();
~Gizmos();
2018-08-24 12:11:41 +00:00
bool init(GLCanvas3D& parent);
2018-06-13 07:12:16 +00:00
bool is_enabled() const;
void set_enabled(bool enable);
2018-10-25 07:35:08 +00:00
std::string update_hover_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection);
void update_on_off_state(const GLCanvas3D& canvas, const Vec2d& mouse_pos, const Selection& selection);
void update_on_off_state(const Selection& selection);
2018-06-13 11:14:17 +00:00
void reset_all_states();
2018-06-14 13:32:26 +00:00
void set_hover_id(int id);
2018-10-09 13:56:34 +00:00
void enable_grabber(EType type, unsigned int id, bool enable);
2018-06-14 13:32:26 +00:00
bool overlay_contains_mouse(const GLCanvas3D& canvas, const Vec2d& mouse_pos) const;
2018-06-15 12:10:28 +00:00
bool grabber_contains_mouse() const;
void update(const Linef3& mouse_ray, bool shift_down, const Point* mouse_pos = nullptr);
#if ENABLE_GIZMOS_RESET
void process_double_click();
#endif // ENABLE_GIZMOS_RESET
Rect get_reset_rect_viewport(const GLCanvas3D& canvas) const;
2018-06-19 07:46:26 +00:00
EType get_current_type() const;
2018-06-15 12:10:28 +00:00
2018-06-18 13:07:17 +00:00
bool is_running() const;
2018-11-22 09:14:31 +00:00
#if ENABLE_GIZMOS_SHORTCUT
bool handle_shortcut(int key, const Selection& selection);
#endif // ENABLE_GIZMOS_SHORTCUT
2018-06-19 07:46:26 +00:00
2018-06-15 12:10:28 +00:00
bool is_dragging() const;
void start_dragging(const Selection& selection);
2018-06-15 12:10:28 +00:00
void stop_dragging();
2018-06-13 08:49:59 +00:00
Vec3d get_displacement() const;
2018-09-11 07:00:28 +00:00
Vec3d get_scale() const;
void set_scale(const Vec3d& scale);
2018-06-19 07:46:26 +00:00
Vec3d get_rotation() const;
void set_rotation(const Vec3d& rotation);
Vec3d get_flattening_normal() const;
void set_flattening_data(const ModelObject* model_object);
void set_model_object_ptr(ModelObject* model_object);
void clicked_on_object(const Vec2d& mouse_position);
void delete_current_grabber(bool delete_all = false);
2018-09-12 10:14:20 +00:00
void render_current_gizmo(const Selection& selection) const;
void render_current_gizmo_for_picking_pass(const Selection& selection) const;
2018-08-21 12:27:36 +00:00
void render_overlay(const GLCanvas3D& canvas) const;
2018-06-13 07:12:16 +00:00
2018-10-18 13:13:38 +00:00
void create_external_gizmo_widgets(wxWindow *parent);
2018-06-13 07:12:16 +00:00
private:
void _reset();
void _render_overlay(const GLCanvas3D& canvas) const;
void _render_current_gizmo(const Selection& selection) const;
2018-06-13 08:49:59 +00:00
float _get_total_overlay_height() const;
2018-06-15 12:10:28 +00:00
GLGizmoBase* _get_current() const;
2018-06-13 07:12:16 +00:00
};
class WarningTexture : public GUI::GLTexture
{
static const unsigned char Background_Color[3];
static const unsigned char Opacity;
int m_original_width;
int m_original_height;
public:
WarningTexture();
bool generate(const std::string& msg);
void render(const GLCanvas3D& canvas) const;
};
class LegendTexture : public GUI::GLTexture
{
static const int Px_Title_Offset = 5;
static const int Px_Text_Offset = 5;
static const int Px_Square = 20;
static const int Px_Square_Contour = 1;
static const int Px_Border = Px_Square / 2;
static const unsigned char Squares_Border_Color[3];
static const unsigned char Background_Color[3];
static const unsigned char Opacity;
int m_original_width;
int m_original_height;
public:
LegendTexture();
bool generate(const GCodePreviewData& preview_data, const std::vector<float>& tool_colors);
void render(const GLCanvas3D& canvas) const;
};
2018-05-09 08:47:04 +00:00
wxGLCanvas* m_canvas;
wxGLContext* m_context;
LegendTexture m_legend_texture;
WarningTexture m_warning_texture;
2018-10-25 07:35:08 +00:00
wxTimer m_timer;
2018-05-09 08:47:04 +00:00
Camera m_camera;
2018-05-14 12:14:19 +00:00
Bed m_bed;
2018-05-18 11:02:47 +00:00
Axes m_axes;
LayersEditing m_layers_editing;
2018-05-23 07:57:44 +00:00
Shader m_shader;
2018-05-23 11:56:54 +00:00
Mouse m_mouse;
2018-06-13 08:49:59 +00:00
mutable Gizmos m_gizmos;
2018-07-23 11:49:48 +00:00
mutable GLToolbar m_toolbar;
2018-05-14 12:14:19 +00:00
2018-06-11 13:13:13 +00:00
mutable GLVolumeCollection m_volumes;
Selection m_selection;
2018-05-23 09:14:49 +00:00
DynamicPrintConfig* m_config;
2018-06-07 09:18:28 +00:00
Model* m_model;
BackgroundSlicingProcess *m_process;
2018-05-09 08:47:04 +00:00
// Screen is only refreshed from the OnIdle handler if it is dirty.
2018-05-09 08:47:04 +00:00
bool m_dirty;
bool m_initialized;
bool m_use_VBOs;
2018-06-05 08:56:55 +00:00
bool m_force_zoom_to_bed_enabled;
2018-05-14 12:14:19 +00:00
bool m_apply_zoom_to_volumes_filter;
mutable int m_hover_volume_id;
2018-07-27 10:08:33 +00:00
bool m_toolbar_action_running;
2018-05-21 12:40:09 +00:00
bool m_warning_texture_enabled;
2018-05-21 12:57:43 +00:00
bool m_legend_texture_enabled;
bool m_picking_enabled;
bool m_moving_enabled;
2018-05-25 12:05:08 +00:00
bool m_shader_enabled;
bool m_dynamic_background_enabled;
2018-05-23 13:35:11 +00:00
bool m_multisample_allowed;
bool m_regenerate_volumes;
2018-05-09 08:47:04 +00:00
std::string m_color_by;
bool m_reload_delayed;
2018-06-05 08:56:55 +00:00
GCodePreviewVolumeIndex m_gcode_preview_volume_index;
2018-10-18 13:13:38 +00:00
wxWindow *m_external_gizmo_widgets_parent;
2018-10-03 12:07:10 +00:00
void post_event(wxEvent &&event);
void viewport_changed();
2018-07-27 10:08:33 +00:00
2018-05-09 08:47:04 +00:00
public:
2018-06-27 09:31:11 +00:00
GLCanvas3D(wxGLCanvas* canvas);
~GLCanvas3D();
2018-05-09 08:47:04 +00:00
2018-10-04 08:41:11 +00:00
#if ENABLE_USE_UNIQUE_GLCONTEXT
void set_context(wxGLContext* context) { m_context = context; }
#endif // ENABLE_USE_UNIQUE_GLCONTEXT
wxGLCanvas* get_wxglcanvas() { return m_canvas; }
2018-09-17 10:15:11 +00:00
2018-05-25 12:05:08 +00:00
bool init(bool useVBOs, bool use_legacy_opengl);
2018-05-23 07:57:44 +00:00
2018-10-04 08:41:11 +00:00
#if !ENABLE_USE_UNIQUE_GLCONTEXT
2018-06-27 09:31:11 +00:00
bool set_current();
2018-10-04 08:41:11 +00:00
#endif // !ENABLE_USE_UNIQUE_GLCONTEXT
2018-05-09 08:47:04 +00:00
void set_as_dirty();
2018-05-14 12:14:19 +00:00
2018-06-11 11:48:02 +00:00
unsigned int get_volumes_count() const;
void reset_volumes();
int check_volumes_outside_state(const DynamicPrintConfig* config) const;
2018-05-23 09:14:49 +00:00
void set_config(DynamicPrintConfig* config);
void set_process(BackgroundSlicingProcess* process);
2018-06-07 09:18:28 +00:00
void set_model(Model* model);
2018-05-23 09:14:49 +00:00
const Selection& get_selection() const { return m_selection; }
Selection& get_selection() { return m_selection; }
2018-05-15 13:38:25 +00:00
// Set the bed shape to a single closed 2D polygon(array of two element arrays),
// triangulate the bed and store the triangles into m_bed.m_triangles,
// fills the m_bed.m_grid_lines and sets m_bed.m_origin.
// Sets m_bed.m_polygon to limit the object placement.
2018-05-14 12:14:19 +00:00
void set_bed_shape(const Pointfs& shape);
2018-05-18 11:02:47 +00:00
void set_axes_length(float length);
2018-05-15 09:07:32 +00:00
2018-06-06 10:36:52 +00:00
void set_color_by(const std::string& value);
2018-09-06 14:10:31 +00:00
2018-05-09 08:47:04 +00:00
float get_camera_zoom() const;
2018-05-14 12:14:19 +00:00
BoundingBoxf3 volumes_bounding_box() const;
bool is_layers_editing_enabled() const;
bool is_layers_editing_allowed() const;
bool is_reload_delayed() const;
2018-05-25 12:05:08 +00:00
void enable_layers_editing(bool enable);
2018-05-21 12:40:09 +00:00
void enable_warning_texture(bool enable);
2018-05-21 12:57:43 +00:00
void enable_legend_texture(bool enable);
void enable_picking(bool enable);
void enable_moving(bool enable);
2018-06-13 07:12:16 +00:00
void enable_gizmos(bool enable);
2018-07-23 11:49:48 +00:00
void enable_toolbar(bool enable);
2018-05-23 07:57:44 +00:00
void enable_shader(bool enable);
2018-06-05 08:56:55 +00:00
void enable_force_zoom_to_bed(bool enable);
void enable_dynamic_background(bool enable);
2018-05-23 13:35:11 +00:00
void allow_multisample(bool allow);
2018-05-21 12:40:09 +00:00
2018-07-23 11:49:48 +00:00
void enable_toolbar_item(const std::string& name, bool enable);
2018-07-27 10:08:33 +00:00
bool is_toolbar_item_pressed(const std::string& name) const;
2018-07-23 11:49:48 +00:00
2018-05-15 08:32:38 +00:00
void zoom_to_bed();
void zoom_to_volumes();
#if ENABLE_MODIFIED_CAMERA_TARGET
void zoom_to_selection();
#endif // ENABLE_MODIFIED_CAMERA_TARGET
void select_view(const std::string& direction);
void set_viewport_from_scene(const GLCanvas3D& other);
2018-05-15 08:32:38 +00:00
void update_volumes_colors_by_extruder();
Rect get_gizmo_reset_rect(const GLCanvas3D& canvas, bool viewport) const;
bool gizmo_reset_rect_contains(const GLCanvas3D& canvas, float x, float y) const;
void render();
2018-05-15 13:38:25 +00:00
2018-11-21 14:28:35 +00:00
void select_all();
void delete_selected();
void ensure_on_bed(unsigned int object_idx);
std::vector<double> get_current_print_zs(bool active_only) const;
void set_toolpaths_range(double low, double high);
std::vector<int> load_object(const ModelObject& model_object, int obj_idx, std::vector<int> instance_idxs);
std::vector<int> load_object(const Model& model, int obj_idx);
void mirror_selection(Axis axis);
void reload_scene(bool refresh_immediately, bool force_full_scene_refresh);
2018-06-05 08:56:55 +00:00
void load_gcode_preview(const GCodePreviewData& preview_data, const std::vector<std::string>& str_tool_colors);
void load_preview(const std::vector<std::string>& str_tool_colors);
2018-06-05 08:56:55 +00:00
2018-06-06 12:19:28 +00:00
void bind_event_handlers();
void unbind_event_handlers();
void on_size(wxSizeEvent& evt);
void on_idle(wxIdleEvent& evt);
void on_char(wxKeyEvent& evt);
2018-05-28 13:23:01 +00:00
void on_mouse_wheel(wxMouseEvent& evt);
void on_timer(wxTimerEvent& evt);
void on_mouse(wxMouseEvent& evt);
void on_paint(wxPaintEvent& evt);
void on_key_down(wxKeyEvent& evt);
Size get_canvas_size() const;
Point get_local_mouse_position() const;
void reset_legend_texture();
2018-10-25 07:35:08 +00:00
void set_tooltip(const std::string& tooltip) const;
2018-10-18 13:13:38 +00:00
void set_external_gizmo_widgets_parent(wxWindow *parent);
2018-11-21 09:36:09 +00:00
void do_move();
void do_rotate();
void do_scale();
void do_flatten();
void do_mirror();
2018-05-14 12:14:19 +00:00
private:
bool _is_shown_on_screen() const;
2018-06-05 08:56:55 +00:00
void _force_zoom_to_bed();
2018-07-23 11:49:48 +00:00
bool _init_toolbar();
2018-10-04 08:41:11 +00:00
#if ENABLE_USE_UNIQUE_GLCONTEXT
bool _set_current();
#endif // ENABLE_USE_UNIQUE_GLCONTEXT
2018-06-01 13:54:41 +00:00
void _resize(unsigned int w, unsigned int h);
BoundingBoxf3 _max_bounding_box() const;
2018-05-14 12:14:19 +00:00
void _zoom_to_bounding_box(const BoundingBoxf3& bbox);
float _get_zoom_to_bounding_box_factor(const BoundingBoxf3& bbox) const;
void _mark_volumes_for_layer_height() const;
2018-05-28 13:23:01 +00:00
void _refresh_if_shown_on_screen();
2018-05-31 06:44:39 +00:00
void _camera_tranform() const;
void _picking_pass() const;
void _render_background() const;
2018-06-11 08:46:32 +00:00
void _render_bed(float theta) const;
2018-06-13 11:14:17 +00:00
void _render_axes(bool depth_test) const;
void _render_objects() const;
void _render_selection() const;
void _render_warning_texture() const;
void _render_legend_texture() const;
void _render_layer_editing_overlay() const;
2018-06-01 13:54:41 +00:00
void _render_volumes(bool fake_colors) const;
2018-08-21 12:27:36 +00:00
void _render_current_gizmo() const;
void _render_gizmos_overlay() const;
2018-07-23 11:49:48 +00:00
void _render_toolbar() const;
#if ENABLE_SHOW_CAMERA_TARGET
void _render_camera_target() const;
#endif // ENABLE_SHOW_CAMERA_TARGET
void _update_volumes_hover_state() const;
void _update_gizmos_data();
2018-06-01 13:54:41 +00:00
float _get_layers_editing_cursor_z_relative() const;
void _perform_layer_editing_action(wxMouseEvent* evt = nullptr);
// Convert the screen space coordinate to an object space coordinate.
// If the Z screen space coordinate is not provided, a depth buffer value is substituted.
Vec3d _mouse_to_3d(const Point& mouse_pos, float* z = nullptr);
2018-06-01 13:54:41 +00:00
2018-06-15 12:10:28 +00:00
// Convert the screen space coordinate to world coordinate on the bed.
Vec3d _mouse_to_bed_3d(const Point& mouse_pos);
2018-06-15 12:10:28 +00:00
2018-08-20 08:23:17 +00:00
// Returns the view ray line, in world coordinate, at the given mouse position.
Linef3 mouse_ray(const Point& mouse_pos);
2018-06-01 13:54:41 +00:00
void _start_timer();
void _stop_timer();
2018-06-05 08:56:55 +00:00
// Create 3D thick extrusion lines for a skirt and brim.
// Adds a new Slic3r::GUI::3DScene::Volume to volumes.
void _load_print_toolpaths();
// Create 3D thick extrusion lines for object forming extrusions.
// Adds a new Slic3r::GUI::3DScene::Volume to $self->volumes,
// one for perimeters, one for infill and one for supports.
void _load_print_object_toolpaths(const PrintObject& print_object, const std::vector<std::string>& str_tool_colors);
// Create 3D thick extrusion lines for wipe tower extrusions
void _load_wipe_tower_toolpaths(const std::vector<std::string>& str_tool_colors);
2018-06-13 11:14:17 +00:00
2018-06-05 08:56:55 +00:00
// generates gcode extrusion paths geometry
void _load_gcode_extrusion_paths(const GCodePreviewData& preview_data, const std::vector<float>& tool_colors);
// generates gcode travel paths geometry
void _load_gcode_travel_paths(const GCodePreviewData& preview_data, const std::vector<float>& tool_colors);
bool _travel_paths_by_type(const GCodePreviewData& preview_data);
bool _travel_paths_by_feedrate(const GCodePreviewData& preview_data);
bool _travel_paths_by_tool(const GCodePreviewData& preview_data, const std::vector<float>& tool_colors);
// generates gcode retractions geometry
void _load_gcode_retractions(const GCodePreviewData& preview_data);
// generates gcode unretractions geometry
void _load_gcode_unretractions(const GCodePreviewData& preview_data);
// generates objects and wipe tower geometry
void _load_shells();
// sets gcode geometry visibility according to user selection
void _update_gcode_volumes_visibility(const GCodePreviewData& preview_data);
void _update_toolpath_volumes_outside_state();
void _show_warning_texture_if_needed();
2018-11-21 09:36:09 +00:00
// generates the legend texture in dependence of the current shown view type
void _generate_legend_texture(const GCodePreviewData& preview_data, const std::vector<float>& tool_colors);
// generates a warning texture containing the given message
void _generate_warning_texture(const std::string& msg);
void _reset_warning_texture();
bool _is_any_volume_outside() const;
2018-07-31 10:25:00 +00:00
void _resize_toolbar() const;
static std::vector<float> _parse_colors(const std::vector<std::string>& colors);
const Print* fff_print() const;
const SLAPrint* sla_print() const;
2018-05-09 08:47:04 +00:00
};
} // namespace GUI
} // namespace Slic3r
#endif // slic3r_GLCanvas3D_hpp_