fix: use get_current_printer_agent_id

src/OrcaSlicer.cpp

@@ -7054,7 +7054,7 @@ int CLI::run(int argc, char **argv)
             gcode_viewer.render_calibration_thumbnail(*calibration_data, cali_thumbnail_width, cali_thumbnail_height,
                 calibration_params, partplate_list, opengl_mgr);
             //generate_calibration_thumbnail(*calibration_data, thumbnail_width, thumbnail_height, calibration_params);
-            // *plate_bboxes[index] = p->generate_first_layer_bbox();
+            //*plate_bboxes[index] = p->generate_first_layer_bbox();
             calibration_thumbnails.push_back(calibration_data);*/
 
             PlateBBoxData* plate_bbox = new PlateBBoxData();

src/libslic3r/AABBMesh.cpp

@@ -54,12 +54,12 @@ public:
                             int &                        i,
                             Eigen::Matrix<double, 1, 3> &closest)
     {
-        size_t idx_unsigned { 0 };
-        Vec3d  closest_vec3d { Vec3d::Zero() };
-        const double dist {
+        size_t idx_unsigned = 0;
+        Vec3d  closest_vec3d(closest);
+        double dist =
             AABBTreeIndirect::squared_distance_to_indexed_triangle_set(
                 its.vertices, its.indices, m_tree, point, idx_unsigned,
-                closest_vec3d) };
+                closest_vec3d);
         i       = int(idx_unsigned);
         closest = closest_vec3d;
         return dist;
@@ -311,9 +311,10 @@ AABBMesh::hit_result IndexedMesh::filter_hits(
 
 
 double AABBMesh::squared_distance(const Vec3d &p, int& i, Vec3d& c) const {
-    const Eigen::Matrix<double, 1, 3> pp { p };
-    Eigen::Matrix<double, 1, 3> cc { Vec3d::Zero() };
-    const double sqdst { m_aabb->squared_distance(*m_tm, pp, i, cc) };
+    double sqdst = 0;
+    Eigen::Matrix<double, 1, 3> pp = p;
+    Eigen::Matrix<double, 1, 3> cc;
+    sqdst = m_aabb->squared_distance(*m_tm, pp, i, cc);
     c = cc;
     return sqdst;
 }

src/libslic3r/AppConfig.cpp

@@ -853,6 +853,10 @@ std::string AppConfig::load()
                         local_machine.dev_ip = p["dev_ip"].get<std::string>();
                     if (p.contains("printer_type"))
                         local_machine.printer_type = p["printer_type"].get<std::string>();
+                    if (p.contains("printer_agent_id"))
+                        local_machine.printer_agent_id = p["printer_agent_id"].get<std::string>();
+                    if (p.contains("access_code"))
+                        local_machine.access_code = p["access_code"].get<std::string>();
                     m_local_machines[local_machine.dev_id] = local_machine;
                 }
             } else {
@@ -883,7 +887,7 @@ std::string AppConfig::load()
                 }
             }
         }
-    } catch(const std::exception &err) {
+    } catch(std::exception err) {
         BOOST_LOG_TRIVIAL(info) << format("parse app config \"%1%\", error: %2%", AppConfig::loading_path(), err.what());
 
         return err.what();
@@ -1065,6 +1069,8 @@ void AppConfig::save()
         m_json["dev_name"]         = local_machine.second.dev_name;
         m_json["dev_ip"]           = local_machine.second.dev_ip;
         m_json["printer_type"]     = local_machine.second.printer_type;
+        m_json["printer_agent_id"] = local_machine.second.printer_agent_id;
+        m_json["access_code"]      = local_machine.second.access_code;
 
         j["local_machines"][local_machine.first] = m_json;
     }

src/libslic3r/AppConfig.hpp

@@ -61,10 +61,19 @@ struct BBLocalMachine
     std::string dev_ip;
     std::string dev_id; /* serial number */
     std::string printer_type; /* model_id */
+    std::string printer_agent_id; /* id of the IPrinterAgent that discovered/bound this device, e.g. "bbl"; empty for entries persisted before this field existed */
+    // Access code, scoped to printer_agent_id above - so a code saved while bound under one
+    // printer agent isn't treated as valid for a different, independent agent talking to the
+    // same physical dev_id. Empty for entries persisted before this field existed; those fall
+    // back to the legacy flat "access_code"/"user_access_code" AppConfig sections (BBL-only,
+    // since BBL was the only agent when they were saved) - see
+    // get_access_code_with_legacy_fallback() in DevManager.cpp.
+    std::string access_code;
 
     bool operator==(const BBLocalMachine& other) const
     {
-        return dev_name == other.dev_name && dev_ip == other.dev_ip && dev_id == other.dev_id && printer_type == other.printer_type;
+        return dev_name == other.dev_name && dev_ip == other.dev_ip && dev_id == other.dev_id && printer_type == other.printer_type &&
+               printer_agent_id == other.printer_agent_id && access_code == other.access_code;
     }
     bool operator!=(const BBLocalMachine& other) const { return !operator==(other); }
 };

src/libslic3r/Fill/FillRectilinear.cpp

