GCodeProcessor additions:

process G90 lines

process G91 lines

process G92 lines

process M82 lines

process M83 lines

process T lines

process extrusion role/width/height comment tags

debug output

src/libslic3r/GCode.cpp

@@ -780,6 +780,10 @@ void GCode::do_export(Print* print, const char* path, GCodePreviewData* preview_
 
     // starts analyzer calculations
     if (m_enable_analyzer) {
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+        m_analyzer.close_debug_output_file();
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+
         BOOST_LOG_TRIVIAL(debug) << "Preparing G-code preview data" << log_memory_info();
         m_analyzer.calc_gcode_preview_data(*preview_data, [print]() { print->throw_if_canceled(); });
         m_analyzer.reset();
@@ -897,24 +901,17 @@ namespace DoExport {
 
 	    // tell analyzer about the gcode flavor
 	    analyzer.set_gcode_flavor(config.gcode_flavor);
-	}
+
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+        analyzer.open_debug_output_file();
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+    }
 
 #if ENABLE_GCODE_VIEWER
     static void init_gcode_processor(const PrintConfig& config, GCodeProcessor& processor)
     {
         processor.reset();
         processor.apply_config(config);
-
-        // send extruder offset data to processor
-        GCodeProcessor::ExtruderOffsetsMap extruder_offsets;
-        const size_t num_extruders = config.nozzle_diameter.values.size();
-        for (size_t id = 0; id < num_extruders; ++id)
-        {
-            const Vec2d& offset = config.extruder_offset.get_at(id);
-            if (!offset.isApprox(Vec2d::Zero()))
-                extruder_offsets[static_cast<unsigned int>(id)] = offset;
-        }
-        processor.set_extruder_offsets(extruder_offsets);
     }
 #endif // ENABLE_GCODE_VIEWER
 
@@ -1340,6 +1337,11 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
         // adds tag for analyzer
         _write_format(file, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erCustom);
 
+#if ENABLE_GCODE_VIEWER
+    // adds tag for processor
+    _write_format(file, ";%s%d\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), erCustom);
+#endif // ENABLE_GCODE_VIEWER
+
     // Write the custom start G-code
     _writeln(file, start_gcode);
 
@@ -1493,6 +1495,11 @@ void GCode::_do_export(Print& print, FILE* file, ThumbnailsGeneratorCallback thu
         // adds tag for analyzer
         _write_format(file, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erCustom);
 
+#if ENABLE_GCODE_VIEWER
+    // adds tag for processor
+    _write_format(file, ";%s%d\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), erCustom);
+#endif // ENABLE_GCODE_VIEWER
+
     // Process filament-specific gcode in extruder order.
     {
         DynamicConfig config;
@@ -3112,6 +3119,10 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
         {
             m_last_analyzer_extrusion_role = path.role();
             sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), int(m_last_analyzer_extrusion_role));
+#if ENABLE_GCODE_VIEWER
+            gcode += buf;
+            sprintf(buf, ";%s%d\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), int(m_last_analyzer_extrusion_role));
+#endif // ENABLE_GCODE_VIEWER
             gcode += buf;
         }
 
@@ -3127,6 +3138,10 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
             m_last_width = path.width;
             sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), m_last_width);
             gcode += buf;
+#if ENABLE_GCODE_VIEWER
+            sprintf(buf, ";%s%f\n", GCodeProcessor::Width_Tag.c_str(), m_last_width);
+            gcode += buf;
+#endif // ENABLE_GCODE_VIEWER
         }
 
         if (last_was_wipe_tower || (m_last_height != path.height))
@@ -3134,6 +3149,10 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
             m_last_height = path.height;
             sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_last_height);
             gcode += buf;
+#if ENABLE_GCODE_VIEWER
+            sprintf(buf, ";%s%f\n", GCodeProcessor::Height_Tag.c_str(), m_last_height);
+            gcode += buf;
+#endif // ENABLE_GCODE_VIEWER
         }
     }
 

src/libslic3r/GCode/Analyzer.cpp

@@ -174,6 +174,19 @@ bool GCodeAnalyzer::is_valid_extrusion_role(ExtrusionRole role)
     return ((erPerimeter <= role) && (role < erMixed));
 }
 
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+void GCodeAnalyzer::open_debug_output_file()
+{
+    boost::filesystem::path path("d:/analyzer.output");
+    m_debug_output.open(path.string());
+}
+
+void GCodeAnalyzer::close_debug_output_file()
+{
+    m_debug_output.close();
+}
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+
 void GCodeAnalyzer::_process_gcode_line(GCodeReader&, const GCodeReader::GCodeLine& line)
 {
     // processes 'special' comments contained in line
@@ -350,7 +363,7 @@ void GCodeAnalyzer::_processG1(const GCodeReader::GCodeLine& line)
     if (delta_pos[E] < 0.0f)
     {
         if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f) || (delta_pos[Z] != 0.0f))
