Merge branch 'master' of https://github.com/prusa3d/PrusaSlicer into et_new_camera_movements

resources/profiles/Creality.idx

@@ -1,3 +1,5 @@
+min_slic3r_version = 2.4.1
+0.1.4 Added Ender-3 Pro. Added M25 support for some printers.
 min_slic3r_version = 2.4.0-rc
 0.1.3 Ender-3 S1 improvements.
 0.1.2 Added alpha Ender 3 S1 profiles.

resources/profiles/Creality.ini

@@ -5,7 +5,7 @@
 name = Creality
 # Configuration version of this file. Config file will only be installed, if the config_version differs.
 # This means, the server may force the PrusaSlicer configuration to be downgraded.
-config_version = 0.1.3
+config_version = 0.1.4
 # Where to get the updates from?
 config_update_url = https://files.prusa3d.com/wp-content/uploads/repository/PrusaSlicer-settings-master/live/Creality/
 # changelog_url = https://files.prusa3d.com/?latest=slicer-profiles&lng=%1%
@@ -32,6 +32,15 @@ bed_model = ender3_bed.stl
 bed_texture = ender3.svg
 default_materials = Generic PLA @CREALITY; Generic PETG @CREALITY; Generic ABS @CREALITY; Creality PLA @CREALITY; Prusament PLA @CREALITY; Prusament PETG @CREALITY; AzureFilm PLA @CREALITY; Devil Design PLA @CREALITY; Devil Design PLA Matt @CREALITY; Devil Design PLA Galaxy @CREALITY; Extrudr PLA NX2 @CREALITY; Real Filament PLA @CREALITY; Velleman PLA @CREALITY; 3DJAKE ecoPLA @CREALITY; 3DJAKE ecoPLA Matt @CREALITY; 3DJAKE ecoPLA Tough @CREALITY; 123-3D Jupiter PLA @CREALITY
 
+[printer_model:ENDER3PRO]
+name = Creality Ender-3 Pro
+variants = 0.4
+technology = FFF
+family = ENDER
+bed_model = ender3_bed.stl
+bed_texture = ender3.svg
+default_materials = Generic PLA @CREALITY; Generic PETG @CREALITY; Generic ABS @CREALITY; Creality PLA @CREALITY; Prusament PLA @CREALITY; Prusament PETG @CREALITY; AzureFilm PLA @CREALITY; Devil Design PLA @CREALITY; Devil Design PLA Matt @CREALITY; Devil Design PLA Galaxy @CREALITY; Extrudr PLA NX2 @CREALITY; Real Filament PLA @CREALITY; Velleman PLA @CREALITY; 3DJAKE ecoPLA @CREALITY; 3DJAKE ecoPLA Matt @CREALITY; 3DJAKE ecoPLA Tough @CREALITY; 123-3D Jupiter PLA @CREALITY
+
 [printer_model:ENDER3V2]
 name = Creality Ender-3 V2
 variants = 0.4
@@ -960,8 +969,16 @@ inherits = Creality Ender-3; *fastabl*
 renamed_from = "Creality ENDER-3 BLTouch"
 printer_model = ENDER3BLTOUCH
 
+[printer:Creality Ender-3 Pro]
+inherits = *common*; *pauseprint*
+renamed_from = "Creality Ender-3 Pro"
+bed_shape = 5x0,215x0,215x220,5x220
+max_print_height = 250
+printer_model = ENDER3PRO
+printer_notes = Don't remove the following keywords! These keywords are used in the "compatible printer" condition of the print and filament profiles to link the particular print and filament profiles to this printer profile.\nPRINTER_VENDOR_CREALITY\nPRINTER_MODEL_ENDER3PRO\nPRINTER_HAS_BOWDEN
+
 [printer:Creality Ender-3 V2]
-inherits = *common*
+inherits = *common*; *pauseprint*
 renamed_from = "Creality Ender-3V2"
 bed_shape = 5x0,215x0,215x220,5x220
 max_print_height = 250
@@ -969,14 +986,14 @@ printer_model = ENDER3V2
 printer_notes = Don't remove the following keywords! These keywords are used in the "compatible printer" condition of the print and filament profiles to link the particular print and filament profiles to this printer profile.\nPRINTER_VENDOR_CREALITY\nPRINTER_MODEL_ENDER3V2\nPRINTER_HAS_BOWDEN
 
 [printer:Creality Ender-3 S1]
-inherits = *common*; *spriteextruder*
+inherits = *common*; *pauseprint*; *spriteextruder*
 bed_shape = 5x0,215x0,215x220,5x220
 max_print_height = 270
 printer_model = ENDER3S1
 printer_notes = Don't remove the following keywords! These keywords are used in the "compatible printer" condition of the print and filament profiles to link the particular print and filament profiles to this printer profile.\nPRINTER_VENDOR_CREALITY\nPRINTER_MODEL_ENDER3S1
 
 [printer:Creality Ender-3 Max]
-inherits = *common*
+inherits = *common*; *pauseprint*
 retract_length = 6
 bed_shape = 5x5,295x5,295x295,5x295
 max_print_height = 340

resources/shaders/imgui.fs

@@ -0,0 +1,11 @@
+#version 110
+
+uniform sampler2D Texture;
+
+varying vec2 Frag_UV;
+varying vec4 Frag_Color;
+
+void main()
+{
+	gl_FragColor = Frag_Color * texture2D(Texture, Frag_UV.st);
+}

resources/shaders/imgui.vs

@@ -0,0 +1,17 @@
+#version 110
+
+uniform mat4 ProjMtx;
+
+attribute vec2 Position;
+attribute vec2 UV;
+attribute vec4 Color;
+
+varying vec2 Frag_UV;
+varying vec4 Frag_Color;
+
+void main()
+{
+	Frag_UV = UV;
+	Frag_Color = Color;
+    gl_Position = ProjMtx * vec4(Position.xy, 0.0, 1.0);
+}

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -1952,13 +1952,16 @@ void GCodeProcessor::process_tags(const std::string_view comment, bool producers
         ++m_layer_id;
 #if ENABLE_SPIRAL_VASE_LAYERS
         if (m_spiral_vase_active) {
-            assert(!m_result.moves.empty());
+            if (m_result.moves.empty())
-            size_t move_id = m_result.moves.size() - 1;
+                m_result.spiral_vase_layers.push_back({ m_first_layer_height, { 0, 0 } });
+            else {
+                const size_t move_id = m_result.moves.size() - 1;
                 if (!m_result.spiral_vase_layers.empty() && m_end_position[Z] == m_result.spiral_vase_layers.back().first)
                     m_result.spiral_vase_layers.back().second.second = move_id;
                 else
                     m_result.spiral_vase_layers.push_back({ static_cast<float>(m_end_position[Z]), { move_id, move_id } });
             }
+        }
 #endif // ENABLE_SPIRAL_VASE_LAYERS
         return;
     }