@@ -3576,7 +3576,7 @@ Polylines FillLateralHoneycomb::fill_surface(const Surface *surface, const FillP
     //     |
     //     |
     // 0 --+--
-    //    ⟋ ⟍
+    //    / \
     // why inverted?
     // it makes determining some of the properties easier
     // and the two angled legs provide additional horizontal stiffness

src/libslic3r/Format/STEP.cpp

@@ -712,7 +712,7 @@ unsigned int Step::get_triangle_num(double linear_deflection, double angle_defle
                 return 0;
             }
         }
-    } catch(const Exception &e) {
+    } catch(Exception e) {
         return 0;
     }
     

src/libslic3r/GCode.cpp

@@ -5511,7 +5511,7 @@ LayerResult GCode::process_layer(
     // add tag for processor
     gcode += ";" + GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Layer_Change) + "\n";
     // export layer z
-    char buf[80];
+    char buf[64];
     sprintf(buf, print.is_BBL_printer() ? "; Z_HEIGHT: %g\n" : ";Z:%g\n", print_z);
     gcode += buf;
     // export layer height

src/libslic3r/Measure.hpp

@@ -94,7 +94,7 @@ public:
 
     void* volume{nullptr};
     std::vector<int>*    plane_indices{nullptr};
-    Transform3d                  world_tran = Transform3d::Identity();
+    Transform3d                  world_tran;
     std::shared_ptr<std::vector<SurfaceFeature>> world_plane_features{nullptr};
     std::shared_ptr<SurfaceFeature> origin_surface_feature{nullptr};
 

src/libslic3r/Orient.hpp

@@ -48,50 +48,100 @@ struct OrientMesh {
 
 };
 
