Merge pull request #66 from HarrierPigeon/belt/tommyb-rendererChanges

Clean up and implement @tommasobbianchi's belt renderer changes

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -4933,6 +4933,13 @@ void GCodeProcessor::process_G92(const GCodeReader::GCodeLine& line)
     if (line.has_z()) {
         m_origin[Z] = m_end_position[Z] - line.z() * lengths_scale_factor;
         any_found = true;
+        // Belt only: the start G-code's purge-blob advance + G92 Z0 resets leave a constant
+        // machine-Z origin offset here; the designed-view back-transform subtracts it so
+        // toolpaths map to the model's belt coordinate (gcode Z). Gated on belt_tilt_angle
+        // (set from the belt header, parsed before the body) so non-belt G-code processing
+        // is byte-identical — no unconditional work on the shared path.
+        if (m_result.belt_tilt_angle != 0.f)
+            m_result.belt_z_origin = m_origin[Z];
     }
 
     if (line.has_e()) {

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -248,6 +248,11 @@ class Print;
         // Belt printer: physical tilt magnitude (deg) parsed from the slicing-rotation
         // header comment; used to enable the preview's belt view.
         float belt_tilt_angle{ 0.f };
+        // Belt printer: machine-Z origin offset (mm) left in m_origin[Z] by the start
+        // G-code (purge-blob belt advance + G92 Z0 resets). Move positions are stored
+        // as gcode_Z + this offset, so the designed-view back-transform must subtract it
+        // to recover the model's belt coordinate.
+        float belt_z_origin{ 0.f };
         RemapAxis preslice_remap_x{ RemapAxis::PosX };
         RemapAxis preslice_remap_y{ RemapAxis::PosY };
         RemapAxis preslice_remap_z{ RemapAxis::PosZ };
@@ -317,6 +322,7 @@ class Print;
             filament_change_count_map = other.filament_change_count_map;
             initial_layer_time = other.initial_layer_time;
             belt_tilt_angle = other.belt_tilt_angle;
+            belt_z_origin = other.belt_z_origin;
             preslice_remap_x = other.preslice_remap_x;
             preslice_remap_y = other.preslice_remap_y;
             preslice_remap_z = other.preslice_remap_z;

src/libslic3r/GCode/MachineFrameTransform.hpp

@@ -33,6 +33,11 @@ public:
 
     bool is_active() const { return m_active; }
 
+    // The composed shear*scale transform (identity when inactive). Exposed so the
+    // G-code viewer can build the machine->model back-transform for the upright
+    // ("designed") belt preview.
+    const Transform3d& transform() const { return m_transform; }
+
 private:
     bool        m_active    = false;
     Transform3d m_transform = Transform3d::Identity();

src/slic3r/GUI/GCodeViewer.cpp

@@ -24,6 +24,8 @@
 #include "GLToolbar.hpp"
 #include "GUI_Preview.hpp"
 #include "libslic3r/Print.hpp"
+#include "libslic3r/BeltTransform.hpp"
+#include "libslic3r/GCode/MachineFrameTransform.hpp"
 #include "libslic3r/Layer.hpp"
 #include "Widgets/ProgressDialog.hpp"
 #include "MsgDialog.hpp"
@@ -1118,6 +1120,59 @@ std::vector<int> GCodeViewer::get_plater_extruder()
     return m_plater_extruder;
 }
 
