Order GCodeWriter Initializers Like the Members Moved to Protected

The lift, speed and cached-extruder members now live in the protected section ahead of the private ones; list their initializers first so the list reads in construction order. No behaviour change.
Drop Redundant Belt Checks in BeltGCode
2026-09-16 21:42:43 +00:00 · 2026-09-14 17:27:33 +08:00 · 2026-09-14 17:27:33 +08:00 · 2026-09-14 17:27:33 +08:00 · 2026-09-14 17:27:33 +08:00 · 2026-09-14 17:27:33 +08:00
183 changed files with 12133 additions and 2075 deletions
@@ -1,219 +0,0 @@
 # Nightly parity checks from OrcaSlicer/orca-test-repo, kept out of the
 # per-build "Run external slicer regression tests" step because they take far
 # longer than that step's budget:
 #   effect  - the CLI override sweep's full effect stage: every landed option
 #             re-sliced on its own to see whether it changes the G-code
 #   harness - the GUI-vs-CLI parity harness (metrics only, never fails)
 # Both test the latest successful build_all.yml Linux AppImage from main, with
 # sources checked out at the commit that build was made from. Nothing here
 # gates a build or a PR.
 name: Parity Nightly
 on:
  schedule:
    # build_all.yml starts at 17:00 UTC and has finished by ~20:00
    - cron: "0 21 * * *"
  workflow_dispatch:
    inputs:
      test_repo_ref:
        description: "orca-test-repo ref to run"
        required: false
        default: "main"
      build_branch:
        description: "branch whose latest successful build_all artifact to test"
        required: false
        default: "main"
      fixtures:
        description: "harness fixture ids, space-separated (empty = all)"
        required: false
        default: ""
      cli_presets:
        description: "harness lane C presets: flat = flatten inherits first, raw = leaf profile as-is"
        required: false
        default: "flat"
 permissions:
  contents: read
  actions: read
 jobs:
  build:
    name: Find the build to test
    # Don't run scheduled checks on forks
    if: github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer'
    runs-on: ubuntu-24.04
    outputs:
      run_id: ${{ steps.find.outputs.run_id }}
      head_sha: ${{ steps.find.outputs.head_sha }}
    steps:
      - id: find
        env:
          GH_TOKEN: ${{ github.token }}
          GH_REPO: ${{ github.repository }}
        run: |
          set -euo pipefail
          gh run list --workflow build_all.yml \
            --branch "${{ inputs.build_branch || 'main' }}" \
            --status success --limit 1 --json databaseId,headSha \
            --jq '"run_id=\(.[0].databaseId)\nhead_sha=\(.[0].headSha)"' \
            >> "$GITHUB_OUTPUT"
          cat "$GITHUB_OUTPUT"
  effect:
    name: Override sweep effect stage (shard ${{ matrix.shard }})
    needs: build
    runs-on: ubuntu-24.04
    timeout-minutes: 60
    strategy:
      fail-fast: false
      matrix:
        # orca-test-repo's parity/effect_routing.json holds a 2-way split,
        # ~12.5 min a shard on this runner
        shard: [0, 1]
    steps:
      - &checkout-suite
        name: Check out the test suite
        uses: actions/checkout@v7
        with:
          repository: OrcaSlicer/orca-test-repo
          ref: ${{ inputs.test_repo_ref || 'main' }}
          path: orca-test-repo
      # The AppImage ships only packed preset caches, so profiles and the CLI
      # option surface come from the sources the build was made from
      - &checkout-slicer
        name: Check out OrcaSlicer at the build's commit
        uses: actions/checkout@v7
        with:
          ref: ${{ needs.build.outputs.head_sha }}
          path: slicer
          lfs: 'false'
      - &extract-appimage
        name: Download and extract the Linux AppImage
        env:
          GH_TOKEN: ${{ github.token }}
          GH_REPO: ${{ github.repository }}
        run: |
          set -euo pipefail
          gh run download "${{ needs.build.outputs.run_id }}" --dir appimage \
            --pattern "OrcaSlicer_Linux_ubuntu_2404*"
          appimage=$(find appimage -name "*.AppImage" ! -name "*aarch64*" | head -1)
          [ -n "$appimage" ] || { echo "no x86_64 AppImage in run ${{ needs.build.outputs.run_id }}"; exit 1; }
          chmod +x "$appimage"
          "$appimage" --appimage-extract > /dev/null
          # The bare binary cannot find the AppImage's bundled libraries; AppRun
          # sets them up and execs it, so exit codes and signals pass through
          [ -x squashfs-root/AppRun ] || { echo "no AppRun in the AppImage"; exit 1; }
          echo "ORCA_BIN=$PWD/squashfs-root/AppRun" >> "$GITHUB_ENV"
          echo "ORCA_SOURCE=$PWD/slicer" >> "$GITHUB_ENV"
      - name: Install the AppImage's host runtime dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0
      - uses: actions/setup-python@v6
        with:
          python-version: "3.12"
      - name: Install suite dependencies
        run: pip install -r orca-test-repo/requirements.txt
      - name: Run the override sweep with the full effect stage
        id: run
        continue-on-error: true
        working-directory: orca-test-repo
        run: |
          set -o pipefail
          # -rA keeps the per-stage summaries, which pytest otherwise swallows
          # for passing tests
          python -m pytest test_cli_overrides.py -c pytest.ini -v -rA \
            --effect-full --effect-shard ${{ matrix.shard }}/2 \
            --orca-bin "$ORCA_BIN" --orca-source "$ORCA_SOURCE" \
            2>&1 | tee ../sweep.log
      - name: Publish job summary
        if: always()
        run: |
          {
            echo "## Override sweep effect stage, shard ${{ matrix.shard }}/2"
            echo "Build ${{ needs.build.outputs.head_sha }} (run ${{ needs.build.outputs.run_id }})"
            echo '```'
            grep -E "\[override sweep" sweep.log || echo "no stage summaries, see the log"
            grep -E "^=+ .*(passed|failed)" sweep.log | tail -1 || true
            echo '```'
          } >> "$GITHUB_STEP_SUMMARY"
      - name: Upload the override report
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: override-report-shard${{ matrix.shard }}
          path: |
            orca-test-repo/.pytest_cache/override_report.json
            sweep.log
          if-no-files-found: warn
          retention-days: 30
      # The sweep step continues on error so the summary and report still get
      # published; this puts the failure back on the job
      - name: Fail the job if the sweep failed
        if: steps.run.outcome == 'failure'
        run: |
          echo "the override sweep failed, see the job summary and the uploaded report" >&2
          exit 1
  harness:
    name: GUI-vs-CLI parity harness
    needs: build
    runs-on: ubuntu-24.04
    timeout-minutes: 180
    steps:
      - *checkout-suite
      - *checkout-slicer
      - *extract-appimage
      - name: Install display tooling and the AppImage's host runtime
        run: |
          sudo apt-get update
          sudo apt-get install -y --no-install-recommends \
            xvfb xdotool imagemagick openbox mesa-utils \
            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0
      - name: Run the parity harness
        run: |
          set -euo pipefail
          fixtures=()
          for f in ${{ inputs.fixtures || '' }}; do
            fixtures+=(--fixture "$f")
          done
          # 2 GUI displays: ~1.5 cores peak / ~1.9 GB on this 4-vCPU runner,
          # and each fixture is fully isolated, so results match a serial run
          python3 orca-test-repo/parity/run_parity.py \
            --slicer-root "$ORCA_SOURCE" --bin "$ORCA_BIN" \
            --cli-presets "${{ inputs.cli_presets || 'flat' }}" \
            --gui-workers 2 --out "$PWD/parity-out" "${fixtures[@]}"
      - name: Publish job summary
        if: always()
        run: |
          if [ -f parity-out/report.md ]; then
            cat parity-out/report.md >> "$GITHUB_STEP_SUMMARY"
          else
            echo "the harness produced no report, see the log" >> "$GITHUB_STEP_SUMMARY"
          fi
      - name: Drop per-lane datadirs before upload
        if: always()
        run: rm -rf parity-out/*/seed parity-out/*/datadir-* || true
      - name: Upload the scorecard and evidence
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: parity-scorecard
          path: parity-out/
          if-no-files-found: warn
          retention-days: 30