-struct OrientParams {
-    float TAR_A               { 0.01f };     // 0.128f;
-    float TAR_B               { 0.177f };
-    float RELATIVE_F          { 6.610621027964314f };
-    float CONTOUR_F           { 0.23228623269775997f };
-    float BOTTOM_F            { 1.167152017941474f };
-    float BOTTOM_HULL_F       { 0.1f };
-    float TAR_C               { 0.24308070476924726f };
-    float TAR_D               { 0.6284515508160871f };
-    float TAR_E               { 0};         // 0.032157292647062234;
-    float FIRST_LAY_H         { 0.2f};      // 0.029;
-    float VECTOR_TOL          { -0.0011163303070972383f };
-    float NEGL_FACE_SIZE      { 0.1f };
-    float ASCENT              { -0.5f };
-    float PLAFOND_ADV         { 0.04079208948120519f };
-    float CONTOUR_AMOUNT      { 0.0101472219892684f };
-    float OV_H                { 1.0370178217794535f };
-    float height_offset       { 2.7417608343142073f };
-    float height_log          { 0.06442030687034085f };
-    float height_log_k        { 0.3933594673063997f };
-    float LAF_MAX             { 0.999f };    // cos(1.4\degree) for low angle face //0.9997f;
-    float LAF_MIN             { 0.9703f };   // cos(14\degree) 0.9703f;
-    float TAR_LAF             { 0.01f };     // 0.1f
-    float TAR_PROJ_AREA       { 0.1f };
-    float BOTTOM_MIN          { 0.1f };      // min bottom area. If lower than it the objects may be unstable
-    float BOTTOM_MAX          { 2000 };      // 400
-    float height_to_bottom_hull_ratio_MIN { 1 };
-    float BOTTOM_HULL_MAX     { 2000 };      // max bottom hull area to clip //600
-    float APPERANCE_FACE_SUPP { 3 };         // penalty of generating supports on appearance face
+// params for minimizing support area
+struct OrientParamsArea {
+    float TAR_A = 0.015f;
+    float TAR_B = 0.177f;
+    float RELATIVE_F = 20;
+    float CONTOUR_F = 0.5f;
+    float BOTTOM_F = 2.5f;
+    float BOTTOM_HULL_F = 0.1f;
+    float TAR_C = 0.1f;
+    float TAR_D = 1;
+    float TAR_E = 0.0115f;
+    float FIRST_LAY_H = 0.2f;//0.0475;
+    float VECTOR_TOL = -0.00083f;
+    float NEGL_FACE_SIZE = 0.01f;
+    float ASCENT = -0.5f;
+    float PLAFOND_ADV = 0.0599f;
+    float CONTOUR_AMOUNT = 0.0182427f;
+    float OV_H = 2.574f;
+    float height_offset = 2.3728f;
+    float height_log = 0.041375f;
+    float height_log_k = 1.9325457f;
+    float LAF_MAX = 0.999f; // cos(1.4\degree) for low angle face 0.9997f
+    float LAF_MIN = 0.97f;  // cos(14\degree) 0.9703f
+    float TAR_LAF = 0.001f; //0.01f
+    float TAR_PROJ_AREA = 0.1f;
+    float BOTTOM_MIN = 0.1f;  // min bottom area. If lower than it the object may be unstable
+    float BOTTOM_MAX = 2000;  // max bottom area. If get to it the object is stable enough (further increase bottom area won't do more help)
+    float height_to_bottom_hull_ratio_MIN = 1;
+    float BOTTOM_HULL_MAX = 2000;// max bottom hull area
+    float APPERANCE_FACE_SUPP=3; // penalty of generating supports on appearance face
 
-    float overhang_angle     { 60.f };
-    bool  use_low_angle_face { true };
-    bool  min_volume         { false };
-    Eigen::Vector3f fun_dir  {};
+    float overhang_angle = 60.f;
+    bool use_low_angle_face = true;
+    bool min_volume = false;
+    Eigen::Vector3f fun_dir;
 
     /// Allow parallel execution.
-    bool parallel { false };
+    bool parallel = true;
 
     /// Progress indicator callback called when an object gets packed.
     /// The unsigned argument is the number of items remaining to pack.
-    std::function<void(unsigned, std::string)> progressind {};
+    std::function<void(unsigned, std::string)> progressind = {};
 
     /// A predicate returning true if abort is needed.
-    std::function<bool(void)> stopcondition {};
+    std::function<bool(void)>     stopcondition = {};
+
+    OrientParamsArea() = default;
+};
+
+struct OrientParams {
+    float TAR_A = 0.01f;//0.128f;
+    float TAR_B = 0.177f;
+    float RELATIVE_F= 6.610621027964314f;
+    float CONTOUR_F = 0.23228623269775997f;
+    float BOTTOM_F = 1.167152017941474f;
+    float BOTTOM_HULL_F = 0.1f;
+    float TAR_C = 0.24308070476924726f;
+    float TAR_D = 0.6284515508160871f;
+    float TAR_E = 0;//0.032157292647062234;
+    float FIRST_LAY_H = 0.2f;//0.029;
+    float VECTOR_TOL = -0.0011163303070972383f;
+    float NEGL_FACE_SIZE = 0.1f;
+    float ASCENT= -0.5f;
+    float PLAFOND_ADV = 0.04079208948120519f;
+    float CONTOUR_AMOUNT = 0.0101472219892684f;
+    float OV_H = 1.0370178217794535f;
+    float height_offset = 2.7417608343142073f;
+    float height_log = 0.06442030687034085f;
+    float height_log_k = 0.3933594673063997f;
+    float LAF_MAX = 0.999f; // cos(1.4\degree) for low angle face //0.9997f;
+    float LAF_MIN= 0.9703f;  // cos(14\degree) 0.9703f;
+    float TAR_LAF = 0.01f; //0.1f
+    float TAR_PROJ_AREA = 0.1f;
+    float BOTTOM_MIN = 0.1f;  // min bottom area. If lower than it the objects may be unstable
+    float BOTTOM_MAX = 2000; //400
+    float height_to_bottom_hull_ratio_MIN = 1;
+    float BOTTOM_HULL_MAX = 2000;// max bottom hull area to clip //600
+    float APPERANCE_FACE_SUPP=3; // penalty of generating supports on appearance face
+
+    float overhang_angle = 60.f;
+    bool use_low_angle_face = true;
+    bool min_volume = false;
+    Eigen::Vector3f fun_dir;
+
+
+    /// Allow parallel execution.
+    bool parallel = false;
+
+    /// Progress indicator callback called when an object gets packed.
+    /// The unsigned argument is the number of items remaining to pack.
+    std::function<void(unsigned, std::string)> progressind = {};
+
+    /// A predicate returning true if abort is needed.
+    std::function<bool(void)>     stopcondition = {};
 
     OrientParams() = default;
 };

src/libslic3r/SLA/IndexedMesh.cpp

@@ -56,12 +56,12 @@ public:
                             int &                        i,
                             Eigen::Matrix<double, 1, 3> &closest)
     {
-        size_t idx_unsigned { 0 };
-        Vec3d  closest_vec3d { Vec3d::Zero() };
-        const double dist {
+        size_t idx_unsigned = 0;
+        Vec3d  closest_vec3d(closest);
+        double dist =
             AABBTreeIndirect::squared_distance_to_indexed_triangle_set(
                 its.vertices, its.indices, m_tree, point, idx_unsigned,
-                closest_vec3d) };
+                closest_vec3d);
         i       = int(idx_unsigned);
         closest = closest_vec3d;
         return dist;

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -10,20 +10,36 @@
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Plater.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
 
 #include "libslic3r/Time.hpp"
 
 using namespace nlohmann;
 
 namespace {
-    // Orca: access_code and user_access_code used to be separate AppConfig keys before the two
-    // fields were merged; fall back to the legacy key so existing users' saved codes aren't lost.
-    std::string get_access_code_with_legacy_fallback(Slic3r::AppConfig* config, const std::string& dev_id)
+    // Orca: access_code lives on BBLocalMachine::access_code (keyed by dev_id via
+    // get_local_machines(), scoped by the record's own printer_agent_id field) - so binding a
+    // printer under one agent doesn't silently appear as already-bound under a different,
+    // independent agent. This only covers LAN devices (BBLocalMachine's own scope); access_code
+    // and user_access_code used to be the only, flat dev_id-only AppConfig keys before
+    // BBLocalMachine::access_code existed, and codes saved back then are still stored flat (no
+    // agent association at all). Since BBL was the only agent that existed at the time, honor
+    // those flat legacy keys as implicitly BBL's - but only for the BBL agent, so they aren't
+    // leaked to other agents that never bound the device themselves.
+    std::string get_access_code_with_legacy_fallback(Slic3r::AppConfig* config, const std::string& dev_id, const std::string& agent_id)
     {
-        std::string code = config->get("access_code", dev_id);
-        if (code.empty())
-            code = config->get("user_access_code", dev_id);
-        return code;
+        const auto& machines = config->get_local_machines();
+        auto        it       = machines.find(dev_id);
+        if (it != machines.end() && it->second.printer_agent_id == agent_id && !it->second.access_code.empty())
+            return it->second.access_code;
+
+        if (agent_id == Slic3r::BBL_PRINTER_AGENT_ID || agent_id.empty()) {
+            std::string code = config->get("access_code", dev_id);
+            if (code.empty())
+                code = config->get("user_access_code", dev_id);
+            return code;
+        }
+        return "";
     }
 }
 
