diff --git a/resources/images/toolbar_brimears.svg b/resources/images/toolbar_brimears.svg
new file mode 100644
index 0000000000..1c5b42af41
--- /dev/null
+++ b/resources/images/toolbar_brimears.svg
@@ -0,0 +1,19 @@
+
diff --git a/resources/images/toolbar_brimears_dark.svg b/resources/images/toolbar_brimears_dark.svg
new file mode 100644
index 0000000000..fe016e3019
--- /dev/null
+++ b/resources/images/toolbar_brimears_dark.svg
@@ -0,0 +1,19 @@
+
diff --git a/src/libslic3r/Brim.cpp b/src/libslic3r/Brim.cpp
index 5deec514a8..e9fdd7921b 100644
--- a/src/libslic3r/Brim.cpp
+++ b/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,
- coordf_t brim_ears_max_angle, bool is_outer_brim) {
+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) {
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++) {
- double angle = (2.0 * PI * i) / POLY_SIDES;
+ 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));
}
@@ -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 ¢er_offset = object->center_offset();
+ model_trsf = model_trsf.pretranslate(Vec3d(- unscale(center_offset.x()), - unscale(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& 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 has_inner_brim = brim_type == btInnerOnly || brim_type == btOuterAndInner || use_brim_ears;
- const bool has_outer_brim = brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btAutoBrim || use_brim_ears;
+ const bool use_auto_brim_ears = object->config().brim_type == btEar;
+ const bool use_brim_ears = object->config().brim_type == btPainted;
+ 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));
- } else {
- // Normal brims
- append(brim_area_object, diff_ex(offset_ex(innerExpoly, brim_width_mod, jtRound, SCALED_RESOLUTION), clipExpoly));
+ outerExpoly = make_brim_ears_auto(innerExpoly, size_ear, ear_detection_length, brim_ears_max_angle, true);
+ }else {
+ outerExpoly = offset_ex(innerExpoly, brim_width_mod, jtRound, SCALED_RESOLUTION);
}
+ append(brim_area_object, diff_ex(outerExpoly, innerExpoly));
}
if (has_inner_brim) {
- auto outerExpoly = offset_ex(ex_poly_holes_reversed, -brim_offset);
- auto clipExpoly = offset_ex(ex_poly_holes_reversed, -brim_width - brim_offset);
-
+ ExPolygons outerExpoly;
+ 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));
- } else {
- // Normal brims
- append(brim_area_object, diff_ex(outerExpoly, 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 {
+ outerExpoly = offset_ex(ex_poly_holes_reversed, -brim_offset);
}
+ append(brim_area_object, diff_ex(outerExpoly, innerExpoly));
}
if (!has_inner_brim) {
// BBS: brim should be apart from holes
diff --git a/src/libslic3r/BrimEarsPoint.hpp b/src/libslic3r/BrimEarsPoint.hpp
new file mode 100644
index 0000000000..d768d21976
--- /dev/null
+++ b/src/libslic3r/BrimEarsPoint.hpp
@@ -0,0 +1,63 @@
+#ifndef BRIMEARSPOINT_HPP
+#define BRIMEARSPOINT_HPP
+
+#include
+
+
+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();
+ return result.cast();
+ }
+
+ 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 void serialize(Archive &ar)
+ {
+ ar(pos, head_front_radius);
+ }
+};
+
+using BrimPoints = std::vector;
+
+}
+
+
+#endif // BRIMEARSPOINT_HPP
\ No newline at end of file
diff --git a/src/libslic3r/CMakeLists.txt b/src/libslic3r/CMakeLists.txt
index 7c673231e0..8a4e2a8429 100644
--- a/src/libslic3r/CMakeLists.txt
+++ b/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
diff --git a/src/libslic3r/ExPolygon.cpp b/src/libslic3r/ExPolygon.cpp
index 364d2a6126..8e1dd12ed5 100644
--- a/src/libslic3r/ExPolygon.cpp
+++ b/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;
diff --git a/src/libslic3r/ExPolygon.hpp b/src/libslic3r/ExPolygon.hpp
index d72fdf3389..187ef27a11 100644
--- a/src/libslic3r/ExPolygon.hpp
+++ b/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);
diff --git a/src/libslic3r/Format/bbs_3mf.cpp b/src/libslic3r/Format/bbs_3mf.cpp
index f13181ad27..38f4f34307 100644
--- a/src/libslic3r/Format/bbs_3mf.cpp
+++ b/src/libslic3r/Format/bbs_3mf.cpp
@@ -170,6 +170,7 @@ const std::string BBS_MODEL_CONFIG_RELS_FILE = "Metadata/_rels/model_settings.co
const std::string SLICE_INFO_CONFIG_FILE = "Metadata/slice_info.config";
const std::string BBS_LAYER_HEIGHTS_PROFILE_FILE = "Metadata/layer_heights_profile.txt";
const std::string LAYER_CONFIG_RANGES_FILE = "Metadata/layer_config_ranges.xml";
+const std::string BRIM_EAR_POINTS_FILE = "Metadata/brim_ear_points.txt";
/*const std::string SLA_SUPPORT_POINTS_FILE = "Metadata/Slic3r_PE_sla_support_points.txt";
const std::string SLA_DRAIN_HOLES_FILE = "Metadata/Slic3r_PE_sla_drain_holes.txt";*/
const std::string CUSTOM_GCODE_PER_PRINT_Z_FILE = "Metadata/custom_gcode_per_layer.xml";
@@ -807,10 +808,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
//typedef std::map IdToAliasesMap;
typedef std::vector InstancesList;
typedef std::map IdToMetadataMap;
+ typedef std::map IdToCutObjectInfoMap;
//typedef std::map IdToGeometryMap;
typedef std::map> IdToLayerHeightsProfileMap;
typedef std::map IdToLayerConfigRangesMap;
- typedef std::map IdToCutObjectInfoMap;
+ typedef std::map IdToBrimPointsMap;
/*typedef std::map> IdToSlaSupportPointsMap;
typedef std::map> IdToSlaDrainHolesMap;*/
using PathToEmbossShapeFileMap = std::map>;
@@ -1000,9 +1002,10 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
//IdToGeometryMap m_orig_geometries; // backup & restore
CurrentConfig m_curr_config;
IdToMetadataMap m_objects_metadata;
- IdToCutObjectInfoMap m_cut_object_infos;
+ IdToCutObjectInfoMap m_cut_object_infos;
IdToLayerHeightsProfileMap m_layer_heights_profiles;
IdToLayerConfigRangesMap m_layer_config_ranges;
+ IdToBrimPointsMap m_brim_ear_points;
/*IdToSlaSupportPointsMap m_sla_support_points;
IdToSlaDrainHolesMap m_sla_drain_holes;*/
PathToEmbossShapeFileMap m_path_to_emboss_shape_files;
@@ -1064,11 +1067,12 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
bool _extract_xml_from_archive(mz_zip_archive& archive, std::string const & path, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler);
bool _extract_xml_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat, XML_StartElementHandler start_handler, XML_EndElementHandler end_handler);
bool _extract_model_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
- void _extract_cut_information_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat, ConfigSubstitutionContext& config_substitutions);
+ void _extract_cut_information_from_archive(mz_zip_archive &archive, const mz_zip_archive_file_stat &stat, ConfigSubstitutionContext &config_substitutions);
void _extract_layer_heights_profile_config_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
void _extract_layer_config_ranges_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat, ConfigSubstitutionContext& config_substitutions);
void _extract_sla_support_points_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
void _extract_sla_drain_holes_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
+ void _extract_brim_ear_points_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
void _extract_custom_gcode_per_print_z_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat);
@@ -1270,6 +1274,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
m_objects_metadata.clear();
m_layer_heights_profiles.clear();
m_layer_config_ranges.clear();
+ m_brim_ear_points.clear();
//m_sla_support_points.clear();
m_curr_metadata_name.clear();
m_curr_characters.clear();
@@ -1759,6 +1764,10 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
// extract slic3r layer config ranges file
_extract_layer_config_ranges_from_archive(archive, stat, config_substitutions);
}
+ else if (boost::algorithm::iequals(name, BRIM_EAR_POINTS_FILE)) {
+ // extract slic3r config file
+ _extract_brim_ear_points_from_archive(archive, stat);
+ }
//BBS: disable SLA related files currently
/*else if (boost::algorithm::iequals(name, SLA_SUPPORT_POINTS_FILE)) {
// extract sla support points file
@@ -1942,6 +1951,10 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
if (obj_layer_config_ranges != m_layer_config_ranges.end())
model_object->layer_config_ranges = std::move(obj_layer_config_ranges->second);
+ IdToBrimPointsMap::iterator obj_brim_points = m_brim_ear_points.find(object.second + 1);
+ if (obj_brim_points != m_brim_ear_points.end())
+ model_object->brim_points = std::move(obj_brim_points->second);
+
// m_sla_support_points are indexed by a 1 based model object index.
/*IdToSlaSupportPointsMap::iterator obj_sla_support_points = m_sla_support_points.find(object.second + 1);
if (obj_sla_support_points != m_sla_support_points.end() && !obj_sla_support_points->second.empty()) {
@@ -2762,6 +2775,77 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
}
}
}
+
+ void _BBS_3MF_Importer::_extract_brim_ear_points_from_archive(mz_zip_archive& archive, const mz_zip_archive_file_stat& stat)
+ {
+ if (stat.m_uncomp_size > 0) {
+ std::string buffer((size_t)stat.m_uncomp_size, 0);
+ mz_bool res = mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, (void*)buffer.data(), (size_t)stat.m_uncomp_size, 0);
+ if (res == 0) {
+ add_error("Error while reading brim ear points data to buffer");
+ return;
+ }
+
+ if (buffer.back() == '\n')
+ buffer.pop_back();
+
+ std::vector objects;
+ boost::split(objects, buffer, boost::is_any_of("\n"), boost::token_compress_off);
+
+ // Info on format versioning - see bbs_3mf.hpp
+ int version = 0;
+ std::string key("brim_points_format_version=");
+ if (!objects.empty() && objects[0].find(key) != std::string::npos) {
+ objects[0].erase(objects[0].begin(), objects[0].begin() + long(key.size())); // removes the string
+ version = std::stoi(objects[0]);
+ objects.erase(objects.begin()); // pop the header
+ }
+
+ for (const std::string& object : objects) {
+ std::vector object_data;
+ boost::split(object_data, object, boost::is_any_of("|"), boost::token_compress_off);
+
+ if (object_data.size() != 2) {
+ add_error("Error while reading object data");
+ continue;
+ }
+
+ std::vector object_data_id;
+ boost::split(object_data_id, object_data[0], boost::is_any_of("="), boost::token_compress_off);
+ if (object_data_id.size() != 2) {
+ add_error("Error while reading object id");
+ continue;
+ }
+
+ int object_id = std::atoi(object_data_id[1].c_str());
+ if (object_id == 0) {
+ add_error("Found invalid object id");
+ continue;
+ }
+
+ IdToBrimPointsMap::iterator object_item = m_brim_ear_points.find(object_id);
+ if (object_item != m_brim_ear_points.end()) {
+ add_error("Found duplicated brim ear points");
+ continue;
+ }
+
+ std::vector object_data_points;
+ boost::split(object_data_points, object_data[1], boost::is_any_of(" "), boost::token_compress_off);
+
+ std::vector brim_ear_points;
+ if (version == 0) {
+ for (unsigned int i=0; i const &flush, ObjectData const &object_data) const;
bool _add_build_to_model_stream(std::stringstream& stream, const BuildItemsList& build_items) const;
- bool _add_cut_information_file_to_archive(mz_zip_archive& archive, Model& model);
bool _add_layer_height_profile_file_to_archive(mz_zip_archive& archive, Model& model);
bool _add_layer_config_ranges_file_to_archive(mz_zip_archive& archive, Model& model);
+ bool _add_brim_ear_points_file_to_archive(mz_zip_archive& archive, Model& model);
bool _add_sla_support_points_file_to_archive(mz_zip_archive& archive, Model& model);
bool _add_sla_drain_holes_file_to_archive(mz_zip_archive& archive, Model& model);
bool _add_print_config_file_to_archive(mz_zip_archive& archive, const DynamicPrintConfig &config);
@@ -5515,6 +5599,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
//BBS: add project embedded preset files
bool _add_project_embedded_presets_to_archive(mz_zip_archive& archive, Model& model, std::vector project_presets);
bool _add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, int export_plate_idx = -1, bool save_gcode = true, bool use_loaded_id = false);
+ bool _add_cut_information_file_to_archive(mz_zip_archive &archive, Model &model);
bool _add_slice_info_config_file_to_archive(mz_zip_archive &archive, const Model &model, PlateDataPtrs &plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config);
bool _add_gcode_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, Export3mfProgressFn proFn = nullptr);
bool _add_custom_gcode_per_print_z_file_to_archive(mz_zip_archive& archive, Model& model, const DynamicPrintConfig* config);
@@ -5914,6 +5999,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
return false;
}
+ if (!_add_brim_ear_points_file_to_archive(archive, model)) {
+ close_zip_writer(&archive);
+ return false;
+ }
+
// BBS progress point
/*BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format("export 3mf EXPORT_STAGE_ADD_SUPPORT\n");
if (proFn) {
@@ -7159,6 +7249,40 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
return true;
}
+ bool _BBS_3MF_Exporter::_add_brim_ear_points_file_to_archive(mz_zip_archive& archive, Model& model)
+ {
+ std::string out = "";
+ char buffer[1024];
+
+ unsigned int count = 0;
+ for (const ModelObject* object : model.objects) {
+ ++count;
+ const BrimPoints& brim_points = object->brim_points;
+ if (!brim_points.empty()) {
+ sprintf(buffer, "object_id=%d|", count);
+ out += buffer;
+
+ // Store the layer height profile as a single space separated list.
+ for (size_t i = 0; i < brim_points.size(); ++i) {
+ sprintf(buffer, (i==0 ? "%f %f %f %f" : " %f %f %f %f"), brim_points[i].pos(0), brim_points[i].pos(1), brim_points[i].pos(2), brim_points[i].head_front_radius);
+ out += buffer;
+ }
+ out += "\n";
+ }
+ }
+
+ if (!out.empty()) {
+ // Adds version header at the beginning:
+ out = std::string("brim_points_format_version=") + std::to_string(brim_points_format_version) + std::string("\n") + out;
+
+ if (!mz_zip_writer_add_mem(&archive, BRIM_EAR_POINTS_FILE.c_str(), (const void*)out.data(), out.length(), MZ_DEFAULT_COMPRESSION)) {
+ add_error("Unable to add brim ear points file to archive");
+ return false;
+ }
+ }
+ return true;
+ }
+
/*
bool _BBS_3MF_Exporter::_add_sla_support_points_file_to_archive(mz_zip_archive& archive, Model& model)
{
diff --git a/src/libslic3r/Format/bbs_3mf.hpp b/src/libslic3r/Format/bbs_3mf.hpp
index 6d0c092b77..6a4c404803 100644
--- a/src/libslic3r/Format/bbs_3mf.hpp
+++ b/src/libslic3r/Format/bbs_3mf.hpp
@@ -141,6 +141,10 @@ inline bool operator & (SaveStrategy & lhs, SaveStrategy rhs)
return ((static_cast(lhs) & static_cast(rhs))) == static_cast(rhs);
}
+enum {
+ brim_points_format_version = 0
+};
+
enum class LoadStrategy
{
Default = 0,
diff --git a/src/libslic3r/Model.cpp b/src/libslic3r/Model.cpp
index 9a6a5718ba..d7b23b6b7e 100644
--- a/src/libslic3r/Model.cpp
+++ b/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& 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)
diff --git a/src/libslic3r/Model.hpp b/src/libslic3r/Model.hpp
index 56f1f7afed..f3000d9628 100644
--- a/src/libslic3r/Model.hpp
+++ b/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
- CutConnectors cut_connectors;
- CutObjectBase cut_id;
+ BrimPoints brim_points;
/* 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 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 config_wrapper(config);
Internal::StaticSerializationWrapper 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);
diff --git a/src/libslic3r/PrintApply.cpp b/src/libslic3r/PrintApply.cpp
index a5cbc3ed34..b7d630c0d5 100644
--- a/src/libslic3r/PrintApply.cpp
+++ b/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.
diff --git a/src/libslic3r/PrintConfig.cpp b/src/libslic3r/PrintConfig.cpp
index 9844bafc14..1c45054d38 100644
--- a/src/libslic3r/PrintConfig.cpp
+++ b/src/libslic3r/PrintConfig.cpp
@@ -328,6 +328,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)
@@ -1258,12 +1259,14 @@ void PrintConfigDef::init_fff_params()
def->enum_keys_map = &ConfigOptionEnum::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"));
diff --git a/src/libslic3r/PrintConfig.hpp b/src/libslic3r/PrintConfig.hpp
index 326d250708..02db0c061b 100644
--- a/src/libslic3r/PrintConfig.hpp
+++ b/src/libslic3r/PrintConfig.hpp
@@ -226,6 +226,7 @@ enum SLAPillarConnectionMode {
enum BrimType {
btAutoBrim, // BBS
btEar, // Orca
+ btPainted, // BBS
btOuterOnly,
btInnerOnly,
btOuterAndInner,
diff --git a/src/libslic3r/libslic3r.h b/src/libslic3r/libslic3r.h
index 798ea77d76..9df346e708 100644
--- a/src/libslic3r/libslic3r.h
+++ b/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;
diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt
index 7dd5f9f996..1e5ae34510 100644
--- a/src/slic3r/CMakeLists.txt
+++ b/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
diff --git a/src/slic3r/GUI/ConfigManipulation.cpp b/src/slic3r/GUI/ConfigManipulation.cpp
index d36690ad85..deb8f66da9 100644
--- a/src/slic3r/GUI/ConfigManipulation.cpp
+++ b/src/slic3r/GUI/ConfigManipulation.cpp
@@ -569,7 +569,8 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, co
bool have_brim = (config->opt_enum("brim_type") != btNoBrim);
toggle_field("brim_object_gap", have_brim);
- bool have_brim_width = (config->opt_enum("brim_type") != btNoBrim) && config->opt_enum("brim_type") != btAutoBrim;
+ bool have_brim_width = (config->opt_enum("brim_type") != btNoBrim) && config->opt_enum("brim_type") != btAutoBrim &&
+ config->opt_enum("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);
diff --git a/src/slic3r/GUI/GLCanvas3D.cpp b/src/slic3r/GUI/GLCanvas3D.cpp
index 7b7b071769..26688a2383 100644
--- a/src/slic3r/GUI/GLCanvas3D.cpp
+++ b/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
diff --git a/src/slic3r/GUI/GLCanvas3D.hpp b/src/slic3r/GUI/GLCanvas3D.hpp
index 34e050c369..c2a5b9d00d 100644
--- a/src/slic3r/GUI/GLCanvas3D.hpp
+++ b/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
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
index 97875ee606..089dd1d454 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.cpp
@@ -74,11 +74,11 @@ PickingModel GLGizmoBase::Grabber::s_cone;
GLGizmoBase::Grabber::~Grabber()
{
- if (s_cube.model.is_initialized())
- s_cube.model.reset();
+ //if (s_cube.model.is_initialized())
+ // s_cube.model.reset();
- if (s_cone.model.is_initialized())
- s_cone.model.reset();
+ //if (s_cone.model.is_initialized())
+ // s_cone.model.reset();
}
float GLGizmoBase::Grabber::get_half_size(float size) const
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
index e78da31501..ed7426dd2f 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBase.hpp
@@ -32,6 +32,7 @@ class ImGuiWrapper;
class GLCanvas3D;
enum class CommonGizmosDataID;
class CommonGizmosDataPool;
+class Selection;
class GLGizmoBase
{
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.cpp b/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.cpp
new file mode 100644
index 0000000000..5ee7bab7c8
--- /dev/null
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.cpp
@@ -0,0 +1,1167 @@
+#include "GLGizmoBrimEars.hpp"
+#include
+#include "slic3r/GUI/GLCanvas3D.hpp"
+#include "slic3r/GUI/Camera.hpp"
+#include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/GUI/Plater.hpp"
+#include "libslic3r/ClipperUtils.hpp"
+#include "libslic3r/ExPolygon.hpp"
+
+namespace Slic3r { namespace GUI {
+
+static const ColorRGBA DEF_COLOR = {0.7f, 0.7f, 0.7f, 1.f};
+static const ColorRGBA SELECTED_COLOR = {0.0f, 0.5f, 0.5f, 1.0f};
+static const ColorRGBA ERR_COLOR = {1.0f, 0.3f, 0.3f, 0.5f};
+static const ColorRGBA HOVER_COLOR = {0.7f, 0.7f, 0.7f, 0.5f};
+
+static ModelVolume *get_model_volume(const Selection &selection, Model &model)
+{
+ const Selection::IndicesList &idxs = selection.get_volume_idxs();
+ // only one selected volume
+ if (idxs.size() != 1) return nullptr;
+ const GLVolume *selected_volume = selection.get_volume(*idxs.begin());
+ if (selected_volume == nullptr) return nullptr;
+
+ const GLVolume::CompositeID &cid = selected_volume->composite_id;
+ const ModelObjectPtrs &objs = model.objects;
+ if (cid.object_id < 0 || objs.size() <= static_cast(cid.object_id)) return nullptr;
+ const ModelObject *obj = objs[cid.object_id];
+ if (cid.volume_id < 0 || obj->volumes.size() <= static_cast(cid.volume_id)) return nullptr;
+ return obj->volumes[cid.volume_id];
+}
+
+GLGizmoBrimEars::GLGizmoBrimEars(GLCanvas3D &parent, const std::string &icon_filename, unsigned int sprite_id) : GLGizmoBase(parent, icon_filename, sprite_id)
+{
+ GLModel::Geometry cylinder_geometry = smooth_cylinder(16, 1.0f, 1.0f);
+ m_cylinder.mesh_raycaster = std::make_unique(std::make_shared(cylinder_geometry.get_as_indexed_triangle_set()));
+ m_cylinder.model.init_from(std::move(cylinder_geometry));
+}
+
+bool GLGizmoBrimEars::on_init()
+{
+
+ m_new_point_head_diameter = get_brim_default_radius();
+
+ m_shortcut_key = WXK_CONTROL_L;
+
+ m_desc["head_diameter"] = _L("Head diameter");
+ m_desc["max_angle"] = _L("Max angle");
+ m_desc["detection_radius"] = _L("Detection radius");
+ m_desc["remove_selected"] = _L("Remove selected points");
+ m_desc["remove_all"] = _L("Remove all");
+ m_desc["auto_generate"] = _L("Auto-generate points");
+ m_desc["section_view"] = _L("Section view");
+
+ m_desc["left_click_caption"] = _L("Left click");
+ m_desc["left_click"] = _L("Add a brim ear");
+ m_desc["right_click_caption"] = _L("Right click");
+ m_desc["right_click"] = _L("Delete a brim ear");
+ m_desc["ctrl_mouse_wheel_caption"] = _L("Ctrl+Mouse wheel");
+ m_desc["ctrl_mouse_wheel"] = _L("Adjust section view");
+
+ return true;
+}
+
+void GLGizmoBrimEars::set_brim_data()
+{
+ if (!m_c->selection_info()) return;
+
+ ModelObject *mo = m_c->selection_info()->model_object();
+
+ if (m_state == On && mo && mo->id() != m_old_mo_id) {
+ reload_cache();
+ m_old_mo_id = mo->id();
+ }
+}
+
+void GLGizmoBrimEars::on_render()
+{
+ ModelObject *mo = m_c->selection_info()->model_object();
+ const Selection &selection = m_parent.get_selection();
+
+ // If current m_c->m_model_object does not match selection, ask GLCanvas3D to turn us off
+ if (m_state == On && (mo != selection.get_model()->objects[selection.get_object_idx()] || m_c->selection_info()->get_active_instance() != selection.get_instance_idx())) {
+ m_parent.post_event(SimpleEvent(EVT_GLCANVAS_RESETGIZMOS));
+ return;
+ }
+
+ glsafe(::glEnable(GL_BLEND));
+ glsafe(::glEnable(GL_DEPTH_TEST));
+
+ if (selection.is_from_single_instance()) render_points(selection);
+
+ m_selection_rectangle.render(m_parent);
+ m_c->object_clipper()->render_cut();
+
+ glsafe(::glDisable(GL_BLEND));
+}
+
+void GLGizmoBrimEars::render_points(const Selection &selection)
+{
+ auto editing_cache = m_editing_cache;
+ if (render_hover_point != nullptr) { editing_cache.push_back(*render_hover_point); }
+
+ size_t cache_size = editing_cache.size();
+
+ bool has_points = (cache_size != 0);
+
+ if (!has_points) return;
+
+ GLShaderProgram *shader = wxGetApp().get_shader("gouraud_light");
+ if (shader != nullptr) shader->start_using();
+ ScopeGuard guard([shader]() {
+ if (shader != nullptr) shader->stop_using();
+ });
+
+ const Camera& camera = wxGetApp().plater()->get_camera();
+ const Transform3d& view_matrix = camera.get_view_matrix();
+ const GLVolume *vol = selection.get_volume(*selection.get_volume_idxs().begin());
+ const Transform3d &instance_scaling_matrix_inverse = vol->get_instance_transformation().get_scaling_factor_matrix().inverse();
+ const Transform3d &instance_matrix = vol->get_instance_transformation().get_matrix();
+
+ ColorRGBA render_color;
+ for (size_t i = 0; i < cache_size; ++i) {
+ const BrimPoint &brim_point = editing_cache[i].brim_point;
+ const bool &point_selected = editing_cache[i].selected;
+ const bool &hover = editing_cache[i].is_hover;
+ const bool &error = editing_cache[i].is_error;
+ // keep show brim ear
+ // if (is_mesh_point_clipped(brim_point.pos.cast()))
+ // continue;
+
+ // First decide about the color of the point.
+ if (hover) {
+ render_color = HOVER_COLOR;
+ } else {
+ if (size_t(m_hover_id) == i) // ignore hover state unless editing mode is active
+ render_color = {0.f, 1.f, 1.f, 1.f};
+ else { // neigher hover nor picking
+ if (point_selected)
+ render_color = SELECTED_COLOR;
+ else {
+ if (error)
+ render_color = ERR_COLOR;
+ else
+ render_color = DEF_COLOR;
+ }
+ }
+ }
+
+ m_cylinder.model.set_color(render_color);
+ if (shader) shader->set_uniform("emission_factor", 0.5f);
+
+ if (vol->is_left_handed()) glFrontFace(GL_CW);
+
+ // Matrices set, we can render the point mark now.
+ // If in editing mode, we'll also render a cone pointing to the sphere.
+ if (editing_cache[i].normal == Vec3f::Zero()) m_c->raycaster()->raycaster()->get_closest_point(editing_cache[i].brim_point.pos, &editing_cache[i].normal);
+
+ Eigen::Quaterniond q;
+ q.setFromTwoVectors(Vec3d{0., 0., 1.}, instance_scaling_matrix_inverse * editing_cache[i].normal.cast());
+
+ double radius = (double) brim_point.head_front_radius * RenderPointScale;
+ const Transform3d center_matrix =
+ instance_matrix
+ * Geometry::translation_transform(brim_point.pos.cast())
+ // Inverse matrix of the instance scaling is applied so that the mark does not scale with the object.
+ * instance_scaling_matrix_inverse
+ * q
+ * Geometry::scale_transform(Vec3d{radius, radius, .2});
+ if (i < m_grabbers.size()) {
+ m_grabbers[i].raycasters[0]->set_transform(center_matrix);
+ }
+ shader->set_uniform("view_model_matrix", view_matrix * center_matrix);
+ m_cylinder.model.render();
+
+ if (vol->is_left_handed()) glFrontFace(GL_CCW);
+ }
+}
+
+bool GLGizmoBrimEars::is_mesh_point_clipped(const Vec3d &point) const
+{
+ if (m_c->object_clipper()->get_position() == 0.) return false;
+
+ auto sel_info = m_c->selection_info();
+ int active_inst = m_c->selection_info()->get_active_instance();
+ const ModelInstance *mi = sel_info->model_object()->instances[active_inst];
+ const Transform3d &trafo = mi->get_transformation().get_matrix();
+
+ Vec3d transformed_point = trafo * point;
+ transformed_point(2) += sel_info->get_sla_shift();
+ return m_c->object_clipper()->get_clipping_plane()->is_point_clipped(transformed_point);
+}
+
+bool GLGizmoBrimEars::unproject_on_mesh2(const Vec2d &mouse_pos, std::pair &pos_and_normal)
+{
+ const Camera &camera = wxGetApp().plater()->get_camera();
+ double clp_dist = m_c->object_clipper()->get_position();
+ const ClippingPlane *clp = m_c->object_clipper()->get_clipping_plane();
+ bool mouse_on_object = false;
+ Vec3f position_on_model;
+ Vec3f normal_on_model;
+ double closest_hit_distance = std::numeric_limits::max();
+
+ for (auto item : m_mesh_raycaster_map) {
+ auto raycaster = item.second->get_raycaster();
+ auto& world_tran = item.second->get_transform();
+ Vec3f normal = Vec3f::Zero();
+ Vec3f hit = Vec3f::Zero();
+ if (raycaster->unproject_on_mesh(mouse_pos, world_tran, camera, hit, normal, clp_dist != 0. ? clp : nullptr)) {
+ double hit_squared_distance = (camera.get_position() - world_tran * hit.cast()).norm();
+ if (hit_squared_distance < closest_hit_distance) {
+ closest_hit_distance = hit_squared_distance;
+ mouse_on_object = true;
+ m_last_hit_volume = item.first;
+ auto volum_trsf = m_last_hit_volume->get_volume_transformation().get_matrix();
+ position_on_model = (m_last_hit_volume->get_volume_transformation().get_matrix() * hit.cast()).cast();
+ normal_on_model = normal;
+ }
+ }
+ }
+ pos_and_normal = std::make_pair(position_on_model, normal_on_model);
+ return mouse_on_object;
+}
+// Unprojects the mouse position on the mesh and saves hit point and normal of the facet into pos_and_normal
+// Return false if no intersection was found, true otherwise.
+bool GLGizmoBrimEars::unproject_on_mesh(const Vec2d &mouse_pos, std::pair &pos_and_normal)
+{
+ if (m_c->raycaster()->raycasters().size() != 1) return false;
+ if (!m_c->raycaster()->raycaster()) return false;
+
+ const Camera &camera = wxGetApp().plater()->get_camera();
+ const Selection &selection = m_parent.get_selection();
+ const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+ Geometry::Transformation trafo = volume->get_instance_transformation();
+ // trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_c->selection_info()->get_sla_shift()));//sla shift看起来可以删掉
+
+ double clp_dist = m_c->object_clipper()->get_position();
+ const ClippingPlane *clp = m_c->object_clipper()->get_clipping_plane();
+
+ // The raycaster query
+ Vec3f hit;
+ Vec3f normal;
+ if (m_c->raycaster()->raycaster()->unproject_on_mesh(mouse_pos, trafo.get_matrix(), camera, hit, normal, clp_dist != 0. ? clp : nullptr)) {
+ pos_and_normal = std::make_pair(hit, normal);
+ return true;
+ }
+
+ return false;
+}
+
+void GLGizmoBrimEars::data_changed(bool is_serializing)
+{
+ if (!m_c->selection_info()) return;
+
+ ModelObject *mo = m_c->selection_info()->model_object();
+ if (mo) {
+ reset_all_pick();
+ register_single_mesh_pick();
+ }
+
+ set_brim_data();
+}
+
+
+bool GLGizmoBrimEars::on_mouse(const wxMouseEvent& mouse_event)
+{
+ if (use_grabbers(mouse_event)) {
+ return true;
+ }
+
+ // wxCoord == int --> wx/types.h
+ Vec2i32 mouse_coord(mouse_event.GetX(), mouse_event.GetY());
+ Vec2d mouse_pos = mouse_coord.cast();
+
+ if (mouse_event.Moving()) {
+ return gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false);
+ }
+
+ // when control is down we allow scene pan and rotation even when clicking
+ // over some object
+ bool control_down = mouse_event.CmdDown();
+ bool grabber_contains_mouse = (get_hover_id() != -1);
+
+ const Selection &selection = m_parent.get_selection();
+ int selected_object_idx = selection.get_object_idx();
+ if (mouse_event.LeftDown()) {
+ if ((!control_down || grabber_contains_mouse) &&
+ gizmo_event(SLAGizmoEventType::LeftDown, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false))
+ // the gizmo got the event and took some action, there is no need
+ // to do anything more
+ return true;
+ } else if (mouse_event.RightDown()){
+ if (!control_down && selected_object_idx != -1 &&
+ gizmo_event(SLAGizmoEventType::RightDown, mouse_pos, false, false, false))
+ // event was taken care of
+ return true;
+ } else if (mouse_event.Dragging()) {
+ if (m_parent.get_move_volume_id() != -1)
+ // don't allow dragging objects with the Sla gizmo on
+ return true;
+ if (!control_down && gizmo_event(SLAGizmoEventType::Dragging,
+ mouse_pos, mouse_event.ShiftDown(),
+ mouse_event.AltDown(), false)) {
+ // the gizmo got the event and took some action, no need to do
+ // anything more here
+ m_parent.set_as_dirty();
+ return true;
+ }
+ if(control_down && (mouse_event.LeftIsDown() || mouse_event.RightIsDown()))
+ {
+ // CTRL has been pressed while already dragging -> stop current action
+ if (mouse_event.LeftIsDown())
+ gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), true);
+ else if (mouse_event.RightIsDown())
+ gizmo_event(SLAGizmoEventType::RightUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), true);
+ return false;
+ }
+ } else if (mouse_event.LeftUp()) {
+ if (!m_parent.is_mouse_dragging()) {
+ // in case SLA/FDM gizmo is selected, we just pass the LeftUp
+ // event and stop processing - neither object moving or selecting
+ // is suppressed in that case
+ gizmo_event(SLAGizmoEventType::LeftUp, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), control_down);
+ return true;
+ }
+ }
+ return false;
+}
+
+// Following function is called from GLCanvas3D to inform the gizmo about a mouse/keyboard event.
+// The gizmo has an opportunity to react - if it does, it should return true so that the Canvas3D is
+// aware that the event was reacted to and stops trying to make different sense of it. If the gizmo
+// concludes that the event was not intended for it, it should return false.
+bool GLGizmoBrimEars::gizmo_event(SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
+{
+ ModelObject *mo = m_c->selection_info()->model_object();
+ int active_inst = m_c->selection_info()->get_active_instance();
+
+ if (action == SLAGizmoEventType::Moving) {
+ // First check that the mouse pointer is on an object.
+ const Selection &selection = m_parent.get_selection();
+ const ModelInstance *mi = mo->instances[0];
+ Plater *plater = wxGetApp().plater();
+ if (!plater) return false;
+ const Camera &camera = wxGetApp().plater()->get_camera();
+ const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+ Transform3d inverse_trsf = volume->get_instance_transformation().get_matrix_no_offset().inverse();
+ std::pair pos_and_normal;
+ if (unproject_on_mesh2(mouse_position, pos_and_normal)) {
+ render_hover_point = new CacheEntry(BrimPoint(pos_and_normal.first, m_new_point_head_diameter / 2.f), false, (inverse_trsf * m_world_normal).cast(), true);
+ } else {
+ delete render_hover_point;
+ render_hover_point = nullptr;
+ }
+ } else if (action == SLAGizmoEventType::LeftDown && (shift_down || alt_down || control_down)) {
+ // left down with shift - show the selection rectangle:
+ if (m_hover_id == -1) {
+ if (shift_down || alt_down) { m_selection_rectangle.start_dragging(mouse_position, shift_down ? GLSelectionRectangle::Select : GLSelectionRectangle::Deselect); }
+ } else {
+ if (m_editing_cache[m_hover_id].selected)
+ unselect_point(m_hover_id);
+ else {
+ if (!alt_down) select_point(m_hover_id);
+ }
+ }
+
+ return true;
+ }
+
+ // left down without selection rectangle - place point on the mesh:
+ if (action == SLAGizmoEventType::LeftDown && !m_selection_rectangle.is_dragging() && !shift_down) {
+ // If any point is in hover state, this should initiate its move - return control back to GLCanvas:
+ if (m_hover_id != -1) return false;
+
+ // If there is some selection, don't add new point and deselect everything instead.
+ if (m_selection_empty) {
+ std::pair pos_and_normal;
+ if (unproject_on_mesh2(mouse_position, pos_and_normal)) {
+ // we got an intersection
+ const Selection &selection = m_parent.get_selection();
+ const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+ Transform3d trsf = volume->get_instance_transformation().get_matrix();
+ Transform3d inverse_trsf = volume->get_instance_transformation().get_matrix_no_offset().inverse();
+ // BBS brim ear postion is placed on the bottom side
+ Vec3d world_pos = trsf * pos_and_normal.first.cast();
+ world_pos[2] = -0.0001;
+ Vec3d object_pos = trsf.inverse() * world_pos;
+ // brim ear always face up
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Add brim ear");
+ add_point_to_cache(object_pos.cast(), m_new_point_head_diameter / 2.f, false, (inverse_trsf * m_world_normal).cast());
+ m_parent.set_as_dirty();
+ m_wait_for_up_event = true;
+ find_single();
+ } else
+ return false;
+ } else
+ select_point(NoPoints);
+
+ return true;
+ }
+
+ // left up with selection rectangle - select points inside the rectangle:
+ if ((action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::ShiftUp || action == SLAGizmoEventType::AltUp) && m_selection_rectangle.is_dragging()) {
+ // Is this a selection or deselection rectangle?
+ GLSelectionRectangle::EState rectangle_status = m_selection_rectangle.get_state();
+
+ // First collect positions of all the points in world coordinates.
+ Geometry::Transformation trafo = mo->instances[active_inst]->get_transformation();
+ // trafo.set_offset(trafo.get_offset() + Vec3d(0., 0., m_c->selection_info()->get_sla_shift()));
+ std::vector points;
+ for (unsigned int i = 0; i < m_editing_cache.size(); ++i) points.push_back(trafo.get_matrix() * m_editing_cache[i].brim_point.pos.cast());
+
+ // Now ask the rectangle which of the points are inside.
+ std::vector points_inside;
+ std::vector points_idxs = m_selection_rectangle.contains(points);
+ m_selection_rectangle.stop_dragging();
+ for (size_t idx : points_idxs) points_inside.push_back(points[idx].cast());
+
+ // Only select/deselect points that are actually visible. We want to check not only
+ // the point itself, but also the center of base of its cone, so the points don't hide
+ // under every miniature irregularity on the model. Remember the actual number and
+ // append the cone bases.
+ size_t orig_pts_num = points_inside.size();
+ for (size_t idx : points_idxs)
+ points_inside.emplace_back((trafo.get_matrix().cast() * (m_editing_cache[idx].brim_point.pos + m_editing_cache[idx].normal)).cast());
+
+ for (size_t idx :
+ m_c->raycaster()->raycaster()->get_unobscured_idxs(trafo, wxGetApp().plater()->get_camera(), points_inside, m_c->object_clipper()->get_clipping_plane())) {
+ if (idx >= orig_pts_num) // this is a cone-base, get index of point it belongs to
+ idx -= orig_pts_num;
+ if (rectangle_status == GLSelectionRectangle::Deselect)
+ unselect_point(points_idxs[idx]);
+ else
+ select_point(points_idxs[idx]);
+ }
+ return true;
+ }
+
+ // left up with no selection rectangle
+ if (action == SLAGizmoEventType::LeftUp) {
+ if (m_wait_for_up_event) { m_wait_for_up_event = false; }
+ return true;
+ }
+
+ // dragging the selection rectangle:
+ if (action == SLAGizmoEventType::Dragging) {
+ if (m_wait_for_up_event)
+ return true; // point has been placed and the button not released yet
+ // this prevents GLCanvas from starting scene rotation
+
+ if (m_selection_rectangle.is_dragging()) {
+ m_selection_rectangle.dragging(mouse_position);
+ return true;
+ }
+
+ return false;
+ }
+
+ if (action == SLAGizmoEventType::Delete) {
+ // delete key pressed
+ delete_selected_points();
+ return true;
+ }
+
+ if (action == SLAGizmoEventType::RightDown) {
+ if (m_hover_id != -1) {
+ select_point(NoPoints);
+ select_point(m_hover_id);
+ delete_selected_points();
+ return true;
+ }
+ return false;
+ }
+
+ if (action == SLAGizmoEventType::SelectAll) {
+ select_point(AllPoints);
+ return true;
+ }
+
+ // mouse wheel up
+ if (action == SLAGizmoEventType::MouseWheelUp && control_down) {
+ double pos = m_c->object_clipper()->get_position();
+ pos = std::min(1., pos + 0.01);
+ m_c->object_clipper()->set_position_by_ratio(pos, false, true);
+ return true;
+ }
+
+ if (action == SLAGizmoEventType::MouseWheelDown && control_down) {
+ double pos = m_c->object_clipper()->get_position();
+ pos = std::max(0., pos - 0.01);
+ m_c->object_clipper()->set_position_by_ratio(pos, false, true);
+ return true;
+ }
+
+ // reset clipper position
+ if (action == SLAGizmoEventType::ResetClippingPlane) {
+ m_c->object_clipper()->set_position_by_ratio(-1., false);
+ return true;
+ }
+
+ return false;
+}
+
+void GLGizmoBrimEars::delete_selected_points()
+{
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Delete brim ear");
+
+ for (unsigned int idx = 0; idx < m_editing_cache.size(); ++idx) {
+ if (m_editing_cache[idx].selected) { m_editing_cache.erase(m_editing_cache.begin() + (idx--)); }
+ }
+
+ select_point(NoPoints);
+ find_single();
+}
+
+void GLGizmoBrimEars::on_dragging(const UpdateData& data)
+{
+ if (m_hover_id != -1) {
+ std::pair pos_and_normal;
+ if (!unproject_on_mesh2(data.mouse_pos.cast(), pos_and_normal)) return;
+ m_editing_cache[m_hover_id].brim_point.pos[0] = pos_and_normal.first.x();
+ m_editing_cache[m_hover_id].brim_point.pos[1] = pos_and_normal.first.y();
+ //m_editing_cache[m_hover_id].normal = pos_and_normal.second;
+ m_editing_cache[m_hover_id].normal = Vec3f(0, 0, 1);
+ find_single();
+ }
+}
+
+std::vector GLGizmoBrimEars::get_config_options(const std::vector &keys) const
+{
+ std::vector out;
+ const ModelObject *mo = m_c->selection_info()->model_object();
+
+ if (!mo) return out;
+
+ const DynamicPrintConfig &object_cfg = mo->config.get();
+ const DynamicPrintConfig &print_cfg = wxGetApp().preset_bundle->sla_prints.get_edited_preset().config;
+ std::unique_ptr default_cfg = nullptr;
+
+ for (const std::string &key : keys) {
+ if (object_cfg.has(key))
+ out.push_back(object_cfg.option(key));
+ else if (print_cfg.has(key))
+ out.push_back(print_cfg.option(key));
+ else { // we must get it from defaults
+ if (default_cfg == nullptr) default_cfg.reset(DynamicPrintConfig::new_from_defaults_keys(keys));
+ out.push_back(default_cfg->option(key));
+ }
+ }
+
+ return out;
+}
+
+void GLGizmoBrimEars::on_render_input_window(float x, float y, float bottom_limit)
+{
+ static float last_y = 0.0f;
+ static float last_h = 0.0f;
+
+ ModelObject *mo = m_c->selection_info()->model_object();
+
+ if (!mo) return;
+
+ const DynamicPrintConfig& obj_cfg = mo->config.get();
+ const DynamicPrintConfig& glb_cfg = wxGetApp().preset_bundle->prints.get_edited_preset().config;
+ const float win_h = ImGui::GetWindowHeight();
+ y = std::min(y, bottom_limit - win_h);
+ GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
+
+ const float currt_scale = m_parent.get_scale();
+ ImGuiWrapper::push_toolbar_style(currt_scale);
+ ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.0 * currt_scale, 5.0 * currt_scale));
+ ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 4.0f * currt_scale);
+ GizmoImguiBegin(get_name(),
+ ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
+
+ float space_size = m_imgui->get_style_scaling() * 8;
+ std::vector text_list = {m_desc["head_diameter"], m_desc["max_angle"], m_desc["detection_radius"], m_desc["clipping_of_view"]};
+ float widest_text = m_imgui->find_widest_text(text_list);
+ float caption_size = widest_text + space_size + ImGui::GetStyle().WindowPadding.x;
+ float input_text_size = m_imgui->scaled(10.0f);
+ float button_size = ImGui::GetFrameHeight();
+
+ float list_width = input_text_size + ImGui::GetStyle().ScrollbarSize + 2 * currt_scale;
+
+ const float slider_icon_width = m_imgui->get_slider_icon_size().x;
+ const float slider_width = list_width - space_size;
+ const float drag_left_width = caption_size + slider_width + space_size;
+
+ // adjust window position to avoid overlap the view toolbar
+ if (last_h != win_h || last_y != y) {
+ // ask canvas for another frame to render the window in the correct position
+ m_imgui->set_requires_extra_frame();
+ if (last_h != win_h) last_h = win_h;
+ if (last_y != y) last_y = y;
+ }
+
+ ImGui::AlignTextToFramePadding();
+
+ // Following is a nasty way to:
+ // - save the initial value of the slider before one starts messing with it
+ // - keep updating the head radius during sliding so it is continuosly refreshed in 3D scene
+ // - take correct undo/redo snapshot after the user is done with moving the slider
+ float initial_value = m_new_point_head_diameter;
+ m_imgui->text(m_desc["head_diameter"]);
+ ImGui::SameLine(caption_size);
+ ImGui::PushItemWidth(slider_width);
+ auto update_cache_radius = [this]() {
+ for (auto &cache_entry : m_editing_cache)
+ if (cache_entry.selected) {
+ cache_entry.brim_point.head_front_radius = m_new_point_head_diameter / 2.f;
+ find_single();
+ }
+ };
+ m_imgui->bbl_slider_float_style("##head_diameter", &m_new_point_head_diameter, 5, 20, "%.1f", 1.0f, true);
+ if (m_imgui->get_last_slider_status().clicked) {
+ if (m_old_point_head_diameter == 0.f) m_old_point_head_diameter = initial_value;
+ }
+ if (m_imgui->get_last_slider_status().edited)
+ update_cache_radius();
+ if (m_imgui->get_last_slider_status().deactivated_after_edit) {
+ // momentarily restore the old value to take snapshot
+ for (auto &cache_entry : m_editing_cache)
+ if (cache_entry.selected) cache_entry.brim_point.head_front_radius = m_old_point_head_diameter / 2.f;
+ float backup = m_new_point_head_diameter;
+ m_new_point_head_diameter = m_old_point_head_diameter;
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Change point head diameter");
+ m_new_point_head_diameter = backup;
+ update_cache_radius();
+ m_old_point_head_diameter = 0.f;
+ }
+ ImGui::SameLine(drag_left_width);
+ ImGui::PushItemWidth(1.5 * slider_icon_width);
+ ImGui::BBLDragFloat("##head_diameter_input", &m_new_point_head_diameter, 0.05f, 0.0f, 0.0f, "%.1f");
+ ImGui::AlignTextToFramePadding();
+
+ m_imgui->text(m_desc["max_angle"]);
+ ImGui::SameLine(caption_size);
+ ImGui::PushItemWidth(slider_width);
+ m_imgui->bbl_slider_float_style("##max_angle", &m_max_angle, 0, 180, "%.1f", 1.0f, true);
+ ImGui::SameLine(drag_left_width);
+ ImGui::PushItemWidth(1.5 * slider_icon_width);
+ ImGui::BBLDragFloat("##max_angle_input", &m_max_angle, 0.05f, 0.0f, 180.0f, "%.1f");
+ ImGui::AlignTextToFramePadding();
+
+ m_imgui->text(m_desc["detection_radius"]);
+ ImGui::SameLine(caption_size);
+ ImGui::PushItemWidth(slider_width);
+ m_imgui->bbl_slider_float_style("##detection_radius", &m_detection_radius, 0, static_cast(m_detection_radius_max), "%.1f", 1.0f, true);
+ ImGui::SameLine(drag_left_width);
+ ImGui::PushItemWidth(1.5 * slider_icon_width);
+ ImGui::BBLDragFloat("##detection_radius_input", &m_detection_radius, 0.05f, 0.0f, static_cast(m_detection_radius_max), "%.1f");
+ ImGui::Separator();
+
+ float clp_dist = float(m_c->object_clipper()->get_position());
+ m_imgui->text(m_desc["section_view"]);
+ ImGui::SameLine(caption_size);
+ ImGui::PushItemWidth(slider_width);
+ bool slider_clp_dist = m_imgui->bbl_slider_float_style("##section_view", &clp_dist, 0.f, 1.f, "%.2f", 1.0f, true);
+ ImGui::SameLine(drag_left_width);
+ ImGui::PushItemWidth(1.5 * slider_icon_width);
+ bool b_clp_dist_input = ImGui::BBLDragFloat("##section_view_input", &clp_dist, 0.05f, 0.0f, 0.0f, "%.2f");
+ if (slider_clp_dist || b_clp_dist_input) { m_c->object_clipper()->set_position_by_ratio(clp_dist, false, true); }
+ ImGui::Separator();
+
+ // ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6.0f, 10.0f));
+
+ float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
+ ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
+ if (m_imgui->button(m_desc["auto_generate"])) { auto_generate(); }
+
+ if (m_imgui->button(m_desc["remove_selected"])) { delete_selected_points(); }
+ float font_size = ImGui::GetFontSize();
+ //ImGui::Dummy(ImVec2(font_size * 1, font_size * 1.3));
+ ImGui::SameLine();
+ if (m_imgui->button(m_desc["remove_all"])) {
+ if (m_editing_cache.size() > 0) {
+ select_point(AllPoints);
+ delete_selected_points();
+ }
+ }
+ ImGui::PopStyleVar(1);
+
+ float get_cur_y = ImGui::GetContentRegionMax().y + ImGui::GetFrameHeight() + y;
+ show_tooltip_information(x, get_cur_y);
+
+ if (glb_cfg.opt_enum("brim_type") != btPainted) {
+ ImGui::SameLine();
+ auto link_text = [&]() {
+ ImColor HyperColor = ImGuiWrapper::COL_ORCA;
+ ImGui::PushStyleColor(ImGuiCol_Text, ImGuiWrapper::to_ImVec4(ColorRGB::WARNING()));
+ float parent_width = ImGui::GetContentRegionAvail().x;
+ m_imgui->text_wrapped(_L("Warning: The brim type is not set to \"painted\",the brim ears will not take effect !"), parent_width);
+ ImGui::PopStyleColor();
+ ImGui::PushStyleColor(ImGuiCol_Text, HyperColor.Value);
+ ImGui::Dummy(ImVec2(font_size * 1.8, font_size * 1.3));
+ ImGui::SameLine();
+ m_imgui->bold_text(_u8L("Set the brim type to \"painted\""));
+ ImGui::PopStyleColor();
+ // underline
+ ImVec2 lineEnd = ImGui::GetItemRectMax();
+ lineEnd.y -= 2.0f;
+ ImVec2 lineStart = lineEnd;
+ lineStart.x = ImGui::GetItemRectMin().x;
+ ImGui::GetWindowDrawList()->AddLine(lineStart, lineEnd, HyperColor);
+ if (ImGui::IsMouseHoveringRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax(), true)) {
+ m_link_text_hover = true;
+ if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
+ DynamicPrintConfig new_conf = obj_cfg;
+ new_conf.set_key_value("brim_type", new ConfigOptionEnum(btPainted));
+ mo->config.assign_config(new_conf);
+ }
+ }else {
+ m_link_text_hover = false;
+ }
+ };
+
+ if (obj_cfg.option("brim_type")) {
+ if (obj_cfg.opt_enum("brim_type") != btPainted) {
+ link_text();
+ }
+ }else {
+ link_text();
+ }
+
+ }
+
+ if (!m_single_brim.empty()) {
+ wxString out = _L("Warning") + ": " + std::to_string(m_single_brim.size()) + _L(" invalid brim ears");
+ m_imgui->warning_text(out);
+ }
+
+ GizmoImguiEnd();
+ ImGui::PopStyleVar(2);
+ ImGuiWrapper::pop_toolbar_style();
+}
+
+void GLGizmoBrimEars::show_tooltip_information(float x, float y)
+{
+ std::array info_array = std::array{"left_click", "right_click", "ctrl_mouse_wheel"};
+ float caption_max = 0.f;
+ for (const auto &t : info_array) { caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc[t + "_caption"]).x); }
+
+ ImTextureID normal_id = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_TOOLTIP);
+ ImTextureID hover_id = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_TOOLTIP_HOVER);
+
+ caption_max += m_imgui->calc_text_size(": "sv).x + 35.f;
+
+ float scale = m_parent.get_scale();
+ ImVec2 button_size = ImVec2(25 * scale, 25 * scale); // ORCA: Use exact resolution will prevent blur on icon
+ ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
+ ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {0, 0}); // ORCA: Dont add padding
+ ImGui::ImageButton3(normal_id, hover_id, button_size);
+
+ if (ImGui::IsItemHovered()) {
+ ImGui::BeginTooltip2(ImVec2(x, y));
+ auto draw_text_with_caption = [this, &caption_max](const wxString &caption, const wxString &text) {
+ m_imgui->text_colored(ImGuiWrapper::COL_ACTIVE, caption);
+ ImGui::SameLine(caption_max);
+ m_imgui->text_colored(ImGuiWrapper::COL_WINDOW_BG, text);
+ };
+
+ for (const auto &t : info_array) draw_text_with_caption(m_desc.at(t + "_caption") + ": ", m_desc.at(t));
+ ImGui::EndTooltip();
+ }
+ ImGui::PopStyleVar(2);
+}
+
+bool GLGizmoBrimEars::on_is_activable() const
+{
+ const Selection &selection = m_parent.get_selection();
+
+ if (!selection.is_single_full_instance()) return false;
+
+ // Check that none of the selected volumes is outside. Only SLA auxiliaries (supports) are allowed outside.
+ // const Selection::IndicesList &list = selection.get_volume_idxs();
+ // for (const auto &idx : list)
+ // if (selection.get_volume(idx)->is_outside && selection.get_volume(idx)->composite_id.volume_id >= 0) return false;
+
+ return true;
+}
+
+std::string GLGizmoBrimEars::on_get_name() const
+{
+ if (!on_is_activable() && m_state == EState::Off) {
+ return _u8L("Brim Ears") + ":\n" + _u8L("Please select single object.");
+ } else {
+ return _u8L("Brim Ears");
+ }
+}
+
+CommonGizmosDataID GLGizmoBrimEars::on_get_requirements() const
+{
+ return CommonGizmosDataID(int(CommonGizmosDataID::SelectionInfo) | int(CommonGizmosDataID::InstancesHider) | int(CommonGizmosDataID::Raycaster) |
+ int(CommonGizmosDataID::ObjectClipper));
+}
+
+void GLGizmoBrimEars::save_model()
+{
+ ModelObject* mo = m_c->selection_info()->model_object();
+ if (mo) {
+ mo->brim_points.clear();
+ for (const CacheEntry& ce : m_editing_cache) mo->brim_points.emplace_back(ce.brim_point);
+ wxGetApp().plater()->set_plater_dirty(true);
+ }
+}
+
+// switch gizmos
+void GLGizmoBrimEars::on_set_state()
+{
+ if (m_state == m_old_state) return;
+
+ if (m_state == On && m_old_state != On) {
+ // the gizmo was just turned on
+ wxGetApp().plater()->enter_gizmos_stack();
+ first_layer_slicer();
+ }
+ if (m_state == Off && m_old_state != Off) {
+ // the gizmo was just turned Off
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Brim ears edit");
+ save_model();
+ m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
+ wxGetApp().plater()->leave_gizmos_stack();
+ // wxGetApp().mainframe->update_slice_print_status(MainFrame::SlicePrintEventType::eEventSliceUpdate, true, true);
+ }
+ m_old_state = m_state;
+}
+
+void GLGizmoBrimEars::on_start_dragging()
+{
+ if (m_hover_id != -1) {
+ select_point(NoPoints);
+ select_point(m_hover_id);
+ m_point_before_drag = m_editing_cache[m_hover_id];
+ } else
+ m_point_before_drag = CacheEntry();
+}
+
+void GLGizmoBrimEars::on_stop_dragging()
+{
+ if (m_hover_id != -1) {
+ CacheEntry backup = m_editing_cache[m_hover_id];
+
+ if (m_point_before_drag.brim_point.pos != Vec3f::Zero() // some point was touched
+ && backup.brim_point.pos != m_point_before_drag.brim_point.pos) // and it was moved, not just selected
+ {
+ m_editing_cache[m_hover_id] = m_point_before_drag;
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Move support point");
+ m_editing_cache[m_hover_id] = backup;
+ }
+ }
+ m_point_before_drag = CacheEntry();
+}
+
+void GLGizmoBrimEars::on_load(cereal::BinaryInputArchive &ar) { ar(m_new_point_head_diameter, m_editing_cache, m_selection_empty); }
+
+void GLGizmoBrimEars::on_save(cereal::BinaryOutputArchive &ar) const { ar(m_new_point_head_diameter, m_editing_cache, m_selection_empty); }
+
+void GLGizmoBrimEars::select_point(int i)
+{
+ if (i == AllPoints || i == NoPoints) {
+ for (auto &point_and_selection : m_editing_cache) point_and_selection.selected = (i == AllPoints);
+ m_selection_empty = (i == NoPoints);
+
+ if (i == AllPoints) m_new_point_head_diameter = m_editing_cache[0].brim_point.head_front_radius * 2.f;
+ } else {
+ m_editing_cache[i].selected = true;
+ m_selection_empty = false;
+ m_new_point_head_diameter = m_editing_cache[i].brim_point.head_front_radius * 2.f;
+ }
+}
+
+void GLGizmoBrimEars::unselect_point(int i)
+{
+ m_editing_cache[i].selected = false;
+ m_selection_empty = true;
+ for (const CacheEntry &ce : m_editing_cache) {
+ if (ce.selected) {
+ m_selection_empty = false;
+ break;
+ }
+ }
+}
+
+void GLGizmoBrimEars::reload_cache()
+{
+ const ModelObject *mo = m_c->selection_info()->model_object();
+ m_editing_cache.clear();
+ for (const BrimPoint &point : mo->brim_points) m_editing_cache.emplace_back(point);
+ find_single();
+}
+
+Points GLGizmoBrimEars::generate_points(Polygon &obj_polygon, float ear_detection_length, float brim_ears_max_angle, bool is_outer)
+{
+ const coordf_t angle_threshold = (180 - brim_ears_max_angle) * PI / 180.0;
+ Points pt_ears;
+ if (ear_detection_length > 0) {
+ double detect_length = ear_detection_length / SCALING_FACTOR;
+ Points points = obj_polygon.points;
+ points.push_back(points.front());
+ points = MultiPoint::_douglas_peucker(points, detect_length);
+ if (points.size() > 4) {
+ points.erase(points.end() - 1);
+ }
+ obj_polygon.points = points;
+ }
+ append(pt_ears, is_outer ? obj_polygon.convex_points(angle_threshold) : obj_polygon.concave_points(angle_threshold));
+ return pt_ears;
+}
+
+void GLGizmoBrimEars::first_layer_slicer()
+{
+ const Selection &selection = m_parent.get_selection();
+ const Selection::IndicesList &idxs = selection.get_volume_idxs();
+ if (idxs.size() <= 0) return;
+ std::vector slice_height(1, 0.1);
+ MeshSlicingParamsEx params;
+ params.mode = MeshSlicingParams::SlicingMode::Regular;
+ params.closing_radius = 0.1f;
+ params.extra_offset = 0.05f;
+ params.resolution = 0.01;
+ ExPolygons part_ex;
+ ExPolygons negative_ex;
+ for (auto idx : idxs) {
+ const GLVolume *volume = selection.get_volume(idx);
+ const ModelVolume *model_volume = get_model_volume(*volume, wxGetApp().model());
+ if (model_volume == nullptr) continue;
+ if (model_volume->type() == ModelVolumeType::MODEL_PART || model_volume->type() == ModelVolumeType::NEGATIVE_VOLUME) {
+ indexed_triangle_set volume_its = model_volume->mesh().its;
+ if (volume_its.indices.size() <= 0) continue;
+ Transform3d trsf = volume->get_instance_transformation().get_matrix() * volume->get_volume_transformation().get_matrix();
+ MeshSlicingParamsEx params_ex(params);
+ params_ex.trafo = params_ex.trafo * trsf;
+ if (params_ex.trafo.rotation().determinant() < 0.) its_flip_triangles(volume_its);
+ ExPolygons sliced_layer = slice_mesh_ex(volume_its, slice_height, params_ex).front();
+ if (model_volume->type() == ModelVolumeType::MODEL_PART) {
+ part_ex = union_ex(part_ex, sliced_layer);
+ } else {
+ negative_ex = union_ex(negative_ex, sliced_layer);
+ }
+ }
+ }
+ m_first_layer = diff_ex(part_ex, negative_ex);
+ get_detection_radius_max();
+}
+
+void GLGizmoBrimEars::auto_generate()
+{
+ const Selection &selection = m_parent.get_selection();
+ const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+ Transform3d trsf = volume->get_instance_transformation().get_matrix();
+ Vec3f normal = (volume->get_instance_transformation().get_matrix_no_offset().inverse() * m_world_normal).cast();
+ auto add_point = [this, &trsf, &normal](const Point &p) {
+ Vec3d world_pos = {float(p.x() * SCALING_FACTOR), float(p.y() * SCALING_FACTOR), -0.0001};
+ Vec3d object_pos = trsf.inverse() * world_pos;
+ // m_editing_cache.emplace_back(BrimPoint(object_pos.cast(), m_new_point_head_diameter / 2), false, normal);
+ add_point_to_cache(object_pos.cast(), m_new_point_head_diameter / 2, false, normal);
+ };
+ for (const ExPolygon &ex_poly : m_first_layer) {
+ Polygon out_poly = ex_poly.contour;
+ Polygons inner_poly = ex_poly.holes;
+ polygons_reverse(inner_poly);
+ Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Auto generate brim ear");
+ Points out_points = generate_points(out_poly, m_detection_radius, m_max_angle, true);
+ for (Point &p : out_points) { add_point(p); }
+ for (Polygon &pl : inner_poly) {
+ Points inner_points = generate_points(pl, m_detection_radius, m_max_angle, false);
+ for (Point &p : inner_points) { add_point(p); }
+ }
+ }
+ find_single();
+}
+
+void GLGizmoBrimEars::get_detection_radius_max()
+{
+ double max_dist = 0.0;
+ int min_points_num = 0;
+ for (const ExPolygon &ex_poly : m_first_layer) {
+ Polygon out_poly = ex_poly.contour;
+ Polygons inner_poly = ex_poly.holes;
+ polygons_reverse(inner_poly);
+
+ Points out_points = out_poly.points;
+ out_points.push_back(out_points.front());
+ double tolerance = 0.0;
+ min_points_num = MultiPoint::_douglas_peucker(out_points, 0).size();
+ int repeat = 0;
+ int loop_protect = 0;
+ for (;;) {
+ loop_protect++;
+ tolerance += 10;
+ int num = MultiPoint::_douglas_peucker(out_points, tolerance / SCALING_FACTOR).size();
+ if (num == min_points_num) {
+ repeat++;
+ if (repeat > 1)
+ break;
+ }
+ min_points_num = num;
+ if (loop_protect > 100) break;
+ }
+ loop_protect = 0;
+ for (;;) {
+ loop_protect++;
+ tolerance -= 1;
+ int num = MultiPoint::_douglas_peucker(out_points, tolerance / SCALING_FACTOR).size();
+ if (num <= min_points_num) {
+ min_points_num = num;
+ }else{
+ break;
+ }
+ if (loop_protect > 100) break;
+ }
+ tolerance += 1;
+ if (tolerance > max_dist)
+ max_dist = tolerance;
+ }
+ if (max_dist > 100 || max_dist <= 0) {
+ m_detection_radius_max = 100;
+ } else {
+ m_detection_radius_max = max_dist;
+ }
+}
+
+bool GLGizmoBrimEars::add_point_to_cache(Vec3f pos, float head_radius, bool selected, Vec3f normal)
+{
+ BrimPoint point(pos, head_radius);
+ for (int i = 0; i < m_editing_cache.size(); i++) {
+ if (m_editing_cache[i].brim_point == point) { return false; }
+ }
+ m_editing_cache.emplace_back(point, selected, normal);
+ return true;
+}
+
+
+void GLGizmoBrimEars::on_register_raycasters_for_picking() {
+ update_raycasters();
+}
+
+void GLGizmoBrimEars::on_unregister_raycasters_for_picking()
+{
+ m_parent.remove_raycasters_for_picking(SceneRaycaster::EType::Gizmo);
+ m_grabbers.clear();
+}
+
+void GLGizmoBrimEars::update_raycasters()
+{
+ // Remove extra raycasters
+ if (m_editing_cache.size() < m_grabbers.size()) {
+ for (auto it = m_grabbers.begin() + m_editing_cache.size(); it != m_grabbers.end(); ++it) {
+ if (it->picking_id >= 0) {
+ it->unregister_raycasters_for_picking();
+ }
+ }
+ m_grabbers.erase(m_grabbers.begin() + m_editing_cache.size(), m_grabbers.end());
+ } else if (m_editing_cache.size() > m_grabbers.size()) {
+ auto remaining = m_editing_cache.size() - m_grabbers.size();
+ while (remaining > 0) {
+ const auto id = m_grabbers.size();
+ auto& g = m_grabbers.emplace_back();
+ g.register_raycasters_for_picking(id);
+ g.raycasters[0] = m_parent.add_raycaster_for_picking(SceneRaycaster::EType::Gizmo, id,
+ *m_cylinder.mesh_raycaster, Transform3d::Identity());
+ remaining--;
+ }
+ }
+}
+
+void GLGizmoBrimEars::register_single_mesh_pick()
+{
+ Selection &selection = m_parent.get_selection();
+ const Selection::IndicesList &idxs = selection.get_volume_idxs();
+ if (idxs.size() > 0) {
+ for (unsigned int idx : idxs) {
+ GLVolume *v = const_cast(selection.get_volume(idx));
+ const ModelVolume* mv = get_model_volume(*v, wxGetApp().model());
+ if (!mv->is_model_part()) continue;
+ auto world_tran = v->get_instance_transformation() * v->get_volume_transformation();
+ if (m_mesh_raycaster_map.find(v) != m_mesh_raycaster_map.end()) {
+ m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
+ } else {
+ auto mesh = mv->mesh_ptr();
+ m_mesh_raycaster_map[v] = std::make_shared(-1, *v->mesh_raycaster, world_tran.get_matrix());
+ m_mesh_raycaster_map[v]->set_transform(world_tran.get_matrix());
+ }
+ }
+ }
+}
+
+//void GLGizmoBrimEars::update_single_mesh_pick(GLVolume *v)
+//{
+// if (m_mesh_raycaster_map.find(v) != m_mesh_raycaster_map.end()) {
+// auto world_tran = v->get_instance_transformation() * v->get_volume_transformation();
+// m_mesh_raycaster_map[v]->world_tran.set_from_transform(world_tran.get_matrix());
+// }
+//}
+
+void GLGizmoBrimEars::reset_all_pick() { std::map>().swap(m_mesh_raycaster_map); }
+
+float GLGizmoBrimEars::get_brim_default_radius() const
+{
+ const double nozzle_diameter = wxGetApp().preset_bundle->printers.get_edited_preset().config.option("nozzle_diameter")->get_at(0);
+ const DynamicPrintConfig &pring_cfg = wxGetApp().preset_bundle->prints.get_edited_preset().config;
+ return pring_cfg.get_abs_value("initial_layer_line_width", nozzle_diameter) * 16.0f;
+}
+
+ExPolygon GLGizmoBrimEars::make_polygon(BrimPoint point, const Geometry::Transformation &trsf)
+{
+ ExPolygon point_round;
+ Transform3d model_trsf = trsf.get_matrix();
+ Vec3f world_pos = point.transform(trsf.get_matrix());
+ coord_t size_ear = scale_(point.head_front_radius);
+ for (size_t i = 0; i < POLY_SIDE_COUNT; i++) {
+ double angle = (2.0 * PI * i) / POLY_SIDE_COUNT;
+ point_round.contour.points.emplace_back(size_ear * cos(angle), size_ear * sin(angle));
+ }
+ Vec3f pos = point.transform(model_trsf);
+ int32_t pt_x = scale_(pos.x());
+ int32_t pt_y = scale_(pos.y());
+ point_round.translate(Point(pt_x, pt_y));
+ return point_round;
+}
+
+void GLGizmoBrimEars::find_single()
+{
+ update_raycasters();
+
+ if (m_editing_cache.size() == 0) {
+ m_single_brim.clear();
+ return;
+ }
+ const Selection &selection = m_parent.get_selection();
+ const GLVolume *volume = selection.get_volume(*selection.get_volume_idxs().begin());
+ Geometry::Transformation trsf = volume->get_instance_transformation();
+ ExPolygons model_pl = m_first_layer;
+
+ m_single_brim.clear();
+ for (int i = 0; i < m_editing_cache.size(); i++)
+ m_single_brim[i] = m_editing_cache[i];
+ unsigned int index = 0;
+ bool cyc = true;
+ while (cyc) {
+ index++;
+ if (index > 99999999) break; // cycle protection
+ if (m_single_brim.empty()) {
+ break;
+ }
+ auto end = --m_single_brim.end();
+ for (auto it = m_single_brim.begin(); it != m_single_brim.end(); ++it) {
+ ExPolygon point_pl = make_polygon(it->second.brim_point, trsf);
+ if (overlaps(model_pl, point_pl)) {
+ model_pl.emplace_back(point_pl);
+ model_pl = union_ex(model_pl);
+ it = m_single_brim.erase(it);
+ break;
+ } else {
+ if (it == end) cyc = false;
+ }
+ }
+ }
+ for (auto& it : m_editing_cache) {
+ it.is_error = false;
+ }
+ for (auto &it : m_single_brim) {
+ m_editing_cache[it.first].is_error = true;
+ }
+}
+}} // namespace Slic3r::GUI
diff --git a/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.hpp b/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.hpp
new file mode 100644
index 0000000000..e316861dbd
--- /dev/null
+++ b/src/slic3r/GUI/Gizmos/GLGizmoBrimEars.hpp
@@ -0,0 +1,180 @@
+#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& pos_and_normal);
+ bool unproject_on_mesh2(const Vec2d& mouse_pos, std::pair& 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
+ 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 m_editing_cache; // a support point and whether it is currently selectedchanges or undo/redo
+ std::map m_single_brim;
+ ObjectID m_old_mo_id;
+ const Vec3d m_world_normal = {0, 0, 1};
+ std::map> 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 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 get_config_options(const std::vector& 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();
+ void update_raycasters();
+
+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;
+ virtual void on_register_raycasters_for_picking() override;
+ virtual void on_unregister_raycasters_for_picking() 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_
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp b/src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp
index 56c3d1714b..fdcd417796 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosCommon.cpp
@@ -312,6 +312,11 @@ void ObjectClipper::render_cut(const std::vector* 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 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();
- //if (abs(camera_dir(0)) > EPSILON || abs(camera_dir(1)) > EPSILON)
- // camera_dir(2) = 0;
+ Vec3d normal;
+ if(vertical_normal) {
+ 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) {
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp b/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp
index c14f2feeba..cad77c7e5d 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosCommon.hpp
+++ b/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* 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);
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
index 87ad6be44c..91918fa147 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.cpp
+++ b/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(m_gizmos[Cut].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
else if (m_current == MeshBoolean)
return dynamic_cast(m_gizmos[MeshBoolean].get())->gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
+ else if (m_current == BrimEars)
+ return dynamic_cast(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 (m_current == SlaSupports || m_current == Hollow)
+ if (evt.GetEventType() == wxEVT_KEY_UP)
+ {
+ 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(get_current());
is_editing = gizmo->is_in_editing_mode();
is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
- }
- else {
- GLGizmoHollow* gizmo = dynamic_cast(get_current());
+ } else*/ if (m_current == BrimEars) {
+ GLGizmoBrimEars* gizmo = dynamic_cast(get_current());
is_rectangle_dragging = gizmo->is_selection_rectangle_dragging();
}
+ /*else {
+ GLGizmoHollow* gizmo = dynamic_cast(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(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(get_current())->is_in_editing_mode())
+ /*if (m_current == SlaSupports && dynamic_cast(get_current())->is_in_editing_mode()) {
+ return true;
+ } else*/ if (m_current == BrimEars) {
+ dynamic_cast(get_current())->save_model();
return false;
+ } else {
+ return false;
+ }
- // BBS: remove SLA editing notification
- //return true;
}
diff --git a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
index 305c767f43..06b0f69210 100644
--- a/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
+++ b/src/slic3r/GUI/Gizmos/GLGizmosManager.hpp
@@ -88,6 +88,7 @@ public:
Measure,
Assembly,
Simplify,
+ BrimEars,
//SlaSupports,
// BBS
//FaceRecognition,
diff --git a/src/slic3r/GUI/ImGuiWrapper.cpp b/src/slic3r/GUI/ImGuiWrapper.cpp
index 39f2da71da..d70700b9cf 100644
--- a/src/slic3r/GUI/ImGuiWrapper.cpp
+++ b/src/slic3r/GUI/ImGuiWrapper.cpp
@@ -416,7 +416,7 @@ void ImGuiWrapper::set_language(const std::string &language)
}
else if (lang == "en") {
ranges = ImGui::GetIO().Fonts->GetGlyphRangesEnglish(); // Basic Latin
- }
+ }
else{
ranges = ImGui::GetIO().Fonts->GetGlyphRangesOthers();
}
@@ -560,6 +560,15 @@ ImVec2 ImGuiWrapper::calc_text_size(const wxString &text,
return size;
}
+float ImGuiWrapper::find_widest_text(std::vector &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);
@@ -1598,9 +1607,9 @@ bool begin_menu(const char *label, bool enabled)
return menu_is_open;
}
-void end_menu()
-{
- ImGui::EndMenu();
+void end_menu()
+{
+ ImGui::EndMenu();
}
bool menu_item_with_icon(const char *label, const char *shortcut, ImVec2 icon_size /* = ImVec2(0, 0)*/, ImU32 icon_color /* = 0*/, bool selected /* = false*/, bool enabled /* = true*/, bool* hovered/* = nullptr*/)
diff --git a/src/slic3r/GUI/ImGuiWrapper.hpp b/src/slic3r/GUI/ImGuiWrapper.hpp
index 7ecf5bbe65..cd1b3d98e4 100644
--- a/src/slic3r/GUI/ImGuiWrapper.hpp
+++ b/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 &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; }
diff --git a/src/slic3r/GUI/PartPlate.cpp b/src/slic3r/GUI/PartPlate.cpp
index ebdcbc4d4c..ffd01e48d9 100644
--- a/src/slic3r/GUI/PartPlate.cpp
+++ b/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 local_lock(m_plates_mutex);
std::vector::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);
}
}
}
diff --git a/src/slic3r/GUI/PartPlate.hpp b/src/slic3r/GUI/PartPlate.hpp
index 675f004c93..6bed8c7f0f 100644
--- a/src/slic3r/GUI/PartPlate.hpp
+++ b/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)
diff --git a/src/slic3r/GUI/Selection.cpp b/src/slic3r/GUI/Selection.cpp
index 79feb0e1fc..68f1387492 100644
--- a/src/slic3r/GUI/Selection.cpp
+++ b/src/slic3r/GUI/Selection.cpp
@@ -2077,6 +2077,7 @@ void Selection::copy_to_clipboard()
dst_object->sla_support_points = src_object->sla_support_points;
dst_object->sla_points_status = src_object->sla_points_status;
dst_object->sla_drain_holes = src_object->sla_drain_holes;
+ dst_object->brim_points = src_object->brim_points;
dst_object->layer_config_ranges = src_object->layer_config_ranges; // #ys_FIXME_experiment
dst_object->layer_height_profile.assign(src_object->layer_height_profile);
dst_object->origin_translation = src_object->origin_translation;