Initial port of Brim ear gizmo

Cherry-picked from bambulab/BambuStudio@92c85a13d0

Co-authored-by: Mack <yongfang.bian@bambulab.com>

src/libslic3r/Brim.cpp

@@ -806,8 +806,8 @@ double configBrimWidthByVolumeGroups(double adhesion, double maxSpeed, const std
 
 // Generate ears
 // Ported from SuperSlicer: https://github.com/supermerill/SuperSlicer/blob/45d0532845b63cd5cefe7de7dc4ef0e0ed7e030a/src/libslic3r/Brim.cpp#L1116
-static ExPolygons make_brim_ears(ExPolygons& obj_expoly, coord_t size_ear, coord_t ear_detection_length,
+static ExPolygons make_brim_ears_auto(const ExPolygons& obj_expoly, coord_t size_ear, coord_t ear_detection_length,
-                                 coordf_t brim_ears_max_angle, bool is_outer_brim) {
+                                      coordf_t brim_ears_max_angle, bool is_outer_brim) {
     ExPolygons mouse_ears_ex;
     if (size_ear <= 0) {
         return mouse_ears_ex;
@@ -815,7 +815,7 @@ static ExPolygons make_brim_ears(ExPolygons& obj_expoly, coord_t size_ear, coord
     // Detect places to put ears
     const coordf_t angle_threshold = (180 - brim_ears_max_angle) * PI / 180.0;
     Points pt_ears;
-    for (ExPolygon &poly : obj_expoly) {
+    for (const ExPolygon &poly : obj_expoly) {
         Polygon decimated_polygon = poly.contour;
         if (ear_detection_length > 0) {
             // decimate polygon
@@ -835,8 +835,8 @@ static ExPolygons make_brim_ears(ExPolygons& obj_expoly, coord_t size_ear, coord
     // Then add ears
     // create ear pattern
     Polygon point_round;
-    for (size_t i = 0; i < POLY_SIDES; i++) {
+    for (size_t i = 0; i < POLY_SIDE_COUNT; i++) {
-        double angle = (2.0 * PI * i) / POLY_SIDES;
+        double angle = (2.0 * PI * i) / POLY_SIDE_COUNT;
         point_round.points.emplace_back(size_ear * cos(angle), size_ear * sin(angle));
     }
 
@@ -850,6 +850,41 @@ static ExPolygons make_brim_ears(ExPolygons& obj_expoly, coord_t size_ear, coord
     return mouse_ears_ex;
 }
 
+static ExPolygons make_brim_ears(const PrintObject* object, const double& flowWidth, float brim_offset, Flow &flow, bool is_outer_brim)
+{
+    ExPolygons mouse_ears_ex;
+    BrimPoints brim_ear_points = object->model_object()->brim_points;
+    if (brim_ear_points.size() <= 0) {
+        return mouse_ears_ex;
+    }
+    const Geometry::Transformation& trsf = object->model_object()->instances[0]->get_transformation();
+    Transform3d model_trsf = trsf.get_matrix_no_offset();
+    const Point &center_offset = object->center_offset();
+    model_trsf = model_trsf.pretranslate(Vec3d(- unscale<double>(center_offset.x()), - unscale<double>(center_offset.y()), 0));
+    for (auto &pt : brim_ear_points) {
+        Vec3f world_pos = pt.transform(trsf.get_matrix());
+        if ( world_pos.z() > 0) continue;
+        Polygon point_round;
+        float brim_width = floor(scale_(pt.head_front_radius) / flowWidth / 2) * flowWidth * 2;
+        if (is_outer_brim) {
+            double flowWidthScale = flowWidth / SCALING_FACTOR;
+            brim_width = floor(brim_width / flowWidthScale / 2) * flowWidthScale * 2;
+        }
+        coord_t size_ear = (brim_width - brim_offset - flow.scaled_spacing());
+        for (size_t i = 0; i < POLY_SIDE_COUNT; i++) {
+            double angle = (2.0 * PI * i) / POLY_SIDE_COUNT;
+            point_round.points.emplace_back(size_ear * cos(angle), size_ear * sin(angle));
+        }
+        mouse_ears_ex.emplace_back();
+        mouse_ears_ex.back().contour = point_round;
+        Vec3f pos = pt.transform(model_trsf);
+        int32_t pt_x = scale_(pos.x());
+        int32_t pt_y = scale_(pos.y());
+        mouse_ears_ex.back().contour.translate(Point(pt_x, pt_y));
+    }
+    return mouse_ears_ex;
+}
+
 //BBS: create all brims
 static ExPolygons outer_inner_brim_area(const Print& print,
     const float no_brim_offset, std::map<ObjectID, ExPolygons>& brimAreaMap,
@@ -888,9 +923,10 @@ static ExPolygons outer_inner_brim_area(const Print& print,
             const float        scaled_additional_brim_width = scale_(floor(5 / flowWidth / 2) * flowWidth * 2);
             const float        scaled_half_min_adh_length = scale_(1.1);
             bool               has_brim_auto = object->config().brim_type == btAutoBrim;
-            const bool         use_brim_ears = object->config().brim_type == btEar;
+            const bool         use_auto_brim_ears = object->config().brim_type == btEar;
-            const bool         has_inner_brim = brim_type == btInnerOnly || brim_type == btOuterAndInner || use_brim_ears;
+            const bool         use_brim_ears = object->config().brim_type == btPainted;
-            const bool         has_outer_brim = brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btAutoBrim || use_brim_ears;
+            const bool         has_inner_brim = brim_type == btInnerOnly || brim_type == btOuterAndInner || use_auto_brim_ears || use_brim_ears;
+            const bool         has_outer_brim = brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btAutoBrim || use_auto_brim_ears || use_brim_ears;
             coord_t            ear_detection_length = scale_(object->config().brim_ears_detection_length.value);
             coordf_t           brim_ears_max_angle = object->config().brim_ears_max_angle.value;
 
@@ -951,27 +987,30 @@ static ExPolygons outer_inner_brim_area(const Print& print,
                         if (has_outer_brim) {
                             // BBS: inner and outer boundary are offset from the same polygon incase of round off error.
                             auto innerExpoly = offset_ex(ex_poly.contour, brim_offset, jtRound, SCALED_RESOLUTION);
-                            auto &clipExpoly = innerExpoly;
+                            ExPolygons outerExpoly;
-
                             if (use_brim_ears) {
+                                outerExpoly = make_brim_ears(object, flowWidth, brim_offset, flow, true);
+                                //outerExpoly = offset_ex(outerExpoly, brim_width_mod, jtRound, SCALED_RESOLUTION);
+                            } else if (use_auto_brim_ears) {
                                 coord_t size_ear = (brim_width_mod - brim_offset - flow.scaled_spacing());
-                                append(brim_area_object, diff_ex(make_brim_ears(innerExpoly, size_ear, ear_detection_length, brim_ears_max_angle, true), clipExpoly));
+                                outerExpoly = make_brim_ears_auto(innerExpoly, size_ear, ear_detection_length, brim_ears_max_angle, true);
-                            } else {
+                            }else {
-                                // Normal brims
+                                outerExpoly = offset_ex(innerExpoly, brim_width_mod, jtRound, SCALED_RESOLUTION);
-                                append(brim_area_object, diff_ex(offset_ex(innerExpoly, brim_width_mod, jtRound, SCALED_RESOLUTION), clipExpoly));
                             }
+                            append(brim_area_object, diff_ex(outerExpoly, innerExpoly));
                         }
                         if (has_inner_brim) {
-                            auto outerExpoly = offset_ex(ex_poly_holes_reversed, -brim_offset);
+                            ExPolygons outerExpoly;
-                            auto clipExpoly = offset_ex(ex_poly_holes_reversed, -brim_width - brim_offset);
+                            auto innerExpoly = offset_ex(ex_poly_holes_reversed, -brim_width - brim_offset);
-
                             if (use_brim_ears) {
+                                outerExpoly = make_brim_ears(object, flowWidth, brim_offset, flow, false);
+                            } else if (use_auto_brim_ears) {
                                 coord_t size_ear = (brim_width - brim_offset - flow.scaled_spacing());
-                                append(brim_area_object, diff_ex(make_brim_ears(outerExpoly, size_ear, ear_detection_length, brim_ears_max_angle, false), clipExpoly));
+                                outerExpoly = make_brim_ears_auto(offset_ex(ex_poly_holes_reversed, -brim_offset), size_ear, ear_detection_length, brim_ears_max_angle, false);
-                            } else {
+                            }else {
-                                // Normal brims
+                                outerExpoly = offset_ex(ex_poly_holes_reversed, -brim_offset);
-                                append(brim_area_object, diff_ex(outerExpoly, clipExpoly));
                             }
+                            append(brim_area_object, diff_ex(outerExpoly, innerExpoly));
                         }
                         if (!has_inner_brim) {
                             // BBS: brim should be apart from holes

src/libslic3r/BrimEarsPoint.hpp

@@ -0,0 +1,63 @@
+#ifndef BRIMEARSPOINT_HPP
+#define BRIMEARSPOINT_HPP
+
+#include <libslic3r/Point.hpp>
+
+
+namespace Slic3r {
+
+// An enum to keep track of where the current points on the ModelObject came from.
+enum class PointsStatus {
+    NoPoints,           // No points were generated so far.
+    Generating,     // The autogeneration algorithm triggered, but not yet finished.
+    AutoGenerated,  // Points were autogenerated (i.e. copied from the backend).
+    UserModified    // User has done some edits.
+};
+
+struct BrimPoint
+{
+    Vec3f pos;
+    float head_front_radius;
+
+    BrimPoint()
+        : pos(Vec3f::Zero()), head_front_radius(0.f)
+    {}
+
+    BrimPoint(float pos_x,
+                 float pos_y,
+                 float pos_z,
+                 float head_radius)
+        : pos(pos_x, pos_y, pos_z)
+        , head_front_radius(head_radius)
+    {}
+
+    BrimPoint(Vec3f position, float head_radius)
+        : pos(position)
+        , head_front_radius(head_radius)
+    {}
+
+    Vec3f transform(const Transform3d &trsf)
+    {
+        Vec3d result = trsf * pos.cast<double>();
+        return result.cast<float>();
+    }
+
+    bool operator==(const BrimPoint &sp) const
+    {
+        float rdiff = std::abs(head_front_radius - sp.head_front_radius);
+        return (pos == sp.pos) && rdiff < float(EPSILON);
+    }
+
+    bool operator!=(const BrimPoint &sp) const { return !(sp == (*this)); }
+    template<class Archive> void serialize(Archive &ar)
+    {
+        ar(pos, head_front_radius);
+    }
+};
+
+using BrimPoints = std::vector<BrimPoint>;
+
+}
+
+
+#endif // BRIMEARSPOINT_HPP

src/libslic3r/CMakeLists.txt

@@ -43,6 +43,7 @@ set(lisbslic3r_sources
     FaceDetector.hpp
     Brim.cpp
     Brim.hpp
+    BrimEarsPoint.hpp
     BuildVolume.cpp
     BuildVolume.hpp
     Circle.cpp

src/libslic3r/ExPolygon.cpp

@@ -185,6 +185,15 @@ bool overlaps(const ExPolygons& expolys1, const ExPolygons& expolys2)
     return false;
 }
 
+bool overlaps(const ExPolygons& expolys, const ExPolygon& expoly)
+{
+    for (const ExPolygon& el : expolys) {
+        if (el.overlaps(expoly))
+                return true;
+    }
+    return false;
+}
+
 Point projection_onto(const ExPolygons& polygons, const Point& from)
 {
     Point projected_pt;

src/libslic3r/ExPolygon.hpp

@@ -457,6 +457,7 @@ inline ExPolygons expolygons_simplify(const ExPolygons &expolys, double toleranc
 bool expolygons_match(const ExPolygon &l, const ExPolygon &r);
 
 bool overlaps(const ExPolygons& expolys1, const ExPolygons& expolys2);
+bool overlaps(const ExPolygons& expolys, const ExPolygon& expoly);
 
 Point projection_onto(const ExPolygons& expolys, const Point& pt);
 

src/libslic3r/Model.cpp

@@ -1063,6 +1063,7 @@ ModelObject& ModelObject::assign_copy(const ModelObject &rhs)
     this->sla_support_points          = rhs.sla_support_points;
     this->sla_points_status           = rhs.sla_points_status;
     this->sla_drain_holes             = rhs.sla_drain_holes;
+    this->brim_points                 = rhs.brim_points;
     this->layer_config_ranges         = rhs.layer_config_ranges;
     this->layer_height_profile        = rhs.layer_height_profile;
     this->printable                   = rhs.printable;
@@ -1102,6 +1103,7 @@ ModelObject& ModelObject::assign_copy(ModelObject &&rhs)
     this->sla_support_points          = std::move(rhs.sla_support_points);
     this->sla_points_status           = std::move(rhs.sla_points_status);
     this->sla_drain_holes             = std::move(rhs.sla_drain_holes);
+    this->brim_points                 = std::move(brim_points);
     this->layer_config_ranges         = std::move(rhs.layer_config_ranges);
     this->layer_height_profile        = std::move(rhs.layer_height_profile);
     this->printable                   = std::move(rhs.printable);
@@ -1736,6 +1738,7 @@ void ModelObject::convert_units(ModelObjectPtrs& new_objects, ConversionType con
     new_object->sla_support_points.clear();
     new_object->sla_drain_holes.clear();
     new_object->sla_points_status = sla::PointsStatus::NoPoints;
+    new_object->brim_points.clear();
     new_object->clear_volumes();
     new_object->input_file.clear();
 
@@ -2040,6 +2043,7 @@ ModelObjectPtrs ModelObject::merge_volumes(std::vector<int>& vol_indeces)
     upper->sla_support_points.clear();
     upper->sla_drain_holes.clear();
     upper->sla_points_status = sla::PointsStatus::NoPoints;
+    upper->brim_points.clear();
     upper->clear_volumes();
     upper->input_file.clear();
 
@@ -3510,6 +3514,17 @@ bool model_mmu_segmentation_data_changed(const ModelObject& mo, const ModelObjec
         [](const ModelVolume &mv_old, const ModelVolume &mv_new){ return mv_old.mmu_segmentation_facets.timestamp_matches(mv_new.mmu_segmentation_facets); });
 }
 
+bool model_brim_points_data_changed(const ModelObject& mo, const ModelObject& mo_new)
+{
+    if (mo.brim_points.size() != mo_new.brim_points.size())
+        return true;
+    for (size_t i = 0; i < mo.brim_points.size(); ++i) {
+        if (mo.brim_points[i] != mo_new.brim_points[i])
+            return true;
+    }
+    return false;
+}
+
 bool model_has_multi_part_objects(const Model &model)
 {
     for (const ModelObject *model_object : model.objects)

src/libslic3r/Model.hpp

@@ -10,6 +10,7 @@
 #include "Slicing.hpp"
 #include "SLA/SupportPoint.hpp"
 #include "SLA/Hollowing.hpp"
+#include "BrimEarsPoint.hpp"
 #include "TriangleMesh.hpp"
 #include "CustomGCode.hpp"
 #include "calib.hpp"
@@ -383,9 +384,7 @@ public:
     // Holes to be drilled into the object so resin can flow out
     sla::DrainHoles         sla_drain_holes;
 
-    // Connectors to be added into the object before cut and are used to create a solid/negative volumes during a cut perform
+    BrimPoints              brim_points;
-    CutConnectors           cut_connectors;
-    CutObjectBase           cut_id;
 
     /* This vector accumulates the total translation applied to the object by the
         center_around_origin() method. Callers might want to apply the same translation
@@ -396,6 +395,10 @@ public:
     // BBS: save for compare with new load volumes
     std::vector<ObjectID>   volume_ids;
 
+    // Connectors to be added into the object before cut and are used to create a solid/negative volumes during a cut perform
+    CutConnectors cut_connectors;
+    CutObjectBase cut_id;
+
     Model*                  get_model() { return m_model; }
     const Model*            get_model() const { return m_model; }
     // BBS: production extension
@@ -673,7 +676,7 @@ private:
         Internal::StaticSerializationWrapper<ModelConfigObject const> config_wrapper(config);
         Internal::StaticSerializationWrapper<LayerHeightProfile const> layer_heigth_profile_wrapper(layer_height_profile);
         ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
-            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation,
+            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation, brim_points,
             m_bounding_box_approx, m_bounding_box_approx_valid, 
             m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
             m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
@@ -686,7 +689,7 @@ private:
         // BBS: add backup, check modify
         SaveObjectGaurd gaurd(*this);
         ar(name, module_name, input_file, instances, volumes, config_wrapper, layer_config_ranges, layer_heigth_profile_wrapper,
-            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation,
+            sla_support_points, sla_points_status, sla_drain_holes, printable, origin_translation, brim_points,
             m_bounding_box_approx, m_bounding_box_approx_valid, 
             m_bounding_box_exact, m_bounding_box_exact_valid, m_min_max_z_valid,
             m_raw_bounding_box, m_raw_bounding_box_valid, m_raw_mesh_bounding_box, m_raw_mesh_bounding_box_valid,
@@ -1694,6 +1697,8 @@ bool model_custom_seam_data_changed(const ModelObject& mo, const ModelObject& mo
 // The function assumes that volumes list is synchronized.
 extern bool model_mmu_segmentation_data_changed(const ModelObject& mo, const ModelObject& mo_new);
 
+bool model_brim_points_data_changed(const ModelObject& mo, const ModelObject& mo_new);
+
 // If the model has multi-part objects, then it is currently not supported by the SLA mode.
 // Either the model cannot be loaded, or a SLA printer has to be activated.
 bool model_has_multi_part_objects(const Model &model);

src/libslic3r/PrintApply.cpp

@@ -1256,6 +1256,7 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
                                           model_volume_list_changed(model_object, model_object_new, ModelVolumeType::SUPPORT_ENFORCER);
         bool layer_height_ranges_differ = ! layer_height_ranges_equal(model_object.layer_config_ranges, model_object_new.layer_config_ranges, model_object_new.layer_height_profile.empty());
         bool model_origin_translation_differ = model_object.origin_translation != model_object_new.origin_translation;
+        bool brim_points_differ = model_brim_points_data_changed(model_object, model_object_new);
         auto print_objects_range        = print_object_status_db.get_range(model_object);
         // The list actually can be empty if all instances are out of the print bed.
         //assert(print_objects_range.begin() != print_objects_range.end());
@@ -1302,6 +1303,10 @@ Print::ApplyStatus Print::apply(const Model &model, DynamicPrintConfig new_full_
             } else if (model_custom_seam_data_changed(model_object, model_object_new)) {
                 update_apply_status(this->invalidate_step(psGCodeExport));
             }
+            if (brim_points_differ) {
+                model_object.brim_points = model_object_new.brim_points;
+                update_apply_status(this->invalidate_all_steps());
+            }
         }
         if (! solid_or_modifier_differ) {
             // Synchronize Object's config.

src/libslic3r/PrintConfig.cpp

@@ -327,6 +327,7 @@ static const t_config_enum_values s_keys_map_BrimType = {
     {"outer_and_inner", btOuterAndInner},
     {"auto_brim", btAutoBrim},  // BBS
     {"brim_ears", btEar},     // Orca
+    {"painted", btPainted},  // BBS
 };
 CONFIG_OPTION_ENUM_DEFINE_STATIC_MAPS(BrimType)
 
@@ -1257,12 +1258,14 @@ void PrintConfigDef::init_fff_params()
     def->enum_keys_map = &ConfigOptionEnum<BrimType>::get_enum_values();
     def->enum_values.emplace_back("auto_brim");
     def->enum_values.emplace_back("brim_ears");
+    def->enum_values.emplace_back("painted");
     def->enum_values.emplace_back("outer_only");
     def->enum_values.emplace_back("inner_only");
     def->enum_values.emplace_back("outer_and_inner");
     def->enum_values.emplace_back("no_brim");
     def->enum_labels.emplace_back(L("Auto"));
     def->enum_labels.emplace_back(L("Mouse ear"));
+    def->enum_labels.emplace_back(L("Painted"));
     def->enum_labels.emplace_back(L("Outer brim only"));
     def->enum_labels.emplace_back(L("Inner brim only"));
     def->enum_labels.emplace_back(L("Outer and inner brim"));

src/libslic3r/PrintConfig.hpp

@@ -226,6 +226,7 @@ enum SLAPillarConnectionMode {
 enum BrimType {
     btAutoBrim,  // BBS
     btEar, // Orca
+    btPainted,  // BBS
     btOuterOnly,
     btInnerOnly,
     btOuterAndInner,

src/libslic3r/libslic3r.h

@@ -65,9 +65,8 @@ static constexpr double LARGE_BED_THRESHOLD = 2147;
 static constexpr size_t MAXIMUM_EXTRUDER_NUMBER = 64;
 
 extern double SCALING_FACTOR;
-// for creating circles (for brim_ear)
-#define POLY_SIDES 24
 static constexpr double PI = 3.141592653589793238;
+#define POLY_SIDE_COUNT 24 // for brim ear circle
 // When extruding a closed loop, the loop is interrupted and shortened a bit to reduce the seam.
 // SoftFever: replaced by seam_gap now
 // static constexpr double LOOP_CLIPPING_LENGTH_OVER_NOZZLE_DIAMETER = 0.15;

src/slic3r/CMakeLists.txt

@@ -145,6 +145,8 @@ set(SLIC3R_GUI_SOURCES
     #GUI/Gizmos/GLGizmoFaceDetector.hpp
     GUI/Gizmos/GLGizmoMeasure.cpp
     GUI/Gizmos/GLGizmoMeasure.hpp
+    GUI/Gizmos/GLGizmoBrimEars.cpp
+    GUI/Gizmos/GLGizmoBrimEars.hpp
     GUI/Gizmos/GLGizmoAssembly.cpp
     GUI/Gizmos/GLGizmoAssembly.hpp
     GUI/Gizmos/GLGizmoSeam.cpp

src/slic3r/GUI/ConfigManipulation.cpp

@@ -569,7 +569,8 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
     
     bool have_brim = (config->opt_enum<BrimType>("brim_type") != btNoBrim);
     toggle_field("brim_object_gap", have_brim);
-    bool have_brim_width = (config->opt_enum<BrimType>("brim_type") != btNoBrim) && config->opt_enum<BrimType>("brim_type") != btAutoBrim;
+    bool have_brim_width = (config->opt_enum<BrimType>("brim_type") != btNoBrim) && config->opt_enum<BrimType>("brim_type") != btAutoBrim &&
+                           config->opt_enum<BrimType>("brim_type") != btPainted;
     toggle_field("brim_width", have_brim_width);
     // wall_filament uses the same logic as in Print::extruders()
     toggle_field("wall_filament", have_perimeters || have_brim);

src/slic3r/GUI/GLCanvas3D.cpp

@@ -1441,6 +1441,8 @@ void GLCanvas3D::toggle_model_objects_visibility(bool visible, const ModelObject
                         && !vol->is_modifier) {
                         vol->force_neutral_color = true;
                     }
+                    else if (gizmo_type == GLGizmosManager::BrimEars)
+                        vol->force_neutral_color = false;
                     else if (gizmo_type == GLGizmosManager::MmuSegmentation)
                         vol->is_active = false;
                     else
@@ -1893,6 +1895,7 @@ void GLCanvas3D::render(bool only_init)
 
     //BBS add partplater rendering logic
     bool only_current = false, only_body = false, show_axes = true, no_partplate = false;
+    bool show_grid = true;
     GLGizmosManager::EType gizmo_type = m_gizmos.get_current_type();
     if (!m_main_toolbar.is_enabled()) {
         //only_body = true;
@@ -1900,6 +1903,8 @@ void GLCanvas3D::render(bool only_init)
     }
     else if ((gizmo_type == GLGizmosManager::FdmSupports) || (gizmo_type == GLGizmosManager::Seam) || (gizmo_type == GLGizmosManager::MmuSegmentation))
         no_partplate = true;
+    else if (gizmo_type == GLGizmosManager::BrimEars && !camera.is_looking_downward())
+        show_grid = false;
 
     /* view3D render*/
     int hover_id = (m_hover_plate_idxs.size() > 0)?m_hover_plate_idxs.front():-1;
@@ -1911,7 +1916,7 @@ void GLCanvas3D::render(bool only_init)
         if (!no_partplate)
             _render_bed(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), show_axes);
         if (!no_partplate) //BBS: add outline logic
-            _render_platelist(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), only_current, only_body, hover_id, true);
+            _render_platelist(camera.get_view_matrix(), camera.get_projection_matrix(), !camera.is_looking_downward(), only_current, only_body, hover_id, true, show_grid);
         _render_objects(GLVolumeCollection::ERenderType::Transparent, !m_gizmos.is_running());
     }
     /* preview render */
@@ -7162,9 +7167,9 @@ void GLCanvas3D::_render_bed(const Transform3d& view_matrix, const Transform3d&
     m_bed.render(*this, view_matrix, projection_matrix, bottom, scale_factor, show_axes);
 }
 
-void GLCanvas3D::_render_platelist(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body, int hover_id, bool render_cali)
+void GLCanvas3D::_render_platelist(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body, int hover_id, bool render_cali, bool show_grid)
 {
-    wxGetApp().plater()->get_partplate_list().render(view_matrix, projection_matrix, bottom, only_current, only_body, hover_id, render_cali);
+    wxGetApp().plater()->get_partplate_list().render(view_matrix, projection_matrix, bottom, only_current, only_body, hover_id, render_cali, show_grid);
 }
 
 void GLCanvas3D::_render_plane() const

src/slic3r/GUI/GLCanvas3D.hpp

@@ -1161,7 +1161,7 @@ private:
     void _render_background();
     void _render_bed(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool show_axes);
     //BBS: add part plate related logic
-    void _render_platelist(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body = false, int hover_id = -1, bool render_cali = false);
+    void _render_platelist(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body = false, int hover_id = -1, bool render_cali = false, bool show_grid = true);
     //BBS: add outline drawing logic
     void _render_objects(GLVolumeCollection::ERenderType type, bool with_outline = true);
     //BBS: GUI refactor: add canvas size as parameters

src/slic3r/GUI/Gizmos/GLGizmoBase.hpp

@@ -32,6 +32,7 @@ class ImGuiWrapper;
 class GLCanvas3D;
 enum class CommonGizmosDataID;
 class CommonGizmosDataPool;
+class Selection;
 
 class GLGizmoBase
 {

src/slic3r/GUI/Gizmos/GLGizmoBrimEars.hpp

@@ -0,0 +1,177 @@
+#ifndef slic3r_GLGizmoBrimEars_hpp_
+#define slic3r_GLGizmoBrimEars_hpp_
+
+#include "GLGizmoBase.hpp"
+#include "slic3r/GUI/GLSelectionRectangle.hpp"
+#include "libslic3r/BrimEarsPoint.hpp"
+#include "libslic3r/ObjectID.hpp"
+
+
+namespace Slic3r {
+
+class ConfigOption;
+
+namespace GUI {
+
+enum class SLAGizmoEventType : unsigned char;
+
+class GLGizmoBrimEars : public GLGizmoBase
+{
+private:
+    using PickRaycaster = SceneRaycasterItem;
+
+    bool unproject_on_mesh(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal);
+    bool unproject_on_mesh2(const Vec2d& mouse_pos, std::pair<Vec3f, Vec3f>& pos_and_normal);
+
+    const float RenderPointScale = 1.f;
+
+    class CacheEntry {
+    public:
+        CacheEntry() :
+            brim_point(BrimPoint()),
+            selected(false),
+            normal(Vec3f(0, 0, 1)),
+            is_hover(false),
+            is_error(false)
+        {}
+
+        CacheEntry(const BrimPoint &point, bool sel = false, const Vec3f &norm = Vec3f(0, 0, 1), bool hover = false, bool error = false)
+            : brim_point(point), selected(sel), normal(norm), is_hover(hover), is_error(error)
+        {}
+
+        bool operator==(const CacheEntry& rhs) const {
+            return (brim_point == rhs.brim_point);
+        }
+
+        bool operator!=(const CacheEntry& rhs) const {
+            return ! ((*this) == rhs);
+        }
+
+        inline bool pos_is_zero() {
+            return brim_point.pos.isZero();
+        }
+
+        void set_empty() {
+            brim_point = BrimPoint();
+            selected = false;
+            normal.setZero();
+            is_hover = false;
+            is_error = false;
+        }
+
+        BrimPoint brim_point;
+        bool selected; // whether the point is selected
+        bool is_hover; // show mouse hover cylinder
+        bool is_error;
+        Vec3f normal;
+
+        template<class Archive>
+        void serialize(Archive & ar)
+        {
+            ar(brim_point, selected, normal);
+        }
+    };
+
+public:
+    GLGizmoBrimEars(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id);
+    virtual ~GLGizmoBrimEars() = default;
+    void data_changed(bool is_serializing) override;
+    void set_brim_data();
+    bool on_mouse(const wxMouseEvent& mouse_event) override;
+    bool gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_position, bool shift_down, bool alt_down, bool control_down);
+    void delete_selected_points();
+    void save_model();
+    //ClippingPlane get_sla_clipping_plane() const;
+
+    bool is_selection_rectangle_dragging() const { return m_selection_rectangle.is_dragging(); }
+
+    bool wants_enter_leave_snapshots() const override { return true; }
+    std::string get_gizmo_entering_text() const override { return "Entering Brim Ears"; }
+    std::string get_gizmo_leaving_text() const override { return "Leaving Brim Ears"; }
+
+private:
+    bool on_init() override;
+    void on_dragging(const UpdateData& data) override;
+    void on_render() override;
+
+    void render_points(const Selection& selection);
+
+    float m_new_point_head_diameter;        // Size of a new point.
+    float m_max_angle = 125.f;
+    float m_detection_radius = 1.f;
+    double m_detection_radius_max = .0f;
+    CacheEntry m_point_before_drag;         // undo/redo - so we know what state was edited
+    float m_old_point_head_diameter = 0.;   // the same
+    mutable std::vector<CacheEntry> m_editing_cache; // a support point and whether it is currently selectedchanges or undo/redo
+    std::map<int, CacheEntry> m_single_brim;
+    ObjectID m_old_mo_id;
+    const Vec3d m_world_normal = {0, 0, 1};
+    std::map<GLVolume*, std::shared_ptr<PickRaycaster>>   m_mesh_raycaster_map;
+    GLVolume* m_last_hit_volume;
+    CacheEntry* render_hover_point = nullptr;
+
+    bool m_link_text_hover = false;
+    
+    PickingModel m_cylinder;
+
+    // This map holds all translated description texts, so they can be easily referenced during layout calculations
+    // etc. When language changes, GUI is recreated and this class constructed again, so the change takes effect.
+    std::map<std::string, wxString> m_desc;
+
+    GLSelectionRectangle m_selection_rectangle;
+
+    ExPolygons m_first_layer;
+
+    bool m_wait_for_up_event = false;
+    bool m_selection_empty = true;
+    EState m_old_state = Off; // to be able to see that the gizmo has just been closed (see on_set_state)
+
+    std::vector<const ConfigOption*> get_config_options(const std::vector<std::string>& keys) const;
+    bool is_mesh_point_clipped(const Vec3d& point) const;
+
+    // Methods that do the model_object and editing cache synchronization,
+    // editing mode selection, etc:
+    enum {
+        AllPoints = -2,
+        NoPoints,
+    };
+    void select_point(int i);
+    void unselect_point(int i);
+    void reload_cache();
+    Points generate_points(Polygon &obj_polygon, float ear_detection_length, float brim_ears_max_angle, bool is_outer);
+    void auto_generate();
+    void first_layer_slicer();
+    void get_detection_radius_max();
+
+protected:
+    void on_set_state() override;
+    void on_set_hover_id() override
+
+    {
+        if ((int)m_editing_cache.size() <= m_hover_id)
+            m_hover_id = -1;
+    }
+    void on_start_dragging() override;
+    void on_stop_dragging() override;
+    void on_render_input_window(float x, float y, float bottom_limit) override;
+    void show_tooltip_information(float x, float y);
+
+    std::string on_get_name() const override;
+    bool on_is_activable() const override;
+    //bool on_is_selectable() const override;
+    virtual CommonGizmosDataID on_get_requirements() const override;
+    void on_load(cereal::BinaryInputArchive& ar) override;
+    void on_save(cereal::BinaryOutputArchive& ar) const override;
+    void register_single_mesh_pick();
+    //void update_single_mesh_pick(GLVolume* v);
+    void reset_all_pick();
+    bool add_point_to_cache(Vec3f pos, float head_radius, bool selected, Vec3f normal);
+    float get_brim_default_radius() const;
+    ExPolygon make_polygon(BrimPoint point, const Geometry::Transformation &trsf);
+    void find_single();
+};
+
+} // namespace GUI
+} // namespace Slic3r
+
+#endif // slic3r_GLGizmoBrimEars_hpp_

src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp

@@ -312,6 +312,11 @@ void ObjectClipper::render_cut(const std::vector<size_t>* ignore_idxs) const
     }
 }
 
+void ObjectClipper::set_position_to_init_layer()
+{
+    m_clp.reset(new ClippingPlane({0, 0, 1}, 0.1));
+    get_pool()->get_canvas()->set_as_dirty();
+}
 
 int ObjectClipper::get_number_of_contours() const
 {
@@ -351,17 +356,22 @@ std::vector<Vec3d> ObjectClipper::point_per_contour() const
 }
 
 
-void ObjectClipper::set_position_by_ratio(double pos, bool keep_normal)
+void ObjectClipper::set_position_by_ratio(double pos, bool keep_normal, bool vertical_normal)
 {
     const ModelObject* mo = get_pool()->selection_info()->model_object();
     int active_inst = get_pool()->selection_info()->get_active_instance();
     double z_shift = get_pool()->selection_info()->get_sla_shift();
 
-    //Vec3d camera_dir = wxGetApp().plater()->get_camera().get_dir_forward();
+    Vec3d normal;
-    //if (abs(camera_dir(0)) > EPSILON || abs(camera_dir(1)) > EPSILON)
+    if(vertical_normal) {
-    //    camera_dir(2) = 0;
+        normal = {0, 0, 1};
+    }else {
+        //Vec3d camera_dir = wxGetApp().plater()->get_camera().get_dir_forward();
+        //if (abs(camera_dir(0)) > EPSILON || abs(camera_dir(1)) > EPSILON)
+        //    camera_dir(2) = 0;
 
-    Vec3d normal = (keep_normal && m_clp) ? m_clp->get_normal() : /*-camera_dir;*/ -wxGetApp().plater()->get_camera().get_dir_forward();
+        normal = (keep_normal && m_clp) ? m_clp->get_normal() : /*-camera_dir;*/ -wxGetApp().plater()->get_camera().get_dir_forward();
+    }
     Vec3d center;
 
     if (get_pool()->get_canvas()->get_canvas_type() == GLCanvas3D::CanvasAssembleView) {

src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp

@@ -232,9 +232,10 @@ public:
     CommonGizmosDataID get_dependencies() const override { return CommonGizmosDataID::SelectionInfo; }
 #endif // NDEBUG
     double get_position() const { return m_clp_ratio; }
+    void set_position_to_init_layer();
     const ClippingPlane* get_clipping_plane(bool ignore_hide_clipped = false) const;
     void render_cut(const std::vector<size_t>* ignore_idxs = nullptr) const;
-    void set_position_by_ratio(double pos, bool keep_normal);
+    void set_position_by_ratio(double pos, bool keep_normal, bool vertical_normal=false);
     void set_range_and_pos(const Vec3d& cpl_normal, double cpl_offset, double pos);
     void set_behavior(bool hide_clipped, bool fill_cut, double contour_width);
     

src/slic3r/GUI/Gizmos/GLGizmosManager.cpp

@@ -15,6 +15,7 @@
 #include "slic3r/GUI/Gizmos/GLGizmoFlatten.hpp"
 //#include "slic3r/GUI/Gizmos/GLGizmoSlaSupports.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoFdmSupports.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmoBrimEars.hpp"
 #include "slic3r/GUI/Gizmos/GLGizmoCut.hpp"
 //#include "slic3r/GUI/Gizmos/GLGizmoFaceDetector.hpp"
 //#include "slic3r/GUI/Gizmos/GLGizmoHollow.hpp"
@@ -206,6 +207,7 @@ bool GLGizmosManager::init()
     m_gizmos.emplace_back(new GLGizmoMeasure(m_parent, m_is_dark ? "toolbar_measure_dark.svg" : "toolbar_measure.svg", EType::Measure));
     m_gizmos.emplace_back(new GLGizmoAssembly(m_parent, m_is_dark ? "toolbar_assembly_dark.svg" : "toolbar_assembly.svg", EType::Assembly));
     m_gizmos.emplace_back(new GLGizmoSimplify(m_parent, "reduce_triangles.svg", EType::Simplify));
+    m_gizmos.emplace_back(new GLGizmoBrimEars(m_parent, m_is_dark ? "toolbar_brimears_dark.svg" : "toolbar_brimears.svg", EType::BrimEars));
     //m_gizmos.emplace_back(new GLGizmoSlaSupports(m_parent, "sla_supports.svg", sprite_id++));
     //m_gizmos.emplace_back(new GLGizmoFaceDetector(m_parent, "face recognition.svg", sprite_id++));
     //m_gizmos.emplace_back(new GLGizmoHollow(m_parent, "hollow.svg", sprite_id++));
@@ -453,6 +455,8 @@ bool GLGizmosManager::gizmo_event(SLAGizmoEventType action, const Vec2d& mouse_p
         return dynamic_cast<GLGizmoCut3D*>(m_gizmos[Cut].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else if (m_current == MeshBoolean)
         return dynamic_cast<GLGizmoMeshBoolean*>(m_gizmos[MeshBoolean].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
+    else if (m_current == BrimEars)
+        return dynamic_cast<GLGizmoBrimEars*>(m_gizmos[BrimEars].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
     else
         return false;
 }
@@ -543,7 +547,7 @@ bool GLGizmosManager::on_mouse_wheel(const wxMouseEvent &evt)
 {
     bool processed = false;
 
-    if (/*m_current == SlaSupports || m_current == Hollow ||*/ m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation) {
+    if (/*m_current == SlaSupports || m_current == Hollow ||*/ m_current == FdmSupports || m_current == Seam || m_current == MmuSegmentation || m_current == BrimEars) {
         float rot = (float)evt.GetWheelRotation() / (float)evt.GetWheelDelta();
         if (gizmo_event((rot > 0.f ? SLAGizmoEventType::MouseWheelUp : SLAGizmoEventType::MouseWheelDown), Vec2d::Zero(), evt.ShiftDown(), evt.AltDown()
             // BBS
@@ -813,21 +817,25 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
     int keyCode = evt.GetKeyCode();
     bool processed = false;
 
-    if (evt.GetEventType() == wxEVT_KEY_UP) {
+    if (evt.GetEventType() == wxEVT_KEY_UP)
-        /*if (m_current == SlaSupports || m_current == Hollow)
+    {
+        if (/*m_current == SlaSupports || m_current == Hollow ||*/ m_current == BrimEars)
         {
             bool is_editing = true;
             bool is_rectangle_dragging = false;
 
-            if (m_current == SlaSupports) {
+            /*if (m_current == SlaSupports) {
                 GLGizmoSlaSupports* gizmo = dynamic_cast<GLGizmoSlaSupports*>(get_current());
                 is_editing = gizmo->is_in_editing_mode();
                 is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
-            }
+            } else*/ if (m_current == BrimEars) {
-            else {
+                GLGizmoBrimEars* gizmo = dynamic_cast<GLGizmoBrimEars*>(get_current());
-                GLGizmoHollow* gizmo = dynamic_cast<GLGizmoHollow*>(get_current());
                 is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
             }
+            /*else {
+                GLGizmoHollow* gizmo = dynamic_cast<GLGizmoHollow*>(get_current());
+                is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
+            }*/
 
             if (keyCode == WXK_SHIFT)
             {
@@ -847,7 +855,7 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
                 // capture number key
                 processed = true;
             }
-        }*/
+        }
         if (m_current == Measure || m_current == Assembly) {
             if (keyCode == WXK_CONTROL)
                 gizmo_event(SLAGizmoEventType::CtrlUp, Vec2d::Zero(), evt.ShiftDown(), evt.AltDown(), evt.CmdDown());
@@ -865,7 +873,12 @@ bool GLGizmosManager::on_key(wxKeyEvent& evt)
 //            m_parent.set_cursor(GLCanvas3D::Cross);
             processed = true;
         }
-        else*/ if (m_current == Cut) {
+        else*/ if  ((m_current == BrimEars) && ((keyCode == WXK_SHIFT) || (keyCode == WXK_ALT)))
+        {
+            processed = true;
+        }
+        else if (m_current == Cut)
+        {
             auto do_move = [this, &processed](double delta_z) {
                 GLGizmoCut3D* cut = dynamic_cast<GLGizmoCut3D*>(get_current());
                 cut->shift_cut(delta_z);
@@ -1324,11 +1337,15 @@ bool GLGizmosManager::grabber_contains_mouse() const
 
 bool GLGizmosManager::is_in_editing_mode(bool error_notification) const
 {
-    //if (m_current != SlaSupports || ! dynamic_cast<GLGizmoSlaSupports*>(get_current())->is_in_editing_mode())
+    /*if (m_current == SlaSupports && dynamic_cast<GLGizmoSlaSupports*>(get_current())->is_in_editing_mode()) {
+        return true;
+    } else*/ if (m_current == BrimEars) {
+        dynamic_cast<GLGizmoBrimEars*>(get_current())->save_model();
         return false;
+    } else {
+        return false;
+    }
 
-    // BBS: remove SLA editing notification
-    //return true;
 }
 
 

src/slic3r/GUI/Gizmos/GLGizmosManager.hpp

@@ -88,6 +88,7 @@ public:
         Measure,
         Assembly,
         Simplify,
+        BrimEars,
         //SlaSupports,
         // BBS
         //FaceRecognition,

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -560,6 +560,15 @@ ImVec2 ImGuiWrapper::calc_text_size(const wxString &text,
     return size;
 }
 
+float ImGuiWrapper::find_widest_text(std::vector<wxString> &text_list)
+{
+    float width = .0f;
+    for(const wxString &text : text_list) {
+        width = std::max(width, this->calc_text_size(text).x);
+    }
+    return width;
+}
+
 ImVec2 ImGuiWrapper::calc_button_size(const wxString &text, const ImVec2 &button_size) const
 {
     const ImVec2        text_size = this->calc_text_size(text);

src/slic3r/GUI/ImGuiWrapper.hpp

@@ -107,7 +107,7 @@ public:
     static ImVec2 calc_text_size(const std::string& text, bool  hide_text_after_double_hash = false, float wrap_width = -1.0f);
     static ImVec2 calc_text_size(const wxString &text, bool  hide_text_after_double_hash = false, float wrap_width = -1.0f);
     ImVec2 calc_button_size(const wxString &text, const ImVec2 &button_size = ImVec2(0, 0)) const;
-
+    float find_widest_text(std::vector<wxString> &text_list);
     ImVec2 get_item_spacing() const;
     float  get_slider_float_height() const;
     const LastSliderStatus& get_last_slider_status() const { return m_last_slider_status; }

src/slic3r/GUI/PartPlate.cpp

@@ -2724,7 +2724,7 @@ bool PartPlate::intersects(const BoundingBoxf3& bb) const
 	return print_volume.intersects(bb);
 }
 
-void PartPlate::render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_body, bool force_background_color, HeightLimitMode mode, int hover_id, bool render_cali)
+void PartPlate::render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_body, bool force_background_color, HeightLimitMode mode, int hover_id, bool render_cali, bool show_grid)
 {
     glsafe(::glEnable(GL_DEPTH_TEST));
 
@@ -2744,7 +2744,8 @@ void PartPlate::render(const Transform3d& view_matrix, const Transform3d& projec
             render_exclude_area(force_background_color);
         }
 
-        render_grid(bottom);
+        if (show_grid)
+            render_grid(bottom);
 
         render_height_limit(mode);
 
@@ -4781,7 +4782,7 @@ void PartPlateList::postprocess_arrange_polygon(arrangement::ArrangePolygon& arr
 
 /*rendering related functions*/
 //render
-void PartPlateList::render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body, int hover_id, bool render_cali)
+void PartPlateList::render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current, bool only_body, int hover_id, bool render_cali, bool show_grid)
 {
 	const std::lock_guard<std::mutex> local_lock(m_plates_mutex);
 	std::vector<PartPlate*>::iterator it = m_plate_list.begin();
@@ -4806,15 +4807,15 @@ void PartPlateList::render(const Transform3d& view_matrix, const Transform3d& pr
 		if (current_index == m_current_plate) {
 			PartPlate::HeightLimitMode height_mode = (only_current)?PartPlate::HEIGHT_LIMIT_NONE:m_height_limit_mode;
 			if (plate_hover_index == current_index)
-                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, plate_hover_action, render_cali);
+                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, plate_hover_action, render_cali, show_grid);
 			else
-                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, -1, render_cali);
+                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, height_mode, -1, render_cali, show_grid);
 		}
 		else {
 			if (plate_hover_index == current_index)
-				(*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, plate_hover_action, render_cali);
+				(*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, plate_hover_action, render_cali, show_grid);
 			else
-                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, -1, render_cali);
+                (*it)->render(view_matrix, projection_matrix, bottom, only_body, false, PartPlate::HEIGHT_LIMIT_NONE, -1, render_cali, show_grid);
 		}
 	}
 }

src/slic3r/GUI/PartPlate.hpp

@@ -363,7 +363,7 @@ public:
     bool contains(const BoundingBoxf3& bb) const;
     bool intersects(const BoundingBoxf3& bb) const;
 
-    void render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_body = false, bool force_background_color = false, HeightLimitMode mode = HEIGHT_LIMIT_NONE, int hover_id = -1, bool render_cali = false);
+    void render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_body = false, bool force_background_color = false, HeightLimitMode mode = HEIGHT_LIMIT_NONE, int hover_id = -1, bool render_cali = false, bool show_grid = true);
 
     void set_selected();
     void set_unselected();
@@ -781,7 +781,7 @@ public:
 
     /*rendering related functions*/
     void on_change_color_mode(bool is_dark) { m_is_dark = is_dark; }
-    void render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current = false, bool only_body = false, int hover_id = -1, bool render_cali = false);
+    void render(const Transform3d& view_matrix, const Transform3d& projection_matrix, bool bottom, bool only_current = false, bool only_body = false, int hover_id = -1, bool render_cali = false, bool show_grid = true);
     void set_render_option(bool bedtype_texture, bool plate_settings);
     void set_render_cali(bool value = true) { render_cali_logo = value; }
     void register_raycasters_for_picking(GLCanvas3D& canvas)