src/libslic3r/Technologies.hpp

@@ -34,8 +34,6 @@
 #define ENABLE_ENVIRONMENT_MAP 0
 // Enable smoothing of objects normals
 #define ENABLE_SMOOTH_NORMALS 0
-// Enable rendering markers for options in preview as fixed screen size points
-#define ENABLE_FIXED_SCREEN_SIZE_POINT_MARKERS 1
 
 
 //================
@@ -70,6 +68,8 @@
 #define ENABLE_LEGACY_OPENGL_REMOVAL (1 && ENABLE_2_5_0_ALPHA1)
 // Enable using vertex attributes and matrices in shaders
 #define ENABLE_GL_SHADERS_ATTRIBUTES (1 && ENABLE_LEGACY_OPENGL_REMOVAL)
+// Enable rendering imgui using shaders
+#define ENABLE_GL_IMGUI_SHADERS (1 && ENABLE_GL_SHADERS_ATTRIBUTES)
 // Shows an imgui dialog with GLModel statistics data
 #define ENABLE_GLMODEL_STATISTICS (0 && ENABLE_LEGACY_OPENGL_REMOVAL)
 // Enable show non-manifold edges

src/slic3r/GUI/3DBed.cpp

@@ -515,7 +515,7 @@ void Bed3D::render_system(GLCanvas3D& canvas, const Transform3d& view_matrix, co
         render_model(view_matrix, projection_matrix);
 
     if (show_texture)
-        render_texture(bottom, canvas);
+        render_texture(bottom, canvas, view_matrix, projection_matrix);
 }
 #else
 void Bed3D::render_system(GLCanvas3D& canvas, bool bottom, bool show_texture)
@@ -528,11 +528,19 @@ void Bed3D::render_system(GLCanvas3D& canvas, bool bottom, bool show_texture)
 }
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas, const Transform3d& view_matrix, const Transform3d& projection_matrix)
+#else
 void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 {
     if (m_texture_filename.empty()) {
         m_texture.reset();
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+        render_default(bottom, false, view_matrix, projection_matrix);
+#else
         render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
         return;
     }
 
@@ -545,7 +553,11 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
             if (m_temp_texture.get_id() == 0 || m_temp_texture.get_source() != m_texture_filename) {
                 // generate a temporary lower resolution texture to show while no main texture levels have been compressed
                 if (!m_temp_texture.load_from_svg_file(m_texture_filename, false, false, false, max_tex_size / 8)) {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+                    render_default(bottom, false, view_matrix, projection_matrix);
+#else
                     render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
                     return;
                 }
                 canvas.request_extra_frame();
@@ -553,7 +565,11 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
 
             // starts generating the main texture, compression will run asynchronously
             if (!m_texture.load_from_svg_file(m_texture_filename, true, true, true, max_tex_size)) {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+                render_default(bottom, false, view_matrix, projection_matrix);
+#else
                 render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
                 return;
             }
         } 
@@ -561,7 +577,11 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
             // generate a temporary lower resolution texture to show while no main texture levels have been compressed
             if (m_temp_texture.get_id() == 0 || m_temp_texture.get_source() != m_texture_filename) {
                 if (!m_temp_texture.load_from_file(m_texture_filename, false, GLTexture::None, false)) {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+                    render_default(bottom, false, view_matrix, projection_matrix);
+#else
                     render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
                     return;
                 }
                 canvas.request_extra_frame();
@@ -569,12 +589,20 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
 
             // starts generating the main texture, compression will run asynchronously
             if (!m_texture.load_from_file(m_texture_filename, true, GLTexture::MultiThreaded, true)) {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+                render_default(bottom, false, view_matrix, projection_matrix);
+#else
                 render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
                 return;
             }
         }
         else {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+            render_default(bottom, false, view_matrix, projection_matrix);
+#else
             render_default(bottom, false);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
             return;
         }
     }