-        type = GCodeMove::Move;
+            type = GCodeMove::Move;
         else
             type = GCodeMove::Retract;
     }
@@ -922,6 +935,20 @@ void GCodeAnalyzer::_store_move(GCodeAnalyzer::GCodeMove::EType type)
     Vec3d start_position = _get_start_position() + extruder_offset;
     Vec3d end_position = _get_end_position() + extruder_offset;
     it->second.emplace_back(type, _get_extrusion_role(), extruder_id, _get_mm3_per_mm(), _get_width(), _get_height(), _get_feedrate(), start_position, end_position, _get_delta_extrusion(), _get_fan_speed(), _get_cp_color_id());
+
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+    if (m_debug_output.good())
+    {
+        m_debug_output << std::to_string((int)type);
+        m_debug_output << ", " << std::to_string((int)_get_extrusion_role());
+        m_debug_output << ", " << Slic3r::to_string(_get_end_position());
+        m_debug_output << ", " << std::to_string(extruder_id);
+        m_debug_output << ", " << std::to_string(_get_feedrate());
+        m_debug_output << ", " << std::to_string(_get_width());
+        m_debug_output << ", " << std::to_string(_get_height());
+        m_debug_output << "\n";
+    }
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
 }
 
 bool GCodeAnalyzer::_is_valid_extrusion_role(int value) const

src/libslic3r/GCode/Analyzer.hpp

@@ -8,6 +8,10 @@
 #include "../Point.hpp"
 #include "../GCodeReader.hpp"
 
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+#include <boost/nowide/fstream.hpp>
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+
 namespace Slic3r {
 
 class GCodePreviewData;
@@ -147,6 +151,14 @@ public:
 
     static bool is_valid_extrusion_role(ExtrusionRole role);
 
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+private:
+    boost::nowide::ofstream m_debug_output;
+public:
+    void open_debug_output_file();
+    void close_debug_output_file();
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+
 private:
     // Processes the given gcode line
     void _process_gcode_line(GCodeReader& reader, const GCodeReader::GCodeLine& line);

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -6,19 +6,47 @@
 static const float INCHES_TO_MM = 25.4f;
 static const float MMMIN_TO_MMSEC = 1.0f / 60.0f;
 
+static bool is_valid_extrusion_role(int value)
+{
+    return ((int)Slic3r::erNone <= value) && (value <= (int)Slic3r::erMixed);
+}
+
 namespace Slic3r {
 
+const std::string GCodeProcessor::Extrusion_Role_Tag = "_PROCESSOR_EXTRUSION_ROLE:";
+const std::string GCodeProcessor::Width_Tag          = "_PROCESSOR_WIDTH:";
+const std::string GCodeProcessor::Height_Tag         = "_PROCESSOR_HEIGHT:";
+
+void GCodeProcessor::apply_config(const PrintConfig& config)
+{
+    m_parser.apply_config(config);
+
+    size_t extruders_count = config.nozzle_diameter.values.size();
+    if (m_extruder_offsets.size() != extruders_count)
+        m_extruder_offsets.resize(extruders_count);
+
+    for (size_t id = 0; id < extruders_count; ++id)
+    {
+        Vec2f offset = config.extruder_offset.get_at(id).cast<float>();
+        m_extruder_offsets[id] = Vec3f(offset(0), offset(1), 0.0f);
+    }
+}
+
 void GCodeProcessor::reset()
 {
     m_units = EUnits::Millimeters;
     m_global_positioning_type = EPositioningType::Absolute;
     m_e_local_positioning_type = EPositioningType::Absolute;
-    
+    m_extruder_offsets = std::vector<Vec3f>(1, Vec3f::Zero());
+
     std::fill(m_start_position.begin(), m_start_position.end(), 0.0f);
     std::fill(m_end_position.begin(), m_end_position.end(), 0.0f);
     std::fill(m_origin.begin(), m_origin.end(), 0.0f);
 
     m_feedrate = 0.0f;
+    m_width = 0.0f;
+    m_height = 0.0f;
+    m_extrusion_role = erNone;
     m_extruder_id = 0;
 
     m_result.reset();
@@ -26,10 +54,8 @@ void GCodeProcessor::reset()
 
 void GCodeProcessor::process_file(const std::string& filename)
 {
-    MoveVertex start_vertex {};
+    m_result.moves.emplace_back(MoveVertex());
-    m_result.moves.emplace_back(start_vertex);
     m_parser.parse_file(filename, [this](GCodeReader& reader, const GCodeReader::GCodeLine& line) { process_gcode_line(line); });
-    int a = 0;
 }
 
 void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line)
@@ -42,8 +68,6 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line)
     m_start_position = m_end_position;
 
     std::string cmd = line.cmd();
-    std::string comment = line.comment();
-
     if (cmd.length() > 1)
     {
         // process command lines
@@ -54,7 +78,13 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line)
                 switch (::atoi(&cmd[1]))
                 {
                 // Move
-                case 1: { process_G1(line); }
+                case 1: { process_G1(line); break; }
+                // Set to Absolute Positioning
+                case 90: { processG90(line); break; }
+                // Set to Relative Positioning
+                case 91: { processG91(line); break; }
+                // Set Position
+                case 92: { processG92(line); break; }
                 default: { break; }
                 }
                 break;
@@ -63,6 +93,10 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line)
             {
                 switch (::atoi(&cmd[1]))
                 {
+                // Set extruder to absolute mode
+                case 82: { processM82(line); break; }
+                // Set extruder to relative mode
+                case 83: { processM83(line); break; }
                 default: { break; }
                 }
                 break;
@@ -74,20 +108,52 @@ void GCodeProcessor::process_gcode_line(const GCodeReader::GCodeLine& line)
         default: { break; }
         }
     }