@@ -55,12 +71,13 @@ namespace Slic3r
                 continue;
             MachineObject* obj       = new MachineObject(this, m_agent, m.dev_name, m.dev_id, m.dev_ip);
             obj->printer_type        = m.printer_type;
+            obj->printer_agent_id    = m.printer_agent_id;
             obj->dev_connection_type = "lan";
             obj->bind_state          = "free";
             obj->bind_sec_link       = "secure";
             obj->m_is_online         = true;
             obj->last_alive          = Slic3r::Utils::get_current_time_utc();
-            obj->set_access_code(get_access_code_with_legacy_fallback(config, m.dev_id), false);
+            obj->set_access_code(get_access_code_with_legacy_fallback(config, m.dev_id, obj->printer_agent_id), false);
             if (obj->has_access_right()) {
                 localMachineList.insert(std::make_pair(m.dev_id, obj));
             } else {
@@ -77,10 +94,12 @@ namespace Slic3r
             if (m.is_lan_mode_printer()) {
                 if (m.has_access_right()) {
                     BBLocalMachine local_machine;
-                    local_machine.dev_id       = m.get_dev_id();
-                    local_machine.dev_name     = m.get_dev_name();
-                    local_machine.dev_ip       = m.get_dev_ip();
-                    local_machine.printer_type = m.printer_type;
+                    local_machine.dev_id           = m.get_dev_id();
+                    local_machine.dev_name         = m.get_dev_name();
+                    local_machine.dev_ip           = m.get_dev_ip();
+                    local_machine.printer_type     = m.printer_type;
+                    local_machine.printer_agent_id = m.printer_agent_id;
+                    local_machine.access_code      = m.get_access_code();
                     config->update_local_machine(local_machine);
                 }
             } else {
@@ -143,6 +162,14 @@ namespace Slic3r
         }
     }
 
+    std::string DeviceManager::get_current_printer_agent_id() const
+    {
+        if (!m_agent)
+            return "";
+        auto printer_agent = m_agent->get_printer_agent();
+        return printer_agent ? printer_agent->get_agent_info().id : "";
+    }
+
     void DeviceManager::EnableMultiMachine(bool enable)
     {
         m_agent->enable_multi_machine(enable);
@@ -339,6 +366,7 @@ namespace Slic3r
                 /* insert a new machine */
                 obj = new MachineObject(this, m_agent, dev_name, dev_id, dev_ip);
                 obj->printer_type = _parse_printer_type(printer_type_str);
+                obj->printer_agent_id = get_current_printer_agent_id();
                 obj->wifi_signal = printer_signal;
                 obj->dev_connection_type = connect_type;
                 obj->bind_state     = bind_state;
@@ -350,7 +378,7 @@ namespace Slic3r
                 //load access code
                 AppConfig* config = Slic3r::GUI::wxGetApp().app_config;
                 if (config) {
-                    obj->set_access_code(get_access_code_with_legacy_fallback(config, dev_id), false);
+                    obj->set_access_code(get_access_code_with_legacy_fallback(config, dev_id, obj->printer_agent_id), false);
                 }
                 localMachineList.insert(std::make_pair(dev_id, obj));
 
@@ -379,6 +407,7 @@ namespace Slic3r
             obj = it->second;
         } else {
             obj = new MachineObject(this, m_agent, machine.dev_name, machine.dev_id, machine.dev_ip);
+            obj->printer_agent_id = get_current_printer_agent_id();
             localMachineList.insert(std::make_pair(machine.dev_id, obj));
         }
         if (machine.printer_type.empty())
@@ -505,16 +534,26 @@ namespace Slic3r
         OnSelectedMachineChanged(previous_selected_machine, selected_machine);
     }
 
