Draw the Toolpaths Top-Down When the Camera Looks Down on the Print

The segments come in print order, bottom layer first, which seen from above is back to
front: every hidden fragment is shaded before the one that covers it, and on an integrated
GPU that overdraw is most of the frame. Drawing the instances last to first whenever the
camera looks down lets the depth test reject the hidden fragments instead. Side views and
views from below keep the print order, and the shadow-caster pass is unchanged.

src/OrcaSlicer.cpp

@@ -5527,28 +5527,12 @@ int CLI::run(int argc, char **argv)
                     //add the virtual object into unselect list if has
                     partplate_list.preprocess_exclude_areas(unselected, enable_wrapping_detect);
 
-                    // Filament ids given on the command line size the tower for STL input. A project
-                    // records its filament use per plate, so count there and keep its tower positions.
-                    const int  plate_count  = partplate_list.get_plate_count();
-                    const bool from_project = used_filament_set.empty();
-                    std::vector<int> plate_filament_counts(plate_count, static_cast<int>(used_filament_set.size()));
-                    if (from_project)
-                        for (int plate_index = 0; plate_index < plate_count; ++plate_index)
-                            plate_filament_counts[plate_index] = static_cast<int>(partplate_list.get_plate(plate_index)->get_extruders_under_cli(true, m_print_config).size());
-                    // A project only gets a tower the slicer will print: the prime tower enabled, and not
-                    // a by-object print unless a smooth timelapse needs it, as the per-plate arrange decides.
-                    const bool project_tower_allowed = m_print_config.option<ConfigOptionBool>("enable_prime_tower", true)->value &&
-                                                       (is_smooth_timelapse || !arrange_cfg.is_seq_print);
-                    const auto plate_needs_wipe_tower = [from_project, project_tower_allowed, is_smooth_timelapse](int filament_count) {
-                        if (!from_project)
-                            return filament_count > 0;
-                        return project_tower_allowed && (filament_count > 1 || (filament_count > 0 && is_smooth_timelapse));
-                    };
-                    const int max_filament_count = plate_count > 0 ? *std::max_element(plate_filament_counts.begin(), plate_filament_counts.end()) : 0;
-
-                    if (plate_needs_wipe_tower(max_filament_count))
+                    if (used_filament_set.size() > 0)
                     {
                         //prepare the wipe tower
+                        int plate_count = partplate_list.get_plate_count();
+                        int extruder_size = used_filament_set.size();
+
                         auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
                         // This margin only pre-adjusts the default away from the near edges;
                         // estimate_wipe_tower_polygon below computes the real clamped position.
@@ -5584,11 +5568,7 @@ int CLI::run(int argc, char **argv)
 
                         for (int bedid = 0; bedid < MAX_PLATE_COUNT; bedid++) {
                             int plate_index_valid = std::min(bedid, plate_count - 1);
-                            // Overflow beds may receive objects from any plate, so size them for the busiest one.
-                            const int extruder_size = bedid < plate_count ? plate_filament_counts[bedid] : max_filament_count;
-                            if (!plate_needs_wipe_tower(extruder_size))
-                                continue;
-                            if (bedid < plate_count && !from_project) {
+                            if (bedid < plate_count) {
                                 wipe_x_option->set_at(&wt_x_opt, plate_index_valid, 0);
                                 wipe_y_option->set_at(&wt_y_opt, plate_index_valid, 0);
                             }
@@ -7044,12 +7024,6 @@ int CLI::run(int argc, char **argv)
                                     }
                                 }
                                 sliced_info.sliced_plates.push_back(sliced_plate_info);
-                            } catch (const Slic3r::SlicingErrors &exs) {
-                                const std::string message = print_fff ? print_fff->slicing_errors_message(exs) : std::string(exs.what());
-                                BOOST_LOG_TRIVIAL(error) << "found slicing or export error for partplate " << index+1 << ": " << message;
-                                boost::nowide::cerr << message << std::endl;
-                                record_exit_reson(outfile_dir, CLI_SLICING_ERROR, index+1, message, sliced_info);
-                                flush_and_exit(CLI_SLICING_ERROR);
                             } catch (const std::exception &ex) {
                                 BOOST_LOG_TRIVIAL(error) << "found slicing or export error for partplate "<<index+1 << std::endl;
                                 boost::nowide::cerr << ex.what() << std::endl;

src/libslic3r/Print.cpp

@@ -1705,25 +1705,6 @@ StringObjectException Print::check_multi_filament_valid(const Print& print)
 
 // Precondition: Print::validate() requires the Print::apply() to be called its invocation.
 //BBS: refine seq-print validation logic
-// The exception's own message is just "Errors"; the detail is in the per-object errors,
-// whose object id is the PrintObject's.
-std::string Print::slicing_errors_message(const SlicingErrors &errors) const
-{
-    std::string message;
-    for (const SlicingError &error : errors.errors_) {
-        std::string object_name;
-        for (const PrintObject *object : m_objects)
-            if (object->id().id == error.objectId()) {
-                object_name = object->model_object()->name;
-                break;
-            }
-        if (!message.empty())
-            message += "\n";
-        message += object_name.empty() ? std::string(error.what()) : object_name + ": " + error.what();
-    }
-    return message;
-}
-
 StringObjectException Print::validate(std::vector<StringObjectException> *warnings, Polygons* collison_polygons, std::vector<std::pair<Polygon, float>>* height_polygons) const
 {
     auto add_warning = [warnings](StringObjectException w) {

src/libslic3r/Print.hpp

@@ -30,8 +30,6 @@
 
 namespace Slic3r {
 
-class SlicingErrors;
-
 class GCode;
 class Layer;
 class ModelObject;
@@ -969,8 +967,6 @@ public:
 
     // Returns an empty string if valid, otherwise returns an error message.
     StringObjectException validate(std::vector<StringObjectException> *warnings = nullptr, Polygons* collison_polygons = nullptr, std::vector<std::pair<Polygon, float>>* height_polygons = nullptr) const override;
-    // The per-object messages of a SlicingErrors, each prefixed with its object's name.
-    std::string slicing_errors_message(const SlicingErrors &errors) const;
     double              skirt_first_layer_height() const;
     Flow                brim_flow() const;
     Flow                skirt_flow() const;

src/libvgcode/src/Shaders.hpp

@@ -34,6 +34,10 @@ static const char* Segments_Vertex_Shader =
 // ORCA: 0 during the shadow caster pass - the bias below shifts eye_position but not
 // world_position, so the caster would write a depth the receiver never looks up.
 "uniform float bias_scale;\n"
+// draw the instances last to first, top layers before the ones they hide, so that early depth
+// rejection discards most of the hidden fragments; set when the camera looks down on the print
+"uniform int reverse_order;\n"
+"uniform int instance_count;\n"
 "in int vertex_id;\n"
 "out vec3 color;\n"
 "// ORCA: realistic view - the light the shadow map is able to block, kept apart from the\n"
@@ -59,7 +63,8 @@ static const char* Segments_Vertex_Shader =
 "  return top_diffuse + front_diffuse + top_specular;\n"
 "}\n"
 "void main() {\n"
-"  int id_a = int(texelFetch(segment_index_tex, gl_InstanceID).r);\n"
+"  int instance = (reverse_order != 0) ? instance_count - 1 - gl_InstanceID : gl_InstanceID;\n"
+"  int id_a = int(texelFetch(segment_index_tex, instance).r);\n"
 "  int id_b = id_a + 1;\n"
 "  vec3 pos_a = texelFetch(position_tex, id_a).xyz;\n"
 "  vec3 pos_b = texelFetch(position_tex, id_b).xyz;\n"

src/libvgcode/src/ViewerImpl.cpp

@@ -763,6 +763,8 @@ void ViewerImpl::init(const std::string& opengl_context_version)
     m_uni_segments_height_width_angle_tex_id = glGetUniformLocation(m_segments_shader_id, "height_width_angle_tex");
     m_uni_segments_colors_tex_id             = glGetUniformLocation(m_segments_shader_id, "color_tex");
     m_uni_segments_segment_index_tex_id      = glGetUniformLocation(m_segments_shader_id, "segment_index_tex");
+    m_uni_segments_reverse_order_id          = glGetUniformLocation(m_segments_shader_id, "reverse_order");
+    m_uni_segments_instance_count_id         = glGetUniformLocation(m_segments_shader_id, "instance_count");
     // ORCA: realistic view
     m_uni_segments_shadow_map_id             = glGetUniformLocation(m_segments_shader_id, "shadow_map");
     m_uni_segments_shadow_light_vp_id        = glGetUniformLocation(m_segments_shader_id, "shadow_light_vp");
@@ -2090,6 +2092,15 @@ void ViewerImpl::render_segments(const Mat4x4& view_matrix, const Mat4x4& projec
     glsafe(glUniformMatrix4fv(m_uni_segments_view_matrix_id, 1, GL_FALSE, view_matrix.data()));
     glsafe(glUniformMatrix4fv(m_uni_segments_projection_matrix_id, 1, GL_FALSE, projection_matrix.data()));
     glsafe(glUniform3fv(m_uni_segments_camera_position_id, 1, camera_position.data()));
+    // The segments come in print order, bottom layer first. Seen from above, that is back to front,
+    // and every hidden fragment is shaded before the one that covers it. Drawing them last to first
+    // lets the depth test reject the hidden ones instead. The camera looks down when the world's
+    // up axis points towards it, which is the view matrix's (2, 2) entry being positive.
+    const bool top_down = !m_rendering_shadow_casters && view_matrix[10] > 0.0f;
+    glsafe(glUniform1i(m_uni_segments_reverse_order_id, top_down ? 1 : 0));
+#ifndef ENABLE_OPENGL_ES
+    glsafe(glUniform1i(m_uni_segments_instance_count_id, static_cast<int>(m_enabled_segments_count)));
+#endif // ENABLE_OPENGL_ES
     // ORCA: realistic view. The depth pass writes the map it would otherwise read, so it shades
     // with the lookup off.
     glsafe(glUniform1i(m_uni_segments_shadow_map_id, m_shadow_map_texture_unit));

src/libvgcode/src/ViewerImpl.hpp

@@ -362,6 +362,8 @@ private:
     int m_uni_segments_height_width_angle_tex_id{ -1 };
     int m_uni_segments_colors_tex_id{ -1 };
     int m_uni_segments_segment_index_tex_id{ -1 };
+    int m_uni_segments_reverse_order_id{ -1 };
+    int m_uni_segments_instance_count_id{ -1 };
     int m_uni_segments_shadow_map_id{ -1 };
     int m_uni_segments_shadow_light_vp_id{ -1 };
     int m_uni_segments_shadow_intensity_id{ -1 };

src/slic3r/GUI/Tab.cpp

@@ -7184,14 +7184,6 @@ void Tab::activate_selected_page(std::function<void()> throw_if_canceled)
     if (!m_active_page)
         return;
 
-#ifdef __WXGTK__
-    // Builds the page off screen, since GTK crashes when it desensitizes a multiline text view
-    // that was built on screen and hidden before its first size allocation.
-    const bool hide_view = m_active_page->build_pending() && m_page_view->IsShown();
-    if (hide_view)
-        m_page_view->Hide();
-    ScopeGuard show_view([this, hide_view] { if (hide_view) m_page_view->Show(); });
-#endif
     m_active_page->activate(m_mode, throw_if_canceled);
     update_changed_ui();
     update_description_lines();

tests/fff_print/test_print.cpp

@@ -505,29 +505,3 @@ TEST_CASE("Sequential printing publishes the nozzle group result", "[Print][Mult
         CHECK(gcode.find("; SEQ-ND-OK") != std::string::npos);
     }
 }
-
-TEST_CASE("Slicing errors are reported per object with the object's name", "[Print]")
-{
-    Print print;
-    Model model;
-    init_print({Slic3r::Test::cube(20.)}, print, model);
-    // Lift the cube off the bed: its first layer is empty, which G-code export reports per object.
-    ModelObject *object = model.objects.front();
-    object->name = "floating cube";
-    object->instances.front()->set_offset(object->instances.front()->get_offset() + Vec3d(0., 0., 2.));
-    print.apply(model, DynamicPrintConfig::full_print_config());
-    print.set_status_silent();
-
-    ScopedTemporaryFile temp(".gcode");
-    std::string message;
-    try {
-        print.process();
-        print.export_gcode(temp.string(), nullptr, nullptr);
-        FAIL("slicing did not report the empty first layer");
-    } catch (const SlicingErrors &errors) {
-        REQUIRE(errors.errors_.size() == 1);
-        message = print.slicing_errors_message(errors);
-    }
-    CHECK(message.rfind("floating cube: ", 0) == 0);
-    CHECK(message.find("empty first layer") != std::string::npos);
-}