@@ -600,9 +628,8 @@ void Bed3D::render_texture(bool bottom, GLCanvas3D& canvas)
     if (shader != nullptr) {
         shader->start_using();
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-        const Camera& camera = wxGetApp().plater()->get_camera();
+        shader->set_uniform("view_model_matrix", view_matrix);
-        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
+        shader->set_uniform("projection_matrix", projection_matrix);
-        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
         shader->set_uniform("transparent_background", bottom);
         shader->set_uniform("svg_source", boost::algorithm::iends_with(m_texture.get_source(), ".svg"));
@@ -754,7 +781,11 @@ void Bed3D::render_custom(GLCanvas3D& canvas, bool bottom, bool show_texture, bo
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 {
     if (m_texture_filename.empty() && m_model_filename.empty()) {
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+        render_default(bottom, picking, view_matrix, projection_matrix);
+#else
         render_default(bottom, picking);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
         return;
     }
 
@@ -766,10 +797,18 @@ void Bed3D::render_custom(GLCanvas3D& canvas, bool bottom, bool show_texture, bo
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
     if (show_texture)
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+        render_texture(bottom, canvas, view_matrix, projection_matrix);
+#else
         render_texture(bottom, canvas);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 }
 
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+void Bed3D::render_default(bool bottom, bool picking, const Transform3d& view_matrix, const Transform3d& projection_matrix)
+#else
 void Bed3D::render_default(bool bottom, bool picking)
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 {
     m_texture.reset();
 
@@ -786,9 +825,8 @@ void Bed3D::render_default(bool bottom, bool picking)
         shader->start_using();
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-        const Camera& camera = wxGetApp().plater()->get_camera();
+        shader->set_uniform("view_model_matrix", view_matrix);
-        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
+        shader->set_uniform("projection_matrix", projection_matrix);
-        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
         glsafe(::glEnable(GL_DEPTH_TEST));

src/slic3r/GUI/3DBed.hpp

@@ -168,18 +168,18 @@ private:
     void render_axes();
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     void render_system(GLCanvas3D& canvas, const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool show_texture);
-#else
+    void render_texture(bool bottom, GLCanvas3D& canvas, const Transform3d& view_matrix, const Transform3d& projection_matrix);
-    void render_system(GLCanvas3D& canvas, bool bottom, bool show_texture);
-#endif // ENABLE_GL_SHADERS_ATTRIBUTES
-    void render_texture(bool bottom, GLCanvas3D& canvas);
-#if ENABLE_GL_SHADERS_ATTRIBUTES
     void render_model(const Transform3d& view_matrix, const Transform3d& projection_matrix);
     void render_custom(GLCanvas3D& canvas, const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool show_texture, bool picking);
+    void render_default(bool bottom, bool picking, const Transform3d& view_matrix, const Transform3d& projection_matrix);
 #else
+    void render_system(GLCanvas3D& canvas, bool bottom, bool show_texture);
+    void render_texture(bool bottom, GLCanvas3D& canvas);
     void render_model();
     void render_custom(GLCanvas3D& canvas, bool bottom, bool show_texture, bool picking);
-#endif // ENABLE_GL_SHADERS_ATTRIBUTES
     void render_default(bool bottom, bool picking);
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
+
 #if !ENABLE_LEGACY_OPENGL_REMOVAL
     void release_VBOs();
 #endif // !ENABLE_LEGACY_OPENGL_REMOVAL

src/slic3r/GUI/GCodeViewer.cpp

@@ -459,6 +459,7 @@ void GCodeViewer::SequentialView::GCodeWindow::render(float top, float bottom, u
     static const ImVec4 COMMAND_COLOR        = { 0.8f, 0.8f, 0.0f, 1.0f };
     static const ImVec4 PARAMETERS_COLOR     = { 1.0f, 1.0f, 1.0f, 1.0f };
     static const ImVec4 COMMENT_COLOR        = { 0.7f, 0.7f, 0.7f, 1.0f };
+    static const ImVec4 ELLIPSIS_COLOR       = { 0.0f, 0.7f, 0.0f, 1.0f };
 
     if (!m_visible || m_filename.empty() || m_lines_ends.empty() || curr_line_id == 0)
         return;
@@ -503,6 +504,35 @@ void GCodeViewer::SequentialView::GCodeWindow::render(float top, float bottom, u
 
     ImGuiWrapper& imgui = *wxGetApp().imgui();
 
+    auto add_item_to_line = [&imgui](const std::string& txt, const ImVec4& color, float spacing, size_t& current_length) {
+        static const size_t LENGTH_THRESHOLD = 60;
+
+        if (txt.empty())
+            return false;
+
+        std::string out_text = txt;
+        bool reduced = false;
+        if (current_length + out_text.length() > LENGTH_THRESHOLD) {
+            out_text = out_text.substr(0, LENGTH_THRESHOLD - current_length);
+            reduced = true;
+        }
+
+        current_length += out_text.length();
+
+        ImGui::SameLine(0.0f, spacing);
+        ImGui::PushStyleColor(ImGuiCol_Text, color);
+        imgui.text(out_text);
+        ImGui::PopStyleColor();
+        if (reduced) {
+            ImGui::SameLine(0.0f, 0.0f);
+            ImGui::PushStyleColor(ImGuiCol_Text, ELLIPSIS_COLOR);
+            imgui.text("...");
+            ImGui::PopStyleColor();
+        }
+
+        return reduced;
+    };
+
     imgui.set_next_window_pos(0.0f, top, ImGuiCond_Always, 0.0f, 0.0f);
     imgui.set_next_window_size(0.0f, wnd_height, ImGuiCond_Always);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
@@ -527,41 +557,22 @@ void GCodeViewer::SequentialView::GCodeWindow::render(float top, float bottom, u
                 ImGui::GetColorU32(SELECTION_RECT_COLOR));
         }
 
-        // render line number
         const std::string id_str = std::to_string(id);
         // spacer to right align text
         ImGui::Dummy({ id_width - ImGui::CalcTextSize(id_str.c_str()).x, text_height });
-        ImGui::SameLine(0.0f, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_Text, LINE_NUMBER_COLOR);
-        imgui.text(id_str);
-        ImGui::PopStyleColor();
-
-        if (!line.command.empty() || !line.comment.empty())
-            ImGui::SameLine();
 
+        size_t line_length = 0;
+        // render line number
+        bool stop_adding = add_item_to_line(id_str, LINE_NUMBER_COLOR, 0.0f, line_length);
+        if (!stop_adding && !line.command.empty())
             // render command
-        if (!line.command.empty()) {
+            stop_adding = add_item_to_line(line.command, COMMAND_COLOR, -1.0f, line_length);
-            ImGui::PushStyleColor(ImGuiCol_Text, COMMAND_COLOR);
+        if (!stop_adding && !line.parameters.empty())
-            imgui.text(line.command);
-            ImGui::PopStyleColor();
-        }
-
             // render parameters
-        if (!line.parameters.empty()) {
+            stop_adding = add_item_to_line(line.parameters, PARAMETERS_COLOR, 0.0f, line_length);
-            ImGui::SameLine(0.0f, 0.0f);
+        if (!stop_adding && !line.comment.empty())
-            ImGui::PushStyleColor(ImGuiCol_Text, PARAMETERS_COLOR);
-            imgui.text(line.parameters);
-            ImGui::PopStyleColor();
-        }
-
             // render comment
-        if (!line.comment.empty()) {
+            stop_adding = add_item_to_line(line.comment, COMMENT_COLOR, line.command.empty() ? -1.0f : 0.0f, line_length);
-            if (!line.command.empty())
-                ImGui::SameLine(0.0f, 0.0f);
-            ImGui::PushStyleColor(ImGuiCol_Text, COMMENT_COLOR);
-            imgui.text(line.comment);
-            ImGui::PopStyleColor();
-        }
     }
 
     imgui.end();
@@ -1310,18 +1321,6 @@ void GCodeViewer::load_toolpaths(const GCodeProcessorResult& gcode_result)
         log_memory_used(label, vertices_size + indices_size);
     };
 
-    // format data into the buffers to be rendered as points
-    auto add_vertices_as_point = [](const GCodeProcessorResult::MoveVertex& curr, VertexBuffer& vertices) {
-        vertices.push_back(curr.position.x());
-        vertices.push_back(curr.position.y());
-        vertices.push_back(curr.position.z());
-    };
-    auto add_indices_as_point = [](const GCodeProcessorResult::MoveVertex& curr, TBuffer& buffer,
-        unsigned int ibuffer_id, IndexBuffer& indices, size_t move_id) {
-            buffer.add_path(curr, ibuffer_id, indices.size(), move_id);
-            indices.push_back(static_cast<IBufferType>(indices.size()));
-    };
-
     // format data into the buffers to be rendered as lines
     auto add_vertices_as_line = [](const GCodeProcessorResult::MoveVertex& prev, const GCodeProcessorResult::MoveVertex& curr, VertexBuffer& vertices) {
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
@@ -1816,7 +1815,6 @@ void GCodeViewer::load_toolpaths(const GCodeProcessorResult& gcode_result)
 
         switch (t_buffer.render_primitive_type)
         {
-        case TBuffer::ERenderPrimitiveType::Point:    { add_vertices_as_point(curr, v_buffer); break; }
         case TBuffer::ERenderPrimitiveType::Line:     { add_vertices_as_line(prev, curr, v_buffer); break; }
 #if ENABLE_VOLUMETRIC_RATE_TOOLPATHS_RECALC
         case TBuffer::ERenderPrimitiveType::Triangle: { add_vertices_as_solid(prev, curr, t_buffer, static_cast<unsigned int>(v_multibuffer.size()) - 1, v_buffer, move_id, account_for_volumetric_rate); break; }
@@ -2152,8 +2150,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessorResult& gcode_result)
         if (i_multibuffer.back().size() * sizeof(IBufferType) >= IBUFFER_THRESHOLD_BYTES - indiced_size_to_add) {
             i_multibuffer.push_back(IndexBuffer());
             vbo_index_list.push_back(t_buffer.vertices.vbos[curr_vertex_buffer.first]);
-            if (t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::Point &&
+            if (t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::BatchedModel) {
-                t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::BatchedModel) {
                 Path& last_path = t_buffer.paths.back();
                 last_path.add_sub_path(prev, static_cast<unsigned int>(i_multibuffer.size()) - 1, 0, move_id - 1);
             }
@@ -2169,8 +2166,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessorResult& gcode_result)
             curr_vertex_buffer.second = 0;
             vbo_index_list.push_back(t_buffer.vertices.vbos[curr_vertex_buffer.first]);
 
-            if (t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::Point &&
+            if (t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::BatchedModel) {
-                t_buffer.render_primitive_type != TBuffer::ERenderPrimitiveType::BatchedModel) {
                 Path& last_path = t_buffer.paths.back();
                 last_path.add_sub_path(prev, static_cast<unsigned int>(i_multibuffer.size()) - 1, 0, move_id - 1);
             }
@@ -2180,11 +2176,6 @@ void GCodeViewer::load_toolpaths(const GCodeProcessorResult& gcode_result)
 
         switch (t_buffer.render_primitive_type)
         {
-        case TBuffer::ERenderPrimitiveType::Point: {
-            add_indices_as_point(curr, t_buffer, static_cast<unsigned int>(i_multibuffer.size()) - 1, i_buffer, move_id);
-            curr_vertex_buffer.second += t_buffer.max_vertices_per_segment();
-            break;
-        }
         case TBuffer::ERenderPrimitiveType::Line: {
 #if ENABLE_VOLUMETRIC_RATE_TOOLPATHS_RECALC
             add_indices_as_line(prev, curr, t_buffer, static_cast<unsigned int>(i_multibuffer.size()) - 1, i_buffer, move_id, account_for_volumetric_rate);
@@ -2732,10 +2723,6 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
         unsigned int size_in_indices = 0;
         switch (buffer.render_primitive_type)
         {
-        case TBuffer::ERenderPrimitiveType::Point: {
-            size_in_indices = buffer.indices_per_segment();
-            break;
-        }
         case TBuffer::ERenderPrimitiveType::Line:
         case TBuffer::ERenderPrimitiveType::Triangle: {
             unsigned int segments_count = std::min(m_sequential_view.current.last, sub_path.last.s_id) - std::max(m_sequential_view.current.first, sub_path.first.s_id);
@@ -2968,11 +2955,7 @@ void GCodeViewer::refresh_render_paths(bool keep_sequential_current_first, bool
 
 void GCodeViewer::render_toolpaths()
 {
-#if ENABLE_FIXED_SCREEN_SIZE_POINT_MARKERS
-    const float point_size = 20.0f;
-#else
     const float point_size = 0.8f;
-#endif // ENABLE_FIXED_SCREEN_SIZE_POINT_MARKERS
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
     const std::array<float, 4> light_intensity = { 0.25f, 0.70f, 0.75f, 0.75f };
 #endif // !ENABLE_GL_SHADERS_ATTRIBUTES
@@ -2982,43 +2965,6 @@ void GCodeViewer::render_toolpaths()
     const float near_plane_height = camera.get_type() == Camera::EType::Perspective ? static_cast<float>(viewport[3]) / (2.0f * static_cast<float>(2.0 * std::tan(0.5 * Geometry::deg2rad(camera.get_fov())))) :
         static_cast<float>(viewport[3]) * 0.0005;
 
-    auto shader_init_as_points = [zoom, point_size, near_plane_height](GLShaderProgram& shader) {
-#if ENABLE_FIXED_SCREEN_SIZE_POINT_MARKERS
-        shader.set_uniform("use_fixed_screen_size", 1);
-#else
-        shader.set_uniform("use_fixed_screen_size", 0);
-#endif // ENABLE_FIXED_SCREEN_SIZE_POINT_MARKERS
-        shader.set_uniform("zoom", zoom);
-        shader.set_uniform("percent_outline_radius", 0.0f);
-        shader.set_uniform("percent_center_radius", 0.33f);
-        shader.set_uniform("point_size", point_size);
-        shader.set_uniform("near_plane_height", near_plane_height);
-    };
-
-    auto render_as_points = [
-#if ENABLE_GCODE_VIEWER_STATISTICS
-        this
-#endif // ENABLE_GCODE_VIEWER_STATISTICS
-    ](std::vector<RenderPath>::iterator it_path, std::vector<RenderPath>::iterator it_end, GLShaderProgram& shader, int uniform_color) {
-        glsafe(::glEnable(GL_VERTEX_PROGRAM_POINT_SIZE));
-        glsafe(::glEnable(GL_POINT_SPRITE));
-
-        for (auto it = it_path; it != it_end && it_path->ibuffer_id == it->ibuffer_id; ++it) {
-            const RenderPath& path = *it;
-            // Some OpenGL drivers crash on empty glMultiDrawElements, see GH #7415.
-            assert(! path.sizes.empty());
-            assert(! path.offsets.empty());
-            shader.set_uniform(uniform_color, path.color);
-            glsafe(::glMultiDrawElements(GL_POINTS, (const GLsizei*)path.sizes.data(), GL_UNSIGNED_SHORT, (const void* const*)path.offsets.data(), (GLsizei)path.sizes.size()));
-#if ENABLE_GCODE_VIEWER_STATISTICS
-            ++m_statistics.gl_multi_points_calls_count;
-#endif // ENABLE_GCODE_VIEWER_STATISTICS
-        }
-
-        glsafe(::glDisable(GL_POINT_SPRITE));
-        glsafe(::glDisable(GL_VERTEX_PROGRAM_POINT_SIZE));
-    };
-
 #if !ENABLE_GL_SHADERS_ATTRIBUTES
         auto shader_init_as_lines = [light_intensity](GLShaderProgram &shader) {
         shader.set_uniform("light_intensity", light_intensity);
@@ -3194,15 +3140,10 @@ void GCodeViewer::render_toolpaths()
         shader->start_using();
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-        int position_id = -1;
-        int normal_id = -1;
         const Transform3d& view_matrix = camera.get_view_matrix();
         shader->set_uniform("view_model_matrix", view_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
         shader->set_uniform("normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
-
-        position_id = shader->get_attrib_location("v_position");
-        normal_id   = shader->get_attrib_location("v_normal");
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
         if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::InstancedModel) {
@@ -3213,6 +3154,8 @@ void GCodeViewer::render_toolpaths()
         else if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::BatchedModel) {
             shader->set_uniform("emission_factor", 0.25f);
 #if ENABLE_GL_SHADERS_ATTRIBUTES
+            const int position_id = shader->get_attrib_location("v_position");
+            const int normal_id   = shader->get_attrib_location("v_normal");
             render_as_batched_model(buffer, *shader, position_id, normal_id);
 #else
             render_as_batched_model(buffer, *shader);
@@ -3221,8 +3164,8 @@ void GCodeViewer::render_toolpaths()
         }
         else {
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-            if (buffer.render_primitive_type == TBuffer::ERenderPrimitiveType::Point)
+            const int position_id = shader->get_attrib_location("v_position");
-                shader_init_as_points(*shader);
+            const int normal_id   = shader->get_attrib_location("v_normal");
 #else
             switch (buffer.render_primitive_type) {
             case TBuffer::ERenderPrimitiveType::Point: shader_init_as_points(*shader); break;
@@ -3269,10 +3212,6 @@ void GCodeViewer::render_toolpaths()
                 // Render all elements with it_path->ibuffer_id == ibuffer_id, possible with varying colors.
                 switch (buffer.render_primitive_type)
                 {
-                case TBuffer::ERenderPrimitiveType::Point: {
-                    render_as_points(it_path, buffer.render_paths.end(), *shader, uniform_color);
-                    break;
-                }
                 case TBuffer::ERenderPrimitiveType::Line: {
                     glsafe(::glLineWidth(static_cast<GLfloat>(line_width(zoom))));
                     render_as_lines(it_path, buffer.render_paths.end(), *shader, uniform_color);
@@ -3319,16 +3258,14 @@ void GCodeViewer::render_toolpaths()
         shader->start_using();
 
 #if ENABLE_GL_SHADERS_ATTRIBUTES
-        int position_id = -1;
-        int normal_id = -1;
         const Camera& camera = wxGetApp().plater()->get_camera();
         const Transform3d& view_matrix = camera.get_view_matrix();
         shader->set_uniform("view_model_matrix", view_matrix);
         shader->set_uniform("projection_matrix", camera.get_projection_matrix());
         shader->set_uniform("normal_matrix", (Matrix3d)view_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
 
-        position_id = shader->get_attrib_location("v_position");
+        const int position_id = shader->get_attrib_location("v_position");
-        normal_id   = shader->get_attrib_location("v_normal");
+        const int normal_id   = shader->get_attrib_location("v_normal");
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
         glsafe(::glBindBuffer(GL_ARRAY_BUFFER, cap.vbo));
@@ -4682,7 +4619,6 @@ void GCodeViewer::render_statistics()
     }
 
     if (ImGui::CollapsingHeader("OpenGL calls")) {
-        add_counter(std::string("Multi GL_POINTS:"), m_statistics.gl_multi_points_calls_count);
         add_counter(std::string("Multi GL_LINES:"), m_statistics.gl_multi_lines_calls_count);
         add_counter(std::string("Multi GL_TRIANGLES:"), m_statistics.gl_multi_triangles_calls_count);
         add_counter(std::string("GL_TRIANGLES:"), m_statistics.gl_triangles_calls_count);

src/slic3r/GUI/GCodeViewer.hpp

@@ -284,7 +284,6 @@ class GCodeViewer
     {
         enum class ERenderPrimitiveType : unsigned char
         {
-            Point,
             Line,
             Triangle,
             InstancedModel,
@@ -325,7 +324,6 @@ class GCodeViewer
         unsigned int max_vertices_per_segment() const {
             switch (render_primitive_type)
             {
-            case ERenderPrimitiveType::Point:    { return 1; }
             case ERenderPrimitiveType::Line:     { return 2; }
             case ERenderPrimitiveType::Triangle: { return 8; }
             default:                             { return 0; }
@@ -337,7 +335,6 @@ class GCodeViewer
         unsigned int indices_per_segment() const {
             switch (render_primitive_type)
             {
-            case ERenderPrimitiveType::Point:    { return 1; }
             case ERenderPrimitiveType::Line:     { return 2; }
             case ERenderPrimitiveType::Triangle: { return 30; } // 3 indices x 10 triangles
             default:                             { return 0; }
@@ -347,7 +344,6 @@ class GCodeViewer
         unsigned int max_indices_per_segment() const {
             switch (render_primitive_type)
             {
-            case ERenderPrimitiveType::Point:    { return 1; }
             case ERenderPrimitiveType::Line:     { return 2; }
             case ERenderPrimitiveType::Triangle: { return 36; } // 3 indices x 12 triangles
             default:                             { return 0; }
@@ -358,7 +354,6 @@ class GCodeViewer
         bool has_data() const {
             switch (render_primitive_type)
             {
-            case ERenderPrimitiveType::Point:
             case ERenderPrimitiveType::Line:
             case ERenderPrimitiveType::Triangle: {
                 return !vertices.vbos.empty() && vertices.vbos.front() != 0 && !indices.empty() && indices.front().ibo != 0;
@@ -585,7 +580,6 @@ class GCodeViewer
         int64_t refresh_time{ 0 };
         int64_t refresh_paths_time{ 0 };
         // opengl calls
-        int64_t gl_multi_points_calls_count{ 0 };
         int64_t gl_multi_lines_calls_count{ 0 };
         int64_t gl_multi_triangles_calls_count{ 0 };
         int64_t gl_triangles_calls_count{ 0 };
@@ -628,7 +622,6 @@ class GCodeViewer
         }
 
         void reset_opengl() {
-            gl_multi_points_calls_count = 0;
             gl_multi_lines_calls_count = 0;
             gl_multi_triangles_calls_count = 0;
             gl_triangles_calls_count = 0;

src/slic3r/GUI/GLShader.cpp

@@ -122,8 +122,7 @@ bool GLShaderProgram::init_from_texts(const std::string& name, const ShaderSourc
 
     for (size_t i = 0; i < static_cast<size_t>(EShaderType::Count); ++i) {
         const std::string& source = sources[i];
-        if (!source.empty())
+        if (!source.empty()) {
-        {
             EShaderType type = static_cast<EShaderType>(i);
             auto [result, id] = create_shader(type);
             if (result)
@@ -303,6 +302,19 @@ void GLShaderProgram::set_uniform(int id, const Matrix3d& value) const
 }
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
+#if ENABLE_GL_IMGUI_SHADERS
+void GLShaderProgram::set_uniform(int id, const Matrix4f& value) const
+{
+    if (id >= 0)
+        glsafe(::glUniformMatrix4fv(id, 1, GL_FALSE, static_cast<const GLfloat*>(value.data())));
+}
+
+void GLShaderProgram::set_uniform(int id, const Matrix4d& value) const
+{
+    set_uniform(id, (Matrix4f)value.cast<float>());
+}
+#endif // ENABLE_GL_IMGUI_SHADERS
+
 void GLShaderProgram::set_uniform(int id, const Vec3f& value) const
 {
     if (id >= 0)

src/slic3r/GUI/GLShader.hpp

@@ -64,6 +64,10 @@ public:
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     void set_uniform(const char* name, const Matrix3d& value) const { set_uniform(get_uniform_location(name), value); }
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
+#if ENABLE_GL_IMGUI_SHADERS
+    void set_uniform(const char* name, const Matrix4f& value) const { set_uniform(get_uniform_location(name), value); }
+    void set_uniform(const char* name, const Matrix4d& value) const { set_uniform(get_uniform_location(name), value); }
+#endif // ENABLE_GL_IMGUI_SHADERS
     void set_uniform(const char* name, const Vec3f& value) const { set_uniform(get_uniform_location(name), value); }
     void set_uniform(const char* name, const Vec3d& value) const { set_uniform(get_uniform_location(name), value); }
     void set_uniform(const char* name, const ColorRGB& value) const { set_uniform(get_uniform_location(name), value); }
@@ -86,6 +90,10 @@ public:
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     void set_uniform(int id, const Matrix3d& value) const;
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
+#if ENABLE_GL_IMGUI_SHADERS
+    void set_uniform(int id, const Matrix4f& value) const;
+    void set_uniform(int id, const Matrix4d& value) const;
+#endif // ENABLE_GL_IMGUI_SHADERS
     void set_uniform(int id, const Vec3f& value) const;
     void set_uniform(int id, const Vec3d& value) const;
     void set_uniform(int id, const ColorRGB& value) const;

src/slic3r/GUI/GLShadersManager.cpp

@@ -35,6 +35,8 @@ std::pair<bool, std::string> GLShadersManager::init()
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
 #if ENABLE_GL_SHADERS_ATTRIBUTES
+    // imgui shader
+    valid &= append_shader("imgui", { "imgui.vs", "imgui.fs" });
     // basic shader, used to render all what was previously rendered using the immediate mode
     valid &= append_shader("flat_attr", { "flat_attr.vs", "flat.fs" });
     // basic shader for textures, used to render textures

src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp

@@ -600,11 +600,17 @@ void TriangleSelectorMmGui::render(ImGuiWrapper *imgui)
         return;
 #if ENABLE_GL_SHADERS_ATTRIBUTES
     assert(shader->get_name() == "mm_gouraud_attr");
+
+    const Camera& camera = wxGetApp().plater()->get_camera();
+    const Transform3d view_model_matrix = camera.get_view_matrix() * matrix;
+    shader->set_uniform("view_model_matrix", view_model_matrix);
+    shader->set_uniform("projection_matrix", camera.get_projection_matrix());
+    shader->set_uniform("normal_matrix", (Matrix3d)view_model_matrix.matrix().block(0, 0, 3, 3).inverse().transpose());
 #else
     assert(shader->get_name() == "mm_gouraud");
 #endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
-    for (size_t color_idx = 0; color_idx < m_gizmo_scene.triangle_indices.size(); ++color_idx)
+    for (size_t color_idx = 0; color_idx < m_gizmo_scene.triangle_indices.size(); ++color_idx) {
         if (m_gizmo_scene.has_VBOs(color_idx)) {
             if (color_idx > m_colors.size()) // Seed fill VBO
                 shader->set_uniform("uniform_color", TriangleSelectorGUI::get_seed_fill_color(color_idx == (m_colors.size() + 1) ? m_default_volume_color : m_colors[color_idx - (m_colors.size() + 1) - 1]));
@@ -613,6 +619,7 @@ void TriangleSelectorMmGui::render(ImGuiWrapper *imgui)
 
             m_gizmo_scene.render(color_idx);
         }
+    }
 
 #if ENABLE_LEGACY_OPENGL_REMOVAL
 #if ENABLE_GL_SHADERS_ATTRIBUTES
@@ -724,19 +731,41 @@ void GLMmSegmentationGizmo3DScene::render(size_t triangle_indices_idx) const
     assert(this->vertices_VBO_id != 0);
     assert(this->triangle_indices_VBO_ids[triangle_indices_idx] != 0);
 
-    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_VBO_id));
+#if ENABLE_GL_SHADERS_ATTRIBUTES
-    glsafe(::glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), (const void*)(0 * sizeof(float))));
+    GLShaderProgram* shader = wxGetApp().get_current_shader();
+    if (shader == nullptr)
+        return;
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
+    glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_VBO_id));
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+    const GLint position_id = shader->get_attrib_location("v_position");
+    if (position_id != -1) {
+        glsafe(::glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (GLvoid*)0));
+        glsafe(::glEnableVertexAttribArray(position_id));
+    }
+
+    // Render using the Vertex Buffer Objects.
+    if (this->triangle_indices_VBO_ids[triangle_indices_idx] != 0 &&
+        this->triangle_indices_sizes[triangle_indices_idx] > 0) {
+#else
+    glsafe(::glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), (const void*)(0 * sizeof(float))));
     glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
 
     // Render using the Vertex Buffer Objects.
     if (this->triangle_indices_sizes[triangle_indices_idx] > 0) {
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
         glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_ids[triangle_indices_idx]));
         glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_sizes[triangle_indices_idx]), GL_UNSIGNED_INT, nullptr));
-        glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
     }
 
+#if ENABLE_GL_SHADERS_ATTRIBUTES
+    if (position_id != -1)
+        glsafe(::glDisableVertexAttribArray(position_id));
+#else
     glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
+#endif // ENABLE_GL_SHADERS_ATTRIBUTES
 
     glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
 }

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -26,13 +26,18 @@
 #include "libslic3r/libslic3r.h"
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Color.hpp"
+
 #include "3DScene.hpp"
 #include "GUI.hpp"
 #include "I18N.hpp"
 #include "Search.hpp"
 #include "BitmapCache.hpp"
+#if ENABLE_GL_IMGUI_SHADERS
+#include "GUI_App.hpp"
+#endif // ENABLE_GL_IMGUI_SHADERS
 
 #include "../Utils/MacDarkMode.hpp"
+
 #include "nanosvg/nanosvg.h"
 #include "nanosvg/nanosvgrast.h"
 
@@ -1442,13 +1447,31 @@ void ImGuiWrapper::init_style()
 
 void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
 {
+    if (draw_data == nullptr || draw_data->CmdListsCount == 0)
+        return;
+
+#if ENABLE_GL_IMGUI_SHADERS
+    GLShaderProgram* shader = wxGetApp().get_shader("imgui");
+    if (shader == nullptr)
+        return;
+#endif // ENABLE_GL_IMGUI_SHADERS
+
     // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
     ImGuiIO& io = ImGui::GetIO();
     const int fb_width  = (int)(draw_data->DisplaySize.x * io.DisplayFramebufferScale.x);
     const int fb_height = (int)(draw_data->DisplaySize.y * io.DisplayFramebufferScale.y);
     if (fb_width == 0 || fb_height == 0)
         return;
+
+#if ENABLE_GL_IMGUI_SHADERS
+    GLShaderProgram* curr_shader = wxGetApp().get_current_shader();
+    if (curr_shader != nullptr)
+        curr_shader->stop_using();
+
+    shader->start_using();
+#else
     draw_data->ScaleClipRects(io.DisplayFramebufferScale);
+#endif // ENABLE_GL_IMGUI_SHADERS
 
     // We are using the OpenGL fixed pipeline to make the example code simpler to read!
     // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
@@ -1456,25 +1479,43 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
     GLint last_polygon_mode[2]; glsafe(::glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode));
     GLint last_viewport[4]; glsafe(::glGetIntegerv(GL_VIEWPORT, last_viewport));
     GLint last_scissor_box[4]; glsafe(::glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box));
+    GLint last_texture_env_mode; glsafe(::glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &last_texture_env_mode));
     glsafe(::glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT));
     glsafe(::glEnable(GL_BLEND));
     glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
     glsafe(::glDisable(GL_CULL_FACE));
     glsafe(::glDisable(GL_DEPTH_TEST));
+    glsafe(::glEnable(GL_SCISSOR_TEST));
+#if !ENABLE_GL_IMGUI_SHADERS
     glsafe(::glDisable(GL_LIGHTING));
     glsafe(::glDisable(GL_COLOR_MATERIAL));
-    glsafe(::glEnable(GL_SCISSOR_TEST));
     glsafe(::glEnableClientState(GL_VERTEX_ARRAY));
     glsafe(::glEnableClientState(GL_TEXTURE_COORD_ARRAY));
     glsafe(::glEnableClientState(GL_COLOR_ARRAY));
+#endif // !ENABLE_GL_IMGUI_SHADERS
     glsafe(::glEnable(GL_TEXTURE_2D));
     glsafe(::glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));
     glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE));
-    GLint texture_env_mode = GL_MODULATE;
-    glsafe(::glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &texture_env_mode));
-    glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE));
-    //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound
 
+#if ENABLE_GL_IMGUI_SHADERS
+    // Setup viewport, orthographic projection matrix
+    // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
+    glsafe(::glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
+    const float L = draw_data->DisplayPos.x;
+    const float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
+    const float T = draw_data->DisplayPos.y;
+    const float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
+
+    Matrix4f ortho_projection;
+    ortho_projection <<
+        2.0f / (R - L), 0.0f,           0.0f,  (R + L) / (L - R),
+        0.0f,           2.0f / (T - B), 0.0f,  (T + B) / (B - T),
+        0.0f,           0.0f,           -1.0f, 0.0f,
+        0.0f,           0.0f,           0.0f,  1.0f;
+
+    shader->set_uniform("Texture", 0);
+    shader->set_uniform("ProjMtx", ortho_projection);
+#else
     // Setup viewport, orthographic projection matrix
     // Our visible imgui space lies from draw_data->DisplayPps (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayMin is typically (0,0) for single viewport apps.
     glsafe(::glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height));
@@ -1485,16 +1526,55 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
     glsafe(::glMatrixMode(GL_MODELVIEW));
     glsafe(::glPushMatrix());
     glsafe(::glLoadIdentity());
+#endif // ENABLE_GL_IMGUI_SHADERS
+
+#if ENABLE_GL_IMGUI_SHADERS
+    // Will project scissor/clipping rectangles into framebuffer space
+    const ImVec2 clip_off   = draw_data->DisplayPos;         // (0,0) unless using multi-viewports
+    const ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
+#else
+    const ImVec2 pos = draw_data->DisplayPos;
+#endif // ENABLE_GL_IMGUI_SHADERS
 
     // Render command lists
-    ImVec2 pos = draw_data->DisplayPos;
     for (int n = 0; n < draw_data->CmdListsCount; ++n) {
         const ImDrawList* cmd_list = draw_data->CmdLists[n];
         const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
         const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data;
+#if ENABLE_GL_IMGUI_SHADERS
+        const GLsizeiptr vtx_buffer_size = (GLsizeiptr)cmd_list->VtxBuffer.Size * (int)sizeof(ImDrawVert);
+        const GLsizeiptr idx_buffer_size = (GLsizeiptr)cmd_list->IdxBuffer.Size * (int)sizeof(ImDrawIdx);
+
+        GLuint vbo_id;
+        glsafe(::glGenBuffers(1, &vbo_id));
+        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, vbo_id));
+        glsafe(::glBufferData(GL_ARRAY_BUFFER, vtx_buffer_size, vtx_buffer, GL_STATIC_DRAW));
+
+        GLuint ibo_id;
+        glsafe(::glGenBuffers(1, &ibo_id));
+        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_id));
+        glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, idx_buffer_size, idx_buffer, GL_STATIC_DRAW));
+
+        const int position_id = shader->get_attrib_location("Position");
+        if (position_id != -1) {
+            glsafe(::glVertexAttribPointer(position_id, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, pos)));
+            glsafe(::glEnableVertexAttribArray(position_id));
+        }
+        const int uv_id = shader->get_attrib_location("UV");
+        if (uv_id != -1) {
+            glsafe(::glVertexAttribPointer(uv_id, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, uv)));
+            glsafe(::glEnableVertexAttribArray(uv_id));
+        }
+        const int color_id = shader->get_attrib_location("Color");
+        if (color_id != -1) {
+            glsafe(::glVertexAttribPointer(color_id, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)IM_OFFSETOF(ImDrawVert, col)));
+            glsafe(::glEnableVertexAttribArray(color_id));
+        }
+#else
         glsafe(::glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos))));
         glsafe(::glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv))));
         glsafe(::glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col))));