-    void DeviceManager::clear_other_devices()
+    void DeviceManager::clear_other_devices(const std::string& target_agent_id)
     {
         // why: on agent swap, keep "My Devices" but drop the transient "Other Devices"
         // Those belong to the previous agent's network scan; the new agent's start_discovery re-populates its own.
+        //
+        // Also drop "My Devices" stamped by a different agent than the one we're swapping to
+        // (target_agent_id, passed by the caller since the live agent hasn't been repointed yet
+        // at this point): otherwise a device first discovered under agent A survives every swap
+        // with a stale printer_agent_id, stays hidden from every agent's filtered list, and only
+        // gets re-tagged if something happens to delete and re-create it (e.g. account logout).
+        // Dropping it here instead lets the new agent's start_discovery re-insert and re-stamp it
+        // like any other fresh device.
         const auto my = get_my_machine_list();
         for (auto it = localMachineList.begin(); it != localMachineList.end();)
         {
-            if (my.find(it->first) == my.end())
+            const bool is_my_device = my.find(it->first) != my.end();
+            const bool agent_mismatch = !target_agent_id.empty() && it->second &&
+                                         it->second->printer_agent_id != target_agent_id;
+            if (!is_my_device || agent_mismatch)
             {
-                // not a "My Device" -> an "Other Device"
                 delete it->second;
                 it = localMachineList.erase(it);
             }
@@ -697,13 +736,16 @@ namespace Slic3r
             m_agent->add_subscribe(subscribe_list_cache);
     }
 
-    std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list()
+    std::map<std::string, MachineObject*> DeviceManager::get_my_machine_list(const std::string& agent_id)
     {
         std::map<std::string, MachineObject*> result;
 
         for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
         {
-            if (it->second && !it->second->is_lan_mode_printer())
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (!it->second->is_lan_mode_printer())
             {
                 result.insert(std::make_pair(it->first, it->second));
             }
@@ -711,7 +753,10 @@ namespace Slic3r
 
         for (auto it = localMachineList.begin(); it != localMachineList.end(); it++)
         {
-            if (it->second && it->second->has_access_right() && it->second->is_avaliable() && it->second->is_lan_mode_printer())
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (it->second->has_access_right() && it->second->is_avaliable() && it->second->is_lan_mode_printer())
             {
                 // remove redundant in userMachineList
                 if (result.find(it->first) == result.end())
@@ -723,12 +768,15 @@ namespace Slic3r
         return result;
     }
 
-    std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list()
+    std::map<std::string, MachineObject*> DeviceManager::get_my_cloud_machine_list(const std::string& agent_id)
     {
         std::map<std::string, MachineObject*> result;
         for (auto it = userMachineList.begin(); it != userMachineList.end(); it++)
         {
-            if (it->second && !it->second->is_lan_mode_printer()) { result.emplace(*it); }
+            if (!it->second || (!agent_id.empty() && it->second->printer_agent_id != agent_id))
+                continue;
+
+            if (!it->second->is_lan_mode_printer()) { result.emplace(*it); }
         }
         return result;
     }
@@ -801,6 +849,7 @@ namespace Slic3r
                     else
                     {
                         obj = new MachineObject(this, m_agent, "", "", "");
+                        obj->printer_agent_id = get_current_printer_agent_id();
                         if (m_agent)
                         {
                             obj->set_bind_status(m_agent->get_user_name(provider));

src/slic3r/GUI/DeviceCore/DevManager.h

@@ -74,7 +74,10 @@ public:
     void erase_user_machine(std::string dev_id) { userMachineList.erase(dev_id); }
     void clean_user_info(bool keep_local_selection = false);
 
-    void clear_other_devices();
+    // target_agent_id: id of the agent being swapped to (empty = no agent-mismatch check,
+    // just the original "drop Other Devices" behavior). Pass the incoming agent's id, not the
+    // live one - this runs before the live agent is repointed.
+    void clear_other_devices(const std::string& target_agent_id = "");
 
     void load_last_machine();
     void update_user_machine_list_info(const std::string& provider);
@@ -90,10 +93,15 @@ public:
 
     /* my machine*/
     MachineObject* get_my_machine(std::string dev_id);
-    std::map<std::string, MachineObject*> get_my_machine_list();
-    std::map<std::string, MachineObject*> get_my_cloud_machine_list();
+    std::map<std::string, MachineObject*> get_my_machine_list(const std::string& agent_id = "");
+    std::map<std::string, MachineObject*> get_my_cloud_machine_list(const std::string& agent_id = "");
     void modify_device_name(std::string dev_id, std::string dev_name, const std::string& provider);
 
+    // id of the currently live IPrinterAgent (IPrinterAgent::get_agent_info().id), or empty if
+    // m_agent has no printer agent set yet. Pass to get_my_machine_list()/get_my_cloud_machine_list()
+    // to scope results to the active agent.
+    std::string get_current_printer_agent_id() const;
+
     /* create machine or update machine properties */
     void on_machine_alive(std::string json_str);
     int query_bind_status(std::string& msg, const std::string& provider);

src/slic3r/GUI/DeviceManager.cpp

@@ -3,6 +3,7 @@
 #include "libslic3r/Time.hpp"
 #include "libslic3r/Thread.hpp"
 #include "slic3r/Utils/NetworkAgent.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
 #include "GuiColor.hpp"
 
 #include "GUI_App.hpp"
@@ -458,11 +459,41 @@ void MachineObject::set_access_code(std::string code, bool only_refresh)
     if (only_refresh) {
         AppConfig* config = GUI::wxGetApp().app_config;
         if (config) {
-            if (!code.empty()) {
-                GUI::wxGetApp().app_config->set_str("access_code", get_dev_id(), code);
-                DeviceManager::update_local_machine(*this);
+            if (is_lan_mode_printer()) {
+                // why: LAN codes are scoped via BBLocalMachine::access_code, keyed by dev_id and
+                // scoped by that record's own printer_agent_id field - see the matching comment
+                // on get_access_code_with_legacy_fallback() in DevManager.cpp - so binding this
+                // device under one printer agent doesn't silently read as already-bound under a
+                // different, independent one. Cloud devices (the else branch below) aren't
+                // scoped this way: they're never recalled from a stale local cache across a
+                // session boundary, since parse_user_print_info() always overwrites their code
+                // fresh from the cloud API's current response, so there's no cross-agent leakage
+                // risk to guard against there.
+                if (!code.empty()) {
+                    DeviceManager::update_local_machine(*this);
+                } else {
+                    // Only patch an existing record's code - don't persist a brand-new
+                    // never-bound entry just because set_access_code("") was called on it.
+                    const auto& machines = config->get_local_machines();
+                    auto        it       = machines.find(get_dev_id());
+                    if (it != machines.end()) {
+                        BBLocalMachine local_machine = it->second;
+                        local_machine.access_code    = "";
+                        config->update_local_machine(local_machine);
+                    }
+                    // Also clear the pre-scoping flat legacy key when unbinding under BBL, so an
+                    // old BBL-era code can't silently "re-bind" this device again via
+                    // get_access_code_with_legacy_fallback()'s legacy fallback.
+                    if (printer_agent_id == BBL_PRINTER_AGENT_ID || printer_agent_id.empty()) {
+                        config->erase("access_code", get_dev_id());
+                        config->erase("user_access_code", get_dev_id());
+                    }
+                }
             } else {
-                GUI::wxGetApp().app_config->erase("access_code", get_dev_id());
+                if (!code.empty())
+                    config->set_str("access_code", get_dev_id(), code);
+                else
+                    config->erase("access_code", get_dev_id());
             }
         }
     }

src/slic3r/GUI/DeviceManager.hpp

@@ -229,6 +229,16 @@ public:
 
     //PRINTER_TYPE printer_type = PRINTER_3DPrinter_UKNOWN;
     std::string printer_type;       /* model_id */
+
+    // id of the IPrinterAgent that was used to discover or bind this device (IPrinterAgent::get_agent_info().id,
+    // e.g. "bbl"), stamped at creation time — not derived from get_agent(), since m_agent is a single
+    // process-wide NetworkAgent shared by every MachineObject and gets repointed on agent swap
+    // (see DeviceManager::set_agent()), so it can't tell which agent originally found this device.
+    // We persist this as well so that when the printer agent is swapped, we don't show unrelated devices,
+    // e.g. if the current printer agent is elegoo, we shouldn't show printers connected by BBL printer agent
+    // under local machines.
+    std::string printer_agent_id;
+
     std::string   get_show_printer_type() const;
     PrinterSeries get_printer_series() const;
     PrinterArch get_printer_arch() const;

src/slic3r/GUI/DeviceTab/uiAmsHumidityPopup.cpp

@@ -1,9 +1,9 @@
-/**********************************************************
-* File: uiAmsHumidityPopup.cpp
+//**********************************************************/
+/* File: uiAmsHumidityPopup.cpp
 *  Description: The popup with DevAms Humidity
 *
 * \n class uiAmsHumidityPopup
-**********************************************************/
+//**********************************************************/
 
 #include "uiAmsHumidityPopup.h"
 
@@ -191,4 +191,4 @@ void uiAmsPercentHumidityDryPopup::msw_rescale()
 
 } // namespace GUI
 
-} // namespace Slic3r
+} // namespace Slic3r

src/slic3r/GUI/DeviceTab/uiAmsHumidityPopup.h

@@ -1,9 +1,9 @@
-/**********************************************************
-* File: uiAmsHumidityPopup.h
+//**********************************************************/
+/* File: uiAmsHumidityPopup.h
 *  Description: The popup with DevAms Humidity
 *
 *  \n class uiAmsHumidityPopup
-**********************************************************/
+//**********************************************************/
 
 #pragma once
 #include "slic3r/GUI/Widgets/AMSItem.hpp"
@@ -68,7 +68,7 @@ private:
 
     wxStaticBitmap* m_dry_state_img;
     Label*          m_dry_state;
-
+    
     Label* m_humidity_header;
     Label* m_humidity_label;
 
@@ -81,4 +81,4 @@ private:
     wxSizer*       m_sizer;
 };
 
-}} // namespace Slic3r::GUI
+}} // namespace Slic3r::GUI