-    else if (comment.length() > 1)
+    else
     {
-        // process tags embedded into comments
+        std::string comment = line.comment();
-        process_comment(line);
+        if (comment.length() > 1)
+            // process tags embedded into comments
+            process_tags(comment);
     }
 }
 
-void GCodeProcessor::process_comment(const GCodeReader::GCodeLine& line)
+void GCodeProcessor::process_tags(const std::string& comment)
 {
+    // extrusion role tag
+    size_t pos = comment.find(Extrusion_Role_Tag);
+    if (pos != comment.npos)
+    {
+        int role = std::stoi(comment.substr(pos + Extrusion_Role_Tag.length()));
+        if (is_valid_extrusion_role(role))
+            m_extrusion_role = static_cast<ExtrusionRole>(role);
+        else
+        {
+            // todo: show some error ?
+        }
+
+        return;
+    }
+
+    // width tag
+    pos = comment.find(Width_Tag);
+    if (pos != comment.npos)
+    {
+        m_width = std::stof(comment.substr(pos + Width_Tag.length()));
+        return;
+    }
+
+    // height tag
+    pos = comment.find(Height_Tag);
+    if (pos != comment.npos)
+    {
+        m_height = std::stof(comment.substr(pos + Height_Tag.length()));
+        return;
+    }
 }
 
 void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
 {
-    auto axis_absolute_position = [this](Axis axis, const GCodeReader::GCodeLine& lineG1)
+    auto absolute_position = [this](Axis axis, const GCodeReader::GCodeLine& lineG1)
     {
         bool is_relative = (m_global_positioning_type == EPositioningType::Relative);
         if (axis == E)
@@ -103,10 +169,36 @@ void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
             return m_start_position[axis];
     };
 
+    auto move_type = [this](const AxisCoords& delta_pos) {
+        EMoveType type = EMoveType::Noop;
+
+        if (delta_pos[E] < 0.0f)
+        {
+            if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f || delta_pos[Z] != 0.0f)
+                type = EMoveType::Travel;
+            else
+                type = EMoveType::Retract;
+        }
+        else if (delta_pos[E] > 0.0f)
+        {
+            if (delta_pos[X] == 0.0f && delta_pos[Y] == 0.0f && delta_pos[Z] == 0.0f)
+                type = EMoveType::Unretract;
+            else if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f))
+                type = EMoveType::Extrude;
+        }
+        else if (delta_pos[X] != 0.0f || delta_pos[Y] != 0.0f || delta_pos[Z] != 0.0f)
+            type = EMoveType::Travel;
+
+        if (type == EMoveType::Extrude && (m_width == 0.0f || m_height == 0.0f || !is_valid_extrusion_role(m_extrusion_role)))
+            type = EMoveType::Travel;
+
+        return type;
+    };
+
     // updates axes positions from line
     for (unsigned char a = X; a <= E; ++a)
     {
-        m_end_position[a] = axis_absolute_position((Axis)a, line);
+        m_end_position[a] = absolute_position((Axis)a, line);
     }
 
     // updates feedrate from line, if present
