GCode Preview - Code cleanup

lib/Slic3r/GUI/3DScene.pm

@@ -30,7 +30,6 @@ use Slic3r::Geometry qw(PI);
 # _dirty: boolean flag indicating, that the screen has to be redrawn on EVT_IDLE.
 # volumes: reference to vector of Slic3r::GUI::3DScene::Volume.
 # _camera_type: 'perspective' or 'ortho'
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
 __PACKAGE__->mk_accessors( qw(_quat _dirty init
                               enable_picking
                               enable_moving
@@ -72,46 +71,6 @@ __PACKAGE__->mk_accessors( qw(_quat _dirty init
                                                             
                               ) );
                               
-#__PACKAGE__->mk_accessors( qw(_quat _dirty init
-#                              enable_picking
-#                              enable_moving
-#                              use_plain_shader
-#                              on_viewport_changed
-#                              on_hover
-#                              on_select
-#                              on_double_click
-#                              on_right_click
-#                              on_move
-#                              on_model_update
-#                              volumes
-#                              _sphi _stheta
-#                              cutting_plane_z
-#                              cut_lines_vertices
-#                              bed_shape
-#                              bed_triangles
-#                              bed_grid_lines
-#                              bed_polygon
-#                              background
-#                              origin
-#                              _mouse_pos
-#                              _hover_volume_idx
-#
-#                              _drag_volume_idx
-#                              _drag_start_pos
-#                              _drag_volume_center_offset
-#                              _drag_start_xy
-#                              _dragged
-#
-#                              _layer_height_edited
-#
-#                              _camera_type
-#                              _camera_target
-#                              _camera_distance
-#                              _zoom
-#                              
-#                              ) );
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
-
 use constant TRACKBALLSIZE  => 0.8;
 use constant TURNTABLE_MODE => 1;
 use constant GROUND_Z       => -0.02;
@@ -181,9 +140,7 @@ sub new {
     $self->_stheta(45);
     $self->_sphi(45);
     $self->_zoom(1);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
     $self->_legend_enabled(0);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
     $self->use_plain_shader(0);
 
     # Collection of GLVolume objects
@@ -256,12 +213,10 @@ sub new {
     return $self;
 }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
 sub set_legend_enabled {
     my ($self, $value) = @_;
    $self->_legend_enabled($value);
 }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
 
 sub Destroy {
     my ($self) = @_;
@@ -1370,10 +1325,8 @@ sub Render {
         glDisable(GL_BLEND);
     }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================   
     # draw gcode preview legend
     $self->draw_legend;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     
     $self->draw_active_object_annotations;
     
@@ -1508,29 +1461,9 @@ sub _variable_layer_thickness_load_reset_image {
 # Paint the tooltip.
 sub _render_image {
     my ($self, $image, $l, $r, $b, $t) = @_;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->_render_texture($image->{texture_id}, $l, $r, $b, $t);
-
-#    glColor4f(1.,1.,1.,1.);
-#    glDisable(GL_LIGHTING);
-#    glEnable(GL_BLEND);
-#    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-#    glEnable(GL_TEXTURE_2D);
-#    glBindTexture(GL_TEXTURE_2D, $image->{texture_id});
-#    glBegin(GL_QUADS);
-#    glTexCoord2d(0.,1.); glVertex3f($l, $b, 0);
-#    glTexCoord2d(1.,1.); glVertex3f($r, $b, 0);
-#    glTexCoord2d(1.,0.); glVertex3f($r, $t, 0);
-#    glTexCoord2d(0.,0.); glVertex3f($l, $t, 0);
-#    glEnd();
-#    glBindTexture(GL_TEXTURE_2D, 0);
-#    glDisable(GL_TEXTURE_2D);
-#    glDisable(GL_BLEND);
-#    glEnable(GL_LIGHTING);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 sub _render_texture {
     my ($self, $tex_id, $l, $r, $b, $t) = @_;
     
@@ -1551,7 +1484,6 @@ sub _render_texture {
     glDisable(GL_BLEND);
     glEnable(GL_LIGHTING);
 }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
 sub draw_active_object_annotations {
     # $fakecolor is a boolean indicating, that the objects shall be rendered in a color coding the object index for picking.
@@ -1665,7 +1597,6 @@ sub draw_active_object_annotations {
     glEnable(GL_DEPTH_TEST);
 }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 sub draw_legend {
     my ($self) = @_;
  
@@ -1694,7 +1625,6 @@ sub draw_legend {
         }
     }
 }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
 sub opengl_info
 {
@@ -2096,14 +2026,12 @@ sub load_wipe_tower_toolpaths {
         if ($print->step_done(STEP_WIPE_TOWER));
 }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
 sub load_gcode_preview {
     my ($self, $print) = @_;
 
     $self->SetCurrent($self->GetContext) if $self->UseVBOs;
     Slic3r::GUI::_3DScene::load_gcode_preview($print, $self->volumes, $self->UseVBOs);
 }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
 sub set_toolpaths_range {
     my ($self, $min_z, $max_z) = @_;

lib/Slic3r/GUI/Plater.pm

@@ -153,7 +153,6 @@ sub new {
     
     EVT_NOTEBOOK_PAGE_CHANGED($self, $self->{preview_notebook}, sub {
         my $preview = $self->{preview_notebook}->GetCurrentPage;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         if ($preview == $self->{preview3D})
         {
             $self->{preview3D}->canvas->set_legend_enabled(1);
@@ -161,8 +160,7 @@ sub new {
         } else {
             $self->{preview3D}->canvas->set_legend_enabled(0);
         }
-#        $self->{preview3D}->load_print(1) if ($preview == $self->{preview3D});
+
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         $preview->OnActivate if $preview->can('OnActivate');        
     });
     
@@ -785,9 +783,7 @@ sub remove {
     splice @{$self->{objects}}, $obj_idx, 1;
     $self->{model}->delete_object($obj_idx);
     $self->{print}->delete_object($obj_idx);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->{print}->clear_gcode_preview_data;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->{list}->DeleteItem($obj_idx);
     $self->object_list_changed;
     
@@ -808,9 +804,7 @@ sub reset {
     @{$self->{objects}} = ();
     $self->{model}->clear_objects;
     $self->{print}->clear_objects;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->{print}->clear_gcode_preview_data;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->{list}->DeleteAllItems;
     $self->object_list_changed;
     
@@ -1451,11 +1445,9 @@ sub on_export_completed {
     # this updates buttons status
     $self->object_list_changed;
     
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     # refresh preview
     $self->{toolpaths2D}->reload_print if $self->{toolpaths2D};
     $self->{preview3D}->reload_print if $self->{preview3D};
-# ===================== ENRICO_GCODE_PREVIEW ==================================================        
 }
 
 sub do_print {

lib/Slic3r/GUI/Plater/3DPreview.pm

@@ -5,16 +5,10 @@ use utf8;
 
 use Slic3r::Print::State ':steps';
 use Wx qw(:misc :sizer :slider :statictext :keycode wxWHITE);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 use Wx::Event qw(EVT_SLIDER EVT_KEY_DOWN EVT_CHECKBOX EVT_CHOICE EVT_CHECKLISTBOX);
-#use Wx::Event qw(EVT_SLIDER EVT_KEY_DOWN EVT_CHECKBOX);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 use base qw(Wx::Panel Class::Accessor);
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 __PACKAGE__->mk_accessors(qw(print enabled _loaded canvas slider_low slider_high single_layer auto_zoom));
-#__PACKAGE__->mk_accessors(qw(print enabled _loaded canvas slider_low slider_high single_layer));
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
 sub new {
     my $class = shift;
@@ -24,9 +18,7 @@ sub new {
     $self->{config} = $config;
     $self->{number_extruders} = 1;
     $self->{preferred_color_mode} = 'feature';
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $self->auto_zoom(1);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
     # init GUI elements
     my $canvas = Slic3r::GUI::3DScene->new($self);
@@ -69,7 +61,6 @@ sub new {
     my $checkbox_singlelayer = $self->{checkbox_singlelayer} = Wx::CheckBox->new($self, -1, "1 Layer");
     my $checkbox_color_by_extruder = $self->{checkbox_color_by_extruder} = Wx::CheckBox->new($self, -1, "Tool");
     
-# ===================== ENRICO_GCODE_PREVIEW ==================================================
     my $choice_view_type = Wx::Choice->new($self, -1);
     $choice_view_type->Append("Feature type");
     $choice_view_type->Append("Height");
@@ -97,7 +88,6 @@ sub new {
     my $checkbox_travel = Wx::CheckBox->new($self, -1, "Travel");
     my $checkbox_retractions = Wx::CheckBox->new($self, -1, "Retractions");    
     my $checkbox_unretractions = Wx::CheckBox->new($self, -1, "Unretractions");
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
     my $hsizer = Wx::BoxSizer->new(wxHORIZONTAL);
     my $vsizer = Wx::BoxSizer->new(wxVERTICAL);
@@ -112,13 +102,11 @@ sub new {
     $vsizer_outer->Add($hsizer, 3, wxALIGN_CENTER_HORIZONTAL, 0);
     $vsizer_outer->Add($checkbox_singlelayer, 0, wxTOP | wxALIGN_CENTER_HORIZONTAL, 5);
     $vsizer_outer->Add($checkbox_color_by_extruder, 0, wxTOP | wxALIGN_CENTER_HORIZONTAL, 5);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     $vsizer_outer->Add($choice_view_type, 0, wxEXPAND | wxALL | wxALIGN_CENTER_HORIZONTAL, 5);
     $vsizer_outer->Add($checklist_features, 0, wxTOP | wxALL | wxALIGN_CENTER_HORIZONTAL, 5);
     $vsizer_outer->Add($checkbox_travel, 0, wxEXPAND | wxALL | wxALIGN_CENTER_VERTICAL, 5);
     $vsizer_outer->Add($checkbox_retractions, 0, wxEXPAND | wxALL | wxALIGN_CENTER_VERTICAL, 5);
     $vsizer_outer->Add($checkbox_unretractions, 0, wxEXPAND | wxALL | wxALIGN_CENTER_VERTICAL, 5);
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
     my $sizer = Wx::BoxSizer->new(wxHORIZONTAL);
     $sizer->Add($canvas, 1, wxALL | wxEXPAND, 0);
@@ -199,7 +187,6 @@ sub new {
         $self->reload_print;
     });
     
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     EVT_CHOICE($self, $choice_view_type, sub {
         my $selection = $choice_view_type->GetCurrentSelection();
         $self->print->set_gcode_preview_type($selection);
@@ -238,7 +225,6 @@ sub new {
         $self->refresh_print;
         $self->auto_zoom(1);
     });
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
     
     $self->SetSizer($sizer);
     $self->SetMinSize($self->GetSize);
@@ -258,16 +244,13 @@ sub reload_print {
     $self->_loaded(0);
 
     if (! $self->IsShown && ! $force) {
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 #        $self->{reload_delayed} = 1;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         return;
     }
 
     $self->load_print;
 }
 
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 sub refresh_print {
     my ($self) = @_;
 
@@ -279,7 +262,6 @@ sub refresh_print {
 
     $self->load_print;
 }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 
 sub load_print {
     my ($self) = @_;
@@ -361,10 +343,9 @@ sub load_print {
     }
 
     if ($self->IsShown) {
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         $self->canvas->load_gcode_preview($self->print);
 
-        # load skirt and brim
+#        # load skirt and brim
 #        $self->canvas->load_print_toolpaths($self->print, \@colors);
 #        $self->canvas->load_wipe_tower_toolpaths($self->print, \@colors);
 #        
@@ -375,15 +356,10 @@ sub load_print {
 #            #my @volume_ids = $self->canvas->load_object($object->model_object);
 #            #$self->canvas->volumes->[$_]->color->[3] = 0.2 for @volume_ids;
 #        }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         if ($self->auto_zoom)
         {
-# ===================== ENRICO_GCODE_PREVIEW ==================================================            
             $self->canvas->zoom_to_volumes;
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         $self->_loaded(1);
     }
     
@@ -445,10 +421,8 @@ sub set_number_extruders {
 
 # Called by the Platter wxNotebook when this page is activated.
 sub OnActivate {
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 #    my ($self) = @_;
 #    $self->reload_print(1) if ($self->{reload_delayed});
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
 }
 
 1;

lib/Slic3r/GUI/Plater/3DToolpaths.pm

@@ -122,7 +122,6 @@ sub load_print {
     }
     
     if ($self->IsShown) {
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
         $self->canvas->load_gcode_preview($self->print);
 
 #        # load skirt and brim
@@ -135,7 +134,7 @@ sub load_print {
 #            #my @volume_ids = $self->canvas->load_object($object->model_object);
 #            #$self->canvas->volumes->[$_]->color->[3] = 0.2 for @volume_ids;
 #        }
-# ===================== ENRICO_GCODE_PREVIEW ==================================================    
+
         $self->canvas->zoom_to_volumes;
         $self->_loaded(1);
     }

xs/src/libslic3r/BoundingBox.cpp

@@ -4,50 +4,9 @@
 
 namespace Slic3r {
 
-//############################################################################################################
-#if !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-template <class PointClass>
-BoundingBoxBase<PointClass>::BoundingBoxBase(const std::vector<PointClass> &points)
-{
-    if (points.empty()) 
-        CONFESS("Empty point set supplied to BoundingBoxBase constructor");
-    typename std::vector<PointClass>::const_iterator it = points.begin();
-    this->min.x = this->max.x = it->x;
-    this->min.y = this->max.y = it->y;
-    for (++it; it != points.end(); ++it) {
-        this->min.x = std::min(it->x, this->min.x);
-        this->min.y = std::min(it->y, this->min.y);
-        this->max.x = std::max(it->x, this->max.x);
-        this->max.y = std::max(it->y, this->max.y);
-    }
-    this->defined = true;
-}
-//############################################################################################################
-#endif // !ENRICO_GCODE_PREVIEW
-//############################################################################################################
 template BoundingBoxBase<Point>::BoundingBoxBase(const std::vector<Point> &points);
 template BoundingBoxBase<Pointf>::BoundingBoxBase(const std::vector<Pointf> &points);
 
-//############################################################################################################
-#if !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-template <class PointClass>
-BoundingBox3Base<PointClass>::BoundingBox3Base(const std::vector<PointClass> &points)
-    : BoundingBoxBase<PointClass>(points)
-{
-    if (points.empty())
-        CONFESS("Empty point set supplied to BoundingBox3Base constructor");
-    typename std::vector<PointClass>::const_iterator it = points.begin();
-    this->min.z = this->max.z = it->z;
-    for (++it; it != points.end(); ++it) {
-        this->min.z = std::min(it->z, this->min.z);
-        this->max.z = std::max(it->z, this->max.z);
-    }
-}
-//############################################################################################################
-#endif // !ENRICO_GCODE_PREVIEW
-//############################################################################################################
 template BoundingBox3Base<Pointf3>::BoundingBox3Base(const std::vector<Pointf3> &points);
 
 BoundingBox::BoundingBox(const Lines &lines)

xs/src/libslic3r/BoundingBox.hpp

@@ -23,8 +23,6 @@ public:
     BoundingBoxBase() : defined(false) {};
     BoundingBoxBase(const PointClass &pmin, const PointClass &pmax) : 
         min(pmin), max(pmax), defined(pmin.x < pmax.x && pmin.y < pmax.y) {}
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     BoundingBoxBase(const std::vector<PointClass>& points)
     {
         if (points.empty())
@@ -42,12 +40,6 @@ public:
         }
         this->defined = (this->min.x < this->max.x) && (this->min.y < this->max.y);
     }
-#else
-//############################################################################################################
-    BoundingBoxBase(const std::vector<PointClass> &points);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     void merge(const PointClass &point);
     void merge(const std::vector<PointClass> &points);
     void merge(const BoundingBoxBase<PointClass> &bb);
@@ -78,8 +70,6 @@ public:
     BoundingBox3Base(const PointClass &pmin, const PointClass &pmax) : 
         BoundingBoxBase<PointClass>(pmin, pmax) 
         { if (pmin.z >= pmax.z) BoundingBoxBase<PointClass>::defined = false; }
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     BoundingBox3Base(const std::vector<PointClass>& points)
         : BoundingBoxBase<PointClass>(points)
     {
@@ -95,12 +85,6 @@ public:
         }
         this->defined &= (this->min.z < this->max.z);
     }
-#else
-//############################################################################################################
-    BoundingBox3Base(const std::vector<PointClass> &points);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     void merge(const PointClass &point);
     void merge(const std::vector<PointClass> &points);
     void merge(const BoundingBox3Base<PointClass> &bb);
@@ -138,15 +122,7 @@ class BoundingBox3  : public BoundingBox3Base<Point3>
 public:
     BoundingBox3() : BoundingBox3Base<Point3>() {};
     BoundingBox3(const Point3 &pmin, const Point3 &pmax) : BoundingBox3Base<Point3>(pmin, pmax) {};
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     BoundingBox3(const Points3& points) : BoundingBox3Base<Point3>(points) {};
-#else
-//############################################################################################################
-    BoundingBox3(const std::vector<Point3> &points) : BoundingBox3Base<Point3>(points) {};
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 };
 
 class BoundingBoxf : public BoundingBoxBase<Pointf> 

xs/src/libslic3r/ExtrusionEntity.hpp

@@ -104,42 +104,17 @@ public:
     float width;
     // Height of the extrusion, used for visualization purposed.
     float height;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // Feedrate of the extrusion, used for visualization purposed.
     float feedrate;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     ExtrusionPath(ExtrusionRole role) : mm3_per_mm(-1), width(-1), height(-1), feedrate(0.0f), m_role(role) {};
     ExtrusionPath(ExtrusionRole role, double mm3_per_mm, float width, float height) : mm3_per_mm(mm3_per_mm), width(width), height(height), feedrate(0.0f), m_role(role) {};
     ExtrusionPath(const ExtrusionPath &rhs) : polyline(rhs.polyline), mm3_per_mm(rhs.mm3_per_mm), width(rhs.width), height(rhs.height), feedrate(rhs.feedrate), m_role(rhs.m_role) {}
     ExtrusionPath(ExtrusionPath &&rhs) : polyline(std::move(rhs.polyline)), mm3_per_mm(rhs.mm3_per_mm), width(rhs.width), height(rhs.height), feedrate(rhs.feedrate), m_role(rhs.m_role) {}
 //    ExtrusionPath(ExtrusionRole role, const Flow &flow) : m_role(role), mm3_per_mm(flow.mm3_per_mm()), width(flow.width), height(flow.height), feedrate(0.0f) {};
-#else
-//############################################################################################################
-    ExtrusionPath(ExtrusionRole role) : mm3_per_mm(-1), width(-1), height(-1), m_role(role) {};
-    ExtrusionPath(ExtrusionRole role, double mm3_per_mm, float width, float height) : mm3_per_mm(mm3_per_mm), width(width), height(height), m_role(role) {};
-    ExtrusionPath(const ExtrusionPath &rhs) : polyline(rhs.polyline), mm3_per_mm(rhs.mm3_per_mm), width(rhs.width), height(rhs.height), m_role(rhs.m_role) {}
-    ExtrusionPath(ExtrusionPath &&rhs) : polyline(std::move(rhs.polyline)), mm3_per_mm(rhs.mm3_per_mm), width(rhs.width), height(rhs.height), m_role(rhs.m_role) {}
-//    ExtrusionPath(ExtrusionRole role, const Flow &flow) : m_role(role), mm3_per_mm(flow.mm3_per_mm()), width(flow.width), height(flow.height) {};
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     ExtrusionPath& operator=(const ExtrusionPath &rhs) { this->m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->feedrate = rhs.feedrate, this->polyline = rhs.polyline; return *this; }
     ExtrusionPath& operator=(ExtrusionPath &&rhs) { this->m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->feedrate = rhs.feedrate, this->polyline = std::move(rhs.polyline); return *this; }
-#else
-//############################################################################################################
-    ExtrusionPath& operator=(const ExtrusionPath &rhs) { this->m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->polyline = rhs.polyline; return *this; }
-    ExtrusionPath& operator=(ExtrusionPath &&rhs) { this->m_role = rhs.m_role; this->mm3_per_mm = rhs.mm3_per_mm; this->width = rhs.width; this->height = rhs.height; this->polyline = std::move(rhs.polyline); return *this; }
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     ExtrusionPath* clone() const { return new ExtrusionPath (*this); }
     void reverse() { this->polyline.reverse(); }

xs/src/libslic3r/GCode.cpp

@@ -402,8 +402,6 @@ void GCode::_do_export(Print &print, FILE *file)
     m_time_estimator.reset();
     m_time_estimator.set_dialect(print.config.gcode_flavor);
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // resets analyzer
     m_analyzer.reset();
 
@@ -411,8 +409,6 @@ void GCode::_do_export(Print &print, FILE *file)
     m_last_mm3_per_mm = GCodeAnalyzer::Default_mm3_per_mm;
     m_last_width = GCodeAnalyzer::Default_Width;
     m_last_height = GCodeAnalyzer::Default_Height;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     // How many times will be change_layer() called?
     // change_layer() in turn increments the progress bar status.
@@ -823,12 +819,8 @@ void GCode::_do_export(Print &print, FILE *file)
         }
     }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // starts analizer calculations
     m_analyzer.calc_gcode_preview_data(print);
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 }
 
 std::string GCode::placeholder_parser_process(const std::string &name, const std::string &templ, unsigned int current_extruder_id, const DynamicConfig *config_override)
@@ -1320,18 +1312,7 @@ void GCode::process_layer(
 			if (print_object == nullptr)
 				// This layer is empty for this particular object, it has neither object extrusions nor support extrusions at this print_z.
 				continue;
-//############################################################################################################
+
-#if !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-            if (m_enable_analyzer_markers) {
-                // Store the binary pointer to the layer object directly into the G-code to be accessed by the GCodeAnalyzer.
-                char buf[64];
-                sprintf(buf, ";_LAYEROBJ:%p\n", m_layer);
-                gcode += buf;
-            }
-//############################################################################################################
-#endif // !ENRICO_GCODE_PREVIEW
-//############################################################################################################
             m_config.apply(print_object->config, true);
             m_layer = layers[layer_id].layer();
             if (m_config.avoid_crossing_perimeters)
@@ -2023,18 +2004,8 @@ std::string GCode::extrude_support(const ExtrusionEntityCollection &support_fill
     return gcode;
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 void GCode::_write(FILE* file, const char *what)
-#else
-//############################################################################################################
-void GCode::_write(FILE* file, const char *what, size_t size)
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 {
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     if (what != nullptr) {
         // apply analyzer, if enabled
         const char* gcode = m_enable_analyzer ? m_analyzer.process_gcode(what).c_str() : what;
@@ -2043,16 +2014,6 @@ void GCode::_write(FILE* file, const char *what, size_t size)
         fwrite(gcode, 1, ::strlen(gcode), file);
         // updates time estimator and gcode lines vector
         m_time_estimator.add_gcode_block(gcode);
-#else
-//############################################################################################################
-    if (size > 0) {
-        // writes string to file
-        fwrite(what, 1, size, file);
-        // updates time estimator and gcode lines vector
-        m_time_estimator.add_gcode_block(what);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     }
 }
 
@@ -2086,15 +2047,8 @@ void GCode::_write_format(FILE* file, const char* format, ...)
     char *bufptr = buffer_dynamic ? (char*)malloc(buflen) : buffer;
     int res = ::vsnprintf(bufptr, buflen, format, args);
     if (res > 0)
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         _write(file, bufptr);
-#else
+
-//############################################################################################################
-        _write(file, bufptr, res);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     if (buffer_dynamic)
         free(bufptr);
 
@@ -2179,8 +2133,6 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
     double F = speed * 60;  // convert mm/sec to mm/min
     
     // extrude arc or line
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     if (m_enable_extrusion_role_markers || m_enable_analyzer)
     {
         if (path.role() != m_last_extrusion_role)
@@ -2231,19 +2183,6 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
             gcode += buf;
         }
     }
-#else
-//############################################################################################################
-    if (m_enable_extrusion_role_markers || m_enable_analyzer_markers) {
-        if (path.role() != m_last_extrusion_role) {
-            m_last_extrusion_role = path.role();
-            char buf[32];
-            sprintf(buf, ";_EXTRUSION_ROLE:%d\n", int(path.role()));
-            gcode += buf;
-        }
-    }
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     std::string comment;
     if (m_enable_cooling_markers) {

xs/src/libslic3r/GCode.hpp

@@ -17,11 +17,7 @@
 #include "GCode/WipeTower.hpp"
 #include "GCodeTimeEstimator.hpp"
 #include "EdgeGrid.hpp"
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include "GCode/Analyzer.hpp"
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 #include <memory>
 #include <string>
@@ -123,28 +119,16 @@ public:
         m_enable_loop_clipping(true), 
         m_enable_cooling_markers(false), 
         m_enable_extrusion_role_markers(false), 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         m_enable_analyzer(true),
-#else
-//############################################################################################################
-        m_enable_analyzer_markers(false),
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
         m_layer_count(0),
         m_layer_index(-1), 
         m_layer(nullptr), 
         m_volumetric_speed(0),
         m_last_pos_defined(false),
         m_last_extrusion_role(erNone),
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         m_last_mm3_per_mm(GCodeAnalyzer::Default_mm3_per_mm),
         m_last_width(GCodeAnalyzer::Default_Width),
         m_last_height(GCodeAnalyzer::Default_Height),
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
         m_brim_done(false),
         m_second_layer_things_done(false),
         m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max()))
@@ -169,12 +153,8 @@ public:
     // inside the generated string and after the G-code export finishes.
     std::string     placeholder_parser_process(const std::string &name, const std::string &templ, unsigned int current_extruder_id, const DynamicConfig *config_override = nullptr);
     bool            enable_cooling_markers() const { return m_enable_cooling_markers; }
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     bool            enable_analyzer() const { return m_enable_analyzer; }
     void            enable_analyzer(bool enable) { m_enable_analyzer = enable; }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     // For Perl bindings, to be used exclusively by unit tests.
     unsigned int    layer_count() const { return m_layer_count; }
@@ -267,20 +247,10 @@ protected:
     // Markers for the Pressure Equalizer to recognize the extrusion type.
     // The Pressure Equalizer removes the markers from the final G-code.
     bool                                m_enable_extrusion_role_markers;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // Enableds the G-code Analyzer.
     // Extended markers will be added during G-code generation.
     // The G-code Analyzer will remove these comments from the final G-code.
     bool                                m_enable_analyzer;
-#else
-//############################################################################################################
-    // Extended markers for the G-code Analyzer.
-    // The G-code Analyzer will remove these comments from the final G-code.
-    bool                                m_enable_analyzer_markers;
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     // How many times will change_layer() be called?
     // change_layer() will update the progress bar.
     unsigned int                        m_layer_count;
@@ -293,14 +263,10 @@ protected:
     double                              m_volumetric_speed;
     // Support for the extrusion role markers. Which marker is active?
     ExtrusionRole                       m_last_extrusion_role;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // Support for G-Code Analyzer
     double                              m_last_mm3_per_mm;
     float                               m_last_width;
     float                               m_last_height;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     Point                               m_last_pos;
     bool                                m_last_pos_defined;
@@ -322,25 +288,12 @@ protected:
     // Time estimator
     GCodeTimeEstimator m_time_estimator;
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // Analyzer
     GCodeAnalyzer m_analyzer;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     // Write a string into a file.
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     void _write(FILE* file, const std::string& what) { this->_write(file, what.c_str()); }
     void _write(FILE* file, const char *what);
-#else
-//############################################################################################################
-    void _write(FILE* file, const std::string& what) { this->_write(file, what.c_str(), what.size()); }
-    void _write(FILE* file, const char *what, size_t size);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     // Write a string into a file. 
     // Add a newline, if the string does not end with a newline already.

xs/src/libslic3r/GCode/Analyzer.cpp

@@ -4,16 +4,10 @@
 
 #include "../libslic3r.h"
 #include "../PrintConfig.hpp"
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include "Print.hpp"
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 #include "Analyzer.hpp"
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 static const std::string AXIS_STR = "XYZE";
 static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
 static const float INCHES_TO_MM = 25.4f;
@@ -21,333 +15,9 @@ static const float DEFAULT_FEEDRATE = 0.0f;
 static const unsigned int DEFAULT_EXTRUDER_ID = 0;
 static const Slic3r::Pointf3 DEFAULT_START_POSITION = Slic3r::Pointf3(0.0f, 0.0f, 0.0f);
 static const float DEFAULT_START_EXTRUSION = 0.0f;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 namespace Slic3r {
 
-//############################################################################################################
-#if !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-void GCodeMovesDB::reset()
-{
-    for (size_t i = 0; i < m_layers.size(); ++ i)
-        delete m_layers[i];
-    m_layers.clear();
-}
-
-GCodeAnalyzer::GCodeAnalyzer(const Slic3r::GCodeConfig *config) : 
-    m_config(config)
-{
-    reset();
-    m_moves = new GCodeMovesDB();
-}
-
-GCodeAnalyzer::~GCodeAnalyzer()
-{
-    delete m_moves;
-}
-
-void GCodeAnalyzer::reset()
-{
-    output_buffer.clear();
-    output_buffer_length = 0;
-
-    m_current_extruder = 0;
-    // Zero the position of the XYZE axes + the current feed
-    memset(m_current_pos, 0, sizeof(float) * 5);
-    m_current_extrusion_role = erNone;
-    m_current_extrusion_width = 0;
-    m_current_extrusion_height = 0;
-    // Expect the first command to fill the nozzle (deretract).
-    m_retracted = true;
-    m_moves->reset();
-}
-
-const char* GCodeAnalyzer::process(const char *szGCode, bool flush)
-{
-    // Reset length of the output_buffer.
-    output_buffer_length = 0;
-
-    if (szGCode != 0) {
-        const char *p = szGCode;
-        while (*p != 0) {
-            // Find end of the line.
-            const char *endl = p;
-            // Slic3r always generates end of lines in a Unix style.
-            for (; *endl != 0 && *endl != '\n'; ++ endl) ;
-            // Process a G-code line, store it into the provided GCodeLine object.
-            bool should_output = process_line(p, endl - p);
-            if (*endl == '\n') 
-                ++ endl;
-            if (should_output)
-                push_to_output(p, endl - p);
-            p = endl;
-        }
-    }
-
-    return output_buffer.data();
-}
-
-// Is a white space?
-static inline bool is_ws(const char c) { return c == ' ' || c == '\t'; }
-// Is it an end of line? Consider a comment to be an end of line as well.
-static inline bool is_eol(const char c) { return c == 0 || c == '\r' || c == '\n' || c == ';'; };
-// Is it a white space or end of line?
-static inline bool is_ws_or_eol(const char c) { return is_ws(c) || is_eol(c); };
-
-// Eat whitespaces.
-static void eatws(const char *&line)
-{
-    while (is_ws(*line)) 
-        ++ line;
-}
-
-// Parse an int starting at the current position of a line.
-// If succeeded, the line pointer is advanced.
-static inline int parse_int(const char *&line)
-{
-    char *endptr = NULL;
-    long result = strtol(line, &endptr, 10);
-    if (endptr == NULL || !is_ws_or_eol(*endptr))
-        throw std::runtime_error("GCodeAnalyzer: Error parsing an int");
-    line = endptr;
-    return int(result);
-};
-
-// Parse an int starting at the current position of a line.
-// If succeeded, the line pointer is advanced.
-static inline float parse_float(const char *&line)
-{
-    char *endptr = NULL;
-    float result = strtof(line, &endptr);
-    if (endptr == NULL || !is_ws_or_eol(*endptr))
-        throw std::runtime_error("GCodeAnalyzer: Error parsing a float");
-    line = endptr;
-    return result;
-};
-
-#define EXTRUSION_ROLE_TAG ";_EXTRUSION_ROLE:"
-bool GCodeAnalyzer::process_line(const char *line, const size_t len)
-{
-    if (strncmp(line, EXTRUSION_ROLE_TAG, strlen(EXTRUSION_ROLE_TAG)) == 0) {
-        line += strlen(EXTRUSION_ROLE_TAG);
-        int role = atoi(line);
-        this->m_current_extrusion_role = ExtrusionRole(role);
-        return false;
-    }
-
-/*
-    // Set the type, copy the line to the buffer.
-    buf.type = GCODE_MOVE_TYPE_OTHER;
-    buf.modified = false;
-    if (buf.raw.size() < len + 1)
-        buf.raw.assign(line, line + len + 1);
-    else
-        memcpy(buf.raw.data(), line, len);
-    buf.raw[len] = 0;
-    buf.raw_length = len;
-
-    memcpy(buf.pos_start, m_current_pos, sizeof(float)*5);
-    memcpy(buf.pos_end, m_current_pos, sizeof(float)*5);
-    memset(buf.pos_provided, 0, 5);
-
-    buf.volumetric_extrusion_rate = 0.f;
-    buf.volumetric_extrusion_rate_start = 0.f;
-    buf.volumetric_extrusion_rate_end = 0.f;
-    buf.max_volumetric_extrusion_rate_slope_positive = 0.f;
-    buf.max_volumetric_extrusion_rate_slope_negative = 0.f;
-	buf.extrusion_role = m_current_extrusion_role;
-
-    // Parse the G-code line, store the result into the buf.
-    switch (toupper(*line ++)) {
-    case 'G': {
-        int gcode = parse_int(line);
-        eatws(line);
-        switch (gcode) {
-        case 0:
-        case 1:
-        {
-            // G0, G1: A FFF 3D printer does not make a difference between the two.
-            float new_pos[5];
-            memcpy(new_pos, m_current_pos, sizeof(float)*5);
-            bool  changed[5] = { false, false, false, false, false };
-            while (!is_eol(*line)) {
-                char axis = toupper(*line++);
-                int  i = -1;
-                switch (axis) {
-                case 'X':
-                case 'Y':
-                case 'Z':
-                    i = axis - 'X';
-                    break;
-                case 'E':
-                    i = 3;
-                    break;
-                case 'F':
-                    i = 4;
-                    break;
-                default:
-                    assert(false);
-                }
-                if (i == -1)
-                    throw std::runtime_error(std::string("GCodeAnalyzer: Invalid axis for G0/G1: ") + axis);
-                buf.pos_provided[i] = true;
-                new_pos[i] = parse_float(line);
-                if (i == 3 && m_config->use_relative_e_distances.value)
-                    new_pos[i] += m_current_pos[i];
-                changed[i] = new_pos[i] != m_current_pos[i];
-                eatws(line);
-            }
-            if (changed[3]) {
-                // Extrusion, retract or unretract.
-                float diff = new_pos[3] - m_current_pos[3];
-                if (diff < 0) {
-                    buf.type = GCODE_MOVE_TYPE_RETRACT;
-                    m_retracted = true;
-                } else if (! changed[0] && ! changed[1] && ! changed[2]) {
-                    // assert(m_retracted);
-                    buf.type = GCODE_MOVE_TYPE_UNRETRACT;
-                    m_retracted = false;
-                } else {
-                    assert(changed[0] || changed[1]);
-                    // Moving in XY plane.
-                    buf.type = GCODE_MOVE_TYPE_EXTRUDE;
-                    // Calculate the volumetric extrusion rate.
-                    float diff[4];
-                    for (size_t i = 0; i < 4; ++ i)
-                        diff[i] = new_pos[i] - m_current_pos[i];
-                    // volumetric extrusion rate = A_filament * F_xyz * L_e / L_xyz [mm^3/min]
-                    float len2 = diff[0]*diff[0]+diff[1]*diff[1]+diff[2]*diff[2];
-                    float rate = m_filament_crossections[m_current_extruder] * new_pos[4] * sqrt((diff[3]*diff[3])/len2);
-                    buf.volumetric_extrusion_rate       = rate;
-                    buf.volumetric_extrusion_rate_start = rate;
-                    buf.volumetric_extrusion_rate_end   = rate;
-                    m_stat.update(rate, sqrt(len2));
-                    if (rate < 10.f) {
-                    	printf("Extremely low flow rate: %f\n", rate);
-                    }
-                }
-            } else if (changed[0] || changed[1] || changed[2]) {
-                // Moving without extrusion.
-                buf.type = GCODE_MOVE_TYPE_MOVE;
-            }
-            memcpy(m_current_pos, new_pos, sizeof(float) * 5);
-            break;
-        }
-        case 92:
-        {
-            // G92 : Set Position
-            // Set a logical coordinate position to a new value without actually moving the machine motors.
-            // Which axes to set?
-            bool set = false;
-            while (!is_eol(*line)) {
-                char axis = toupper(*line++);
-                switch (axis) {
-                case 'X':
-                case 'Y':
-                case 'Z':
-                    m_current_pos[axis - 'X'] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f;
-                    set = true;
-                    break;
-                case 'E':
-                    m_current_pos[3] = (!is_ws_or_eol(*line)) ? parse_float(line) : 0.f;
-                    set = true;
-                    break;
-                default:
-                    throw std::runtime_error(std::string("GCodeAnalyzer: Incorrect axis in a G92 G-code: ") + axis);
-                }
-                eatws(line);
-            }
-            assert(set);
-            break;
-        }
-        case 10:
-        case 22:
-            // Firmware retract.
-            buf.type = GCODE_MOVE_TYPE_RETRACT;
-            m_retracted = true;
-            break;
-        case 11:
-        case 23:
-            // Firmware unretract.
-            buf.type = GCODE_MOVE_TYPE_UNRETRACT;
-            m_retracted = false;
-            break;
-        default:
-            // Ignore the rest.
-        break;
-        }
-        break;
-    }
-    case 'M': {
-        int mcode = parse_int(line);
-        eatws(line);
-        switch (mcode) {
-        default:
-            // Ignore the rest of the M-codes.
-        break;
-        }
-        break;
-    }
-    case 'T':
-    {
-        // Activate an extruder head.
-        int new_extruder = parse_int(line);
-        if (new_extruder != m_current_extruder) {
-            m_current_extruder = new_extruder;
-            m_retracted = true;
-            buf.type = GCODE_MOVE_TYPE_TOOL_CHANGE;
-        } else {
-            buf.type = GCODE_MOVE_TYPE_NOOP;
-        }
-        break;
-    }
-    }
-
-    buf.extruder_id = m_current_extruder;
-    memcpy(buf.pos_end, m_current_pos, sizeof(float)*5);
-*/
-	return true;
-}
-
-void GCodeAnalyzer::push_to_output(const char *text, const size_t len, bool add_eol)
-{
-    // New length of the output buffer content.
-    size_t len_new = output_buffer_length + len + 1;
-    if (add_eol)
-        ++ len_new;
-
-    // Resize the output buffer to a power of 2 higher than the required memory.
-    if (output_buffer.size() < len_new) {
-        size_t v = len_new;
-        // Compute the next highest power of 2 of 32-bit v
-        // http://graphics.stanford.edu/~seander/bithacks.html
-        v--;
-        v |= v >> 1;
-        v |= v >> 2;
-        v |= v >> 4;
-        v |= v >> 8;
-        v |= v >> 16;
-        v++;
-        output_buffer.resize(v);
-    }
-
-    // Copy the text to the output.
-    if (len != 0) {
-        memcpy(output_buffer.data() + output_buffer_length, text, len);
-        output_buffer_length += len;
-    }
-    if (add_eol)
-        output_buffer[output_buffer_length ++] = '\n';
-    output_buffer[output_buffer_length] = 0;
-}
-//############################################################################################################
-#endif // !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 const std::string GCodeAnalyzer::Extrusion_Role_Tag = "_ANALYZER_EXTR_ROLE:";
 const std::string GCodeAnalyzer::Mm3_Per_Mm_Tag = "_ANALYZER_MM3_PER_MM:";
 const std::string GCodeAnalyzer::Width_Tag = "_ANALYZER_WIDTH:";
@@ -539,6 +209,7 @@ const GCodeAnalyzer::PreviewData::Color GCodeAnalyzer::PreviewData::Extrusion::D
     Color(0.0f, 0.0f, 0.0f, 1.0f)  // erMixed
 };
 
+// todo: merge with Slic3r::ExtrusionRole2String() from GCode.cpp
 const std::string GCodeAnalyzer::PreviewData::Extrusion::Default_Extrusion_Role_Names[Num_Extrusion_Roles]
 {
     "None",
@@ -1424,7 +1095,5 @@ GCodeAnalyzer::PreviewData::Color operator * (float f, const GCodeAnalyzer::Prev
         clamp(0.0f, 1.0f, f * color.rgba[2]),
         clamp(0.0f, 1.0f, f * color.rgba[3]));
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 } // namespace Slic3r

xs/src/libslic3r/GCode/Analyzer.hpp

@@ -5,169 +5,13 @@
 #include "../PrintConfig.hpp"
 #include "../ExtrusionEntity.hpp"
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include "Point.hpp"
 #include "GCodeReader.hpp"
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 namespace Slic3r {
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class Print;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
-//############################################################################################################
-#if !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-enum GCodeMoveType
-{
-    GCODE_MOVE_TYPE_NOOP,
-    GCODE_MOVE_TYPE_RETRACT,
-    GCODE_MOVE_TYPE_UNRETRACT,
-    GCODE_MOVE_TYPE_TOOL_CHANGE,
-    GCODE_MOVE_TYPE_MOVE,
-    GCODE_MOVE_TYPE_EXTRUDE,
-};
-
-// For visualization purposes, for the purposes of the G-code analysis and timing.
-// The size of this structure is 56B.
-// Keep the size of this structure as small as possible, because all moves of a complete print
-// may be held in RAM.
-struct GCodeMove
-{
-    bool        moving_xy(const float* pos_start)   const { return fabs(pos_end[0] - pos_start[0]) > 0.f || fabs(pos_end[1] - pos_start[1]) > 0.f; }
-    bool        moving_xy()                         const { return moving_xy(get_pos_start()); }
-    bool        moving_z (const float* pos_start)   const { return fabs(pos_end[2] - pos_start[2]) > 0.f; }
-    bool        moving_z ()                         const { return moving_z(get_pos_start()); }
-    bool        extruding(const float* pos_start)   const { return moving_xy() && pos_end[3] > pos_start[3]; }
-    bool        extruding()                         const { return extruding(get_pos_start()); }
-    bool        retracting(const float* pos_start)  const { return pos_end[3] < pos_start[3]; }
-    bool        retracting()                        const { return retracting(get_pos_start()); }    
-    bool        deretracting(const float* pos_start)  const { return ! moving_xy() && pos_end[3] > pos_start[3]; }
-    bool        deretracting()                      const { return deretracting(get_pos_start()); }
-
-    float       dist_xy2(const float* pos_start)    const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]); }
-    float       dist_xy2()                          const { return dist_xy2(get_pos_start()); }
-    float       dist_xyz2(const float* pos_start)   const { return (pos_end[0] - pos_start[0]) * (pos_end[0] - pos_start[0]) + (pos_end[1] - pos_start[1]) * (pos_end[1] - pos_start[1]) + (pos_end[2] - pos_start[2]) * (pos_end[2] - pos_start[2]); }
-    float       dist_xyz2()                         const { return dist_xyz2(get_pos_start()); }
-
-    float       dist_xy(const float* pos_start)     const { return sqrt(dist_xy2(pos_start)); }
-    float       dist_xy()                           const { return dist_xy(get_pos_start()); }
-    float       dist_xyz(const float* pos_start)    const { return sqrt(dist_xyz2(pos_start)); }
-    float       dist_xyz()                          const { return dist_xyz(get_pos_start()); }
-
-    float       dist_e(const float* pos_start)      const { return fabs(pos_end[3] - pos_start[3]); }
-    float       dist_e()                            const { return dist_e(get_pos_start()); }
-
-    float       feedrate()                          const { return pos_end[4]; }
-    float       time(const float* pos_start)        const { return dist_xyz(pos_start) / feedrate(); }
-    float       time()                              const { return time(get_pos_start()); }
-    float       time_inv(const float* pos_start)    const { return feedrate() / dist_xyz(pos_start); }
-    float       time_inv()                          const { return time_inv(get_pos_start()); }
-
-    const float*    get_pos_start() const { assert(type != GCODE_MOVE_TYPE_NOOP); return this[-1].pos_end; }
-
-    // Pack the enums to conserve space. With C++x11 the allocation size could be declared for enums, but for old C++ this is the only portable way.
-    // GCodeLineType
-    uint8_t         type;
-    // Index of the active extruder.
-    uint8_t         extruder_id;
-    // ExtrusionRole
-    uint8_t         extrusion_role;
-    // For example, is it a bridge flow? Is the fan on?
-    uint8_t         flags;
-    // X,Y,Z,E,F. Storing the state of the currently active extruder only.
-    float           pos_end[5];
-    // Extrusion width, height for this segment in um.
-    uint16_t        extrusion_width;
-    uint16_t        extrusion_height;
-};
-
-typedef std::vector<GCodeMove> GCodeMoves;
-
-struct GCodeLayer
-{
-    // Index of an object printed.
-    size_t                  object_idx;
-    // Index of an object instance printed.
-    size_t                  object_instance_idx;
-    // Index of the layer printed.
-    size_t                  layer_idx;
-    // Top z coordinate of the layer printed.
-    float                   layer_z_top;
-
-    // Moves over this layer. The 0th move is always of type GCODELINETYPE_NOOP and
-    // it sets the initial position and tool for the layer.
-    GCodeMoves              moves;
-
-    // Indices into m_moves, where the tool changes happen.
-    // This is useful, if one wants to display just only a piece of the path quickly.
-    std::vector<size_t>     tool_changes;
-};
-
-typedef std::vector<GCodeLayer*> GCodeLayerPtrs;
-
-class GCodeMovesDB
-{
-public:
-    GCodeMovesDB() {};
-    ~GCodeMovesDB() { reset(); }
-    void reset();
-    GCodeLayerPtrs      m_layers;
-};
-
-// Processes a G-code to extract moves and their types.
-// This information is then used to render the print simulation colored by the extrusion type
-// or various speeds.
-// The GCodeAnalyzer is employed as a G-Code filter. It reads the G-code as it is generated,
-// parses the comments generated by Slic3r just for the analyzer, and removes these comments.
-class GCodeAnalyzer
-{
-public:
-    GCodeAnalyzer(const Slic3r::GCodeConfig *config);
-    ~GCodeAnalyzer();
-
-    void reset();
-
-    // Process a next batch of G-code lines. Flush the internal buffers if asked for.
-    const char* process(const char *szGCode, bool flush);
-    // Length of the buffer returned by process().
-    size_t get_output_buffer_length() const { return output_buffer_length; }
-
-private:
-    // Keeps the reference, does not own the config.
-    const Slic3r::GCodeConfig      *m_config;
-
-    // Internal data.
-    // X,Y,Z,E,F
-    float                           m_current_pos[5];
-    size_t                          m_current_extruder;
-    ExtrusionRole                   m_current_extrusion_role;
-    uint16_t                        m_current_extrusion_width;
-    uint16_t                        m_current_extrusion_height;
-    bool                            m_retracted;
-
-    GCodeMovesDB                   *m_moves;
-
-    // Output buffer will only grow. It will not be reallocated over and over.
-    std::vector<char>               output_buffer;
-    size_t                          output_buffer_length;
-
-    bool process_line(const char *line, const size_t len);
-
-    // Push the text to the end of the output_buffer.
-    void push_to_output(const char *text, const size_t len, bool add_eol = true);
-};
-//############################################################################################################
-#endif // !ENRICO_GCODE_PREVIEW
-//############################################################################################################
-
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class GCodeAnalyzer
 {
 public:
@@ -553,9 +397,6 @@ private:
 GCodeAnalyzer::PreviewData::Color operator + (const GCodeAnalyzer::PreviewData::Color& c1, const GCodeAnalyzer::PreviewData::Color& c2);
 GCodeAnalyzer::PreviewData::Color operator * (float f, const GCodeAnalyzer::PreviewData::Color& color);
 
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
-
 } // namespace Slic3r
 
 #endif /* slic3r_GCode_Analyzer_hpp_ */

xs/src/libslic3r/Line.cpp

@@ -218,8 +218,6 @@ Line::ccw(const Point& point) const
     return point.ccw(*this);
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 double Line3::length() const
 {
     return a.distance_to(b);
@@ -229,8 +227,6 @@ Vector3 Line3::vector() const
 {
     return Vector3(b.x - a.x, b.y - a.y, b.z - a.z);
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 Pointf3
 Linef3::intersect_plane(double z) const

xs/src/libslic3r/Line.hpp

@@ -7,20 +7,12 @@
 namespace Slic3r {
 
 class Line;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class Line3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 class Linef3;
 class Polyline;
 class ThickLine;
 typedef std::vector<Line> Lines;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 typedef std::vector<Line3> Lines3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 typedef std::vector<ThickLine> ThickLines;
 
 class Line
@@ -66,8 +58,6 @@ class ThickLine : public Line
     ThickLine(Point _a, Point _b) : Line(_a, _b), a_width(0), b_width(0) {};
 };
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class Line3
 {
 public:
@@ -80,8 +70,6 @@ public:
     double length() const;
     Vector3 vector() const;
 };
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 class Linef
 {

xs/src/libslic3r/MultiPoint.cpp

@@ -214,8 +214,6 @@ MultiPoint::_douglas_peucker(const Points &points, const double tolerance)
     return results;
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 void MultiPoint3::translate(double x, double y)
 {
     for (Point3& p : points)
@@ -270,8 +268,6 @@ bool MultiPoint3::remove_duplicate_points()
 
     return false;
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 BoundingBox get_extents(const MultiPoint &mp)
 { 

xs/src/libslic3r/MultiPoint.hpp

@@ -10,11 +10,7 @@
 namespace Slic3r {
 
 class BoundingBox;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class BoundingBox3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 class MultiPoint
 {
@@ -84,8 +80,6 @@ public:
     static Points _douglas_peucker(const Points &points, const double tolerance);
 };
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class MultiPoint3
 {
 public:
@@ -104,8 +98,6 @@ public:
     // Remove exact duplicates, return true if any duplicate has been removed.
     bool remove_duplicate_points();
 };
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 extern BoundingBox get_extents(const MultiPoint &mp);
 extern BoundingBox get_extents_rotated(const std::vector<Point> &points, double angle);

xs/src/libslic3r/Point.hpp

@@ -14,29 +14,17 @@ class Line;
 class Linef;
 class MultiPoint;
 class Point;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class Point3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 class Pointf;
 class Pointf3;
 typedef Point Vector;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 typedef Point3 Vector3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 typedef Pointf Vectorf;
 typedef Pointf3 Vectorf3;
 typedef std::vector<Point> Points;
 typedef std::vector<Point*> PointPtrs;
 typedef std::vector<const Point*> PointConstPtrs;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 typedef std::vector<Point3> Points3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 typedef std::vector<Pointf> Pointfs;
 typedef std::vector<Pointf3> Pointf3s;
 
@@ -201,24 +189,11 @@ public:
     static Point3 new_scale(coordf_t x, coordf_t y, coordf_t z) { return Point3(coord_t(scale_(x)), coord_t(scale_(y)), coord_t(scale_(z))); }
     bool operator==(const Point3 &rhs) const { return this->x == rhs.x && this->y == rhs.y && this->z == rhs.z; }
     bool operator!=(const Point3 &rhs) const { return ! (*this == rhs); }
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     bool coincides_with(const Point3& rhs) const { return this->x == rhs.x && this->y == rhs.y && this->z == rhs.z; }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 private:
     // Hide the following inherited methods:
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     bool operator==(const Point &rhs) const;
     bool operator!=(const Point &rhs) const;
-#else
-//############################################################################################################
-    bool operator==(const Point &rhs);
-    bool operator!=(const Point &rhs);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 };
 
 std::ostream& operator<<(std::ostream &stm, const Pointf &pointf);
@@ -273,11 +248,7 @@ public:
     static Pointf3 new_unscale(coord_t x, coord_t y, coord_t z) {
         return Pointf3(unscale(x), unscale(y), unscale(z));
     };
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     static Pointf3 new_unscale(const Point3& p) { return Pointf3(unscale(p.x), unscale(p.y), unscale(p.z)); }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     void scale(double factor);
     void translate(const Vectorf3 &vector);
     void translate(double x, double y, double z);
@@ -290,21 +261,10 @@ public:
 
 private:
     // Hide the following inherited methods:
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     bool operator==(const Pointf &rhs) const;
     bool operator!=(const Pointf &rhs) const;
-#else
-//############################################################################################################
-    bool operator==(const Pointf &rhs);
-    bool operator!=(const Pointf &rhs);
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 };
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 inline Pointf3 operator+(const Pointf3& p1, const Pointf3& p2) { return Pointf3(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z); }
 inline Pointf3 operator-(const Pointf3& p1, const Pointf3& p2) { return Pointf3(p1.x - p2.x, p1.y - p2.y, p1.z - p2.z); }
 inline Pointf3 operator-(const Pointf3& p) { return Pointf3(-p.x, -p.y, -p.z); }
@@ -317,8 +277,6 @@ inline Pointf3 normalize(const Pointf3& v)
     coordf_t len = ::sqrt(sqr(v.x) + sqr(v.y) + sqr(v.z));
     return (len != 0.0) ? 1.0 / len * v : Pointf3(0.0, 0.0, 0.0);
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 template<typename TO> inline TO convert_to(const Point &src) { return TO(typename TO::coord_type(src.x), typename TO::coord_type(src.y)); }
 template<typename TO> inline TO convert_to(const Pointf &src) { return TO(typename TO::coord_type(src.x), typename TO::coord_type(src.y)); }

xs/src/libslic3r/Polyline.cpp

@@ -278,8 +278,6 @@ ThickPolyline::reverse()
     std::swap(this->endpoints.first, this->endpoints.second);
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 Lines3 Polyline3::lines() const
 {
     Lines3 lines;
@@ -293,7 +291,5 @@ Lines3 Polyline3::lines() const
     }
     return lines;
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 }

xs/src/libslic3r/Polyline.hpp

@@ -129,8 +129,6 @@ class ThickPolyline : public Polyline {
     void reverse();
 };
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class Polyline3 : public MultiPoint3
 {
 public:
@@ -138,8 +136,6 @@ public:
 };
 
 typedef std::vector<Polyline3> Polylines3;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 }
 

xs/src/libslic3r/Print.cpp

@@ -66,8 +66,6 @@ bool Print::reload_model_instances()
     return invalidated;
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 void Print::clear_gcode_preview_data()
 {
     gcode_preview.reset();
@@ -103,8 +101,6 @@ void Print::set_gcode_preview_unretractions_visible(bool visible)
 {
     gcode_preview.unretraction.is_visible = visible;
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 PrintRegion* Print::add_region()
 {

xs/src/libslic3r/Print.hpp

@@ -15,11 +15,7 @@
 #include "Slicing.hpp"
 #include "GCode/ToolOrdering.hpp"
 #include "GCode/WipeTower.hpp"
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include "GCode/Analyzer.hpp"
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 #include "tbb/atomic.h"
 
@@ -245,11 +241,7 @@ public:
 
     // ordered collections of extrusion paths to build skirt loops and brim
     ExtrusionEntityCollection skirt, brim;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     GCodeAnalyzer::PreviewData gcode_preview;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     Print() : total_used_filament(0), total_extruded_volume(0) { restart(); }
     ~Print() { clear_objects(); }
@@ -263,8 +255,6 @@ public:
     void reload_object(size_t idx);
     bool reload_model_instances();
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     void clear_gcode_preview_data();
     void set_gcode_preview_type(unsigned char type);
     void set_gcode_preview_extrusion_flags(unsigned int flags);
@@ -272,8 +262,6 @@ public:
     void set_gcode_preview_travel_visible(bool visible);
     void set_gcode_preview_retractions_visible(bool visible);
     void set_gcode_preview_unretractions_visible(bool visible);
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     // methods for handling regions
     PrintRegion* get_region(size_t idx) { return regions.at(idx); }

xs/src/libslic3r/libslic3r.h

@@ -163,29 +163,12 @@ static inline T clamp(const T low, const T high, const T value)
     return std::max(low, std::min(high, value));
 }
 
-//############################################################################################################
-#define ENRICO_GCODE_PREVIEW 1
-//############################################################################################################
-
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 template <typename T, typename Number>
 static inline T lerp(const T& a, const T& b, Number t)
 {
     assert((t >= Number(-EPSILON)) && (t <= Number(1) + Number(EPSILON)));
     return (Number(1) - t) * a + t * b;
 }
-#else
-//############################################################################################################
-template <typename T>
-static inline T lerp(const T a, const T b, const T t)
-{
-    assert(t >= T(-EPSILON) && t <= T(1.+EPSILON));
-    return (1. - t) * a + t * b;
-}
-//############################################################################################################
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 } // namespace Slic3r
 

xs/src/slic3r/GUI/3DScene.cpp

@@ -8,11 +8,7 @@
 #include "../../libslic3r/Geometry.hpp"
 #include "../../libslic3r/Print.hpp"
 #include "../../libslic3r/Slicing.hpp"
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include "GCode/Analyzer.hpp"
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -25,14 +21,10 @@
 #include <tbb/parallel_for.h>
 #include <tbb/spin_mutex.h>
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 #include <wx/bitmap.h>
 #include <wx/dcmemory.h>
 #include <wx/image.h>
 #include <wx/settings.h>
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 namespace Slic3r {
 
@@ -215,12 +207,8 @@ void GLVolume::set_range(double min_z, double max_z)
 
 void GLVolume::render() const
 {
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     if (!is_active)
         return;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     glCullFace(GL_BACK);
     glPushMatrix();
@@ -352,12 +340,9 @@ void GLVolumeCollection::render_VBOs() const
     GLint color_id = (current_program_id > 0) ? glGetUniformLocation(current_program_id, "uniform_color") : -1;
 
     for (GLVolume *volume : this->volumes) {
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         if (!volume->is_active)
             continue;
-#endif // ENRICO_GCODE_PREVIEW
+
-//############################################################################################################
         if (!volume->indexed_vertex_array.vertices_and_normals_interleaved_VBO_id)
             continue;
         GLsizei n_triangles = GLsizei(std::min(volume->indexed_vertex_array.triangle_indices_size, volume->tverts_range.second - volume->tverts_range.first));
@@ -396,12 +381,9 @@ void GLVolumeCollection::render_legacy() const
  
     for (GLVolume *volume : this->volumes) {
         assert(! volume->indexed_vertex_array.vertices_and_normals_interleaved_VBO_id);
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         if (!volume->is_active)
             continue;
-#endif // ENRICO_GCODE_PREVIEW
+
-//############################################################################################################
         GLsizei n_triangles = GLsizei(std::min(volume->indexed_vertex_array.triangle_indices_size, volume->tverts_range.second - volume->tverts_range.first));
         GLsizei n_quads     = GLsizei(std::min(volume->indexed_vertex_array.quad_indices_size,     volume->qverts_range.second - volume->qverts_range.first));
         if (n_triangles + n_quads == 0)
@@ -638,8 +620,6 @@ static void thick_lines_to_indexed_vertex_array(
 #undef BOTTOM
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 // caller is responsible for supplying NO lines with zero length
 static void thick_lines_to_indexed_vertex_array(const Lines3& lines,
     const std::vector<double>& widths,
@@ -954,8 +934,6 @@ static void point_to_indexed_vertex_array(const Point3& point,
     volume.push_triangle(idxs[3], idxs[1], idxs[4]);
     volume.push_triangle(idxs[0], idxs[3], idxs[4]);
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 static void thick_lines_to_verts(
     const Lines                 &lines, 
@@ -968,8 +946,6 @@ static void thick_lines_to_verts(
     thick_lines_to_indexed_vertex_array(lines, widths, heights, closed, top_z, volume.indexed_vertex_array);
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 static void thick_lines_to_verts(const Lines3& lines,
     const std::vector<double>& widths,
     const std::vector<double>& heights,
@@ -995,8 +971,6 @@ static inline void extrusionentity_to_verts(const ExtrusionPath &extrusion_path,
     std::vector<double> heights(lines.size(), extrusion_path.height);
     thick_lines_to_verts(lines, widths, heights, false, print_z, volume);
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 // Fill in the qverts and tverts with quads and triangles for the extrusion_path.
 static inline void extrusionentity_to_verts(const ExtrusionPath &extrusion_path, float print_z, const Point &copy, GLVolume &volume)
@@ -1081,8 +1055,6 @@ static void extrusionentity_to_verts(const ExtrusionEntity *extrusion_entity, fl
     }
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 static void polyline3_to_verts(const Polyline3& polyline, double width, double height, GLVolume& volume)
 {
     Lines3 lines = polyline.lines();
@@ -1300,8 +1272,6 @@ void _3DScene::LegendTexture::_destroy_texture()
         m_tex_id = 0;
     }
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 void _3DScene::_glew_init()
 { 
@@ -1335,8 +1305,6 @@ static inline std::vector<float> parse_colors(const std::vector<std::string> &sc
     return output;
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 void _3DScene::load_gcode_preview(const Print* print, GLVolumeCollection* volumes, bool use_VBOs)
 {
     if (volumes->empty())
@@ -1368,8 +1336,6 @@ unsigned int _3DScene::get_legend_texture_height()
 {
     return s_legend_texture.get_texture_height();
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 // Create 3D thick extrusion lines for a skirt and brim.
 // Adds a new Slic3r::GUI::3DScene::Volume to volumes.
@@ -1728,8 +1694,6 @@ void _3DScene::_load_wipe_tower_toolpaths(
     BOOST_LOG_TRIVIAL(debug) << "Loading wipe tower toolpaths in parallel - end"; 
 }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 void _3DScene::_load_gcode_extrusion_paths(const Print& print, GLVolumeCollection& volumes, bool use_VBOs)
 {
     // helper functions to select data in dependence of the extrusion view type
@@ -2071,7 +2035,5 @@ void _3DScene::_generate_legend_texture(const Print& print)
 {
     s_legend_texture.generate_texture(print);
 }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 }

xs/src/slic3r/GUI/3DScene.hpp

@@ -7,11 +7,7 @@
 #include "../../libslic3r/TriangleMesh.hpp"
 #include "../../libslic3r/Utils.hpp"
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 class wxBitmap;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
 namespace Slic3r {
 
@@ -112,13 +108,9 @@ public:
         push_geometry(float(x), float(y), float(z), float(nx), float(ny), float(nz));
     }
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     inline void push_geometry(const Pointf3& p, const Vectorf3& n) {
         push_geometry(p.x, p.y, p.z, n.x, n.y, n.z);
     }
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     inline void push_triangle(int idx1, int idx2, int idx3) {
         if (this->triangle_indices.size() + 3 > this->vertices_and_normals_interleaved.capacity())
@@ -221,11 +213,7 @@ public:
         select_group_id(-1),
         drag_group_id(-1),
         selected(false),
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
         is_active(true),
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
         hover(false),
         tverts_range(0, size_t(-1)),
         qverts_range(0, size_t(-1))
@@ -262,12 +250,8 @@ public:
     int                 drag_group_id;
     // Is this object selected?
     bool                selected;
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     // Whether or not this volume is active for rendering
     bool                is_active;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
     // Boolean: Is mouse over this object?
     bool                hover;
 
@@ -367,8 +351,6 @@ private:
 
 class _3DScene
 {
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     struct GCodePreviewData
     {
         enum EType
@@ -427,19 +409,13 @@ class _3DScene
     };
 
     static LegendTexture s_legend_texture;
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 public:
     static void _glew_init();
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
     static void load_gcode_preview(const Print* print, GLVolumeCollection* volumes, bool use_VBOs);
     static unsigned int get_legend_texture_id();
     static unsigned int get_legend_texture_width();
     static unsigned int get_legend_texture_height();
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 
     static void _load_print_toolpaths(
         const Print                     *print,
@@ -453,15 +429,12 @@ public:
         const std::vector<std::string>  &tool_colors,
         bool                             use_VBOs);
 
-
     static void _load_wipe_tower_toolpaths(
         const Print                    *print,
         GLVolumeCollection             *volumes,
         const std::vector<std::string> &tool_colors_str,
         bool                            use_VBOs);
 
-//############################################################################################################
-#if ENRICO_GCODE_PREVIEW
 private:
     // generates gcode extrusion paths geometry
     static void _load_gcode_extrusion_paths(const Print& print, GLVolumeCollection& volumes, bool use_VBOs);
@@ -475,8 +448,6 @@ private:
     static void _update_gcode_volumes_visibility(const Print& print, GLVolumeCollection& volumes);
     // generates the legend texture in dependence of the current shown view type
     static void _generate_legend_texture(const Print& print);
-#endif // ENRICO_GCODE_PREVIEW
-//############################################################################################################
 };
 
 }

xs/xsp/Print.xsp

@@ -165,14 +165,12 @@ _constant()
     size_t object_count()
         %code%{ RETVAL = THIS->objects.size(); %};
 
-// ===================== ENRICO_GCODE_PREVIEW ==================================================
     void clear_gcode_preview_data();
     void set_gcode_preview_type(unsigned char type);
     void set_gcode_preview_extrusion_flags(unsigned int flags);
     void set_gcode_preview_travel_visible(bool visible);
     void set_gcode_preview_retractions_visible(bool visible);
     void set_gcode_preview_unretractions_visible(bool visible);
-// ===================== ENRICO_GCODE_PREVIEW ==================================================
         
     PrintRegionPtrs* regions()
         %code%{ RETVAL = &THIS->regions; %};