src/slic3r/GUI/DeviceTab/uiDeviceUpdateVersion.cpp

@@ -1,9 +1,9 @@
-/**********************************************************
-* File: uiDeviceUpdateVersion.cpp
+//**********************************************************/
+/* File: uiDeviceUpdateVersion.cpp
 *  Description: The panel with firmware info
 *
 * \n class uiDeviceUpdateVersion
-**********************************************************/
+//**********************************************************/
 
 #include "uiDeviceUpdateVersion.h"
 
@@ -114,4 +114,4 @@ void uiDeviceUpdateVersion::CreateWidgets()
     Layout();
 
     wxGetApp().UpdateDarkUIWin(this);
-}
+}

src/slic3r/GUI/DeviceTab/uiDeviceUpdateVersion.h

@@ -1,9 +1,9 @@
-/**********************************************************
-* File: uiDeviceUpdateVersion.h
+//**********************************************************/
+/* File: uiDeviceUpdateVersion.h
 *  Description: The panel with firmware info
 * 
 *  \n class uiDeviceUpdateVersion
-**********************************************************/
+//**********************************************************/
 
 #pragma once
 #include <wx/panel.h>
@@ -44,4 +44,4 @@ private:
     wxStaticText*   m_dev_version;
     wxStaticBitmap* m_dev_upgrade_indicator;
 };