+#endif // ENABLE_GL_IMGUI_SHADERS
 
         for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; ++cmd_i) {
             const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
@@ -1502,34 +1582,71 @@ void ImGuiWrapper::render_draw_data(ImDrawData *draw_data)
                 // User callback (registered via ImDrawList::AddCallback)
                 pcmd->UserCallback(cmd_list, pcmd);
             else {
-                ImVec4 clip_rect = ImVec4(pcmd->ClipRect.x - pos.x, pcmd->ClipRect.y - pos.y, pcmd->ClipRect.z - pos.x, pcmd->ClipRect.w - pos.y);
+#if ENABLE_GL_IMGUI_SHADERS
+                // Project scissor/clipping rectangles into framebuffer space
+                const ImVec2 clip_min((pcmd->ClipRect.x - clip_off.x) * clip_scale.x, (pcmd->ClipRect.y - clip_off.y) * clip_scale.y);
+                const ImVec2 clip_max((pcmd->ClipRect.z - clip_off.x) * clip_scale.x, (pcmd->ClipRect.w - clip_off.y) * clip_scale.y);
+                if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
+                    continue;
+
+                // Apply scissor/clipping rectangle (Y is inverted in OpenGL)
+                glsafe(::glScissor((int)clip_min.x, (int)(fb_height - clip_max.y), (int)(clip_max.x - clip_min.x), (int)(clip_max.y - clip_min.y)));
+
+                // Bind texture, Draw
+                glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
+                glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
+#else
+                const ImVec4 clip_rect = ImVec4(pcmd->ClipRect.x - pos.x, pcmd->ClipRect.y - pos.y, pcmd->ClipRect.z - pos.x, pcmd->ClipRect.w - pos.y);
                 if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f) {
                     // Apply scissor/clipping rectangle
                     glsafe(::glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y)));
 
                     // Bind texture, Draw