+// Belt printers: compute the full machine->model back-transform from the print
+// config, so the "designed" (upright) G-code preview maps each toolpath vertex
+// back to Cartesian space. The G-code forward pipeline is (BeltGCodeWriter::
+// to_machine_coords):  gcode = MachineFrame( AxisRemap( X ) ), with X = model if
+// gcode_back_transform (write already un-rotated to Cartesian) else BeltForward(
+// model). So the inverse is:
+//   model = [BeltForward^-1 if !gcode_back_transform] . AxisRemap^-1 . MachineFrame^-1
+// All parts are config-driven affines -> handles any rotation/shear/scale/axis-
+// remap combination. (origin-snap is a per-instance translation that only shifts
+// position, not orientation, so it is intentionally omitted.)
+static Transform3d compute_belt_back_transform(const PrintConfig& cfg)
+{
+    if (!cfg.belt_printer.value)
+        return Transform3d::Identity();
+
+    MachineFrameTransform mft;
+    mft.init_from_config(cfg);
+    const Transform3d mf_inv = mft.is_active() ? Transform3d(mft.transform().inverse())
+                                               : Transform3d::Identity();
+
+    // Forward G-code axis remap as an affine matrix (out_i = sign * in[r_i % 3], plus a
+    // build-volume offset for Rev axes). This is the matrix form of the per-point
+    // GCodeWriter::apply_axis_remap (row convention: each OUTPUT axis selects an input
+    // axis + sign) and MUST stay in sync with it. The build-volume max matches what the
+    // writer is fed in GCode.cpp (printable_area max + printable_height). NB: this is the
+    // transpose of the column convention used by BeltTransformPipeline::build_preslice_remap
+    // — the two remaps are not interchangeable. (Follow-up: precompute this matrix once in
+    // GCodeWriter and share it with apply_axis_remap to remove the parallel encoding.)
+    Transform3d ar = Transform3d::Identity();
+    const int rr[3] = { int(cfg.gcode_remap_x.value), int(cfg.gcode_remap_y.value), int(cfg.gcode_remap_z.value) };
+    if (rr[0] != 0 || rr[1] != 1 || rr[2] != 2) {
+        BoundingBoxf bbox_bed(cfg.printable_area.values);
+        const Vec3d vmax(bbox_bed.max.x(), bbox_bed.max.y(), cfg.printable_height.value);
+        Matrix3d M = Matrix3d::Zero();
+        Vec3d    t = Vec3d::Zero();
+        for (int i = 0; i < 3; ++i) {
+            const int axis = rr[i] % 3;
+            if (rr[i] < 3)      M(i, axis) =  1.0;
+            else if (rr[i] < 6) M(i, axis) = -1.0;
+            else              { M(i, axis) = -1.0; t[i] = vmax[axis]; }
+        }
+        ar.linear()      = M;
+        ar.translation() = t;
+    }
+    const Transform3d ar_inv = ar.inverse();
+
+    Transform3d bf_inv = Transform3d::Identity();
+    if (!cfg.gcode_back_transform.value)
+        bf_inv = BeltTransformPipeline::build_forward_transform(cfg).inverse();
+
+    return bf_inv * ar_inv * mf_inv;
+}
+
 //BBS: always load shell at preview
 void GCodeViewer::load_as_gcode(const GCodeProcessorResult& gcode_result, const Print& print, const std::vector<std::string>& str_tool_colors,
                 const std::vector<std::string>& str_color_print_colors, const BuildVolume& build_volume,
@@ -1125,13 +1180,25 @@ void GCodeViewer::load_as_gcode(const GCodeProcessorResult& gcode_result, const
 {
     m_loaded_as_preview = false;
 
+    // Belt printers: drive the designed/raw view UI (legend checkbox, hotkey B, canvas-toolbar
+    // menu item) from the loaded print here. Plater::set_bed_shape also calls set_belt_printer(),
+    // but only on bed-shape changes — not reliably on every slice/preview load — so the UI was
+    // staying hidden even though the (config-driven) designed view rendered. The tilt magnitude
+    // comes from the G-code header (gcode_result.belt_tilt_angle, abs of the slicing rotation).
+    m_belt_view_enabled = print.config().belt_printer.value;
+    m_belt_angle_deg    = gcode_result.belt_tilt_angle;
+
     const bool current_top_layer_only = m_viewer.is_top_layer_only_view_range();
     const bool required_top_layer_only = get_app_config()->get_bool("seq_top_layer_only");
     if (current_top_layer_only != required_top_layer_only)
         m_viewer.toggle_top_layer_only_view_range();
 
-    // avoid processing if called with the same gcode_result
-    if (m_last_result_id == gcode_result.id && wxGetApp().is_editor()) {
+    // avoid processing if called with the same gcode_result.
+    // Belt printers are exempt: the toolpath geometry fed to libvgcode depends on
+    // the current designed/raw view state (back-transform applied in convert), so
+    // re-running the conversion is required for the upright view and for toggling
+    // it (hotkey B) to take effect even when the G-code itself is unchanged.
+    if (m_last_result_id == gcode_result.id && wxGetApp().is_editor() && !print.config().belt_printer.value) {
         //BBS: add logs
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": the same id %1%, return directly, result %2% ") % m_last_result_id % (&gcode_result);
 
@@ -1172,8 +1239,89 @@ void GCodeViewer::load_as_gcode(const GCodeProcessorResult& gcode_result, const
         return;
     }
 
-    // convert data from PrusaSlicer format to libvgcode format
-    libvgcode::GCodeInputData data = libvgcode::convert(gcode_result, str_tool_colors, str_color_print_colors, m_viewer);
+    // convert data from PrusaSlicer format to libvgcode format.
+    // Belt printers: when the "designed (upright) view" is active, back-transform
+    // the toolpath geometry into model/Cartesian space using the general belt
+    // inverse (handles any mesh rotation + shear + axis remap). When off, the raw
+    // machine-frame G-code is shown (useful for debugging the transform itself).
+    const bool is_belt = print.config().belt_printer.value;
+    Transform3d belt_inv = (is_belt && m_belt_show_designed)
+        ? compute_belt_back_transform(print.config()) : Transform3d::Identity();
+    // Belt: move positions are stored as gcode_Z + belt_z_origin (the start G-code's
+    // purge-blob advance baked into the machine-Z origin by its G92 Z0 resets). Subtract
+    // that constant before the linear back-transform so every toolpath maps to the model's
+    // belt coordinate. Without it the back-transform mixes the offset with the gantry-Y
+    // term, leaving a per-move designed-Y error that min-corner anchoring cannot remove
+    // when a bridge/keel move happens to cancel it at the bbox minimum.
+    if (is_belt && m_belt_show_designed && gcode_result.belt_z_origin != 0.0f)
+        belt_inv = belt_inv * Transform3d(Eigen::Translation3d(Vec3d(0.0, 0.0, -double(gcode_result.belt_z_origin))));
+    const bool apply_belt = is_belt && m_belt_show_designed
+        && !belt_inv.matrix().isApprox(Transform3d::Identity().matrix());
+    if (apply_belt) {
+        // The linear belt back-transform recovers the print's shape and orientation but not
+        // the per-object placement/lift translation: the object's position on the belt, the
+        // BeltSliceStrategy min-Z lift, and the centering pre-translate are applied OUTSIDE
+        // build_forward_transform() (see PrintObjectSlice.cpp), so its linear inverse leaves
+        // them un-undone. Uncorrected, the upright toolpaths float a fixed offset from the
+        // model shell. Recover the translation generally — independent of the offset's exact
+        // source or the axis remap — by anchoring the back-transformed object body onto the
+        // upright model bounding box (the same space the shells render in).
+        BoundingBoxf3 model_bb;
+        for (const PrintObject* po : print.objects())
+            for (const ModelInstance* mi : po->model_object()->instances)
+                model_bb.merge(po->model_object()->instance_bounding_box(*mi));
+        // Build the anchor bbox from surface toolpaths only. After the belt_z_origin
+        // correction the surface back-transforms onto the model, but a few elevated
+        // features (bridges/overhangs over the chevron gap) are mis-mapped by the linear
+        // inverse to well outside the model body; if one becomes the bbox minimum it
+        // drags the min-corner anchor by ~20mm. Drop moves that land clearly outside the
+        // (correct) model bbox — a geometric filter, not a role guess.
+        // Tolerance around the model bbox for outlier rejection, and the minimum fraction
+        // of MOVES (by count) the clip must retain before we trust it over the full bbox.
+        // Count, not bbox extent: a single far-flung outlier move (e.g. a belt-entry purge
+        // that maps to y~0) inflates the full bbox so much that a size-fraction test would
+        // wrongly reject the clip and re-include the outlier, dragging the min-corner anchor
+        // by ~the offset. By count the clip keeps ~100% of moves here and ~0% only when the
+        // object is genuinely offset from the belt entry (the real fall-back-to-full case).
+        constexpr double ANCHOR_CLIP_MARGIN_MM   = 10.0;
+        constexpr double ANCHOR_CLIP_MIN_KEEP    = 0.5;
+        BoundingBoxf3 tp_bb_clip, tp_bb_full;
+        size_t n_filtered = 0, n_clip = 0;
+        const double y_lo = model_bb.defined ? model_bb.min.y() - ANCHOR_CLIP_MARGIN_MM : -1e30;
+        const double y_hi = model_bb.defined ? model_bb.max.y() + ANCHOR_CLIP_MARGIN_MM :  1e30;
+        for (const GCodeProcessorResult::MoveVertex& mv : gcode_result.moves)
+            if (mv.type == EMoveType::Extrude && mv.layer_id >= 1) { // skip layer-0 prime/skirt
+                ++n_filtered;
+                const Vec3d p = belt_inv * mv.position.cast<double>();
+                tp_bb_full.merge(p);
+                if (p.y() >= y_lo && p.y() <= y_hi) {
+                    tp_bb_clip.merge(p);
+                    ++n_clip;
+                }
+            }
+        // Use the clipped bbox when it still holds the bulk of the moves (outliers removed).
+        // If the object sits far from the belt entry the toolpaths are grossly offset and the
+        // clip drops most of them — fall back to the full bbox so the min-corner anchor still
+        // recovers that gross translation rather than breaking.
+        const BoundingBoxf3& tp_bb =
+            (tp_bb_clip.defined && n_filtered > 0 &&
+             double(n_clip) >= ANCHOR_CLIP_MIN_KEEP * double(n_filtered)) ? tp_bb_clip : tp_bb_full;
+        if (model_bb.defined && tp_bb.defined) {
+            // Anchor the back-transformed toolpath body onto the upright model bbox by
+            // its MIN corner. (Center anchoring was tried and regressed when the toolpath
+            // and model bounding boxes differ in extent.) With the belt_z_origin
+            // correction above and the outlier-robust bbox below, the surface overlaps the
+            // shell to well under a millimetre when the object is at the belt entry; an
+            // object placed elsewhere in global-rotation mode still carries the placement
+            // translation, which this min-corner step recovers.
+            const Vec3d d = model_bb.min - tp_bb.min;
+            belt_inv = Transform3d(Eigen::Translation3d(d)) * belt_inv;
+            BOOST_LOG_TRIVIAL(debug) << "[BELT-PREVIEW] anchor d=[" << d.x() << "," << d.y() << "," << d.z()
+                << "] (clip kept " << n_clip << "/" << n_filtered << " moves)";
+        }
+    }
+    libvgcode::GCodeInputData data = libvgcode::convert(gcode_result, str_tool_colors, str_color_print_colors, m_viewer,
+        apply_belt ? &belt_inv : nullptr);
 
 //#define ENABLE_DATA_EXPORT 1
 //#if ENABLE_DATA_EXPORT
@@ -2303,12 +2451,12 @@ void GCodeViewer::render_toolpaths()
 {
     const Camera& camera = wxGetApp().plater()->get_camera();
     Matrix4f view = camera.get_view_matrix().matrix().cast<float>();
-    // Belt "designed" view: apply the precomputed inverse of the full belt
-    // shear+scale transform so toolpaths appear upright (as originally designed)
-    // instead of transformed on the belt.
-    if (m_belt_show_designed && m_belt_view_enabled) {
-        view = (camera.get_view_matrix() * m_belt_inverse_transform).matrix().cast<float>();
-    }
+    // Belt "designed" (upright) view is produced by back-transforming the toolpath
+    // GEOMETRY into model space at load time (see load_as_gcode ->
+    // compute_belt_back_transform -> libvgcode::convert). The camera is left untouched
+    // here; transforming the view as well would double-apply the inverse. Baking the
+    // transform into the geometry (not the camera) also keeps the bed and toolpaths in
+    // the same frame so they stay aligned.
     const libvgcode::Mat4x4 converted_view_matrix = libvgcode::convert(view);
     const libvgcode::Mat4x4 converted_projetion_matrix = libvgcode::convert(static_cast<Matrix4f>(camera.get_projection_matrix().matrix().cast<float>()));
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
@@ -4702,7 +4850,19 @@ void GCodeViewer::render_legend(float &legend_height, int canvas_width, int canv
         ImGui::TextColored(ImVec4(0.f, 0.59f, 0.53f, 1.f), "%s", _u8L("Belt Printer").c_str());
         ImGui::Dummy({ window_padding, 0 });
         ImGui::SameLine();
-        ImGui::Checkbox(_u8L("Show designed view (upright) [B]").c_str(), &m_belt_show_designed);
+        // Checked = show the raw machine-frame G-code (designed/upright view off). Worded to
+        // match the canvas-toolbar menu item "Show raw G-code (belt only)". m_belt_show_designed
+        // is the inverse of this checkbox, so bind a temporary and flip it on change.
+        bool show_raw = !m_belt_show_designed;
+        if (ImGui::Checkbox(_u8L("Show raw G-code (belt only) [B]").c_str(), &show_raw)) {
+            m_belt_show_designed = !show_raw;
+            // The designed-view back-transform is baked into the toolpath geometry at load
+            // time, so the toggle only takes effect once the preview is re-converted. Defer
+            // the refresh to the next event-loop tick (CallAfter) to avoid re-entering the
+            // preview load from inside legend rendering.
+            if (Plater* plater = wxGetApp().plater())
+                plater->CallAfter([plater]() { plater->refresh_belt_view(); });
+        }
     }
 
     legend_height = ImGui::GetCurrentWindow()->Size.y;

src/slic3r/GUI/GCodeViewer.hpp

@@ -245,8 +245,8 @@ mutable bool m_no_render_path { false };
 
     bool  m_belt_view_enabled = false;
     float m_belt_angle_deg = 0.f;
-    bool  m_belt_show_designed = false;  // Toggle: show designed (upright) view via inverse shear
-    Transform3d m_belt_inverse_transform{Transform3d::Identity()};
+    bool  m_belt_show_designed = true;   // Toggle: designed (upright, back-transformed) view by default;
+                                         // turn off (hotkey B) to inspect the raw machine-frame G-code.
 
     libvgcode::Viewer m_viewer;
     bool m_loaded_as_preview{ false };
@@ -348,7 +348,6 @@ public:
     void export_toolpaths_to_obj(const char* filename) const;
 
     void set_belt_printer(bool enabled, float angle_deg) { m_belt_view_enabled = enabled; m_belt_angle_deg = angle_deg; }
-    void set_belt_inverse_transform(const Transform3d& t) { m_belt_inverse_transform = t; }
     bool is_belt_view() const { return m_belt_view_enabled && m_belt_angle_deg > 0.f; }
     void toggle_belt_show_designed() { if (m_belt_view_enabled) m_belt_show_designed = !m_belt_show_designed; }
     bool is_belt_show_designed() const { return m_belt_show_designed; }

src/slic3r/GUI/GLCanvas3D.cpp

@@ -3512,6 +3512,10 @@ void GLCanvas3D::on_char(wxKeyEvent& evt)
             if (dynamic_cast<Preview*>(m_canvas->GetParent()) != nullptr &&
                 m_gcode_viewer.is_belt_view()) {
                 m_gcode_viewer.toggle_belt_show_designed();
+                // The designed-view back-transform is baked into the toolpath geometry at load
+                // time, so the toggle only takes visual effect once the preview is re-converted.
+                if (Plater* plater = wxGetApp().plater())
+                    plater->refresh_belt_view();
                 m_dirty = true;
             }
             break;
@@ -9190,6 +9194,21 @@ void GLCanvas3D::_render_canvas_toolbar()
             ImGui::TextColored(enable ? ImVec4(1,1,1,1) : ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled), "%s", into_u8(condition ? ImGui::VisibleIcon : ImGui::HiddenIcon).c_str());
         };
 
+        // Belt printers, G-code preview only: toggle the designed (upright) view vs the raw
+        // machine-frame G-code. Same state as hotkey B and the legend checkbox; the reload is
+        // deferred (CallAfter) so the preview is not rebuilt mid-render.
+        if (m_canvas_type == ECanvasType::CanvasPreview && m_gcode_viewer.is_belt_view()) {
+            create_menu_item( _utf8(L("Show raw G-code (belt only)")),
+                true,
+                !m_gcode_viewer.is_belt_show_designed(), // eye lit = raw machine-frame G-code (designed view off)
+                [this, p]{
+                    m_gcode_viewer.toggle_belt_show_designed();
+                    p->CallAfter([p]{ p->refresh_belt_view(); });
+                }
+            );
+            ImGui::Separator();
+        }
+
         create_menu_item( _utf8(L("3D Navigator")),
             m_canvas_type != ECanvasType::CanvasAssembleView, // not work on assembly
             wxGetApp().show_3d_navigator(),

src/slic3r/GUI/GUI_Preview.cpp

@@ -351,6 +351,17 @@ void Preview::reload_print(bool only_gcode)
     m_only_gcode = only_gcode;
 }
 
+void Preview::refresh_belt_view()
+{
+    // Re-run the G-code preview conversion so the belt "designed view" toggle takes effect
+    // (the back-transform is baked into the toolpath geometry in GCodeViewer::load_as_gcode,
+    // and belt printers are exempt from the same-result-id load cache so the re-convert runs).
+    // Reset m_loaded_print to bypass the "already loaded" guard the way reload_print does, but
+    // keep the current layer (Z) range and only-gcode mode so the view doesn't jump on toggle.
+    m_loaded_print = nullptr;
+    load_print(true /*keep_z_range*/, m_only_gcode);
+}
+
 //BBS: always load shell at preview
 void Preview::load_shells(const Print& print, bool force_previewing)
 {

src/slic3r/GUI/GUI_Preview.hpp

@@ -141,6 +141,8 @@ public:
     //BBS: add only gcode mode
     void load_print(bool keep_z_range = false, bool only_gcode = false);
     void reload_print(bool only_gcode = false);
+    // Belt printers: re-convert the G-code preview so the "designed view" toggle takes effect.
+    void refresh_belt_view();
     //BBS: always load shell at preview
     void load_shells(const Print& print, bool force_previewing = false);
     void reset_shells();

src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.cpp

@@ -189,10 +189,22 @@ Slic3r::PrintEstimatedStatistics::ETimeMode convert(const ETimeMode& mode)
 }
 
 GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::vector<std::string>& str_tool_colors,
-    const std::vector<std::string>& str_color_print_colors, const Viewer& viewer)
+    const std::vector<std::string>& str_color_print_colors, const Viewer& viewer,
+    const Slic3r::Transform3d* belt_xform)
 {
     GCodeInputData ret;
 
+    // Belt printers: optionally map each vertex DISPLAY position from machine
+    // (G-code) space back to model/Cartesian space using the general belt
+    // back-transform (handles any mesh rotation + shear + axis remap, not just
+    // 45 deg). Only the rendered position is transformed; layer_id, times and
+    // the volumetric/flow math below keep the original machine-space values.
+    auto xform_pos = [belt_xform](const Slic3r::Vec3f& v) -> Vec3 {
+        if (belt_xform != nullptr)
+            return convert(Slic3r::Vec3f((*belt_xform * v.cast<double>()).cast<float>()));
+        return convert(v);
+    };
+
     // collect tool colors
     ret.tools_colors.reserve(str_tool_colors.size());
     for (const std::string& color : str_tool_colors) {
@@ -221,7 +233,7 @@ GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::ve
                 // equal to the current one with the exception of the position, which should match the previous move position,
                 // and the times, which are set to zero
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
-                const libvgcode::PathVertex vertex = { convert(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
+                const libvgcode::PathVertex vertex = { xform_pos(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
                     curr.mm3_per_mm, curr.fan_speed, curr.temperature, 0.0f, convert(curr.extrusion_role), curr_type,
                     static_cast<uint32_t>(curr.gcode_id), static_cast<uint32_t>(curr.layer_id),
                     static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), { 0.0f, 0.0f },
@@ -229,7 +241,7 @@ GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::ve
                     /* ORCA: Add Acceleration visualization support */ curr.acceleration,
                     /* ORCA: Add Jerk visualization support */ curr.jerk };
 #else
-              const libvgcode::PathVertex vertex = { convert(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
+              const libvgcode::PathVertex vertex = { xform_pos(prev.position), curr.height, curr.width, curr.feedrate, prev.actual_feedrate,
                     curr.mm3_per_mm, curr.fan_speed, curr.temperature, convert(curr.extrusion_role), curr_type,
                     static_cast<uint32_t>(curr.gcode_id), static_cast<uint32_t>(curr.layer_id),
                     static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), { 0.0f, 0.0f },
@@ -242,7 +254,7 @@ GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::ve
         }
 
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
-        const libvgcode::PathVertex vertex = { convert(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
+        const libvgcode::PathVertex vertex = { xform_pos(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
             curr.mm3_per_mm, curr.fan_speed, curr.temperature,
             result.filament_densities[curr.extruder_id] * curr.mm3_per_mm * (curr.position - prev.position).norm(),
             convert(curr.extrusion_role), curr_type, static_cast<uint32_t>(curr.gcode_id), static_cast<uint32_t>(curr.layer_id),
@@ -251,7 +263,7 @@ GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::ve
             /* ORCA: Add Acceleration visualization support */ curr.acceleration,
             /* ORCA: Add Jerk visualization support */ curr.jerk };
 #else
-        const libvgcode::PathVertex vertex = { convert(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
+        const libvgcode::PathVertex vertex = { xform_pos(curr.position), curr.height, curr.width, curr.feedrate, curr.actual_feedrate,
             curr.mm3_per_mm, curr.fan_speed, curr.temperature, convert(curr.extrusion_role), curr_type,
             static_cast<uint32_t>(curr.gcode_id), static_cast<uint32_t>(curr.layer_id),
             static_cast<uint8_t>(curr.extruder_id), static_cast<uint8_t>(curr.cp_color_id), curr.time,
@@ -263,6 +275,11 @@ GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::ve
     }
     ret.vertices.shrink_to_fit();
 
+    // Note: the belt designed-view anchoring (recovering the per-object placement/
+    // lift translation the linear back-transform cannot) is folded into belt_xform
+    // by the caller (GCodeViewer::load_as_gcode), which anchors onto the upright
+    // model bounding box. Nothing extra to do here.
+
     ret.spiral_vase_mode = result.spiral_vase_mode;
 
     return ret;

src/slic3r/GUI/LibVGCode/LibVGCodeWrapper.hpp

@@ -71,7 +71,8 @@ extern Slic3r::PrintEstimatedStatistics::ETimeMode convert(const ETimeMode& mode
 
 // mapping from Slic3r::GCodeProcessorResult to libvgcode::GCodeInputData
 extern GCodeInputData convert(const Slic3r::GCodeProcessorResult& result, const std::vector<std::string>& str_tool_colors,
-    const std::vector<std::string>& str_color_print_colors, const Viewer& viewer);
+    const std::vector<std::string>& str_color_print_colors, const Viewer& viewer,
+    const Slic3r::Transform3d* belt_xform = nullptr);
 
 // mapping from Slic3r::Print to libvgcode::GCodeInputData
 extern GCodeInputData convert(const Slic3r::Print& print, const std::vector<std::string>& str_tool_colors,

src/slic3r/GUI/Plater.cpp

@@ -11381,31 +11381,13 @@ void Plater::priv::set_bed_shape(const Pointfs       &shape,
             bed.set_belt_printer(true, static_cast<float>(belt_angle), tilt_axis);
             if (preview)
                 preview->get_canvas3d()->get_gcode_viewer().set_belt_printer(true, static_cast<float>(belt_angle));
-
-            // Compute the inverse of the mesh-side belt transform for the G-code
-            // viewer.  The sole mesh transform is the slicing rotation; build its
-            // matrix from config and hand the viewer its inverse (rotation is
-            // orthogonal, so the inverse is the transpose).
-            Transform3d forward = Transform3d::Identity();
-            if (rot_axis != BeltRotationAxis::None && std::abs(rot_angle) > EPSILON) {
-                Vec3d unit_axis = Vec3d::UnitX();
-                switch (rot_axis) {
-                case BeltRotationAxis::X: unit_axis = Vec3d::UnitX(); break;
-                case BeltRotationAxis::Y: unit_axis = Vec3d::UnitY(); break;
-                case BeltRotationAxis::Z: unit_axis = Vec3d::UnitZ(); break;
-                default: break;
-                }
-                forward.linear() = Eigen::AngleAxisd(Geometry::deg2rad(rot_angle), unit_axis).toRotationMatrix();
-            }
-            Transform3d inverse = forward.inverse();
-            if (preview)
-                preview->get_canvas3d()->get_gcode_viewer().set_belt_inverse_transform(inverse);
+            // The belt "designed view" back-transform is rebuilt from the print config at
+            // G-code load time (GCodeViewer::compute_belt_back_transform), so no mesh-side
+            // inverse needs to be pushed to the viewer here.
         } else {
             bed.set_belt_printer(false, 0.f);
-            if (preview) {
+            if (preview)
                 preview->get_canvas3d()->get_gcode_viewer().set_belt_printer(false, 0.f);
-                preview->get_canvas3d()->get_gcode_viewer().set_belt_inverse_transform(Transform3d::Identity());
-            }
         }
     }
 
@@ -14166,6 +14148,11 @@ void Plater::reload_print()
     p->preview->reload_print();
 }
 
+void Plater::refresh_belt_view()
+{
+    p->preview->refresh_belt_view();
+}
+
 // BBS
 wxString Plater::get_project_name()
 {

src/slic3r/GUI/Plater.hpp

@@ -329,6 +329,10 @@ public:
     void load_gcode(const wxString& filename);
     void reload_gcode_from_disk();
     void reload_print();
+    // Belt printers: re-run the G-code preview conversion so the "designed view" toggle
+    // (hotkey B / legend checkbox) takes effect; the back-transform is applied to the
+    // toolpath geometry at load time. Keeps the current layer range and only-gcode mode.
+    void refresh_belt_view();
 
     // SoftFever
     void calib_pa(const Calib_Params& params);