-};// end of namespace Slic3r::GUI
+};// end of namespace Slic3r::GUI

src/slic3r/GUI/GUI_App.cpp

@@ -3937,7 +3937,13 @@ void GUI_App::set_live_printer_agent(std::shared_ptr<IPrinterAgent> agent)
         m_agent->set_user_selected_machine("");
         // note: belt-and-suspenders (precedent: DeviceManagerRefresher::on_timer)
         dev->OnSelectedMachineLost(); // why: clear stale sidebar sync-status / AMS
-        dev->clear_other_devices(); // why: drop stale LAN discoveries; keep My Devices
+        // why: drop stale LAN discoveries; keep My Devices, but only those belonging to the
+        // agent we're about to swap to, so a device stamped by the outgoing agent doesn't
+        // linger hidden - the new agent's start_discovery re-inserts and re-stamps it fresh.
+        // agent is null when clearing the live agent entirely (e.g. plugin unload); there's no
+        // target to filter against then, so fall back to the original "keep all My Devices"
+        // behavior rather than guessing.
+        dev->clear_other_devices(agent ? agent->get_agent_info().id : std::string());
     }
 
     m_agent->set_printer_agent(agent);

src/slic3r/GUI/GUI_ObjectList.cpp

@@ -3213,7 +3213,7 @@ void ObjectList::merge(bool to_multipart_object)
         //changed_object(obj_idx);
         //remove();
     }