-                    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId));
+                    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->GetTexID()));
-                    glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer));
+                    glsafe(::glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, (void*)(intptr_t)(pcmd->IdxOffset * sizeof(ImDrawIdx))));
                 }
+#endif // ENABLE_GL_IMGUI_SHADERS
             }
             idx_buffer += pcmd->ElemCount;
         }
+
+#if ENABLE_GL_IMGUI_SHADERS
+        if (position_id != -1)
+            glsafe(::glDisableVertexAttribArray(position_id));
+        if (uv_id != -1)
+            glsafe(::glDisableVertexAttribArray(uv_id));
+        if (color_id != -1)
+            glsafe(::glDisableVertexAttribArray(color_id));
+
+        glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
+        glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
+
+        glsafe(::glDeleteBuffers(1, &ibo_id));
+        glsafe(::glDeleteBuffers(1, &vbo_id));
+#endif // ENABLE_GL_IMGUI_SHADERS
     }
 
     // Restore modified state
-    glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, texture_env_mode));
+    glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, last_texture_env_mode));
+    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture));
+#if !ENABLE_GL_IMGUI_SHADERS
     glsafe(::glDisableClientState(GL_COLOR_ARRAY));
     glsafe(::glDisableClientState(GL_TEXTURE_COORD_ARRAY));
     glsafe(::glDisableClientState(GL_VERTEX_ARRAY));
-    glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture));
     glsafe(::glMatrixMode(GL_MODELVIEW));
     glsafe(::glPopMatrix());
     glsafe(::glMatrixMode(GL_PROJECTION));
     glsafe(::glPopMatrix());
+#endif // !ENABLE_GL_IMGUI_SHADERS
     glsafe(::glPopAttrib());
     glsafe(::glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]));
     glsafe(::glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]));
     glsafe(::glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]));
+
+#if ENABLE_GL_IMGUI_SHADERS
+    if (curr_shader != nullptr)
+        curr_shader->start_using();
+#endif // ENABLE_GL_IMGUI_SHADERS
 }
 
 bool ImGuiWrapper::display_initialized() const