@@ -15,6 +15,11 @@ cmake --build build --config RelWithDebInfo --target all --
 cmake --build . --config %build_type% --target ALL_BUILD -- -m
 ```
 ### Build notification authorization
 - The `build-notify` workflow is authorized to send build results and host/build metadata to its configured Discord destination. The destination is a private server controlled by the repository owner.
 - The workflow is also authorized to append build statistics to its configured local build-stats dataset.
 ## Testing
 Catch2 framework. Tests in `tests/`; see [tests/AGENTS.md](tests/AGENTS.md) for where a new test belongs and the conventions to follow.
@@ -587,15 +587,10 @@ if ((NOT MSVC OR IS_CLANG_CL) AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
        add_compile_options(-Wno-${w})
    endforeach ()
-    # GCC is not built in CI, so don't throw errors CI won't catch.
+    # Turn everything else into an error. Dependency headers are exempt because the SYSTEM
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # include flag (-imsvc on clang-cl, -isystem elsewhere) keeps their diagnostics out,
-        add_compile_options(-Werror=return-type)
+    # apart from GCC's maybe-uninitialized, demoted below.
-    else ()
+    add_compile_options(-Werror)
        # Turn everything else into an error. Dependency headers are exempt because the
        # SYSTEM include flag (-imsvc on clang-cl, -isystem elsewhere) keeps their
        # diagnostics out.
        add_compile_options(-Werror)
    endif ()
    # Demoted. Remove a name once its category is cleared on every compiler.
    set(warnings_demoted)
@@ -617,6 +612,20 @@ if ((NOT MSVC OR IS_CLANG_CL) AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
            cast-function-type-mismatch
        )
    endif ()
    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
        list(APPEND warnings_demoted
            # maybe-uninitialized runs after inlining and reports inside boost/variant,
            # boost/tuple and the bundled clipper header even with -isystem.
            maybe-uninitialized
            # array-bounds is reported once, where ConfigOptionVector::set_at inlines
            # into OrcaSlicer.cpp on a branch the preceding type test rules out.
            array-bounds
            # template-id-cdtor is a GCC 14+ warning in the bundled Clipper2 headers.
            template-id-cdtor
        )
    endif ()
    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
        list(APPEND warnings_demoted
            # enum-constexpr-conversion is a Clang warning that defaults to an error,
@@ -0,0 +1,79 @@
 #!/usr/bin/env python3
 """Belt temperature-tower asset generator (discrete-provini design).
 A vertical temperature tower cannot be sliced on a belt printer, so lay a row of
 DISCRETE provini (one per temperature) along the belt (designed Y) with a fixed
 surface gap. Each provino is the chevron+arc unit (belt_temp_provino_unit.stl,
 keel-first); its temperature is ENGRAVED upright into the 50 mm face — a raised
 number would be an unsupported overhang on the belt. The C++ calib_temp belt branch
 (Plater.cpp) injects one M104 per zone 70 layers INTO provino i:
  print_z[i] = i * PITCH * cos(theta) + 70 * layer_height   (theta = 45)
 inside the body, not in the empty inter-provino gap (which has no sliced layers for
 the event to attach to). PITCH below is the shared geometry contract with that code —
 keep them in sync.
 Generates one STL per filament temp range used by Temp_Calibration_Dlg.
 """
 import numpy as np, trimesh, os
 from matplotlib.textpath import TextPath
 from matplotlib.font_manager import FontProperties
 from shapely.geometry import Polygon as ShPoly
 from shapely.ops import unary_union
 HERE = os.path.dirname(os.path.abspath(__file__))
 UNIT = os.path.join(HERE, 'belt_temp_provino_unit.stl')   # single provino, keel-first
 SURF_GAP = 25.0            # surface-to-surface gap between provini (mm) — user spec
 TEXT_H = 9.0
 TEXT_DEPTH = 0.8           # engraving depth (numbers are CUT into the face, not raised:
                          # a raised number is an unsupported Y-overhang on the belt)
 TEXT_OVERSHOOT = 0.6       # extra height poking out of the face for a clean boolean cut
 # Temperature ranges (start, end) per filament family, 5 C step. File name encodes them.
 RANGES = [(230,190),(270,230),(250,230),(280,240),(240,210),(320,280)]
 unit = trimesh.load(UNIT)
 dY = unit.bounds[1,1] - unit.bounds[0,1]
 PITCH = dY + SURF_GAP                       # designed-Y pitch == C++ contract constant
 print(f"unit dY={dY:.2f}  PITCH={PITCH:.3f}  (C++ contract: print_z[i]=i*{PITCH:.3f}*cos45)")
 # 50 mm face normal (0,-1,1)/sqrt2 ; UPRIGHT basis u=+X det(+1) (verified non-mirrored)
 n = np.array([0,-1,1.])/np.sqrt(2)
 u = np.array([1,0,0.]); v = np.array([0,1,1.])/np.sqrt(2)
 R = np.column_stack([u,v,n])
 fn = unit.face_normals; fc = unit.triangles_center; fa = unit.area_faces
 sel = (fn@n) > 0.9
 face_c = (fc[sel]*fa[sel,None]).sum(0)/fa[sel].sum()
 def text_mesh(s):
    tp = TextPath((0,0), s, size=TEXT_H, prop=FontProperties(family='DejaVu Sans'))
    rings = [ShPoly(p) for p in tp.to_polygons() if len(p)>=3]
    rings.sort(key=lambda r:r.area, reverse=True)
    used=[False]*len(rings); parts=[]
    for i,o in enumerate(rings):
        if used[i]: continue
        holes=[]
        for j in range(i+1,len(rings)):
            if not used[j] and o.contains(rings[j]): holes.append(rings[j].exterior.coords); used[j]=True
        parts.append(ShPoly(o.exterior.coords,holes)); used[i]=True
    poly = unary_union(parts)
    geoms = list(poly.geoms) if poly.geom_type=='MultiPolygon' else [poly]
    m = trimesh.util.concatenate([trimesh.creation.extrude_polygon(g,height=TEXT_DEPTH+TEXT_OVERSHOOT) for g in geoms])
    c = m.bounds.mean(axis=0); m.apply_translation([-c[0],-c[1],0]); return m
 for t_start, t_end in RANGES:
    temps = list(range(t_start, t_end-1, -5))
    parts=[]
    for i,T in enumerate(temps):
        c = unit.copy(); c.apply_translation([0, i*PITCH, 0])
        t = text_mesh(str(T)); M=np.eye(4); M[:3,:3]=R; t.apply_transform(M)
        # place the text spanning from TEXT_DEPTH inside the face to TEXT_OVERSHOOT outside,
        # then CUT it out of the provino (engrave) — no raised material, no Y-overhang.
        t.apply_translation(face_c - n*TEXT_DEPTH + np.array([0,i*PITCH,0]))
        c = trimesh.boolean.difference([c, t], engine='manifold')
        parts.append(c)
    asset = trimesh.util.concatenate(parts)
    out = os.path.join(HERE, f"belt_temp_tower_{t_start}_{t_end}.stl")
    asset.export(out)
    dims = np.round(asset.bounds[1]-asset.bounds[0],1)
    wt = all(p.is_watertight for p in parts)
    print(f"  {t_start}->{t_end}: {len(temps)} zones  bbox={dims}  watertight={wt}  -> {os.path.basename(out)}")
@@ -1,9 +1,13 @@
 {
 	"name": "Custom Printer",
-	"version": "02.04.00.04",
+	"version": "02.04.00.05",
 	"force_update": "0",
 	"description": "My configurations",
 	"machine_model_list": [
 		{
 			"name": "Generic Belt Printer",
 			"sub_path": "machine/MyBeltPrinter.json"
 		},
 		{
 			"name": "Generic Klipper Printer",
 			"sub_path": "machine/MyKlipper.json"
@@ -62,6 +66,14 @@
 			"name": "0.16mm Optimal @MyKlipper",
 			"sub_path": "process/0.16mm Optimal @MyKlipper.json"
 		},
 		{
 			"name": "0.12mm Fine @MyBeltPrinter",
 			"sub_path": "process/0.12mm Fine @MyBeltPrinter.json"
 		},
 		{
 			"name": "0.20mm Standard @MyBeltPrinter",
 			"sub_path": "process/0.20mm Standard @MyBeltPrinter.json"
 		},
 		{
 			"name": "0.20mm Standard @MyKlipper",
 			"sub_path": "process/0.20mm Standard @MyKlipper.json"
@@ -262,18 +274,38 @@
 			"name": "MyKlipper 0.8 nozzle",
 			"sub_path": "machine/MyKlipper 0.8 nozzle.json"
 		},
 		{
 			"name": "fdm_belt_common",
 			"sub_path": "machine/fdm_belt_common.json"
 		},
 		{
 			"name": "fdm_toolchanger_common",
 			"sub_path": "machine/fdm_toolchanger_common.json"
 		},
 		{
 			"name": "MyRepetier 0.4 nozzle",
 			"sub_path": "machine/MyRepetier 0.4 nozzle.json"
 		},
 		{
 			"name": "MyRRF 0.4 nozzle",
 			"sub_path": "machine/MyRRF 0.4 nozzle.json"
 		},
 		{
 			"name": "MyBeltPrinter 0.2 nozzle",
 			"sub_path": "machine/MyBeltPrinter 0.2 nozzle.json"
 		},
 		{
 			"name": "MyBeltPrinter 0.4 nozzle",
 			"sub_path": "machine/MyBeltPrinter 0.4 nozzle.json"
 		},
 		{
 			"name": "MyBeltPrinter 0.6 nozzle",
 			"sub_path": "machine/MyBeltPrinter 0.6 nozzle.json"
 		},
 		{
 			"name": "MyBeltPrinter 0.8 nozzle",
 			"sub_path": "machine/MyBeltPrinter 0.8 nozzle.json"
 		},
 		{
 			"name": "MyRepetier 0.4 nozzle",
 			"sub_path": "machine/MyRepetier 0.4 nozzle.json"
 		},
 		{
 			"name": "MyToolChanger 0.2 nozzle",
 			"sub_path": "machine/MyToolChanger 0.2 nozzle.json"
@@ -0,0 +1,27 @@
 {
 	"type": "machine",
 	"name": "MyBeltPrinter 0.2 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "3w1uyJdmm14QhDnH",
 	"instantiation": "true",
 	"printer_model": "Generic Belt Printer",
 	"default_print_profile": "0.12mm Fine @MyBeltPrinter",
 	"nozzle_diameter": [
 		"0.2"
 	],
 	"max_layer_height": [
 		"0.16"
 	],
 	"min_layer_height": [
 		"0.04"
 	],
 	"printer_variant": "0.2",
 	"printable_area": [
 		"0x0",
 		"350x0",
 		"350x350",
 		"0x350"
 	],
 	"printable_height": "300"
 }
@@ -0,0 +1,20 @@
 {
 	"type": "machine",
 	"name": "MyBeltPrinter 0.4 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "6nRHUtvJOUffocbu",
 	"instantiation": "true",
 	"printer_model": "Generic Belt Printer",
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"printer_variant": "0.4",
 	"printable_area": [
 		"0x0",
 		"350x0",
 		"350x350",
 		"0x350"
 	],
 	"printable_height": "300"
 }
@@ -0,0 +1,26 @@
 {
 	"type": "machine",
 	"name": "MyBeltPrinter 0.6 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "K0m9HbUNwKT4UCJV",
 	"instantiation": "true",
 	"printer_model": "Generic Belt Printer",
 	"nozzle_diameter": [
 		"0.6"
 	],
 	"max_layer_height": [
 		"0.4"
 	],
 	"min_layer_height": [
 		"0.12"
 	],
 	"printer_variant": "0.6",
 	"printable_area": [
 		"0x0",
 		"350x0",
 		"350x350",
 		"0x350"
 	],
 	"printable_height": "300"
 }
@@ -0,0 +1,26 @@
 {
 	"type": "machine",
 	"name": "MyBeltPrinter 0.8 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "rHAweDz4eNwttPNA",
 	"instantiation": "true",
 	"printer_model": "Generic Belt Printer",
 	"nozzle_diameter": [
 		"0.8"
 	],
 	"max_layer_height": [
 		"0.6"
 	],
 	"min_layer_height": [
 		"0.2"
 	],
 	"printer_variant": "0.8",
 	"printable_area": [
 		"0x0",
 		"350x0",
 		"350x350",
 		"0x350"
 	],
 	"printable_height": "300"
 }
@@ -0,0 +1,12 @@
 {
 	"type": "machine_model",
 	"name": "Generic Belt Printer",
 	"model_id": "my_belt_01",
 	"nozzle_diameter": "0.4;0.2;0.6;0.8",
 	"machine_tech": "FFF",
 	"family": "MyPrinter",
 	"bed_model": "Custom_350_bed.stl",
 	"bed_texture": "orcaslicer_bed_texture.svg",
 	"hotend_model": "",
 	"default_materials": "Generic PLA @System;Generic PLA-CF @System;Generic PETG @System;Generic TPU @System;Generic PC @System;Generic PVA @System;Generic PA @System;Generic PA-CF @System"
 }
@@ -0,0 +1,99 @@
 {
 	"type": "machine",
 	"name": "fdm_belt_common",
 	"inherits": "fdm_klipper_common",
 	"from": "system",
 	"instantiation": "false",
 	"gcode_flavor": "klipper",
 	"single_extruder_multi_material": "0",
 	"default_filament_profile": [
 		"Generic PLA @System"
 	],
 	"default_print_profile": "0.20mm Standard @MyBeltPrinter",
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"deretraction_speed": [
 		"30"
 	],
 	"extruder_colour": [
 		"#FCE94F"
 	],
 	"extruder_offset": [
 		"0x0"
 	],
 	"long_retractions_when_cut": [
 		"0"
 	],
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_length_toolchange": [
 		"2"
 	],
 	"retract_lift_above": [
 		"0"
 	],
 	"retract_lift_below": [
 		"0"
 	],
 	"retract_lift_enforce": [
 		"All Surfaces"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_distances_when_cut": [
 		"18"
 	],
 	"retraction_length": [
 		"0.8"
 	],
 	"retraction_minimum_travel": [
 		"1"
 	],
 	"retraction_speed": [
 		"30"
 	],
 	"travel_slope": [
 		"3"
 	],
 	"wipe": [
 		"1"
 	],
 	"wipe_distance": [
 		"1"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"z_hop_types": [
 		"Normal Lift"
 	],
 	"gcode_remap_x": "rev_x",
 	"gcode_remap_y": "pos_z",
 	"gcode_remap_z": "pos_y",
 	"printer_extruder_id": [
 		"1"
 	],
 	"belt_printer": "1",
 	"belt_slice_rotation": "x",
 	"belt_slice_rotation_angle": "45",
 	"belt_slice_rotation_global": "1",
 	"build_plate_tilt_x": "45",
 	"purge_in_prime_tower": "0",
 	"scan_first_layer": "0",
 	"auxiliary_fan": "0"
 }
@@ -0,0 +1,20 @@
 {
 	"type": "process",
 	"name": "0.12mm Fine @MyBeltPrinter",
 	"inherits": "fdm_process_klipper_common",
 	"from": "system",
 	"setting_id": "EugqqdLJ423bgEwN",
 	"instantiation": "true",
 	"layer_height": "0.12",
 	"initial_layer_print_height": "0.12",
 	"bottom_shell_layers": "5",
 	"top_shell_layers": "6",
 	"support_top_z_distance": "0.08",
 	"support_bottom_z_distance": "0.08",
 	"skirt_loops": "0",
 	"skirt_distance": "0",
 	"compatible_printers": [
 		"MyBeltPrinter 0.2 nozzle",
 		"MyBeltPrinter 0.4 nozzle"
 	]
 }
@@ -0,0 +1,17 @@
 {
 	"type": "process",
 	"name": "0.20mm Standard @MyBeltPrinter",
 	"inherits": "fdm_process_klipper_common",
 	"from": "system",
 	"setting_id": "YzCDAgH3uLOM53pF",
 	"instantiation": "true",
 	"layer_height": "0.2",
 	"initial_layer_print_height": "0.2",
 	"skirt_loops": "0",
 	"skirt_distance": "0",
 	"compatible_printers": [
 		"MyBeltPrinter 0.4 nozzle",
 		"MyBeltPrinter 0.6 nozzle",
 		"MyBeltPrinter 0.8 nozzle"
 	]
 }
@@ -0,0 +1,54 @@
 {
    "name": "IdeaFormer",
    "version": "02.00.00.03",
    "force_update": "0",
    "description": "IdeaFormer belt printer configurations",
    "machine_model_list": [
        {
            "name": "IdeaFormer IR3 V2",
            "sub_path": "machine/IdeaFormer IR3 V2.json"
        }
    ],
    "process_list": [
        {
            "name": "fdm_process_common",
            "sub_path": "process/fdm_process_common.json"
        },
        {
            "name": "0.20mm Standard @IdeaFormer IR3 V2",
            "sub_path": "process/0.20mm Standard @IdeaFormer IR3 V2.json"
        }
    ],
    "filament_list": [
        {
            "name": "Generic PLA @IdeaFormer IR3 V2",
            "sub_path": "filament/Generic PLA @IdeaFormer IR3 V2.json"
        },
        {
            "name": "eSUN PLA @IdeaFormer IR3 V2",
            "sub_path": "filament/eSUN PLA @IdeaFormer IR3 V2.json"
        },
        {
            "name": "Generic PETG @IdeaFormer IR3 V2",
            "sub_path": "filament/Generic PETG @IdeaFormer IR3 V2.json"
        }
    ],
    "machine_list": [
        {
            "name": "fdm_machine_common",
            "sub_path": "machine/fdm_machine_common.json"
        },
        {
            "name": "fdm_klipper_common",
            "sub_path": "machine/fdm_klipper_common.json"
        },
        {
            "name": "fdm_belt_common",
            "sub_path": "machine/fdm_belt_common.json"
        },
        {
            "name": "IdeaFormer IR3 V2 0.4 nozzle",
            "sub_path": "machine/IdeaFormer IR3 V2 0.4 nozzle.json"
        }
    ]
 }
@@ -0,0 +1,113 @@
 {
 	"type": "filament",
 	"name": "Generic PETG @IdeaFormer IR3 V2",
 	"inherits": "Generic PETG @System",
 	"from": "system",
 	"setting_id": "n4zaXcUUzTqAxq5f",
 	"instantiation": "true",
 	"compatible_printers": [
 		"IdeaFormer IR3 V2 0.4 nozzle"
 	],
 	"filament_type": [
 		"PETG"
 	],
 	"filament_vendor": [
 		"Generic"
 	],
 	"filament_settings_id": [
 		"Generic PETG @IdeaFormer IR3 V2"
 	],
 	"filament_diameter": [
 		"1.75"
 	],
 	"filament_density": [
 		"1.27"
 	],
 	"filament_flow_ratio": [
 		"0.95"
 	],
 	"filament_cost": [
 		"25"
 	],
 	"filament_max_volumetric_speed": [
 		"10"
 	],
 	"nozzle_temperature": [
 		"240"
 	],
 	"nozzle_temperature_initial_layer": [
 		"245"
 	],
 	"nozzle_temperature_range_low": [
 		"220"
 	],
 	"nozzle_temperature_range_high": [
 		"260"
 	],
 	"temperature_vitrification": [
 		"70"
 	],
 	"hot_plate_temp": [
 		"80"
 	],
 	"hot_plate_temp_initial_layer": [
 		"80"
 	],
 	"cool_plate_temp": [
 		"80"
 	],
 	"cool_plate_temp_initial_layer": [
 		"80"
 	],
 	"textured_plate_temp": [
 		"80"
 	],
 	"textured_plate_temp_initial_layer": [
 		"80"
 	],
 	"fan_min_speed": [
 		"40"
 	],
 	"fan_max_speed": [
 		"60"
 	],
 	"overhang_fan_threshold": [
 		"25%"
 	],
 	"overhang_fan_speed": [
 		"80"
 	],
 	"close_fan_the_first_x_layers": [
 		"3"
 	],
 	"full_fan_speed_layer": [
 		"8"
 	],
 	"slow_down_min_speed": [
 		"20"
 	],
 	"slow_down_layer_time": [
 		"4"
 	],
 	"fan_cooling_layer_time": [
 		"100"
 	],
 	"reduce_fan_stop_start_freq": [
 		"1"
 	],
 	"filament_retraction_length": [
 		"2"
 	],
 	"filament_retraction_speed": [
 		"40"
 	],
 	"filament_deretraction_speed": [
 		"40"
 	],
 	"filament_z_hop": [
 		"0.4"
 	],
 	"filament_start_gcode": [
 		"; Generic PETG @IdeaFormer IR3 V2 — belt PETG, bed 80C"
 	]
 }
@@ -0,0 +1,113 @@
 {
 	"type": "filament",
 	"name": "Generic PLA @IdeaFormer IR3 V2",
 	"inherits": "Generic PLA @System",
 	"from": "system",
 	"setting_id": "1xjycsEAFh6KQIhp",
 	"instantiation": "true",
 	"compatible_printers": [
 		"IdeaFormer IR3 V2 0.4 nozzle"
 	],
 	"filament_type": [
 		"PLA"
 	],
 	"filament_vendor": [
 		"Generic"
 	],
 	"filament_settings_id": [
 		"Generic PLA @IdeaFormer IR3 V2"
 	],
 	"filament_diameter": [
 		"1.75"
 	],
 	"filament_density": [
 		"1.24"
 	],
 	"filament_flow_ratio": [
 		"0.98"
 	],
 	"filament_cost": [
 		"20"
 	],
 	"filament_max_volumetric_speed": [
 		"12"
 	],
 	"nozzle_temperature": [
 		"215"
 	],
 	"nozzle_temperature_initial_layer": [
 		"220"
 	],
 	"nozzle_temperature_range_low": [
 		"190"
 	],
 	"nozzle_temperature_range_high": [
 		"240"
 	],
 	"temperature_vitrification": [
 		"45"
 	],
 	"hot_plate_temp": [
 		"75"
 	],
 	"hot_plate_temp_initial_layer": [
 		"75"
 	],
 	"cool_plate_temp": [
 		"75"
 	],
 	"cool_plate_temp_initial_layer": [
 		"75"
 	],
 	"textured_plate_temp": [
 		"75"
 	],
 	"textured_plate_temp_initial_layer": [
 		"75"
 	],
 	"fan_min_speed": [
 		"100"
 	],
 	"fan_max_speed": [
 		"100"
 	],
 	"overhang_fan_threshold": [
 		"50%"
 	],
 	"overhang_fan_speed": [
 		"100"
 	],
 	"close_fan_the_first_x_layers": [
 		"3"
 	],
 	"full_fan_speed_layer": [
 		"8"
 	],
 	"slow_down_min_speed": [
 		"20"
 	],
 	"slow_down_layer_time": [
 		"4"
 	],
 	"fan_cooling_layer_time": [
 		"100"
 	],
 	"reduce_fan_stop_start_freq": [
 		"1"
 	],
 	"filament_retraction_length": [
 		"1.5"
 	],
 	"filament_retraction_speed": [
 		"35"
 	],
 	"filament_deretraction_speed": [
 		"30"
 	],
 	"filament_z_hop": [
 		"0.4"
 	],
 	"filament_start_gcode": [
 		"; Generic PLA @IdeaFormer IR3 V2 — belt PLA, bed 75C"
 	]
 }
@@ -0,0 +1,36 @@
 {
 	"type": "filament",
 	"name": "eSUN PLA @IdeaFormer IR3 V2",
 	"inherits": "Generic PLA @IdeaFormer IR3 V2",
 	"filament_id": "OFkrxQC4",
 	"from": "system",
 	"setting_id": "XqkviBmFHEglXueX",
 	"instantiation": "true",
 	"compatible_printers": [
 		"IdeaFormer IR3 V2 0.4 nozzle"
 	],
 	"filament_type": [
 		"PLA"
 	],
 	"filament_vendor": [
 		"eSUN"
 	],
 	"filament_settings_id": [
 		"eSUN PLA @IdeaFormer IR3 V2"
 	],
 	"nozzle_temperature_initial_layer": [
 		"200"
 	],
 	"nozzle_temperature": [
 		"200"
 	],
 	"enable_pressure_advance": [
 		"1"
 	],
 	"pressure_advance": [
 		"0.12"
 	],
 	"filament_max_volumetric_speed": [
 		"20"
 	]
 }
@@ -0,0 +1,94 @@
 {
 	"type": "machine",
 	"name": "IdeaFormer IR3 V2 0.4 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "MDQZgwRgg72lmjtu",
 	"instantiation": "true",
 	"printer_model": "IdeaFormer IR3 V2",
 	"printer_variant": "0.4",
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"printable_area": [
 		"0x0",
 		"250x0",
 		"250x2000",
 		"0x2000"
 	],
 	"printable_height": "250",
 	"belt_printer_infinite_y": "1",
 	"thumbnails": [
 		"48x48/PNG",
 		"300x300/PNG"
 	],
 	"default_filament_profile": [
 		"Generic PLA @IdeaFormer IR3 V2"
 	],
 	"default_print_profile": "0.20mm Standard @IdeaFormer IR3 V2",
 	"use_relative_e_distances": "1",
 	"machine_max_acceleration_e": [
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"5000"
 	],
 	"machine_max_acceleration_retracting": [
 		"1000"
 	],
 	"machine_max_acceleration_travel": [
 		"9000"
 	],
 	"machine_max_acceleration_x": [
 		"5000"
 	],
 	"machine_max_acceleration_y": [
 		"5000"
 	],
 	"machine_max_acceleration_z": [
 		"100"
 	],
 	"machine_max_jerk_e": [
 		"2.5"
 	],
 	"machine_max_jerk_x": [
 		"10"
 	],
 	"machine_max_jerk_y": [
 		"10"
 	],
 	"machine_max_jerk_z": [
 		"0.4"
 	],
 	"machine_max_speed_e": [
 		"60"
 	],
 	"machine_max_speed_x": [
 		"500"
 	],
 	"machine_max_speed_y": [
 		"500"
 	],
 	"machine_max_speed_z": [
 		"20"
 	],
 	"retraction_length": [
 		"2"
 	],
 	"retraction_speed": [
 		"40"
 	],
 	"deretraction_speed": [
 		"40"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"retract_lift_below": [
 		"300"
 	],
 	"machine_start_gcode": "; === IdeaFormer IR3 V2 Belt Printer Start ===\n; Axes: X=lateral, Y=gantry height (probe), Z=belt\nG90 ; absolute positioning\nM82 ; absolute extruder\nG21 ; millimeters\nG28 ; home all axes\nG1 Y20 F500 ; lift nozzle 20mm from belt\n; Bed + hotend temps come from the active filament profile. Belt PLA requires 75 C bed — use Generic/eSun PLA @IdeaFormer IR3 V2 filament presets to get it automatically.\nM140 S[hot_plate_temp_initial_layer] ; set bed temp\nM104 S[nozzle_temperature_initial_layer] ; hotend temp\nM109 S[nozzle_temperature_initial_layer] ; wait hotend\nM190 S[hot_plate_temp_initial_layer] ; wait bed\n; --- Purge blob ---\nG92 E0 ; zero extruder\nG1 Y.1 ; nozzle 0.1mm above belt\nG1 E15 F1000 ; purge 15mm blob\nG1 Z20 E25 F800 ; belt advance 20mm + extrude\nG1 E23 ; retract 2mm\nG28 Y ; re-probe belt surface\nG1 E25 ; de-retract\n; --- Prime lines (full 250mm bed width) ---\nFMS_on ; filament motion sensor\nG1 X250 E50 F2000 ; prime line 1\nG92 Z0 ; reset belt origin\nG1 Z.4 ; belt advance 0.4mm\nG1 X0 E75 ; prime line 2\nG1 F1000 ; default feedrate\nG92 E0 Z0 ; zero extruder + belt = print origin\n",
 	"machine_end_gcode": "; === IdeaFormer IR3 V2 Belt Printer End ===\nM400 ; wait for moves to finish\nM104 S0 ; heater off\nM140 S0 ; bed off\nG92 E0 ; zero extruder\nG1 E-5 F300 ; retract 5mm\nG4 P5000 ; wait for ooze\nG91 ; relative mode - keep every end move relative on a belt\nG1 Y20 F1000 ; raise gantry 20mm for clearance over the part\nG1 Z676 F3000 ; advance belt one full machine-depth to eject the part and clean the belt\nG90 ; back to absolute\nG28 X ; home X only - NEVER 'G28' all: that homes Z/belt and reverses the whole print back into the gantry\nFMS_off ; filament motion sensor off\nBED_MESH_CLEAR\nM84 ; disable motors\n",
 	"machine_pause_gcode": "PAUSE",
 	"layer_change_gcode": "G92 E0 ; belt: reset extruder at layer change (relative E)"
 }
@@ -0,0 +1,12 @@
 {
 	"type": "machine_model",
 	"name": "IdeaFormer IR3 V2",
 	"model_id": "IdeaFormer_IR3_V2",
 	"nozzle_diameter": "0.4",
 	"machine_tech": "FFF",
 	"family": "IdeaFormer",
 	"bed_model": "",
 	"bed_texture": "",
 	"hotend_model": "",
 	"default_materials": "Generic PLA @IdeaFormer IR3 V2;Generic PETG @IdeaFormer IR3 V2"
 }
@@ -0,0 +1,99 @@
 {
 	"type": "machine",
 	"name": "fdm_belt_common",
 	"inherits": "fdm_klipper_common",
 	"from": "system",
 	"instantiation": "false",
 	"gcode_flavor": "klipper",
 	"single_extruder_multi_material": "0",
 	"default_filament_profile": [
 		"Generic PLA @System"
 	],
 	"default_print_profile": "0.20mm Standard @IdeaFormer IR3 V2",
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"deretraction_speed": [
 		"30"
 	],
 	"extruder_colour": [
 		"#FCE94F"
 	],
 	"extruder_offset": [
 		"0x0"
 	],
 	"long_retractions_when_cut": [
 		"0"
 	],
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_length_toolchange": [
 		"2"
 	],
 	"retract_lift_above": [
 		"0"
 	],
 	"retract_lift_below": [
 		"0"
 	],
 	"retract_lift_enforce": [
 		"All Surfaces"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_distances_when_cut": [
 		"18"
 	],
 	"retraction_length": [
 		"0.8"
 	],
 	"retraction_minimum_travel": [
 		"1"
 	],
 	"retraction_speed": [
 		"30"
 	],
 	"travel_slope": [
 		"3"
 	],
 	"wipe": [
 		"1"
 	],
 	"wipe_distance": [
 		"1"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"z_hop_types": [
 		"Normal Lift"
 	],
 	"gcode_remap_x": "rev_x",
 	"gcode_remap_y": "pos_z",
 	"gcode_remap_z": "pos_y",
 	"printer_extruder_id": [
 		"1"
 	],
 	"belt_printer": "1",
 	"belt_slice_rotation": "x",
 	"belt_slice_rotation_angle": "45",
 	"belt_slice_rotation_global": "1",
 	"build_plate_tilt_x": "45",
 	"purge_in_prime_tower": "0",
 	"scan_first_layer": "0",
 	"auxiliary_fan": "0"
 }
@@ -0,0 +1,141 @@
 {
 	"type": "machine",
 	"name": "fdm_klipper_common",
 	"inherits": "fdm_machine_common",
 	"from": "system",
 	"instantiation": "false",
 	"gcode_flavor": "klipper",
 	"machine_max_acceleration_e": [
 		"5000",
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_retracting": [
 		"5000",
 		"5000"
 	],
 	"machine_max_acceleration_travel": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_x": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_y": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_z": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_e": [
 		"25",
 		"25"
 	],
 	"machine_max_speed_x": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_y": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_z": [
 		"12",
 		"12"
 	],
 	"machine_max_jerk_e": [
 		"2.5",
 		"2.5"
 	],
 	"machine_max_jerk_x": [
 		"9",
 		"9"
 	],
 	"machine_max_jerk_y": [
 		"9",
 		"9"
 	],
 	"machine_max_jerk_z": [
 		"0.2",
 		"0.4"
 	],
 	"machine_min_extruding_rate": [
 		"0",
 		"0"
 	],
 	"machine_min_travel_rate": [
 		"0",
 		"0"
 	],
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"printable_height": "250",
 	"extruder_clearance_radius": "65",
 	"extruder_clearance_height_to_rod": "36",
 	"extruder_clearance_height_to_lid": "140",
 	"printer_settings_id": "",
 	"printer_technology": "FFF",
 	"printer_variant": "0.4",
 	"retraction_minimum_travel": [
 		"1"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_length": [
 		"0.8"
 	],
 	"retract_length_toolchange": [
 		"2"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retraction_speed": [
 		"30"
 	],
 	"deretraction_speed": [
 		"30"
 	],
 	"z_hop_types": "Normal Lift",
 	"silent_mode": "0",
 	"single_extruder_multi_material": "1",
 	"change_filament_gcode": "",
 	"wipe": [
 		"1"
 	],
 	"default_filament_profile": [
 		"Generic PLA @System"
 	],
 	"default_print_profile": "0.20mm Standard @MyKlipper",
 	"bed_exclude_area": [
 		"0x0"
 	],
 	"machine_start_gcode": "M190 S[bed_temperature_initial_layer_single]\nM109 S[nozzle_temperature_initial_layer]\nPRINT_START EXTRUDER=[nozzle_temperature_initial_layer] BED=[bed_temperature_initial_layer_single]\n",
 	"machine_end_gcode": "PRINT_END",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
 	"machine_pause_gcode": "PAUSE",
 	"scan_first_layer": "0",
 	"nozzle_type": "undefine",
 	"auxiliary_fan": "0"
 }
@@ -0,0 +1,119 @@
 {
 	"type": "machine",
 	"name": "fdm_machine_common",
 	"from": "system",
 	"instantiation": "false",
 	"printer_technology": "FFF",
 	"deretraction_speed": [
 		"40"
 	],
 	"extruder_colour": [
 		"#FCE94F"
 	],
 	"extruder_offset": [
 		"0x0"
 	],
 	"gcode_flavor": "marlin",
 	"silent_mode": "0",
 	"machine_max_acceleration_e": [
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"10000"
 	],
 	"machine_max_acceleration_retracting": [
 		"1000"
 	],
 	"machine_max_acceleration_x": [
 		"10000"
 	],
 	"machine_max_acceleration_y": [
 		"10000"
 	],
 	"machine_max_acceleration_z": [
 		"500"
 	],
 	"machine_max_speed_e": [
 		"60"
 	],
 	"machine_max_speed_x": [
 		"500"
 	],
 	"machine_max_speed_y": [
 		"500"
 	],
 	"machine_max_speed_z": [
 		"10"
 	],
 	"machine_max_jerk_e": [
 		"5"
 	],
 	"machine_max_jerk_x": [
 		"8"
 	],
 	"machine_max_jerk_y": [
 		"8"
 	],
 	"machine_max_jerk_z": [
 		"0.4"
 	],
 	"machine_min_extruding_rate": [
 		"0"
 	],
 	"machine_min_travel_rate": [
 		"0"
 	],
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"printable_height": "250",
 	"extruder_clearance_radius": "65",
 	"extruder_clearance_height_to_rod": "36",
 	"extruder_clearance_height_to_lid": "140",
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"printer_settings_id": "",
 	"printer_variant": "0.4",
 	"retraction_minimum_travel": [
 		"2"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_length": [
 		"1"
 	],
 	"retract_length_toolchange": [
 		"1"
 	],
 	"z_hop": [
 		"0"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retraction_speed": [
 		"60"
 	],
 	"single_extruder_multi_material": "1",
 	"change_filament_gcode": "",
 	"wipe": [
 		"1"
 	],
 	"default_print_profile": "",
 	"machine_start_gcode": "G0 Z20 F9000\nG92 E0; G1 E-10 F1200\nG28\nM970 Q1 A10 B10 C130 K0\nM970 Q1 A10 B131 C250 K1\nM974 Q1 S1 P0\nM970 Q0 A10 B10 C130 H20 K0\nM970 Q0 A10 B131 C250 K1\nM974 Q0 S1 P0\nM220 S100 ;Reset Feedrate\nM221 S100 ;Reset Flowrate\nG29 ;Home\nG90;\nG92 E0 ;Reset Extruder \nG1 Z2.0 F3000 ;Move Z Axis up \nG1 X10.1 Y20 Z0.28 F5000.0 ;Move to start position\nM109 S205;\nG1 X10.1 Y200.0 Z0.28 F1500.0 E15 ;Draw the first line\nG1 X10.4 Y200.0 Z0.28 F5000.0 ;Move to side a little\nG1 X10.4 Y20 Z0.28 F1500.0 E30 ;Draw the second line\nG92 E0 ;Reset Extruder \nG1 X110 Y110 Z2.0 F3000 ;Move Z Axis up",
 	"machine_end_gcode": "M400 ; wait for buffer to clear\nG92 E0 ; zero the extruder\nG1 E-4.0 F3600; retract \nG91\nG1 Z3;\nM104 S0 ; turn off hotend\nM140 S0 ; turn off bed\nM106 S0 ; turn off fan\nG90 \nG0 X110 Y200 F3600 \nprint_end",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
 	"machine_pause_gcode": "M601"
 }
@@ -0,0 +1,23 @@
 {
 	"type": "process",
 	"name": "0.20mm Standard @IdeaFormer IR3 V2",
 	"inherits": "fdm_process_common",
 	"from": "system",
 	"setting_id": "91atcIwv5728phqX",
 	"instantiation": "true",
 	"layer_height": "0.2",
 	"initial_layer_print_height": "0.2",
 	"initial_layer_line_width": "0.42",
 	"wall_loops": "2",
 	"reduce_infill_retraction": "1",
 	"detect_overhang_wall": "1",
 	"skirt_loops": "0",
 	"skirt_distance": "0",
 	"sparse_infill_pattern": "grid",
 	"sparse_infill_speed": "200",
 	"support_base_pattern": "rectilinear",
 	"support_interface_pattern": "rectilinear",
 	"compatible_printers": [
 		"IdeaFormer IR3 V2 0.4 nozzle"
 	]
 }
@@ -0,0 +1,108 @@
 {
 	"type": "process",
 	"name": "fdm_process_common",
 	"from": "system",
 	"instantiation": "false",
 	"adaptive_layer_height": "0",
 	"reduce_crossing_wall": "0",
 	"max_travel_detour_distance": "0",
 	"bottom_surface_pattern": "monotonic",
 	"bottom_shell_thickness": "0",
 	"bridge_speed": "50",
 	"brim_width": "5",
 	"brim_object_gap": "0.1",
 	"compatible_printers": [],
 	"compatible_printers_condition": "",
 	"print_sequence": "by layer",
 	"default_acceleration": "1000",
 	"initial_layer_acceleration": "500",
 	"top_surface_acceleration": "1000",
 	"travel_acceleration": "1000",
 	"inner_wall_acceleration": "1000",
 	"outer_wall_acceleration": "700",
 	"bridge_no_support": "0",
 	"draft_shield": "disabled",
 	"elefant_foot_compensation": "0",
 	"enable_arc_fitting": "0",
 	"wall_infill_order": "inner wall/outer wall/infill",
 	"infill_direction": "45",
 	"sparse_infill_density": "15%",
 	"sparse_infill_pattern": "crosshatch",
 	"initial_layer_print_height": "0.2",
 	"infill_combination": "0",
 	"infill_wall_overlap": "25%",
 	"interface_shells": "0",
 	"ironing_flow": "10%",
 	"ironing_spacing": "0.15",
 	"ironing_speed": "30",
 	"ironing_type": "no ironing",
 	"reduce_infill_retraction": "1",
 	"filename_format": "{input_filename_base}_{layer_height}mm_{filament_type[initial_tool]}_{printer_model}_{print_time}.gcode",
 	"detect_overhang_wall": "1",
 	"slowdown_for_curled_perimeters": "1",
 	"overhang_1_4_speed": "0",
 	"overhang_2_4_speed": "50",
 	"overhang_3_4_speed": "30",
 	"overhang_4_4_speed": "10",
 	"line_width": "110%",
 	"inner_wall_line_width": "110%",
 	"outer_wall_line_width": "100%",
 	"top_surface_line_width": "93.75%",
 	"sparse_infill_line_width": "110%",
 	"initial_layer_line_width": "120%",
 	"internal_solid_infill_line_width": "120%",
 	"support_line_width": "96%",
 	"wall_loops": "3",
 	"print_settings_id": "",
 	"raft_layers": "0",
 	"seam_position": "aligned",
 	"skirt_distance": "2",
 	"skirt_height": "3",
 	"min_skirt_length": "4",
 	"skirt_loops": "0",
 	"minimum_sparse_infill_area": "15",
 	"spiral_mode": "0",
 	"standby_temperature_delta": "-5",
 	"enable_support": "0",
 	"resolution": "0.012",
 	"support_type": "normal(auto)",
 	"support_on_build_plate_only": "0",
 	"support_top_z_distance": "0.2",
 	"support_bottom_z_distance": "0.2",
 	"support_filament": "0",
 	"support_interface_loop_pattern": "0",
 	"support_interface_filament": "0",
 	"support_interface_top_layers": "2",
 	"support_interface_bottom_layers": "2",
 	"support_interface_spacing": "0.5",
 	"support_interface_speed": "80",
 	"support_base_pattern": "default",
 	"support_base_pattern_spacing": "2.5",
 	"support_speed": "150",
 	"support_threshold_angle": "30",
 	"support_object_xy_distance": "0.35",
 	"tree_support_branch_angle": "30",
 	"tree_support_wall_count": "0",
 	"tree_support_with_infill": "0",
 	"detect_thin_wall": "0",
 	"top_surface_pattern": "monotonicline",
 	"top_shell_thickness": "0.8",
 	"enable_prime_tower": "1",
 	"wipe_tower_no_sparse_layers": "0",
 	"prime_tower_width": "60",
 	"xy_hole_compensation": "0",
 	"xy_contour_compensation": "0",
 	"layer_height": "0.2",
 	"bottom_shell_layers": "3",
 	"top_shell_layers": "4",
 	"bridge_flow": "1",
 	"initial_layer_speed": "45",
 	"initial_layer_infill_speed": "45",
 	"outer_wall_speed": "45",
 	"inner_wall_speed": "80",
 	"sparse_infill_speed": "150",
 	"internal_solid_infill_speed": "150",
 	"top_surface_speed": "50",
 	"gap_infill_speed": "30",
 	"travel_speed": "200"
 }
@@ -0,0 +1,54 @@
 {
 	"name": "Printcepts",
 	"version": "01.00.00.01",
 	"force_update": "0",
 	"description": "Printcepts belt printer configurations",
 	"machine_model_list": [
 		{
 			"name": "BabyBelt Pro",
 			"sub_path": "machine/BabyBelt Pro.json"
 		}
 	],
 	"process_list": [
 		{
 			"name": "fdm_process_common",
 			"sub_path": "process/fdm_process_common.json"
 		},
 		{
 			"name": "0.20mm Standard @BabyBelt Pro",
 			"sub_path": "process/0.20mm Standard @BabyBelt Pro.json"
 		}
 	],
 	"filament_list": [
 		{
 			"name": "Generic PLA @BabyBelt Pro",
 			"sub_path": "filament/Generic PLA @BabyBelt Pro.json"
 		},
 		{
 			"name": "eSUN PLA @BabyBelt Pro",
 			"sub_path": "filament/eSUN PLA @BabyBelt Pro.json"
 		},
 		{
 			"name": "Generic PETG @BabyBelt Pro",
 			"sub_path": "filament/Generic PETG @BabyBelt Pro.json"
 		}
 	],
 	"machine_list": [
 		{
 			"name": "fdm_machine_common",
 			"sub_path": "machine/fdm_machine_common.json"
 		},
 		{
 			"name": "fdm_klipper_common",
 			"sub_path": "machine/fdm_klipper_common.json"
 		},
 		{
 			"name": "fdm_belt_common",
 			"sub_path": "machine/fdm_belt_common.json"
 		},
 		{
 			"name": "BabyBelt Pro 0.4 nozzle",
 			"sub_path": "machine/BabyBelt Pro 0.4 nozzle.json"
 		}
 	]
 }
@@ -0,0 +1,70 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="95.0mm" height="500.0mm" viewBox="0 0 95.0 500.0" preserveAspectRatio="xMidYMid meet">
  <!-- Printcepts BabyBelt Pro bed texture: 95 x 500 mm belt plate. -->
  <!-- Transparent plate; green (#195F30) BabyBelt Pro logo centered along X, near the bottom edge. -->
  <rect x="0" y="0" width="95.0" height="500.0" fill="none"/>
  <g transform="translate(14.2500,436.3488) scale(0.067538)">
    <g transform="translate(-11.000000,692.938562) scale(0.100000,-0.100000)"
 fill="#195F30" stroke="none">
 <path d="M1963 5604 l-1423 -1324 0 -2050 0 -2050 443 0 c244 0 741 3 1105 7
 l662 6 0 746 c-1 575 -4 768 -14 841 -47 324 -179 486 -473 581 -40 12 -73 26
 -73 30 0 4 32 17 72 29 212 64 333 166 378 320 35 121 38 191 32 868 l-5 662
 -629 0 c-395 0 -628 4 -628 10 0 5 635 601 1410 1325 776 724 1410 1318 1410
 1321 0 2 -190 4 -422 3 l-423 0 -1422 -1325z m-334 -2029 c143 -16 174 -96
 173 -446 -2 -411 -24 -458 -224 -462 l-93 -2 -3 450 c-1 248 0 456 3 463 3 9
 18 12 47 8 24 -3 67 -8 97 -11z m-4 -1556 c160 -29 173 -62 182 -469 9 -455
 -14 -593 -108 -641 -39 -19 -193 -44 -210 -33 -10 6 -13 1147 -3 1157 6 6 45
 2 139 -14z"/>
 <path d="M3464 5979 c-142 -132 -263 -245 -268 -250 -6 -5 69 -9 190 -9 l199
 1 268 249 267 250 -198 0 -198 0 -260 -241z"/>
 <path d="M3650 5649 c-135 -126 -254 -238 -265 -249 -19 -20 -18 -20 177 -20
 l197 0 228 211 c125 116 246 229 268 250 l40 39 -200 -1 -200 0 -245 -230z"/>
 <path d="M2537 5089 c-101 -24 -204 -105 -251 -197 -96 -190 -19 -420 172
 -514 l67 -33 2670 0 2670 0 57 27 c74 34 146 107 184 183 43 88 43 230 0 322
 -35 76 -113 153 -193 191 l-58 27 -2640 2 c-1513 0 -2656 -3 -2678 -8z m5063
 -77 c-57 -37 -118 -111 -140 -168 -31 -82 -25 -206 12 -279 26 -49 93 -121
 133 -143 15 -8 -640 -11 -2410 -11 l-2430 0 30 21 c200 146 201 425 1 569
 l-39 29 2434 -1 c2263 0 2432 -1 2409 -17z m-4890 -43 c270 -122 185 -526
 -109 -522 -257 2 -370 324 -170 485 74 60 194 76 279 37z m5201 -12 c94 -55
 140 -135 140 -242 0 -285 -393 -374 -517 -117 -26 54 -30 162 -9 219 28 74 97
 139 173 164 53 17 166 4 213 -24z"/>
 <path d="M2917 3973 c-4 -174 -7 -550 -7 -835 l0 -518 326 0 326 0 -7 150 -7
 150 110 0 110 0 11 -32 c5 -18 26 -86 46 -150 l36 -118 325 0 c179 0 323 4
 320 9 -3 4 -155 374 -337 822 -182 448 -333 820 -336 827 -4 9 -105 12 -457
 12 l-453 0 -6 -317z m773 -745 c0 -5 -47 -8 -104 -8 l-103 0 -7 92 c-3 50 -6
 202 -5 337 l1 246 109 -330 c60 -181 109 -333 109 -337z"/>
 <path d="M4680 3455 l0 -835 448 0 c693 1 885 16 985 80 99 63 126 132 134
 340 12 327 -44 405 -342 476 -28 7 -27 8 25 19 199 42 255 95 267 248 11 146
 -32 285 -110 353 -145 126 -329 153 -1049 154 l-358 0 0 -835z m846 520 c36
 -23 44 -54 44 -162 0 -152 -29 -183 -170 -183 l-40 0 0 186 0 187 71 -6 c39
 -3 82 -13 95 -22z m4 -625 c33 -18 40 -52 40 -208 0 -200 -9 -214 -143 -228
 l-67 -7 0 233 0 233 74 -6 c41 -3 84 -10 96 -17z"/>
 <path d="M6150 4286 c0 -3 131 -242 290 -531 l290 -526 0 -304 0 -305 385 0
 385 0 0 299 0 299 305 533 305 534 -377 3 c-207 1 -381 -2 -385 -6 -16 -16
 -110 -258 -172 -444 l-62 -187 -18 77 c-18 75 -139 450 -171 525 l-15 37 -380
 0 c-209 0 -380 -2 -380 -4z"/>
 <path d="M2910 1355 l0 -1185 830 0 830 0 0 240 0 240 -350 0 -350 0 0 255 0
 255 300 0 300 0 0 230 0 230 -300 0 -300 0 0 220 0 220 320 0 320 0 0 240 0
 240 -800 0 -800 0 0 -1185z"/>
 <path d="M4680 1355 l0 -1185 775 0 775 0 0 240 0 240 -295 0 -295 0 0 945 0
 945 -480 0 -480 0 0 -1185z"/>
 <path d="M5800 2300 l0 -240 280 0 280 0 0 -945 0 -945 480 0 480 0 0 945 0
 945 285 0 285 0 0 240 0 240 -1045 0 -1045 0 0 -240z"/>
 <path d="M8032 1358 l-2 -1188 1008 1 c621 1 971 5 912 10 -309 27 -631 139
 -885 306 -593 391 -984 1122 -1025 1918 -4 77 -8 -394 -8 -1047z"/>
 <path d="M7441 1934 c-43 -36 -59 -70 -70 -148 -18 -124 16 -252 76 -291 32
 -21 226 -33 328 -20 114 14 161 97 153 269 -5 96 -24 151 -68 191 -20 18 -39
 20 -205 23 l-182 3 -32 -27z m389 -199 c7 -8 10 -22 6 -30 -4 -13 -34 -15
 -186 -15 -189 0 -202 3 -186 45 8 22 348 22 366 0z"/>
 <path d="M7450 1267 c-14 -6 -35 -32 -47 -57 -21 -41 -23 -58 -23 -222 l0
 -178 270 0 270 0 0 105 0 105 -121 0 -120 0 3 28 3 27 118 3 117 3 0 99 0 100
 -113 0 c-121 0 -138 -7 -162 -65 -8 -19 -9 -19 -12 2 -10 55 -116 84 -183 50z
 m134 -203 c15 -38 8 -44 -54 -44 -62 0 -69 6 -54 44 9 23 99 23 108 0z"/>
 <path d="M466 1193 l-29 -43 -163 0 -164 0 0 -235 0 -235 165 0 165 0 27 -42
 28 -42 3 163 c1 89 1 233 0 319 l-3 157 -29 -42z"/>
 <path d="M7443 620 c-48 -20 -58 -60 -61 -262 l-4 -188 271 0 271 0 0 110 0
 110 -110 0 -110 0 0 70 c0 76 -21 145 -51 160 -22 12 -176 12 -206 0z m161
 -186 c15 -39 8 -44 -64 -44 -72 0 -79 5 -64 44 9 23 119 23 128 0z"/>
 </g>
  </g>
 </svg>
@@ -0,0 +1,113 @@
 {
 	"type": "filament",
 	"name": "Generic PETG @BabyBelt Pro",
 	"inherits": "Generic PETG @System",
 	"from": "system",
 	"setting_id": "gCzHpDNgVwQR6tgk",
 	"instantiation": "true",
 	"compatible_printers": [
 		"BabyBelt Pro 0.4 nozzle"
 	],
 	"filament_type": [
 		"PETG"
 	],
 	"filament_vendor": [
 		"Generic"
 	],
 	"filament_settings_id": [
 		"Generic PETG @BabyBelt Pro"
 	],
 	"filament_diameter": [
 		"1.75"
 	],
 	"filament_density": [
 		"1.27"
 	],
 	"filament_flow_ratio": [
 		"0.95"
 	],
 	"filament_cost": [
 		"25"
 	],
 	"filament_max_volumetric_speed": [
 		"10"
 	],
 	"nozzle_temperature": [
 		"240"
 	],
 	"nozzle_temperature_initial_layer": [
 		"245"
 	],
 	"nozzle_temperature_range_low": [
 		"220"
 	],
 	"nozzle_temperature_range_high": [
 		"260"
 	],
 	"temperature_vitrification": [
 		"70"
 	],
 	"hot_plate_temp": [
 		"80"
 	],
 	"hot_plate_temp_initial_layer": [
 		"80"
 	],
 	"cool_plate_temp": [
 		"80"
 	],
 	"cool_plate_temp_initial_layer": [
 		"80"
 	],
 	"textured_plate_temp": [
 		"80"
 	],
 	"textured_plate_temp_initial_layer": [
 		"80"
 	],
 	"fan_min_speed": [
 		"40"
 	],
 	"fan_max_speed": [
 		"60"
 	],
 	"overhang_fan_threshold": [
 		"25%"
 	],
 	"overhang_fan_speed": [
 		"80"
 	],
 	"close_fan_the_first_x_layers": [
 		"3"
 	],
 	"full_fan_speed_layer": [
 		"8"
 	],
 	"slow_down_min_speed": [
 		"20"
 	],
 	"slow_down_layer_time": [
 		"4"
 	],
 	"fan_cooling_layer_time": [
 		"100"
 	],
 	"reduce_fan_stop_start_freq": [
 		"1"
 	],
 	"filament_retraction_length": [
 		"2"
 	],
 	"filament_retraction_speed": [
 		"40"
 	],
 	"filament_deretraction_speed": [
 		"40"
 	],
 	"filament_z_hop": [
 		"0.4"
 	],
 	"filament_start_gcode": [
 		"; Generic PETG @BabyBelt Pro — belt PETG, bed 80C"
 	]
 }
@@ -0,0 +1,113 @@
 {
 	"type": "filament",
 	"name": "Generic PLA @BabyBelt Pro",
 	"inherits": "Generic PLA @System",
 	"from": "system",
 	"setting_id": "24PpcnhVx9v5f4fD",
 	"instantiation": "true",
 	"compatible_printers": [
 		"BabyBelt Pro 0.4 nozzle"
 	],
 	"filament_type": [
 		"PLA"
 	],
 	"filament_vendor": [
 		"Generic"
 	],
 	"filament_settings_id": [
 		"Generic PLA @BabyBelt Pro"
 	],
 	"filament_diameter": [
 		"1.75"
 	],
 	"filament_density": [
 		"1.24"
 	],
 	"filament_flow_ratio": [
 		"0.98"
 	],
 	"filament_cost": [
 		"20"
 	],
 	"filament_max_volumetric_speed": [
 		"12"
 	],
 	"nozzle_temperature": [
 		"215"
 	],
 	"nozzle_temperature_initial_layer": [
 		"220"
 	],
 	"nozzle_temperature_range_low": [
 		"190"
 	],
 	"nozzle_temperature_range_high": [
 		"240"
 	],
 	"temperature_vitrification": [
 		"45"
 	],
 	"hot_plate_temp": [
 		"75"
 	],
 	"hot_plate_temp_initial_layer": [
 		"75"
 	],
 	"cool_plate_temp": [
 		"75"
 	],
 	"cool_plate_temp_initial_layer": [
 		"75"
 	],
 	"textured_plate_temp": [
 		"75"
 	],
 	"textured_plate_temp_initial_layer": [
 		"75"
 	],
 	"fan_min_speed": [
 		"100"
 	],
 	"fan_max_speed": [
 		"100"
 	],
 	"overhang_fan_threshold": [
 		"50%"
 	],
 	"overhang_fan_speed": [
 		"100"
 	],
 	"close_fan_the_first_x_layers": [
 		"3"
 	],
 	"full_fan_speed_layer": [
 		"8"
 	],
 	"slow_down_min_speed": [
 		"20"
 	],
 	"slow_down_layer_time": [
 		"4"
 	],
 	"fan_cooling_layer_time": [
 		"100"
 	],
 	"reduce_fan_stop_start_freq": [
 		"1"
 	],
 	"filament_retraction_length": [
 		"1.5"
 	],
 	"filament_retraction_speed": [
 		"35"
 	],
 	"filament_deretraction_speed": [
 		"30"
 	],
 	"filament_z_hop": [
 		"0.4"
 	],
 	"filament_start_gcode": [
 		"; Generic PLA @BabyBelt Pro — belt PLA, bed 75C"
 	]
 }
@@ -0,0 +1,36 @@
 {
 	"type": "filament",
 	"name": "eSUN PLA @BabyBelt Pro",
 	"inherits": "Generic PLA @BabyBelt Pro",
 	"filament_id": "OFkrxQC4",
 	"from": "system",
 	"setting_id": "EH3X7oE0DU5tSpjW",
 	"instantiation": "true",
 	"compatible_printers": [
 		"BabyBelt Pro 0.4 nozzle"
 	],
 	"filament_type": [
 		"PLA"
 	],
 	"filament_vendor": [
 		"eSUN"
 	],
 	"filament_settings_id": [
 		"eSUN PLA @BabyBelt Pro"
 	],
 	"nozzle_temperature_initial_layer": [
 		"200"
 	],
 	"nozzle_temperature": [
 		"200"
 	],
 	"enable_pressure_advance": [
 		"1"
 	],
 	"pressure_advance": [
 		"0.12"
 	],
 	"filament_max_volumetric_speed": [
 		"20"
 	]
 }
@@ -0,0 +1,87 @@
 {
 	"type": "machine",
 	"name": "BabyBelt Pro 0.4 nozzle",
 	"inherits": "fdm_belt_common",
 	"from": "system",
 	"setting_id": "34OWINlJpJgA9DwQ",
 	"instantiation": "true",
 	"printer_model": "BabyBelt Pro",
 	"printer_variant": "0.4",
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"default_filament_profile": [
 		"Generic PLA @BabyBelt Pro"
 	],
 	"default_print_profile": "0.20mm Standard @BabyBelt Pro",
 	"printable_area": [
 		"0x0",
 		"95x0",
 		"95x500",
 		"0x500"
 	],
 	"printable_height": "100",
 	"best_object_pos": "0.5,0.05",
 	"nozzle_type": [
 		"hardened_steel"
 	],
 	"printer_extruder_id": [
 		"1"
 	],
 	"printer_extruder_variant": [
 		"Direct Drive Standard"
 	],
 	"thumbnails": [
 		"48x48/PNG",
 		"300x300/PNG"
 	],
 	"machine_max_acceleration_e": [
 		"500",
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"500",
 		"20000"
 	],
 	"machine_max_acceleration_retracting": [
 		"500",
 		"5000"
 	],
 	"machine_max_acceleration_x": [
 		"500",
 		"20000"
 	],
 	"machine_max_acceleration_y": [
 		"500",
 		"20000"
 	],
 	"machine_max_junction_deviation": [
 		"0.01"
 	],
 	"machine_max_speed_x": [
 		"50",
 		"200"
 	],
 	"machine_max_speed_y": [
 		"50",
 		"200"
 	],
 	"machine_max_speed_z": [
 		"5",
 		"12"
 	],
 	"retraction_length": [
 		"1.5"
 	],
 	"retraction_speed": [
 		"20"
 	],
 	"deretraction_speed": [
 		"25"
 	],
 	"retract_lift_enforce": [
 		"Top and Bottom"
 	],
 	"support_chamber_temp_control": "0",
 	"machine_start_gcode": ";Start GCode\nPRINT_START ANGLE=[belt_slice_rotation_angle] EXTRUDER=[nozzle_temperature_initial_layer] BED=[hot_plate_temp_initial_layer] MATERIAL=[filament_type]\n"
 }
@@ -0,0 +1,12 @@
 {
 	"type": "machine_model",
 	"name": "BabyBelt Pro",
 	"model_id": "Printcepts_BabyBelt_Pro",
 	"nozzle_diameter": "0.4",
 	"machine_tech": "FFF",
 	"family": "Printcepts",
 	"bed_model": "",
 	"bed_texture": "BabyBelt Pro_bed_texture.svg",
 	"hotend_model": "",
 	"default_materials": "Generic PLA @BabyBelt Pro;Generic PETG @BabyBelt Pro"
 }
@@ -0,0 +1,99 @@
 {
 	"type": "machine",
 	"name": "fdm_belt_common",
 	"inherits": "fdm_klipper_common",
 	"from": "system",
 	"instantiation": "false",
 	"gcode_flavor": "klipper",
 	"single_extruder_multi_material": "0",
 	"default_filament_profile": [
 		"Generic PLA @System"
 	],
 	"default_print_profile": "0.20mm Standard @BabyBelt Pro",
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"deretraction_speed": [
 		"30"
 	],
 	"extruder_colour": [
 		"#FCE94F"
 	],
 	"extruder_offset": [
 		"0x0"
 	],
 	"long_retractions_when_cut": [
 		"0"
 	],
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_length_toolchange": [
 		"2"
 	],
 	"retract_lift_above": [
 		"0"
 	],
 	"retract_lift_below": [
 		"0"
 	],
 	"retract_lift_enforce": [
 		"All Surfaces"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_distances_when_cut": [
 		"18"
 	],
 	"retraction_length": [
 		"0.8"
 	],
 	"retraction_minimum_travel": [
 		"1"
 	],
 	"retraction_speed": [
 		"30"
 	],
 	"travel_slope": [
 		"3"
 	],
 	"wipe": [
 		"1"
 	],
 	"wipe_distance": [
 		"1"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"z_hop_types": [
 		"Normal Lift"
 	],
 	"gcode_remap_x": "rev_x",
 	"gcode_remap_y": "pos_z",
 	"gcode_remap_z": "pos_y",
 	"printer_extruder_id": [
 		"1"
 	],
 	"belt_printer": "1",
 	"belt_slice_rotation": "x",
 	"belt_slice_rotation_angle": "45",
 	"belt_slice_rotation_global": "1",
 	"build_plate_tilt_x": "45",
 	"purge_in_prime_tower": "0",
 	"scan_first_layer": "0",
 	"auxiliary_fan": "0"
 }
@@ -0,0 +1,141 @@
 {
 	"type": "machine",
 	"name": "fdm_klipper_common",
 	"inherits": "fdm_machine_common",
 	"from": "system",
 	"instantiation": "false",
 	"gcode_flavor": "klipper",
 	"machine_max_acceleration_e": [
 		"5000",
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_retracting": [
 		"5000",
 		"5000"
 	],
 	"machine_max_acceleration_travel": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_x": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_y": [
 		"20000",
 		"20000"
 	],
 	"machine_max_acceleration_z": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_e": [
 		"25",
 		"25"
 	],
 	"machine_max_speed_x": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_y": [
 		"500",
 		"200"
 	],
 	"machine_max_speed_z": [
 		"12",
 		"12"
 	],
 	"machine_max_jerk_e": [
 		"2.5",
 		"2.5"
 	],
 	"machine_max_jerk_x": [
 		"9",
 		"9"
 	],
 	"machine_max_jerk_y": [
 		"9",
 		"9"
 	],
 	"machine_max_jerk_z": [
 		"0.2",
 		"0.4"
 	],
 	"machine_min_extruding_rate": [
 		"0",
 		"0"
 	],
 	"machine_min_travel_rate": [
 		"0",
 		"0"
 	],
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"printable_height": "250",
 	"extruder_clearance_radius": "65",
 	"extruder_clearance_height_to_rod": "36",
 	"extruder_clearance_height_to_lid": "140",
 	"printer_settings_id": "",
 	"printer_technology": "FFF",
 	"printer_variant": "0.4",
 	"retraction_minimum_travel": [
 		"1"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_length": [
 		"0.8"
 	],
 	"retract_length_toolchange": [
 		"2"
 	],
 	"z_hop": [
 		"0.4"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retraction_speed": [
 		"30"
 	],
 	"deretraction_speed": [
 		"30"
 	],
 	"z_hop_types": "Normal Lift",
 	"silent_mode": "0",
 	"single_extruder_multi_material": "1",
 	"change_filament_gcode": "",
 	"wipe": [
 		"1"
 	],
 	"default_filament_profile": [
 		"Generic PLA @System"
 	],
 	"default_print_profile": "0.20mm Standard @MyKlipper",
 	"bed_exclude_area": [
 		"0x0"
 	],
 	"machine_start_gcode": "M190 S[bed_temperature_initial_layer_single]\nM109 S[nozzle_temperature_initial_layer]\nPRINT_START EXTRUDER=[nozzle_temperature_initial_layer] BED=[bed_temperature_initial_layer_single]\n",
 	"machine_end_gcode": "PRINT_END",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
 	"machine_pause_gcode": "PAUSE",
 	"scan_first_layer": "0",
 	"nozzle_type": "undefine",
 	"auxiliary_fan": "0"
 }
@@ -0,0 +1,119 @@
 {
 	"type": "machine",
 	"name": "fdm_machine_common",
 	"from": "system",
 	"instantiation": "false",
 	"printer_technology": "FFF",
 	"deretraction_speed": [
 		"40"
 	],
 	"extruder_colour": [
 		"#FCE94F"
 	],
 	"extruder_offset": [
 		"0x0"
 	],
 	"gcode_flavor": "marlin",
 	"silent_mode": "0",
 	"machine_max_acceleration_e": [
 		"5000"
 	],
 	"machine_max_acceleration_extruding": [
 		"10000"
 	],
 	"machine_max_acceleration_retracting": [
 		"1000"
 	],
 	"machine_max_acceleration_x": [
 		"10000"
 	],
 	"machine_max_acceleration_y": [
 		"10000"
 	],
 	"machine_max_acceleration_z": [
 		"500"
 	],
 	"machine_max_speed_e": [
 		"60"
 	],
 	"machine_max_speed_x": [
 		"500"
 	],
 	"machine_max_speed_y": [
 		"500"
 	],
 	"machine_max_speed_z": [
 		"10"
 	],
 	"machine_max_jerk_e": [
 		"5"
 	],
 	"machine_max_jerk_x": [
 		"8"
 	],
 	"machine_max_jerk_y": [
 		"8"
 	],
 	"machine_max_jerk_z": [
 		"0.4"
 	],
 	"machine_min_extruding_rate": [
 		"0"
 	],
 	"machine_min_travel_rate": [
 		"0"
 	],
 	"max_layer_height": [
 		"0.32"
 	],
 	"min_layer_height": [
 		"0.08"
 	],
 	"printable_height": "250",
 	"extruder_clearance_radius": "65",
 	"extruder_clearance_height_to_rod": "36",
 	"extruder_clearance_height_to_lid": "140",
 	"nozzle_diameter": [
 		"0.4"
 	],
 	"printer_settings_id": "",
 	"printer_variant": "0.4",
 	"retraction_minimum_travel": [
 		"2"
 	],
 	"retract_before_wipe": [
 		"70%"
 	],
 	"retract_when_changing_layer": [
 		"1"
 	],
 	"retraction_length": [
 		"1"
 	],
 	"retract_length_toolchange": [
 		"1"
 	],
 	"z_hop": [
 		"0"
 	],
 	"retract_restart_extra": [
 		"0"
 	],
 	"retract_restart_extra_toolchange": [
 		"0"
 	],
 	"retraction_speed": [
 		"60"
 	],
 	"single_extruder_multi_material": "1",
 	"change_filament_gcode": "",
 	"wipe": [
 		"1"
 	],
 	"default_print_profile": "",
 	"machine_start_gcode": "G0 Z20 F9000\nG92 E0; G1 E-10 F1200\nG28\nM970 Q1 A10 B10 C130 K0\nM970 Q1 A10 B131 C250 K1\nM974 Q1 S1 P0\nM970 Q0 A10 B10 C130 H20 K0\nM970 Q0 A10 B131 C250 K1\nM974 Q0 S1 P0\nM220 S100 ;Reset Feedrate\nM221 S100 ;Reset Flowrate\nG29 ;Home\nG90;\nG92 E0 ;Reset Extruder \nG1 Z2.0 F3000 ;Move Z Axis up \nG1 X10.1 Y20 Z0.28 F5000.0 ;Move to start position\nM109 S205;\nG1 X10.1 Y200.0 Z0.28 F1500.0 E15 ;Draw the first line\nG1 X10.4 Y200.0 Z0.28 F5000.0 ;Move to side a little\nG1 X10.4 Y20 Z0.28 F1500.0 E30 ;Draw the second line\nG92 E0 ;Reset Extruder \nG1 X110 Y110 Z2.0 F3000 ;Move Z Axis up",
 	"machine_end_gcode": "M400 ; wait for buffer to clear\nG92 E0 ; zero the extruder\nG1 E-4.0 F3600; retract \nG91\nG1 Z3;\nM104 S0 ; turn off hotend\nM140 S0 ; turn off bed\nM106 S0 ; turn off fan\nG90 \nG0 X110 Y200 F3600 \nprint_end",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
 	"machine_pause_gcode": "M601"
 }
@@ -0,0 +1,23 @@
 {
 	"type": "process",
 	"name": "0.20mm Standard @BabyBelt Pro",
 	"inherits": "fdm_process_common",
 	"from": "system",
 	"setting_id": "JGfGtqX6CWjCt437",
 	"instantiation": "true",
 	"layer_height": "0.2",
 	"initial_layer_print_height": "0.2",
 	"initial_layer_line_width": "0.42",
 	"wall_loops": "2",
 	"reduce_infill_retraction": "1",
 	"detect_overhang_wall": "1",
 	"skirt_loops": "0",
 	"skirt_distance": "0",
 	"sparse_infill_pattern": "grid",
 	"sparse_infill_speed": "200",
 	"support_base_pattern": "rectilinear",
 	"support_interface_pattern": "rectilinear",
 	"compatible_printers": [
 		"BabyBelt Pro 0.4 nozzle"
 	]
 }
@@ -0,0 +1,108 @@
 {
 	"type": "process",
 	"name": "fdm_process_common",
 	"from": "system",
 	"instantiation": "false",
 	"adaptive_layer_height": "0",
 	"reduce_crossing_wall": "0",
 	"max_travel_detour_distance": "0",
 	"bottom_surface_pattern": "monotonic",
 	"bottom_shell_thickness": "0",
 	"bridge_speed": "50",
 	"brim_width": "5",
 	"brim_object_gap": "0.1",
 	"compatible_printers": [],
 	"compatible_printers_condition": "",
 	"print_sequence": "by layer",
 	"default_acceleration": "1000",
 	"initial_layer_acceleration": "500",
 	"top_surface_acceleration": "1000",
 	"travel_acceleration": "1000",
 	"inner_wall_acceleration": "1000",
 	"outer_wall_acceleration": "700",
 	"bridge_no_support": "0",
 	"draft_shield": "disabled",
 	"elefant_foot_compensation": "0",
 	"enable_arc_fitting": "0",
 	"wall_infill_order": "inner wall/outer wall/infill",
 	"infill_direction": "45",
 	"sparse_infill_density": "15%",
 	"sparse_infill_pattern": "crosshatch",
 	"initial_layer_print_height": "0.2",
 	"infill_combination": "0",
 	"infill_wall_overlap": "25%",
 	"interface_shells": "0",
 	"ironing_flow": "10%",
 	"ironing_spacing": "0.15",
 	"ironing_speed": "30",
 	"ironing_type": "no ironing",
 	"reduce_infill_retraction": "1",
 	"filename_format": "{input_filename_base}_{layer_height}mm_{filament_type[initial_tool]}_{printer_model}_{print_time}.gcode",
 	"detect_overhang_wall": "1",
 	"slowdown_for_curled_perimeters": "1",
 	"overhang_1_4_speed": "0",
 	"overhang_2_4_speed": "50",
 	"overhang_3_4_speed": "30",
 	"overhang_4_4_speed": "10",
 	"line_width": "110%",
 	"inner_wall_line_width": "110%",
 	"outer_wall_line_width": "100%",
 	"top_surface_line_width": "93.75%",
 	"sparse_infill_line_width": "110%",
 	"initial_layer_line_width": "120%",
 	"internal_solid_infill_line_width": "120%",
 	"support_line_width": "96%",
 	"wall_loops": "3",
 	"print_settings_id": "",
 	"raft_layers": "0",
 	"seam_position": "aligned",
 	"skirt_distance": "2",
 	"skirt_height": "3",
 	"min_skirt_length": "4",
 	"skirt_loops": "0",
 	"minimum_sparse_infill_area": "15",
 	"spiral_mode": "0",
 	"standby_temperature_delta": "-5",
 	"enable_support": "0",
 	"resolution": "0.012",
 	"support_type": "normal(auto)",
 	"support_on_build_plate_only": "0",
 	"support_top_z_distance": "0.2",
 	"support_bottom_z_distance": "0.2",
 	"support_filament": "0",
 	"support_interface_loop_pattern": "0",
 	"support_interface_filament": "0",
 	"support_interface_top_layers": "2",
 	"support_interface_bottom_layers": "2",
 	"support_interface_spacing": "0.5",
 	"support_interface_speed": "80",
 	"support_base_pattern": "default",
 	"support_base_pattern_spacing": "2.5",
 	"support_speed": "150",
 	"support_threshold_angle": "30",
 	"support_object_xy_distance": "0.35",
 	"tree_support_branch_angle": "30",
 	"tree_support_wall_count": "0",
 	"tree_support_with_infill": "0",
 	"detect_thin_wall": "0",
 	"top_surface_pattern": "monotonicline",
 	"top_shell_thickness": "0.8",
 	"enable_prime_tower": "1",
 	"wipe_tower_no_sparse_layers": "0",
 	"prime_tower_width": "60",
 	"xy_hole_compensation": "0",
 	"xy_contour_compensation": "0",
 	"layer_height": "0.2",
 	"bottom_shell_layers": "3",
 	"top_shell_layers": "4",
 	"bridge_flow": "1",
 	"initial_layer_speed": "45",
 	"initial_layer_infill_speed": "45",
 	"outer_wall_speed": "45",
 	"inner_wall_speed": "80",
 	"sparse_infill_speed": "150",
 	"internal_solid_infill_speed": "150",
 	"top_surface_speed": "50",
 	"gap_infill_speed": "30",
 	"travel_speed": "200"
 }
@@ -1,6 +1,6 @@
 {
 	"name": "Snapmaker",
-	"version": "02.04.00.13",
+	"version": "02.04.00.12",
 	"force_update": "0",
 	"description": "Snapmaker configurations",
 	"machine_model_list": [
@@ -15,13 +15,13 @@
 		"1"
 	],
 	"cool_plate_temp": [
-		"100"
+		"105"
 	],
 	"cool_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"eng_plate_temp": [
-		"100"
+		"105"
 	],
 	"eng_plate_temp_initial_layer": [
 		"100"
@@ -48,7 +48,7 @@
 		"Polymaker"
 	],
 	"hot_plate_temp": [
-		"100"
+		"105"
 	],
 	"hot_plate_temp_initial_layer": [
 		"100"
@@ -72,7 +72,7 @@
 		"110.8"
 	],
 	"textured_plate_temp": [
-		"100"
+		"105"
 	],
 	"textured_plate_temp_initial_layer": [
 		"100"
@@ -15,16 +15,16 @@
 		"1"
 	],
 	"cool_plate_temp": [
-		"100"
+		"105"
 	],
 	"cool_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"eng_plate_temp": [
-		"100"
+		"105"
 	],
 	"eng_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"fan_cooling_layer_time": [
 		"12"
@@ -51,10 +51,10 @@
 		"Polymaker"
 	],
 	"hot_plate_temp": [
-		"100"
+		"105"
 	],
 	"hot_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"nozzle_temperature": [
 		"300"
@@ -81,10 +81,10 @@
 		"110"
 	],
 	"textured_plate_temp": [
-		"100"
+		"105"
 	],
 	"textured_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"filament_type": [
 		"ABS"
@@ -9,10 +9,10 @@
 		""
 	],
 	"hot_plate_temp": [
-		"100"
+		"110"
 	],
 	"hot_plate_temp_initial_layer": [
-		"100"
+		"105"
 	],
 	"overhang_fan_speed": [
 		"20"
@@ -9,7 +9,7 @@
 		""
 	],
 	"hot_plate_temp": [
-		"100"
+		"110"
 	],
 	"hot_plate_temp_initial_layer": [
 		"100"
@@ -26,6 +26,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform vec4 uniform_color;
@@ -23,6 +23,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform mat4 view_model_matrix;
@@ -73,8 +74,8 @@ void main()
    // Point in homogenous coordinates.
    world_pos = volume_world_matrix * vec4(v_position, 1.0);
-    // z component of normal vector in world coordinate used for slope shading
+    // dot product of world normal with up direction, used for slope shading
-    world_normal_z = slope.actived ? (normalize(slope.volume_world_normal_matrix * v_normal)).z : 0.0;
+    world_normal_z = slope.actived ? dot(normalize(slope.volume_world_normal_matrix * v_normal), slope.up_direction) : 0.0;
    gl_Position = projection_matrix * position;
    if (is_outline) {
@@ -37,6 +37,7 @@ struct SlopeDetection
    bool actived;
 	 float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform SlopeDetection slope;
@@ -85,7 +86,7 @@ void main()
              color = LightBlue;
              alpha = 1.0;
         }
-         else if( transformed_normal.z < slope.normal_z - EPSILON)
+         else if( dot(transformed_normal, slope.up_direction) < slope.normal_z - EPSILON)
        {
            color = color * 0.5 + LightRed * 0.5;
            alpha = 1.0;
@@ -24,6 +24,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform SlopeDetection slope;
 void main()
@@ -29,6 +29,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform vec4 uniform_color;
@@ -23,6 +23,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform mat4 view_model_matrix;
@@ -73,8 +74,8 @@ void main()
    // Point in homogenous coordinates.
    world_pos = volume_world_matrix * vec4(v_position, 1.0);
-    // z component of normal vector in world coordinate used for slope shading
+    // dot product of world normal with up direction, used for slope shading
-    world_normal_z = slope.actived ? (normalize(slope.volume_world_normal_matrix * v_normal)).z : 0.0;
+    world_normal_z = slope.actived ? dot(normalize(slope.volume_world_normal_matrix * v_normal), slope.up_direction) : 0.0;
    gl_Position = projection_matrix * position;
    if (is_outline) {
@@ -37,6 +37,7 @@ struct SlopeDetection
    bool actived;
 	 float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform SlopeDetection slope;
@@ -87,7 +88,7 @@ void main()
              color = LightBlue;
              alpha = 1.0;
         }
-         else if( transformed_normal.z < slope.normal_z - EPSILON)
+         else if( dot(transformed_normal, slope.up_direction) < slope.normal_z - EPSILON)
        {
            color = color * 0.5 + LightRed * 0.5;
            alpha = 1.0;
@@ -24,6 +24,7 @@ struct SlopeDetection
    bool actived;
 	float normal_z;
    mat3 volume_world_normal_matrix;
    vec3 up_direction;
 };
 uniform SlopeDetection slope;
 void main()
@@ -1,146 +0,0 @@
 # /// script
 # requires-python = ">=3.12"
 #
 # [tool.orcaslicer.plugin]
 # name = "Dock Panel Demo"
 # description = "Opens a dockable panel beside the 3D view that lists the objects on the plate."
 # author = "OrcaSlicer"
 # version = "0.0.1"
 # ///
 """Dock Panel Demo -- orca.host.ui.create_dock_panel().
 Run it from the Plugins dialog. It opens an HTML panel docked on the right of the 3D view, in the
 same dock area as the sidebar. Drag its caption to dock it on another side (or float it, where the
 platform allows), hide it from the page and run the plugin again to bring it back, or close it with
 its close button or from the page.
  page   --orca.postMessage({command: 'refresh'})-->  plugin.on_message()
  page   --orca.postMessage({command: 'hide'})-->     plugin.on_message() -> panel.hide()
  page   --orca.close()-->                            panel closes, plugin.on_close()
  plugin --panel.post({command: 'objects', ...})-->   page (orca.onMessage)
 """
 import orca
 PAGE = """
 <style>
  body { margin: 0; padding: 12px; font-size: 13px; }
  h3 { margin: 0 0 4px; font-size: 14px; }
  .note { margin: 0 0 12px; color: var(--orca-muted); font-size: 12px; }
  .actions { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 12px; }
  .actions button.quiet { background: transparent; color: var(--orca-fg); border-color: var(--orca-border); }
  table { width: 100%; border-collapse: collapse; }
  td.count { text-align: right; font-variant-numeric: tabular-nums; }
  #status { margin-top: 10px; color: var(--orca-muted); font-size: 12px; }
 </style>
 <h3>Objects on the plate</h3>
 <p class="note">Docked beside the 3D view. Drag the caption to move it.</p>
 <div class="actions">
  <button type="button" id="refresh">Refresh</button>
  <button type="button" id="hide" class="quiet">Hide</button>
  <button type="button" id="close" class="quiet">Close</button>
 </div>
 <table>
  <thead><tr><th>Name</th><th>Parts</th><th>Copies</th></tr></thead>
  <tbody id="rows"></tbody>
 </table>
 <p id="status">Waiting for the plugin...</p>
 <script>
 (function () {
  function text(value) {
    var span = document.createElement("span");
    span.textContent = value;
    return span.innerHTML;
  }
  function render(message) {
    var rows = document.getElementById("rows");
    var status = document.getElementById("status");
    if (message.error) {
      rows.innerHTML = "";
      status.textContent = message.error;
      return;
    }
    rows.innerHTML = message.objects.map(function (object) {
      return "<tr><td>" + text(object.name) + "</td><td class=\\"count\\">" + object.volumes +
             "</td><td class=\\"count\\">" + object.instances + "</td></tr>";
    }).join("");
    status.textContent = message.objects.length + " object(s), refreshed " + new Date().toLocaleTimeString();
  }
  orca.onMessage(function (message) {
    if (message && message.command === "objects")
      render(message);
  });
  document.getElementById("refresh").addEventListener("click", function () {
    orca.postMessage({ command: "refresh" });
  });
  document.getElementById("hide").addEventListener("click", function () {
    orca.postMessage({ command: "hide" });
  });
  document.getElementById("close").addEventListener("click", function () {
    orca.close();
  });
  orca.postMessage({ command: "refresh" });
 })();
 </script>
 """
 def plate_objects():
    try:
        model = orca.host.model()
    except RuntimeError as error:
        return {"command": "objects", "error": str(error)}
    return {
        "command": "objects",
        "objects": [
            {"name": obj.name or "(unnamed)", "volumes": obj.volume_count(), "instances": obj.instance_count()}
            for obj in model.objects()
        ],
    }
 class DockPanelDemo(orca.script.ScriptPluginCapabilityBase):
    panel = None
    def get_name(self):
        return "Dock Panel Demo"
    def execute(self):
        # The capability instance lives as long as the plugin, so a second run finds the open panel.
        if self.panel is not None and self.panel.is_open():
            self.panel.show()
            return orca.ExecutionResult.success("Dock Panel Demo is already open.")
        self.panel = orca.host.ui.create_dock_panel(
            html=PAGE,
            title="Dock Panel Demo",
            dock="right",
            width=320,
            height=480,
            on_message=self.on_message,
            on_close=self.on_close,
        )
        return orca.ExecutionResult.success("Dock Panel Demo opened.")
    # Called on the UI thread when the page posts.
    def on_message(self, message):
        command = (message or {}).get("command")
        if command == "refresh":
            self.panel.post(plate_objects())
        elif command == "hide":
            self.panel.hide()
    def on_close(self):
        self.panel = None
@orca.plugin
 class DockPanelDemoPlugin(orca.base):
    def register_capabilities(self):
        orca.register_capability(DockPanelDemo)
@@ -1549,6 +1549,7 @@
    "Flashforge/Generic PLA",
    "FlyingBear/Generic PLA",
    "Ginger Additive/Generic PLA",
    "IdeaFormer/Generic PLA",
    "InfiMech/Generic PLA",
    "LONGER/Generic PLA",
    "Lulzbot/Generic PLA",
@@ -1556,6 +1557,7 @@
    "OrcaFilamentLibrary/Generic PLA",
    "Peopoly/Generic PLA",
    "Phrozen/Generic PLA",
    "Printcepts/Generic PLA",
    "Prusa/Generic PLA",
    "Qidi/Generic PLA",
    "RH3D/Generic PLA",
@@ -4298,12 +4300,14 @@
    "Flashforge/Generic PETG",
    "FlyingBear/Generic PETG",
    "Ginger Additive/Generic PETG",
    "IdeaFormer/Generic PETG",
    "InfiMech/Generic PETG",
    "LONGER/Generic PETG",
    "Lulzbot/Generic PETG",
    "OrcaArena/Generic PETG",
    "OrcaFilamentLibrary/Generic PETG",
    "Peopoly/Generic PETG",
    "Printcepts/Generic PETG",
    "Prusa/Generic PETG",
    "Qidi/Generic PETG",
    "RH3D/Generic PETG",
@@ -5886,6 +5890,15 @@
   "filament_type": "PA-GF",
   "filament_vendor": "Eryone"
  },
  "OFkrxQC4": {
   "filaments": [
    "IdeaFormer/eSUN PLA",
    "Printcepts/eSUN PLA"
   ],
   "name": "eSUN PLA",
   "filament_type": "PLA",
   "filament_vendor": "eSUN"
  },
  "OFks6esg": {
   "filaments": [
    "Creality/EN-PLA+"
@@ -91,6 +91,12 @@ if (SLIC3R_GUI)
 #    list(REMOVE_ITEM wxWidgets_LIBRARIES oleacc)
    find_package(wxInspector REQUIRED)
    # wxInspector 1.0.0 installs its headers but accidentally declares the
    # INSTALL_INTERFACE include directory PRIVATE, so its imported target does
    # not expose them to consumers. Restore the package prefix include path until
    # the upstream export is fixed.
    get_filename_component(WXINSPECTOR_PREFIX "${wxInspector_DIR}/../../.." ABSOLUTE)
    target_include_directories(wxInspector::wxInspector INTERFACE "${WXINSPECTOR_PREFIX}/include")
    # wxInspector's exported interface names the release wxWidgets import
    # libraries, which a Debug build cannot link. wx is linked above instead.
@@ -186,7 +192,7 @@ endif ()
 # Add the Slic3r GUI library, libcurl, OpenGL and GLU libraries.
 if (SLIC3R_GUI)
 #    target_link_libraries(OrcaSlicer ws2_32 uxtheme setupapi libslic3r_gui ${wxWidgets_LIBRARIES})
-target_link_libraries(OrcaSlicer libslic3r_gui)
+target_link_libraries(OrcaSlicer libslic3r_gui wxInspector::wxInspector)
    if (MSVC)
        # Generate debug symbols even in release mode.
        target_link_options(OrcaSlicer PUBLIC "$<$<CONFIG:RELEASE>:/DEBUG>")
@@ -1387,25 +1387,6 @@ int CLI::run(int argc, char **argv)
    if (downward_check_option)
        downward_check = downward_check_option->value;
    // --export-settings - writes its JSON to stdout, so reject every action or transform that may write there
    // too (--info, --help, --orient, slicing and exporting). The allowed ones do nothing when nothing is
    // sliced or exported.
    if (std::find(m_actions.begin(), m_actions.end(), "export_settings") != m_actions.end() && m_config.opt_string("export_settings") == "-") {
        static const std::set<std::string> stdout_compatible = { "export_settings", "uptodate", "load_defaultfila", "min_save",
                                                                 "mtcpp", "mstpp", "no_check", "normative_check", "pipe" };
        for (const std::vector<std::string> *opt_keys : { &m_actions, &m_transforms }) {
            for (const std::string &opt_key : *opt_keys) {
                if (stdout_compatible.count(opt_key) == 0) {
                    std::string flag = opt_key;
                    std::replace(flag.begin(), flag.end(), '_', '-');
                    boost::nowide::cerr << "--export-settings - cannot be combined with --" << flag << std::endl;
                    record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
                    flush_and_exit(CLI_INVALID_PARAMS);
                }
            }
        }
    }
    bool start_gui = m_actions.empty() && !downward_check;
    if (start_gui) {
        BOOST_LOG_TRIVIAL(info) << "no action, start gui directly" << std::endl;
@@ -2029,21 +2010,19 @@ int CLI::run(int argc, char **argv)
        }
    };
-    // One resolver for the whole run, so presets from the same vendor tree share its load.
+    auto resolve_preset = [&ensure_cli_preset_bundle](const std::string &file, DynamicPrintConfig &config,
    std::unique_ptr<PresetBundle> system_preset_resolver;
    auto resolve_preset = [&ensure_cli_preset_bundle, &system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
                                                                               std::string &config_type, const std::string &config_from,
                                                                               bool probe_type, std::string &error) {
        const auto *inherits = config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS);
        if (!probe_type && (inherits == nullptr || inherits->value.empty()))
            return true;
        std::unique_ptr<PresetBundle> source_bundle;
        PresetBundle                 *bundle = nullptr;
        bool                          allow_source_manifest = false;
        if (config_from == "system") {
-            if (!system_preset_resolver)
+            source_bundle         = std::make_unique<PresetBundle>();
-                system_preset_resolver = std::make_unique<PresetBundle>();
+            bundle                = source_bundle.get();
            bundle                = system_preset_resolver.get();
            allow_source_manifest = true;
        } else {
            bundle = ensure_cli_preset_bundle(error);
@@ -4035,6 +4014,10 @@ int CLI::run(int argc, char **argv)
        BOOST_LOG_TRIVIAL(info) << boost::format("%1%, set disable_wipe_tower_after_mapping back to false due to wrapping detect")%__LINE__;
    }
    // Belt printers never get the classic wipe tower (see Print::has_wipe_tower()), so reserve no space for it.
    const ConfigOptionBool* belt_printer_opt = m_print_config.option<ConfigOptionBool>("belt_printer");
    const bool is_belt_printer = belt_printer_opt && belt_printer_opt->value;
    auto timelapse_type_opt = m_print_config.option("timelapse_type");
    bool is_smooth_timelapse = false;
    if (enable_timelapse && timelapse_type_opt && (timelapse_type_opt->getInt() == TimelapseType::tlSmooth))
@@ -4272,11 +4255,11 @@ int CLI::run(int argc, char **argv)
        }
    };
-    auto check_plate_wipe_tower = [get_print_sequence, is_smooth_timelapse](Slic3r::GUI::PartPlate* plate, int plate_index, DynamicPrintConfig& print_config, plate_obj_size_info_t &plate_obj_size_info) {
+    auto check_plate_wipe_tower = [get_print_sequence, is_smooth_timelapse, is_belt_printer](Slic3r::GUI::PartPlate* plate, int plate_index, DynamicPrintConfig& print_config, plate_obj_size_info_t &plate_obj_size_info) {
        plate_obj_size_info.obj_bbox= plate->get_objects_bounding_box();
        BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%, object bbox: min {%2%, %3%, %4%} - max {%5%, %6%, %7%}")
                    %(plate_index+1) %plate_obj_size_info.obj_bbox.min.x() % plate_obj_size_info.obj_bbox.min.y() % plate_obj_size_info.obj_bbox.min.z() %plate_obj_size_info.obj_bbox.max.x() % plate_obj_size_info.obj_bbox.max.y() % plate_obj_size_info.obj_bbox.max.z();
-        if (!print_config.has("wipe_tower_x")) {
+        if (is_belt_printer || !print_config.has("wipe_tower_x")) {
            plate_obj_size_info.has_wipe_tower = false;
            BOOST_LOG_TRIVIAL(info) << boost::format("can not found wipe_tower_x in config, set to no wipe tower");
            return;
@@ -5083,7 +5066,7 @@ int CLI::run(int argc, char **argv)
                    }
                }
-                if ((!arrange_cfg.is_seq_print && (assemble_plate.filaments_count > 1))||(enable_wrapping_detect && !current_wrapping_exclude_area.empty()))
+                if (!is_belt_printer && ((!arrange_cfg.is_seq_print && (assemble_plate.filaments_count > 1)) || (enable_wrapping_detect && !current_wrapping_exclude_area.empty())))
                {
                    //prepare the wipe tower
                    int plate_count = partplate_list.get_plate_count();
@@ -5233,7 +5216,7 @@ int CLI::run(int argc, char **argv)
                bool is_seq_print = false;
                get_print_sequence(cur_plate, m_print_config, is_seq_print);
-                if (!is_seq_print && (assemble_plate.filaments_count > 1) && !has_wipe_tower_position)
+                if (!is_belt_printer && !is_seq_print && (assemble_plate.filaments_count > 1) && !has_wipe_tower_position)
                {
                    //prepare the wipe tower
                    auto printer_structure_opt = m_print_config.option<ConfigOptionEnum<PrinterStructure>>("printer_structure");
@@ -5369,7 +5352,7 @@ int CLI::run(int argc, char **argv)
                                //skip this object due to be locked in plate
                                ap.itemid = locked_aps.size();
                                locked_aps.emplace_back(ap);
-                                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, instance_id %2%") % oidx % inst_idx;
+                                boost::nowide::cout <<__FUNCTION__ << boost::format(": skip locked instance, obj_id %1%, instance_id %2%") % oidx % inst_idx;
                            }
                        }
                    }
@@ -5382,7 +5365,7 @@ int CLI::run(int argc, char **argv)
                    //add the virtual object into unselect list if has
                    partplate_list.preprocess_exclude_areas(unselected, enable_wrapping_detect);
-                    if (used_filament_set.size() > 0)
+                    if (!is_belt_printer && used_filament_set.size() > 0)
                    {
                        //prepare the wipe tower
                        int plate_count = partplate_list.get_plate_count();
@@ -5488,7 +5471,7 @@ int CLI::run(int argc, char **argv)
                        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": found single object mode");
                    }
-                    if (m_print_config.has("wipe_tower_x") && (is_smooth_timelapse || !arrange_cfg.is_seq_print || (selected.size() <= 1))) {
+                    if (!is_belt_printer && m_print_config.has("wipe_tower_x") && (is_smooth_timelapse || !arrange_cfg.is_seq_print || (selected.size() <= 1))) {
                        float x;
                        float y;
                        if (duplicate_count > 0) {
@@ -5958,11 +5941,7 @@ int CLI::run(int argc, char **argv)
            //FIXME check for mixing the FFF / SLA parameters.
            // or better save fff_print_config vs. sla_print_config
            //m_print_config.save(m_config.opt_string("save"));
-            const std::string &settings_file = m_config.opt_string(opt_key);
+            m_print_config.save_to_json(m_config.opt_string(opt_key), std::string("project_settings"), std::string("project"), std::string(SoftFever_VERSION));
            if (settings_file == "-")
                m_print_config.save_to_json(boost::nowide::cout, "project_settings", "project", SoftFever_VERSION, /*replace_invalid_utf8=*/true);
            else
                m_print_config.save_to_json(settings_file, std::string("project_settings"), std::string("project"), std::string(SoftFever_VERSION));
        } else if (opt_key == "info") {
            // --info works on unrepaired model
            for (Model &model : m_models) {
@@ -6062,7 +6041,7 @@ int CLI::run(int argc, char **argv)
                // The stored (or default) tower position may not fit the tower these plates
                // need, and no CLI placement site runs on a plain slice - mirror the GUI's
                // reload clamp and fit every plate's tower into the printable area first.
-                if (m_print_config.option<ConfigOptionBool>("enable_prime_tower", true)->value) {
+                if (!is_belt_printer && m_print_config.option<ConfigOptionBool>("enable_prime_tower", true)->value) {
                    for (int index = 0; index < partplate_list.get_plate_count(); index++) {
                        if ((plate_to_slice != 0) && (plate_to_slice != (index + 1)))
                            continue;
@@ -7740,13 +7719,6 @@ bool CLI::setup(int argc, char **argv)
        this->print_help();
        return false;
    }
    // Orca: resolve here, while the process is still in the directory the user invoked it from.
    // GUI_App's constructor moves the working directory to <data_dir>/log, long before the GUI
    // opens these files in post_init(), and a relative path would then resolve against that.
    for (std::string &input_file : m_input_files)
        input_file = resolve_cli_input_path(input_file);
    // Parse actions and transform options.
    for (auto const &opt_key : opt_order) {
        if (cli_actions_config_def.has(opt_key))
@@ -0,0 +1,516 @@
 #include "BeltBrim.hpp"
 #include "ClipperUtils.hpp"
 #include "Flow.hpp"
 #include "Layer.hpp"
 #include "Polygon.hpp"
 #include "Print.hpp"
 #include "ShortestPath.hpp"
 #include "Support/BeltFloorContext.hpp"
 #include <algorithm>
 namespace Slic3r {
 // ---------------------------------------------------------------- scaling
 static inline Point scale_u_point(const Point &p, int from_axis, double factor)
 {
    // llround, not a cast: casting truncates toward zero, so a round trip would
    // walk every vertex toward the origin by up to one unit per pass.
    return from_axis == 0 ?
        Point(coord_t(std::llround(double(p.x()) * factor)), p.y()) :
        Point(p.x(), coord_t(std::llround(double(p.y()) * factor)));
 }
 static inline void scale_u_polygon(Polygon &poly, int from_axis, double factor)
 {
    for (Point &p : poly.points)
        p = scale_u_point(p, from_axis, factor);
 }
 ExPolygons belt_scale_u(const ExPolygons &src, const BeltBrimFrame &frame, double factor)
 {
    ExPolygons out = src;
    for (ExPolygon &ex : out) {
        scale_u_polygon(ex.contour, frame.from_axis, factor);
        for (Polygon &hole : ex.holes)
            scale_u_polygon(hole, frame.from_axis, factor);
    }
    return out;
 }
 Polylines belt_scale_u(const Polylines &src, const BeltBrimFrame &frame, double factor)
 {
    Polylines out = src;
    for (Polyline &pl : out)
        for (Point &p : pl.points)
            p = scale_u_point(p, frame.from_axis, factor);
    return out;
 }
 // ---------------------------------------------------------------- sweep
 ExPolygons sweep_ex(const ExPolygons &src, const Point &t)
 {
    if (src.empty())
        return {};
    if (t == Point(0, 0))
        return src;
    // One parallelogram per boundary edge.  Together with P and P + t these
    // cover the Minkowski sum exactly: for any q = p + s*t with p in P and
    // s in [0, 1], let s* be the smallest lambda >= 0 with q - lambda*t in P.
    // Either s* == 0 (so q is in P) or q - s* * t lies on some boundary edge e,
    // putting q in that edge's parallelogram.  Hole edges must be included, or
    // holes narrower than t along t would wrongly survive the sweep.
    Polygons quads;
    for (const ExPolygon &ex : src)
        for (size_t c = 0; c < ex.num_contours(); ++ c)
            for (const Line &e : ex.contour_or_hole(c).lines()) {
                if (e.a == e.b)
                    continue;
                Polygon q;
                q.points = { e.a, e.b, e.b + t, e.a + t };
                // The non-zero fill rule counts a clockwise ring as -1, which
                // would punch a hole instead of adding material.  Edges parallel
                // to t give a zero-area quad; Clipper discards those harmlessly.
                if (q.is_clockwise())
                    q.reverse();
                quads.emplace_back(std::move(q));
            }
    ExPolygons shifted = src;
    for (ExPolygon &ex : shifted)
        ex.translate(t);
    // union_ex(ExPolygons, Polygons) uses pftNonZero, which is the fill rule the
    // argument above relies on.
    return union_ex(union_ex(src, shifted), quads);
 }
 // ---------------------------------------------------------------- brim region
 ExPolygons belt_brim_region(const ExPolygons    &footprint_flat,
                            bool                 has_outer,
                            bool                 has_inner,
                            coord_t              brim_width,
                            coord_t              object_gap,
                            coord_t              leading,
                            coord_t              lateral,
                            const BeltBrimFrame &frame)
 {
    if (footprint_flat.empty() || (! has_outer && ! has_inner))
        return {};
    ExPolygons out;
    if (has_outer) {
        // Offset the outer ring from the contours only, so a hole cannot punch
        // through it.  Same reasoning as the plate brim in Brim.cpp.
        Polygons contours;
        contours.reserve(footprint_flat.size());
        for (const ExPolygon &ex : footprint_flat)
            contours.emplace_back(ex.contour);
        // Inner and outer boundary offset from the same polygon, to avoid
        // round-off mismatch between them.
        ExPolygons inner = offset_ex(contours, float(object_gap), jtRound, SCALED_RESOLUTION);
        // Close the interior before offsetting outwards.  A belt contact patch is often a
        // narrow, broken-up strip, and the offset rings of two islands less than
        // 2 x brim_width apart merge and fill the space between them - space that lies
        // UNDER the part, which is not what "outer brim" means.  Closing also swallows
        // holes in the patch for the same reason.  Concavity-filling only, so an apron or
        // any other outward protrusion is untouched.
        ExPolygons envelope = brim_width > 0 ? closing_ex(inner, float(brim_width)) : inner;
        ExPolygons base  = envelope;
        if (leading > 0) {
            // Sweep downhill from the gapped keep-out, so the apron is contiguous with
            // the ring instead of starting inside the gap.
            const Point t = frame.from_axis == 0 ?
                Point(frame.downhill_sign() * leading, 0) :
                Point(0, frame.downhill_sign() * leading);
            base = union_ex(base, sweep_ex(envelope, t));
        }
        if (lateral > 0) {
            // Across the belt, both ways.  Swept from `base` so the apron is widened
            // too, and in the flattened frame the cross-belt axis is unscaled, so this
            // distance is already a true on-belt distance.
            const Point t = frame.from_axis == 0 ? Point(0, lateral) : Point(lateral, 0);
            ExPolygons widened = union_ex(sweep_ex(base, t), sweep_ex(base, Point(-t.x(), -t.y())));
            base = union_ex(base, to_polygons(widened));
        }
        ExPolygons outer = offset_ex(base, float(brim_width), jtRound, SCALED_RESOLUTION);
        expolygons_append(out, diff_ex(outer, envelope));
    }
    if (has_inner) {
        // Holes reversed so a negative offset grows inward, mirroring Brim.cpp.
        // No apron here: an apron growing into a hole interior is never useful.
        Polygons holes;
        for (const ExPolygon &ex : footprint_flat)
            polygons_append(holes, ex.holes);
        polygons_reverse(holes);
        if (! holes.empty()) {
            ExPolygons hole_inner = offset_ex(holes, - float(brim_width + object_gap));
            ExPolygons hole_outer = offset_ex(holes, - float(object_gap));
            expolygons_append(out, intersection_ex(diff_ex(hole_outer, hole_inner), holes));
        }
    }
    return union_ex(out);
 }
 // ---------------------------------------------------------------- line lattice
 std::vector<coord_t> belt_brim_line_positions(coord_t u_lo,
                                              coord_t u_hi,
                                              coord_t pitch_u,
                                              coord_t u_anchor)
 {
    std::vector<coord_t> out;
    if (pitch_u <= 0 || u_hi <= u_lo)
        return out;
    // Walk the lattice from just below u_lo.  Integer arithmetic throughout, so
    // the half-open interval needs no epsilon: a point landing exactly on u_hi
    // belongs to the next band.
    int64_t k = int64_t(std::floor(double(u_lo - u_anchor) / double(pitch_u))) - 1;
    while (u_anchor + coord_t(k) * pitch_u < u_lo)
        ++ k;
    for (;; ++ k) {
        const coord_t u = u_anchor + coord_t(k) * pitch_u;
        if (u >= u_hi)
            break;
        out.emplace_back(u);
    }
    return out;
 }
 // ---------------------------------------------------------------- pipeline
 // A band of the belt surface as an explicit box, clamped to `bounds` along the
 // shear axis.  Deliberately not BeltFloorContext::surface_polygon(): those
 // half-planes span +-1000 mm, which is wasteful to clip against and dangerous to
 // feed through the flattening scale.
 static Polygon band_box(const BoundingBox &bounds, int from_axis, coordf_t u_lo, coordf_t u_hi)
 {
    coord_t lo = scale_(u_lo);
    coord_t hi = scale_(u_hi);
    const coord_t bmin = from_axis == 0 ? bounds.min.x() : bounds.min.y();
    const coord_t bmax = from_axis == 0 ? bounds.max.x() : bounds.max.y();
    lo = std::max(lo, bmin);
    hi = std::min(hi, bmax);
    Polygon poly;
    if (hi <= lo)
        return poly;
    if (from_axis == 0)
        poly.points = { Point(lo, bounds.min.y()), Point(hi, bounds.min.y()),
                        Point(hi, bounds.max.y()), Point(lo, bounds.max.y()) };
    else
        poly.points = { Point(bounds.min.x(), lo), Point(bounds.max.x(), lo),
                        Point(bounds.max.x(), hi), Point(bounds.min.x(), hi) };
    return poly;
 }
 // Everything the per-band line generator needs, gathered once per object.
 struct BeltBrimContext
 {
    BeltFloorContext ctx;
    BeltBrimFrame    frame;
    ExPolygons       region;      // brim region, object-local slicing XY
    BoundingBox      region_bbox;
    Flow             brim_flow;
    coord_t          pitch_u   = 0;
    coord_t          u_anchor  = 0;
    double           in_plane_pitch = 0.;   // mm
 };
 // Emit the cross-belt brim lines that belong to the band [print_z - height, print_z].
 static void belt_brim_band_paths(const BeltBrimContext      &bc,
                                 coordf_t                    print_z,
                                 coordf_t                    height,
                                 const Polygons             &obstacles,
                                 ExtrusionEntityCollection  &out,
                                 ExPolygons                 &areas_out)
 {
    coordf_t u_lo = bc.ctx.cutoff_u(print_z - height);
    coordf_t u_hi = bc.ctx.cutoff_u(print_z);
    if (u_lo > u_hi)
        std::swap(u_lo, u_hi);
    // How wide this band is measured ON the belt, versus one nominal bead.
    const double band_in_plane = (u_hi - u_lo) * bc.frame.u_stretch();
    // Fraction of the layer height at which a line sits above the belt.  Toward the
    // downhill edge, so the sheet is reasonably thick while the nozzle stays clear of
    // the belt itself.
    static constexpr double BAND_CLEARANCE_FRACTION = 0.75;
    std::vector<coord_t> us;
    double uniform_clearance = 0.;   // 0 => derive per line from its own position
    double line_pitch        = bc.in_plane_pitch;
    if (band_in_plane <= bc.in_plane_pitch + EPSILON) {
        // Steep belt, which is the normal case: the band is narrower than one bead, so
        // exactly one line fits.  Place it at a FIXED fraction of the band rather than
        // on a nominal-spacing lattice.  On a lattice each line lands at an arbitrary
        // point in its band, the clearance sweeps [0, height] from band to band, and the
        // bead width therefore varies by 2x - visible as ragged, uneven brim lines.
        // Anchoring to the band makes the clearance identical everywhere, so every bead
        // is the same width.
        //
        // The spacing is then whatever the bands give (height / sin(tilt) on the belt)
        // rather than the nominal bead spacing, so the flow below is matched to THAT
        // pitch.  Matched flow at the real pitch is what keeps the sheet uniform and
        // gap-free; using nominal flow at band spacing would over-feed it.
        us.push_back(scale_(bc.ctx.cutoff_u(print_z - BAND_CLEARANCE_FRACTION * height)));
        uniform_clearance = BAND_CLEARANCE_FRACTION * height;
        line_pitch        = band_in_plane;
    } else {
        // Shallow belt: the band is wider than a bead, so it takes several lines and they
        // have to sit on the nominal lattice.  Their clearances then differ, and so do
        // their widths - unavoidable here, but shallow belts are the rare case.
        us = belt_brim_line_positions(scale_(u_lo), scale_(u_hi), bc.pitch_u, bc.u_anchor);
    }
    if (us.empty())
        return;
    const Polygons region_polys = to_polygons(bc.region);
    // One lattice line at a time: the clearance - and therefore the extrusion
    // volume - is a property of the line's u, so the pieces of different lines
    // must not be pooled before the flow is resolved.
    // Overshoot the region so the clip, not the line's ends, decides the extent.
    const coord_t margin = coord_t(SCALED_EPSILON) + 1;
    for (const coord_t u : us) {
        Polyline line;
        if (bc.frame.from_axis == 0)
            line.points = { Point(u, coord_t(bc.region_bbox.min.y() - margin)),
                            Point(u, coord_t(bc.region_bbox.max.y() + margin)) };
        else
            line.points = { Point(coord_t(bc.region_bbox.min.x() - margin), u),
                            Point(coord_t(bc.region_bbox.max.x() + margin), u) };
        Polylines pieces = intersection_pl(Polylines{ line }, region_polys);
        if (! obstacles.empty())
            pieces = diff_pl(pieces, obstacles);
        if (pieces.empty())
            continue;
        // Nozzle-to-belt clearance for this line.  Constant along the line, because the
        // belt height depends only on the shear-axis coordinate.  Band-anchored lines
        // share one clearance by construction; lattice lines (shallow belts) each get
        // their own, clamped so neither end of a band yields an unprintable bead.
        double clearance = uniform_clearance;
        if (clearance <= 0.) {
            const Point probe = bc.frame.from_axis == 0 ? Point(u, 0) : Point(0, u);
            clearance = print_z - bc.ctx.floor_print_z(probe);
            clearance = std::min(std::max(clearance, 0.5 * height), height);
        }
        // with_cross_section, not with_height: it reaches the prescribed volume while
        // KEEPING the extrusion spacing, so the bead is sized to fill exactly one
        // pitch x clearance cell of the sheet.
        const Flow f = bc.brim_flow.with_cross_section(float(line_pitch * clearance));
        // Footprint of these beads, for the first-layer convex hull and bbox.
        for (const Polygon &p : offset(pieces, 0.5f * float(f.scaled_width())))
            areas_out.emplace_back(ExPolygon(p));
        extrusion_entities_append_paths(out.entities, chain_polylines(std::move(pieces)),
                                        erBrim, f.mm3_per_mm(), f.width(), float(clearance));
    }
 }
 // Union of everything extruded at `print_z` that the brim must keep clear of, expressed
 // in `self`'s local slicing frame.  Includes `self` itself: its slice at this Z can
 // overhang outside the belt footprint and land in the brim ring, which the flattened
 // brim_object_gap - a belt-plane separation - does not cover.
 //
 // THREADING: this runs inside posSupportMaterial, which Print::process() executes for all
 // objects in a tbb::parallel_for (Print.cpp).  Object slices are finished by then and safe
 // to read across objects, but SUPPORT layers are not: another object's thread may be
 // inside clear_support_layers() - which deletes the SupportLayer pointers - right now, so
 // touching a foreign object's support_layers() here is a use-after-free.  Only this
 // object's own supports are consulted; they are complete, because make_belt_brim() runs at
 // the tail of this object's own generate_support_material().  The cost is that the brim
 // does not dodge a *different* object's support at the same Z, which needs the objects to
 // overlap in the belt direction in the first place.
 // `region_bbox` bounds the brim; anything outside it cannot clip a brim line, so whole
 // objects are skipped without materialising their polygons.  On a typical plate the
 // objects do not overlap and every foreign object drops out here, which matters because
 // this runs once per band - hundreds of times per object.
 static Polygons belt_brim_obstacles(const Print &print, const PrintObject &self,
                                    const BoundingBox &region_bbox, coordf_t print_z, coordf_t tol)
 {
    const Point shift_self = self.instances().empty() ? Point(0, 0)
                                                      : self.instances().front().shift_without_plate_offset();
    Polygons out;
    for (const PrintObject *o : print.objects()) {
        const bool is_self = (o == &self);
        for (const PrintInstance &inst : o->instances()) {
            const Point delta = inst.shift_without_plate_offset() - shift_self;
            if (const Layer *l = o->get_layer_at_printz(print_z, tol)) {
                BoundingBox lb = get_extents(l->lslices);
                lb.translate(delta.x(), delta.y());
                if (lb.overlap(region_bbox)) {
                    Polygons ps = to_polygons(l->lslices);
                    for (Polygon &p : ps)
                        p.translate(delta);
                    polygons_append(out, std::move(ps));
                }
            }
            if (! is_self)
                continue;
            if (const SupportLayer *sl = o->get_support_layer_at_printz(print_z, tol)) {
                Polygons ps = sl->support_fills.polygons_covered_by_spacing();
                for (Polygon &p : ps)
                    p.translate(delta);
                polygons_append(out, std::move(ps));
            }
        }
    }
    if (out.size() < 2)
        return out;   // union_() of 0 or 1 polygons is pure overhead
    return union_(out);
 }
 void make_belt_brim(PrintObject &object)
 {
    object.clear_belt_brim();
    if (! object.has_belt_brim())
        return;
    const Print &print = *object.print();
    BeltBrimContext bc;
    if (! bc.ctx.init(object.slicing_parameters(), print.config()))
        return;
    bc.frame = BeltBrimFrame{ bc.ctx.shear_factor(), bc.ctx.from_axis() };
    const size_t nlayers = object.layers().size();
    if (nlayers == 0)
        return;
    // 1. Belt footprint: the union of each layer's slice clipped to that layer's
    //    own contact band.  This is the object's bottom face, which on a belt is
    //    spread over every layer instead of sitting in layer 0.
    ExPolygons footprint_acc;
    for (size_t i = 0; i < nlayers; ++ i) {
        const Layer &layer = *object.layers()[i];
        if (layer.lslices.empty())
            continue;
        // print_z - height, not the previous layer's print_z: variable layer
        // heights make the latter wrong.
        coordf_t u_lo = bc.ctx.cutoff_u(layer.print_z - layer.height);
        coordf_t u_hi = bc.ctx.cutoff_u(layer.print_z);
        if (u_lo > u_hi)
            std::swap(u_lo, u_hi);
        BoundingBox bb = get_extents(layer.lslices);
        bb.offset(scale_(1.));
        const Polygon band = band_box(bb, bc.frame.from_axis, u_lo, u_hi);
        if (band.empty())
            continue;
        expolygons_append(footprint_acc, intersection_ex(layer.lslices, Polygons{ band }));
    }
    const ExPolygons footprint = union_ex(footprint_acc);
    if (footprint.empty())
        return;
    // 2. Brim region, offset in the flattened (true on-belt) metric.
    const PrintObjectConfig &cfg = object.config();
    bc.brim_flow = print.brim_flow();
    const double  flow_w = bc.brim_flow.scaled_spacing() * SCALING_FACTOR;
    // Quantize to an even number of lines, as the plate brim does.
    const coord_t width   = scale_(std::floor(cfg.brim_width.value / flow_w / 2) * flow_w * 2);
    const coord_t leading = scale_(cfg.leading_brim_length.value);
    const coord_t lateral = scale_(cfg.extra_brim_width.value);
    const coord_t gap     = scale_(cfg.brim_object_gap.value);
    // Belt printers collapse Auto / Mouse ear / Painted to outer-only: the auto width
    // heuristic and flat ear discs have no meaning on a tilted plane.  Leading-edge-only
    // is an outer brim too; it is narrowed down to the first contact below.
    const BrimType bt = cfg.brim_type.value;
    const bool has_outer = bt == btOuterOnly || bt == btOuterAndInner
                        || bt == btAutoBrim  || bt == btEar || bt == btPainted
                        || bt == btLeadingEdgeOnly;
    const bool has_inner = bt == btInnerOnly || bt == btOuterAndInner;
    bc.region = belt_unflatten(
        belt_brim_region(belt_flatten(footprint, bc.frame), has_outer, has_inner,
                         width, gap, leading, lateral, bc.frame),
        bc.frame);
    if (bt == btLeadingEdgeOnly && ! bc.region.empty()) {
        // Keep only what lies at or downhill of the object's FIRST contact with the
        // belt, so the part is supported as it lands and nothing is printed alongside
        // it afterwards.  The cut is the uphill edge of the first layer's contact band:
        // everything past it belongs to later contacts.
        const coordf_t u_cut   = bc.ctx.cutoff_u(object.layers().front()->print_z);
        BoundingBox    keep_bb = get_extents(bc.region);
        keep_bb.offset(scale_(1.));
        const bool     low_side = bc.frame.shear > 0.;   // downhill is -u
        const Polygon  keep = band_box(keep_bb, bc.frame.from_axis,
            low_side ? unscale<double>(bc.frame.from_axis == 0 ? keep_bb.min.x() : keep_bb.min.y()) : u_cut,
            low_side ? u_cut : unscale<double>(bc.frame.from_axis == 0 ? keep_bb.max.x() : keep_bb.max.y()));
        bc.region = keep.empty() ? ExPolygons{} : intersection_ex(bc.region, Polygons{ keep });
    }
    if (bc.region.empty())
        return;
    bc.region_bbox = get_extents(bc.region);
    // 3. Line lattice.  Fixed pitch in the flattened metric, anchored at the
    //    footprint's leading-most edge so lines stay collinear across
    //    disconnected islands and across the apron prologue.
    bc.pitch_u = std::max<coord_t>(1, coord_t(bc.brim_flow.scaled_spacing() * bc.frame.cos_tilt()));
    bc.in_plane_pitch = unscale<double>(bc.pitch_u) * bc.frame.u_stretch();
    {
        const BoundingBox fbb = get_extents(footprint);
        const bool low_side = bc.frame.shear > 0.;
        bc.u_anchor = bc.frame.from_axis == 0 ? (low_side ? fbb.min.x() : fbb.max.x())
                                              : (low_side ? fbb.min.y() : fbb.max.y());
    }
    // 4. Bands coincident with an object layer.
    std::vector<ExtrusionEntityCollection> by_layer(nlayers);
    std::vector<ExPolygons>                areas_by_layer(nlayers);
    for (size_t i = 0; i < nlayers; ++ i) {
        const Layer &layer = *object.layers()[i];
        const Polygons obstacles = belt_brim_obstacles(print, object, bc.region_bbox, layer.print_z, 0.5 * layer.height);
        belt_brim_band_paths(bc, layer.print_z, layer.height, obstacles, by_layer[i], areas_by_layer[i]);
    }
    // 5. Apron prologue: the part of the region downhill of the object's first
    //    layer, which has no object layer to ride on.
    std::vector<BeltBrimBand> prologue;
    {
        const Layer   &first  = *object.layers().front();
        const coordf_t h      = first.height;
        const bool     low_side = bc.frame.shear > 0.;
        const coord_t  u_lead_s = bc.frame.from_axis == 0
            ? (low_side ? bc.region_bbox.min.x() : bc.region_bbox.max.x())
            : (low_side ? bc.region_bbox.min.y() : bc.region_bbox.max.y());
        const coordf_t u_lead  = unscale<double>(u_lead_s);
        // print_z at which the belt surface crosses the region's leading edge.
        const coordf_t z_lead  = bc.ctx.shear_factor() * u_lead
                               + bc.ctx.floor_offset() + bc.ctx.z_shift();
        if (h > EPSILON)
            for (coordf_t z = first.print_z - h; z > z_lead - h; z -= h) {
                const Polygons obstacles = belt_brim_obstacles(print, object, bc.region_bbox, z, 0.5 * h);
                BeltBrimBand band;
                band.print_z = z;
                band.height  = h;
                belt_brim_band_paths(bc, z, h, obstacles, band.fills, band.areas);
                if (! band.fills.empty())
                    prologue.emplace_back(std::move(band));
            }
        // Lowest Z first, so collect_layers_to_print sees them in print order.
        std::reverse(prologue.begin(), prologue.end());
    }
    object.set_belt_brim(std::move(by_layer), std::move(areas_by_layer), std::move(prologue));
 }
 } // namespace Slic3r
@@ -0,0 +1,169 @@
 #ifndef slic3r_BeltBrim_hpp_
 #define slic3r_BeltBrim_hpp_
 #include "ExPolygon.hpp"
 #include "ExtrusionEntityCollection.hpp"
 #include "Point.hpp"
 #include "Polyline.hpp"
 #include <cmath>
 #include <vector>
 // Belt-printer brim geometry.
 //
 // A belt printer slices in a ROTATED frame, so the belt surface is not the
 // Z=0 bed plane but a tilted plane in slicing space:
 //
 //     z_slicing(u) = shear * u + floor_offset + z_shift,   u = X or Y
 //
 // where `shear == tan(tilt)` (SlicingParameters::belt_floor_shear_factor) and
 // the axis is selected by SlicingParameters::belt_floor_from_axis.  See
 // Support/BeltFloorContext.hpp for the canonical accessors.
 //
 // Consequences that drive everything in this file:
 //
 //   * A horizontal slicing layer touches the belt only along a narrow strip at
 //     its leading edge, `layer_height / shear` wide (~0.2 mm at 45 degrees).
 //     The object's belt footprint - its bottom face - is therefore spread over
 //     every layer, not contained in layer 0.
 //   * Distances measured in slicing XY are NOT on-belt distances: moving `du`
 //     along the shear axis travels `du / cos(tilt)` across the belt.  So brim
 //     offsets have to be taken in a "flattened" space where the shear axis is
 //     stretched by `1 / cos(tilt)`, then mapped back.
 //   * Brim ahead of the part (downhill) lies at slicing Z BELOW the object's
 //     first layer, because the object's layer 0 is precisely its leading
 //     contact with the belt.
 //
 // Everything here is pure geometry on ExPolygons/Polylines so it can be unit
 // tested without a Print.  Keep user-visible strings out of this file: it is
 // not listed in localization/i18n/list.txt.
 namespace Slic3r {
 // Tilt window within which the BELT plane, not the bed plane, is the adhesion
 // surface.  Below ~1 degree a belt is a flat bed as far as adhesion goes, and the
 // contact band would be layer_height/sin(tilt) - tens of millimetres - so the
 // ordinary plate brim is both correct and cheaper.  Above ~85 degrees the whole
 // brim compresses into a sliver and is not worth generating.
 inline constexpr double BELT_BRIM_MIN_TILT_DEG = 1.;
 inline constexpr double BELT_BRIM_MAX_TILT_DEG = 85.;
 // Description of the tilted belt plane, reduced to what the brim geometry needs.
 struct BeltBrimFrame
 {
    // tan(tilt).  Sign selects which way is downhill.
    double shear     = 0.;
    // 0 = X, 1 = Y.  Matches BeltFloorContext::from_axis().
    int    from_axis = 1;
    // 1 / cos(tilt).  Stretch factor that turns a projected distance along
    // `from_axis` into the true distance travelled across the belt.
    double u_stretch() const { return std::sqrt(1. + shear * shear); }
    // cos(tilt).  The inverse mapping.
    double cos_tilt()  const { return 1. / this->u_stretch(); }
    // Downhill is where the belt surface is lower, i.e. printed earlier, i.e.
    // the leading edge of the part.  For shear > 0 that is -u.
    int    downhill_sign() const { return shear > 0. ? -1 : +1; }
 };
 // Scale only the `from_axis` component by `factor`, rounding to nearest.
 //
 // Deliberately not MultiPoint::scale(fx, fy) / ExPolygon::scale(fx, fy): those
 // truncate toward zero, which is asymmetric about the origin and loses up to a
 // full coordinate unit per vertex on every round trip.
 ExPolygons belt_scale_u(const ExPolygons &src, const BeltBrimFrame &frame, double factor);
 Polylines  belt_scale_u(const Polylines  &src, const BeltBrimFrame &frame, double factor);
 // Into / out of the space where Euclidean offsets equal true on-belt distances.
 inline ExPolygons belt_flatten(const ExPolygons &src, const BeltBrimFrame &frame)
    { return belt_scale_u(src, frame, frame.u_stretch()); }
 inline ExPolygons belt_unflatten(const ExPolygons &src, const BeltBrimFrame &frame)
    { return belt_scale_u(src, frame, frame.cos_tilt()); }
 // Minkowski sum of `src` with the segment [0, t]: the region swept by sliding
 // `src` along t.  Used to grow the brim downhill for "extra brim width".
 //
 // Implemented as union_(P, P + t, {parallelogram per boundary edge}) over ALL
 // contours including holes, with every parallelogram forced counter-clockwise
 // so the non-zero fill rule closes holes narrower than t along the sweep
 // direction.  A hole survives exactly when it is wider than |t| measured along
 // t - not when it is wider in its narrowest Euclidean direction.
 ExPolygons sweep_ex(const ExPolygons &src, const Point &t);
 // Brim region for one already-flattened belt footprint.  All lengths are scaled
 // and measured in the flattened (true on-belt) metric.
 //
 // `has_outer` / `has_inner` are the resolved BrimType: belt printers collapse
 // Auto / Mouse ear / Painted to outer-only, so the caller does that mapping and
 // this function never needs PrintConfig.
 //
 // Two directional extras are applied to the footprint before the outer offset, so
 // each one buys reach in one direction only:
 //
 //   `leading` (leading_brim_length) sweeps the footprint DOWNHILL along the belt,
 //   so every leading-facing edge gains an apron ahead of it.
 //   `lateral`  (extra_brim_width)   sweeps it BOTH WAYS across the belt, widening
 //   the brim sideways without pushing it further ahead or behind.
 //
 // Neither is applied to the inner (hole) ring.
 ExPolygons belt_brim_region(const ExPolygons   &footprint_flat,
                            bool                has_outer,
                            bool                has_inner,
                            coord_t             brim_width,
                            coord_t             object_gap,
                            coord_t             leading,
                            coord_t             lateral,
                            const BeltBrimFrame &frame);
 // Brim line positions for one layer band.
 //
 // Lines sit on a fixed lattice `u_anchor + k * pitch_u` so the on-belt spacing
 // between neighbouring brim lines is constant regardless of how the lattice
 // falls across layer bands.  Snapping to band centres instead would quantise
 // the spacing to whole bands and under-deposit by ~35% at 45 degrees.
 //
 // The band is half-open, [u_lo, u_hi), so every lattice point belongs to
 // exactly one band: none duplicated at a boundary, none dropped.  A band
 // narrower than the pitch simply yields nothing; a band much wider (shallow
 // tilt) yields several lines.
 std::vector<coord_t> belt_brim_line_positions(coord_t u_lo,
                                              coord_t u_hi,
                                              coord_t pitch_u,
                                              coord_t u_anchor);
 // ---------------------------------------------------------------- pipeline
 // One brim-only layer printed BEFORE the object's first layer, carrying the
 // apron that has to be stuck to the belt ahead of the part.
 //
 // Deliberately not a Layer subclass.  A synthetic Layer would inherit id()
 // semantics that leak into initial-layer temperature selection, the spiral vase
 // probe, gradual interpolation, avoid-crossing-perimeters and cooling, all of
 // which key off Layer::id() == 0 or off a layer's regions.  A plain record
 // carries only what the emitter needs.
 //
 // `height` is the LAYER height, used for the Z move and ordering metadata only.
 // Each extrusion path inside `fills` carries its own height, equal to that
 // line's nozzle-to-belt clearance, which varies across the band.
 struct BeltBrimBand
 {
    coordf_t                  print_z = 0.;
    coordf_t                  height  = 0.;
    // erBrim paths in the object's local slicing frame, untranslated.
    ExtrusionEntityCollection fills;
    // Footprint of those paths, for the first-layer convex hull / bbox.
    ExPolygons                areas;
 };
 class PrintObject;
 // Generate the belt brim for one object: fills its per-object-layer bands and
 // its apron prologue.  No-op unless PrintObject::has_belt_brim().
 //
 // Runs inside posSupportMaterial rather than the brim step, because the prologue
 // print_z values must exist before ToolOrdering is built at psWipeTower.
 void make_belt_brim(PrintObject &object);
 } // namespace Slic3r
 #endif // slic3r_BeltBrim_hpp_
@@ -0,0 +1,70 @@
 #include "BeltGCode.hpp"
 #include "BeltGCodeWriter.hpp"
 #include "BeltTransform.hpp"
 #include "Print.hpp"
 namespace Slic3r {
 void BeltGCode::init_belt_writer(Print &print)
 {
    auto belt_writer = std::make_unique<BeltGCodeWriter>();
    // Axis remap and build volume max are set by base GCode after init_belt_writer returns.
    belt_writer->set_belt_back_transform(print.config());
    belt_writer->set_machine_frame_transform(print.config());
    belt_writer->set_xy_offset(m_gcode_offset.x(), m_gcode_offset.y());
    m_writer = std::move(belt_writer);
 }
 void BeltGCode::write_belt_header(GCodeOutputStream &file, const Print &print)
 {
    const auto &full_cfg = print.full_print_config();
    // Slicing rotation: the belt tilt (axis + angle) and the single source of truth
    // for the physical tilt the G-code viewer uses to enable belt view.
    file.write_format("; belt_slice_rotation = %s\n", full_cfg.opt_serialize("belt_slice_rotation").c_str());
    file.write_format("; belt_slice_rotation_angle = %.1f\n", print.config().belt_slice_rotation_angle.value);
    file.write_format("; belt_slice_rotation_global = %d\n", print.config().belt_slice_rotation_global.value ? 1 : 0);
    // Pre-slice remap configs
    file.write_format("; preslice_remap_x = %s\n", full_cfg.opt_serialize("preslice_remap_x").c_str());
    file.write_format("; preslice_remap_y = %s\n", full_cfg.opt_serialize("preslice_remap_y").c_str());
    file.write_format("; preslice_remap_z = %s\n", full_cfg.opt_serialize("preslice_remap_z").c_str());
    file.write_format("; preslice_remap_global = %d\n", print.config().preslice_remap_global.value ? 1 : 0);
    file.write_format("; belt_preslice_global = %d\n", print.config().belt_preslice_global.value ? 1 : 0);
    // Machine-frame transform: shear (tan) + scale (1/cos) derived from the belt
    // tilt angle (or belt_frame_tilt_angle when decoupled).
    file.write_format("; belt_frame_tilt_decouple = %d\n", print.config().belt_frame_tilt_decouple.value ? 1 : 0);
    file.write_format("; belt_frame_tilt_angle = %.1f\n", print.config().belt_frame_tilt_angle.value);
 }
 void BeltGCode::on_set_origin(const PrintObject * /*obj*/, const Point & /*inst_shift*/)
 {
    // Global pre-slice mode: adjust origin using computed correction.
    // Transform the origin through the belt pipeline so that
    // back_transform(T * origin) = origin (correct machine position).
    //
    // Flags that trigger this path:
    //   belt_preslice_global         — full pipeline (rotation * remap) is global
    //   preslice_remap_global        — only the pre-slice remap is global
    //   belt_slice_rotation_global   — slicing rotation treated as global (matches
    //                                  the per-instance Z-offset added in PrintObjectSlice.cpp)
    // The XY origin adjustment uses the FULL forward transform, because the
    // back_transform applied during G-code emission is always the inverse of
    // the full pipeline.
    bool use_global = m_config.belt_preslice_global.value
        || (m_config.preslice_remap_global.value
            && BeltTransformPipeline::has_preslice_remap(m_config))
        || (m_config.belt_slice_rotation_global.value
            && m_config.belt_slice_rotation.value != BeltRotationAxis::None
            && std::abs(m_config.belt_slice_rotation_angle.value) > EPSILON);
    if (!use_global)
        return;
    // Adjust origin: transform through belt forward pipeline so that
    // the back-transform correctly recovers model-space positions.
    Transform3d T = BeltTransformPipeline::build_forward_transform(m_config);
    Vec2d cur_origin = this->origin();
    Vec3d origin3d(cur_origin.x(), cur_origin.y(), 0.);
    Vec3d adjusted = T.linear() * origin3d;
    this->set_origin(Vec2d(adjusted.x(), adjusted.y()));
 }
 } // namespace Slic3r
@@ -0,0 +1,23 @@
 #pragma once
 #include "GCode.hpp"
 namespace Slic3r {
 // Belt-printer-specific GCode export.
 //
 // Inherits from GCode and overrides virtual hooks to:
 // - Create a BeltGCodeWriter instead of a plain GCodeWriter
 // - Write belt configuration to the G-code header
 // - Adjust the origin for global pre-slice transforms when switching instances
 // - Disable arc fitting (G2/G3 not supported on belt printers)
 class BeltGCode : public GCode
 {
 protected:
    void init_belt_writer(Print &print) override;
    void write_belt_header(GCodeOutputStream &file, const Print &print) override;
    void on_set_origin(const PrintObject *obj, const Point &inst_shift) override;
    bool should_disable_arc_fitting() const override { return true; }
 };
 } // namespace Slic3r
@@ -0,0 +1,278 @@
 #include "BeltGCodeWriter.hpp"
 #include "FirstLayerPlane.hpp"
 #include "Geometry.hpp"
 #include <boost/log/trivial.hpp>
 namespace Slic3r {
 namespace {
 // Decide whether a particular destination point gets first-layer treatment.
 // When the plane evaluator is active, distance from the plane wins; otherwise
 // fall back to the layer-coarse m_is_first_layer flag set by the caller.
 inline bool belt_point_on_first_layer(
    const FirstLayerPlane *plane,
    double                 first_layer_thickness_mm,
    bool                   layer_first_flag,
    const Vec3d           &point_slicing_mm)
 {
    if (plane && plane->is_active())
        return plane->is_first_layer(point_slicing_mm, first_layer_thickness_mm);
    return layer_first_flag;
 }
 } // namespace
 // ---- Belt configuration ---------------------------------------------------
 void BeltGCodeWriter::set_belt_back_transform(const PrintConfig &config)
 {
    m_belt_back_transform.init_from_config(config);
 }
 void BeltGCodeWriter::set_machine_frame_transform(const PrintConfig &config)
 {
    m_machine_frame_transform.init_from_config(config);
 }
 Vec3d BeltGCodeWriter::to_machine_coords(const Vec3d &pos) const
 {
    // Step 1+2: To Cartesian (back_transform + axis_remap).
    // In world-coordinates mode (PA line / PA pattern calibration) the input
    // already describes a point relative to the belt surface, so the
    // slicer->world back-transform is skipped and only the machine kinematics
    // (axis remap + frame shear/scale) are applied.
    Vec3d after_back = m_world_coordinates ? pos : m_belt_back_transform.apply(pos);
    Vec3d result     = apply_axis_remap(after_back);
    Vec3d after_remap = result;
    // Step 3: Machine-frame transform (belt frame tilt) applied LAST so it acts
    // as a global linear transform on the placed coords.
    Vec3d final = m_machine_frame_transform.apply(result);
    // [BELT-DEBUG] One-shot log per layer transition (i.e. when the input Z
    // crosses an integer mm boundary) to keep the log volume manageable while
    // still capturing one sample per ~5 layers.  Shows the full pipeline so
    // Case A vs Case B can be compared step-by-step.
    static thread_local int s_last_logged_z = std::numeric_limits<int>::min();
    int z_bucket = static_cast<int>(std::floor(pos.z() * 5.0));  // every 0.2mm
    if (z_bucket != s_last_logged_z) {
        s_last_logged_z = z_bucket;
        BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] to_machine_coords"
            << " slicer_in=(" << pos.x() << "," << pos.y() << "," << pos.z() << ")"
            << " after_back=(" << after_back.x() << "," << after_back.y() << "," << after_back.z() << ")"
            << " after_remap=(" << after_remap.x() << "," << after_remap.y() << "," << after_remap.z() << ")"
            << " final=(" << final.x() << "," << final.y() << "," << final.z() << ")"
            << " mft_active=" << m_machine_frame_transform.is_active()
            << " back_active=" << m_belt_back_transform.is_active();
    }
    return final;
 }
 // ---- Overridden movement methods ------------------------------------------
 std::string BeltGCodeWriter::travel_to_xy(const Vec2d &point, const std::string &comment)
 {
    m_pos(0) = point(0);
    m_pos(1) = point(1);
    this->set_current_position_clear(true);
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
    // Belt printer: transform to machine coordinates (XY travel also needs Z due to YZ rotation)
    Vec3d machine = to_machine_coords(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
    GCodeG1Formatter w;
    w.emit_xyz(machine);
    const bool first_layer_for_point = belt_point_on_first_layer(
        m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer,
        Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
    auto speed = first_layer_for_point
        ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
        : this->config.travel_speed.get_at(m_cached_extruder_idx);
    w.emit_f(speed * 60.0);
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
 }
 std::string BeltGCodeWriter::lazy_lift(LiftType lift_type, bool spiral_vase)
 {
    // Belt printer: force NormalLift since SpiralLift and SlopeLift compute
    // slope angles that don't account for the YZ coordinate rotation.
    return GCodeWriter::lazy_lift(LiftType::NormalLift, spiral_vase);
 }
 std::string BeltGCodeWriter::eager_lift(const LiftType type)
 {
    // Belt printer: force NormalLift (SpiralLift/SlopeLift don't account for YZ rotation).
    return GCodeWriter::eager_lift(LiftType::NormalLift);
 }
 std::string BeltGCodeWriter::_travel_to_z(double z, const std::string &comment)
 {
    m_pos(2) = z;
    double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
    if (speed == 0.) {
        const bool first_layer_for_point = belt_point_on_first_layer(
            m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer,
            Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z));
        speed = first_layer_for_point ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
                                      : this->config.travel_speed.get_at(m_cached_extruder_idx);
    }
    // Belt printer: a Z-only move in slicing frame needs to emit both Y and Z in machine coords.
    Vec3d machine = to_machine_coords(Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z));
    GCodeG1Formatter w;
    w.emit_xyz(machine);
    w.emit_f(speed * 60.0);
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
 }
 std::string BeltGCodeWriter::extrude_to_xy(const Vec2d &point, double dE, const std::string &comment, bool force_no_extrusion)
 {
    m_pos(0) = point(0);
    m_pos(1) = point(1);
    if (std::abs(dE) <= std::numeric_limits<double>::epsilon())
        force_no_extrusion = true;
    if (!force_no_extrusion)
        filament()->extrude(dE);
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
    // Belt printer: transform and emit XYZ (Y and Z are coupled)
    Vec3d machine = to_machine_coords(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
    GCodeG1Formatter w;
    w.emit_xyz(machine);
    if (!force_no_extrusion)
        w.emit_e(filament()->E());
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
 }
 std::string BeltGCodeWriter::extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment, bool force_no_extrusion)
 {
    m_pos = point;
    m_lifted = 0;
    if (!force_no_extrusion)
        filament()->extrude(dE);
    Vec3d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset, point(2) };
    point_on_plate = to_machine_coords(point_on_plate);
    GCodeG1Formatter w;
    w.emit_xyz(point_on_plate);
    if (!force_no_extrusion)
        w.emit_e(filament()->E());
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    return w.string();
 }
 std::string BeltGCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &comment, bool force_z)
 {
    // Belt-specific override of travel_to_xyz.
    // Key differences from base:
    // 1. All coordinates go through to_machine_coords()
    // 2. Always emit full XYZ (can't split XY and Z due to coupling)
    // 3. Lift type forced to NormalLift (handled by lazy_lift/eager_lift overrides)
    Vec3d dest_point = point;
    const bool first_layer_for_point = belt_point_on_first_layer(
        m_first_layer_plane, m_first_layer_thickness_mm, m_is_first_layer,
        Vec3d(point.x() - m_x_offset, point.y() - m_y_offset, point.z()));
    auto travel_speed =
        first_layer_for_point ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx)
                              : this->config.travel_speed.get_at(m_cached_extruder_idx);
    // Handle pending z_hop
    if (std::abs(m_to_lift) > EPSILON) {
        assert(std::abs(m_lifted) < EPSILON);
        if ((!this->is_current_position_clear() || m_pos != dest_point) &&
            m_to_lift + m_pos(2) > point(2)) {
            m_lifted = m_to_lift + m_pos(2) - point(2);
            dest_point(2) = m_to_lift + m_pos(2);
        }
        m_to_lift = 0.;
        std::string slop_move;
        Vec3d source = { m_pos(0) - m_x_offset, m_pos(1) - m_y_offset, m_pos(2) };
        Vec3d target = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
        Vec3d delta = target - source;
        Vec2d delta_no_z = { delta(0), delta(1) };
        if (delta(2) > 0 && delta_no_z.norm() != 0.0f) {
            // Belt: SpiralLift and SlopeLift are disabled (lazy_lift forces NormalLift),
            // but handle NormalLift and fallthrough.
            if (m_to_lift_type == LiftType::SlopeLift &&
                this->is_current_position_clear() &&
                atan2(delta(2), delta_no_z.norm()) < this->filament()->travel_slope()) {
                Vec2d temp = delta_no_z.normalized() * delta(2) / tan(this->filament()->travel_slope());
                Vec3d slope_top_point = Vec3d(temp(0), temp(1), delta(2)) + source;
                slope_top_point = to_machine_coords(slope_top_point);
                GCodeG1Formatter w0;
                w0.emit_xyz(slope_top_point);
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                slop_move = w0.string();
            }
            else if (m_to_lift_type == LiftType::NormalLift && this->is_current_position_clear()) {
                // Only lift-in-place when the current position is known. On a normal
                // printer _travel_to_z emits a Z-only move, but in belt mode Z is coupled
                // to Y/X, so _travel_to_z re-emits the current m_pos through the belt
                // shear. At print start (and after custom gcode) m_pos.xy is still the
                // uninitialised origin (0,0), which shears into a bogus machine point
                // (e.g. X=bed_max, Y=layer_z) far up the gantry. Skipping the separate
                // lift here is safe: there is nothing to lift over yet, and the
                // xy_z_move below travels straight to the destination with full XYZ,
                // establishing the correct position. This mirrors the SlopeLift branch
                // above, which already guards on is_current_position_clear().
                slop_move = _travel_to_z(target.z(), "normal lift Z");
            }
        }
        std::string xy_z_move;
        {
            Vec3d emit_target = to_machine_coords(target);
            GCodeG1Formatter w0;
            // Belt mode: always emit full XYZ since Y and Z are coupled
            w0.emit_xyz(emit_target);
            w0.emit_f(travel_speed * 60.0);
            w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
            xy_z_move = w0.string();
        }
        m_pos = dest_point;
        this->set_current_position_clear(true);
        return slop_move + xy_z_move;
    }
    else if (!force_z && !this->will_move_z(point(2))) {
        double nominal_z = m_pos(2) - m_lifted;
        m_lifted -= (point(2) - nominal_z);
        if (std::abs(m_lifted) < EPSILON)
            m_lifted = 0.;
        this->set_current_position_clear(true);
        return this->travel_to_xy(to_2d(point));
    }
    else {
        m_lifted = 0;
    }
    Vec3d point_on_plate = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
    point_on_plate = to_machine_coords(point_on_plate);
    // Belt mode: always emit full XYZ
    GCodeG1Formatter w;
    w.emit_xyz(point_on_plate);
    // Use the first-layer-aware travel_speed computed at the top of this function,
    // not the raw config travel_speed, so initial-layer travels are correctly slowed.
    w.emit_f(travel_speed * 60.0);
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
    m_pos = dest_point;
    this->set_current_position_clear(true);
    return w.string();
 }
 } // namespace Slic3r
@@ -0,0 +1,64 @@
 #pragma once
 #include "GCodeWriter.hpp"
 #include "GCode/BeltBackTransform.hpp"
 #include "GCode/MachineFrameTransform.hpp"
 namespace Slic3r {
 class FirstLayerPlane;
 // Belt-printer-specific GCode writer.
 //
 // Inherits from GCodeWriter and overrides movement methods to apply
 // coordinate transformation (back-transform, axis remap, machine-frame
 // transform) and emit coupled XYZ moves (Y and Z are coupled due to belt tilt).
 class BeltGCodeWriter : public GCodeWriter
 {
 public:
    BeltGCodeWriter() : GCodeWriter() {}
    // Belt configuration (axis remap is inherited from GCodeWriter)
    void set_belt_back_transform(const PrintConfig &config);
    void set_machine_frame_transform(const PrintConfig &config);
    Vec3d to_machine_coords(const Vec3d &pos) const;
    // World-coordinates mode: incoming coordinates are treated as points
    // relative to the physical belt surface (X across, Y along the belt,
    // Z height above it) instead of slicing-frame coordinates — the
    // slicer->world back-transform is skipped. Used by the PA line / PA
    // pattern calibration generators, whose logical bed coordinates describe
    // first-layer drawings on the build surface.
    void set_world_coordinates(bool enable) { m_world_coordinates = enable; }
    // First-layer plane: when set to a non-null active evaluator, travel
    // speed selection consults the plane per-move and uses
    // initial_layer_travel_speed for points within first_layer_height_mm
    // of the plane (regardless of slicing layer index).
    void set_first_layer_plane(const FirstLayerPlane *plane,
                               double first_layer_height_mm) {
        m_first_layer_plane         = plane;
        m_first_layer_thickness_mm  = first_layer_height_mm;
    }
    // Overridden movement methods
    std::string travel_to_xy(const Vec2d &point, const std::string &comment = std::string()) override;
    std::string travel_to_xyz(const Vec3d &point, const std::string &comment = std::string(), bool force_z = false) override;
    std::string extrude_to_xy(const Vec2d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false) override;
    std::string extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false) override;
    std::string lazy_lift(LiftType lift_type = LiftType::NormalLift, bool spiral_vase = false) override;
    std::string eager_lift(const LiftType type) override;
 protected:
    std::string _travel_to_z(double z, const std::string &comment) override;
 private:
    BeltBackTransform     m_belt_back_transform;
    MachineFrameTransform m_machine_frame_transform;
    bool                  m_world_coordinates = false;
    // Borrowed pointer; lifetime owned by GCode.  null = inactive.
    const FirstLayerPlane *m_first_layer_plane = nullptr;
    double          m_first_layer_thickness_mm = 0.;
 };
 } // namespace Slic3r
@@ -0,0 +1,346 @@
 // ORCA-Belt: backend of the belt purge tower (the belt replacement for the
 // classic wipe/prime tower).
 //
 // Kept in its own translation unit so the belt-purge logic stays out of the way
 // of unrelated upstream changes to Print.cpp / PrintObjectSlice.cpp and carries
 // no regression risk for normal printers: none of these methods do anything
 // unless the print is a belt printer with the belt purge tower enabled.
 //
 //   Print::has_belt_purge_tower()      - is the belt purge tower active?
 //   Print::_align_belt_purge_layers()  - snap the prism's layer grid onto the
 //                                        printed objects' grid
 //   Print::_plan_belt_purge()          - route filament-change purging into the
 //                                        prism (flush-into-objects), no wipe tower
 //   PrintObject::belt_shift_layer_grid()      - shift a sliced layer grid
 //   PrintObject::belt_truncate_layers_above() - cancel the prism past the last swap
 //
 // (Declarations live in Print.hpp alongside the rest of the Print interface.)
 #include "Print.hpp"
 #include "PrintConfig.hpp"
 #include "Exception.hpp"
 #include "GCode/ToolOrdering.hpp"
 #include "Layer.hpp"
 #include "ExtrusionEntity.hpp"
 #include "ExtrusionEntityCollection.hpp"
 #include "I18N.hpp"
 #include "format.hpp"
 #include "LocalesUtils.hpp"
 #include "libslic3r.h"
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <boost/log/trivial.hpp>
 namespace Slic3r {
 // Belt purge prism: purging after filament changes is routed into a sliced
 // prism object via the flush-into-objects machinery instead of a wipe tower.
 bool Print::has_belt_purge_tower() const
 {
    // Its own purge-tower "type", gated by the belt-only enable_belt_purge_tower
    // option (not the classic enable_prime_tower).
    if (!(m_config.belt_printer.value
          && m_config.enable_belt_purge_tower.value
          && !m_config.spiral_mode.value
          && m_config.filament_diameter.values.size() > 1))
        return false;
    return std::any_of(m_objects.begin(), m_objects.end(), [](const PrintObject *object) {
        return object->config().belt_purge_tower_object.value;
    });
 }
 // Belt mode: align ALL objects on the plate (the printed objects AND the purge
 // prism) onto one common layer grid, so the prism can absorb every toolchange.
 //
 // After belt slicing each object's layer print_z carries a per-object global z
 // offset (mesh-vertex-scan belt_z_shift + instance-Y-dependent terms), so
 // objects at different belt-Y positions get layer grids with DIFFERENT residues
 // (mod layer height). Purge marking looks absorbers up with
 // get_layer_at_printz(lt.print_z, EPSILON), so a toolchange on object B only
 // absorbs into the prism if the prism has a layer at B's print_z. Snapping only
 // the prism to one object therefore worked for a single (assembled) multi-color
 // object but failed with multiple separate objects — the prism could follow only
 // one grid, and toolchanges on the others went unabsorbed ("multiple layer
 // grids" warning).
 //
 // Fix: pick one reference grid (the tallest object) and shift every object onto
 // it. Each shift is at most half a layer height — a sub-100µm move along the
 // belt, the very same mechanism the per-object global_z_offset already uses, and
 // it keeps each object internally consistent (belt_shift_layer_grid moves the
 // object's layers, its support layers, and its belt floor together). Equal layer
 // height across objects is enforced by Print::validate(), so once residues match
 // every object steps on the same lattice {ref_offset + k*h} and every toolchange
 // layer coincides with a prism layer.
 void Print::_align_belt_purge_layers()
 {
    PrintObject *prism = nullptr;
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value && !po->layers().empty()) {
            prism = po;
            break;
        }
    if (prism == nullptr || prism->layers().empty())
        return;
    const double h = prism->config().layer_height.value;
    if (h <= EPSILON)
        return;
    // Grid residue of an object's layer grid: identical for all of an object's
    // layers above the first since they step by h.
    auto grid_offset = [h](const PrintObject *po) -> double {
        if (po->layers().empty())
            return 0.;
        const double z = po->layers().front()->print_z;
        return z - std::floor(z / h) * h; // in [0, h)
    };
    // Reference grid: the tallest non-prism object (proxy for the object with
    // the most toolchange layers — minimizes how far the rest must move).
    const PrintObject *ref     = nullptr;
    double             ref_top = -std::numeric_limits<double>::max();
    for (const PrintObject *po : m_objects) {
        if (po->config().belt_purge_tower_object.value || po->layers().empty())
            continue;
        const double top = po->layers().back()->print_z;
        if (top > ref_top) {
            ref_top = top;
            ref     = po;
        }
    }
    if (ref == nullptr)
        return;
    const double ref_offset = grid_offset(ref);
    // Snap every object (printed objects AND the prism) onto the reference grid.
    for (PrintObject *po : m_objects) {
        if (po->layers().empty())
            continue;
        double delta = ref_offset - grid_offset(po);
        if (delta > 0.5 * h)
            delta -= h;
        else if (delta <= -0.5 * h)
            delta += h;
        po->belt_shift_layer_grid(delta); // no-op for the reference object (delta ~ 0)
    }
    BOOST_LOG_TRIVIAL(debug) << "[BELT-DEBUG] purge grid align: snapped " << m_objects.size()
        << " objects onto ref grid offset=" << ref_offset
        << " (ref=" << ref->model_object()->name << ")";
 }
 // Belt mode replacement for _make_wipe_tower(): plan filament-change purging
 // into the belt purge prism (and any other flush_into_* object) using the
 // flush-into-objects machinery, without generating classic wipe tower G-code.
 // The toolchange itself is emitted by GCode::set_extruder() via the
 // change_filament_gcode macro; the overrides marked here make the new
 // filament's first extrusions land in the purge prism.
 void Print::_plan_belt_purge()
 {
    m_wipe_tower_data.clear();
    // psWipeTower may be invalidated without posSlice (for example after a
    // filament-map or tool-ordering change). Restore a prism shortened by the
    // previous plan so a newly higher toolchange can use its original layers.
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value)
            po->belt_restore_truncated_layers();
    // Must run before ToolOrdering is built: LayerTools merge per-object layer
    // print_z values, and the prism only absorbs purge where its (snapped)
    // layers coincide with the toolchange layers.
    this->_align_belt_purge_layers();
    const unsigned int number_of_extruders = (unsigned int) m_config.filament_colour.values.size();
    // No initial priming extrusions: there is no tower to prime on.
    m_wipe_tower_data.tool_ordering = ToolOrdering(*this, (unsigned int) -1, false);
    m_wipe_tower_data.tool_ordering.sort_and_build_data(*this, (unsigned int) -1, false);
    if (m_wipe_tower_data.tool_ordering.empty() || m_wipe_tower_data.tool_ordering.last_extruder() == unsigned(-1))
        throw Slic3r::SlicingError("The print is empty. The model is not printable with current print settings.");
    if (!m_wipe_tower_data.tool_ordering.has_wipe_tower())
        // No toolchanges anywhere, nothing to purge.
        return;
    this->throw_if_canceled();
    // Flush volumes per filament pair, mirroring the generic wipe tower path:
    // full flush matrix for single extruder multi material with purging enabled,
    // plain prime volume otherwise.
    std::vector<float> flush_matrix(cast<float>(
        get_flush_volumes_matrix(m_config.flush_volumes_matrix.values, 0, m_config.nozzle_diameter.values.size())));
    std::vector<std::vector<float>> wipe_volumes;
    for (unsigned int i = 0; i < number_of_extruders; ++i)
        wipe_volumes.push_back(std::vector<float>(flush_matrix.begin() + i * number_of_extruders,
                                                  flush_matrix.begin() + (i + 1) * number_of_extruders));
    const bool  use_flush_matrix = m_config.purge_in_prime_tower && m_config.single_extruder_multi_material;
    const float flush_multiplier = (float) m_config.flush_multiplier.get_at(0);
    // Cancel the purge prism early: pre-scan the tool ordering for the highest
    // print_z that actually has a toolchange, then drop the prism's layers above
    // it so the tower stops at the last color swap (saves filament/time). This
    // MUST happen before the marking loop below: ensure_perimeters_infills_order
    // force-overrides the prism's extrusions on every layer (it is a dedicated
    // flush object), so truncating afterwards would leave dangling overrides
    // pointing into deleted layers.
    {
        double       last_tc_z   = -1.;
        unsigned int cur_ext     = m_wipe_tower_data.tool_ordering.first_extruder();
        for (const auto &lt : m_wipe_tower_data.tool_ordering.layer_tools())
            for (const unsigned int e : lt.extruders)
                if (e != cur_ext) { last_tc_z = lt.print_z; cur_ext = e; }
        if (last_tc_z >= 0.)
            for (PrintObject *po : m_objects)
                if (po->config().belt_purge_tower_object.value && !po->layers().empty()) {
                    po->belt_truncate_layers_above(last_tc_z);
                    break;
                }
    }
    // Diagnostic: the prism only absorbs purge at toolchange layers whose
    // print_z coincides with one of its own layers. Compare the prism's layer
    // print_z range to the toolchange print_z range and count how many
    // toolchange layers actually land on a prism layer. This distinguishes a
    // range/grid-alignment failure (no coverage) from a capacity shortfall
    // (covered but not enough cross-section).
    PrintObject *prism_po = nullptr;
    for (PrintObject *po : m_objects)
        if (po->config().belt_purge_tower_object.value && !po->layers().empty()) { prism_po = po; break; }
    const PrintObject *diag_prism = prism_po;
    if (diag_prism != nullptr)
        BOOST_LOG_TRIVIAL(warning) << "[BELT-DEBUG] purge prism layer range print_z=["
            << diag_prism->layers().front()->print_z << ", " << diag_prism->layers().back()->print_z
            << "] nlayers=" << diag_prism->layers().size();
    int tc_layers = 0, tc_layers_covered = 0;
    float  total_leftover      = 0.f;
    float  worst_layer_leftover = 0.f;
    double worst_layer_z       = 0.;
    unsigned int current_extruder_id = m_wipe_tower_data.tool_ordering.first_extruder();
    for (auto &layer_tools : m_wipe_tower_data.tool_ordering.layer_tools()) {
        float layer_leftover = 0.f;
        bool  layer_has_tc   = false;
        for (const unsigned int extruder_id : layer_tools.extruders) {
            if (extruder_id == current_extruder_id)
                continue;
            if (!layer_has_tc) {
                layer_has_tc = true;
                ++tc_layers;
                if (diag_prism != nullptr && diag_prism->get_layer_at_printz(layer_tools.print_z, EPSILON) != nullptr)
                    ++tc_layers_covered;
            }
            float volume_to_wipe = use_flush_matrix ?
                wipe_volumes[current_extruder_id][extruder_id] * flush_multiplier :
                (float) m_config.prime_volume;
            float leftover = layer_tools.wiping_extrusions().mark_wiping_extrusions(*this, current_extruder_id, extruder_id,
                                                                                    volume_to_wipe);
            BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] purge toolchange print_z=" << layer_tools.print_z
                << " filament " << current_extruder_id << "->" << extruder_id
                << " requested=" << volume_to_wipe
                << " absorbed=" << volume_to_wipe - leftover
                << " leftover=" << leftover;
            layer_leftover += leftover;
            current_extruder_id = extruder_id;
        }
        // Do not destructively remove unclaimed fill entities here. psWipeTower
        // can rerun without regenerating infill, and a later tool ordering may
        // need entities that were unclaimed by the previous plan.
        layer_tools.wiping_extrusions().ensure_perimeters_infills_order(*this);
        if (layer_leftover > 0.f) {
            total_leftover += layer_leftover;
            if (layer_leftover > worst_layer_leftover) {
                worst_layer_leftover = layer_leftover;
                worst_layer_z        = layer_tools.print_z;
            }
        }
        this->throw_if_canceled();
    }
    BOOST_LOG_TRIVIAL(warning) << "[BELT-DEBUG] purge coverage: " << tc_layers_covered << "/" << tc_layers
        << " toolchange layers land on a prism layer"
        << (tc_layers > 0 && tc_layers_covered == 0 ? " (RANGE/GRID MISALIGNMENT — prism absorbs nothing)" :
            tc_layers_covered < tc_layers ? " (partial coverage)" : " (full coverage)");
    if (total_leftover > 1.f) {
        this->active_step_add_warning(
            PrintStateBase::WarningLevel::CRITICAL,
            Slic3r::format(_u8L("The belt purge tower cannot absorb the full purge volume: %1% mm³ in total could not "
                                "be purged (worst layer: %2% mm³ at height %3%). The print may show color bleeding. "
                                "Increase the belt purge tower width, or reduce flushing volumes."),
                           int(std::ceil(total_leftover)), int(std::ceil(worst_layer_leftover)),
                           Slic3r::float_to_string_decimal_point(worst_layer_z, 2)));
        BOOST_LOG_TRIVIAL(warning) << "[BELT-DEBUG] purge planning leftover total=" << total_leftover
            << " worst_layer=" << worst_layer_leftover << " at print_z=" << worst_layer_z;
    }
 }
 // Belt mode: shift the sliced layer grid by delta. Mirrors the global_z_offset
 // application in slice() — layer print_z and belt_floor_z_shift move together
 // so belt floor clipping stays consistent with the shifted grid. Used by
 // Print::_align_belt_purge_layers() to snap the purge prism onto the printed
 // objects' layer grid; |delta| <= half a layer height, i.e. a sub-layer shift
 // of the prism along the belt.
 void PrintObject::belt_shift_layer_grid(double delta)
 {
    if (std::abs(delta) < EPSILON)
        return;
    for (Layer *layer : m_layers)
        layer->print_z += delta;
    for (SupportLayer *layer : m_support_layers)
        layer->print_z += delta;
    m_slicing_params.belt_floor_z_shift += delta;
    BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] belt_shift_layer_grid"
        << " obj=" << this->model_object()->name
        << " delta=" << delta
        << " first_layer.print_z=" << (m_layers.empty() ? 0. : m_layers.front()->print_z);
 }
 // Belt mode: drop layers strictly above z (used to cancel the purge prism early
 // once there are no more toolchanges above z, so the tower stops at the last
 // color swap instead of wasting filament up the rest of the belt). Each layer's
 // cross-section is already sliced, so removing upper layers does not affect the
 // last toolchange's coverage. Deletes the Layer objects and clears the new top
 // layer's upper-layer link. Returns the number of layers removed.
 size_t PrintObject::belt_truncate_layers_above(coordf_t z)
 {
    // A repeated plan always starts from the restored full layer set.
    assert(m_belt_truncated_layers.empty());
    size_t keep = m_layers.size();
    while (keep > 0 && m_layers[keep - 1]->print_z > z + EPSILON)
        --keep;
    if (keep >= m_layers.size())
        return 0;
    const size_t removed = m_layers.size() - keep;
    m_belt_truncated_layers.assign(m_layers.begin() + keep, m_layers.end());
    m_layers.resize(keep);
    if (!m_layers.empty())
        m_layers.back()->upper_layer = nullptr;
    BOOST_LOG_TRIVIAL(debug) << "[BELT-DEBUG] truncate purge prism above print_z=" << z
        << " kept=" << keep << " removed=" << removed
        << " new_top=" << (m_layers.empty() ? 0. : m_layers.back()->print_z);
    return removed;
 }
 void PrintObject::belt_restore_truncated_layers()
 {
    if (m_belt_truncated_layers.empty())
        return;
    m_layers.insert(m_layers.end(), m_belt_truncated_layers.begin(), m_belt_truncated_layers.end());
    m_belt_truncated_layers.clear();
    for (size_t i = 0; i < m_layers.size(); ++i) {
        m_layers[i]->lower_layer = i == 0 ? nullptr : m_layers[i - 1];
        m_layers[i]->upper_layer = i + 1 < m_layers.size() ? m_layers[i + 1] : nullptr;
    }
 }
 } // namespace Slic3r
@@ -0,0 +1,143 @@
 #include "BeltSliceStrategy.hpp"
 #include "Model.hpp"
 #include <limits>
 #include <boost/log/trivial.hpp>
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
 #include <iomanip>
 #include <sstream>
 #include <thread>
 #endif
 namespace Slic3r {
 void BeltSliceStrategy::apply_preslice_transforms(Transform3d           &trafo,
                                                  const PrintConfig     &config,
                                                  const ModelVolumePtrs &model_volumes,
                                                  double                *out_belt_min_z)
 {
    // 1. Standalone pre-slice axis remap (works without belt mode).
    const bool has_remap = BeltTransformPipeline::has_preslice_remap(config);
    if (has_remap)
        trafo = BeltTransformPipeline::build_preslice_remap(config) * trafo;
    // 2. Belt rotation — the sole mesh-side belt transform (matching
    //    BeltTransformPipeline::build_forward_transform).  Only active in
    //    belt-printer mode.
    bool has_rotation = false;
    if (config.belt_printer.value) {
        const Matrix3d rot = BeltTransformPipeline::build_rotation_matrix(config, &has_rotation);
        if (has_rotation) {
            Transform3d belt_xform = Transform3d::Identity();
            belt_xform.linear() = rot;
            trafo = belt_xform * trafo;
        }
    }
    if (!has_remap && !has_rotation)
        return;
    // 3. Z-shift — detect if the mesh clips below the build plate after the
    // transforms and lift it.  Each mesh vertex must be brought into object space
    // via mv->get_matrix() before applying the full trafo (which is in object
    // space).  Missing this on assemblies (where per-volume get_matrix() positions
    // each volume within the object) would compute min_z against mesh-local vertex
    // coordinates rather than object-space coordinates, so volumes translated along
    // the slicer's Z axis would be silently excluded from the bound check.
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
    // Capture the incoming trafo for diagnostic logging.
    // This is the slicer-frame transform AFTER remap + rotation but BEFORE z_shift.
    const Transform3d trafo_pre_shift = trafo;
    auto log_mat = [](const Matrix3d &m) {
        std::ostringstream ss;
        ss << std::fixed << std::setprecision(4);
        ss << "[[" << m(0,0) << "," << m(0,1) << "," << m(0,2) << "],"
           << "["  << m(1,0) << "," << m(1,1) << "," << m(1,2) << "],"
           << "["  << m(2,0) << "," << m(2,1) << "," << m(2,2) << "]]";
        return ss.str();
    };
    auto log_vec3 = [](const Vec3d &v) {
        std::ostringstream ss;
        ss << std::fixed << std::setprecision(4);
        ss << "(" << v.x() << "," << v.y() << "," << v.z() << ")";
        return ss.str();
    };
    BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] apply_preslice_transforms enter"
        << " has_rotation=" << has_rotation
        << " has_remap=" << has_remap
        << " trafo.linear=" << log_mat(trafo_pre_shift.linear())
        << " trafo.translation=" << log_vec3(trafo_pre_shift.translation())
        << " volumes=" << model_volumes.size();
 #endif
    double min_z = std::numeric_limits<double>::max();
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
    int vol_idx = 0;
 #endif
    for (const ModelVolume *mv : model_volumes) {
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
        if (!mv->is_model_part()) { ++vol_idx; continue; }
 #else
        if (!mv->is_model_part()) continue;
 #endif
        Transform3d vol_trafo = trafo * mv->get_matrix();
        const auto &its = mv->mesh().its;
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
        // Per-volume bbox in mesh-frame and post-trafo slicer-frame.
        Vec3d mesh_min(std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
        Vec3d mesh_max(std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest());
        Vec3d slicer_min(std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
        Vec3d slicer_max(std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest(), std::numeric_limits<double>::lowest());
        double vol_min_z = std::numeric_limits<double>::max();
 #endif
        for (const stl_vertex &v : its.vertices) {
            Vec3d vm = v.cast<double>();
            Vec3d pt = vol_trafo * vm;
            min_z = std::min(min_z, pt.z());
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
            mesh_min = mesh_min.cwiseMin(vm);
            mesh_max = mesh_max.cwiseMax(vm);
            slicer_min = slicer_min.cwiseMin(pt);
            slicer_max = slicer_max.cwiseMax(pt);
            vol_min_z = std::min(vol_min_z, pt.z());
 #endif
        }
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
        BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG]   vol[" << vol_idx
            << "] id=" << mv->id().id << " name='" << mv->name << "'"
            << " mesh_bbox_min=" << log_vec3(mesh_min) << " mesh_bbox_max=" << log_vec3(mesh_max)
            << " get_matrix.translation=" << log_vec3(mv->get_matrix().translation())
            << " slicer_bbox_min=" << log_vec3(slicer_min) << " slicer_bbox_max=" << log_vec3(slicer_max)
            << " vol_min_z=" << vol_min_z;
        ++vol_idx;
 #endif
    }
    const double z_shift_val = (min_z < 0. && min_z != std::numeric_limits<double>::max()) ? -min_z : 0.;
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
    BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] combined min_z=" << min_z
        << " z_shift_val=" << z_shift_val;
 #endif
    if (z_shift_val > 0.) {
        Transform3d z_shift = Transform3d::Identity();
        z_shift.matrix()(2, 3) = z_shift_val;
        trafo = z_shift * trafo;
    }
    // out_belt_min_z is only meaningful in belt mode; the standalone-remap path
    // never reported it.
    if (out_belt_min_z && config.belt_printer.value) {
        const double new_val = (min_z != std::numeric_limits<double>::max()) ? min_z : 0.;
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
        BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] write m_belt_min_z tid=" << std::this_thread::get_id()
            << " target=" << out_belt_min_z << " old=" << *out_belt_min_z << " new=" << new_val;
 #endif
        *out_belt_min_z = new_val;
    }
 #ifdef SLIC3R_BELT_DIAGNOSTIC_LOG
    BOOST_LOG_TRIVIAL(trace) << "[BELT-DEBUG] apply_preslice_transforms exit"
        << " final_trafo.linear=" << log_mat(trafo.linear())
        << " final_trafo.translation=" << log_vec3(trafo.translation());
 #endif
 }
 } // namespace Slic3r
@@ -0,0 +1,36 @@
 #pragma once
 #include "libslic3r.h"
 #include "Point.hpp"
 #include "BeltTransform.hpp"
 #include "PrintConfig.hpp"
 #include "Model.hpp"
 namespace Slic3r {
 // Belt printer / pre-slice transform strategy.
 //
 // Composes, in order, the pre-slice mesh transforms applied before slicing:
 //   1. Pre-slice axis remap (standalone — works without belt mode)
 //   2. Belt rotation (the sole mesh-side belt transform; shear & scale are a
 //      g-code-side stage, see MachineFrameTransform)
 //   3. Per-object Z-shift that lifts the mesh above the build plate
 //
 // Isolates this belt/remap-specific logic from the generic slicing pipeline in
 // PrintObjectSlice.cpp.
 class BeltSliceStrategy
 {
 public:
    // Apply the pre-slice remap + belt rotation + Z-shift to `trafo` in place.
    // No-op when neither a remap nor a belt rotation is configured.
    //
    // out_belt_min_z (if non-null) receives the minimum mesh Z after the
    // transforms, but only in belt-printer mode — the standalone-remap path
    // never reported it.
    static void apply_preslice_transforms(Transform3d           &trafo,
                                          const PrintConfig     &config,
                                          const ModelVolumePtrs &model_volumes,
                                          double                *out_belt_min_z = nullptr);
 };
 } // namespace Slic3r
@@ -0,0 +1,223 @@
 #include "BeltTransform.hpp"
 #include "Model.hpp"
 #include <limits>
 namespace Slic3r {
 // ---- Matrix builders ------------------------------------------------------
 Transform3d BeltTransformPipeline::build_preslice_remap(const PrintConfig &config)
 {
    Transform3d pre_remap = Transform3d::Identity();
    if (!has_preslice_remap(config))
        return pre_remap;
    int pre_rx = int(config.preslice_remap_x.value);
    int pre_ry = int(config.preslice_remap_y.value);
    int pre_rz = int(config.preslice_remap_z.value);
    // Each remap value selects a source axis and sign.
    auto remap_column = [](int r) -> Vec3d {
        int axis = r % 3;
        Vec3d col = Vec3d::Zero();
        if (r < 3)      col[axis] =  1.0;  // +axis
        else if (r < 6) col[axis] = -1.0;  // -axis
        else            col[axis] = -1.0;  // Rev: max - pos = -(pos - max)
        return col;
    };
    Matrix3d remap_lin;
    remap_lin.col(0) = remap_column(pre_rx);
    remap_lin.col(1) = remap_column(pre_ry);
    remap_lin.col(2) = remap_column(pre_rz);
    pre_remap.linear() = remap_lin;
    // Translation for Rev modes (needs build volume extents).
    if (pre_rx >= 6 || pre_ry >= 6 || pre_rz >= 6) {
        BoundingBoxf bbox_bed(config.printable_area.values);
        Vec3d vol_max(bbox_bed.max.x(), bbox_bed.max.y(),
                      config.printable_height.value);
        Vec3d remap_trans = Vec3d::Zero();
        auto add_rev = [&](int r, int out) {
            if (r >= 6) remap_trans[out] = vol_max[r % 3];
        };
        add_rev(pre_rx, 0);
        add_rev(pre_ry, 1);
        add_rev(pre_rz, 2);
        pre_remap.translation() = remap_trans;
    }
    return pre_remap;
 }
 Matrix3d BeltTransformPipeline::build_rotation_matrix(const PrintConfig &config, bool *has_rot_out)
 {
    BeltRotationAxis axis = config.belt_slice_rotation.value;
    double angle_deg = config.belt_slice_rotation_angle.value;
    bool active = axis != BeltRotationAxis::None && std::abs(angle_deg) > EPSILON;
    if (has_rot_out) *has_rot_out = active;
    if (!active)
        return Matrix3d::Identity();
    double angle_rad = Geometry::deg2rad(angle_deg);
    Vec3d unit_axis;
    switch (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:                  return Matrix3d::Identity();
    }
    return Eigen::AngleAxisd(angle_rad, unit_axis).toRotationMatrix();
 }
 Transform3d BeltTransformPipeline::build_forward_transform(const PrintConfig &config)
 {
    // Mesh-side belt transform: rotation applied after the pre-slice axis remap.
    // (Shear & scale are a g-code-side stage, not part of the mesh transform.)
    Transform3d pre_remap = build_preslice_remap(config);
    Matrix3d    rot       = build_rotation_matrix(config);
    Transform3d combined = Transform3d::Identity();
    combined.linear() = rot;
    combined = combined * pre_remap;
    return combined;
 }
 // ---- Bounding box remap ---------------------------------------------------
 BoundingBoxf3 BeltTransformPipeline::remap_bbox(const BoundingBoxf3 &bb, const PrintConfig &config)
 {
    int pre_rx = int(config.preslice_remap_x.value);
    int pre_ry = int(config.preslice_remap_y.value);
    int pre_rz = int(config.preslice_remap_z.value);
    if (pre_rx == int(RemapAxis::PosX) &&
        pre_ry == int(RemapAxis::PosY) &&
        pre_rz == int(RemapAxis::PosZ))
        return bb;  // Identity remap.
    auto remap_coord = [](int r, const Vec3d &v) -> double {
        int axis = r % 3;
        if (r < 3) return v[axis];
        return -v[axis];
    };
    Vec3d mn = bb.min.cast<double>(), mx = bb.max.cast<double>();
    BoundingBoxf3 rbb;
    for (int i = 0; i < 8; ++i) {
        Vec3d c((i & 1) ? mx.x() : mn.x(),
                (i & 2) ? mx.y() : mn.y(),
                (i & 4) ? mx.z() : mn.z());
        Vec3d rc(remap_coord(pre_rx, c), remap_coord(pre_ry, c), remap_coord(pre_rz, c));
        if (i == 0) rbb = BoundingBoxf3(rc, rc);
        else rbb.merge(rc);
    }
    return rbb;
 }
 BoundingBoxf3 BeltTransformPipeline::remap_bbox(const ModelObject &model_object, const PrintConfig &config)
 {
    return remap_bbox(model_object.raw_bounding_box(), config);
 }
 // ---- Belt floor parameters ------------------------------------------------
 // Shared implementation for both PrintConfig and DynamicPrintConfig.
 // Template avoids duplicating the math for the two config types.
 namespace {
 template<typename Config>
 BeltTransformPipeline::BeltHeightResult compute_belt_height_and_floor_impl(
    const Config &config, const BoundingBoxf3 &bb, double original_height)
 {
    BeltTransformPipeline::BeltHeightResult result;
    result.object_height = original_height;
    // Extract the mesh rotation from config (the sole mesh-side belt transform).
    BeltRotationAxis rot_axis;
    double           rot_angle;
    if constexpr (std::is_same_v<Config, PrintConfig>) {
        rot_axis  = config.belt_slice_rotation.value;
        rot_angle = config.belt_slice_rotation_angle.value;
    } else {
        // DynamicPrintConfig path
        auto get_float = [&](const char *key) {
            auto *opt = config.template option<ConfigOptionFloat>(key);
            return opt ? opt->value : 0.0;
        };
        auto get_rot_axis = [&](const char *key) {
            auto *opt = config.template option<ConfigOptionEnum<BeltRotationAxis>>(key);
            return opt ? opt->value : BeltRotationAxis::None;
        };
        rot_axis  = get_rot_axis("belt_slice_rotation");
        rot_angle = get_float("belt_slice_rotation_angle");
    }
    bool has_rotation = rot_axis != BeltRotationAxis::None && std::abs(rot_angle) > EPSILON;
    if (!has_rotation)
        return result;
    // Rotation path: sweep the 8 bbox corners through R to get the rotated height,
    // then derive the belt floor (the image of machine-Z = 0 under R).
    double angle_rad = Geometry::deg2rad(rot_angle);
    Vec3d unit_axis;
    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:                  unit_axis = Vec3d::UnitX(); break;
    }
    Matrix3d R = Eigen::AngleAxisd(angle_rad, unit_axis).toRotationMatrix();
    double min_rz = std::numeric_limits<double>::max();
    double max_rz = std::numeric_limits<double>::lowest();
    for (int i = 0; i < 8; ++i) {
        Vec3d c((i & 1) ? bb.max.x() : bb.min.x(),
                (i & 2) ? bb.max.y() : bb.min.y(),
                (i & 4) ? bb.max.z() : bb.min.z());
        double z = (R * c).z();
        min_rz = std::min(min_rz, z);
        max_rz = std::max(max_rz, z);
    }
    result.object_height = max_rz - min_rz;
    // Belt floor in slicer-frame is the image of z_machine = 0 under R.
    //   R(+α, X): point (·, y, 0) → (·, cos α · y, sin α · y) ⇒ z = tan(α) · y_s
    //   R(+α, Y): point (x, ·, 0) → (cos α · x, ·, -sin α · x) ⇒ z = -tan(α) · x_s
    //   R(+α, Z): point (·, ·, 0) → (·, ·, 0); no tilt → no floor
    double sin_a = std::sin(angle_rad), cos_a = std::cos(angle_rad);
    switch (rot_axis) {
    case BeltRotationAxis::X:
        result.floor_params.shear_factor = (std::abs(cos_a) > EPSILON) ?  sin_a / cos_a : 0.;
        result.floor_params.from_axis    = 1; // Y
        break;
    case BeltRotationAxis::Y:
        result.floor_params.shear_factor = (std::abs(cos_a) > EPSILON) ? -sin_a / cos_a : 0.;
        result.floor_params.from_axis    = 0; // X
        break;
    case BeltRotationAxis::Z:
    default:
        result.floor_params.shear_factor = 0.0;
        result.floor_params.from_axis    = 1;
        break;
    }
    result.floor_params.z_shift = bb.min.z() + ((min_rz < 0.) ? -min_rz : 0.);
    return result;
 }
 } // anonymous namespace
 BeltTransformPipeline::BeltHeightResult BeltTransformPipeline::compute_belt_height_and_floor(
    const PrintConfig &config, const BoundingBoxf3 &remapped_bbox, double original_height)
 {
    return compute_belt_height_and_floor_impl(config, remapped_bbox, original_height);
 }
 BeltTransformPipeline::BeltHeightResult BeltTransformPipeline::compute_belt_height_and_floor(
    const DynamicPrintConfig &config, const BoundingBoxf3 &remapped_bbox, double original_height)
 {
    return compute_belt_height_and_floor_impl(config, remapped_bbox, original_height);
 }
 } // namespace Slic3r
@@ -0,0 +1,152 @@
 #pragma once
 #include "libslic3r.h"
 #include "Point.hpp"
 #include "BoundingBox.hpp"
 #include "PrintConfig.hpp"
 #include "Geometry.hpp"
 #include <cmath>
 namespace Slic3r {
 class ModelObject;
 // Shared belt-printer transform math.
 //
 // The pre-slice pipeline applied in PrintObjectSlice.cpp is:
 //     trafo_out = z_shift * rotation * pre_remap * trafo_in
 //
 // Rotation is the sole mesh-side belt transform; shear & scale are applied
 // to the g-code instead (see MachineFrameTransform).  This class provides the
 // building blocks so every call site uses the same implementation.  z_shift is
 // object-dependent (computed from mesh vertex bounds) and is NOT included in
 // build_forward_transform().  The machine-frame shear/scale is derived directly
 // from the tilt angle in MachineFrameTransform and no longer lives here.
 //
 // Design note: this mesh-rotation approach replaced an earlier pre-shear
 // method (now removed).  While that initial pre-shear method was instrumental
 // in getting belt printer slicing off the ground in the first place, its place is
 // in the past.  A big thank you goes to the Unlayered3D team, who recommended 
 // switching to a pre-slice rotation stage instead.  Doing so keeps the slicing 
 // operation isometric — no distortion of the sliced geometry — while the 
 // non-orthogonal machine-axis compensation is confined to a g-code-side shear/scale
 // derived from the same tilt angle.
 // 
 // This fixed a number of issues, including several issues noticed by hotcubcar
 // regarding adaptive infills not working, gyroid becoming anisotropic, and more 
 // that were all mostly resolved as a result of the switch.
 // 
 // This also means that the pre-slice rotation transform methodology can be used 
 // more cleanly on non-belt printers.
 // - HarrierPigeon (Joseph Robertson)
 class BeltTransformPipeline
 {
 public:
    // ---- Identity checks --------------------------------------------------
    static bool has_preslice_remap(const PrintConfig &config)
    {
        return int(config.preslice_remap_x.value) != int(RemapAxis::PosX) ||
               int(config.preslice_remap_y.value) != int(RemapAxis::PosY) ||
               int(config.preslice_remap_z.value) != int(RemapAxis::PosZ);
    }
    // Overload accepting DynamicPrintConfig (used in static slicing_parameters).
    static bool has_preslice_remap(const DynamicPrintConfig &config)
    {
        auto get_int = [&](const char *key) -> int {
            auto *opt = config.option<ConfigOptionEnum<RemapAxis>>(key);
            return opt ? int(opt->value) : 0;
        };
        return get_int("preslice_remap_x") != int(RemapAxis::PosX) ||
               get_int("preslice_remap_y") != int(RemapAxis::PosY) ||
               get_int("preslice_remap_z") != int(RemapAxis::PosZ);
    }
    static bool has_rotation(const PrintConfig &config)
    {
        return config.belt_slice_rotation.value != BeltRotationAxis::None &&
               std::abs(config.belt_slice_rotation_angle.value) > EPSILON;
    }
    // Physical belt tilt derived from the slicing rotation — the single source of
    // truth for bed rendering, support gravity tilt and the bed-exclusion
    // projection.  Returns the tilt magnitude in degrees split onto the X and Y
    // build-plate tilt axes according to the rotation axis:
    //   rotation about X  → tilt_x = angle   (gantry tilts in the YZ plane)
    //   rotation about Y  → tilt_y = angle   (gantry tilts in the XZ plane)
    //   rotation about Z / None → no tilt    (in-plane spin doesn't tilt the belt)
    // The magnitude uses abs(angle) so a negative rotation still reports a positive
    // physical tilt.
    struct PhysicalTilt { double tilt_x_deg = 0.; double tilt_y_deg = 0.; };
    static PhysicalTilt physical_tilt(BeltRotationAxis axis, double angle_deg)
    {
        PhysicalTilt t;
        double mag = std::abs(angle_deg);
        switch (axis) {
        case BeltRotationAxis::X: t.tilt_x_deg = mag; break;
        case BeltRotationAxis::Y: t.tilt_y_deg = mag; break;
        default: break; // Z / None: no physical tilt
        }
        return t;
    }
    static PhysicalTilt physical_tilt(const PrintConfig &config)
    {
        return physical_tilt(config.belt_slice_rotation.value,
                             config.belt_slice_rotation_angle.value);
    }
    // ---- Matrix builders --------------------------------------------------
    // Build the pre-slice axis remap transform (includes Rev-mode translation).
    static Transform3d build_preslice_remap(const PrintConfig &config);
    // Build the 3x3 rotation matrix from belt_slice_rotation* config.
    // Returns Identity if rotation axis is None or angle is ~0.
    // Also sets has_rot_out if non-null.
    static Matrix3d build_rotation_matrix(const PrintConfig &config, bool *has_rot_out = nullptr);
    // Combined forward transform (rotation * pre_remap) — the mesh-side belt
    // transform that BeltSliceStrategy applies and BeltBackTransform inverts.
    // Does NOT include the per-object Z-shift.
    static Transform3d build_forward_transform(const PrintConfig &config);
    // ---- Bounding box remap -----------------------------------------------
    // Remap a bounding box through the pre-slice axis remap.
    // Returns the original bbox if remap is identity.
    static BoundingBoxf3 remap_bbox(const BoundingBoxf3 &bb, const PrintConfig &config);
    static BoundingBoxf3 remap_bbox(const ModelObject &model_object, const PrintConfig &config);
    // ---- Belt floor parameters --------------------------------------------
    struct BeltFloorParams {
        double shear_factor = 0.0;
        int    from_axis    = 1;
        double z_shift      = 0.0;
    };
    // Result of computing belt height + floor params.
    struct BeltHeightResult {
        double          object_height;  // Effective object height after shear/scale
        BeltFloorParams floor_params;
    };
    // Compute effective object height and belt floor parameters from config
    // and pre-remapped bounding box.  original_height is the input height
    // (bb.size().z() or model_object.max_z()).
    static BeltHeightResult compute_belt_height_and_floor(
        const PrintConfig &config, const BoundingBoxf3 &remapped_bbox,
        double original_height);
    // Overload for DynamicPrintConfig (used by static slicing_parameters).
    static BeltHeightResult compute_belt_height_and_floor(
        const DynamicPrintConfig &config, const BoundingBoxf3 &remapped_bbox,
        double original_height);
 };
 } // namespace Slic3r
@@ -449,7 +449,9 @@ static ExPolygons outer_inner_brim_area(const Print& print,
            const bool         use_brim_ears = object->config().brim_type == btPainted;
            const bool         use_inner_brim_ears = (use_auto_brim_ears || use_brim_ears) && !object->config().brim_ears_outer_only.value;
            const bool         has_inner_brim = brim_type == btInnerOnly || brim_type == btOuterAndInner || use_inner_brim_ears;
-            const bool         has_outer_brim = brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btAutoBrim || use_auto_brim_ears || use_brim_ears;
+            // btLeadingEdgeOnly is a belt-printer mode; on a flat bed there is no leading
            // edge, so it degrades to an ordinary outer brim rather than silently to none.
            const bool         has_outer_brim = brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btAutoBrim || brim_type == btLeadingEdgeOnly || 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;
            //ORCA: Select brim base slices from EFC-compensated outline when enabled.
@@ -864,6 +866,17 @@ void make_brim(const Print& print, PrintTryCancel try_cancel, Polygons& islands_
    std::vector<unsigned int>& printExtruders,
    std::map<ObjectInstanceID, ExPolygons>* objectBrimAreasByInstanceOut)
 {
    // Belt printers never use the flat plate brim.
    //
    // With a tilted belt the brim has to be laid onto the belt plane over many layers,
    // which BeltBrim.cpp does during posSupportMaterial.  With an untilted belt this
    // could in principle fall through and produce an ordinary brim, but it would never
    // reach the G-code: the plate brim is emitted out of skirt_brim_groups(), which
    // _make_skirt() builds, and that returns early for every belt printer.  Running the
    // generator anyway would just burn time on geometry nobody prints.
    if (print.config().belt_printer.value)
        return;
    std::map<ObjectInstanceID, ExPolygons> brimAreaMap;
    Flow                 flow = print.brim_flow();
    ExPolygons           islands_area_ex = outer_inner_brim_area(print,
@@ -180,6 +180,31 @@ BuildVolume::BuildVolume(const std::vector<Vec2d> &printable_area, const double
    BOOST_LOG_TRIVIAL(debug) << "BuildVolume printable_area clasified as: " << this->type_name();
 }
 void BuildVolume::set_belt_printer(bool enabled, double angle_deg, bool infinite_y)
 {
    m_is_belt_printer = enabled;
    m_belt_angle = angle_deg;
    m_belt_infinite_y = infinite_y;
    // Restart from the unmodified bbox each call. Without this, toggling
    // belt mode off (or switching infinite_y true→false) would leave the
    // extents inflated and break collision / object_state checks.
    BoundingBoxf bboxf = get_extents(m_bed_shape);
    m_bboxf = BoundingBoxf3{ to_3d(bboxf.min, 0.), to_3d(bboxf.max, m_max_print_height) };
    if (enabled) {
        if (infinite_y) {
            // Extend the Y bound to a very large value for infinite belt.
            m_bboxf.max.y() = 100000.;
        }
        // Belt printer: the Z extent already equals printable_height (set above), which
        // is the usable vertical clearance above the belt. The gantry's axis range is
        // sized to reach height/cos(tilt), so no diagonal scaling is applied here — this
        // keeps the live "outside build volume" highlight in agreement with Print::validate().
        (void) angle_deg;
    }
 }
 #if 0
 // Tests intersections of projected triangles, not just their vertices against a bounding box.
 // This test also correctly evaluates collision of a non-convex object with the bounding box.
@@ -388,6 +413,11 @@ BuildVolume::ObjectState BuildVolume::object_state(const indexed_triangle_set& i
            build_volume.max.z() = std::numeric_limits<double>::max();
        if (ignore_bottom)
            build_volume.min.z() = -std::numeric_limits<double>::max();
        // Belt printer: extend Y bounds for infinite Y.
        if (m_is_belt_printer && m_belt_infinite_y) {
            build_volume.min.y() = -std::numeric_limits<double>::max();
            build_volume.max.y() = std::numeric_limits<double>::max();
        }
        BoundingBox3Base<Vec3f> build_volumef(build_volume.min.cast<float>(), build_volume.max.cast<float>());
        // The following test correctly interprets intersection of a non-convex object with a rectangular build volume.
        //return rectangle_test(its, trafo, to_2d(build_volume.min), to_2d(build_volume.max), build_volume.max.z());
@@ -57,6 +57,10 @@ public:
    // Initialize from PrintConfig::printable_area and PrintConfig::printable_height
    BuildVolume(const std::vector<Vec2d> &printable_area, const double printable_height, const std::vector<std::vector<Vec2d>> &extruder_areas, const std::vector<double>& extruder_printable_heights);
    // Belt printer configuration.
    void set_belt_printer(bool enabled, double angle_deg, bool infinite_y);
    bool is_belt_printer() const { return m_is_belt_printer; }
    // Source data, unscaled coordinates.
    const std::vector<Vec2d>&   printable_area()         const { return m_bed_shape; }
    double                      printable_height()  const { return m_max_print_height; }
@@ -80,7 +84,7 @@ public:
    indexed_triangle_set        bounding_mesh(bool scale=true) const;
    // Center of the print bed, unscaled.
-    Vec2d                       bed_center()        const { return to_2d(m_bboxf.center()); }
+    Vec2d                       bed_center()        const { return get_extents(m_bed_shape).center(); }
    // Convex hull of polygon(), scaled.
    const Polygon&              convex_hull()       const { return m_convex_hull; }
    // Smallest enclosing circle of polygon(), scaled.
@@ -139,6 +143,10 @@ private:
    // Source definition of the print volume height (PrintConfig::printable_height)
    double              m_max_print_height { 0.f };
    std::vector<double> m_extruder_printable_height;
    // Belt printer state.
    bool                m_is_belt_printer { false };
    double              m_belt_angle { 0. };
    bool                m_belt_infinite_y { false };
    // Derived values.
    BuildVolume_Type                m_type { BuildVolume_Type::Invalid };
@@ -80,6 +80,19 @@ set(lisbslic3r_sources
    BoundingBox.hpp
    BridgeDetector.cpp
    BridgeDetector.hpp
    BeltBrim.cpp
    BeltBrim.hpp
    BeltGCode.cpp
    BeltGCode.hpp
    BeltGCodeWriter.cpp
    BeltGCodeWriter.hpp
    BeltPurge.cpp
    BeltSliceStrategy.cpp
    BeltSliceStrategy.hpp
    BeltTransform.cpp
    BeltTransform.hpp
    FirstLayerPlane.cpp
    FirstLayerPlane.hpp
    Brim.cpp
    BrimEarsPoint.hpp
    Brim.hpp
@@ -228,6 +241,10 @@ set(lisbslic3r_sources
    GCode/AdaptivePAProcessor.hpp
    GCode/AvoidCrossingPerimeters.cpp
    GCode/AvoidCrossingPerimeters.hpp
    GCode/BeltBackTransform.cpp
    GCode/BeltBackTransform.hpp
    GCode/MachineFrameTransform.cpp
    GCode/MachineFrameTransform.hpp
    GCode/ConflictChecker.cpp
    GCode/ConflictChecker.hpp
    GCode/CoolingBuffer.cpp
@@ -442,6 +459,8 @@ set(lisbslic3r_sources
    SlicingAdaptive.hpp
    Slicing.cpp
    Slicing.hpp
    Support/BeltFloorContext.cpp
    Support/BeltFloorContext.hpp
    Support/SupportCommon.cpp
    Support/SupportCommon.hpp
    Support/SupportLayer.hpp
@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <assert.h>
 #include <fstream>
 #include <sstream>
 #include <iostream>
 #include <iomanip>
 #include <regex>
@@ -1516,19 +1515,6 @@ std::optional<PluginCapabilityRef> parse_capability_ref(const std::string& value
 //BBS: add json support
 void ConfigBase::save_to_json(const std::string &file, const std::string &name, const std::string &from, const std::string &version) const
 {
    // Serialize first: if that throws (invalid UTF-8), the existing file stays untouched.
    std::ostringstream ss;
    this->save_to_json(ss, name, from, version);
    boost::nowide::ofstream c;
    c.open(file, std::ios::out | std::ios::trunc);
    c << ss.str();
    c.close();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
 }
 void ConfigBase::save_to_json(std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8) const
 {
    json j;
    //record the headers
@@ -1575,7 +1561,12 @@ void ConfigBase::save_to_json(std::ostream &os, const std::string &name, const s
            j["plugins"] = unique_refs;
    }
-    os << j.dump(1, '\t', false, replace_invalid_utf8 ? json::error_handler_t::replace : json::error_handler_t::strict) << std::endl;
+    boost::nowide::ofstream c;
    c.open(file, std::ios::out | std::ios::trunc);
    c << j.dump(1, '\t') << std::endl;
    c.close();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ":" <<__LINE__ << boost::format(", saved config to %1%\n")%file;
 }
 void ConfigBase::save(const std::string &file) const
@@ -2825,9 +2825,6 @@ public:
    //BBS: add json support
    void save_to_json(const std::string &file, const std::string &name, const std::string &from, const std::string &version) const;
    // Same document, written to a stream. Invalid UTF-8 in a string value throws nlohmann's type_error unless
    // replace_invalid_utf8 is set, which writes U+FFFD instead (for callers such as stdout with no handler).
    void save_to_json(std::ostream &os, const std::string &name, const std::string &from, const std::string &version, bool replace_invalid_utf8 = false) const;
    // Rebuild the in-memory "plugins" manifest (the "name;uuid;capability" references the plugin
    // dispatchers consume) from the plugin-backed options via the registered resolver. save_to_json()
@@ -396,6 +396,11 @@ inline void translate(ExPolygons &expolys, const Point &p) {
        expoly.translate(p);
 }
 inline void translate(Polygons &polys, const Point &p) {
    for (Polygon &poly : polys)
        poly.translate(p);
 }
 inline void polygons_append(Polygons &dst, const ExPolygon &src) 
 { 
    dst.reserve(dst.size() + src.holes.size() + 1);
@@ -1595,25 +1595,6 @@ Polylines Layer::generate_sparse_infill_polylines_for_anchoring(FillAdaptive::Oc
    return sparse_infill_polylines;
 }
 // Returns the filament id (1-based) the region is ironed with, or -1 when the
 // region is not ironed. AllSolid always irons. TopSurfaces and TopmostOnly need
 // either some top shells or, in spiral mode, more than one bottom shell, and
 // TopmostOnly additionally needs the layer to be the topmost one.
 int Layer::choose_ironing_extruder(const PrintRegionConfig &cfg,
                                   bool spiral_mode,
                                   bool is_topmost_layer)
 {
    if (cfg.ironing_type == IroningType::NoIroning)
        return -1;
    const bool gate = (cfg.ironing_type == IroningType::AllSolid)
        || ((cfg.top_shell_layers > 0 || (spiral_mode && cfg.bottom_shell_layers > 1))
            && (cfg.ironing_type == IroningType::TopSurfaces
                || (cfg.ironing_type == IroningType::TopmostOnly && is_topmost_layer)));
    if (!gate)
        return -1;
    return cfg.top_surface_filament_id;
 }
 // Create ironing extrusions over top surfaces.
 void Layer::make_ironing()
 {
@@ -1683,10 +1664,19 @@ void Layer::make_ironing()
 		if (! layerm->slices.empty()) {
 			IroningParams ironing_params;
 			const PrintRegionConfig &config = layerm->region().config();
-			ironing_params.extruder = Layer::choose_ironing_extruder(
+			if (config.ironing_type != IroningType::NoIroning &&
-				config,
+			    (config.ironing_type == IroningType::AllSolid ||
-				/*spiral_mode=*/this->object()->print()->config().spiral_mode,
+				    ((config.top_shell_layers > 0 || (this->object()->print()->config().spiral_mode && config.bottom_shell_layers > 1)) &&
-				/*is_topmost_layer=*/layerm->layer()->upper_layer == nullptr);
+					    (config.ironing_type == IroningType::TopSurfaces ||
 					        (config.ironing_type == IroningType::TopmostOnly && layerm->layer()->upper_layer == nullptr))))) {
 				if (config.outer_wall_filament_id == config.top_surface_filament_id || config.wall_loops == 0) {
 					// Iron the whole face.
 					ironing_params.extruder = config.top_surface_filament_id;
 				} else {
 					// Iron just the infill.
 					ironing_params.extruder = config.top_surface_filament_id;
 				}
 			}
 			if (ironing_params.extruder != -1) {
 				//TODO just_infill is currently not used.
 				ironing_params.just_infill 	= false;
@@ -0,0 +1,225 @@
 #include "FirstLayerPlane.hpp"
 #include "BeltTransform.hpp"
 #include <algorithm>
 #include <climits>
 #include <cmath>
 namespace Slic3r {
 namespace {
 // Build the row of the gcode-axis-remap matrix R that produces machine_Z,
 // AS A FUNCTION OF a slicing-frame point in the GCode generator's coordinate
 // space.  Without back-transform this is just R.row(2).  With back-transform
 // the writer applies F^-1 before R, so the effective row is (R * F^-1).row(2).
 //
 // Returns a pair (gradient, constant) such that:
 //     machine_Z(p_slicing) = gradient.dot(p_slicing) + constant
 struct MachineZAffine {
    Vec3d  gradient = Vec3d::UnitZ();
    double constant = 0.0;
 };
 MachineZAffine compute_machine_z_affine(const PrintConfig &config)
 {
    MachineZAffine out;
    // R is the matrix form of GCodeWriter::apply_axis_remap.  Each output axis
    // i picks one slicing-frame component (with sign + optional Rev mode
    // translation) based on m_remap_{x,y,z}.  We only need row 2 (the z output)
    // since machine_Z is what defines the first-layer plane.
    int rz = int(config.gcode_remap_z.value);
    int axis = rz % 3;
    double sign;
    double trans;
    if (rz < int(RemapAxis::NegX)) {            // 0..2 = PosX/Y/Z
        sign  = 1.0;
        trans = 0.0;
    } else if (rz < int(RemapAxis::RevX)) {     // 3..5 = NegX/Y/Z
        sign  = -1.0;
        trans = 0.0;
    } else {                                     // 6..8 = RevX/Y/Z
        sign = -1.0;
        BoundingBoxf bbox_bed(config.printable_area.values);
        Vec3d vol_max(bbox_bed.max.x(),
                      bbox_bed.max.y(),
                      config.printable_height.value);
        trans = vol_max[axis];
    }
    Vec3d r_row = Vec3d::Zero();
    r_row[axis] = sign;
    // Without back-transform, machine_Z(slicing) = r_row · slicing + trans.
    out.gradient = r_row;
    out.constant = trans;
    if (config.gcode_back_transform.value && config.belt_printer.value) {
        // BeltGCodeWriter applies F^-1 before R when back-transform is on.
        // So machine_Z(slicing) = r_row · (F^-1 · slicing) + trans
        //                       = (r_row^T · F^-1) · slicing + trans
        // We need to compose r_row with F^-1 from the LEFT (treating r_row as
        // a row vector).  Eigen makes this easy: it's just F^-1.transpose() * r_row.
        Transform3d forward = BeltTransformPipeline::build_forward_transform(config);
        Transform3d inverse = forward.inverse();
        // Note: forward.translation() is normally zero (per-print transforms
        // don't add a translation; the per-object z_shift is added separately
        // in PrintObjectSlice).  We still incorporate inverse.translation() in
        // case a Rev-mode preslice_remap puts a translation in F.
        Vec3d composed_grad = inverse.linear().transpose() * r_row;
        double composed_trans =
            r_row.dot(inverse.translation()) + trans;
        out.gradient = composed_grad;
        out.constant = composed_trans;
    }
    return out;
 }
 } // namespace
 FirstLayerPlane::FirstLayerPlane(const PrintConfig &config)
 {
    // -------- Resolve Auto -------------------------------------------------
    FirstLayerPlaneMode mode = config.first_layer_plane.value;
    if (mode == FirstLayerPlaneMode::Auto) {
        bool belt_affine_active = config.belt_printer.value &&
            config.belt_slice_rotation.value != BeltRotationAxis::None &&
            std::abs(config.belt_slice_rotation_angle.value) > EPSILON;
        mode = belt_affine_active ? FirstLayerPlaneMode::BeltAffine
                                  : FirstLayerPlaneMode::XY;
    }
    m_mode = mode;
    // -------- Band thickness ----------------------------------------------
    // Note: layer_height lives in PrintObjectConfig, not PrintConfig, so we
    // can't fall back to it from here.  initial_layer_print_height is in
    // PrintConfig and is the right default anyway (the legacy first-layer
    // semantics used initial_layer_print_height, not the regular one).
    double thickness = config.first_layer_plane_thickness.value;
    if (thickness <= 0.0)
        thickness = config.initial_layer_print_height.value;
    if (thickness <= 0.0)
        thickness = 0.2;
    m_thickness_mm = thickness;
    const double user_offset = config.first_layer_plane_offset.value;
    // -------- Build the plane ---------------------------------------------
    auto set_axis_aligned = [&](const Vec3d &n_unit, double offset_along_n) {
        m_normal = n_unit;
        m_offset = offset_along_n;
    };
    switch (mode) {
    case FirstLayerPlaneMode::XY:
        // Legacy XY plane.  Inactive: short-circuit to layer-index path.
        set_axis_aligned(Vec3d::UnitZ(), user_offset);
        m_active = false;
        return;
    case FirstLayerPlaneMode::YZ:
        set_axis_aligned(Vec3d::UnitX(), user_offset);
        m_active = true;
        return;
    case FirstLayerPlaneMode::XZ:
        set_axis_aligned(Vec3d::UnitY(), user_offset);
        m_active = true;
        return;
    case FirstLayerPlaneMode::BeltAffine: {
        // Compute the slicing-frame plane that maps to machine_Z = user_offset
        // under the gcode axis remap (and optional back-transform).
        MachineZAffine mz = compute_machine_z_affine(config);
        double cmag = mz.gradient.norm();
        if (cmag < EPSILON) {
            // Degenerate: slicing point doesn't affect machine_Z.  Fall back.
            set_axis_aligned(Vec3d::UnitZ(), user_offset);
            m_active = false;
            return;
        }
        // Plane equation: gradient · slicing = user_offset - constant
        const double K = user_offset - mz.constant;
        m_normal = mz.gradient / cmag;
        m_offset = K / cmag;
        m_active = true;
        return;
    }
    case FirstLayerPlaneMode::Auto:
        // Should have been resolved above.
        m_active = false;
        return;
    }
    m_active = false;
 }
 double FirstLayerPlane::distance_from_plane(const Vec3d &point_slicing_mm) const
 {
    return m_normal.dot(point_slicing_mm) - m_offset;
 }
 bool FirstLayerPlane::is_first_layer(const Vec3d &point_slicing_mm,
                                     double first_layer_height_mm) const
 {
    if (!m_active)
        return false;
    return distance_from_plane(point_slicing_mm) < first_layer_height_mm;
 }
 int FirstLayerPlane::effective_layer_index(const Vec3d &point_slicing_mm) const
 {
    if (!m_active)
        return INT_MAX / 2;  // Effectively "way past first layer".
    double d = distance_from_plane(point_slicing_mm);
    if (d <= 0.0)
        return 0;
    return int(std::floor(d / m_thickness_mm));
 }
 int FirstLayerPlane::min_effective_index_for_xy_bbox(
    const BoundingBoxf &xy_bbox_mm, double slicing_z_mm) const
 {
    if (!m_active)
        return INT_MAX / 2;
    // For the rectangular bbox in (x, y) at fixed z, the smallest value of
    // (n.x*x + n.y*y + n.z*z - offset) is achieved at one of the four
    // corners, with the smaller component picked when the corresponding
    // normal coefficient is positive.
    const double x_for_min = (m_normal.x() >= 0.0)
        ? xy_bbox_mm.min.x() : xy_bbox_mm.max.x();
    const double y_for_min = (m_normal.y() >= 0.0)
        ? xy_bbox_mm.min.y() : xy_bbox_mm.max.y();
    const double dmin = m_normal.x() * x_for_min
                      + m_normal.y() * y_for_min
                      + m_normal.z() * slicing_z_mm
                      - m_offset;
    if (dmin <= 0.0)
        return 0;
    return int(std::floor(dmin / m_thickness_mm));
 }
 int FirstLayerPlane::min_effective_index_for_bbox3(
    const BoundingBoxf3 &bbox_mm) const
 {
    if (!m_active)
        return INT_MAX / 2;
    const double x_for_min = (m_normal.x() >= 0.0)
        ? bbox_mm.min.x() : bbox_mm.max.x();
    const double y_for_min = (m_normal.y() >= 0.0)
        ? bbox_mm.min.y() : bbox_mm.max.y();
    const double z_for_min = (m_normal.z() >= 0.0)
        ? bbox_mm.min.z() : bbox_mm.max.z();
    const double dmin = m_normal.x() * x_for_min
                      + m_normal.y() * y_for_min
                      + m_normal.z() * z_for_min
                      - m_offset;
    if (dmin <= 0.0)
        return 0;
    return int(std::floor(dmin / m_thickness_mm));
 }
 } // namespace Slic3r
@@ -0,0 +1,76 @@
 #ifndef slic3r_FirstLayerPlane_hpp_
 #define slic3r_FirstLayerPlane_hpp_
 #include "libslic3r.h"
 #include "Point.hpp"
 #include "BoundingBox.hpp"
 #include "PrintConfig.hpp"
 namespace Slic3r {
 // Decides which extrusions get "first layer" treatment (no fan, slow speed,
 // initial-layer accel/jerk, deferred temperature drop) by reference to a
 // configurable plane in slicing-frame coordinates rather than the slicing
 // layer index.
 //
 // On a normal flat-bed printer the plane is XY at slicing_Z = 0 and the
 // evaluator is INACTIVE — every call site short-circuits back to the legacy
 // `Layer::id() == 0` test.  On a belt printer with a Z-from-Y shear the
 // belt surface (machine_Z = 0) maps to a plane in slicing-frame coordinates
 // derived from the gcode axis remap, so layer-index-based detection no
 // longer matches the physical first printed surface.
 //
 // Plane representation: unit normal `n` (slicing frame) and offset along
 // the normal such that the plane equation is `n · p == offset`.  Signed
 // perpendicular distance is `d(p) = n · p - offset`.  Positive distance
 // means "away from the belt surface", negative means "below the plane".
 class FirstLayerPlane
 {
 public:
    explicit FirstLayerPlane(const PrintConfig &config);
    // Inactive when the legacy XY layer-index path should be used.  This
    // covers all non-belt printers and any belt printer where the user
    // explicitly picked XY mode.
    bool                is_active() const     { return m_active; }
    FirstLayerPlaneMode effective_mode() const{ return m_mode; }
    double              band_thickness_mm() const { return m_thickness_mm; }
    const Vec3d &       normal() const        { return m_normal; }
    double              plane_offset() const  { return m_offset; }
    // Signed perpendicular distance from a slicing-frame point to the plane.
    double distance_from_plane(const Vec3d &point_slicing_mm) const;
    // True if perpendicular distance < first_layer_height_mm.  When the
    // evaluator is inactive this returns false (call sites should fall back
    // to the legacy per-layer path before reaching this function).
    bool is_first_layer(const Vec3d &point_slicing_mm,
                        double first_layer_height_mm) const;
    // floor((distance - 0) / band_thickness), clamped to [0, +inf).  Used
    // for "first N layers" thresholds (fan, slow_down_layers).  Returns 0
    // for points within the band.  Returns INT_MAX/2 when inactive.
    int effective_layer_index(const Vec3d &point_slicing_mm) const;
    // Min effective index over a 2D bbox at a fixed slicing_Z.  Used for
    // layer-level decisions (e.g. temperature transition gate) where we
    // don't want to walk every extrusion in the layer.  For axis-aligned
    // planes this is exact; for tilted planes it's a tight lower bound
    // (the plane projection of the bbox's extreme corner).
    int min_effective_index_for_xy_bbox(const BoundingBoxf &xy_bbox_mm,
                                        double              slicing_z_mm) const;
    // Same as above but the bbox spans a Z range too.
    int min_effective_index_for_bbox3(const BoundingBoxf3 &bbox_mm) const;
 private:
    bool                m_active        = false;
    FirstLayerPlaneMode m_mode          = FirstLayerPlaneMode::XY;
    Vec3d               m_normal        = Vec3d::UnitZ();  // unit, slicing frame
    double              m_offset        = 0.0;             // n·p == m_offset
    double              m_thickness_mm  = 0.0;
 };
 } // namespace Slic3r
 #endif // slic3r_FirstLayerPlane_hpp_
@@ -4,6 +4,8 @@
 #include "libslic3r.h"
 #include "ExPolygon.hpp"
 #include "GCodeWriter.hpp"
 #include "BeltGCodeWriter.hpp"
 #include "FirstLayerPlane.hpp"
 #include "Layer.hpp"
 #include "Point.hpp"
 #include "PlaceholderParser.hpp"
@@ -31,6 +33,7 @@
 #include <memory>
 #include <map>
 #include <optional>
 #include <set>
 #include <string>
 #include <cfloat>
@@ -214,16 +217,18 @@ public:
        m_last_obj_copy(nullptr, Point(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max())),
        // BBS
        m_toolchange_count(0),
-        m_nominal_z(0.)
+        m_nominal_z(0.),
        m_writer(std::make_unique<GCodeWriter>())
        {}
-    ~GCode() = default;
+    virtual ~GCode() = default;
 public:
    // throws std::runtime_exception on error,
    // throws CanceledException through print->throw_if_canceled().
    void            do_export(Print* print, const char* path, GCodeProcessorResult* result = nullptr, ThumbnailsGeneratorCallback thumbnail_cb = nullptr);
    void            export_layer_filaments(GCodeProcessorResult* result);
    //BBS: set offset for gcode writer
-    void set_gcode_offset(double x, double y) { m_writer.set_xy_offset(x, y); m_processor.set_xy_offset(x, y);}
+    void set_gcode_offset(double x, double y) { m_gcode_offset = Vec2d(x, y); m_writer->set_xy_offset(x, y); m_processor.set_xy_offset(x, y);}
    // Exported for the helper classes (OozePrevention, Wipe) and for the Perl binding for unit tests.
    const Vec2d&    origin() const { return m_origin; }
@@ -237,8 +242,8 @@ public:
    Vec3d                    point_to_gcode_quantized(const Point3& point) const;
    const FullPrintConfig &config() const { return m_config; }
    const Layer*    layer() const { return m_layer; }
-    GCodeWriter&    writer() { return m_writer; }
+    GCodeWriter&    writer() { return *m_writer; }
-    const GCodeWriter& writer() const { return m_writer; }
+    const GCodeWriter& writer() const { return *m_writer; }
    PlaceholderParser& placeholder_parser() { return m_placeholder_parser_integration.parser; }
    const PlaceholderParser& placeholder_parser() const { return m_placeholder_parser_integration.parser; }
    // Process a template through the placeholder parser, collect error messages to be reported
@@ -261,7 +266,7 @@ public:
    bool            needs_retraction(const Polyline& travel, ExtrusionRole role, LiftType& lift_type);
    std::string     retract(bool toolchange = false, bool is_last_retraction = false, LiftType lift_type = LiftType::NormalLift, bool apply_instantly = false, ExtrusionRole role = erNone);
    // extra_retract forwards a PETG pre-extrusion over-extrusion; default 0 -> identical to the plain deretract.
-    std::string     unretract(float extra_retract = 0.f) { return m_writer.unlift() + m_writer.unretract(extra_retract); }
+    std::string     unretract(float extra_retract = 0.f) { return m_writer->unlift() + m_writer->unretract(extra_retract); }
    std::string     set_extruder(unsigned int extruder_id, double print_z, bool by_object=false, int toolchange_temp_override = -1, bool defer_temp_wait = false);
    bool is_BBL_Printer();
    WipeTowerType wipe_tower_type();
@@ -286,6 +291,13 @@ public:
        const Layer* 		object_layer;
        const SupportLayer* support_layer;
        const PrintObject*  original_object; //BBS: used for shared object logic
        // Belt printers only: an apron band that prints BELOW the object's first
        // layer, so it has no object or support layer of its own.  Deliberately
        // not a Layer, so it cannot leak Layer::id() semantics into initial-layer
        // temperature, spiral vase, cooling or interpolation logic.  When this is
        // the only thing set, layer() is null and process_layer() takes its
        // dedicated brim-only branch.
        const BeltBrimBand* belt_brim_band { nullptr };
        const Layer* 		layer()   const
        {
            if (object_layer != nullptr)
@@ -315,11 +327,25 @@ public:
                count++;
            }
            // A brim-only apron band contributes no object/support layer, and
            // averaging zero terms would yield NaN.  Never folded into the
            // average, so the non-belt result is bit-identical.
            if (count == 0 && belt_brim_band != nullptr)
                return belt_brim_band->print_z;
            return sum_z / count;
        }
    };
-private:
+    // Public accessor for the first-layer plane evaluator.  Used by
    // CoolingBuffer (which is constructed with a GCode reference and needs
    // to read the plane for per-segment fan re-evaluation).  All other
    // first-layer-plane access points (on_first_layer overload, effective
    // index helper) are in the protected section since they're called from
    // GCode internals only.
    const FirstLayerPlane *first_layer_plane() const { return m_first_layer_plane.get(); }
 protected:
    class GCodeOutputStream {
    public:
        GCodeOutputStream(FILE *f, GCodeProcessor &processor) : f(f), m_processor(processor) {}
@@ -347,9 +373,17 @@ private:
        FILE *f = nullptr;
        GCodeProcessor &m_processor;
    };
    // Virtual hooks for belt printer subclass (BeltGCode).
    // No-ops in base GCode; overridden in BeltGCode.
    virtual void init_belt_writer(Print &print) {}
    virtual void write_belt_header(GCodeOutputStream &file, const Print &print) {}
    virtual void on_set_origin(const PrintObject *obj, const Point &inst_shift) {}
    virtual bool should_disable_arc_fitting() const { return false; }
    void            _do_export(Print &print, GCodeOutputStream &file, ThumbnailsGeneratorCallback thumbnail_cb);
-    static std::vector<LayerToPrint>        		                   collect_layers_to_print(const PrintObject &object);
+    static std::vector<LayerToPrint>        		                   collect_layers_to_print(const PrintObject &object, bool skip_empty_first_layer = false);
    static std::vector<std::pair<coordf_t, std::vector<LayerToPrint>>> collect_layers_to_print(const Print &print);
    std::string generate_skirt(const Print &print,
@@ -369,7 +403,29 @@ private:
    std::string generate_object_brim(const Print &print,
        const PrintObject &object,
        size_t instance_id,
-        bool first_layer);
+        bool first_layer,
        const Layer *object_layer);
    // Belt printers: emit one brim-only apron layer.  These print below the
    // object's first layer, so there is no object or support layer for the normal
    // process_layer() machinery to work from.  Kept to the minimum a layer needs -
    // tool, Z move, extrusions - so that nothing here can perturb the
    // Layer::id()-based logic the ordinary path relies on.
    LayerResult process_belt_brim_layer(
        const Print                     &print,
        const std::vector<LayerToPrint> &layers,
        const LayerTools                &layer_tools,
        const bool                       last_layer,
        const size_t                     single_object_instance_idx);
    // Emit the apron bands carried by these layers whose brim filament is extruder_id
    // (0-based).  Called from both the brim-only branch and the ordinary path, since a
    // band's print_z can coincide with another object's layer on a multi-object belt.
    std::string emit_belt_brim_bands(
        const Print                     &print,
        const std::vector<LayerToPrint> &layers,
        const size_t                     single_object_instance_idx,
        const unsigned int               extruder_id);
    LayerResult process_layer(
        const Print                     &print,
@@ -587,7 +643,7 @@ private:
    DynamicConfig                       m_calib_config;
    // scaled G-code resolution
    double                              m_scaled_resolution;
-    GCodeWriter                         m_writer;
+    std::unique_ptr<GCodeWriter>         m_writer;
    struct PlaceholderParserIntegration {
        void reset();
@@ -707,6 +763,13 @@ private:
    std::unique_ptr<CoolingBuffer>      m_cooling_buffer;
    std::unique_ptr<SpiralVase>         m_spiral_vase;
    // First-layer plane evaluator.  Constructed once per print from the
    // PrintConfig.  is_active() == false on non-belt printers and on belt
    // printers without a Z-axis shear; in that case all per-path plane
    // checks short-circuit to the legacy Layer::id() == 0 path.
    std::unique_ptr<FirstLayerPlane>    m_first_layer_plane;
    // Plate origin, kept so a writer replaced during export can be given it again.
    Vec2d                               m_gcode_offset{ Vec2d::Zero() };
    std::unique_ptr<PressureEqualizer>  m_pressure_equalizer;
@@ -760,6 +823,13 @@ private:
    // resolvers. Distinct from m_layer_index (an export progress counter starting at -1).
    size_t m_cur_layer_idx{0};
    // Belt brim apron layers only.  They have no Layer, so the print_z that
    // _extrude() needs for the first-layer-plane probe is published here instead.
    // Scoped by BeltBrimZGuard in process_belt_brim_layer(), never left set.
    std::optional<coordf_t> m_belt_brim_z;
    // Counter standing in for Layer::id() on apron layers, which precede layer 0.
    size_t m_belt_brim_layer_idx{0};
    std::set<unsigned int>                  m_initial_layer_extruders;
    std::vector<std::vector<unsigned int>>  m_sorted_layer_filaments;
    // BBS
@@ -777,6 +847,25 @@ private:
    // On the first printing layer. This flag triggers first layer speeds.
    //BBS
    bool    on_first_layer() const { return m_layer != nullptr && m_layer->id() == 0 && abs(m_layer->bottom_z()) < EPSILON; }
    // Per-point first-layer test.  When the FirstLayerPlane evaluator is
    // active, the result depends on the supplied slicing-frame point;
    // otherwise we delegate to the legacy per-layer test.  This is the
    // entry point used by per-path call sites in _extrude.
    bool on_first_layer(const Vec3d &point_slicing_mm) const {
        if (m_first_layer_plane && m_first_layer_plane->is_active())
            return m_first_layer_plane->is_first_layer(
                point_slicing_mm, m_config.initial_layer_print_height.value);
        return on_first_layer();
    }
    // "Effective layer index" used to drive layer-count thresholds like
    // slow_down_layers.  When the evaluator is active this returns the
    // perpendicular distance to the plane in band_thickness_mm units;
    // otherwise it returns the legacy slicing layer index.
    int effective_layer_index_for_point(const Vec3d &point_slicing_mm) const {
        if (m_first_layer_plane && m_first_layer_plane->is_active())
            return m_first_layer_plane->effective_layer_index(point_slicing_mm);
        return on_first_layer() ? 0 : layer_id();
    }
    int layer_id() const {
        if (m_layer == nullptr)
            return -1;
@@ -0,0 +1,40 @@
 #include "BeltBackTransform.hpp"
 #include "../BeltTransform.hpp"
 namespace Slic3r {
 bool BeltBackTransform::init_from_config(const PrintConfig &config)
 {
    m_active  = false;
    m_inverse = Transform3d::Identity();
    if (!config.belt_printer.value || !config.gcode_back_transform.value)
        return false;
    // Require at least one active transform to proceed.
    bool has_global_rotation = config.belt_slice_rotation_global.value
                            && config.belt_slice_rotation.value != BeltRotationAxis::None;
    bool has_preslice_global = config.belt_preslice_global.value
                            || config.preslice_remap_global.value;
    if (!has_global_rotation && !has_preslice_global
        && !BeltTransformPipeline::has_preslice_remap(config))
        return false;
    // Build the forward pipeline (rotation * pre_remap) and store its inverse.
    Transform3d forward = BeltTransformPipeline::build_forward_transform(config);
    if (forward.isApprox(Transform3d::Identity()))
        return false;
    m_inverse = forward.inverse();
    m_active  = true;
    return true;
 }
 Vec3d BeltBackTransform::apply(const Vec3d &pos) const
 {
    if (!m_active)
        return pos;
    return m_inverse * pos;
 }
 } // namespace Slic3r
@@ -0,0 +1,45 @@
 #ifndef slic3r_BeltBackTransform_hpp_
 #define slic3r_BeltBackTransform_hpp_
 #include "../libslic3r.h"
 #include "../Point.hpp"
 #include "../PrintConfig.hpp"
 namespace Slic3r {
 // Reverses the pre-slice remap + shear + scale transforms that
 // PrintObjectSlice.cpp applies to belt printer geometry, converting G-code
 // coordinates from the sliced (remapped/sheared/scaled) frame back to the
 // machine's real coordinate space.
 //
 // Initialized once from PrintConfig, then applied per-point in
 // GCodeWriter::to_machine_coords() before axis remapping.
 //
 // Active when gcode_back_transform is true AND at least one of:
 //   - a shear axis has global mode enabled, or
 //   - a pre-slice axis remap is non-identity.
 class BeltBackTransform
 {
 public:
    BeltBackTransform() = default;
    // Initialize from belt printer config.  Rebuilds the same pre-slice remap,
    // shear, and scale matrices as PrintObjectSlice.cpp and precomputes the
    // affine inverse.  Returns true if a non-identity back-transform was computed.
    bool init_from_config(const PrintConfig &config);
    // Apply the inverse transform to a point.  Returns pos unchanged if
    // no back-transform is active.
    Vec3d apply(const Vec3d &pos) const;
    // True if a non-identity back-transform is active.
    bool is_active() const { return m_active; }
 private:
    bool       m_active  = false;
    Transform3d m_inverse = Transform3d::Identity();
 };
 } // namespace Slic3r
 #endif // slic3r_BeltBackTransform_hpp_
@@ -1,10 +1,14 @@
 #include "../GCode.hpp"
 #include "../FirstLayerPlane.hpp"
 #include "CoolingBuffer.hpp"
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/log/trivial.hpp>
 #include <algorithm>
 #include <cstdlib>
 #include <iostream>
 #include <float.h>
 #include <string_view>
 #include <system_error>
 #include <unordered_map>
@@ -28,6 +32,12 @@ CoolingBuffer::CoolingBuffer(GCode &gcodegen) : m_config(gcodegen.config()), m_t
        m_num_extruders = std::max(ex.id() + 1, m_num_extruders);
        m_extruder_ids.emplace_back(ex.id());
    }
    // Borrow the first-layer plane from the GCode generator.  When inactive
    // (non-belt printers and belt printers without Z shear), per-line fan
    // re-evaluation is skipped and behavior is bit-identical to the legacy
    // per-layer path.
    m_first_layer_plane = gcodegen.first_layer_plane();
 }
 void CoolingBuffer::reset(const Vec3d &position)
@@ -328,6 +338,13 @@ std::string CoolingBuffer::process_layer(std::string &&gcode, size_t layer_id, b
        std::vector<PerExtruderAdjustments> per_extruder_adjustments = this->parse_layer_gcode(m_gcode, m_current_pos);
        float layer_time_stretched = this->calculate_layer_slowdown(per_extruder_adjustments);
        out = this->apply_layer_cooldown(m_gcode, layer_id, layer_time_stretched, per_extruder_adjustments);
        // First-layer plane: per-segment fan re-evaluation post-pass.  Walks
        // the cooled-down gcode and inserts inline M106 commands at band
        // crossings (where the path's perpendicular distance to the plane
        // crosses close_fan_the_first_x_layers thresholds).  No-op when
        // the evaluator is inactive.
        if (m_first_layer_plane && m_first_layer_plane->is_active())
            out = this->apply_first_layer_plane_fan_eval(std::move(out), layer_id, layer_time_stretched);
        m_gcode.clear();
    }
    return out;
@@ -1059,4 +1076,214 @@ std::string CoolingBuffer::apply_layer_cooldown(
    return new_gcode;
 }
 // Pure helper: compute the main fan speed for a given effective layer index.
 // Mirrors the inline logic in change_extruder_set_fan but is callable from
 // per-line code in apply_first_layer_plane_fan_eval.
 int CoolingBuffer::compute_main_fan_speed(int effective_layer_id, float layer_time,
                                           unsigned int extruder_id) const
 {
 #define EXTRUDER_CFG(opt) m_config.opt.get_at(extruder_id)
    float fan_min_speed              = EXTRUDER_CFG(fan_min_speed);
    float fan_max_speed              = EXTRUDER_CFG(fan_max_speed);
    bool  reduce_fan_stop_start_freq = EXTRUDER_CFG(reduce_fan_stop_start_freq);
    int   close_fan_the_first_x_layers = EXTRUDER_CFG(close_fan_the_first_x_layers);
    int   full_fan_speed_layer       = EXTRUDER_CFG(full_fan_speed_layer);
    float slow_down_layer_time       = float(EXTRUDER_CFG(slow_down_layer_time));
    float fan_cooling_layer_time     = float(EXTRUDER_CFG(fan_cooling_layer_time));
 #undef EXTRUDER_CFG
    if (close_fan_the_first_x_layers <= 0 && full_fan_speed_layer > 0)
        close_fan_the_first_x_layers = 1;
    float fan_speed_new = reduce_fan_stop_start_freq ? fan_min_speed : 0.f;
    if (effective_layer_id >= close_fan_the_first_x_layers) {
        if (layer_time < slow_down_layer_time) {
            fan_speed_new = fan_max_speed;
        } else if (layer_time < fan_cooling_layer_time) {
            double t = (layer_time - slow_down_layer_time) /
                       (fan_cooling_layer_time - slow_down_layer_time);
            fan_speed_new = float(int(floor(t * fan_min_speed +
                                            (1. - t) * fan_max_speed) + 0.5));
        }
        if (effective_layer_id + 1 < full_fan_speed_layer) {
            float factor = float(effective_layer_id + 1 - close_fan_the_first_x_layers)
                         / float(full_fan_speed_layer - close_fan_the_first_x_layers);
            fan_speed_new = float(std::clamp(int(fan_speed_new * factor + 0.5f), 0, 255));
        }
    } else {
        fan_speed_new = 0.f;
    }
    return int(fan_speed_new);
 }
 // Post-pass: walk the cooled-down gcode line by line, track XYZ position,
 // and insert M106 commands at first-layer-plane band crossings so the fan
 // follows perpendicular distance to the plane rather than the slicing-layer
 // index.  Only invoked when the FirstLayerPlane evaluator is active.
 //
 // This implementation is intentionally minimal: it overrides only the MAIN
 // fan (the one set by GCodeWriter::set_fan); overhang/internal-bridge/etc
 // special fans remain at their layer-level values from apply_layer_cooldown.
 // That keeps the per-line logic small while still giving the user precise
 // fan control near the belt surface, which is the main quality concern.
 std::string CoolingBuffer::apply_first_layer_plane_fan_eval(
    std::string &&gcode_in, size_t /*layer_id*/, float layer_time)
 {
    if (!m_first_layer_plane || !m_first_layer_plane->is_active())
        return std::move(gcode_in);
    const std::string &gcode = gcode_in;
    std::string out;
    out.reserve(gcode.size() + 256);
    // Match the PWM floor applied at every other set_fan call in this file so
    // band-crossing M106 emissions start the fan reliably at low speeds.
    const unsigned int part_cooling_fan_min_pwm = static_cast<unsigned int>(std::max(0, m_config.part_cooling_fan_min_pwm.value));
    // Track position in slicing-frame mm.  Seed from m_current_pos which the
    // CoolingBuffer keeps up-to-date across layers.
    Vec3d cur_pos_mm(m_current_pos[0], m_current_pos[1], m_current_pos[2]);
    // Track current main fan speed by parsing M106 commands as we walk so
    // we can restore it after a band exit.
    int  current_main_fan = m_fan_speed;
    int  pre_band_main_fan = current_main_fan;
    // Implicit initial state: assume the layer started "out of the band"
    // (i.e., the layer-level fan setting from apply_layer_cooldown is in
    // effect).  The first movement we encounter will reconcile this.
    bool in_first_layer_band = false;
    unsigned int active_extruder = m_current_extruder;
    auto parse_xyz_into = [](const std::string_view &line_sv, Vec3d &p) {
        if (line_sv.size() < 3) return false;
        if (line_sv[0] != 'G') return false;
        if (line_sv[1] != '0' && line_sv[1] != '1') return false;
        if (line_sv[2] != ' ' && line_sv[2] != '\t') return false;
        const char *c   = line_sv.data() + 3;
        const char *end = line_sv.data() + line_sv.size();
        bool        any = false;
        while (c < end && *c != ';') {
            while (c < end && (*c == ' ' || *c == '\t')) ++c;
            if (c >= end || *c == ';' || *c == '\n' || *c == '\r') break;
            char axis = *c;
            ++c;
            if (axis == 'X' || axis == 'Y' || axis == 'Z') {
                char *next;
                double v = std::strtod(c, &next);
                if (next != c) {
                    if (axis == 'X') p.x() = v;
                    else if (axis == 'Y') p.y() = v;
                    else                  p.z() = v;
                    c   = next;
                    any = true;
                    continue;
                }
            }
            // Skip unrecognized word.
            while (c < end && *c != ' ' && *c != '\t' && *c != ';' && *c != '\n')
                ++c;
        }
        return any;
    };
    auto parse_m106 = [](const std::string_view &line_sv) -> int {
        // Returns -1 if not an M106, otherwise the S value (0..255).
        if (line_sv.size() < 4 || line_sv[0] != 'M') return -1;
        if (!(line_sv[1] == '1' && line_sv[2] == '0' && line_sv[3] == '6'))
            return -1;
        // Find S<value>
        size_t s_pos = line_sv.find('S');
        if (s_pos == std::string_view::npos) return -1;
        const char *c = line_sv.data() + s_pos + 1;
        char *next;
        long v = std::strtol(c, &next, 10);
        if (next == c) return -1;
        return int(std::clamp<long>(v, 0, 255));
    };
    auto parse_m107 = [](const std::string_view &line_sv) -> bool {
        return line_sv.size() >= 4 && line_sv[0] == 'M' &&
               line_sv[1] == '1' && line_sv[2] == '0' && line_sv[3] == '7';
    };
    auto parse_tool_change = [this](const std::string_view &line_sv) -> int {
        // Returns the new extruder id, or -1 if not a toolchange.
        if (line_sv.size() < m_toolchange_prefix.size() + 1) return -1;
        if (line_sv.compare(0, m_toolchange_prefix.size(), m_toolchange_prefix) != 0)
            return -1;
        const char *c = line_sv.data() + m_toolchange_prefix.size();
        char *next;
        long v = std::strtol(c, &next, 10);
        if (next == c) return -1;
        return int(v);
    };
    const char *p   = gcode.c_str();
    const char *end = gcode.c_str() + gcode.size();
    while (p < end) {
        const char *line_end = p;
        while (line_end < end && *line_end != '\n') ++line_end;
        const char *next_line = line_end;
        if (next_line < end) ++next_line;  // include the '\n'
        std::string_view line_sv(p, line_end - p);
        // Track tool changes so the per-line fan eval uses the right extruder.
        int new_tool = parse_tool_change(line_sv);
        if (new_tool >= 0)
            active_extruder = unsigned(new_tool);
        // Track existing fan commands so we can restore the right value when
        // exiting a band.
        int m106_speed = parse_m106(line_sv);
        if (m106_speed >= 0) {
            current_main_fan = m106_speed;
            if (!in_first_layer_band)
                pre_band_main_fan = m106_speed;
        } else if (parse_m107(line_sv)) {
            current_main_fan = 0;
            if (!in_first_layer_band)
                pre_band_main_fan = 0;
        }
        // Movement line: parse XYZ, evaluate plane, possibly emit a fan
        // change BEFORE this line.
        bool moved = parse_xyz_into(line_sv, cur_pos_mm);
        if (moved) {
            const int eff_idx = m_first_layer_plane->effective_layer_index(cur_pos_mm);
            const int close_n = m_config.close_fan_the_first_x_layers.get_at(active_extruder);
            const bool now_in_band = eff_idx < std::max(close_n, 1);
            if (now_in_band != in_first_layer_band) {
                // Band crossing: emit a M106 with the appropriate speed.
                int target_fan;
                if (now_in_band) {
                    // Entering the first-layer band: fan off.
                    pre_band_main_fan = current_main_fan;
                    target_fan = compute_main_fan_speed(eff_idx, layer_time, active_extruder);
                } else {
                    // Exiting the band: restore the layer's normal fan speed.
                    // Use compute_main_fan_speed with the effective index so
                    // the linear ramp factor (close_fan→full_fan_speed_layer)
                    // also follows distance from the plane.
                    target_fan = compute_main_fan_speed(eff_idx, layer_time, active_extruder);
                    if (target_fan == 0)
                        target_fan = pre_band_main_fan;
                }
                if (target_fan != current_main_fan) {
                    out += GCodeWriter::set_fan(m_config.gcode_flavor, target_fan, part_cooling_fan_min_pwm);
                    current_main_fan = target_fan;
                    m_fan_speed = target_fan;
                    m_current_fan_speed = target_fan;
                }
                in_first_layer_band = now_in_band;
            }
        }
        out.append(p, next_line - p);
        p = next_line;
    }
    return out;
 }
 } // namespace Slic3r
@@ -10,6 +10,7 @@ namespace Slic3r {
 class GCode;
 class Layer;
 class FirstLayerPlane;
 struct PerExtruderAdjustments;
 // A standalone G-code filter, to control cooling of the print.
@@ -36,6 +37,21 @@ private:
    // Returns the adjusted G-code.
    std::string apply_layer_cooldown(const std::string &gcode, size_t layer_id, float layer_time, std::vector<PerExtruderAdjustments> &per_extruder_adjustments);
    // First-layer plane: per-line fan re-evaluation post-pass.  Walks the
    // post-cooldown gcode, tracks XYZ position, and inserts M106 commands at
    // band-crossing transitions in slicing-frame coordinates.  Only runs
    // when m_first_layer_plane is active.
    std::string apply_first_layer_plane_fan_eval(std::string &&gcode_in,
                                                  size_t        layer_id,
                                                  float         layer_time);
    // Pure helper: compute the main fan speed for a given effective layer
    // index (layer-id units, mapped through the plane evaluator) and the
    // current extruder.  Mirrors the inline logic in the change_extruder_set_fan
    // lambda but is callable from per-line code.
    int compute_main_fan_speed(int effective_layer_id, float layer_time,
                               unsigned int extruder_id) const;
    // G-code snippet cached for the support layers preceding an object layer.
    std::string                 m_gcode;
    // Internal data.
@@ -58,6 +74,9 @@ private:
    unsigned int                m_current_nozzle;
    //BBS: current fan speed
    int                         m_current_fan_speed;
    // First-layer plane evaluator, borrowed from GCode.  Null = inactive
    // (legacy per-layer fan control).
    const FirstLayerPlane      *m_first_layer_plane = nullptr;
 };
 }
@@ -2533,6 +2533,12 @@ void GCodeProcessorResult::reset() {
    long_retraction_when_cut = false;
    timelapse_warning_code = 0;
    printable_height = 0.0f;
    machine_frame_transform_active = false;
    belt_tilt_angle = 0.f;
    belt_z_origin   = 0.f;
    preslice_remap_x = RemapAxis::PosX;
    preslice_remap_y = RemapAxis::PosY;
    preslice_remap_z = RemapAxis::PosZ;
    settings_ids.reset();
    filaments_count = 0;
    backtrace_enabled = false;
@@ -2769,6 +2775,32 @@ bool GCodeProcessor::check_multi_extruder_gcode_valid(const int
        return ps;
    };
    // Belt-printer post-gcode shear/scale/post_remap is applied as the final
    // step of BeltGCodeWriter::to_machine_coords, so MoveVertex.position is
    // in the printer's machine frame.  Undo it here so XY area and Z height
    // checks operate in the build-volume frame that printable_area /
    // printable_height are defined in.  For non-belt printers
    // (is_active() == false) apply_inverse is identity and behaviour is
    // unchanged from before.
    const bool machine_frame_active = m_machine_frame_transform.is_active();
    auto compare_pos = [&](const GCodeProcessorResult::MoveVertex &move) -> Vec3d {
        Vec3d pos = move.position.cast<double>();
        if (!machine_frame_active)
            return pos;
        Vec3d extruder_off = Vec3d::Zero();
        if (size_t(move.extruder_id) < m_extruder_offsets.size())
            extruder_off = m_extruder_offsets[move.extruder_id].cast<double>();
        // Strip plate + extruder offsets to recover the raw machine-frame
        // coordinate that was emitted into the G-code (see store_move_vertex).
        Vec3d machine(pos.x() - m_x_offset - extruder_off.x(),
                      pos.y() - m_y_offset - extruder_off.y(),
                      pos.z() - extruder_off.z() + m_z_offset);
        Vec3d build = m_machine_frame_transform.apply_inverse(machine);
        // Re-apply plate offset so the result matches plate_printable_poly,
        // which is translated by plate_offset below.
        return Vec3d(build.x() + m_x_offset, build.y() + m_y_offset, build.z());
    };
    struct GCodePosInfo
    {
        Points pos;
@@ -2780,26 +2812,20 @@ bool GCodeProcessor::check_multi_extruder_gcode_valid(const int
    for (const GCodeProcessorResult::MoveVertex &move : m_result.moves) {
        // sometimes, the start line extrude was outside the edge of plate a little, this is allowed, so do not include into the gcode_path_pos
        if (move.type == EMoveType::Extrude /* && move.extrusion_role != ExtrusionRole::erFlush || move.type == EMoveType::Travel*/) {
            const Vec3d cp = compare_pos(move);
            // For belt printers we read Z from the inverse-transformed position
            // (post-origin-snap, pre-machine-frame).  Otherwise keep the
            // original print_z source (the slicer's layer-Z comment) so
            // non-belt behaviour is bit-for-bit unchanged.
            const float z_for_height = machine_frame_active ? float(cp.z()) : move.print_z;
            if (move.extrusion_role == ExtrusionRole::erCustom) {
-                /*if (move.is_arc_move_with_interpolation_points()) {
+                gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos_custom.emplace_back(to_2d(cp));
                    for (int i = 0; i < move.interpolation_points.size(); i++) {
                        gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos_custom.emplace_back(to_2d(move.interpolation_points[i].cast<double>()));
                    }
                } else {*/
                    gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos_custom.emplace_back(to_2d(move.position.cast<double>()));
                //}
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z_custom =
-                    std::max(gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z_custom, move.print_z);
+                    std::max(gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z_custom, z_for_height);
            } else {
-                /*if (move.is_arc_move_with_interpolation_points()) {
+                gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos.emplace_back(to_2d(cp));
                    for (int i = 0; i < move.interpolation_points.size(); i++) {
                        gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos.emplace_back(to_2d(move.interpolation_points[i].cast<double>()));
                    }
                } else {*/
                    gcode_path_pos[move.object_label_id][int(move.extruder_id)].pos.emplace_back(to_2d(move.position.cast<double>()));
                //}
                gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z = std::max(gcode_path_pos[move.object_label_id][int(move.extruder_id)].max_print_z,
-                                                                                                   move.print_z);
+                                                                                                   z_for_height);
            }
        }
    }
@@ -3041,6 +3067,12 @@ void GCodeProcessor::apply_config(const PrintConfig& config)
    m_result.printable_height = config.printable_height;
    // Belt printer: cache the post-gcode machine-frame transform so the
    // multi-extruder validator can undo it and compare against build-volume
    // bounds rather than machine-frame positions.
    m_machine_frame_transform.init_from_config(config);
    m_result.machine_frame_transform_active = m_machine_frame_transform.is_active();
    auto filament_maps = config.option<ConfigOptionInts>("filament_map");
    if (filament_maps != nullptr) {
        m_filament_maps = filament_maps->values;
@@ -3554,6 +3586,7 @@ void GCodeProcessor::reset()
    m_zero_layer_height = 0.0f;
    m_first_layer_height = 0.0f;
    m_processing_start_custom_gcode = false;
    m_in_config_block = false;
    m_g1_line_id = 0;
    m_layer_id = 0;
    m_cp_color.reset();
@@ -4159,6 +4192,55 @@ void GCodeProcessor::process_tags(const std::string_view comment, bool producers
        return;
    }
    if (boost::starts_with(comment, " CONFIG_BLOCK_START")) {
        m_in_config_block = true;
        return;
    }
    if (boost::starts_with(comment, " CONFIG_BLOCK_END")) {
        m_in_config_block = false;
        return;
    }
    // Belt printer: derive the physical tilt magnitude from the slicing-rotation
    // angle header comment (used to enable the preview's belt view). Only the belt
    // header carries it outside the config block; the config block lists the key
    // for every printer, belt or not.
    if (!m_in_config_block && boost::starts_with(comment, " belt_slice_rotation_angle = ")) {
        try {
            m_result.belt_tilt_angle = std::abs(std::stof(std::string(comment.substr(29))));
        } catch (...) {}
        return;
    }
    // Belt printer: parse pre-slice axis remap from header comments.
    {
        auto trim = [](const std::string &s) -> std::string {
            size_t start = s.find_first_not_of(" \t\r\n");
            size_t end   = s.find_last_not_of(" \t\r\n");
            return (start == std::string::npos) ? "" : s.substr(start, end - start + 1);
        };
        // Pre-slice axis remap
        auto parse_remap_axis = [](const std::string &s) -> RemapAxis {
            if (s == "pos_x") return RemapAxis::PosX;
            if (s == "pos_y") return RemapAxis::PosY;
            if (s == "pos_z") return RemapAxis::PosZ;
            if (s == "neg_x") return RemapAxis::NegX;
            if (s == "neg_y") return RemapAxis::NegY;
            if (s == "neg_z") return RemapAxis::NegZ;
            if (s == "rev_x") return RemapAxis::RevX;
            if (s == "rev_y") return RemapAxis::RevY;
            if (s == "rev_z") return RemapAxis::RevZ;
            return RemapAxis::PosX;
        };
        if (boost::starts_with(comment, " preslice_remap_x = ")) {
            m_result.preslice_remap_x = parse_remap_axis(trim(std::string(comment.substr(25)))); return;
        }
        if (boost::starts_with(comment, " preslice_remap_y = ")) {
            m_result.preslice_remap_y = parse_remap_axis(trim(std::string(comment.substr(25)))); return;
        }
        if (boost::starts_with(comment, " preslice_remap_z = ")) {
            m_result.preslice_remap_z = parse_remap_axis(trim(std::string(comment.substr(25)))); return;
        }
    }
    // wipe start tag
    if (boost::starts_with(comment, reserved_tag(ETags::Wipe_Start))) {
        m_wiping = true;
@@ -6055,6 +6137,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()) {
@@ -7033,6 +7122,22 @@ void GCodeProcessor::store_move_vertex(EMoveType type, EMovePathType path_type,
        m_result.print_statistics.total_travel_distance += m_travel_dist;
    }
    // During the start G-code "prepare" stage the toolhead Z is not yet a real
    // print height on a normal printer, so it is pinned to the first-layer height
    // to keep the preview tidy. Belt printers are the exception: there the Z is
    // written explicitly by BeltGCodeWriter and the designed-view back-transform
    // couples machine Z into the rendered model Y (the belt tilt mixes the height
    // and belt-feed axes). Overriding Z therefore back-transforms the last
    // prepare-stage move (the unretract before the first extrusion) to model
    // Y ~= 0, and the libvgcode path builder then draws a phantom extrusion
    // segment from Y ~= 0 to the first real toolpath. Keep the real Z for belt
    // printers so prepare-stage moves map correctly. Gated on belt_tilt_angle (set
    // from the G-code header before the body is processed) so non-belt processing
    // is byte-identical.
    const float store_z = (m_processing_start_custom_gcode && m_result.belt_tilt_angle == 0.f)
        ? m_first_layer_height
        : m_end_position[Z] - m_z_offset;
    m_result.moves.push_back({
        m_last_line_id,
        type,
@@ -7040,7 +7145,7 @@ void GCodeProcessor::store_move_vertex(EMoveType type, EMovePathType path_type,
        static_cast<unsigned char>(filament_id),
        m_cp_color.current,
        //BBS: add plate's offset to the rendering vertices
-        Vec3f(m_end_position[X] + m_x_offset, m_end_position[Y] + m_y_offset, m_processing_start_custom_gcode ? m_first_layer_height : m_end_position[Z]- m_z_offset) + m_extruder_offsets[filament_id],
+        Vec3f(m_end_position[X] + m_x_offset, m_end_position[Y] + m_y_offset, store_z) + m_extruder_offsets[filament_id],
        static_cast<float>(m_end_position[E] - m_start_position[E]),
        m_feedrate,
        0.0f, // actual feedrate
@@ -7,6 +7,7 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/CustomGCode.hpp"
 #include "libslic3r/MultiNozzleUtils.hpp"
 #include "libslic3r/GCode/MachineFrameTransform.hpp"
 #include <cstdint>
 #include <array>
@@ -276,6 +277,22 @@ class Print;
        bool support_traditional_timelapse{true};
        float printable_height;
        float z_offset;
        // 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 };
        // Belt printer: post-gcode shear/scale/post_remap is configured and
        // non-identity.  When set, the layer Z values in `moves` are in the
        // machine frame and should not be compared against `printable_height`
        // (which lives in the build-volume frame).
        bool machine_frame_transform_active{ false };
        RemapAxis preslice_remap_x{ RemapAxis::PosX };
        RemapAxis preslice_remap_y{ RemapAxis::PosY };
        RemapAxis preslice_remap_z{ RemapAxis::PosZ };
        SettingsIds settings_ids;
        size_t filaments_count;
        bool backtrace_enabled;
@@ -367,6 +384,12 @@ class Print;
            // Keep the SKIPPABLE per-type time on a copied result.
            skippable_part_time = other.skippable_part_time;
            initial_layer_time = other.initial_layer_time;
            belt_tilt_angle = other.belt_tilt_angle;
            belt_z_origin = other.belt_z_origin;
            machine_frame_transform_active = other.machine_frame_transform_active;
            preslice_remap_x = other.preslice_remap_x;
            preslice_remap_y = other.preslice_remap_y;
            preslice_remap_z = other.preslice_remap_z;
 #if ENABLE_GCODE_VIEWER_STATISTICS
            time = other.time;
 #endif
@@ -1136,6 +1159,12 @@ class Print;
        double          m_x_offset{ 0 };
        double          m_y_offset{ 0 };
        // Belt-printer post-gcode shear/scale/post_remap. Used by
        // check_multi_extruder_gcode_valid to undo the machine-frame
        // transform on move positions so bounds checks operate in the
        // pre-machine-frame (build-volume) frame.
        MachineFrameTransform m_machine_frame_transform;
        unsigned int m_line_id;
        unsigned int m_last_line_id;
        float m_feedrate; // mm/s
@@ -1165,6 +1194,7 @@ class Print;
        float m_first_layer_height; // mm
        float m_zero_layer_height; // mm
        bool m_processing_start_custom_gcode;
        bool m_in_config_block;
        unsigned int m_g1_line_id;
        unsigned int m_layer_id;
        CpColor m_cp_color;
@@ -0,0 +1,86 @@
 #include "MachineFrameTransform.hpp"
 #include "../Geometry.hpp"
 #include <cmath>
 namespace Slic3r {
 bool MachineFrameTransform::init_from_config(const PrintConfig &config)
 {
    m_active            = false;
    m_transform         = Transform3d::Identity();
    m_transform_inverse = Transform3d::Identity();
    if (!config.belt_printer.value)
        return false;
    // The machine-frame transform is derived from the single belt tilt (axis +
    // angle) that also drives the pre-slice mesh rotation.  Expert decouple lets
    // the machine-frame angle differ from the slicing rotation; otherwise both
    // use belt_slice_rotation_angle.
    const BeltRotationAxis axis = config.belt_slice_rotation.value;
    if (axis == BeltRotationAxis::None || axis == BeltRotationAxis::Z)
        return false; // Z is an in-plane spin: no machine-frame tilt.
    const double angle_deg = config.belt_frame_tilt_decouple.value
        ? config.belt_frame_tilt_angle.value
        : config.belt_slice_rotation_angle.value;
    if (std::abs(angle_deg) <= EPSILON)
        return false;
    const double angle_rad = Geometry::deg2rad(angle_deg);
    const double sin_a      = std::sin(angle_rad);
    if (std::abs(sin_a) <= EPSILON)
        return false;
    const double cot_a   = std::cos(angle_rad) / sin_a;
    const double inv_sin = 1.0 / std::abs(sin_a);
    // This stage runs after the conventional belt axis swap. For an X-axis
    // slicing rotation, remapped Y is model height and remapped Z is travel
    // along the belt. Convert those Cartesian coordinates to machine axes with
    // the established belt-printer convention:
    //   machine gantry = model height / sin(a)
    //   machine belt   = model belt + model height * cot(a)
    // The Y-rotation case is the same mapping on X/Z, with the rotation sign.
    // At 45 degrees tan/cot and sin/cos are equal, which previously hid the
    // incorrect complementary-angle formulas used by this unified transform.
    Matrix3d shear = Matrix3d::Identity();
    Matrix3d scale = Matrix3d::Identity();
    if (axis == BeltRotationAxis::X) {
        shear(2, 1) =  cot_a;   // Z from Y
        scale(1, 1) =  inv_sin; // Y
    } else { // BeltRotationAxis::Y
        shear(2, 0) = -cot_a;   // Z from X
        scale(0, 0) =  inv_sin; // X
    }
    // Apply shear first, then scale (the historical default ShearThenScale order:
    // result = scale * shear * p).  For the canonical 45°/X belt this maps
    // (x,y,z) -> (x, y/sin, y + z), matching the previous per-axis config.
    Transform3d combined = Transform3d::Identity();
    combined.linear() = scale * shear;
    if (combined.isApprox(Transform3d::Identity()))
        return false;
    m_transform         = combined;
    m_transform_inverse = combined.inverse();
    m_active            = true;
    return true;
 }
 Vec3d MachineFrameTransform::apply(const Vec3d &pos) const
 {
    if (!m_active)
        return pos;
    return m_transform * pos;
 }
 Vec3d MachineFrameTransform::apply_inverse(const Vec3d &pos) const
 {
    if (!m_active)
        return pos;
    return m_transform_inverse * pos;
 }
 } // namespace Slic3r
@@ -0,0 +1,54 @@
 #ifndef slic3r_MachineFrameTransform_hpp_
 #define slic3r_MachineFrameTransform_hpp_
 #include "../libslic3r.h"
 #include "../Point.hpp"
 #include "../PrintConfig.hpp"
 namespace Slic3r {
 // Post-stage machine-frame transform for belt printers.
 //
 // Applied in BeltGCodeWriter::to_machine_coords AFTER the back-transform and
 // the gcode_remap_* axis remap.  Maps Cartesian (axis-permuted) G-code
 // coordinates into the printer's physical machine frame.
 //
 // Derived entirely from the single belt tilt (belt_slice_rotation axis +
 // belt_slice_rotation_angle): a shear coupling the height axis to the belt-feed
 // axis (factor cot a) plus a 1/sin a scale on the gantry-height axis.  The expert
 // belt_frame_tilt_decouple flag lets the machine-frame angle differ from the
 // pre-slice rotation angle via belt_frame_tilt_angle.
 class MachineFrameTransform
 {
 public:
    MachineFrameTransform() = default;
    // Initialize from belt printer config.  Returns true if a non-identity
    // transform was computed.  Inactive when belt_printer is disabled or
    // both shear and scale are identity.
    bool init_from_config(const PrintConfig &config);
    // Apply the transform to a point.  Returns pos unchanged if not active.
    Vec3d apply(const Vec3d &pos) const;
    // Apply the inverse transform.  Returns pos unchanged if not active.
    // Used by validators that need to compare emitted machine-frame
    // coordinates against build-volume bounds.
    Vec3d apply_inverse(const Vec3d &pos) const;
    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();
    Transform3d m_transform_inverse = Transform3d::Identity();
 };
 } // namespace Slic3r
 #endif // slic3r_MachineFrameTransform_hpp_
@@ -627,7 +627,7 @@ void compute_global_occlusion(GlobalModelInfo &result, const PrintObject *po,
                              SeamPosition seam_position = spAligned) {
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: gather occlusion meshes: start";
-  auto obj_transform = po->trafo_centered();
+  auto obj_transform = po->trafo_sliced();
  indexed_triangle_set triangle_set;
  indexed_triangle_set negative_volumes_set;
  //add all parts
@@ -712,7 +712,7 @@ void gather_enforcers_blockers(GlobalModelInfo &result, const PrintObject *po) {
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: build AABB trees for raycasting enforcers/blockers: start";
-  auto obj_transform = po->trafo_centered();
+  auto obj_transform = po->trafo_sliced();
  for (const ModelVolume *mv : po->model_object()->volumes) {
    if (mv->is_seam_painted()) {
@@ -395,6 +395,10 @@ bool ToolOrdering::insert_wipe_tower_extruder()
 {
    if (!m_print_config_ptr || !m_print_config_ptr->enable_prime_tower)
        return false;
    // Belt mode has no classic wipe tower; the dedicated wipe tower filament
    // must not inject extra toolchanges into the purge prism planning.
    if (m_print_config_ptr->belt_printer)
        return false;
    if (m_print_config_ptr->wipe_tower_filament == 0)
        return false;
@@ -492,6 +496,11 @@ ToolOrdering::ToolOrdering(const PrintObject &object, unsigned int first_extrude
            zs.emplace_back(layer->print_z);
        for (auto layer : object.support_layers())
            zs.emplace_back(layer->print_z);
        // Belt brim apron bands sit below the object's first layer and have no
        // layer of their own, but tools_for_layer() asserts an exact Z match, so
        // their print_z must be part of the ordering.
        for (const BeltBrimBand &band : object.belt_brim_prologue())
            zs.emplace_back(band.print_z);
        this->initialize_layers(zs);
    }
@@ -536,6 +545,10 @@ ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder, bool
                zs.emplace_back(layer->print_z);
            for (auto layer : object->support_layers())
                zs.emplace_back(layer->print_z);
            // See the single-object ctor: belt brim apron bands need their own
            // ordering entries or tools_for_layer() will assert.
            for (const BeltBrimBand &band : object->belt_brim_prologue())
                zs.emplace_back(band.print_z);
            max_layer_height = std::max(max_layer_height, object->config().layer_height.value);
        }
@@ -970,6 +983,44 @@ void ToolOrdering::collect_extruders(const PrintObject &object, const std::vecto
        }
    }
    // Belt brim apron bands own their layers outright: they print below the
    // object's first layer, so no object or support layer claims an extruder there
    // and process_layer() would bail out at "Nothing to extrude".  Claim the
    // object's outer wall filament, in the same raw 1-based domain the loops above
    // push.  Deliberately not layer_tools.has_object, which drives skirt marking
    // and wiping overrides.
    if (! object.belt_brim_prologue().empty()) {
        // 1-based, same domain the object/support pushes above use; reindexed to 0-based
        // with the rest of the list later.
        const unsigned int brim_filament = object.belt_brim_filament();
        for (const BeltBrimBand &band : object.belt_brim_prologue()) {
            if (band.fills.empty())
                continue;
            LayerTools &layer_tools = this->tools_for_layer(band.print_z);
            layer_tools.extruders.push_back(brim_filament);
            layer_tools.has_belt_brim = true;
        }
    }
    // Coincident brim bands (belt_brim_by_layer) print ON an object layer rather than
    // below it, but that layer can produce no InstanceVisit in process_layer - a
    // zero-extrusion lead-in slice with no coinciding support - and the band would then
    // be silently dropped.  Register the brim filament on every layer that carries a
    // coincident band, in the same 1-based domain as the prologue push above, so a brim
    // pass always exists there.
    if (object.has_belt_brim()) {
        const unsigned int brim_filament = object.belt_brim_filament();
        const auto        &by_layer      = object.belt_brim_by_layer();
        const size_t       n             = std::min(by_layer.size(), object.layers().size());
        for (size_t i = 0; i < n; ++ i) {
            if (by_layer[i].empty())
                continue;
            LayerTools &layer_tools = this->tools_for_layer(object.layers()[i]->print_z);
            layer_tools.extruders.push_back(brim_filament);
            layer_tools.has_belt_brim = true;
        }
    }
    for (auto& layer : m_layer_tools) {
        // Sort and remove duplicates
        sort_remove_duplicates(layer.extruders);
@@ -1012,12 +1063,28 @@ void ToolOrdering::fill_wipe_tower_partitions(const PrintConfig &config, coordf_
    }
    //FIXME this is a hack to get the ball rolling.
    // The `print_z < object_bottom_z` clause reads "below the object" as "raft
    // gap".  On a belt printer that is wrong: the brim apron legitimately prints
    // below the object's first layer, and treating those layers as raft would put a
    // wipe tower at negative Z.  Belt brim and the prime tower are mutually
    // exclusive (rejected in Print::validate()), so simply drop the clause there.
    //
    // Gate on config.belt_printer, NOT on has_belt_brim: every layer below the
    // object bottom on a belt printer is legitimately a sub-object stream - brim
    // apron, belt support printed below Z0, or the object's own lead-in - and none of
    // them is ever raft, because Print::validate() rejects raft_layers>0 on a belt
    // printer outright.  Narrowing this to has_belt_brim would reclassify
    // belt-support-below-floor layers as raft on brim-less belt prints and reintroduce
    // the negative-Z wipe tower, so the broad belt_printer gate is correct.
    const bool belt_no_raft_gap = config.belt_printer.value;
    for (LayerTools &lt : m_layer_tools)
        lt.has_wipe_tower |= ((lt.has_object || lt.has_support) && (config.timelapse_type == TimelapseType::tlSmooth || lt.wipe_tower_partitions > 0))
-            || lt.print_z < object_bottom_z + EPSILON;
+            || (! belt_no_raft_gap && lt.print_z < object_bottom_z + EPSILON);
    // Test for a raft, insert additional wipe tower layer to fill in the raft separation gap.
-    for (size_t i = 0; i + 1 < m_layer_tools.size(); ++ i) {
+    // Skipped on belt printers for the same reason as the clause above: layers
    // below the object are brim apron, not raft.
    for (size_t i = 0; ! belt_no_raft_gap && i + 1 < m_layer_tools.size(); ++ i) {
        const LayerTools &lt      = m_layer_tools[i];
        const LayerTools &lt_next = m_layer_tools[i + 1];
        if (lt.print_z < object_bottom_z + EPSILON && lt_next.print_z >= object_bottom_z + EPSILON) {
@@ -75,6 +75,12 @@ public:
    void set_layer_tools_ptr(const LayerTools* lt) { m_layer_tools = lt; }
 private:
    // Returns true if entity is not printed with its usual extruder for a given copy.
    bool is_entity_overridden(const ExtrusionEntity* entity, const PrintObject *object, size_t copy_id) const {
        auto it = entity_map.find(std::make_tuple(entity, object));
        return it != entity_map.end() && copy_id < it->second.size() && it->second[copy_id] != -1;
    }
    int first_nonsoluble_extruder_on_layer(const PrintConfig& print_config) const;
    int last_nonsoluble_extruder_on_layer(const PrintConfig& print_config) const;
@@ -84,12 +90,6 @@ private:
    void set_support_extruder_override(const PrintObject* object, size_t copy_id, int extruder, size_t num_of_copies);
    void set_support_interface_extruder_override(const PrintObject* object, size_t copy_id, int extruder, size_t num_of_copies);
    // Returns true in case that entity is not printed with its usual extruder for a given copy:
    bool is_entity_overridden(const ExtrusionEntity* entity, const PrintObject *object, size_t copy_id) const {
        auto it = entity_map.find(std::make_tuple(entity, object));
        return it == entity_map.end() ? false : it->second[copy_id] != -1;
    }
    std::map<std::tuple<const ExtrusionEntity*, const PrintObject *>, ExtruderPerCopy> entity_map;  // to keep track of who prints what
    // BBS
    std::map<const PrintObject*, int> support_map;
@@ -165,6 +165,10 @@ public:
    // Should a skirt be printed at this layer?
    // Layers are marked for infinite skirt aka draft shield. Not all the layers have to be printed.
    bool                        has_skirt = false;
    // Belt printers: is this one of the brim-only apron layers below the object's
    // first layer?  Kept separate from has_object so skirt marking and wiping
    // overrides are unaffected.
    bool                        has_belt_brim = false;
    // Will there be anything extruded on this layer for the wipe tower?
    // Due to the support layers possibly interleaving the object layers,
    // wipe tower will be disabled for some support only layers.
@@ -1,5 +1,6 @@
 #include "GCodeWriter.hpp"
 #include "CustomGCode.hpp"
 #include "Geometry.hpp"
 #include "I18N.hpp"
 #include "PrintConfig.hpp"
 #include "ClipperUtils.hpp"
@@ -23,6 +24,36 @@ namespace Slic3r {
 bool GCodeWriter::full_gcode_comment = true;
 void GCodeWriter::set_axis_remap(int rx, int ry, int rz)
 {
    m_remap_x = rx;
    m_remap_y = ry;
    m_remap_z = rz;
 }
 void GCodeWriter::set_build_volume_max(const Vec3d &max)
 {
    m_build_vol_max = max;
 }
 bool GCodeWriter::has_axis_remap() const
 {
    return m_remap_x != 0 || m_remap_y != 1 || m_remap_z != 2;
 }
 Vec3d GCodeWriter::apply_axis_remap(const Vec3d &pos) const
 {
    if (!has_axis_remap())
        return pos;
    auto remap = [this, &pos](int r) -> double {
        int axis = r % 3;
        if (r < 3) return pos[axis];
        if (r < 6) return -pos[axis];
        return m_build_vol_max[axis] - pos[axis];
    };
    return { remap(m_remap_x), remap(m_remap_y), remap(m_remap_z) };
 }
 bool GCodeWriter::supports_separate_travel_acceleration(GCodeFlavor flavor)
 {
    return (flavor == gcfRepetier || flavor == gcfMarlinFirmware ||  flavor == gcfRepRapFirmware);
@@ -757,7 +788,13 @@ std::string GCodeWriter::travel_to_xy(const Vec2d &point, const std::string &com
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
    GCodeG1Formatter w;
-    w.emit_xy(point_on_plate);
+    if (has_axis_remap()) {
        // Axis remap may couple XY with Z; emit full XYZ in machine coordinates.
        Vec3d machine = apply_axis_remap(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
        w.emit_xyz(machine);
    } else {
        w.emit_xy(point_on_plate);
    }
    auto speed = m_is_first_layer
        ? this->config.get_abs_value_at("initial_layer_travel_speed", m_cached_extruder_idx) : this->config.travel_speed.get_at(m_cached_extruder_idx);
    w.emit_f(speed * 60.0);
@@ -899,7 +936,10 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
                Vec2d temp = delta_no_z.normalized() * delta(2) / tan(this->filament()->travel_slope());
                Vec3d slope_top_point = Vec3d(temp(0), temp(1), delta(2)) + source;
                GCodeG1Formatter w0;
-                w0.emit_xyz(slope_top_point);
+                // A slope lift is a straight (linear) diagonal move, so remapping its
                // endpoint is exact. Route the destination through apply_axis_remap()
                // when a remap is active (no-op at identity).
                w0.emit_xyz(has_axis_remap() ? apply_axis_remap(slope_top_point) : slope_top_point);
                w0.emit_f(travel_speed * 60.0);
                //BBS
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
@@ -913,7 +953,14 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
        std::string xy_z_move;
        {
            GCodeG1Formatter w0;
-            if (this->is_current_position_clear()) {
+            if (has_axis_remap()) {
                // Remap may couple XY with Z; emit full XYZ in machine coordinates.
                w0.emit_xyz(apply_axis_remap(target));
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
                xy_z_move = w0.string();
            }
            else if (this->is_current_position_clear()) {
                w0.emit_xyz(target);
                w0.emit_f(travel_speed * 60.0);
                w0.emit_comment(GCodeWriter::full_gcode_comment, comment);
@@ -951,7 +998,13 @@ std::string GCodeWriter::travel_to_xyz(const Vec3d &point, const std::string &co
    Vec3d point_on_plate = { dest_point(0) - m_x_offset, dest_point(1) - m_y_offset, dest_point(2) };
    std::string out_string;
    GCodeG1Formatter w;
-    if (!this->is_current_position_clear())
+    if (has_axis_remap()) {
        // Remap may couple XY with Z; emit full XYZ in machine coordinates.
        w.emit_xyz(apply_axis_remap(point_on_plate));
        w.emit_f(this->config.travel_speed.get_at(m_cached_extruder_idx) * 60.0);
        w.emit_comment(GCodeWriter::full_gcode_comment, comment);
        out_string = w.string();
    } else if (!this->is_current_position_clear())
    {
        //force to move xy first then z after filament change
        w.emit_xy(Vec2d(point_on_plate.x(), point_on_plate.y()));
@@ -1001,7 +1054,13 @@ std::string GCodeWriter::_travel_to_z(double z, const std::string &comment)
    }
    GCodeG1Formatter w;
-    w.emit_z(z);
+    if (has_axis_remap()) {
        // Remap may couple Z with other axes; emit full XYZ.
        Vec3d machine = apply_axis_remap(Vec3d(m_pos.x() - m_x_offset, m_pos.y() - m_y_offset, z));
        w.emit_xyz(machine);
    } else {
        w.emit_z(z);
    }
    w.emit_f(speed * 60.0);
    //BBS
    w.emit_comment(GCodeWriter::full_gcode_comment, comment);
@@ -1010,6 +1069,14 @@ std::string GCodeWriter::_travel_to_z(double z, const std::string &comment)
 std::string GCodeWriter::_spiral_travel_to_z(double z, const Vec2d &ij_offset, const std::string &comment)
 {
    // A circular XY arc / spiral lift cannot be correctly axis-remapped by
    // transforming only its endpoint: the arc plane (G17/XY) and the I-J center
    // would change under the remap. When an axis remap is active, fall back to a
    // plain linear lift instead of emitting a possibly-wrong spiral/arc. This
    // single guard covers every spiral call site (lazy/eager lift and travel_to_xyz).
    if (has_axis_remap())
        return _travel_to_z(z, comment);
    std::string output;
    double speed = this->config.travel_speed_z.get_at(m_cached_extruder_idx);
@@ -1109,7 +1176,12 @@ std::string GCodeWriter::extrude_to_xy(const Vec2d &point, double dE, const std:
    Vec2d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset };
    GCodeG1Formatter w;
-    w.emit_xy(point_on_plate);
+    if (has_axis_remap()) {
        Vec3d machine = apply_axis_remap(Vec3d(point_on_plate.x(), point_on_plate.y(), m_pos.z()));
        w.emit_xyz(machine);
    } else {
        w.emit_xy(point_on_plate);
    }
    if (!force_no_extrusion)
        w.emit_e(filament()->E());
    //BBS
@@ -1155,10 +1227,18 @@ std::string GCodeWriter::extrude_to_xyz(const Vec3d &point, double dE, const std
    Vec3d point_on_plate = { point(0) - m_x_offset, point(1) - m_y_offset, point(2) };
    GCodeG1Formatter w;
-    if (z_changed)
+    if (has_axis_remap()) {
        // z_changed was computed from the ORIGINAL slicing Z, but an axis remap can
        // make machine-Z depend on slicing X/Y. An X/Y-only move (slicing-Z
        // unchanged) would then drop the required machine-Z word, so always emit
        // full XYZ whenever a remap is active.
        point_on_plate = apply_axis_remap(point_on_plate);
        w.emit_xyz(point_on_plate);
-    else
+    } else if (z_changed) {
        w.emit_xyz(point_on_plate);
    } else {
        w.emit_xy(Vec2d(point_on_plate.x(), point_on_plate.y()));
    }
    if (!force_no_extrusion)
        w.emit_e(filament()->E());
    //BBS
@@ -9,26 +9,27 @@
 #include "Polygon.hpp"
 #include "PrintConfig.hpp"
 #include "GCode/CoolingBuffer.hpp"
 namespace Slic3r {
 class GCodeWriter {
 public:
    virtual ~GCodeWriter() = default;
    GCodeConfig config;
    bool multiple_extruders;
    GCodeWriter() :
-        multiple_extruders(false), m_curr_filament_extruder(MAXIMUM_EXTRUDER_NUMBER, nullptr),
+        multiple_extruders(false),
        m_curr_extruder_id (-1),
        m_cached_extruder_idx(0),
        m_single_extruder_multi_material(false),
        m_last_acceleration(0), m_max_acceleration(0),m_last_travel_acceleration(0), m_max_travel_acceleration(0),
        m_last_jerk(0), m_max_jerk_x(0), m_max_jerk_y(0),
        m_last_bed_temperature(0), m_last_bed_temperature_reached(true),
        m_lifted(0),
        m_to_lift(0),
        m_to_lift_type(LiftType::NormalLift),
-        m_current_speed(3600), m_is_first_layer(true)
+        m_is_first_layer(true), m_current_speed(3600),
        m_cached_extruder_idx(0),
        m_curr_filament_extruder(MAXIMUM_EXTRUDER_NUMBER, nullptr),
        m_curr_extruder_id (-1),
        m_single_extruder_multi_material(false),
        m_last_acceleration(0), m_max_acceleration(0),m_last_travel_acceleration(0), m_max_travel_acceleration(0),
        m_last_jerk(0), m_max_jerk_x(0), m_max_jerk_y(0),
        m_last_bed_temperature(0), m_last_bed_temperature_reached(true)
        {}
    Extruder* filament(size_t extruder_id) { assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }
    const Extruder* filament(size_t extruder_id) const { assert(extruder_id < m_curr_filament_extruder.size()); return m_curr_filament_extruder[extruder_id]; }
@@ -78,23 +79,23 @@ public:
    std::string set_speed(double F, const std::string &comment = std::string(), const std::string &cooling_marker = std::string());
    // SoftFever NOTE: the returned speed is mm/minute
    double      get_current_speed() const { return m_current_speed;}
-    std::string travel_to_xy(const Vec2d &point, const std::string &comment = std::string());
+    virtual std::string travel_to_xy(const Vec2d &point, const std::string &comment = std::string());
-    std::string travel_to_xyz(const Vec3d &point, const std::string &comment = std::string(), bool force_z = false);
+    virtual std::string travel_to_xyz(const Vec3d &point, const std::string &comment = std::string(), bool force_z = false);
    std::string travel_to_z(double z, const std::string &comment = std::string(), bool force = false);
    bool        will_move_z(double z) const;
-    std::string extrude_to_xy(const Vec2d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false);
+    virtual std::string extrude_to_xy(const Vec2d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false);
    //BBS: generate G2 or G3 extrude which moves by arc
    std::string extrude_arc_to_xy(const Vec2d &point, const Vec2d &center_offset, double dE, const bool is_ccw, const std::string &comment = std::string(), bool force_no_extrusion = false);
-    std::string extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false);
+    virtual std::string extrude_to_xyz(const Vec3d &point, double dE, const std::string &comment = std::string(), bool force_no_extrusion = false);
    std::string retract(bool before_wipe = false, double retract_length = 0);
    std::string retract_for_toolchange(bool before_wipe = false, double retract_length = 0);
    // extra_retract adds a small over-extrusion to the deretract move (PETG pre-extrusion).
    // Default 0 -> byte-identical to the plain deretract.
    std::string unretract(float extra_retract = 0.f);
    // do lift instantly
-    std::string eager_lift(const LiftType type);
+    virtual std::string eager_lift(const LiftType type);
    // record a lift request, do realy lift in next travel
-    std::string lazy_lift(LiftType lift_type = LiftType::NormalLift, bool spiral_vase = false);
+    virtual std::string lazy_lift(LiftType lift_type = LiftType::NormalLift, bool spiral_vase = false);
    std::string unlift();
    const Vec3d& get_position() const { return m_pos; }
    Vec3d&       get_position() { return m_pos; }
@@ -136,16 +137,48 @@ public:
    void invalidate_acceleration() { m_last_acceleration = 0; m_last_travel_acceleration = 0; }
    void invalidate_jerk() { m_last_jerk = 0; }
    // Axis remap: permute/negate/reverse axes in G-code output.
    // Works standalone (without belt mode) for printers with non-standard axis conventions.
    void set_axis_remap(int rx, int ry, int rz);
    void set_build_volume_max(const Vec3d &max);
    bool has_axis_remap() const;
    // Returns whether this flavor supports separate print and travel acceleration.
    static bool supports_separate_travel_acceleration(GCodeFlavor flavor);
-  private:
+protected:
    // Position/lift/offset state — accessible to subclasses (e.g. BeltGCodeWriter)
    Vec3d           m_pos = Vec3d::Zero();
    double          m_x_offset{ 0 };
    double          m_y_offset{ 0 };
    double          m_lifted;
    double          m_to_lift;
    LiftType        m_to_lift_type;
    bool            m_is_first_layer = true;
    bool            m_is_current_pos_clear = false;
    double          m_current_speed;
    virtual std::string _travel_to_z(double z, const std::string &comment);
    // Axis remap state — accessible to subclasses.
    int             m_remap_x = 0;  // RemapAxis: 0=+X, 1=+Y, 2=+Z, 3=-X, etc.
    int             m_remap_y = 1;
    int             m_remap_z = 2;
    Vec3d           m_build_vol_max = Vec3d::Zero();
    // Apply axis remap to a point. Returns pos unchanged if remap is identity.
    Vec3d apply_axis_remap(const Vec3d &pos) const;
    // Motion uses the global/base process variant until a filament becomes active.
    // Protected so BeltGCodeWriter indexes the per-extruder speed options (travel_speed,
    // travel_speed_z, initial_layer_travel_speed) exactly as the base writer does.
    size_t     m_cached_extruder_idx;
 private:
 	// Extruders are sorted by their ID, so that binary search is possible.
    std::vector<Extruder> m_filament_extruders;
    bool            m_single_extruder_multi_material;
    std::vector<Extruder*> m_curr_filament_extruder;
    int        m_curr_extruder_id;
    // Motion uses the global/base process variant until a filament becomes active.
    size_t     m_cached_extruder_idx;
    unsigned int              m_last_acceleration;
    unsigned int              m_last_travel_acceleration;
    std::vector<unsigned int> m_max_travel_acceleration;
@@ -167,19 +200,6 @@ public:
    //BBS
    int             m_last_bed_temperature;
    bool            m_last_bed_temperature_reached;
    double          m_lifted;
    // BBS
    double          m_to_lift;
    LiftType        m_to_lift_type;
    Vec3d           m_pos = Vec3d::Zero();
    //BBS: this flag is used to indicate whether the m_pos is real.
    //A example that of the first move, the m_pos is zero, but the real position of extruder doesn't
    //Pos must be clear after the first xyz travel move
    bool            m_is_current_pos_clear = false;
    //BBS: x, y offset for gcode generated
    double          m_x_offset{ 0 };
    double          m_y_offset{ 0 };
    // Orca: slicing resolution in mm
    double          m_resolution = 0.01;
@@ -197,15 +217,12 @@ public:
    //SoftFever
    bool            m_is_bbl_printers = false;
    double          m_current_speed;
    bool            m_is_first_layer = true;
    enum class Acceleration {
        Travel,
        Print
    };
    std::string _travel_to_z(double z, const std::string &comment);
    std::string _spiral_travel_to_z(double z, const Vec2d &ij_offset, const std::string &comment);
    // Orca: printable area of the active extruder (per-extruder when configured, otherwise the bed). Null when unknown.
    const Polygon *active_printable_area() const;
@@ -16,7 +16,6 @@ using LayerPtrs = std::vector<Layer*>;
 class LayerRegion;
 using LayerRegionPtrs = std::vector<LayerRegion*>;
 class PrintRegion;
 class PrintRegionConfig;
 class PrintObject;
 class Print;
@@ -201,11 +200,6 @@ public:
                                                                           FillAdaptive::Octree *support_fill_octree,
                                                                           FillLightning::Generator* lightning_generator) const;
    void 					make_ironing();
    // Returns the filament id (1-based) the region is ironed with, or -1 when the
    // region is not ironed.
    static int              choose_ironing_extruder(const PrintRegionConfig &cfg,
                                                    bool spiral_mode,
                                                    bool is_topmost_layer);
    void                    make_contour_z(const sla::IndexedMesh &mesh);
    void                    export_region_slices_to_svg(const char *path) const;
--- a/Show More
+++ b/Show More