@@ -124,56 +216,109 @@ void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
 
     // no displacement, return
     if (max_abs_delta == 0.0f)
-        return; // <<<<<<<<<<<<<<<<< is this correct for time estimate ?
+        return;
 
-    // detect move type
+    // store g1 move
-    EMoveType move_type = EMoveType::Noop;
+    store_move_vertex(move_type(delta_pos));
-    if (delta_pos[E] < 0.0f)
+}
+
+void GCodeProcessor::processG90(const GCodeReader::GCodeLine& line)
+{
+    m_global_positioning_type = EPositioningType::Absolute;
+}
+
+void GCodeProcessor::processG91(const GCodeReader::GCodeLine& line)
+{
+    m_global_positioning_type = EPositioningType::Relative;
+}
+
+void GCodeProcessor::processG92(const GCodeReader::GCodeLine& line)
+{
+    float lengthsScaleFactor = (m_units == EUnits::Inches) ? INCHES_TO_MM : 1.0f;
+    bool anyFound = false;
+
+    if (line.has_x())
     {
-        if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f) || (delta_pos[Z] != 0.0f))
+        m_origin[X] = m_end_position[X] - line.x() * lengthsScaleFactor;
-            move_type = EMoveType::Travel;
+        anyFound = true;
-        else
-            move_type = EMoveType::Retract;
     }
-    else if (delta_pos[E] > 0.0f)
+
+    if (line.has_y())
     {
-        if ((delta_pos[X] == 0.0f) && (delta_pos[Y] == 0.0f) && (delta_pos[Z] == 0.0f))
+        m_origin[Y] = m_end_position[Y] - line.y() * lengthsScaleFactor;
-            move_type = EMoveType::Unretract;
+        anyFound = true;
-        else if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f))
-            move_type = EMoveType::Extrude;
     }
-    else if ((delta_pos[X] != 0.0f) || (delta_pos[Y] != 0.0f) || (delta_pos[Z] != 0.0f))
-        move_type = EMoveType::Travel;
 
-    // correct position by extruder offset
+    if (line.has_z())
-    Vec3d extruder_offset = Vec3d::Zero();
+    {
-    auto it = m_extruder_offsets.find(m_extruder_id);
+        m_origin[Z] = m_end_position[Z] - line.z() * lengthsScaleFactor;
-    if (it != m_extruder_offsets.end())
+        anyFound = true;
-        extruder_offset = Vec3d(it->second(0), it->second(1), 0.0);
+    }
 
+    if (line.has_e())
+    {
+        // extruder coordinate can grow to the point where its float representation does not allow for proper addition with small increments,
+        // we set the value taken from the G92 line as the new current position for it
+        m_end_position[E] = line.e() * lengthsScaleFactor;
+        anyFound = true;
+    }
+
+    if (!anyFound && !line.has_unknown_axis())
+    {
+        // The G92 may be called for axes that PrusaSlicer does not recognize, for example see GH issue #3510, 
+        // where G92 A0 B0 is called although the extruder axis is till E.
+        for (unsigned char a = X; a <= E; ++a)
+        {
+            m_origin[a] = m_end_position[a];
+        }
+    }
+}
+
+void GCodeProcessor::processM82(const GCodeReader::GCodeLine& line)
+{
+    m_e_local_positioning_type = EPositioningType::Absolute;
+}
+
+void GCodeProcessor::processM83(const GCodeReader::GCodeLine& line)
+{
+    m_e_local_positioning_type = EPositioningType::Relative;
+}
+
+void GCodeProcessor::processT(const GCodeReader::GCodeLine& line)
+{
+    const std::string& cmd = line.cmd();
+    if (cmd.length() > 1)
+    {
+        unsigned int id = (unsigned int)std::stoi(cmd.substr(1));
+        if (m_extruder_id != id)
+        {
+            unsigned int extruders_count = (unsigned int)m_extruder_offsets.size();
+            if (id >= extruders_count)
+                BOOST_LOG_TRIVIAL(error) << "GCodeProcessor encountered an invalid toolchange, maybe from a custom gcode.";
+            else
+            {
+                m_extruder_id = id;
+//                if (_get_cp_color_id() != INT_MAX) <<<<<<<<<<<<<<<<<<< TODO
+//                    _set_cp_color_id(m_extruder_color[id]);
+            }
+
+            // store tool change move
+            store_move_vertex(EMoveType::Tool_change);
+        }
+    }
+}
+
+void GCodeProcessor::store_move_vertex(EMoveType type)
+{
     MoveVertex vertex;
-    vertex.position = Vec3d(m_end_position[0], m_end_position[1], m_end_position[2]) + extruder_offset;
+    vertex.type = type;
+    vertex.extrusion_role = m_extrusion_role;
+    vertex.position = Vec3f(m_end_position[0], m_end_position[1], m_end_position[2]) + m_extruder_offsets[m_extruder_id];
     vertex.feedrate = m_feedrate;
-    vertex.type = move_type;
+    vertex.width = m_width;
+    vertex.height = m_height;
+    vertex.extruder_id = m_extruder_id;
     m_result.moves.emplace_back(vertex);
-
-/*
-    std::cout << "start: ";
-    for (unsigned char a = X; a <= E; ++a)
-    {
-        std::cout << m_start_position[a];
-        if (a != E)
-            std::cout << ", ";
-    }
-    std::cout << " - end: ";
-    for (unsigned char a = X; a <= E; ++a)
-    {
-        std::cout << m_end_position[a];
-        if (a != E)
-            std::cout << ", ";
-    }
-    std::cout << "\n";
-*/
 }
 
 } /* namespace Slic3r */

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -3,11 +3,19 @@
 
 #if ENABLE_GCODE_VIEWER
 #include "../GCodeReader.hpp"