-   // wxGetApp().plater()->load_model_objects(objects);
+   /* wxGetApp().plater()->load_model_objects(objects);
 
     Selection& selection = p->view3D->get_canvas3d()->get_selection();
     size_t last_obj_idx = p->model.objects.size() - 1;

src/slic3r/GUI/IMSlider.cpp

@@ -1733,7 +1733,7 @@ std::string IMSlider::get_label(int tick, LabelType label_type)
         ::sprintf(layer_height, "%.2f", m_values.empty() ? m_label_koef * value : m_values[value]);
         if (label_type == ltHeight) return std::string(layer_height);
         if (label_type == ltHeightWithLayer) {
-            char   buffer[90];
+            char   buffer[64];
             size_t layer_number;
             layer_number = m_draw_mode == dmSequentialFffPrint ? (m_values.empty() ? value : value + 1) : m_is_wipe_tower ? get_layer_number(value, label_type) + 1 : (m_values.empty() ? value : value + 1);
             ::sprintf(buffer, "%5s\n%5s", std::to_string(layer_number).c_str(), layer_height);

src/slic3r/GUI/Jobs/OrientJob.cpp

@@ -149,46 +149,6 @@ void OrientJob::prepare()
     }
 }
 
-/// parameters to minimize support area
-static void setMinimalSupportAreaPrams(Slic3r::orientation::OrientParams &out)
-{
-    out.TAR_A               = 0.015f;
-    out.TAR_B               = 0.177f;
-    out.RELATIVE_F          = 20;
-    out.CONTOUR_F           = 0.5f;
-    out.BOTTOM_F            = 2.5f;
-    out.BOTTOM_HULL_F       = 0.1f;
-    out.TAR_C               = 0.1f;
-    out.TAR_D               = 1;
-    out.TAR_E               = 0.0115f;
-    out.FIRST_LAY_H         = 0.2f;      // 0.0475;
-    out.VECTOR_TOL          = -0.00083f;
-    out.NEGL_FACE_SIZE      = 0.01f;
-    out.ASCENT              = -0.5f;
-    out.PLAFOND_ADV         = 0.0599f;
-    out.CONTOUR_AMOUNT      = 0.0182427f;
-    out.OV_H                = 2.574f;
-    out.height_offset       = 2.3728f;
-    out.height_log          = 0.041375f;
-    out.height_log_k        = 1.9325457f;
-    out.LAF_MAX             = 0.999f;    // cos(1.4\degree) for low angle face 0.9997f
-    out.LAF_MIN             = 0.97f;     // cos(14\degree) 0.9703f
-    out.TAR_LAF             = 0.001f;    // 0.01f
-    out.TAR_PROJ_AREA       = 0.1f;
-    out.BOTTOM_MIN          = 0.1f;      // min bottom area. If lower than it the object may be unstable
-    out.BOTTOM_MAX          = 2000;      // max bottom area. If get to it the object is stable enough (further increase bottom area won't do more help)
-    out.height_to_bottom_hull_ratio_MIN = 1,
-    out.BOTTOM_HULL_MAX     = 2000;      // max bottom hull area
-    out.APPERANCE_FACE_SUPP = 3;         // penalty of generating supports on appearance face
-    out.overhang_angle      = 60.f;
-    out.use_low_angle_face  = true;
-    out.min_volume          = false;
-    out.fun_dir             = {};
-    out.parallel            = true;
-    out.progressind         = {};
-    out.stopcondition       = {};
-}
-
 void OrientJob::process(Ctl &ctl)
 {
     static const auto arrangestr = _u8L("Orienting...");
@@ -201,8 +161,9 @@ void OrientJob::process(Ctl &ctl)
     const GLCanvas3D::OrientSettings& settings = m_plater->canvas3D()->get_orient_settings();
 
     orientation::OrientParams params;
+    orientation::OrientParamsArea params_area;
     if (settings.min_area) {
-        setMinimalSupportAreaPrams(params);
+        memcpy(&params, &params_area, sizeof(params));
         params.min_volume = false;
     }
     else {

src/slic3r/GUI/SelectMachine.cpp

@@ -3629,7 +3629,7 @@ void SelectMachineDialog::on_send_print()
         BOOST_LOG_TRIVIAL(error) << "build_nozzle_info errors";
     }
 
-    m_print_job->sdcard_state = obj_->GetStorage()->get_sdcard_state();
+    m_print_job->sdcard_state = obj_->GetStorage()->get_sdcard_state();    
     m_print_job->has_sdcard =  wxGetApp().app_config->get("allow_abnormal_storage") == "true"
             ? (m_print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_NORMAL
                || m_print_job->sdcard_state == DevStorage::SdcardState::HAS_SDCARD_ABNORMAL)
@@ -3868,11 +3868,12 @@ _compare_obj_names(MachineObject* obj1, MachineObject* obj2)
 }
 
 /*******************************************************************
-* @note   _collect_machine_list
-* @param  dev_manager -- the device manager
-* @param  sorted_machine_objs -- return the sorted machine objects
-* @param  best_one -- return the best one
-*******************************************************************/
+*@note   _collect_machine_list
+*@param  dev_manager -- the device manager
+*@param  sorted_machine_objs -- return the sorted machine objects
+*@param  best_one -- return the best one
+*/
+/*******************************************************************/
 static void
 _collect_sorted_machines(Slic3r::DeviceManager* dev_manager,
                          std::vector<MachineObject*>& sorted_machine_objs)
@@ -3912,7 +3913,7 @@ _collect_sorted_machines(Slic3r::DeviceManager* dev_manager,
     };
 
     // collect from user machine list
-    const auto& user_machine_list = dev_manager->get_my_machine_list();// user machine list
+    const auto& user_machine_list = dev_manager->get_my_machine_list(dev_manager->get_current_printer_agent_id());// user machine list
     for (const auto& elem : user_machine_list)
     {
         MachineObject* mobj = elem.second;

src/slic3r/GUI/SelectMachinePop.cpp

@@ -501,6 +501,7 @@ void SelectMachinePopup::update_other_devices()
     DeviceManager* dev = wxGetApp().getDeviceManager();
     if (!dev) return;
     m_free_machine_list = dev->get_local_machinelist();
+    const std::string current_agent_id = dev->get_current_printer_agent_id();
 
     BOOST_LOG_TRIVIAL(trace) << "SelectMachinePopup update_other_devices start";
     this->Freeze();
@@ -512,6 +513,10 @@ void SelectMachinePopup::update_other_devices()
         /* do not show printer bind state is empty */
         if (!mobj->is_avaliable()) continue;
 
+        /* do not show devices discovered/bound by a different printer agent */
+        if (mobj->printer_agent_id != current_agent_id)
+            continue;
+
         if (!wxGetApp().is_user_login(wxGetApp().get_printer_cloud_provider()) && !mobj->is_lan_mode_printer())
             continue;
 
@@ -634,7 +639,7 @@ void SelectMachinePopup::update_user_devices()
     }
 
     m_bind_machine_list.clear();
-    m_bind_machine_list = dev->get_my_machine_list();
+    m_bind_machine_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
     //sort list
     std::vector<std::pair<std::string, MachineObject*>> user_machine_list;

src/slic3r/Utils/RaycastManager.cpp

@@ -107,7 +107,7 @@ std::optional<RaycastManager::Hit> RaycastManager::first_hit(const Vec3d& point,
     const AABBMesh *hit_mesh = nullptr;
     double hit_squared_distance = 0.;
     int hit_face = -1;
-    Vec3d hit_world { Vec3d::Zero() };
+    Vec3d hit_world;
     const Transform3d *hit_tramsformation = nullptr;
     const TrKey *hit_key = nullptr;