+#include "../Point.hpp"
+#include "../ExtrusionEntity.hpp"
 
 namespace Slic3r {
 
     class GCodeProcessor
     {
+    public:
+        static const std::string Extrusion_Role_Tag;
+        static const std::string Width_Tag;
+        static const std::string Height_Tag;
+
+    private:
         using AxisCoords = std::array<float, 4>;
 
         enum class EUnits : unsigned char
@@ -33,16 +41,29 @@ namespace Slic3r {
             Num_Types
         };
 
+    public:
         struct MoveVertex
         {
-            Vec3d position{ Vec3d::Zero() }; // mm
-            float feedrate{ 0.0f }; // mm/s
-            // type of the move terminating at this vertex
             EMoveType type{ EMoveType::Noop };
-        };
+            ExtrusionRole extrusion_role{ erNone };
+            Vec3f position{ Vec3f::Zero() }; // mm
+            float feedrate{ 0.0f }; // mm/s
+            float width{ 0.0f }; // mm
+            float height{ 0.0f }; // mm
+            unsigned int extruder_id{ 0 };
 
-    public:
+            std::string to_string() const
-        typedef std::map<unsigned int, Vec2d> ExtruderOffsetsMap;
+            {
+                std::string str = std::to_string((int)type);
+                str += ", " + std::to_string((int)extrusion_role);
+                str += ", " + Slic3r::to_string((Vec3d)position.cast<double>());
+                str += ", " + std::to_string(extruder_id);
+                str += ", " + std::to_string(feedrate);
+                str += ", " + std::to_string(width);
+                str += ", " + std::to_string(height);
+                return str;
+            }
+        };
 
         struct Result
         {
@@ -56,25 +77,26 @@ namespace Slic3r {
         EUnits m_units;
         EPositioningType m_global_positioning_type;
         EPositioningType m_e_local_positioning_type;
+        std::vector<Vec3f> m_extruder_offsets;
 
         AxisCoords m_start_position; // mm
         AxisCoords m_end_position;   // mm
         AxisCoords m_origin;         // mm
 
         float m_feedrate; // mm/s
+        float m_width;    // mm
+        float m_height;   // mm
+        ExtrusionRole m_extrusion_role;
         unsigned int m_extruder_id;
-        ExtruderOffsetsMap m_extruder_offsets;
 
         Result m_result;
 
     public:
         GCodeProcessor() { reset(); }
 
-        void apply_config(const PrintConfig& config) { m_parser.apply_config(config); }
+        void apply_config(const PrintConfig& config);
         void reset();
 
-        void set_extruder_offsets(const ExtruderOffsetsMap& extruder_offsets) { m_extruder_offsets = extruder_offsets; }
-
         const Result& get_result() const { return m_result; }
         Result&& extract_result() { return std::move(m_result); }
 
@@ -86,11 +108,31 @@ namespace Slic3r {
         void process_gcode_line(const GCodeReader::GCodeLine& line);
 
         // Process tags embedded into comments
-        void process_comment(const GCodeReader::GCodeLine& line);
+        void process_tags(const std::string& comment);
 
         // Move
         void process_G1(const GCodeReader::GCodeLine& line);
-    };
+
+        // Set to Absolute Positioning
+        void processG90(const GCodeReader::GCodeLine& line);
+
+        // Set to Relative Positioning
+        void processG91(const GCodeReader::GCodeLine& line);
+
+        // Set Position
+        void processG92(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to absolute mode
+        void processM82(const GCodeReader::GCodeLine& line);
+
+        // Set extruder to relative mode
+        void processM83(const GCodeReader::GCodeLine& line);
+
+        // Processes T line (Select Tool)
+        void processT(const GCodeReader::GCodeLine& line);
+
+        void store_move_vertex(EMoveType type);
+   };
 
 } /* namespace Slic3r */
 

src/libslic3r/GCode/WipeTower.cpp

@@ -22,6 +22,9 @@ TODO LIST
 #include <numeric>
 
 #include "Analyzer.hpp"
+#if ENABLE_GCODE_VIEWER
+#include "GCodeProcessor.hpp"
+#endif // ENABLE_GCODE_VIEWER
 #include "BoundingBox.hpp"
 
 #if defined(__linux) || defined(__GNUC__ )
@@ -55,7 +58,15 @@ public:
             char buf[64];
             sprintf(buf, ";%s%f\n", GCodeAnalyzer::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
             m_gcode += buf;
+#if ENABLE_GCODE_VIEWER
+            sprintf(buf, ";%s%f\n", GCodeProcessor::Height_Tag.c_str(), m_layer_height); // don't rely on GCodeAnalyzer knowing the layer height - it knows nothing at priming
+            m_gcode += buf;
+#endif // ENABLE_GCODE_VIEWER
             sprintf(buf, ";%s%d\n", GCodeAnalyzer::Extrusion_Role_Tag.c_str(), erWipeTower);
+#if ENABLE_GCODE_VIEWER
+            m_gcode += buf;
+            sprintf(buf, ";%s%d\n", GCodeProcessor::Extrusion_Role_Tag.c_str(), erWipeTower);
+#endif // ENABLE_GCODE_VIEWER
             m_gcode += buf;
             change_analyzer_line_width(line_width);
         }
@@ -65,6 +76,10 @@ public:
             char buf[64];
             sprintf(buf, ";%s%f\n", GCodeAnalyzer::Width_Tag.c_str(), line_width);
             m_gcode += buf;
+#if ENABLE_GCODE_VIEWER
+            sprintf(buf, ";%s%f\n", GCodeProcessor::Width_Tag.c_str(), line_width);
+            m_gcode += buf;
+#endif // ENABLE_GCODE_VIEWER
             return *this;
     }
 

src/libslic3r/Technologies.hpp

@@ -60,14 +60,9 @@
 // Moves GLCanvas3DManager from being a static member of _3DScene to be a normal member of GUI_App
 #define ENABLE_NON_STATIC_CANVAS_MANAGER (1 && ENABLE_2_3_0_ALPHA1)
 
-
-//==================
-// 2.3.0.alpha1 techs
-//==================
-#define ENABLE_2_3_0_ALPHA1 1
-
 // Enable G-Code viewer
 #define ENABLE_GCODE_VIEWER (1 && ENABLE_2_3_0_ALPHA1)
+#define ENABLE_GCODE_VIEWER_DEBUG_OUTPUT (1 && ENABLE_GCODE_VIEWER)
 
 
 #endif // _prusaslicer_technologies_h_

src/slic3r/GUI/GLCanvas3D.cpp

@@ -2772,6 +2772,16 @@ static void load_gcode_retractions(const GCodePreviewData::Retraction& retractio
 #if ENABLE_GCODE_VIEWER
 void GLCanvas3D::load_gcode_preview_2(const GCodeProcessor::Result& gcode_result)
 {
+#if ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
+    boost::filesystem::path path("d:/processor.output");
+    boost::nowide::ofstream out;
+    out.open(path.string());
+    for (const GCodeProcessor::MoveVertex& v : gcode_result.moves)
+    {
+        out << v.to_string() << "\n";
+    }
+    out.close();
+#endif // ENABLE_GCODE_VIEWER_DEBUG_OUTPUT
 }
 #endif // ENABLE_GCODE_VIEWER