mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-13 19:01:21 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 ExPikaPaka
|
682814878d |
@@ -341,12 +341,12 @@ jobs:
|
||||
|
||||
# Notarize main DMG
|
||||
xcrun notarytool submit "OrcaSlicer_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
|
||||
retry xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
|
||||
xcrun stapler staple OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
|
||||
|
||||
# Notarize profile validator DMG if it exists
|
||||
if [ -f "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" ]; then
|
||||
xcrun notarytool submit "OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg" --apple-id "${{ secrets.APPLE_DEV_ACCOUNT }}" --team-id "${{ secrets.TEAM_ID }}" --password "${{ secrets.APP_PWD }}" --wait
|
||||
retry xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
|
||||
xcrun stapler staple OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
|
||||
fi
|
||||
|
||||
- name: Create DMG without notary
|
||||
@@ -460,6 +460,10 @@ jobs:
|
||||
- name: Build slicer Win
|
||||
if: runner.os == 'Windows'
|
||||
working-directory: ${{ github.workspace }}
|
||||
# Orca: Removed Netfabb STL fixing service support in favor of CGAL.
|
||||
# env:
|
||||
# WindowsSdkDir: 'C:\Program Files (x86)\Windows Kits\10\'
|
||||
# WindowsSDKVersion: '10.0.26100.0\'
|
||||
# --tests builds the unit tests too; the unit_tests_windows_* jobs run them.
|
||||
run: |
|
||||
# cache-path is the install directory inside the deps build directory.
|
||||
|
||||
@@ -16,15 +16,6 @@ on:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
# Listing caches and builds while waiting for a deps cache.
|
||||
actions: read
|
||||
|
||||
# Read by scripts/ci_deps_cache.sh.
|
||||
env:
|
||||
REPO: ${{ github.repository }}
|
||||
WORKFLOW: build_all.yml
|
||||
BASE_REF: ${{ github.base_ref }}
|
||||
JOB: build_linux (${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }})
|
||||
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-${{ github.event.pull_request.number }}
|
||||
@@ -44,7 +35,7 @@ jobs:
|
||||
# The PR merge commit plus its first parent, the base it is diffed against.
|
||||
fetch-depth: 2
|
||||
|
||||
- name: Look for changed files
|
||||
- name: Look for changed C++ files
|
||||
id: changes
|
||||
run: |
|
||||
if git -c core.quotePath=false diff --name-only HEAD^1 -- src tests | grep -qE '\.(cpp|cc|cxx|hpp|h|hxx)$'; then
|
||||
@@ -52,75 +43,18 @@ jobs:
|
||||
else
|
||||
echo "No C++ changes under src/ or tests/."
|
||||
fi
|
||||
if ! git diff --quiet HEAD^1 -- deps; then
|
||||
echo "deps=true" >> "$GITHUB_OUTPUT"
|
||||
fi
|
||||
echo "deps-key=linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}" >> "$GITHUB_OUTPUT"
|
||||
|
||||
# Parsing needs the dependency headers, not a build of this PR's deps/.
|
||||
# Without an exact match the job waits for the build that saves it: this
|
||||
# PR's own when it changes deps/, otherwise a running push build of the
|
||||
# base branch with the same deps. With neither, a PR that keeps deps/
|
||||
# falls back to the newest cache.
|
||||
# Parsing needs the dependency headers, not a build of this PR's deps/, so
|
||||
# a PR that changes deps/ falls back to the newest cache main has.
|
||||
- name: Restore cached deps
|
||||
id: deps_cache
|
||||
if: steps.changes.outputs.cpp == 'true'
|
||||
uses: actions/cache/restore@v6
|
||||
with:
|
||||
path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
|
||||
key: ${{ steps.changes.outputs.deps-key }}
|
||||
|
||||
- name: Look for a build to wait for
|
||||
id: wait_check
|
||||
if: steps.changes.outputs.cpp == 'true' && steps.deps_cache.outputs.cache-hit != 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
HEAD_SHA: ${{ github.event.pull_request.head.sha }}
|
||||
run: bash scripts/ci_deps_cache.sh ${{ steps.changes.outputs.deps == 'true' && 'own' || 'check' }}
|
||||
|
||||
# Linux Build Deps takes about 35 minutes on GitHub-hosted runners. The
|
||||
# wait ends early when the deps job fails.
|
||||
- name: Wait for the deps cache
|
||||
if: steps.wait_check.outputs.wait-for != ''
|
||||
timeout-minutes: 100
|
||||
env:
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
KEY: ${{ steps.changes.outputs.deps-key }}
|
||||
CACHE_REF: ${{ steps.changes.outputs.deps == 'true' && github.ref || format('refs/heads/{0}', github.base_ref) }}
|
||||
KEY_INPUTS: ${{ steps.wait_check.outputs.key-inputs }}
|
||||
WAIT_FOR: ${{ steps.wait_check.outputs.wait-for }}
|
||||
WAIT_SINCE: ${{ steps.wait_check.outputs.wait-since }}
|
||||
WAIT_MINUTES: 90
|
||||
run: bash scripts/ci_deps_cache.sh wait
|
||||
|
||||
- name: Restore the deps cache after waiting
|
||||
id: waited_cache
|
||||
if: steps.wait_check.outputs.wait-for != ''
|
||||
uses: actions/cache/restore@v6
|
||||
with:
|
||||
path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
|
||||
key: ${{ steps.changes.outputs.deps-key }}
|
||||
|
||||
- name: Fail without this PR's deps cache
|
||||
if: steps.changes.outputs.deps == 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
|
||||
run: |
|
||||
echo "::error::No deps cache ${{ steps.changes.outputs.deps-key }}. Check this PR's Linux Build Deps job, then rerun clang-tidy."
|
||||
exit 1
|
||||
|
||||
- name: Restore the newest cached deps
|
||||
id: newest_cache
|
||||
if: steps.changes.outputs.deps != 'true' && steps.wait_check.outcome == 'success' && steps.waited_cache.outputs.cache-hit != 'true'
|
||||
uses: actions/cache/restore@v6
|
||||
with:
|
||||
path: ${{ github.workspace }}/deps/build/OrcaSlicer_dep
|
||||
key: ${{ steps.changes.outputs.deps-key }}
|
||||
key: linux-clang-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }}
|
||||
restore-keys: linux-clang-cache-orcaslicer_deps-build-
|
||||
fail-on-cache-miss: true
|
||||
|
||||
- name: Warn about older deps
|
||||
if: steps.newest_cache.outcome == 'success' && steps.newest_cache.outputs.cache-hit != 'true'
|
||||
run: echo "::warning title=Older deps::No cache matches this PR's deps/, so clang-tidy parsed against ${{ steps.newest_cache.outputs.cache-matched-key }}. If it reports errors in code that uses a dependency, rerun clang-tidy once the base branch's Build all has saved the new deps."
|
||||
|
||||
- name: Apt-Install Dependencies
|
||||
if: steps.changes.outputs.cpp == 'true' && !vars.SELF_HOSTED
|
||||
uses: ./.github/actions/apt-install-deps
|
||||
|
||||
@@ -497,6 +497,47 @@ endif()
|
||||
# Once we get rid of Perl and libslic3r is linked statically, we can get rid of -fPIC
|
||||
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
|
||||
# WIN10SDK_PATH is used to point CMake to the WIN10 SDK installation directory.
|
||||
# We pick it from environment if it is not defined in another way
|
||||
# ORCA: Removed Netfabb STL fixing service support in favor of CGAL.
|
||||
# if(WIN32)
|
||||
# if(NOT DEFINED WIN10SDK_PATH)
|
||||
# if(DEFINED ENV{WIN10SDK_PATH})
|
||||
# set(WIN10SDK_PATH "$ENV{WIN10SDK_PATH}")
|
||||
# endif()
|
||||
# endif()
|
||||
# if(DEFINED WIN10SDK_PATH)
|
||||
# #BBS: modify win10sdk_path
|
||||
# if (EXISTS "${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h")
|
||||
# set(WIN10SDK_INCLUDE_PATH "${WIN10SDK_PATH}")
|
||||
# else()
|
||||
# message("WIN10SDK_PATH is invalid: ${WIN10SDK_PATH}")
|
||||
# message("${WIN10SDK_PATH}/winrt/windows.graphics.printing3d.h was not found")
|
||||
# message("STL fixing by the Netfabb service will not be compiled")
|
||||
# unset(WIN10SDK_PATH)
|
||||
# endif()
|
||||
# else()
|
||||
# # Try to use the default Windows 10 SDK path.
|
||||
# if (DEFINED ENV{WindowsSdkDir} AND DEFINED ENV{WindowsSDKVersion})
|
||||
# set(WIN10SDK_INCLUDE_PATH "$ENV{WindowsSdkDir}/Include/$ENV{WindowsSDKVersion}")
|
||||
# else ()
|
||||
# set(WIN10SDK_INCLUDE_PATH "C:/Program Files (x86)/Windows Kits/10/Include/10.0.26100.0")
|
||||
# endif ()
|
||||
# if (NOT EXISTS "${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h")
|
||||
# message("${WIN10SDK_INCLUDE_PATH}/winrt/windows.graphics.printing3d.h was not found")
|
||||
# message("STL fixing by the Netfabb service will not be compiled")
|
||||
# unset(WIN10SDK_INCLUDE_PATH)
|
||||
# endif()
|
||||
# endif()
|
||||
# if(WIN10SDK_INCLUDE_PATH)
|
||||
# message("Building with Win10 Netfabb STL fixing service support")
|
||||
# add_definitions(-DHAS_WIN10SDK)
|
||||
# include_directories(SYSTEM "${WIN10SDK_INCLUDE_PATH}")
|
||||
# else()
|
||||
# message("Building without Win10 Netfabb STL fixing service support")
|
||||
# endif()
|
||||
# endif()
|
||||
|
||||
if (APPLE)
|
||||
message("OS X SDK Path: ${CMAKE_OSX_SYSROOT}")
|
||||
if (CMAKE_OSX_DEPLOYMENT_TARGET)
|
||||
|
||||
@@ -1,18 +1,10 @@
|
||||
# ccache does not parse the -clang: arguments CMake uses for clang-cl's gcc-style
|
||||
# depfile, so a cache hit writes the object and no depfile, and Ninja then records
|
||||
# no headers for that object. ccache reproduces /showIncludes output on a hit.
|
||||
#
|
||||
# Clang also records the modification time of every input in a precompiled header
|
||||
# and rejects the header once one differs. ccache caches the compile that creates
|
||||
# the header, so a tree that regenerates cmake_pch.cxx gets back a header stamped
|
||||
# with the old file's time, and every compile that uses it fails. The build system
|
||||
# already rebuilds the header when an input changes. This covers the dependencies,
|
||||
# such as wxWidgets; PrecompiledHeader.cmake does the same for OrcaSlicer's targets.
|
||||
foreach (_lang C CXX)
|
||||
if (CMAKE_${_lang}_COMPILER_ID STREQUAL "Clang" AND
|
||||
CMAKE_${_lang}_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
|
||||
set(CMAKE_DEPFILE_FLAGS_${_lang} "/showIncludes")
|
||||
set(CMAKE_${_lang}_DEPFILE_FORMAT msvc)
|
||||
list(APPEND CMAKE_${_lang}_COMPILE_OPTIONS_CREATE_PCH -Xclang -fno-pch-timestamp)
|
||||
endif ()
|
||||
endforeach ()
|
||||
|
||||
@@ -1,135 +0,0 @@
|
||||
# Mesh repair — High Level Design
|
||||
|
||||
## Purpose and scope
|
||||
|
||||
Mesh repair turns a broken triangle mesh into closed, outward oriented shells that bound a solid, so that the
|
||||
mesh slices predictably and the other mesh tools (booleans, cut, painting) get valid input. It runs on demand:
|
||||
the *Fix Model* command of the context menu of an object or part and of the warning icon in the object list, *Fix
|
||||
All* and *Fix All Plates* in the context menu of a plate, the prompt the Cut tool shows when a cut leaves open edges,
|
||||
the *Repair and import* choice of texture import, and the `--repair` option of the command line. It is built on CGAL
|
||||
and is the only repair the application has, on every platform.
|
||||
|
||||
`repair_mesh()` in `src/libslic3r/MeshRepair.cpp` does the work on one `TriangleMesh`, and `ModelVolume::repair()`
|
||||
applies it to a part: it replaces the mesh only when the repair changed it, and remaps or drops the painting of a
|
||||
replaced mesh. The GUI side, `fix_model_with_cgal_gui()` in `src/slic3r/Utils/FixModelByCgal.cpp`, runs it on a
|
||||
worker thread for each volume of an object, or for one volume, behind a progress dialog. `repair_mesh()` reports its
|
||||
progress between stages through a callback, which cancels the repair by throwing.
|
||||
|
||||
## What the repaired mesh is
|
||||
|
||||
The repair keeps what the slicer would print from the input. The slicer fills a layer where the winding number of
|
||||
the input surface is not zero (`MeshSlicingParams::SlicingMode::Regular` uses Clipper's nonzero fill rule), so:
|
||||
|
||||
- Shells crossing each other print as their union. The repair keeps them as separate shells, as the parts of an
|
||||
object are kept, and makes each of them an outward oriented solid.
|
||||
- A shell inside a solid that is oriented like it adds nothing, and the repair removes it.
|
||||
- A shell inside a solid that is oriented inward is a cavity, and stays one.
|
||||
- A whole mesh turned inside out prints as a solid, and the repair turns it outward.
|
||||
|
||||
On top of that, it closes holes and cracks, gives inconsistently oriented triangles the orientation of their
|
||||
neighbours, drops degenerate, duplicate and stray flat geometry, and removes small self-intersections inside a shell,
|
||||
such as slivers and folds. Where none of this applies, it reports the mesh as unmodified and the caller keeps the
|
||||
original mesh, its painting and its object id.
|
||||
|
||||
A volume is repaired in place and is never split into several parts: splitting by connectivity would turn a cavity
|
||||
into a separate solid part and fill it. Each solid of the result is a shell of its own, so *Split to parts* still
|
||||
separates them. Open pieces of the input whose borders meet exactly, which are pieces of one surface rather than
|
||||
solids, come out as the one shell they form.
|
||||
|
||||
## Pipeline
|
||||
|
||||
The input is treated as a triangle soup. Every stage after the first only runs on what the previous ones could
|
||||
not settle, so a valid mesh passes through quickly.
|
||||
|
||||
### Valid parts first
|
||||
|
||||
Parts of the input that are connected by vertex indices and are already closed, consistently oriented 2-manifolds
|
||||
skip the soup stages and go straight to the shell stages. Merging their points with coincident points of other
|
||||
parts would only make non-manifold junctions out of solids that touch, for example parts of an assembly exported
|
||||
together or voxels written as separate cubes.
|
||||
|
||||
### Soup clean-up
|
||||
|
||||
The rest of the soup has its coincident points merged. Triangles with repeated corners are dropped. Coincident
|
||||
triangles of opposite orientation are a wall between two solids touching face to face, so they cancel in pairs;
|
||||
of the remaining copies of a triangle one is kept. A connected region that would vanish entirely through
|
||||
cancelling is a two-sided export instead (every face written in both orientations), and keeps one copy of each
|
||||
triangle.
|
||||
|
||||
Open edges then get their vertices welded within a tolerance of 1e-4 of the bounding box diagonal, which closes the
|
||||
cracks some exporters leave between triangles that should share corners. A vertex is never welded further than a
|
||||
quarter of its shortest edge, so welding cannot collapse fine detail. A soup that stays mostly open after welding has
|
||||
cracks wider than that tolerance, and is welded again with ten and then a hundred times the tolerance.
|
||||
|
||||
### Work units
|
||||
|
||||
The soup is cut into units repaired independently and in parallel: its connected parts, except that open parts whose
|
||||
bounding boxes touch share a unit, so that cracks and T-junctions between separately exported patches still close.
|
||||
|
||||
### Building the mesh
|
||||
|
||||
A unit whose edges are each shared by at most two triangles, running in opposite directions, and whose vertices each
|
||||
have a single fan of triangles, becomes a `Surface_mesh` directly. Any other unit is oriented first. Triangles are
|
||||
flipped so that neighbours across an edge shared by two of them agree, each part keeping the orientation the
|
||||
majority of its area had, which keeps inward oriented cavities inward. Edges where that is impossible or that more
|
||||
than two triangles share are cut, and each fan of triangles around a vertex gets its own copy of the vertex. If that
|
||||
still leaves an invalid mesh, CGAL's `orient_polygon_soup()` orients the unit instead, and the parts it flipped
|
||||
against their majority are reversed back. The linear pass exists because `orient_polygon_soup()` is several times
|
||||
slower on large soups that need only a few fixes.
|
||||
|
||||
### Closing
|
||||
|
||||
Compatible borders are stitched, parts that can be stitched once reversed are merged, and borders still open are
|
||||
snapped onto each other within the weld tolerance, which closes T-junctions. Exactly degenerate faces are removed.
|
||||
|
||||
Holes are filled last. Planar border loops that face each other in one plane, one inside the other, bound a single
|
||||
region, such as a missing annulus at the end of a tube or a cap with features standing on it. Such a group is
|
||||
triangulated at once with a 2D constrained Delaunay triangulation that fills only the faces at odd nesting depth,
|
||||
so the openings inside the region stay open. The patch is used only if it closes every loop with the orientation
|
||||
of the triangles around it. Every other loop is filled on its own with `triangulate_hole()`, which uses a 2D
|
||||
constrained Delaunay triangulation when the loop is planar. Otherwise it searches the best triangulation among all
|
||||
triangles over the loop for loops of up to 100 edges, and among the triangles of a 3D Delaunay triangulation for
|
||||
longer ones, as the full search is cubic in the length of the loop. Beyond 200 edges the full search is not even
|
||||
used as a fallback, and a fan around the loop's centroid closes a loop nothing else could.
|
||||
|
||||
The closed unit is split into its shells. The largest stays in place and the others are copied out, as converting
|
||||
the whole mesh again costs seconds on large models.
|
||||
|
||||
### Shells
|
||||
|
||||
The shells of all units, together with the valid parts set aside at the start, are handled independently and in
|
||||
parallel. Shells enclosing no volume, which hole filling makes out of stray flat patches, are dropped.
|
||||
|
||||
Self-intersections inside a shell are removed locally with `experimental::remove_self_intersections()`, which
|
||||
remeshes the region around them. It is used only for local defects: a shell whose intersections involve more than
|
||||
5 % of its faces is left as it is, and a result that changes the enclosed volume by more than 0.1 % is undone. On
|
||||
heavily overlapping ornamental models the remeshing otherwise cuts parts down to slivers, while on genuine defects
|
||||
it changes the volume by thousandths of a percent. Overlaps left in place slice correctly. Remeshing can cut
|
||||
small pieces off a shell, so a shell it changed is split again and its pieces enclosing no volume are dropped.
|
||||
|
||||
Shells crossing others are found through their bounding boxes and an AABB tree per shell, and are made outward
|
||||
oriented solids. For every other shell the winding number just outside it is summed from the orientation of the
|
||||
shells containing it, tested from a point on its largest face. The shell bounds the solid only if the winding
|
||||
number is zero on exactly one of its sides; it is then oriented so that the solid is inside, or dropped otherwise.
|
||||
|
||||
Crossing shells are not united. Slicing unites them anyway, uniting them exactly costs tens of seconds on models
|
||||
made of many overlapping pieces, and it would fuse parts that *Split to parts* should keep apart.
|
||||
|
||||
## Robustness
|
||||
|
||||
The repair avoids `experimental::autorefine_and_remove_self_intersections()` and corefinement, which can crash on
|
||||
messy input, and uses only steps whose failures it can detect. A step that fails keeps its input. CGAL precondition
|
||||
failures surface as `repair_mesh()` returning false with the message as the error. The output is written in float,
|
||||
as every mesh in the application is.
|
||||
|
||||
The result does not depend on thread scheduling. `libslic3r_cgal` is built with `CGAL_LINKED_WITH_TBB`. Units and
|
||||
shells are processed in parallel, but each on its own data, and their results are gathered in a fixed order;
|
||||
sorts compare complete keys, and the detected self-intersections are put in order before they are used. Snapping
|
||||
stays sequential, as its parallel version gives different results from run to run. Holes are filled with the full
|
||||
search wherever it is affordable, because the search among Delaunay triangles can choose between equally good fills
|
||||
differently from run to run, so only non-planar holes of more than 100 edges may still vary. On some inputs
|
||||
`experimental::remove_self_intersections()` itself places a few vertices differently from run to run.
|
||||
|
||||
## Verification
|
||||
|
||||
`tests/libslic3r/test_mesh_repair.cpp` covers each kind of defect above on small meshes with known volumes.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "Bambulab",
|
||||
"url": "http://www.bambulab.com/Parameters/vendor/BBL.json",
|
||||
"version": "02.08.00.15",
|
||||
"version": "02.08.00.14",
|
||||
"force_update": "0",
|
||||
"description": "the initial version of BBL configurations",
|
||||
"machine_model_list": [
|
||||
|
||||
+1
-1
File diff suppressed because one or more lines are too long
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "Qidi",
|
||||
"version": "02.04.00.17",
|
||||
"version": "02.04.00.16",
|
||||
"force_update": "0",
|
||||
"description": "Qidi configurations",
|
||||
"machine_model_list": [
|
||||
|
||||
@@ -83,7 +83,7 @@
|
||||
"extruder_clearance_height_to_lid": "120",
|
||||
"layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nLOG_Z\nG92 E0\n",
|
||||
"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
|
||||
"machine_start_gcode": "PRINT_START BED=[bed_temperature_initial_layer_single] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[bed_temperature_initial_layer_single]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
|
||||
"machine_start_gcode": "PRINT_START BED=[hot_plate_temp_initial_layer] HOTEND=[nozzle_temperature_initial_layer] CHAMBER=[chamber_temperature]\nM83\nM140 S[hot_plate_temp_initial_layer]\nM104 S[nozzle_temperature_initial_layer]\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1] - 5, first_layer_print_min[1] + 80) - 85), 0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 3} Z0\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85), 0) + 6}\nG1 Z1 F600\n",
|
||||
"thumbnails_format": "PNG",
|
||||
"default_filament_profile": [
|
||||
"Generic PLA @Qidi Q1 Pro 0.4 nozzle"
|
||||
|
||||
@@ -100,7 +100,7 @@
|
||||
"default_filament_profile": [
|
||||
"Generic PLA @Qidi"
|
||||
],
|
||||
"machine_start_gcode": "G28\nM140 S[bed_temperature_initial_layer_single]\nM190 S[bed_temperature_initial_layer_single]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
|
||||
"machine_start_gcode": "G28\nM140 S[hot_plate_temp_initial_layer]\nM190 S[hot_plate_temp_initial_layer]\nM109 S[nozzle_temperature_initial_layer]\nG92 E-19\nG0 Y5 Z0.3 F3600\nG1 X5 E0 F2400\n",
|
||||
"machine_end_gcode": "M104 S0\nM140 S0\n;Retract the filament\nG92 E0\nG1 E-3 F300\nG28\nM84\n",
|
||||
"scan_first_layer": "0"
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@
|
||||
"210x210/COLPIC",
|
||||
"110x110/PNG"
|
||||
],
|
||||
"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[bed_temperature_initial_layer_single]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
|
||||
"machine_start_gcode": "PRINT_START\nG28\nM141 S0\nG0 Z50 F600\nM190 S[hot_plate_temp_initial_layer]\nG28 Z\nG29; mesh bed leveling ,comment this code to close it\nG0 X0 Y0 Z50 F6000\nM141 S{overall_chamber_temperature}\nM109 S[nozzle_temperature_initial_layer]\nM106 P3 S255\nM83\nG4 P3000\nG0 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0)} Z5 F6000\nG0 Z[initial_layer_print_height] F600\nG1 E3 F1800\nG1 X{(min(print_bed_max[0], first_layer_print_min[0] + 80))} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0)} E{85 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 85} E{83 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 2} E{2 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 Y{max((min(print_bed_max[1], first_layer_print_min[1] + 80) - 85),0) + 3} E{82 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 X{max((min(print_bed_max[0], first_layer_print_min[0] + 80) - 85),0) + 12} E{-10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\nG1 E{10 * 0.5 * initial_layer_print_height * nozzle_diameter[0]} F3000\n",
|
||||
"machine_end_gcode": "M141 S0\nM104 S0\nM140 S0\nG1 E-3 F1800\nG0 Z{min(max_print_height, max_layer_z + 3)} F600\nG0 X0 Y0 F12000\n{if max_layer_z < max_print_height / 2}G1 Z{max_print_height / 2 + 10} F600{else}G1 Z{min(max_print_height, max_layer_z + 3)}{endif}",
|
||||
"scan_first_layer": "0"
|
||||
}
|
||||
|
||||
+17
-43
@@ -1,27 +1,21 @@
|
||||
#!/usr/bin/env bash
|
||||
# Lets a pull request's macOS deps build, or its clang-tidy job, wait for a
|
||||
# build that saves the deps cache it needs, from a Linux job. `check` runs after
|
||||
# a cache miss and names a queued or running push build of the base branch with
|
||||
# the same deps/ and .github/ to wait for, unless the pull request changes either.
|
||||
# `own` names the pull request's own build instead, for clang-tidy when the pull
|
||||
# request changes deps/. `wait` waits until that build saves KEY under CACHE_REF,
|
||||
# or its deps job fails. actions/cache then confirms the entry can be restored.
|
||||
# Lets a pull request's macOS deps build wait for a push build of the base
|
||||
# branch that builds the same deps, from a Linux job. `check` runs after a cache
|
||||
# miss and names a queued or running base build with the same deps/ and .github/
|
||||
# to wait for, unless the pull request changes either. `wait` waits until that
|
||||
# build saves KEY. actions/cache then confirms the entry can be restored.
|
||||
#
|
||||
# Environment: GH_TOKEN, REPO, WORKFLOW_REF (or WORKFLOW, the build workflow's
|
||||
# file name) and BASE_REF, plus HEAD_SHA for `own`, and KEY_INPUTS, WAIT_FOR,
|
||||
# WAIT_SINCE, WAIT_MINUTES, KEY, CACHE_REF (default the base branch) and ARCH
|
||||
# (or JOB, the matrix job's name) for `wait`.
|
||||
# Environment: GH_TOKEN, REPO, WORKFLOW_REF and BASE_REF, plus KEY_INPUTS,
|
||||
# WAIT_FOR, WAIT_SINCE, WAIT_MINUTES, KEY and ARCH for `wait`.
|
||||
# Writes key-inputs, wait-for and wait-since to $GITHUB_OUTPUT.
|
||||
set -uo pipefail
|
||||
|
||||
workflow=${WORKFLOW_REF:-}
|
||||
workflow=${workflow%%@*}
|
||||
workflow=${WORKFLOW:-${workflow##*/}}
|
||||
workflow=${WORKFLOW_REF%%@*}
|
||||
workflow=${workflow##*/}
|
||||
|
||||
# Must match the job names in build_all.yml, build_check_cache.yml and build_deps.yml.
|
||||
job=${JOB:-build_macos_arch (${ARCH:-})}
|
||||
check_job_name="$job / Check Cache"
|
||||
deps_job_name="$job / Build Deps / Build Deps"
|
||||
check_job_name="build_macos_arch (${ARCH:-}) / Check Cache"
|
||||
deps_job_name="build_macos_arch (${ARCH:-}) / Build Deps / Build Deps"
|
||||
|
||||
out() { echo "$1" >> "${GITHUB_OUTPUT:-/dev/stdout}"; }
|
||||
|
||||
@@ -69,27 +63,8 @@ check() {
|
||||
fi
|
||||
}
|
||||
|
||||
own() {
|
||||
out "key-inputs=$(local_key_inputs HEAD)"
|
||||
local id
|
||||
# The build can be created a moment after this job.
|
||||
for _ in 1 2 3 4 5; do
|
||||
id=$(gh api -X GET "repos/$REPO/actions/workflows/$workflow/runs" \
|
||||
-f head_sha="$HEAD_SHA" -f event=pull_request -f per_page=1 --jq '.workflow_runs[0].id // empty' < /dev/null)
|
||||
[ -n "$id" ] && break
|
||||
sleep 30
|
||||
done
|
||||
if [ -n "$id" ]; then
|
||||
echo "Waiting for the deps cache of build $id of this pull request."
|
||||
out "wait-for=$id"
|
||||
out "wait-since=$(date +%s)"
|
||||
else
|
||||
echo "No build of this pull request is building its deps."
|
||||
fi
|
||||
}
|
||||
|
||||
key_saved() {
|
||||
gh cache list -R "$REPO" --ref "${CACHE_REF:-refs/heads/$BASE_REF}" --key "$KEY" --json key < /dev/null \
|
||||
gh cache list -R "$REPO" --ref "refs/heads/$BASE_REF" --key "$KEY" --json key < /dev/null \
|
||||
| jq -e --arg key "$KEY" 'any(.[]; .key == $key)' > /dev/null
|
||||
}
|
||||
|
||||
@@ -112,11 +87,11 @@ wait_for() {
|
||||
key_saved && { echo "Found $KEY."; return; }
|
||||
sleep 20
|
||||
done
|
||||
echo "Build $id finished its deps without saving $KEY."
|
||||
echo "Build $id of $BASE_REF finished its deps without saving $KEY."
|
||||
return ;;
|
||||
"completed cancelled") ;;
|
||||
completed*)
|
||||
echo "The deps job of build $id did not succeed."
|
||||
echo "The deps job of build $id of $BASE_REF did not succeed."
|
||||
return ;;
|
||||
# The deps job exists only once the build's cache check has succeeded.
|
||||
"")
|
||||
@@ -125,7 +100,7 @@ wait_for() {
|
||||
completed*)
|
||||
check=$(jq -r --arg name "$check_job_name" 'first(.jobs[] | select(.name == $name) | .conclusion) // ""' <<< "$jobs")
|
||||
if [ -z "$warned" ] && { [ -z "$check" ] || [ "$check" = success ]; }; then
|
||||
echo "::warning title=Deps wait::Build $id has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
|
||||
echo "::warning title=Deps wait::Build $id of $BASE_REF has no job named \"$deps_job_name\". If the build jobs were renamed, update scripts/ci_deps_cache.sh. This does not affect this pull request."
|
||||
warned=1
|
||||
fi ;;
|
||||
*)
|
||||
@@ -143,12 +118,11 @@ wait_for() {
|
||||
seen="$seen $id"
|
||||
echo "Following build $id of $BASE_REF."
|
||||
done
|
||||
echo "No build saved $KEY."
|
||||
echo "No build of $BASE_REF saved $KEY."
|
||||
}
|
||||
|
||||
case "${1:-}" in
|
||||
check) check ;;
|
||||
own) own ;;
|
||||
wait) wait_for ;;
|
||||
*) echo "usage: $0 check|own|wait" >&2; exit 2 ;;
|
||||
*) echo "usage: $0 check|wait" >&2; exit 2 ;;
|
||||
esac
|
||||
|
||||
+6
-28
@@ -99,7 +99,6 @@
|
||||
#include "libslic3r/Preset.hpp"
|
||||
#include "libslic3r/Geometry.hpp"
|
||||
#include "libslic3r/GCode.hpp"
|
||||
#include "libslic3r/MeshRepair.hpp"
|
||||
#include "libslic3r/Model.hpp"
|
||||
#include "libslic3r/ModelArrange.hpp"
|
||||
#include "libslic3r/Platform.hpp"
|
||||
@@ -207,7 +206,7 @@ std::map<int, std::string> cli_errors = {
|
||||
{CLI_OBJECT_ORIENT_FAILED, "An error occurred when auto-orienting object(s)."},
|
||||
{CLI_MODIFIED_PARAMS_TO_PRINTER, "Found modified parameter in printer preset in the 3mf file, which should not be changed."},
|
||||
{CLI_FILE_VERSION_NOT_SUPPORTED, "Unsupported 3MF version. Please make sure the 3MF file was created with the official version of Bambu Studio, not a beta version."},
|
||||
{CLI_NO_SUITABLE_OBJECTS, "The plate has nothing to slice: it is empty, or no object on it is both printable and fully inside the print volume."},
|
||||
{CLI_NO_SUITABLE_OBJECTS, "One of the plate is empty or has no object fully inside it. Please check that the 3mf contains no empty plate in Orca Slicer before uploading."},
|
||||
{CLI_VALIDATE_ERROR, "There are some incorrect slicing parameters in the 3mf. Please verify the slicing of all plates in Orca Slicer before uploading."},
|
||||
{CLI_OBJECTS_PARTLY_INSIDE, "Some objects are located over the boundary of the heated bed."},
|
||||
{CLI_EXPORT_CACHE_DIRECTORY_CREATE_FAILED, "Failed creating directory when exporting cache data."},
|
||||
@@ -1464,7 +1463,7 @@ int CLI::run(int argc, char **argv)
|
||||
//int arrange_option;
|
||||
int plate_to_slice = 0, filament_count = 0, duplicate_count = 0, real_duplicate_count = 0, current_extruder_count = 1, new_extruder_count = 1, current_printer_variant_count = 1, current_print_variant_count = 1, new_printer_variant_count = 1;
|
||||
bool first_file = true, is_bbl_3mf = false, need_arrange = true, has_thumbnails = false, up_config_to_date = false, normative_check = true, duplicate_single_object = false, use_first_fila_as_default = false, minimum_save = false, enable_timelapse = false;
|
||||
bool allow_rotations = false, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
|
||||
bool allow_rotations = true, skip_modified_gcodes = false, avoid_extrusion_cali_region = false, skip_useless_pick = false, allow_newer_file = false, current_is_multi_extruder = false, new_is_multi_extruder = false, allow_mix_temp = false, enable_wrapping_detect = false;
|
||||
Semver file_version;
|
||||
std::map<size_t, bool> orients_requirement;
|
||||
std::vector<Preset*> project_presets;
|
||||
@@ -5131,19 +5130,9 @@ int CLI::run(int argc, char **argv)
|
||||
}
|
||||
}
|
||||
} else if (opt_key == "repair") {
|
||||
if (m_config.opt_bool(opt_key))
|
||||
for (Model &model : m_models)
|
||||
for (ModelObject *object : model.objects) {
|
||||
for (ModelVolume *volume : object->volumes) {
|
||||
MeshRepairStats stats;
|
||||
std::string error;
|
||||
if (!volume->repair(true, &stats, &error))
|
||||
BOOST_LOG_TRIVIAL(warning) << "repair of " << object->name << " / " << volume->name << " failed: " << error;
|
||||
else if (stats.modified)
|
||||
BOOST_LOG_TRIVIAL(info) << "repaired " << object->name << " / " << volume->name;
|
||||
}
|
||||
object->invalidate_bounding_box();
|
||||
}
|
||||
// Models are repaired by default.
|
||||
//for (auto &model : m_models)
|
||||
// model.repair();
|
||||
} else {
|
||||
boost::nowide::cerr << "error: option not implemented yet: " << opt_key << std::endl;
|
||||
record_exit_reson(outfile_dir, CLI_UNSUPPORTED_OPERATION, 0, cli_errors[CLI_UNSUPPORTED_OPERATION], sliced_info);
|
||||
@@ -5153,7 +5142,6 @@ int CLI::run(int argc, char **argv)
|
||||
|
||||
BOOST_LOG_TRIVIAL(info) << "finished model pre-process commands\n";
|
||||
bool oriented_or_arranged = false;
|
||||
bool arranged_without_rotations = false;
|
||||
//BBS: add orient and arrange logic here
|
||||
for (auto& model : m_models)
|
||||
{
|
||||
@@ -5421,7 +5409,6 @@ int CLI::run(int argc, char **argv)
|
||||
BOOST_LOG_TRIVIAL(info) << boost::format("start plate %1%'s arranging...") % (i + 1);
|
||||
arrangement::arrange(selected, unselected, beds, arrange_cfg);
|
||||
//arrangement::arrange(unprintable, {}, beds, arrange_cfg);
|
||||
arranged_without_rotations |= !arrange_cfg.allow_rotations;
|
||||
BOOST_LOG_TRIVIAL(info) << boost::format("finished plate %1%'s arranging") % (i + 1);
|
||||
|
||||
//step-4: postprocess the bed index and result
|
||||
@@ -5894,7 +5881,6 @@ int CLI::run(int argc, char **argv)
|
||||
BOOST_LOG_TRIVIAL(info) << boost::format("start %1% th arranging...")%arrange_count;
|
||||
arrangement::arrange(selected, unselected, beds, arrange_cfg);
|
||||
arrangement::arrange(unprintable, {}, beds, arrange_cfg);
|
||||
arranged_without_rotations |= !arrange_cfg.allow_rotations;
|
||||
BOOST_LOG_TRIVIAL(info) << boost::format("finished %1% th arranging...")%arrange_count;
|
||||
|
||||
//Step-4:postprocess by partplate list&&apply the result
|
||||
@@ -6439,15 +6425,7 @@ int CLI::run(int argc, char **argv)
|
||||
|
||||
if (count == 0) {
|
||||
BOOST_LOG_TRIVIAL(error) << "plate "<< index+1<< ": Nothing to be sliced, Either the print is empty or no object is fully inside the print volume before apply." << std::endl;
|
||||
std::string no_objects_reason = cli_errors[CLI_NO_SUITABLE_OBJECTS];
|
||||
if (arranged_without_rotations) {
|
||||
//ORCA: result.json is only written on Linux, so also print the reason to stderr.
|
||||
no_objects_reason = "No object is fully inside the print volume. Arrange ran without rotations."
|
||||
" If an object only fits the bed when rotated, pass --allow-rotations."
|
||||
" Otherwise the plate is empty or an object is larger than the printable area or height.";
|
||||
boost::nowide::cerr << "plate " << index+1 << ": " << no_objects_reason << std::endl;
|
||||
}
|
||||
record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, no_objects_reason, sliced_info);
|
||||
record_exit_reson(outfile_dir, CLI_NO_SUITABLE_OBJECTS, index+1, cli_errors[CLI_NO_SUITABLE_OBJECTS], sliced_info);
|
||||
flush_and_exit(CLI_NO_SUITABLE_OBJECTS);
|
||||
}
|
||||
else if ((plate_to_slice != 0) || pre_check) {
|
||||
|
||||
@@ -625,7 +625,6 @@ add_library(libslic3r_cgal STATIC
|
||||
CutSurface.hpp CutSurface.cpp
|
||||
IntersectionPoints.hpp IntersectionPoints.cpp
|
||||
MeshBoolean.hpp MeshBoolean.cpp
|
||||
MeshRepair.hpp MeshRepair.cpp
|
||||
TryCatchSignal.hpp TryCatchSignal.cpp
|
||||
Triangulation.hpp Triangulation.cpp
|
||||
)
|
||||
@@ -653,9 +652,7 @@ if (IS_CLANG_CL)
|
||||
target_compile_options(libslic3r_cgal PRIVATE -Wno-overriding-option)
|
||||
endif ()
|
||||
|
||||
# Lets CGAL algorithms given CGAL::Parallel_if_available_tag run on TBB.
|
||||
target_compile_definitions(libslic3r_cgal PRIVATE CGAL_LINKED_WITH_TBB)
|
||||
target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs TBB::tbb)
|
||||
target_link_libraries(libslic3r_cgal PRIVATE ${_cgal_tgt} admesh libigl mcut boost_libs)
|
||||
|
||||
if (MSVC AND "${CMAKE_SIZEOF_VOID_P}" STREQUAL "4") # 32 bit MSVC workaround
|
||||
target_compile_definitions(libslic3r_cgal PRIVATE CGAL_DO_NOT_USE_MPZF)
|
||||
|
||||
@@ -236,29 +236,19 @@ static void getNamedSolids(const TopLoc_Location& location,
|
||||
int i = 0;
|
||||
switch (shape_type) {
|
||||
case TopAbs_COMPOUND:
|
||||
if (!isSplitCompound) {
|
||||
namedSolids.emplace_back(TopoDS::Compound(transform.Shape()), fullName);
|
||||
break;
|
||||
}
|
||||
case TopAbs_COMPSOLID:
|
||||
if (!isSplitCompound) {
|
||||
namedSolids.emplace_back(transform.Shape(), fullName);
|
||||
namedSolids.emplace_back(TopoDS::CompSolid(transform.Shape()), fullName);
|
||||
} else {
|
||||
for (explorer.Init(transform.Shape(), TopAbs_SOLID); explorer.More(); explorer.Next()) {
|
||||
i++;
|
||||
const TopoDS_Shape& currentShape = explorer.Current();
|
||||
namedSolids.emplace_back(TopoDS::Solid(currentShape), fullName + "-SOLID-" + std::to_string(i));
|
||||
}
|
||||
// Surface models have no solids: each shell outside a solid is a part, and loose faces stay together.
|
||||
i = 0;
|
||||
for (explorer.Init(transform.Shape(), TopAbs_SHELL, TopAbs_SOLID); explorer.More(); explorer.Next())
|
||||
namedSolids.emplace_back(explorer.Current(), fullName + "-SHELL-" + std::to_string(++i));
|
||||
TopoDS_Compound loose_faces;
|
||||
TopoDS_Builder builder;
|
||||
builder.MakeCompound(loose_faces);
|
||||
bool has_loose_faces = false;
|
||||
for (explorer.Init(transform.Shape(), TopAbs_FACE, TopAbs_SHELL); explorer.More(); explorer.Next()) {
|
||||
builder.Add(loose_faces, explorer.Current());
|
||||
has_loose_faces = true;
|
||||
}
|
||||
if (has_loose_faces)
|
||||
namedSolids.emplace_back(loose_faces, fullName);
|
||||
}
|
||||
break;
|
||||
case TopAbs_SOLID:
|
||||
|
||||
@@ -64,6 +64,7 @@
|
||||
#include <ostream>
|
||||
#include <sstream>
|
||||
#include <set>
|
||||
#include <iterator>
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
#include <map>
|
||||
@@ -855,14 +856,30 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
std::vector<std::string> custom_seam;
|
||||
std::vector<std::string> mmu_segmentation;
|
||||
std::vector<std::string> fuzzy_skin;
|
||||
// One per texture displacement layer slot, indexed like `triangles` but stored only as far as the
|
||||
// slot's last painted triangle: empty when the slot has no paint, which is nearly every file.
|
||||
// One per texture displacement layer slot, indexed by triangle like the masks above, but
|
||||
// empty for a slot nothing paints and no longer than its last painted triangle.
|
||||
// See push_texture_displacement().
|
||||
std::vector<std::string> texture_displacement[TEXTURE_DISPLACEMENT_MAX_LAYERS];
|
||||
// BBS
|
||||
std::vector<std::string> face_properties;
|
||||
|
||||
bool empty() { return vertices.empty() || triangles.empty(); }
|
||||
|
||||
// Records the paint mask of the triangle just appended, for one layer slot. A slot no
|
||||
// triangle names keeps its vector empty instead of holding one empty string per triangle:
|
||||
// eight slots over a million triangles would otherwise cost hundreds of megabytes, for
|
||||
// every project, whether or not it uses the feature. The vector is padded up to the
|
||||
// triangles seen so far the first time a value turns up, so it stays indexed by triangle,
|
||||
// and both readers stop at its size, so trailing triangles without a value need nothing.
|
||||
void push_texture_displacement(int slot, std::string &&mask_string) {
|
||||
std::vector<std::string> &mask = texture_displacement[slot];
|
||||
if (mask_string.empty() && mask.empty())
|
||||
return;
|
||||
assert(!triangles.empty());
|
||||
mask.resize(triangles.size() - 1);
|
||||
mask.push_back(std::move(mask_string));
|
||||
}
|
||||
|
||||
// backup & restore
|
||||
void swap(Geometry& o) {
|
||||
std::swap(vertices, o.vertices);
|
||||
@@ -3355,11 +3372,13 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
add_error("Malformed texture displacement data: " + json_path);
|
||||
return;
|
||||
}
|
||||
// The archive is the only source of a layer's pixels. `path` comes from the project file, so loading
|
||||
// the project must never read the file it names: that would let whoever made the project pick any
|
||||
// local (or, on Windows, network) file to read, and the next save would embed it in the archive.
|
||||
// `path` stays a label of where the texture came from; a layer the archive carries no image for
|
||||
// loads without one, its settings intact, until the user picks a texture again.
|
||||
// The pixels come from the archive and nowhere else. A layer the archive carries no image for -
|
||||
// saved while its texture had not been loaded, or written by a build that stored only the path -
|
||||
// keeps its settings without an image, which the user recovers by picking the texture again.
|
||||
// `layer.path` is left alone on purpose: it names a file on the machine the project was made on,
|
||||
// so reading it here would let any project choose a local file to open - a UNC path among them -
|
||||
// and have the next save copy it into the archive. The EmbossShape SVGs are read from the archive
|
||||
// only, for the same reason.
|
||||
for (TextureDisplacementLayer &layer : layers) {
|
||||
if (layer.path_in_3mf.empty())
|
||||
continue;
|
||||
@@ -3368,7 +3387,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
add_error("Missing texture displacement image: " + layer.path_in_3mf);
|
||||
continue;
|
||||
}
|
||||
layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(), image->second.end());
|
||||
layer.image_data = std::make_shared<std::vector<unsigned char>>(image->second.begin(),
|
||||
image->second.end());
|
||||
}
|
||||
volume.texture_displacement_layers = std::move(layers);
|
||||
volume.texture_displacement_options = options;
|
||||
@@ -4031,11 +4051,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
m_curr_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
|
||||
m_curr_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
|
||||
if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
|
||||
std::vector<std::string> &mask = m_curr_object->geometry.texture_displacement[slot];
|
||||
mask.resize(m_curr_object->geometry.triangles.size());
|
||||
mask.back() = paint;
|
||||
}
|
||||
m_curr_object->geometry.push_texture_displacement(
|
||||
slot, bbs_get_attribute_value_string(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot]));
|
||||
// BBS
|
||||
m_curr_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
|
||||
}
|
||||
@@ -5390,7 +5407,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
|
||||
const std::vector<std::string> &mask = sub_object->geometry.texture_displacement[slot];
|
||||
if (mask.empty())
|
||||
continue; // no triangle painted on this slot
|
||||
continue; // written by a build without the feature
|
||||
FacetsAnnotation &facets = volume->texture_displacement_facet(slot);
|
||||
facets.reserve(triangles_count);
|
||||
for (size_t i = 0; i < triangles_count && i < mask.size(); ++i)
|
||||
@@ -5906,11 +5923,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
current_object->geometry.mmu_segmentation.push_back(bbs_get_attribute_value_string(attributes, num_attributes, MMU_SEGMENTATION_ATTR));
|
||||
current_object->geometry.fuzzy_skin.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_FUZZY_SKIN_ATTR));
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
|
||||
if (const char *paint = bbs_get_attribute_value_charptr(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot])) {
|
||||
std::vector<std::string> &mask = current_object->geometry.texture_displacement[slot];
|
||||
mask.resize(current_object->geometry.triangles.size());
|
||||
mask.back() = paint;
|
||||
}
|
||||
current_object->geometry.push_texture_displacement(
|
||||
slot, bbs_get_attribute_value_string(attributes, num_attributes, TEXTURE_DISPLACEMENT_ATTRS[slot]));
|
||||
// BBS
|
||||
current_object->geometry.face_properties.push_back(bbs_get_attribute_value_string(attributes, num_attributes, FACE_PROPERTY_ATTR));
|
||||
}
|
||||
@@ -7341,14 +7355,10 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
|
||||
if (iter != m_shared_meshes.end())
|
||||
{
|
||||
const ModelVolume* shared_volume = iter->second.second;
|
||||
bool same_texture_paint = true;
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS) && same_texture_paint; ++slot)
|
||||
same_texture_paint = shared_volume->texture_displacement_facet(slot).equals(volume->texture_displacement_facet(slot));
|
||||
if ((shared_volume->supported_facets.equals(volume->supported_facets))
|
||||
&& (shared_volume->seam_facets.equals(volume->seam_facets))
|
||||
&& (shared_volume->mmu_segmentation_facets.equals(volume->mmu_segmentation_facets))
|
||||
&& (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets))
|
||||
&& same_texture_paint)
|
||||
&& (shared_volume->fuzzy_skin_facets.equals(volume->fuzzy_skin_facets)))
|
||||
{
|
||||
auto data = iter->second.first;
|
||||
const_cast<_BBS_3MF_Exporter *>(this)->m_volume_paths.insert({volume, {data->sub_path, data->volumes_objectID.find(iter->second.second)->second}});
|
||||
|
||||
+2
-15
@@ -1033,15 +1033,6 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
|
||||
return buf;
|
||||
}
|
||||
|
||||
// FanMover consumes these markers (and drops them) to avoid splitting a G1 inside custom gcode.
|
||||
// Only written when FanMover runs, the same gate as its construction in GCode::process_layers.
|
||||
static std::string wrap_custom_gcode_for_fan_mover(const FullPrintConfig &config, const std::string &gcode)
|
||||
{
|
||||
if (config.fan_speedup_time.value == 0 && config.fan_kickstart.value <= 0)
|
||||
return gcode;
|
||||
return ";_FAN_MOVER_SKIP_START\n" + gcode + ";_FAN_MOVER_SKIP_END\n";
|
||||
}
|
||||
|
||||
std::string WipeTowerIntegration::append_tcr(GCode& gcodegen, const WipeTower::ToolChangeResult& tcr, int new_filament_id, double z) const
|
||||
{
|
||||
if (new_filament_id != -1 && new_filament_id != tcr.new_tool)
|
||||
@@ -1393,9 +1384,6 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)
|
||||
toolchange_gcode_str = gcodegen.placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &config);
|
||||
|
||||
check_add_eol(toolchange_gcode_str);
|
||||
// Type1 wipe tower path (every BBL printer): bracket the same way set_extruder() does,
|
||||
// so FanMover doesn't split a G1 inside this custom gcode either.
|
||||
toolchange_gcode_str = wrap_custom_gcode_for_fan_mover(gcodegen.config(), toolchange_gcode_str);
|
||||
|
||||
//BBS
|
||||
{
|
||||
@@ -4262,7 +4250,7 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
|
||||
config.set_key_value("nozzle_diameter_at_nozzle_id", new ConfigOptionFloats(get_nozzle_diameters_by_nozzle_id(group_result.get())));
|
||||
config.set_key_value("nozzle_volume_types", new ConfigOptionStrings(get_nozzle_volume_types_by_nozzle_id(group_result.get())));
|
||||
config.set_key_value("layer_num", new ConfigOptionInt(m_layer_index));
|
||||
std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.get_at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
|
||||
std::string filament_start_gcode = this->placeholder_parser_process("filament_start_gcode", print.config().filament_start_gcode.values.at(initial_non_support_extruder_id), initial_non_support_extruder_id,&config);
|
||||
file.writeln(filament_start_gcode);
|
||||
// Mark the first filament used in print. Multi-nozzle printers (H2C) get ";VT%d H%d" where
|
||||
// H = dynamic ? nozzle_id : -1; existing single-nozzle printers keep the bare ";VT%d" so their
|
||||
@@ -10907,8 +10895,7 @@ std::string GCode::set_extruder(unsigned int new_filament_id, double print_z, bo
|
||||
|
||||
toolchange_gcode_parsed = placeholder_parser_process("change_filament_gcode", change_filament_gcode, new_filament_id, &dyn_config);
|
||||
check_add_eol(toolchange_gcode_parsed);
|
||||
// toolchange_gcode_parsed is still read below (get_last_z_from_gcode, custom_gcode_changes_tool).
|
||||
gcode += wrap_custom_gcode_for_fan_mover(m_config, toolchange_gcode_parsed);
|
||||
gcode += toolchange_gcode_parsed;
|
||||
|
||||
//BBS
|
||||
{
|
||||
|
||||
@@ -445,11 +445,6 @@ void FanMover::_process_gcode_line(GCodeReader& reader, const GCodeReader::GCode
|
||||
std::string extrusion_string = line.raw().substr(6, line.raw().size() - 6);
|
||||
current_role = ExtrusionEntity::string_to_role(extrusion_string);
|
||||
}
|
||||
if (line.raw().rfind(";_FAN_MOVER_SKIP_", 0) == 0) {
|
||||
// Internal markers: read here, then dropped from the output.
|
||||
m_is_custom_gcode = line.raw().rfind(";_FAN_MOVER_SKIP_START", 0) == 0;
|
||||
time = -1;
|
||||
}
|
||||
if (line.raw().size() > 16) {
|
||||
if (line.raw().rfind("; custom gcode", 0) != std::string::npos) {
|
||||
if (line.raw().rfind("; custom gcode end", 0) != std::string::npos)
|
||||
|
||||
@@ -2602,13 +2602,12 @@ void GCodeProcessorResult::reset() {
|
||||
//BBS: add mutex for protection of gcode result
|
||||
lock();
|
||||
|
||||
// moves and lines_ends grow with the print: free them, as no reset result reuses the capacity.
|
||||
clear_and_shrink(moves);
|
||||
moves.clear();
|
||||
plate_mass = {};
|
||||
object_masses.clear();
|
||||
body_masses.clear();
|
||||
support_masses.clear();
|
||||
clear_and_shrink(lines_ends);
|
||||
lines_ends.clear();
|
||||
printable_area = Pointfs();
|
||||
//BBS: add bed exclude area
|
||||
bed_exclude_area = Pointfs();
|
||||
@@ -3599,10 +3598,6 @@ void GCodeProcessor::apply_config(const DynamicPrintConfig& config)
|
||||
if (has_scarf_joint_seam != nullptr)
|
||||
m_detect_layer_based_on_tag = m_detect_layer_based_on_tag || has_scarf_joint_seam->value;
|
||||
|
||||
const ConfigOptionBool* manual_filament_change = config.option<ConfigOptionBool>("manual_filament_change");
|
||||
if (manual_filament_change != nullptr)
|
||||
m_manual_filament_change = manual_filament_change->value;
|
||||
|
||||
const ConfigOptionEnumGeneric *bed_type = config.option<ConfigOptionEnumGeneric>("curr_bed_type");
|
||||
if (bed_type != nullptr)
|
||||
m_result.bed_type = (BedType)bed_type->value;
|
||||
|
||||
@@ -1228,7 +1228,7 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
|
||||
// m_result.nozzle_group_result, which is handed over only after the stream for the
|
||||
// pre-heat injector's second pass and gates the richer change-time model.
|
||||
std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> m_nozzle_group_result;
|
||||
bool m_manual_filament_change{ false };
|
||||
bool m_manual_filament_change;
|
||||
|
||||
//BBS: x, y offset for gcode generated
|
||||
double m_x_offset{ 0 };
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
#include "JumpPointSearch.hpp"
|
||||
#include "BoundingBox.hpp"
|
||||
#include "ExPolygon.hpp"
|
||||
#include "Point.hpp"
|
||||
#include "libslic3r/AStar.hpp"
|
||||
#include "libslic3r/KDTreeIndirect.hpp"
|
||||
#include "libslic3r/Polygon.hpp"
|
||||
#include "libslic3r/Polyline.hpp"
|
||||
#include "libslic3r/libslic3r.h"
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <iterator>
|
||||
#include <limits>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include <oneapi/tbb/scalable_allocator.h>
|
||||
|
||||
//#define DEBUG_FILES
|
||||
#ifdef DEBUG_FILES
|
||||
#include "libslic3r/SVG.hpp"
|
||||
#endif
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
// execute fn for each pixel on the line. If fn returns false, terminate the iteration
|
||||
template<typename PointFn> void dda(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
|
||||
{
|
||||
coord_t dx = abs(x1 - x0);
|
||||
coord_t dy = abs(y1 - y0);
|
||||
coord_t x = x0;
|
||||
coord_t y = y0;
|
||||
coord_t n = 1 + dx + dy;
|
||||
coord_t x_inc = (x1 > x0) ? 1 : -1;
|
||||
coord_t y_inc = (y1 > y0) ? 1 : -1;
|
||||
coord_t error = dx - dy;
|
||||
dx *= 2;
|
||||
dy *= 2;
|
||||
|
||||
for (; n > 0; --n) {
|
||||
if (!fn(x, y)) return;
|
||||
|
||||
if (error > 0) {
|
||||
x += x_inc;
|
||||
error -= dy;
|
||||
} else {
|
||||
y += y_inc;
|
||||
error += dx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// will draw the line twice, second time with and offset of 1 in the direction of normal
|
||||
// may call the fn on the same coordiantes multiple times!
|
||||
template<typename PointFn> void double_dda_with_offset(coord_t x0, coord_t y0, coord_t x1, coord_t y1, const PointFn &fn)
|
||||
{
|
||||
Vec2d normal = Point{y1 - y0, x1 - x0}.cast<double>().normalized();
|
||||
normal.x() = ceil(normal.x());
|
||||
normal.y() = ceil(normal.y());
|
||||
Point start_offset = Point(x0, y0) + (normal).cast<coord_t>();
|
||||
Point end_offset = Point(x1, y1) + (normal).cast<coord_t>();
|
||||
|
||||
dda(x0, y0, x1, y1, fn);
|
||||
dda(start_offset.x(), start_offset.y(), end_offset.x(), end_offset.y(), fn);
|
||||
}
|
||||
|
||||
template<typename CellPositionType, typename CellQueryFn> class JPSTracer
|
||||
{
|
||||
public:
|
||||
// Use incoming_dir [0,0] for starting points, so that all directions are checked from that point
|
||||
struct Node
|
||||
{
|
||||
CellPositionType position;
|
||||
CellPositionType incoming_dir;
|
||||
};
|
||||
|
||||
JPSTracer(CellPositionType target, CellQueryFn is_passable) : target(target), is_passable(is_passable) {}
|
||||
|
||||
private:
|
||||
CellPositionType target;
|
||||
CellQueryFn is_passable; // should return boolean whether the cell is passable or not
|
||||
|
||||
CellPositionType find_jump_point(CellPositionType start, CellPositionType forward_dir) const
|
||||
{
|
||||
CellPositionType next = start + forward_dir;
|
||||
while (next != target && is_passable(next) && !(is_jump_point(next, forward_dir))) { next = next + forward_dir; }
|
||||
|
||||
if (is_passable(next)) {
|
||||
return next;
|
||||
} else {
|
||||
return start;
|
||||
}
|
||||
}
|
||||
|
||||
bool is_jump_point(CellPositionType pos, CellPositionType forward_dir) const
|
||||
{
|
||||
if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
|
||||
// diagonal
|
||||
CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
|
||||
CellPositionType vertical_check_dir = CellPositionType{0, forward_dir.y()};
|
||||
|
||||
if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) { return true; }
|
||||
|
||||
if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) { return true; }
|
||||
|
||||
if (find_jump_point(pos, horizontal_check_dir) != pos) { return true; }
|
||||
|
||||
if (find_jump_point(pos, vertical_check_dir) != pos) { return true; }
|
||||
|
||||
return false;
|
||||
} else { // horizontal or vertical
|
||||
CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
|
||||
|
||||
if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { return true; }
|
||||
|
||||
if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { return true; }
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
template<class Fn> void foreach_reachable(const Node &from, Fn &&fn) const
|
||||
{
|
||||
const CellPositionType & pos = from.position;
|
||||
const CellPositionType & forward_dir = from.incoming_dir;
|
||||
std::vector<CellPositionType> dirs_to_check{};
|
||||
|
||||
if (abs(forward_dir.x()) + abs(forward_dir.y()) == 0) { // special case for starting point
|
||||
dirs_to_check = all_directions;
|
||||
} else if (abs(forward_dir.x()) + abs(forward_dir.y()) == 2) {
|
||||
// diagonal
|
||||
CellPositionType horizontal_check_dir = CellPositionType{forward_dir.x(), 0};
|
||||
CellPositionType vertical_check_dir = CellPositionType{0, forward_dir.y()};
|
||||
|
||||
if (!is_passable(pos - horizontal_check_dir) && is_passable(pos + forward_dir - 2 * horizontal_check_dir)) {
|
||||
dirs_to_check.push_back(forward_dir - 2 * horizontal_check_dir);
|
||||
}
|
||||
|
||||
if (!is_passable(pos - vertical_check_dir) && is_passable(pos + forward_dir - 2 * vertical_check_dir)) {
|
||||
dirs_to_check.push_back(forward_dir - 2 * vertical_check_dir);
|
||||
}
|
||||
|
||||
dirs_to_check.push_back(horizontal_check_dir);
|
||||
dirs_to_check.push_back(vertical_check_dir);
|
||||
dirs_to_check.push_back(forward_dir);
|
||||
|
||||
} else { // horizontal or vertical
|
||||
CellPositionType side_dir = CellPositionType(forward_dir.y(), forward_dir.x());
|
||||
|
||||
if (!is_passable(pos + side_dir) && is_passable(pos + forward_dir + side_dir)) { dirs_to_check.push_back(forward_dir + side_dir); }
|
||||
|
||||
if (!is_passable(pos - side_dir) && is_passable(pos + forward_dir - side_dir)) { dirs_to_check.push_back(forward_dir - side_dir); }
|
||||
dirs_to_check.push_back(forward_dir);
|
||||
}
|
||||
|
||||
for (const CellPositionType &dir : dirs_to_check) {
|
||||
CellPositionType jp = find_jump_point(pos, dir);
|
||||
if (jp != pos) fn(Node{jp, dir});
|
||||
}
|
||||
}
|
||||
|
||||
float distance(Node a, Node b) const { return (a.position - b.position).template cast<double>().norm(); }
|
||||
|
||||
float goal_heuristic(Node n) const { return n.position == target ? -1.f : (target - n.position).template cast<double>().norm(); }
|
||||
|
||||
size_t unique_id(Node n) const { return (static_cast<size_t>(uint16_t(n.position.x())) << 16) + static_cast<size_t>(uint16_t(n.position.y())); }
|
||||
|
||||
const std::vector<CellPositionType> all_directions{{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
|
||||
};
|
||||
|
||||
void JPSPathFinder::clear()
|
||||
{
|
||||
inpassable.clear();
|
||||
max_search_box.max = Pixel(std::numeric_limits<coord_t>::min(), std::numeric_limits<coord_t>::min());
|
||||
max_search_box.min = Pixel(std::numeric_limits<coord_t>::max(), std::numeric_limits<coord_t>::max());
|
||||
add_obstacles(bed_shape);
|
||||
}
|
||||
|
||||
void JPSPathFinder::add_obstacles(const Lines &obstacles)
|
||||
{
|
||||
auto store_obstacle = [&](coord_t x, coord_t y) {
|
||||
max_search_box.max.x() = std::max(max_search_box.max.x(), x);
|
||||
max_search_box.max.y() = std::max(max_search_box.max.y(), y);
|
||||
max_search_box.min.x() = std::min(max_search_box.min.x(), x);
|
||||
max_search_box.min.y() = std::min(max_search_box.min.y(), y);
|
||||
inpassable.insert(Pixel{x, y});
|
||||
return true;
|
||||
};
|
||||
|
||||
for (const Line &l : obstacles) {
|
||||
Pixel start = pixelize(l.a);
|
||||
Pixel end = pixelize(l.b);
|
||||
double_dda_with_offset(start.x(), start.y(), end.x(), end.y(), store_obstacle);
|
||||
}
|
||||
}
|
||||
|
||||
Polyline JPSPathFinder::find_path(const Point &p0, const Point &p1)
|
||||
{
|
||||
Pixel start = pixelize(p0);
|
||||
Pixel end = pixelize(p1);
|
||||
if (inpassable.empty() || (start - end).cast<float>().norm() < 3.0) { return Polyline{p0, p1}; }
|
||||
|
||||
if (inpassable.find(start) != inpassable.end()) {
|
||||
dda(start.x(), start.y(), end.x(), end.y(), [&](coord_t x, coord_t y) {
|
||||
if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
|
||||
start = Pixel(x, y);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
if (inpassable.find(end) != inpassable.end()) {
|
||||
dda(end.x(), end.y(), start.x(), start.y(), [&](coord_t x, coord_t y) {
|
||||
if (inpassable.find(Pixel(x, y)) == inpassable.end() || start == end) { // new start not found yet, and xy passable
|
||||
end = Pixel(x, y);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
BoundingBox search_box = max_search_box;
|
||||
search_box.max -= Pixel(1, 1);
|
||||
search_box.min += Pixel(1, 1);
|
||||
|
||||
BoundingBox bounding_square(Points{start, end});
|
||||
bounding_square.max += Pixel(5, 5);
|
||||
bounding_square.min -= Pixel(5, 5);
|
||||
coord_t bounding_square_size = 2 * std::max(bounding_square.size().x(), bounding_square.size().y());
|
||||
bounding_square.max.x() += (bounding_square_size - bounding_square.size().x()) / 2;
|
||||
bounding_square.min.x() -= (bounding_square_size - bounding_square.size().x()) / 2;
|
||||
bounding_square.max.y() += (bounding_square_size - bounding_square.size().y()) / 2;
|
||||
bounding_square.min.y() -= (bounding_square_size - bounding_square.size().y()) / 2;
|
||||
|
||||
// Intersection - limit the search box to a square area around the start and end, to fasten the path searching
|
||||
search_box.max = search_box.max.cwiseMin(bounding_square.max);
|
||||
search_box.min = search_box.min.cwiseMax(bounding_square.min);
|
||||
|
||||
auto cell_query = [&](Pixel pixel) { return search_box.contains(pixel) && (pixel == start || pixel == end || inpassable.find(pixel) == inpassable.end()); };
|
||||
|
||||
JPSTracer<Pixel, decltype(cell_query)> tracer(end, cell_query);
|
||||
using QNode = astar::QNode<JPSTracer<Pixel, decltype(cell_query)>>;
|
||||
|
||||
std::unordered_map<size_t, QNode> astar_cache{};
|
||||
std::vector<Pixel, PointsAllocator<Pixel>> out_path;
|
||||
std::vector<decltype(tracer)::Node> out_nodes;
|
||||
|
||||
if (!astar::search_route(tracer, {start, {0, 0}}, std::back_inserter(out_nodes), astar_cache)) {
|
||||
// path not found - just reconstruct the best path from astar cache.
|
||||
// Note that astar_cache is NOT empty - at least the starting point should always be there
|
||||
auto coordiante_func = [&astar_cache](size_t idx, size_t dim) { return float(astar_cache[idx].node.position[dim]); };
|
||||
std::vector<size_t> keys;
|
||||
keys.reserve(astar_cache.size());
|
||||
for (const auto &pair : astar_cache) { keys.push_back(pair.first); }
|
||||
KDTreeIndirect<2, float, decltype(coordiante_func)> kd_tree(coordiante_func, keys);
|
||||
size_t closest_qnode = find_closest_point(kd_tree, end.cast<float>());
|
||||
|
||||
out_path.push_back(end);
|
||||
while (closest_qnode != astar::Unassigned) {
|
||||
out_path.push_back(astar_cache[closest_qnode].node.position);
|
||||
closest_qnode = astar_cache[closest_qnode].parent;
|
||||
}
|
||||
} else {
|
||||
for (const auto &node : out_nodes) { out_path.push_back(node.position); }
|
||||
out_path.push_back(start);
|
||||
}
|
||||
|
||||
#ifdef DEBUG_FILES
|
||||
auto scaled_points = [](const Points &ps) {
|
||||
Points r;
|
||||
for (const Point &p : ps) { r.push_back(Point::new_scale(p.x(), p.y())); }
|
||||
return r;
|
||||
};
|
||||
auto scaled_point = [](const Point &p) { return Point::new_scale(p.x(), p.y()); };
|
||||
::Slic3r::SVG svg(debug_out_path(("path_jps" + std::to_string(print_z) + "_" + std::to_string(rand() % 1000)).c_str()).c_str(),
|
||||
BoundingBox(scaled_point(search_box.min), scaled_point(search_box.max)));
|
||||
for (const auto &p : inpassable) { svg.draw(scaled_point(p), "black", scale_(0.4)); }
|
||||
for (const auto &qn : astar_cache) { svg.draw(scaled_point(qn.second.node.position), "blue", scale_(0.3)); }
|
||||
svg.draw(Polyline(scaled_points(out_path)), "yellow", scale_(0.25));
|
||||
svg.draw(scaled_point(end), "purple", scale_(0.4));
|
||||
svg.draw(scaled_point(start), "green", scale_(0.4));
|
||||
#endif
|
||||
|
||||
std::vector<Pixel, PointsAllocator<Pixel>> tmp_path;
|
||||
tmp_path.reserve(out_path.size());
|
||||
// Some path found, reverse and remove points that do not change direction
|
||||
std::reverse(out_path.begin(), out_path.end());
|
||||
{
|
||||
tmp_path.push_back(out_path.front()); // first point
|
||||
for (size_t i = 1; i < out_path.size() - 1; i++) {
|
||||
if ((out_path[i] - out_path[i - 1]).cast<float>().normalized() != (out_path[i + 1] - out_path[i]).cast<float>().normalized()) { tmp_path.push_back(out_path[i]); }
|
||||
}
|
||||
tmp_path.push_back(out_path.back()); // last_point
|
||||
out_path = tmp_path;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_FILES
|
||||
svg.draw(Polyline(scaled_points(out_path)), "orange", scale_(0.20));
|
||||
#endif
|
||||
|
||||
tmp_path.clear();
|
||||
// remove redundant jump points - there are points that change direction but are not needed - this inefficiency arises from the
|
||||
// usage of grid search The removal alg tries to find the longest Px Px+k path without obstacles. If Px Px+k+1 is blocked, it will
|
||||
// insert the Px+k point to result and continue search from Px+k
|
||||
{
|
||||
tmp_path.push_back(out_path.front()); // first point
|
||||
size_t index_of_last_stored_point = 0;
|
||||
for (size_t i = 1; i < out_path.size(); i++) {
|
||||
if (i - index_of_last_stored_point < 2) continue;
|
||||
bool passable = true;
|
||||
auto store_obstacle = [&](coord_t x, coord_t y) {
|
||||
if (Pixel(x, y) != start && Pixel(x, y) != end && inpassable.find(Pixel(x, y)) != inpassable.end()) {
|
||||
passable = false;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
};
|
||||
dda(tmp_path.back().x(), tmp_path.back().y(), out_path[i].x(), out_path[i].y(), store_obstacle);
|
||||
if (!passable) {
|
||||
tmp_path.push_back(out_path[i - 1]);
|
||||
index_of_last_stored_point = i - 1;
|
||||
}
|
||||
}
|
||||
tmp_path.push_back(out_path.back()); // last_point
|
||||
out_path = tmp_path;
|
||||
}
|
||||
|
||||
#ifdef DEBUG_FILES
|
||||
svg.draw(Polyline(scaled_points(out_path)), "red", scale_(0.15));
|
||||
svg.Close();
|
||||
#endif
|
||||
|
||||
// before returing the path, transform it from pixels back to points.
|
||||
// Also replace the first and last pixel by input points so that result path patches input params exactly.
|
||||
for (Pixel &p : out_path) { p = unpixelize(p); }
|
||||
out_path.front() = p0;
|
||||
out_path.back() = p1;
|
||||
|
||||
return Polyline(out_path);
|
||||
}
|
||||
|
||||
} // namespace Slic3r
|
||||
@@ -0,0 +1,39 @@
|
||||
#pragma once
|
||||
#include "Line.hpp"
|
||||
#ifndef SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
|
||||
#define SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_
|
||||
|
||||
#include "BoundingBox.hpp"
|
||||
#include "Polygon.hpp"
|
||||
#include "libslic3r/Layer.hpp"
|
||||
#include "libslic3r/Point.hpp"
|
||||
#include "libslic3r/Polyline.hpp"
|
||||
#include "libslic3r/libslic3r.h"
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
class JPSPathFinder
|
||||
{
|
||||
using Pixel = Point;
|
||||
std::unordered_set<Pixel, PointHash> inpassable;
|
||||
coordf_t print_z;
|
||||
BoundingBox max_search_box;
|
||||
Lines bed_shape;
|
||||
|
||||
const coord_t resolution = scaled(1.5);
|
||||
Pixel pixelize(const Point &p) { return p / resolution; }
|
||||
Point unpixelize(const Pixel &p) { return p * resolution; }
|
||||
|
||||
public:
|
||||
JPSPathFinder() = default;
|
||||
void init_bed_shape(const Points &bed_shape) { this->bed_shape = (to_lines(Polygon{bed_shape})); };
|
||||
void clear();
|
||||
void add_obstacles(const Lines &obstacles);
|
||||
Polyline find_path(const Point &start, const Point &end);
|
||||
};
|
||||
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif /* SRC_LIBSLIC3R_JUMPPOINTSEARCH_HPP_ */
|
||||
@@ -29,6 +29,8 @@
|
||||
#include <CGAL/Polygon_mesh_processing/triangulate_hole.h>
|
||||
#include <CGAL/Polygon_mesh_processing/stitch_borders.h>
|
||||
#include <CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h>
|
||||
#include <CGAL/Polygon_mesh_processing/repair_degeneracies.h>
|
||||
#include <CGAL/Polygon_mesh_processing/manifoldness.h>
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
#include <algorithm>
|
||||
@@ -48,6 +50,7 @@
|
||||
#include <CGAL/Polygon_mesh_processing/orient_polygon_soup.h>
|
||||
#include <CGAL/Polygon_mesh_processing/repair.h>
|
||||
#include <CGAL/Polygon_mesh_processing/remesh.h>
|
||||
#include <CGAL/Polygon_mesh_processing/repair_polygon_soup.h>
|
||||
#include <CGAL/Polygon_mesh_processing/orientation.h>
|
||||
// BBS: for segment
|
||||
#include <CGAL/mesh_segmentation.h>
|
||||
@@ -655,6 +658,91 @@ bool empty(const CGALMesh &mesh)
|
||||
return mesh.m.is_empty();
|
||||
}
|
||||
|
||||
bool repair(TriangleMesh& mesh, RepairedMeshErrors* repaired_errors, std::string* error)
|
||||
{
|
||||
namespace PMP = CGAL::Polygon_mesh_processing;
|
||||
|
||||
if (mesh.empty())
|
||||
return true;
|
||||
|
||||
try {
|
||||
// 1) Convert to polygon soup
|
||||
std::vector<_EpicMesh::Point> points;
|
||||
std::vector<std::vector<std::size_t>> polygons;
|
||||
|
||||
points.reserve(mesh.its.vertices.size());
|
||||
polygons.reserve(mesh.its.indices.size());
|
||||
|
||||
for (const auto& v : mesh.its.vertices)
|
||||
points.emplace_back(v.x(), v.y(), v.z());
|
||||
|
||||
for (const auto& f : mesh.its.indices)
|
||||
polygons.push_back({size_t(f[0]), size_t(f[1]), size_t(f[2])});
|
||||
|
||||
// 2) Aggressive soup cleanup
|
||||
PMP::repair_polygon_soup(points, polygons);
|
||||
|
||||
// 3) Convert soup → mesh
|
||||
_EpicMesh cgal_mesh;
|
||||
PMP::polygon_soup_to_polygon_mesh(points, polygons, cgal_mesh);
|
||||
|
||||
// 4) Remove degenerate geometry
|
||||
PMP::remove_degenerate_faces(cgal_mesh);
|
||||
PMP::remove_isolated_vertices(cgal_mesh);
|
||||
|
||||
// 5) Fix remaining non-manifold vertices
|
||||
PMP::duplicate_non_manifold_vertices(cgal_mesh);
|
||||
|
||||
// 6) Boolean union (keeps only outer shell)
|
||||
_EpicMesh tmp;
|
||||
if (PMP::corefine_and_compute_union(cgal_mesh, cgal_mesh, tmp)) {
|
||||
cgal_mesh = std::move(tmp);
|
||||
}
|
||||
// If it fails, continue anyway with previous mesh
|
||||
|
||||
// 7) Fill holes
|
||||
if (!CGAL::is_closed(cgal_mesh)) {
|
||||
using halfedge_descriptor = boost::graph_traits<_EpicMesh>::halfedge_descriptor;
|
||||
|
||||
std::vector<halfedge_descriptor> borders;
|
||||
CGAL::extract_boundary_cycles(cgal_mesh, std::back_inserter(borders));
|
||||
|
||||
for (halfedge_descriptor h : borders) {
|
||||
PMP::triangulate_and_refine_hole(cgal_mesh, h);
|
||||
}
|
||||
}
|
||||
|
||||
// 8) Final validity check
|
||||
if (!CGAL::is_closed(cgal_mesh)) {
|
||||
if (error)
|
||||
*error = "Repair failed: mesh still open after hole filling.";
|
||||
return false;
|
||||
}
|
||||
|
||||
// 9) Ensure outward orientation
|
||||
if (!PMP::does_bound_a_volume(cgal_mesh))
|
||||
PMP::orient_to_bound_a_volume(cgal_mesh);
|
||||
|
||||
// 10) Convert back
|
||||
indexed_triangle_set its = cgal_to_indexed_triangle_set(cgal_mesh);
|
||||
|
||||
RepairedMeshErrors errs{};
|
||||
errs.facets_removed = 0;
|
||||
errs.edges_fixed = 0;
|
||||
|
||||
mesh = TriangleMesh(std::move(its), errs);
|
||||
|
||||
if (repaired_errors)
|
||||
*repaired_errors = errs;
|
||||
|
||||
return true;
|
||||
} catch (const std::exception& e) {
|
||||
if (error)
|
||||
*error = e.what();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
CGALMeshPtr clone(const CGALMesh &m)
|
||||
{
|
||||
return CGALMeshPtr{new CGALMesh{m}};
|
||||
|
||||
@@ -77,6 +77,9 @@ TriangleMesh merge(std::vector<TriangleMesh> meshes);
|
||||
bool does_bound_a_volume(const CGALMesh &mesh);
|
||||
bool empty(const CGALMesh &mesh);
|
||||
|
||||
// Repair a mesh using CGAL. Returns true on success. Optionally returns a summary of repairs and an error string.
|
||||
bool repair(TriangleMesh &mesh, RepairedMeshErrors *repaired_errors = nullptr, std::string *error = nullptr);
|
||||
|
||||
// Real UV unwrap of an open mesh patch via CGAL's LSCM (Least Squares Conformal Maps) surface
|
||||
// parameterization. Returns one UV coordinate per input vertex (same indexing as `mesh.vertices`),
|
||||
// or nullopt if `mesh` isn't a single topological disk -- LSCM needs exactly one connected
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,28 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
class TriangleMesh;
|
||||
|
||||
struct MeshRepairStats
|
||||
{
|
||||
std::size_t welded_vertices = 0;
|
||||
std::size_t removed_triangles = 0;
|
||||
std::size_t reversed_shells = 0;
|
||||
std::size_t filled_holes = 0;
|
||||
std::size_t removed_shells = 0;
|
||||
std::size_t self_intersections = 0;
|
||||
// False when the input already was closed, consistently oriented and free of self-intersections.
|
||||
bool modified = false;
|
||||
};
|
||||
|
||||
// Returns false, leaving the mesh untouched, if no solid can be built. progress gets the percentage done and may
|
||||
// throw to cancel. See docs/HLSD/mesh-repair.md.
|
||||
bool repair_mesh(TriangleMesh &mesh, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
|
||||
const std::function<void(int)> &progress = {});
|
||||
|
||||
} // namespace Slic3r
|
||||
+22
-39
@@ -29,7 +29,6 @@
|
||||
#include "TriangleMeshSlicer.hpp"
|
||||
#include "TriangleSelector.hpp"
|
||||
#include "MaterialType.hpp"
|
||||
#include "MeshRepair.hpp"
|
||||
|
||||
#include "Format/AMF.hpp"
|
||||
#include "Format/svg.hpp"
|
||||
@@ -2947,18 +2946,6 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
|
||||
if (text_configuration.has_value())
|
||||
text_configuration.reset();
|
||||
|
||||
// Parts without a convex hull enclose no volume; drop them here, as deleting volumes later could delete this one.
|
||||
std::vector<std::unique_ptr<ModelVolume>> parts;
|
||||
for (TriangleMesh &mesh : meshes)
|
||||
if (!mesh.empty()) {
|
||||
std::unique_ptr<ModelVolume> part(new ModelVolume(object, *this, std::move(mesh)));
|
||||
if (const std::shared_ptr<const TriangleMesh> &hull = part->get_convex_hull_shared_ptr();
|
||||
hull != nullptr && !hull->its.vertices.empty() && !hull->its.indices.empty())
|
||||
parts.emplace_back(std::move(part));
|
||||
}
|
||||
if (parts.empty())
|
||||
return 1;
|
||||
|
||||
std::optional<TriangleSelector::SavedPainting> saved_painting = remap_paint ? save_painting() :
|
||||
std::optional<TriangleSelector::SavedPainting>{};
|
||||
|
||||
@@ -2969,22 +2956,26 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
|
||||
unsigned int extruder_counter = 0;
|
||||
const Vec3d offset = this->get_offset();
|
||||
|
||||
for (std::unique_ptr<ModelVolume> &part : parts) {
|
||||
for (TriangleMesh &mesh : meshes) {
|
||||
if (mesh.empty())
|
||||
// Repair may have removed unconnected triangles, thus emptying the mesh.
|
||||
continue;
|
||||
|
||||
if (idx == 0) {
|
||||
this->set_mesh(part->m_mesh);
|
||||
m_convex_hull = part->m_convex_hull;
|
||||
this->set_mesh(std::move(mesh));
|
||||
this->calculate_convex_hull();
|
||||
this->invalidate_convex_hull_2d();
|
||||
// Assign a new unique ID, so that a new GLVolume will be generated.
|
||||
this->set_new_unique_id();
|
||||
// reset the source to disable reload from disk
|
||||
this->source = ModelVolume::Source();
|
||||
|
||||
// BBS: reset facet annotations
|
||||
this->reset_extra_facets();
|
||||
}
|
||||
else
|
||||
this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), part.release());
|
||||
this->object->volumes.insert(this->object->volumes.begin() + (++ivolume), new ModelVolume(object, *this, std::move(mesh)));
|
||||
|
||||
// reset the source to disable reload from disk
|
||||
this->object->volumes[ivolume]->source = ModelVolume::Source();
|
||||
this->object->volumes[ivolume]->set_offset(Vec3d::Zero());
|
||||
this->object->volumes[ivolume]->center_geometry_after_creation();
|
||||
this->object->volumes[ivolume]->translate(offset);
|
||||
@@ -2998,29 +2989,21 @@ size_t ModelVolume::split(unsigned int max_extruders, bool remap_paint)
|
||||
++ idx;
|
||||
}
|
||||
|
||||
// discard volumes for which the convex hull was not generated or is degenerate
|
||||
size_t i = 0;
|
||||
while (i < this->object->volumes.size()) {
|
||||
const std::shared_ptr<const TriangleMesh> &hull = this->object->volumes[i]->get_convex_hull_shared_ptr();
|
||||
if (hull == nullptr || hull->its.vertices.empty() || hull->its.indices.empty()) {
|
||||
this->object->delete_volume(i);
|
||||
--idx;
|
||||
--i;
|
||||
}
|
||||
++i;
|
||||
}
|
||||
|
||||
return idx;
|
||||
}
|
||||
|
||||
bool ModelVolume::repair(bool keep_painting, MeshRepairStats *stats_out, std::string *error, const std::function<void(int)> &progress)
|
||||
{
|
||||
TriangleMesh mesh = this->mesh();
|
||||
MeshRepairStats stats;
|
||||
const bool ok = repair_mesh(mesh, &stats, error, progress);
|
||||
if (stats_out)
|
||||
*stats_out = stats;
|
||||
if (!ok || !stats.modified)
|
||||
return ok;
|
||||
|
||||
const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ? save_painting() : std::nullopt;
|
||||
this->set_mesh(std::move(mesh));
|
||||
this->calculate_convex_hull();
|
||||
this->invalidate_convex_hull_2d();
|
||||
// Assign a new unique ID, so that a new GLVolume will be generated.
|
||||
this->set_new_unique_id();
|
||||
this->restore_painting(saved_painting);
|
||||
return true;
|
||||
}
|
||||
|
||||
void ModelVolume::translate(const Vec3d& displacement)
|
||||
{
|
||||
set_offset(get_offset() + displacement);
|
||||
|
||||
+7
-11
@@ -77,7 +77,6 @@ class Preset;
|
||||
class BBLProject;
|
||||
|
||||
class KeyStore;
|
||||
struct MeshRepairStats;
|
||||
|
||||
namespace UndoRedo {
|
||||
class StackImpl;
|
||||
@@ -888,13 +887,13 @@ public:
|
||||
// The triangular model.
|
||||
const TriangleMesh& mesh() const { return *m_mesh.get(); }
|
||||
std::shared_ptr<const TriangleMesh> mesh_ptr() const { return m_mesh; }
|
||||
void set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
|
||||
void set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
|
||||
void set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); m_is_splittable = -1; }
|
||||
void set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); m_is_splittable = -1; }
|
||||
void set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; m_is_splittable = -1; }
|
||||
void set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); m_is_splittable = -1; }
|
||||
void reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); m_is_splittable = -1; }
|
||||
void set_mesh(const TriangleMesh &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
|
||||
void set_mesh(TriangleMesh &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
|
||||
void set_mesh(const indexed_triangle_set &mesh) { m_mesh = std::make_shared<const TriangleMesh>(mesh); }
|
||||
void set_mesh(indexed_triangle_set &&mesh) { m_mesh = std::make_shared<const TriangleMesh>(std::move(mesh)); }
|
||||
void set_mesh(std::shared_ptr<const TriangleMesh> &mesh) { m_mesh = mesh; }
|
||||
void set_mesh(std::unique_ptr<const TriangleMesh> &&mesh) { m_mesh = std::move(mesh); }
|
||||
void reset_mesh() { m_mesh = std::make_shared<const TriangleMesh>(); }
|
||||
const std::shared_ptr<const TriangleMesh>& get_mesh_shared_ptr() const { return m_mesh; }
|
||||
// Configuration parameters specific to an object model geometry or a modifier volume,
|
||||
// overriding the global Slic3r settings and the ModelObject settings.
|
||||
@@ -1044,9 +1043,6 @@ public:
|
||||
// Return the number of volumes created from this one.
|
||||
// This is useful to assign different materials to different volumes of an object.
|
||||
size_t split(unsigned int max_extruders, bool remap_paint);
|
||||
// Replaces the mesh by its repair_mesh() result if that changed it. False if no solid can be built.
|
||||
bool repair(bool keep_painting, MeshRepairStats *stats = nullptr, std::string *error = nullptr,
|
||||
const std::function<void(int)> &progress = {});
|
||||
void translate(double x, double y, double z) { translate(Vec3d(x, y, z)); }
|
||||
void translate(const Vec3d& displacement);
|
||||
void scale(const Vec3d& scaling_factors);
|
||||
|
||||
@@ -2164,16 +2164,6 @@ int PresetCollection::get_differed_values_to_update(Preset& preset, std::map<std
|
||||
DynamicPrintConfig temp_config;
|
||||
std::vector<std::string> dirty_options = preset.config.diff(parent_preset->config);
|
||||
|
||||
// Send the variant layout even when it matches the parent's, as the local save does: the loader
|
||||
// sizes the per-variant values by it and would otherwise keep only the first one.
|
||||
std::string extruder_id_name, extruder_variant_name;
|
||||
std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
|
||||
Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
|
||||
if (!extruder_id_name.empty())
|
||||
dirty_options.emplace_back(extruder_id_name);
|
||||
if (!extruder_variant_name.empty())
|
||||
dirty_options.emplace_back(extruder_variant_name);
|
||||
|
||||
for (auto option: dirty_options)
|
||||
{
|
||||
ConfigOption *opt_src = preset.config.option(option);
|
||||
@@ -2638,34 +2628,15 @@ bool PresetCollection::load_user_preset(std::string name, std::map<std::string,
|
||||
new_config = default_preset.config;
|
||||
}
|
||||
|
||||
std::string extruder_id_name, extruder_variant_name;
|
||||
std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
|
||||
Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
|
||||
|
||||
// Older uploads left out a variant layout equal to the parent's but still sent one value per
|
||||
// parent variant. Read those values against the parent's layout instead of cutting them to one.
|
||||
if (inherit_preset && !cloud_config.has(extruder_variant_name)) {
|
||||
const auto *parent_variants = inherit_preset->config.option<ConfigOptionStrings>(extruder_variant_name);
|
||||
const size_t variant_count = parent_variants ? parent_variants->size() : 0;
|
||||
bool values_per_variant = false;
|
||||
for (const std::string &key : cloud_config.keys()) {
|
||||
const size_t stride = key_set2->count(key) ? 2 : key_set1->count(key) ? 1 : 0;
|
||||
const auto *values = dynamic_cast<const ConfigOptionVectorBase *>(cloud_config.option(key));
|
||||
if (stride > 0 && key != extruder_id_name && values && variant_count > 1 && values->size() == variant_count * stride) {
|
||||
values_per_variant = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (values_per_variant)
|
||||
for (const std::string &key : {extruder_id_name, extruder_variant_name})
|
||||
if (!key.empty() && !cloud_config.has(key) && inherit_preset->config.has(key))
|
||||
cloud_config.set_key_value(key, inherit_preset->config.option(key)->clone());
|
||||
}
|
||||
|
||||
extend_default_config_length(cloud_config, false, {});
|
||||
|
||||
if (inherit_preset)
|
||||
if (inherit_preset) {
|
||||
std::string extruder_id_name, extruder_variant_name;
|
||||
std::set<std::string> *key_set1 = nullptr, *key_set2 = nullptr;
|
||||
Preset::get_extruder_names_and_keysets(m_type, extruder_id_name, extruder_variant_name, &key_set1, &key_set2);
|
||||
|
||||
new_config.update_diff_values_to_child_config(cloud_config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
|
||||
}
|
||||
else{
|
||||
new_config.apply(std::move(cloud_config));
|
||||
extend_default_config_length(new_config, true, default_preset.config);
|
||||
|
||||
@@ -3905,8 +3905,14 @@ void PresetBundle::export_selections(AppConfig &config)
|
||||
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": printer %1%, print %2%, filaments[0] %3% ")%printers.get_selected_preset_name() % prints.get_selected_preset_name() %filament_presets[0];
|
||||
}
|
||||
|
||||
size_t PresetBundle::resize_project_filament_slots(size_t n)
|
||||
void PresetBundle::set_num_filaments(unsigned int n, std::string new_color)
|
||||
{
|
||||
unsigned old_filament_count = this->filament_presets.size();
|
||||
if (n > old_filament_count && old_filament_count != 0)
|
||||
filament_presets.resize(n, filament_presets.back());
|
||||
else {
|
||||
filament_presets.resize(n);
|
||||
}
|
||||
ConfigOptionStrings* filament_color = project_config.option<ConfigOptionStrings>("filament_colour");
|
||||
ConfigOptionStrings *filament_multi_color = project_config.option<ConfigOptionStrings>("filament_multi_colour");
|
||||
ConfigOptionStrings* filament_color_type = project_config.option<ConfigOptionStrings>("filament_colour_type");
|
||||
@@ -3932,25 +3938,9 @@ size_t PresetBundle::resize_project_filament_slots(size_t n)
|
||||
ams_multi_color_filment.resize(n);
|
||||
|
||||
resize_mixed_filament_metadata(project_config, old_slot_count, n);
|
||||
return old_slot_count;
|
||||
}
|
||||
|
||||
void PresetBundle::set_num_filaments(unsigned int n, std::string new_color)
|
||||
{
|
||||
unsigned old_filament_count = this->filament_presets.size();
|
||||
if (n > old_filament_count && old_filament_count != 0)
|
||||
filament_presets.resize(n, filament_presets.back());
|
||||
else {
|
||||
filament_presets.resize(n);
|
||||
}
|
||||
|
||||
const size_t old_slot_count = resize_project_filament_slots(n);
|
||||
|
||||
//BBS set new filament color to new_color
|
||||
if (!new_color.empty()) {
|
||||
ConfigOptionStrings* filament_color = project_config.option<ConfigOptionStrings>("filament_colour");
|
||||
ConfigOptionStrings *filament_multi_color = project_config.option<ConfigOptionStrings>("filament_multi_colour");
|
||||
ConfigOptionStrings* filament_color_type = project_config.option<ConfigOptionStrings>("filament_colour_type");
|
||||
for (size_t i = old_slot_count; i < n; i++) {
|
||||
filament_color->values[i] = new_color;
|
||||
filament_multi_color->values[i] = new_color;
|
||||
@@ -5387,23 +5377,6 @@ DynamicPrintConfig PresetBundle::full_fff_config(bool apply_extruder, std::optio
|
||||
add_if_some_non_empty(std::move(print_compatible_printers), "print_compatible_printers");
|
||||
out.option<ConfigOptionStrings>("extruder_ams_count", true)->values = save_extruder_ams_count_to_string(this->extruder_ams_counts);
|
||||
|
||||
// The slice config is consumed by code that indexes per-slot arrays by material id
|
||||
// (MultiMaterialSegmentation sizes its state count from filament_colour). After the
|
||||
// producer-side lockstep in update_multi_material_filament_presets() these project-scoped
|
||||
// arrays are expected to be exactly num_filaments; the property the pipeline relies on is
|
||||
// that none is shorter (a short filament_colour was the OOB in #16432). Pad if needed.
|
||||
for (const char* per_slot_key : { "filament_colour", "filament_colour_type", "filament_multi_colour" }) {
|
||||
auto* per_slot_opt = dynamic_cast<ConfigOptionVectorBase*>(out.option(per_slot_key, true));
|
||||
if (per_slot_opt == nullptr)
|
||||
continue;
|
||||
if (per_slot_opt->size() < num_filaments) {
|
||||
BOOST_LOG_TRIVIAL(warning) << "full_fff_config: per-slot array " << per_slot_key
|
||||
<< " has " << per_slot_opt->size() << " entries, padding to num_filaments=" << num_filaments;
|
||||
per_slot_opt->resize(num_filaments, FullPrintConfig::defaults().option(per_slot_key));
|
||||
}
|
||||
assert(per_slot_opt->size() >= num_filaments);
|
||||
}
|
||||
|
||||
out.option<ConfigOptionEnumGeneric>("printer_technology", true)->value = ptFFF;
|
||||
return out;
|
||||
}
|
||||
@@ -7938,15 +7911,6 @@ void PresetBundle::update_multi_material_filament_presets(size_t to_delete_filam
|
||||
this->filament_presets.resize(num_extruders, this->filament_presets.empty() ? this->filaments.first_visible().name :
|
||||
this->filament_presets.back());
|
||||
num_filaments = this->filament_presets.size();
|
||||
|
||||
// Keep the project-scoped per-slot arrays in lockstep with the padded preset list, so
|
||||
// consumers that size from filament_colour (MultiMaterialSegmentation) agree with those
|
||||
// that size from the preset list / filament_diameter (PrintObjectSlice). Grow only: a
|
||||
// colour array longer than the preset list is a valid state (a project with more slots
|
||||
// than nozzles) and must not be truncated here.
|
||||
const auto* filament_colour = this->project_config.option<ConfigOptionStrings>("filament_colour");
|
||||
if (filament_colour == nullptr || filament_colour->values.size() < num_filaments)
|
||||
this->resize_project_filament_slots(num_filaments);
|
||||
}
|
||||
if (to_delete_filament_id == -1)
|
||||
to_delete_filament_id = num_filaments;
|
||||
|
||||
@@ -394,12 +394,6 @@ public:
|
||||
// slots live. A caller adding physical filaments has to add num_mixed_filaments() on top and
|
||||
// then move the new slots ahead of the mixed tail, as Sidebar::add_custom_filament does.
|
||||
void set_num_filaments(unsigned int n, std::string new_col = "");
|
||||
// Grow or shrink the project-scoped per-slot arrays (filament_colour, filament_colour_type,
|
||||
// filament_multi_colour, the filament maps and the mixed metadata) to n, without touching
|
||||
// filament_presets and without rebuilding flush volumes. Callers that resize filament_presets
|
||||
// must keep these arrays in lockstep with it. Returns the array size before the resize so the
|
||||
// caller can seed the new tail.
|
||||
size_t resize_project_filament_slots(size_t n);
|
||||
void update_num_filaments(unsigned int to_del_flament_id);
|
||||
|
||||
void get_ams_cobox_infos(AMSComboInfo &combox_info);
|
||||
|
||||
@@ -2991,15 +2991,6 @@ void PrintObject::clear_shared_object()
|
||||
void PrintObject::copy_layers_from_shared_object()
|
||||
{
|
||||
if (m_shared_object) {
|
||||
// Orca: Print::process() calls this once per slice for each sharing object, after clear_shared_object() has
|
||||
// emptied any earlier alias, so the vectors hold only layers this object sliced itself before it started sharing
|
||||
// (or nothing). Free them here, as clear_support_layers() / clear_layers() would; those skip deletion while
|
||||
// m_shared_object is set. The belt-only data they also free is always empty here, because belt printers never
|
||||
// share layers.
|
||||
for (SupportLayer *layer : m_support_layers)
|
||||
delete layer;
|
||||
for (Layer *layer : m_layers)
|
||||
delete layer;
|
||||
m_layers.clear();
|
||||
m_support_layers.clear();
|
||||
|
||||
|
||||
@@ -12866,11 +12866,10 @@ CLITransformConfigDef::CLITransformConfigDef()
|
||||
//def->cli = "orient|o";
|
||||
def->set_default_value(new ConfigOptionInt(0));
|
||||
|
||||
def = this->add("repair", coBool);
|
||||
/*def = this->add("repair", coBool);
|
||||
def->label = L("Repair");
|
||||
def->tooltip = L("Repair the meshes of the models as Fix Model does: close holes and cracks, orient them outward and "
|
||||
"remove self-intersections.");
|
||||
def->set_default_value(new ConfigOptionBool(false));
|
||||
def->tooltip = L("Repair the model's meshes if it is non-manifold mesh.");
|
||||
def->set_default_value(new ConfigOptionBool(false));*/
|
||||
|
||||
def = this->add("rotate", coFloat);
|
||||
def->label = L("Rotate");
|
||||
@@ -13086,7 +13085,7 @@ CLIMiscConfigDef::CLIMiscConfigDef()
|
||||
def = this->add("allow_rotations", coBool);
|
||||
def->label = L("Allow rotation when arranging");
|
||||
def->tooltip = L("If enabled, Arrange will allow rotation when placing objects.");
|
||||
def->set_default_value(new ConfigOptionBool(false));
|
||||
def->set_default_value(new ConfigOptionBool(true));
|
||||
|
||||
def = this->add("align_to_y_axis", coBool);
|
||||
def->label = L("Align to Y axis when arranging");
|
||||
|
||||
@@ -982,9 +982,6 @@ void PrintObject::generate_support_material(bool with_belt_brim)
|
||||
this->_generate_support_material();
|
||||
m_print->throw_if_canceled();
|
||||
}
|
||||
// Orca: the tree support collision/avoidance caches and support nodes are only used while this step runs
|
||||
// (detect_overhangs() rebuilds them from scratch), so don't keep them resident until the next slice.
|
||||
this->clear_tree_support_preview_cache();
|
||||
// Belt brim rides here rather than in the brim step because its apron
|
||||
// prologue introduces print_z values below the object's first layer, and
|
||||
// those must exist before ToolOrdering is built at psWipeTower - one step
|
||||
|
||||
@@ -1073,14 +1073,8 @@ static inline void apply_mm_segmentation(PrintObject &print_object, ThrowOnCance
|
||||
const auto &layer_ranges = print_object.shared_regions()->layer_ranges;
|
||||
double z = print_object.get_layer(int(range.begin()))->slice_z;
|
||||
auto it_layer_range = layer_range_first(layer_ranges, z);
|
||||
// The per-layer row width of the segmentation is the number of material channels it
|
||||
// was built with (filament_colour.size()). Size the bound from the data itself rather
|
||||
// than from filament_diameter.size(): those two arrays can diverge (the project's
|
||||
// colour array can end up shorter than the padded preset list), and trusting the
|
||||
// larger count reads past the end of every row.
|
||||
// BBS
|
||||
const size_t num_extruders = segmentation.empty() ? 0 : segmentation.front().size();
|
||||
assert(num_extruders == print_object.print()->config().filament_diameter.size());
|
||||
const size_t num_extruders = print_object.print()->config().filament_diameter.size();
|
||||
|
||||
struct ByExtruder {
|
||||
ExPolygons expolygons;
|
||||
@@ -1103,8 +1097,7 @@ static inline void apply_mm_segmentation(PrintObject &print_object, ThrowOnCance
|
||||
by_extruder.assign(num_extruders, ByExtruder());
|
||||
by_region.assign(layer.region_count(), ByRegion());
|
||||
bool layer_split = false;
|
||||
const size_t layer_channels = segmentation[layer_id].size();
|
||||
for (size_t extruder_id = 0; extruder_id < std::min(num_extruders, layer_channels); ++ extruder_id) {
|
||||
for (size_t extruder_id = 0; extruder_id < num_extruders; ++ extruder_id) {
|
||||
ByExtruder ®ion = by_extruder[extruder_id];
|
||||
append(region.expolygons, std::move(segmentation[layer_id][extruder_id]));
|
||||
if (! region.expolygons.empty()) {
|
||||
@@ -1539,7 +1532,7 @@ void PrintObject::slice_volumes()
|
||||
if (min_growth < 0.f || elfoot > 0.f) {
|
||||
// Apply the negative XY compensation. (the ones that is <0)
|
||||
ExPolygons trimming;
|
||||
const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
|
||||
static const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
|
||||
if (elfoot > 0.f) {
|
||||
ExPolygons expolygons_to_compensate = offset_ex(layer->merged(eps), -eps);
|
||||
lslices_elfoot_uncompensated[layer_id] = expolygons_to_compensate;
|
||||
|
||||
@@ -1976,15 +1976,37 @@ coordf_t TreeSupport::get_radius(const SupportNode* node)
|
||||
return node->radius;
|
||||
}
|
||||
|
||||
// Orca: drop_nodes() calls these several times per node per layer, so they return a reference into the
|
||||
// TreeSupportData cache. The cache only ever inserts, so its entries never move while nodes drop in parallel.
|
||||
const ExPolygons& TreeSupport::get_avoidance(coordf_t radius, size_t obj_layer_nr)
|
||||
ExPolygons TreeSupport::get_avoidance(coordf_t radius, size_t obj_layer_nr)
|
||||
{
|
||||
#if USE_SUPPORT_3D
|
||||
if (m_model_volumes) {
|
||||
bool on_build_plate = m_object_config->support_on_build_plate_only.value;
|
||||
const Polygons& avoid_polys = m_model_volumes->getAvoidance(radius, obj_layer_nr, TreeSupport3D::TreeModelVolumes::AvoidanceType::FastSafe, on_build_plate, true);
|
||||
ExPolygons expolys;
|
||||
for (auto& poly : avoid_polys)
|
||||
expolys.emplace_back(std::move(poly));
|
||||
return expolys;
|
||||
}
|
||||
return ExPolygons();
|
||||
#else
|
||||
return m_ts_data->get_avoidance(radius, obj_layer_nr);
|
||||
#endif
|
||||
}
|
||||
const ExPolygons& TreeSupport::get_collision(coordf_t radius, size_t layer_nr)
|
||||
ExPolygons TreeSupport::get_collision(coordf_t radius, size_t layer_nr)
|
||||
{
|
||||
#if USE_SUPPORT_3D
|
||||
if (m_model_volumes) {
|
||||
bool on_build_plate = m_object_config->support_on_build_plate_only.value;
|
||||
const Polygons& collision_polys = m_model_volumes->getCollision(radius, layer_nr, true);
|
||||
ExPolygons expolys;
|
||||
for (auto& poly : collision_polys)
|
||||
expolys.emplace_back(std::move(poly));
|
||||
return expolys;
|
||||
}
|
||||
#else
|
||||
return m_ts_data->get_collision(radius, layer_nr);
|
||||
#endif
|
||||
return ExPolygons();
|
||||
}
|
||||
Polygons TreeSupport::get_collision_polys(coordf_t radius, size_t layer_nr)
|
||||
{
|
||||
@@ -2805,12 +2827,7 @@ void TreeSupport::draw_circles()
|
||||
#endif // SUPPORT_TREE_DEBUG_TO_SVG
|
||||
|
||||
SupportLayerPtrs& ts_layers = m_object->support_layers();
|
||||
// Orca: the vector owns its layers, so the dropped ones are deleted before they are erased.
|
||||
// std::stable_partition (unlike std::remove_if) leaves exactly the dropped layers in the tail.
|
||||
// Only heights below EPSILON are dropped; written as !(height < EPSILON), a NaN height is kept.
|
||||
auto iter = std::stable_partition(ts_layers.begin(), ts_layers.end(), [](SupportLayer* ts_layer) { return !(ts_layer->height < EPSILON); });
|
||||
for (auto it = iter; it != ts_layers.end(); ++it)
|
||||
delete *it;
|
||||
auto iter = std::remove_if(ts_layers.begin(), ts_layers.end(), [](SupportLayer* ts_layer) { return ts_layer->height < EPSILON; });
|
||||
ts_layers.erase(iter, ts_layers.end());
|
||||
for (int layer_nr = 0; layer_nr < ts_layers.size(); layer_nr++) {
|
||||
ts_layers[layer_nr]->upper_layer = layer_nr != ts_layers.size() - 1 ? ts_layers[layer_nr + 1] : nullptr;
|
||||
@@ -3054,7 +3071,7 @@ void TreeSupport::drop_nodes()
|
||||
//Insert a completely new node and let both original nodes fade.
|
||||
Point next_position = (node.position + neighbours[0]) / 2; //Average position of the two nodes.
|
||||
coordf_t next_radius = calc_radius(node.dist_mm_to_top+height_next);
|
||||
const ExPolygons& avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
|
||||
auto avoid_layer = get_avoidance(next_radius, obj_layer_nr_next);
|
||||
if (group_index == 0)
|
||||
{
|
||||
//Avoid collisions.
|
||||
@@ -3258,7 +3275,7 @@ void TreeSupport::drop_nodes()
|
||||
}
|
||||
#endif
|
||||
coordf_t next_radius = calc_radius(node.dist_mm_to_top + height_next);
|
||||
const ExPolygons& avoidance_next = get_avoidance(next_radius, obj_layer_nr_next);
|
||||
auto avoidance_next = get_avoidance(next_radius, obj_layer_nr_next);
|
||||
|
||||
Point to_outside = projection_onto(avoidance_next, node.position);
|
||||
Point direction_to_outer = to_outside - node.position;
|
||||
@@ -3320,7 +3337,7 @@ void TreeSupport::drop_nodes()
|
||||
p_node->to_buildplate = false;
|
||||
return; // from parallel_for_each lambda
|
||||
}
|
||||
const ExPolygons& next_collision = get_collision(0, obj_layer_nr_next);
|
||||
auto next_collision = get_collision(0, obj_layer_nr_next);
|
||||
const bool to_buildplate = !is_inside_ex(m_ts_data->m_layer_outlines[obj_layer_nr_next], next_layer_vertex);
|
||||
// don't increase radius if next node will collide partially with the object (STUDIO-7883)
|
||||
to_outside = projection_onto(next_collision, next_layer_vertex);
|
||||
|
||||
@@ -536,9 +536,9 @@ private:
|
||||
coordf_t calc_branch_radius(coordf_t base_radius, coordf_t mm_to_top, double diameter_angle_scale_factor, bool use_min_distance=true);
|
||||
coordf_t calc_radius(coordf_t mm_to_top);
|
||||
coordf_t get_radius(const SupportNode* node);
|
||||
const ExPolygons& get_avoidance(coordf_t radius, size_t obj_layer_nr);
|
||||
ExPolygons get_avoidance(coordf_t radius, size_t obj_layer_nr);
|
||||
// layer's expolygon expanded by radius+m_xy_distance
|
||||
const ExPolygons& get_collision(coordf_t radius, size_t layer_nr);
|
||||
ExPolygons get_collision(coordf_t radius, size_t layer_nr);
|
||||
// get Polygons instead of ExPolygons
|
||||
Polygons get_collision_polys(coordf_t radius, size_t layer_nr);
|
||||
|
||||
|
||||
@@ -5310,44 +5310,40 @@ bool texture_displacement_layers_from_json(const std::string
|
||||
if (!root.is_object())
|
||||
return false;
|
||||
|
||||
TextureDisplacementOptions out_options;
|
||||
if (const auto it = root.find("options"); it != root.end() && it->is_object()) {
|
||||
const nlohmann::json &opt = *it;
|
||||
read(opt, "displace_border", out_options.displace_border);
|
||||
read(opt, "smooth_enabled", out_options.smooth_enabled);
|
||||
read(opt, "smooth_strength", out_options.smooth_strength);
|
||||
read(opt, "smooth_iterations", out_options.smooth_iterations);
|
||||
read(opt, "smooth_skip_border", out_options.smooth_skip_border);
|
||||
read(opt, "pipeline_v2", out_options.pipeline_v2);
|
||||
read(opt, "v2_refine_mm", out_options.v2_refine_mm);
|
||||
read(opt, "v2_regularize", out_options.v2_regularize);
|
||||
read(opt, "v2_max_triangles_k", out_options.v2_max_triangles_k);
|
||||
read(opt, "v2_relocate", out_options.v2_relocate);
|
||||
read(opt, "v2_flip_edges", out_options.v2_flip_edges);
|
||||
read(opt, "color_mix_enabled", out_options.color_mix_enabled);
|
||||
read(opt, "color_despeckle", out_options.color_despeckle);
|
||||
read(opt, "color_mix_count", out_options.color_mix_count);
|
||||
read(opt, "active_slot", out_options.active_slot);
|
||||
read(opt, "panel_mode", out_options.panel_mode);
|
||||
out_options.active_slot = std::clamp(out_options.active_slot, 0, int(TEXTURE_DISPLACEMENT_MAX_LAYERS) - 1);
|
||||
out_options.panel_mode = std::clamp(out_options.panel_mode, 0, 1);
|
||||
}
|
||||
|
||||
TextureDisplacementOptions out_options;
|
||||
std::vector<TextureDisplacementLayer> out_layers;
|
||||
// read() skips a value of the wrong type, but the vector, matrix, seam, island and UV-override arrays
|
||||
// below read their numbers with get<>(), which throws on one; that rejects the document, like text that
|
||||
// does not parse.
|
||||
// Past the parse, a value of the wrong type still throws: get<int>() on a string, get<float>() on
|
||||
// null. Nothing between here and the project load catches that, so one bad number would fail the
|
||||
// whole file instead of this one block. Report it malformed and let the volume load without it.
|
||||
try {
|
||||
if (const auto it = root.find("options"); it != root.end() && it->is_object()) {
|
||||
const nlohmann::json &opt = *it;
|
||||
read(opt, "displace_border", out_options.displace_border);
|
||||
read(opt, "smooth_enabled", out_options.smooth_enabled);
|
||||
read(opt, "smooth_strength", out_options.smooth_strength);
|
||||
read(opt, "smooth_iterations", out_options.smooth_iterations);
|
||||
read(opt, "smooth_skip_border", out_options.smooth_skip_border);
|
||||
read(opt, "pipeline_v2", out_options.pipeline_v2);
|
||||
read(opt, "v2_refine_mm", out_options.v2_refine_mm);
|
||||
read(opt, "v2_regularize", out_options.v2_regularize);
|
||||
read(opt, "v2_max_triangles_k", out_options.v2_max_triangles_k);
|
||||
read(opt, "v2_relocate", out_options.v2_relocate);
|
||||
read(opt, "v2_flip_edges", out_options.v2_flip_edges);
|
||||
read(opt, "color_mix_enabled", out_options.color_mix_enabled);
|
||||
read(opt, "color_despeckle", out_options.color_despeckle);
|
||||
read(opt, "color_mix_count", out_options.color_mix_count);
|
||||
read(opt, "active_slot", out_options.active_slot);
|
||||
read(opt, "panel_mode", out_options.panel_mode);
|
||||
out_options.active_slot = std::clamp(out_options.active_slot, 0, int(TEXTURE_DISPLACEMENT_MAX_LAYERS) - 1);
|
||||
out_options.panel_mode = std::clamp(out_options.panel_mode, 0, 1);
|
||||
}
|
||||
|
||||
if (const auto it = root.find("layers"); it != root.end() && it->is_array()) {
|
||||
for (const nlohmann::json &j : *it) {
|
||||
if (!j.is_object())
|
||||
continue;
|
||||
TextureDisplacementLayer l;
|
||||
read(j, "slot", l.slot);
|
||||
// The panel and the paint masks are indexed by slot, so a layer without a valid one rejects the
|
||||
// document rather than reaching them.
|
||||
if (l.slot < 0 || l.slot >= int(TEXTURE_DISPLACEMENT_MAX_LAYERS))
|
||||
return false;
|
||||
read(j, "name", l.name);
|
||||
read(j, "path", l.path);
|
||||
read(j, "path_in_3mf", l.path_in_3mf);
|
||||
@@ -5414,7 +5410,7 @@ bool texture_displacement_layers_from_json(const std::string
|
||||
out_layers.push_back(std::move(l));
|
||||
}
|
||||
}
|
||||
} catch (const nlohmann::json::exception &) {
|
||||
} catch (...) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -424,10 +424,7 @@ struct TextureDisplacementOptions
|
||||
// responsible for writing it and for filling `image_data` back in on load.
|
||||
std::string texture_displacement_layers_to_json(const std::vector<TextureDisplacementLayer> &layers,
|
||||
const TextureDisplacementOptions &options);
|
||||
// Returns false and leaves both outputs untouched when the text is not a valid JSON object, a number in a
|
||||
// layer's vector, matrix, seam, island or UV-override array has the wrong type, or a layer's slot is
|
||||
// missing or outside [0, TEXTURE_DISPLACEMENT_MAX_LAYERS). Any other value of the wrong type or shape
|
||||
// keeps its default.
|
||||
// Returns false and leaves both outputs untouched when the text is not valid JSON.
|
||||
bool texture_displacement_layers_from_json(const std::string &text,
|
||||
std::vector<TextureDisplacementLayer> &layers,
|
||||
TextureDisplacementOptions &options);
|
||||
|
||||
@@ -673,14 +673,14 @@ static bool repair_cluster_smooth(
|
||||
[&]() { return cancelled(); }, &repair_error);
|
||||
if (repaired) {
|
||||
if (cancelled()) return false;
|
||||
BOOST_LOG_TRIVIAL(info) << log_prefix << ": mesh repair finished.";
|
||||
BOOST_LOG_TRIVIAL(info) << log_prefix << ": Windows 3D mesh repair finished.";
|
||||
if (!resample_face_colors(TriMesh(std::move(repaired_its))))
|
||||
return false;
|
||||
} else {
|
||||
BOOST_LOG_TRIVIAL(warning) << log_prefix << ": mesh repair failed: " << repair_error;
|
||||
BOOST_LOG_TRIVIAL(warning) << log_prefix << ": Windows 3D mesh repair failed: " << repair_error;
|
||||
}
|
||||
} else {
|
||||
BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without repair.";
|
||||
BOOST_LOG_TRIVIAL(info) << log_prefix << ": importing mesh without Windows 3D repair.";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#pragma once
|
||||
#ifndef libslic3r_Timer_hpp_
|
||||
#define libslic3r_Timer_hpp_
|
||||
|
||||
#include "TriangleMesh.hpp"
|
||||
|
||||
@@ -9,3 +10,5 @@ public:
|
||||
static TriangleMesh smooth_triangle_mesh(const TriangleMesh &mesh,bool& ok);
|
||||
};
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif // libslic3r_Timer_hpp_
|
||||
|
||||
@@ -109,6 +109,7 @@ extern std::string format_memsize_MB(size_t n);
|
||||
extern std::string format_memsize(size_t bytes, unsigned int decimals = 1);
|
||||
// Return string to be added to the boost::log output to inform about the current process memory allocation.
|
||||
// The string is non-empty if the loglevel >= info (3) or ignore_loglevel==true.
|
||||
// Latter is used to get the memory info from SysInfoDialog.
|
||||
extern std::string log_memory_info(bool ignore_loglevel = false);
|
||||
extern void disable_multi_threading();
|
||||
// Returns the size of physical memory (RAM) in bytes.
|
||||
|
||||
@@ -1744,7 +1744,9 @@ std::string format_diameter_to_str(double diameter, int precision)
|
||||
return oss.str();
|
||||
}
|
||||
|
||||
// Returns platform-specific string to be used as log output.
|
||||
// Returns platform-specific string to be used as log output or parsed in SysInfoDialog.
|
||||
// The latter parses the string with (semi)colons as separators, it should look about as
|
||||
// "desc1: value1; desc2: value2" or similar (spaces should not matter).
|
||||
std::string log_memory_info(bool ignore_loglevel)
|
||||
{
|
||||
std::string out;
|
||||
|
||||
@@ -21,9 +21,7 @@ namespace libvgcode {
|
||||
// the triangles that share it: the shader runs 8 times per segment instead of 24.
|
||||
static constexpr const std::array<uint8_t, 8> VERTEX_DATA = { 0, 1, 2, 3, 4, 5, 6, 7 };
|
||||
|
||||
// 16-bit indices: GCN 1/2 GPUs have no 8-bit index support, and some of their drivers
|
||||
// emulate it wrongly in instanced draws.
|
||||
static constexpr const std::array<uint16_t, 24> INDEX_DATA = {
|
||||
static constexpr const std::array<uint8_t, 24> INDEX_DATA = {
|
||||
0, 1, 2, // front spike
|
||||
0, 2, 3, // front spike
|
||||
0, 3, 4, // right/bottom body
|
||||
@@ -39,7 +37,7 @@ void SegmentTemplate::init()
|
||||
if (m_vao_id != 0)
|
||||
return;
|
||||
|
||||
m_size_in_bytes_gpu += VERTEX_DATA.size() * sizeof(uint8_t) + INDEX_DATA.size() * sizeof(uint16_t);
|
||||
m_size_in_bytes_gpu += (VERTEX_DATA.size() + INDEX_DATA.size()) * sizeof(uint8_t);
|
||||
|
||||
int curr_vertex_array;
|
||||
glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
|
||||
@@ -63,7 +61,7 @@ void SegmentTemplate::init()
|
||||
// and restored together with the vao.
|
||||
glsafe(glGenBuffers(1, &m_ibo_id));
|
||||
glsafe(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo_id));
|
||||
glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint16_t), INDEX_DATA.data(), GL_STATIC_DRAW));
|
||||
glsafe(glBufferData(GL_ELEMENT_ARRAY_BUFFER, INDEX_DATA.size() * sizeof(uint8_t), INDEX_DATA.data(), GL_STATIC_DRAW));
|
||||
|
||||
glsafe(glBindBuffer(GL_ARRAY_BUFFER, curr_array_buffer));
|
||||
glsafe(glBindVertexArray(curr_vertex_array));
|
||||
@@ -96,7 +94,7 @@ void SegmentTemplate::render(size_t count)
|
||||
glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
|
||||
|
||||
glsafe(glBindVertexArray(m_vao_id));
|
||||
glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_SHORT,
|
||||
glsafe(glDrawElementsInstanced(GL_TRIANGLES, static_cast<GLsizei>(INDEX_DATA.size()), GL_UNSIGNED_BYTE,
|
||||
nullptr, static_cast<GLsizei>(count)));
|
||||
glsafe(glBindVertexArray(curr_vertex_array));
|
||||
}
|
||||
|
||||
@@ -927,17 +927,15 @@ void ViewerImpl::reset()
|
||||
m_used_extruders.clear();
|
||||
m_total_time = { 0.0f, 0.0f };
|
||||
m_travels_time = { 0.0f, 0.0f };
|
||||
m_vertices.clear();
|
||||
m_vertices_colors.clear();
|
||||
// swap rather than clear: these are sized by the print, and a reset means the memory
|
||||
// should go back, not sit reserved until the next load
|
||||
std::vector<PathVertex>().swap(m_vertices);
|
||||
std::vector<float>().swap(m_vertices_colors);
|
||||
for (std::vector<float>& times : m_layer_start_times)
|
||||
std::vector<float>().swap(times);
|
||||
std::vector<uint32_t>().swap(m_layer_first_vertex);
|
||||
m_layers_in_vertex_order = false;
|
||||
// BitSet::clear() only zeroes the bits, it keeps the blocks allocated; load() builds a new
|
||||
// bitset anyway and it is never read while m_vertices is empty
|
||||
m_valid_lines_bitset = BitSet<>();
|
||||
m_valid_lines_bitset.clear();
|
||||
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
|
||||
m_cog_marker.reset();
|
||||
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
|
||||
@@ -1836,7 +1834,6 @@ size_t ViewerImpl::get_used_cpu_memory() const
|
||||
ret += sizeof(m_extrusion_roles_colors);
|
||||
ret += sizeof(m_options_colors);
|
||||
ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
|
||||
ret += STDVEC_MEMSIZE(m_vertices_colors, float);
|
||||
for (const std::vector<float>& times : m_layer_start_times)
|
||||
ret += STDVEC_MEMSIZE(times, float);
|
||||
ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);
|
||||
|
||||
@@ -416,6 +416,8 @@ set(SLIC3R_GUI_SOURCES
|
||||
GUI/MultiSendMachineModel.hpp
|
||||
GUI/MultiTaskManagerPage.cpp
|
||||
GUI/MultiTaskManagerPage.hpp
|
||||
GUI/MultiTaskModel.cpp
|
||||
GUI/MultiTaskModel.hpp
|
||||
GUI/NetworkTestDialog.cpp
|
||||
GUI/NetworkTestDialog.hpp
|
||||
GUI/Notebook.cpp
|
||||
@@ -800,6 +802,7 @@ set(SLIC3R_GUI_SOURCES
|
||||
Utils/PrintHost.hpp
|
||||
Utils/Process.cpp
|
||||
Utils/Process.hpp
|
||||
Utils/Profile.hpp
|
||||
Utils/RaycastManager.cpp
|
||||
Utils/RaycastManager.hpp
|
||||
Utils/Repetier.cpp
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#pragma once
|
||||
#ifndef slic3r_GUI_SingleChoice_hpp_
|
||||
#define slic3r_GUI_SingleChoice_hpp_
|
||||
|
||||
#include "GUI_Utils.hpp"
|
||||
#include "Plater.hpp"
|
||||
@@ -32,3 +33,5 @@ private:
|
||||
|
||||
};
|
||||
}} // namespace Slic3r::GUI
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,19 @@
|
||||
#include <exception>
|
||||
#include <stdexcept>
|
||||
|
||||
#include "libslic3r/Exception.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
class ConfigError : public Slic3r::RuntimeError {
|
||||
using Slic3r::RuntimeError::RuntimeError;
|
||||
};
|
||||
|
||||
namespace GUI {
|
||||
|
||||
class ConfigGUITypeError : public ConfigError {
|
||||
using ConfigError::ConfigError;
|
||||
};
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
@@ -1105,10 +1105,6 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, in
|
||||
toggle_field("support_filament", have_support_material || have_skirt);
|
||||
|
||||
toggle_line("raft_contact_distance", have_raft && !have_support_soluble);
|
||||
// Orca:Hide raft expansion when raft is not enabled
|
||||
toggle_line("raft_expansion", have_raft);
|
||||
// Orca: Slim, Strong and Hybrid tree supports size their raft by first layer expansion only.
|
||||
toggle_field("raft_expansion", !(is_tree(support_type) && (support_style == smsTreeSlim || support_style == smsTreeStrong || support_style == smsTreeHybrid)));
|
||||
|
||||
// Orca: First-layer density is available for supports broadly.
|
||||
toggle_field("raft_first_layer_density", have_support_material);
|
||||
|
||||
@@ -1514,8 +1514,6 @@ wxDEFINE_EVENT(EVT_GLCANVAS_PRINTABLE, SimpleEvent);
|
||||
const double GLCanvas3D::DefaultCameraZoomToBoxMarginFactor = 1.25;
|
||||
const double GLCanvas3D::DefaultCameraZoomToBedMarginFactor = 2.00;
|
||||
const double GLCanvas3D::DefaultCameraZoomToPlateMarginFactor = 1.25;
|
||||
// Main-thread only: _render_frame never runs off it, so no atomic is needed.
|
||||
int GLCanvas3D::s_frames_in_progress = 0;
|
||||
|
||||
void GLCanvas3D::load_arrange_settings()
|
||||
{
|
||||
@@ -2470,8 +2468,7 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
|
||||
}
|
||||
|
||||
m_in_render = true;
|
||||
++s_frames_in_progress;
|
||||
Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; --s_frames_in_progress; });
|
||||
Slic3r::ScopeGuard in_render_guard([this]() { m_in_render = false; });
|
||||
(void)in_render_guard;
|
||||
|
||||
if (m_canvas == nullptr)
|
||||
@@ -2716,31 +2713,15 @@ void GLCanvas3D::_render_frame(bool scene_dirty, bool only_init)
|
||||
|
||||
// On Wayland, eglSwapBuffers blocks when the canvas is hidden or
|
||||
// occluded. Skip the swap to avoid stalling the render loop.
|
||||
// Code run from inside this frame - a modal dialog a gizmo opened from its ImGui panel, a
|
||||
// synchronous paint of another canvas - may have made a different surface current. Bind this one
|
||||
// again before presenting, so the swap is not issued against a window the context no longer
|
||||
// belongs to: on Mesa/X11 that is a fatal BadMatch, not the no-op it is on other platforms. Draws
|
||||
// already issued before this point cannot be redirected - only this swap is protected.
|
||||
if (m_canvas->IsShownOnScreen() && _set_current()) {
|
||||
if (m_canvas->IsShownOnScreen()) {
|
||||
m_canvas->SwapBuffers();
|
||||
m_frame_profiler.mark("swap");
|
||||
if (!overlay_tick)
|
||||
m_render_stats.increment_fps_counter();
|
||||
m_presented_signature = signature;
|
||||
}
|
||||
else {
|
||||
if (m_canvas->IsShownOnScreen()) {
|
||||
// Logged once: if the rebind fails it does so every frame, and a warning per frame would
|
||||
// bury everything else.
|
||||
static bool rebind_failure_logged = false;
|
||||
if (!rebind_failure_logged) {
|
||||
rebind_failure_logged = true;
|
||||
BOOST_LOG_TRIVIAL(warning) << "GLCanvas3D: could not rebind the GL context to this canvas before "
|
||||
"SwapBuffers(); the frame is not presented";
|
||||
}
|
||||
}
|
||||
else
|
||||
m_presented_signature.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// Everything drawn into the 3D scene, from the clear to the post processing passes, ending in the
|
||||
|
||||
@@ -643,8 +643,6 @@ private:
|
||||
#endif
|
||||
unsigned int m_last_w, m_last_h;
|
||||
bool m_in_render;
|
||||
// How many canvases are inside _render_frame() right now - see is_frame_in_progress().
|
||||
static int s_frames_in_progress;
|
||||
wxTimer m_timer;
|
||||
wxTimer m_timer_set_color;
|
||||
// Armed by each frame that draws the FPS overlay; its tick requests an overlay-only frame.
|
||||
@@ -976,11 +974,6 @@ public:
|
||||
void on_change_color_mode(bool is_dark, bool reinit = true);
|
||||
const bool get_dark_mode_status() { return m_is_dark; }
|
||||
void set_as_dirty() { m_dirty = true; }
|
||||
// True while any GLCanvas3D is inside _render_frame(). The other surfaces that share the app's one
|
||||
// GL context (the UV editor canvas) check this before making themselves current: a frame interrupted
|
||||
// by another surface finishes drawing into that surface and then presents a window the context no
|
||||
// longer belongs to, which on Mesa/X11 is a fatal X error (BadMatch) rather than a no-op.
|
||||
static bool is_frame_in_progress() { return s_frames_in_progress > 0; }
|
||||
void requires_check_outside_state() { m_requires_check_outside_state = true; }
|
||||
|
||||
unsigned int get_volumes_count() const { return (unsigned int)m_volumes.volumes.size(); }
|
||||
|
||||
@@ -719,6 +719,9 @@ void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right,
|
||||
// does not treat anti-aliased icon edges as window transparency.
|
||||
glsafe(::glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
|
||||
|
||||
glsafe(::glEnable(GL_TEXTURE_2D));
|
||||
glsafe(::glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE));
|
||||
|
||||
glsafe(::glBindTexture(GL_TEXTURE_2D, (GLuint)tex_id));
|
||||
|
||||
GLModel::Geometry init_data;
|
||||
@@ -750,6 +753,7 @@ void GLTexture::render_sub_texture(unsigned int tex_id, float left, float right,
|
||||
|
||||
glsafe(::glBindTexture(GL_TEXTURE_2D, 0));
|
||||
|
||||
glsafe(::glDisable(GL_TEXTURE_2D));
|
||||
glsafe(::glDisable(GL_BLEND));
|
||||
}
|
||||
|
||||
|
||||
@@ -3232,16 +3232,9 @@ bool GUI_App::on_init_inner()
|
||||
#ifdef _MSW_DARK_MODE
|
||||
|
||||
#ifndef __WINDOWS__
|
||||
// The label colours and the dark mode flag were set above from the saved mode. When the system theme
|
||||
// differs from it, refresh them, or dialogs that map their colours stay in the old mode for this session.
|
||||
const bool saved_dark_mode = dark_mode();
|
||||
wxSystemAppearance app = wxSystemSettings::GetAppearance();
|
||||
GUI::wxGetApp().app_config->set("dark_color_mode", app.IsDark() ? "1" : "0");
|
||||
GUI::wxGetApp().app_config->save();
|
||||
if (dark_mode() != saved_dark_mode) {
|
||||
init_label_colours();
|
||||
Update_dark_mode_flag();
|
||||
}
|
||||
#endif // __APPLE__
|
||||
|
||||
|
||||
@@ -4862,6 +4855,12 @@ void GUI_App::recreate_GUI(const wxString &msg_name)
|
||||
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "recreate_GUI exit";
|
||||
}
|
||||
|
||||
void GUI_App::system_info()
|
||||
{
|
||||
//SysInfoDialog dlg;
|
||||
//dlg.ShowModal();
|
||||
}
|
||||
|
||||
void GUI_App::keyboard_shortcuts(ShortcutContext page, wxWindow* parent)
|
||||
{
|
||||
KBShortcutsDialog dlg(parent != nullptr ? parent : mainframe, page);
|
||||
|
||||
@@ -519,6 +519,7 @@ public:
|
||||
void check_printer_presets();
|
||||
|
||||
void recreate_GUI(const wxString& message);
|
||||
void system_info();
|
||||
void keyboard_shortcuts(ShortcutContext page, wxWindow* parent = nullptr); // the main frame when null
|
||||
void troubleshoot();
|
||||
void load_project(wxWindow *parent, wxString& input_file) const;
|
||||
|
||||
@@ -1952,16 +1952,6 @@ void MenuFactory::create_plate_menu()
|
||||
},
|
||||
"", nullptr, []() { return !plater()->get_partplate_list().get_selected_plate()->get_objects().empty(); }, m_parent);
|
||||
|
||||
// fix objects on current plate
|
||||
append_menu_item(menu, wxID_ANY, _L("Fix All"), _L("Fix all models on the current plate"),
|
||||
[](wxCommandEvent&) { obj_list()->fix_all_through_cgal(false); }, "", nullptr,
|
||||
[]() { return !plater()->get_partplate_list().get_selected_plate()->empty(); }, m_parent);
|
||||
|
||||
// fix objects on all plates
|
||||
append_menu_item(menu, wxID_ANY, _L("Fix All Plates"), _L("Fix all models on all plates"),
|
||||
[](wxCommandEvent&) { obj_list()->fix_all_through_cgal(true); }, "", nullptr,
|
||||
[]() { return !plater()->model().objects.empty(); }, m_parent);
|
||||
|
||||
// orient objects on current plate
|
||||
append_menu_item(menu, wxID_ANY, _L("Auto Rotate"), _L("Auto rotate current plate"),
|
||||
[](wxCommandEvent&) {
|
||||
|
||||
@@ -6297,44 +6297,30 @@ void ObjectList::rename_item()
|
||||
}
|
||||
|
||||
void ObjectList::fix_through_cgal()
|
||||
{
|
||||
std::vector<int> obj_idxs, vol_idxs;
|
||||
get_selection_indexes(obj_idxs, vol_idxs);
|
||||
fix_through_cgal(obj_idxs, vol_idxs);
|
||||
}
|
||||
|
||||
void ObjectList::fix_all_through_cgal(bool all_plates)
|
||||
{
|
||||
std::vector<int> obj_idxs;
|
||||
if (all_plates) {
|
||||
for (int obj_idx = 0; obj_idx < int(m_objects->size()); ++obj_idx)
|
||||
obj_idxs.push_back(obj_idx);
|
||||
} else {
|
||||
for (const ModelObject *mo : wxGetApp().plater()->get_partplate_list().get_selected_plate()->get_objects_on_this_plate())
|
||||
obj_idxs.push_back(int(std::find(m_objects->begin(), m_objects->end(), mo) - m_objects->begin()));
|
||||
std::sort(obj_idxs.begin(), obj_idxs.end());
|
||||
obj_idxs.erase(std::unique(obj_idxs.begin(), obj_idxs.end()), obj_idxs.end());
|
||||
}
|
||||
fix_through_cgal(obj_idxs, {});
|
||||
}
|
||||
|
||||
void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::vector<int> &vol_idxs)
|
||||
{
|
||||
// Do not fix anything when a gizmo is open. There might be issues with updates
|
||||
// and what is worse, the snapshot time would refer to the internal stack.
|
||||
if (obj_idxs.empty() || !wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
|
||||
if (!wxGetApp().plater()->get_view3D_canvas3D()->get_gizmos_manager().check_gizmos_closed_except(GLGizmosManager::Undefined))
|
||||
return;
|
||||
|
||||
// model_name
|
||||
std::vector<std::string> succes_models;
|
||||
// model_name failing reason
|
||||
std::vector<std::pair<std::string, std::string>> failed_models;
|
||||
size_t unchanged_models = 0;
|
||||
bool painting_removed = false;
|
||||
|
||||
std::vector<int> obj_idxs, vol_idxs;
|
||||
get_selection_indexes(obj_idxs, vol_idxs);
|
||||
|
||||
std::vector<std::string> model_names;
|
||||
|
||||
// clear selections from the non-broken models if any exists
|
||||
// and than fill names of models to repairing
|
||||
if (vol_idxs.empty()) {
|
||||
#if !FIX_THROUGH_CGAL_ALWAYS
|
||||
for (int i = int(obj_idxs.size())-1; i >= 0; --i)
|
||||
if (object(obj_idxs[i])->get_repaired_errors_count() == 0)
|
||||
obj_idxs.erase(obj_idxs.begin()+i);
|
||||
#endif // FIX_THROUGH_CGAL_ALWAYS
|
||||
for (int obj_idx : obj_idxs)
|
||||
if (object(obj_idx))
|
||||
model_names.push_back(object(obj_idx)->name);
|
||||
@@ -6342,26 +6328,31 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
|
||||
else {
|
||||
ModelObject* obj = object(obj_idxs.front());
|
||||
if (obj) {
|
||||
#if !FIX_THROUGH_CGAL_ALWAYS
|
||||
for (int i = int(vol_idxs.size()) - 1; i >= 0; --i)
|
||||
if (obj->get_repaired_errors_count(vol_idxs[i]) == 0)
|
||||
vol_idxs.erase(vol_idxs.begin() + i);
|
||||
#endif // FIX_THROUGH_CGAL_ALWAYS
|
||||
for (int vol_idx : vol_idxs)
|
||||
model_names.push_back(obj->volumes[vol_idx]->name);
|
||||
}
|
||||
}
|
||||
|
||||
auto plater = wxGetApp().plater();
|
||||
const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
|
||||
|
||||
auto fix_and_update_progress = [&](const int obj_idx, const int vol_idx, int model_idx, ProgressDialog& progress_dlg)
|
||||
auto fix_and_update_progress = [this, plater, model_names](const int obj_idx, const int vol_idx,
|
||||
int model_idx,
|
||||
ProgressDialog& progress_dlg,
|
||||
std::vector<std::string>& succes_models,
|
||||
std::vector<std::pair<std::string, std::string>>& failed_models)
|
||||
{
|
||||
ModelObject *mo = object(obj_idx);
|
||||
if (!mo)
|
||||
if (!object(obj_idx))
|
||||
return false;
|
||||
|
||||
const std::string& model_name = model_names[model_idx];
|
||||
wxString msg = _L("Repairing model object");
|
||||
if (model_names.size() == 1)
|
||||
msg += ": " + from_u8(model_name) + "\n";
|
||||
else if (model_names.size() > 10)
|
||||
msg += ": " + from_u8(model_name) + wxString::Format(" (%d/%d)", model_idx + 1, int(model_names.size())) + "\n";
|
||||
else {
|
||||
msg += ":\n";
|
||||
for (int i = 0; i < int(model_names.size()); ++i)
|
||||
@@ -6369,29 +6360,33 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
|
||||
msg += "\n";
|
||||
}
|
||||
|
||||
auto count_painted = [mo]() { return std::count_if(mo->volumes.begin(), mo->volumes.end(), [](const ModelVolume *mv) { return mv->is_any_painted(); }); };
|
||||
const auto painted_before = count_painted();
|
||||
std::string res;
|
||||
bool modified = false;
|
||||
if (!fix_model_with_cgal_gui(*mo, vol_idx, progress_dlg, msg, res, keep_painting, &modified))
|
||||
return false;
|
||||
|
||||
if (modified) {
|
||||
painting_removed = painting_removed || count_painted() < painted_before;
|
||||
mo->ensure_on_bed();
|
||||
plater->changed_mesh(obj_idx);
|
||||
plater->get_partplate_list().notify_instance_update(obj_idx, 0);
|
||||
plater->sidebar().obj_list()->update_plate_values_for_items();
|
||||
update_item_error_icon(obj_idx, vol_idx);
|
||||
update_info_items(obj_idx);
|
||||
const bool keep_painting = GUI::wxGetApp().app_config->get_bool("keep_painting");
|
||||
if (!keep_painting) {
|
||||
plater->clear_before_change_mesh(obj_idx);
|
||||
}
|
||||
const size_t volumes_before = object(obj_idx)->volumes.size();
|
||||
std::string res;
|
||||
if (!fix_model_with_cgal_gui(*(object(obj_idx)), vol_idx, progress_dlg, msg, res, keep_painting))
|
||||
return false;
|
||||
//wxGetApp().plater()->changed_mesh(obj_idx);
|
||||
object(obj_idx)->ensure_on_bed();
|
||||
plater->changed_mesh(obj_idx);
|
||||
|
||||
if (!res.empty())
|
||||
failed_models.push_back({ model_name, res });
|
||||
else if (modified)
|
||||
const size_t volumes_after = object(obj_idx)->volumes.size();
|
||||
if (volumes_after != volumes_before)
|
||||
add_volumes_to_object_in_list(obj_idx);
|
||||
|
||||
plater->get_partplate_list().notify_instance_update(obj_idx, 0);
|
||||
plater->sidebar().obj_list()->update_plate_values_for_items();
|
||||
|
||||
if (res.empty())
|
||||
succes_models.push_back(model_name);
|
||||
else
|
||||
++unchanged_models;
|
||||
failed_models.push_back({ model_name, res });
|
||||
|
||||
update_item_error_icon(obj_idx, vol_idx);
|
||||
update_info_items(obj_idx);
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
@@ -6404,7 +6399,11 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
|
||||
if (vol_idxs.empty()) {
|
||||
int vol_idx{ -1 };
|
||||
for (int obj_idx : obj_idxs) {
|
||||
if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
|
||||
#if !FIX_THROUGH_CGAL_ALWAYS
|
||||
if (object(obj_idx)->get_repaired_errors_count(vol_idx) == 0)
|
||||
continue;
|
||||
#endif // FIX_THROUGH_CGAL_ALWAYS
|
||||
if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg, succes_models, failed_models))
|
||||
break;
|
||||
model_idx++;
|
||||
}
|
||||
@@ -6412,7 +6411,7 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
|
||||
else {
|
||||
int obj_idx{ obj_idxs.front() };
|
||||
for (int vol_idx : vol_idxs) {
|
||||
if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg))
|
||||
if (!fix_and_update_progress(obj_idx, vol_idx, model_idx, progress_dlg, succes_models, failed_models))
|
||||
break;
|
||||
model_idx++;
|
||||
}
|
||||
@@ -6420,29 +6419,20 @@ void ObjectList::fix_through_cgal(const std::vector<int> &obj_idxs, const std::v
|
||||
// Close the progress dialog
|
||||
progress_dlg.Update(100, "");
|
||||
|
||||
if (painting_removed)
|
||||
plater->notify_painting_removed();
|
||||
|
||||
// Show info notification
|
||||
std::vector<wxString> blocks;
|
||||
wxString msg;
|
||||
wxString bullet_suf = "\n - ";
|
||||
if (!succes_models.empty()) {
|
||||
wxString block = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
|
||||
msg = _L_PLURAL("The following model object has been repaired", "The following model objects have been repaired", succes_models.size()) + ":";
|
||||
for (auto& model : succes_models)
|
||||
block += bullet_suf + from_u8(model);
|
||||
blocks.push_back(block);
|
||||
msg += bullet_suf + from_u8(model);
|
||||
msg += "\n\n";
|
||||
}
|
||||
if (!failed_models.empty()) {
|
||||
wxString block = _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":";
|
||||
msg += _L_PLURAL("Failed to repair the following model object", "Failed to repair the following model objects", failed_models.size()) + ":\n";
|
||||
for (auto& model : failed_models)
|
||||
block += bullet_suf + from_u8(model.first) + ": " + _(model.second);
|
||||
blocks.push_back(block);
|
||||
msg += bullet_suf + from_u8(model.first) + ": " + _(model.second);
|
||||
}
|
||||
if (unchanged_models > 0)
|
||||
blocks.push_back(format_wxstr(_L_PLURAL("%1$d model object needed no repair.", "%1$d model objects needed no repair.", unchanged_models), unchanged_models));
|
||||
wxString msg;
|
||||
for (const wxString &block : blocks)
|
||||
msg += (msg.IsEmpty() ? "" : "\n\n") + block;
|
||||
if (msg.IsEmpty())
|
||||
msg = _L("Repairing was canceled");
|
||||
plater->get_notification_manager()->push_notification(NotificationType::CgalFinished, NotificationManager::NotificationLevel::PrintInfoShortNotificationLevel, into_u8(msg));
|
||||
|
||||
@@ -47,6 +47,9 @@ typedef double coordf_t;
|
||||
typedef std::pair<coordf_t, coordf_t> t_layer_height_range;
|
||||
typedef std::map<t_layer_height_range, ModelConfig> t_layer_config_ranges;
|
||||
|
||||
// Manifold mesh may contain self-intersections, so we want to always allow fixing the mesh.
|
||||
#define FIX_THROUGH_CGAL_ALWAYS 1
|
||||
|
||||
namespace GUI {
|
||||
|
||||
enum class Shortcut : uint8_t;
|
||||
@@ -460,9 +463,6 @@ public:
|
||||
void split_instances();
|
||||
void rename_item();
|
||||
void fix_through_cgal();
|
||||
// Fixes every object on the selected plate, or on all plates.
|
||||
void fix_all_through_cgal(bool all_plates);
|
||||
void fix_through_cgal(const std::vector<int> &obj_idxs, const std::vector<int> &vol_idxs);
|
||||
void simplify();
|
||||
void smooth_mesh();
|
||||
void update_item_error_icon(const int obj_idx, int vol_idx) const ;
|
||||
|
||||
@@ -1036,11 +1036,6 @@ bool GLGizmoPainterBase::on_mouse(const wxMouseEvent &mouse_event)
|
||||
Vec2d mouse_pos = mouse_coord.cast<double>();
|
||||
|
||||
if (mouse_event.Moving()) {
|
||||
// No button is down, yet a stroke is still open: its release went elsewhere, as a paint drag does not
|
||||
// capture the mouse. End the stroke as that release would have.
|
||||
if (m_button_down != Button::None)
|
||||
gizmo_event(m_button_down == Button::Left ? SLAGizmoEventType::LeftUp : SLAGizmoEventType::RightUp, mouse_pos,
|
||||
mouse_event.ShiftDown(), mouse_event.AltDown(), false);
|
||||
gizmo_event(SLAGizmoEventType::Moving, mouse_pos, mouse_event.ShiftDown(), mouse_event.AltDown(), false);
|
||||
return false;
|
||||
}
|
||||
@@ -1210,10 +1205,6 @@ void GLGizmoPainterBase::on_set_state()
|
||||
m_old_mo_id = -1;
|
||||
//m_iva.release_geometry();
|
||||
m_triangle_selectors.clear();
|
||||
// A stroke still open goes with the selectors. Its state must not carry into the next session, where the
|
||||
// first move would end it as if released and the first press would paint a line from its last position.
|
||||
m_button_down = Button::None;
|
||||
m_last_mouse_click = Vec2d::Zero();
|
||||
|
||||
//Camera& camera = wxGetApp().plater()->get_camera();
|
||||
//camera.look_at(camera.get_position(), m_previous_target, Vec3d::UnitZ());
|
||||
|
||||
@@ -494,17 +494,7 @@ bool GLGizmoTextureDisplacement::on_init()
|
||||
{ctrl + _L("Mouse wheel"), m_desc["gap_area"]},
|
||||
toggle_wireframe_shortcut
|
||||
};
|
||||
|
||||
// Both ways into the same input box on any slider in the panel: ImGui turns a slider into one when
|
||||
// it is Ctrl+clicked or when it is given the keyboard focus, which is what the edit icon asks for.
|
||||
m_desc["type_value"] = _L("Type an exact value into a slider");
|
||||
m_shortcuts_sliders = {
|
||||
{ctrl + _L("Left mouse button"), m_desc["type_value"]},
|
||||
{_L("Edit icon at a slider's right end"), m_desc["type_value"]},
|
||||
};
|
||||
for (std::vector<std::pair<wxString, wxString>> *list : {&m_shortcuts_brush, &m_shortcuts_bucket_fill, &m_shortcuts_gap_fill})
|
||||
list->insert(list->end(), m_shortcuts_sliders.begin(), m_shortcuts_sliders.end());
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -562,11 +552,6 @@ void GLGizmoTextureDisplacement::on_shutdown()
|
||||
m_shaded_island_delta = Eigen::Matrix<float, 2, 3>::Identity();
|
||||
m_island_drag_active = false;
|
||||
m_island_move_set.clear();
|
||||
// The pane closes below, taking the highlight with it, and the view must not open the next session in a
|
||||
// Fast the user never picked. Set directly: nothing is to be queued against a gizmo that is closing.
|
||||
if (m_island_view.switched)
|
||||
m_use_shaded_preview = false;
|
||||
m_island_view = IslandViewFollow{};
|
||||
m_adjust_texture_mode = false;
|
||||
m_seam_edit_mode = false;
|
||||
m_adjust_drag_handle = AdjustHandle::None;
|
||||
@@ -732,13 +717,18 @@ void GLGizmoTextureDisplacement::render_painter_gizmo()
|
||||
|
||||
// The UV editor's island selection, shown on the model. Polled here rather than pushed: the pane
|
||||
// changes its selection in its own mouse handling, and a compare of a few ints per frame is free.
|
||||
if (const std::vector<int> *islands = island_highlight_selection()) {
|
||||
if (*islands != m_island_overlay_selection)
|
||||
rebuild_island_overlay(*islands);
|
||||
render_island_overlay();
|
||||
} else if (m_island_overlay_glmodel.is_initialized()) {
|
||||
m_island_overlay_glmodel.reset();
|
||||
m_island_overlay_selection.clear();
|
||||
{
|
||||
const TextureDisplacementLayer *al = active_layer();
|
||||
const UVEditorCanvas *uv_canvas = wxGetApp().plater()->get_uv_editor_canvas();
|
||||
if (m_show_uv_editor && al != nullptr && al->projection_method == TextureProjectionMethod::LSCM &&
|
||||
uv_canvas != nullptr && !m_uv_editor_unwrap.empty()) {
|
||||
if (uv_canvas->selected_islands() != m_island_overlay_selection)
|
||||
rebuild_island_overlay(uv_canvas->selected_islands());
|
||||
render_island_overlay();
|
||||
} else if (m_island_overlay_glmodel.is_initialized()) {
|
||||
m_island_overlay_glmodel.reset();
|
||||
m_island_overlay_selection.clear();
|
||||
}
|
||||
}
|
||||
|
||||
// Diagnostic overlays, drawn on top of whatever preview is active (both pull toward the camera
|
||||
@@ -1520,7 +1510,7 @@ void GLGizmoTextureDisplacement::render_shaded_preview_mesh()
|
||||
// is box-filtered down to 128 px for a ~48 px row, and feeding it to the shader cost the preview
|
||||
// three quarters of the height map's detail - and, since height_tex_texel is derived from it, also
|
||||
// flattened the shading gradient and made the parallax march skip itself at angles where it should
|
||||
// run. Cached per image_data and smoothing, so no PNG is decoded per frame.
|
||||
// run. Cached on the image_data pointer + smoothing, so no PNG is decoded per frame.
|
||||
GLTexture *tex = get_layer_height_texture(*layer);
|
||||
if (tex == nullptr || tex->get_width() <= 0 || tex->get_height() <= 0)
|
||||
return;
|
||||
@@ -1926,16 +1916,6 @@ void GLGizmoTextureDisplacement::render_paint_overlay(GLModel &overlay)
|
||||
shader->stop_using();
|
||||
}
|
||||
|
||||
const std::vector<int> *GLGizmoTextureDisplacement::island_highlight_selection()
|
||||
{
|
||||
const TextureDisplacementLayer *al = active_layer();
|
||||
const UVEditorCanvas *uv_canvas = wxGetApp().plater()->get_uv_editor_canvas();
|
||||
if (m_show_uv_editor && al != nullptr && al->projection_method == TextureProjectionMethod::LSCM &&
|
||||
uv_canvas != nullptr && !m_uv_editor_unwrap.empty())
|
||||
return &uv_canvas->selected_islands();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void GLGizmoTextureDisplacement::rebuild_island_overlay(const std::vector<int> &selection)
|
||||
{
|
||||
m_island_overlay_glmodel.reset();
|
||||
@@ -2661,37 +2641,6 @@ void GLGizmoTextureDisplacement::apply_view_mode(int mode)
|
||||
m_parent.set_as_dirty();
|
||||
}
|
||||
|
||||
int GLGizmoTextureDisplacement::view_mode() const
|
||||
{
|
||||
return m_use_shaded_preview ? 1 :
|
||||
m_uv_check_mode == UVCheckMode::Checker ? 2 :
|
||||
m_uv_check_mode == UVCheckMode::Distortion ? 3 : 0;
|
||||
}
|
||||
|
||||
int GLGizmoTextureDisplacement::IslandViewFollow::step(bool shown_now, int view, bool debug_open)
|
||||
{
|
||||
shown = shown_now;
|
||||
if (!shown) {
|
||||
// The view is back to Normal already if a debug stage took it, and Normal applied over a stage would
|
||||
// queue a preview job that replaces the stage being inspected.
|
||||
const bool restore = switched && view == 1;
|
||||
switched = keep_normal = false;
|
||||
return restore ? 0 : -1;
|
||||
}
|
||||
if (view != 0 || keep_normal || debug_open)
|
||||
return -1;
|
||||
switched = true;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void GLGizmoTextureDisplacement::follow_island_highlight()
|
||||
{
|
||||
const std::vector<int> *islands = island_highlight_selection();
|
||||
const int view = m_island_view.step(islands != nullptr && !islands->empty(), view_mode(), m_debug_stage >= 0);
|
||||
if (view >= 0)
|
||||
apply_view_mode(view);
|
||||
}
|
||||
|
||||
void GLGizmoTextureDisplacement::push_uv_pane_state()
|
||||
{
|
||||
UVEditorCanvas *canvas = wxGetApp().plater()->get_uv_editor_canvas();
|
||||
@@ -2932,8 +2881,7 @@ void GLGizmoTextureDisplacement::run_uv_command(int cmd, float value)
|
||||
rebuild_preview();
|
||||
}
|
||||
}
|
||||
// FrameAll/ToggleSnap are handled inside the canvas; ProjectFromView is not wired yet. SelectionChanged
|
||||
// only asks for this frame: follow_island_highlight() and the overlay read the selection back themselves.
|
||||
// FrameAll/ToggleSnap are handled inside the canvas; ProjectFromView is not wired yet.
|
||||
m_parent.set_as_dirty();
|
||||
}
|
||||
|
||||
@@ -3760,8 +3708,6 @@ void GLGizmoTextureDisplacement::ensure_panel_icons()
|
||||
"texture_displacement_adjust.svg", "canvas_drag.svg", "texture_displacement_move_up.svg",
|
||||
"texture_displacement_move_down.svg", "texture_displacement_drag.svg",
|
||||
"texture_displacement_select_all.svg", "texture_displacement_erase_all.svg",
|
||||
// The "type a value instead" icon at the right end of every slider.
|
||||
"edit.svg",
|
||||
};
|
||||
std::vector<std::string> paths;
|
||||
paths.reserve(names.size());
|
||||
@@ -4080,8 +4026,8 @@ void GLGizmoTextureDisplacement::remove_texture_layer(int slot)
|
||||
if (slot >= 0 && slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS)) {
|
||||
mv->texture_displacement_facet(slot).reset();
|
||||
m_thumbnails[size_t(slot)].reset();
|
||||
m_thumbnail_source[size_t(slot)].reset();
|
||||
m_layer_expanded[size_t(slot)] = false;
|
||||
m_thumbnail_source[size_t(slot)] = nullptr;
|
||||
m_layer_expanded[size_t(slot)] = false;
|
||||
}
|
||||
if (m_picker_slot == slot)
|
||||
m_picker_slot = -1;
|
||||
@@ -4255,7 +4201,7 @@ int GLGizmoTextureDisplacement::select_visible_faces(const std::array<float, 12>
|
||||
selector.reset();
|
||||
for (unsigned i : unobscured)
|
||||
selector.set_facet(int(front_facing[i]), EnforcerBlockerType::ENFORCER);
|
||||
selector.request_update_render_data(true);
|
||||
selector.request_update_render_data();
|
||||
|
||||
update_model_object();
|
||||
m_parent.set_as_dirty();
|
||||
@@ -4278,7 +4224,7 @@ void GLGizmoTextureDisplacement::select_whole_model()
|
||||
const size_t facet_count = v->mesh().its.indices.size();
|
||||
for (size_t i = 0; i < facet_count; ++i)
|
||||
m_triangle_selectors[idx]->set_facet(int(i), EnforcerBlockerType::ENFORCER);
|
||||
m_triangle_selectors[idx]->request_update_render_data(true);
|
||||
m_triangle_selectors[idx]->request_update_render_data();
|
||||
}
|
||||
update_model_object();
|
||||
m_parent.set_as_dirty();
|
||||
@@ -5384,7 +5330,7 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_thumbnail(const TextureDisplace
|
||||
return nullptr;
|
||||
|
||||
const size_t slot = size_t(layer.slot);
|
||||
if (m_thumbnails[slot] && m_thumbnail_source[slot].lock() == layer.image_data &&
|
||||
if (m_thumbnails[slot] && m_thumbnail_source[slot] == layer.image_data.get() &&
|
||||
m_thumbnail_smoothing[slot] == layer.smoothing)
|
||||
return m_thumbnails[slot].get();
|
||||
|
||||
@@ -5397,7 +5343,7 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_thumbnail(const TextureDisplace
|
||||
return nullptr;
|
||||
|
||||
m_thumbnails[slot] = std::move(texture);
|
||||
m_thumbnail_source[slot] = layer.image_data;
|
||||
m_thumbnail_source[slot] = layer.image_data.get();
|
||||
m_thumbnail_smoothing[slot] = layer.smoothing;
|
||||
return m_thumbnails[slot].get();
|
||||
}
|
||||
@@ -5406,17 +5352,17 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_color_texture(const TextureDisp
|
||||
{
|
||||
if (layer.empty() || !layer.color_enabled)
|
||||
return nullptr;
|
||||
if (m_color_tex && m_color_tex_source.lock() == layer.image_data && m_color_tex_smoothing == layer.smoothing)
|
||||
if (m_color_tex && m_color_tex_source == layer.image_data.get() && m_color_tex_smoothing == layer.smoothing)
|
||||
return m_color_tex.get();
|
||||
|
||||
std::unique_ptr<GLTexture> texture = upload_color_texture(decode_height_texture(layer), HEIGHT_TEX_MAX_PX);
|
||||
if (!texture) {
|
||||
m_color_tex.reset();
|
||||
m_color_tex_source.reset();
|
||||
m_color_tex_source = nullptr;
|
||||
return nullptr;
|
||||
}
|
||||
m_color_tex = std::move(texture);
|
||||
m_color_tex_source = layer.image_data;
|
||||
m_color_tex_source = layer.image_data.get();
|
||||
m_color_tex_smoothing = layer.smoothing;
|
||||
return m_color_tex.get();
|
||||
}
|
||||
@@ -5428,7 +5374,7 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_height_texture(const TextureDis
|
||||
|
||||
// One slot, not one per layer: the preview shader only ever shades the *active* layer, so a single
|
||||
// full-resolution upload is enough and the VRAM cost stays at one texture rather than eight.
|
||||
if (m_height_tex && m_height_tex_source.lock() == layer.image_data && m_height_tex_smoothing == layer.smoothing)
|
||||
if (m_height_tex && m_height_tex_source == layer.image_data.get() && m_height_tex_smoothing == layer.smoothing)
|
||||
return m_height_tex.get();
|
||||
|
||||
std::unique_ptr<GLTexture> texture = upload_height_thumbnail(decode_height_texture(layer), HEIGHT_TEX_MAX_PX);
|
||||
@@ -5436,7 +5382,7 @@ GLTexture *GLGizmoTextureDisplacement::get_layer_height_texture(const TextureDis
|
||||
return nullptr;
|
||||
|
||||
m_height_tex = std::move(texture);
|
||||
m_height_tex_source = layer.image_data;
|
||||
m_height_tex_source = layer.image_data.get();
|
||||
m_height_tex_smoothing = layer.smoothing;
|
||||
return m_height_tex.get();
|
||||
}
|
||||
@@ -5877,9 +5823,6 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
GizmoImguiBegin(get_name(), flags);
|
||||
ensure_panel_icons();
|
||||
process_uv_commands(); // clicks from the UV editor pane, run here where the GL context is current
|
||||
// After the pane's commands, which can close it or change the view, and before the View row, so the row
|
||||
// lights the view this frame ends up in and a click on it has the last word.
|
||||
follow_island_highlight();
|
||||
const float previous_body_h = m_panel_body_h;
|
||||
const float previous_footer_h = m_panel_footer_h;
|
||||
|
||||
@@ -6004,8 +5947,8 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
}
|
||||
return s + "...";
|
||||
};
|
||||
// Label column + a slider filling the rest of the row, value printed inside the track.
|
||||
// `right_inset` keeps a layer card's inner padding.
|
||||
// Label column + a slider filling the rest of the row, value printed inside the track. Ctrl+click on
|
||||
// any of these types a value in. `right_inset` keeps a layer card's inner padding.
|
||||
const auto slider_label = [&](const wxString &label) {
|
||||
const float x0 = ImGui::GetCursorPosX();
|
||||
ImGui::AlignTextToFramePadding();
|
||||
@@ -6013,107 +5956,17 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
ImGui::SameLine();
|
||||
ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + label_w));
|
||||
};
|
||||
|
||||
// ---- Typed values on sliders ----
|
||||
// Every slider in the panel goes through typed_slider(), so all of them take a number the same
|
||||
// two ways: Ctrl+click on the track, or the edit icon at the right end for the same box without
|
||||
// the modifier. Both end up in ImGui's own "temp input" mode - the icon only asks ImGui to focus
|
||||
// the slider, which is what turns it into an input box (see SliderScalar) - so the parsing,
|
||||
// the clamping and the Enter/click-away behaviour are ImGui's, not a second implementation.
|
||||
|
||||
// Retires a click whose row is no longer being drawn - the panel changed mode in between - so that
|
||||
// it cannot fire later when that row comes back. Before any row is drawn, so a live one still wins.
|
||||
if (!m_slider_type_request.empty() && ImGui::GetFrameCount() > m_slider_type_request_frame + 1)
|
||||
m_slider_type_request.clear();
|
||||
|
||||
// Exactly as tall as the slider it sits beside, so it lines up with the track without the row
|
||||
// having to be re-centred around it; icon_button() pads the glyph itself down to about 0.7 of this.
|
||||
const float edit_icon_w = frame_h;
|
||||
// What the slider's own width has to give up for the icon beside it.
|
||||
const float edit_icon_room = edit_icon_w + gap_s;
|
||||
|
||||
// One end of a range, through the slider's own format, so the bounds in the tooltip read exactly
|
||||
// like the value in the track. A parenthesised note in the format - "(auto)" - is dropped: it
|
||||
// describes the current state, not the bound.
|
||||
const auto fmt_bound = [](const char *format, auto v) {
|
||||
char buf[64];
|
||||
std::snprintf(buf, sizeof(buf), format, v);
|
||||
std::string out(buf);
|
||||
const size_t paren = out.find('(');
|
||||
if (paren != std::string::npos)
|
||||
out.erase(paren);
|
||||
while (!out.empty() && out.back() == ' ')
|
||||
out.pop_back();
|
||||
return out;
|
||||
};
|
||||
const auto range_text = [](const std::string &lo, const std::string &hi) {
|
||||
return Slic3r::format(_u8L("Range: %1% to %2%"), lo, hi);
|
||||
};
|
||||
const auto edit_icon_tip = [&](const std::string &range) {
|
||||
return _u8L("Type a value instead of dragging. Ctrl+click on the slider does the same.") + "\n\n" + range;
|
||||
};
|
||||
|
||||
// Draws `slider` at `item_w` (SetNextItemWidth's convention: negative measures back from the right
|
||||
// edge, and the caller has already left edit_icon_room in it), then the edit icon. `tip` and the
|
||||
// range go on both. Returns whatever the slider returned.
|
||||
const auto typed_row = [&](const char *id, float item_w, const wxString &tip, const std::string &range,
|
||||
const std::function<bool()> &slider) -> bool {
|
||||
// Deferred from the click a frame ago: SetKeyboardFocusHere() is a request for the *next*
|
||||
// frame, so it has to be issued before the slider it names, not from the icon beside it.
|
||||
if (m_slider_type_request == id) {
|
||||
ImGui::SetKeyboardFocusHere();
|
||||
m_slider_type_request.clear();
|
||||
m_parent.set_as_dirty(); // the focus only lands on a frame that actually gets drawn
|
||||
}
|
||||
ImGui::SetNextItemWidth(item_w);
|
||||
const bool changed = slider();
|
||||
// AllowWhenDisabled: several of these rows are drawn inside disabled_begin(), and a greyed
|
||||
// slider is exactly when the user needs to be told what it is and why it is not moving.
|
||||
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
|
||||
wxString full = tip;
|
||||
if (!full.IsEmpty())
|
||||
full += "\n\n";
|
||||
m_imgui->tooltip(full + from_u8(range), wrap_w);
|
||||
}
|
||||
// SameLine() puts the cursor back at the slider's own top (ItemSize records the Y the item was
|
||||
// drawn at), so an icon of the same height lands on the track wherever the row placed it.
|
||||
ImGui::SameLine(0.f, gap_s);
|
||||
if (icon_button(int(ImGui::GetID(id)), "edit.svg", edit_icon_w, _L("Edit"), from_u8(edit_icon_tip(range)))) {
|
||||
m_slider_type_request = id;
|
||||
m_slider_type_request_frame = ImGui::GetFrameCount();
|
||||
m_parent.set_as_dirty(); // the next frame is where the request above is turned into focus
|
||||
}
|
||||
return changed;
|
||||
};
|
||||
|
||||
// The two forms every slider in the panel is one of. They derive the range from the bounds they are
|
||||
// already given, so no row states its bounds or its format twice and the tooltip cannot drift from
|
||||
// the track. `item_w` is as typed_row() takes it.
|
||||
const auto typed_slider = [&](const char *id, float item_w, float *v, float v_min, float v_max, const char *format,
|
||||
bool log, const wxString &tip) -> bool {
|
||||
return typed_row(id, item_w, tip, range_text(fmt_bound(format, v_min), fmt_bound(format, v_max)), [&] {
|
||||
return ImGui::SliderFloat(id, v, v_min, v_max, format,
|
||||
ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
|
||||
});
|
||||
};
|
||||
const auto typed_slider_int = [&](const char *id, float item_w, int *v, int v_min, int v_max, const char *format,
|
||||
bool log, const wxString &tip) -> bool {
|
||||
return typed_row(id, item_w, tip, range_text(fmt_bound(format, v_min), fmt_bound(format, v_max)), [&] {
|
||||
return ImGui::SliderInt(id, v, v_min, v_max, format,
|
||||
ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
|
||||
});
|
||||
};
|
||||
|
||||
// Label column + the slider filling the rest of the row.
|
||||
const auto float_row = [&](const char *id, const wxString &label, float *v, float v_min, float v_max, const char *format,
|
||||
bool log, float right_inset, const wxString &tip) -> bool {
|
||||
bool log, float right_inset) -> bool {
|
||||
slider_label(label);
|
||||
return typed_slider(id, -(std::max(right_inset, 1.f) + edit_icon_room), v, v_min, v_max, format, log, tip);
|
||||
ImGui::SetNextItemWidth(-std::max(right_inset, 1.f));
|
||||
return ImGui::SliderFloat(id, v, v_min, v_max, format, ImGuiSliderFlags_AlwaysClamp | (log ? ImGuiSliderFlags_Logarithmic : 0));
|
||||
};
|
||||
const auto int_row = [&](const char *id, const wxString &label, int *v, int v_min, int v_max, const char *format,
|
||||
float right_inset, const wxString &tip) -> bool {
|
||||
float right_inset) -> bool {
|
||||
slider_label(label);
|
||||
return typed_slider_int(id, -(std::max(right_inset, 1.f) + edit_icon_room), v, v_min, v_max, format, false, tip);
|
||||
ImGui::SetNextItemWidth(-std::max(right_inset, 1.f));
|
||||
return ImGui::SliderInt(id, v, v_min, v_max, format, ImGuiSliderFlags_AlwaysClamp);
|
||||
};
|
||||
const auto layer_name = [](const TextureDisplacementLayer &l) {
|
||||
return l.name.empty() ? Slic3r::format(_u8L("Layer %1%"), l.slot + 1) : l.name;
|
||||
@@ -6326,7 +6179,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
if (v->is_model_part()) {
|
||||
++idx;
|
||||
m_triangle_selectors[idx]->reset();
|
||||
m_triangle_selectors[idx]->request_update_render_data(true);
|
||||
m_triangle_selectors[idx]->request_update_render_data();
|
||||
}
|
||||
update_model_object();
|
||||
m_parent.set_as_dirty();
|
||||
@@ -6337,10 +6190,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
const auto centre_on_row = [&](float h) { ImGui::SetCursorPosY(row_y + std::round((icon_md - h) * 0.5f)); };
|
||||
vsep(icon_md);
|
||||
if (is_brush_mode) {
|
||||
ImGui::SetNextItemWidth(std::max(1.f, row_end - ImGui::GetCursorPosX() - (3.f * gap_s + 1.f + 2.f * icon_sm)));
|
||||
centre_on_row(frame_h);
|
||||
typed_slider("##cursor_radius",
|
||||
std::max(1.f, row_end - ImGui::GetCursorPosX() - (3.f * gap_s + 1.f + 2.f * icon_sm) - edit_icon_room),
|
||||
&m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f mm", false, m_desc.at("cursor_size"));
|
||||
ImGui::SliderFloat("##cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f mm",
|
||||
ImGuiSliderFlags_AlwaysClamp);
|
||||
hover_tip(m_desc.at("cursor_size"));
|
||||
vsep(icon_sm);
|
||||
const bool is_circle = m_cursor_type == TriangleSelector::CursorType::CIRCLE;
|
||||
centre_on_row(icon_sm);
|
||||
@@ -6353,10 +6207,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
_L("Sphere - paints only within a ball around the point under the cursor")))
|
||||
m_cursor_type = TriangleSelector::CursorType::SPHERE;
|
||||
} else if (is_area_mode) {
|
||||
ImGui::SetNextItemWidth(std::max(1.f, row_end - ImGui::GetCursorPosX()));
|
||||
centre_on_row(frame_h);
|
||||
typed_slider("##smart_fill_angle", std::max(1.f, row_end - ImGui::GetCursorPosX() - edit_icon_room),
|
||||
&m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, "%.0f°", false,
|
||||
_L("Angle threshold - the fill stops at edges sharper than this"));
|
||||
ImGui::SliderFloat("##smart_fill_angle", &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, "%.0f°",
|
||||
ImGuiSliderFlags_AlwaysClamp);
|
||||
hover_tip(_u8L("Angle threshold - the fill stops at edges sharper than this"));
|
||||
} else {
|
||||
centre_on_row(frame_h);
|
||||
ImGui::AlignTextToFramePadding();
|
||||
@@ -6368,9 +6223,10 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
// ---- View: Normal / Fast / Checker / Distortion as one group, Wireframe on its own ----
|
||||
// The underlying state stays m_use_shaded_preview + m_uv_check_mode.
|
||||
{
|
||||
const int cur_mode = view_mode();
|
||||
const int cur_mode = m_use_shaded_preview ? 1 :
|
||||
m_uv_check_mode == UVCheckMode::Checker ? 2 :
|
||||
m_uv_check_mode == UVCheckMode::Distortion ? 3 : 0;
|
||||
int new_mode = cur_mode;
|
||||
int picked = -1; // the button clicked, the active one included
|
||||
bool wf_toggle = false;
|
||||
bool open_uv_editor = false;
|
||||
// Checker and Distortion both draw *the unwrap* - the first the texture grid laid over it, the second
|
||||
@@ -6393,19 +6249,19 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + m_imgui->scaled(2.6f)));
|
||||
if (icon_toggle(701, "texture_displacement_real_preview.svg", cur_mode == 0, icon_md, _L("Normal"),
|
||||
_L("Normal - the real geometry, exactly what Bake will produce. Slower to update")))
|
||||
new_mode = picked = 0;
|
||||
new_mode = 0;
|
||||
ImGui::SameLine(0.f, gap_s);
|
||||
if (icon_toggle(702, "texture_displacement_fast_preview.svg", cur_mode == 1, icon_md, _L("Fast"),
|
||||
_L("Fast - the relief is only shaded on, not built, and only for the layer you are "
|
||||
"editing. Updates instantly while you paint")))
|
||||
new_mode = picked = 1;
|
||||
new_mode = 1;
|
||||
ImGui::SameLine(0.f, gap_s);
|
||||
if (icon_toggle(703, "texture_displacement_checker.svg", cur_mode == 2, icon_md, _L("Checker"),
|
||||
_L("Checker - a test grid instead of the texture. Where the squares stay square the "
|
||||
"texture is undistorted; where they stretch, it will too. Opens the UV editor if "
|
||||
"it is closed"),
|
||||
uv_view_na)) {
|
||||
new_mode = picked = 2;
|
||||
new_mode = 2;
|
||||
open_uv_editor = true;
|
||||
}
|
||||
ImGui::SameLine(0.f, gap_s);
|
||||
@@ -6413,7 +6269,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
_L("Distortion - blue-to-red stretch heatmap over the unwrap. Opens the UV editor if "
|
||||
"it is closed"),
|
||||
uv_view_na)) {
|
||||
new_mode = picked = 3;
|
||||
new_mode = 3;
|
||||
open_uv_editor = true;
|
||||
}
|
||||
vsep(icon_md);
|
||||
@@ -6437,8 +6293,6 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
if (new_mode == cur_mode)
|
||||
update_uv_editor(); // otherwise apply_view_mode() below does it
|
||||
}
|
||||
if (picked >= 0)
|
||||
m_island_view.picked(picked);
|
||||
if (new_mode != cur_mode)
|
||||
apply_view_mode(new_mode);
|
||||
if (wf_toggle) {
|
||||
@@ -6627,16 +6481,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
|
||||
// The three controls nearly every layer needs; everything else waits behind "More settings".
|
||||
// Depth and tile size are logarithmic, so both ends of their wide ranges stay usable.
|
||||
m_preview_params_dirty |= float_row("##depth", _L("Depth"), &layer.depth_mm, 0.01f, 10.f, "%.3f mm", true, card_pad,
|
||||
_L("Height of the relief: how far white in the texture lifts the surface, in "
|
||||
"millimetres. Black does not move it at all, unless Midlevel says otherwise."));
|
||||
m_preview_params_dirty |= float_row("##tile_size", _L("Tile size"), &layer.tiling_scale, 0.2f, 200.f, "%.2f mm", true, card_pad,
|
||||
_L("How wide one copy of the texture is on the model. Smaller repeats the pattern "
|
||||
"more often and makes its detail finer; with Tile off, this is the size of the "
|
||||
"single copy."));
|
||||
m_preview_params_dirty |= float_row("##rotation", _L("Rotation"), &layer.rotation_deg, 0.f, 360.f, "%.0f°", false, card_pad,
|
||||
_L("Turns the texture on the surface, in degrees - for lining a pattern up with an "
|
||||
"edge of the model."));
|
||||
m_preview_params_dirty |= float_row("##depth", _L("Depth"), &layer.depth_mm, 0.01f, 10.f, "%.3f mm", true, card_pad);
|
||||
hover_tip(_u8L("Height of the relief: how far white in the texture lifts the surface, in "
|
||||
"millimetres. Black does not move it at all, unless Midlevel says otherwise."));
|
||||
m_preview_params_dirty |= float_row("##tile_size", _L("Tile size"), &layer.tiling_scale, 0.2f, 200.f, "%.2f mm", true, card_pad);
|
||||
hover_tip(_u8L("How wide one copy of the texture is on the model. Smaller repeats the pattern "
|
||||
"more often and makes its detail finer; with Tile off, this is the size of the "
|
||||
"single copy."));
|
||||
m_preview_params_dirty |= float_row("##rotation", _L("Rotation"), &layer.rotation_deg, 0.f, 360.f, "%.0f°", false, card_pad);
|
||||
hover_tip(_u8L("Turns the texture on the surface, in degrees - for lining a pattern up with an "
|
||||
"edge of the model."));
|
||||
|
||||
if (m_layer_expanded[size_t(layer.slot)]) {
|
||||
{
|
||||
@@ -6651,22 +6505,22 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
|
||||
// Midlevel: the height that means "don't move". At 0 the surface only ever bulges outwards;
|
||||
// at 0.5 mid-grey is neutral and darker texels cut inwards.
|
||||
m_preview_params_dirty |= float_row("##midlevel", _L("Midlevel"), &layer.midlevel, 0.f, 10.f, "%.2f", false, card_pad,
|
||||
_L("Which gray stays where the surface already is. At 0 the texture only pushes "
|
||||
"outwards; at 0.5 mid-gray stays put, so darker grays cut in and lighter ones "
|
||||
"still push out - one image both embosses and engraves.\n\n"
|
||||
"What cuts in has to fit: inside a sharp corner or through a thin wall, a deep "
|
||||
"cut can pass through the other side."));
|
||||
m_preview_params_dirty |= float_row("##midlevel", _L("Midlevel"), &layer.midlevel, 0.f, 10.f, "%.2f", false, card_pad);
|
||||
hover_tip(_u8L("Which gray stays where the surface already is. At 0 the texture only pushes "
|
||||
"outwards; at 0.5 mid-gray stays put, so darker grays cut in and lighter ones "
|
||||
"still push out - one image both embosses and engraves.\n\n"
|
||||
"What cuts in has to fit: inside a sharp corner or through a thin wall, a deep "
|
||||
"cut can pass through the other side."));
|
||||
if (layer.midlevel > 0.f && layer.depth_mm > 1.f) {
|
||||
ImGui::PushTextWrapPos(content_rx - card_pad);
|
||||
m_imgui->warning_text(_L("Deep inward displacement may self-intersect."));
|
||||
ImGui::PopTextWrapPos();
|
||||
}
|
||||
|
||||
m_preview_params_dirty |= float_row("##smoothing", _L("Smoothing"), &layer.smoothing, 0.f, 1.f, "%.2f", false, card_pad,
|
||||
_L("Blurs the image before it is used, which rounds off hard steps and removes "
|
||||
"speckle from a noisy photo. Raise it if the relief looks harsh or grainy; it "
|
||||
"costs fine detail."));
|
||||
m_preview_params_dirty |= float_row("##smoothing", _L("Smoothing"), &layer.smoothing, 0.f, 1.f, "%.2f", false, card_pad);
|
||||
hover_tip(_u8L("Blurs the image before it is used, which rounds off hard steps and removes "
|
||||
"speckle from a noisy photo. Raise it if the relief looks harsh or grainy; it "
|
||||
"costs fine detail."));
|
||||
|
||||
// Edge fade: the relief flattens toward the boundary of the painted area.
|
||||
m_preview_params_dirty |= m_imgui->bbl_checkbox(_L("Edge fade") + "##edge_smoothing", layer.edge_smoothing);
|
||||
@@ -6674,11 +6528,12 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
"blends into the bare surface instead of stopping at a step."));
|
||||
ImGui::SameLine();
|
||||
m_imgui->disabled_begin(!layer.edge_smoothing);
|
||||
m_preview_params_dirty |= typed_slider("##edge_amount", -(card_pad + edit_icon_room),
|
||||
&layer.edge_smoothing_amount, 0.02f, 1.f, "%.2f", false,
|
||||
_L("How far in the fade reaches, as a share of the painted area. Small "
|
||||
"values soften a narrow band at the edge; 1 flattens almost all of it."));
|
||||
ImGui::SetNextItemWidth(-card_pad);
|
||||
m_preview_params_dirty |= ImGui::SliderFloat("##edge_amount", &layer.edge_smoothing_amount, 0.02f, 1.f, "%.2f",
|
||||
ImGuiSliderFlags_AlwaysClamp);
|
||||
m_imgui->disabled_end();
|
||||
hover_tip(_u8L("How far in the fade reaches, as a share of the painted area. Small values "
|
||||
"soften a narrow band at the edge; 1 flattens almost all of it."));
|
||||
|
||||
// Invert and Colours share a row.
|
||||
{
|
||||
@@ -6723,19 +6578,19 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
// Every mix can become a filament slot, and there are only so many beside the
|
||||
// physical filaments.
|
||||
const int max_mixes = std::max(1, int(EnforcerBlockerType::ExtruderMax) - int(m_palette_filaments.size()));
|
||||
if (int_row("##color_mix_count", _L("Mixed colors"), &opts.color_mix_count, 1, max_mixes, "%d", card_pad,
|
||||
_L("The most mixed filaments a bake may add. They are picked from the "
|
||||
"texture's colors, and only the ones the bake actually uses are created.")))
|
||||
if (int_row("##color_mix_count", _L("Mixed colors"), &opts.color_mix_count, 1, max_mixes, "%d", card_pad))
|
||||
m_preview_params_dirty = true;
|
||||
hover_tip(_u8L("The most mixed filaments a bake may add. They are picked from the "
|
||||
"texture's colors, and only the ones the bake actually uses are created."));
|
||||
// After the slider, so a change shows in the same frame.
|
||||
ImGui::TextDisabled("%s", Slic3r::format(_u8L("%1% printable colors from %2% filaments"),
|
||||
int(cached_palette().size()), int(m_palette_filaments.size())).c_str());
|
||||
}
|
||||
if (int_row("##color_despeckle", _L("Denoise"), &opts.color_despeckle, 0, 6, "%d", card_pad,
|
||||
_L("Cleans up single stray triangles of the wrong color, which detail finer "
|
||||
"than the mesh leaves behind. Raise it if the result looks speckled, "
|
||||
"lower it if small features are being swallowed.")))
|
||||
if (int_row("##color_despeckle", _L("Denoise"), &opts.color_despeckle, 0, 6, "%d", card_pad))
|
||||
m_preview_params_dirty = true;
|
||||
hover_tip(_u8L("Cleans up single stray triangles of the wrong color, which detail finer "
|
||||
"than the mesh leaves behind. Raise it if the result looks speckled, "
|
||||
"lower it if small features are being swallowed."));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6840,10 +6695,10 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
"gets the texture, and its border becomes the edge of the projection."));
|
||||
|
||||
if (projector_open) {
|
||||
if (int_row("##projector_opacity", _L("Opacity"), &m_projector_opacity, 20, 255, "%d", card_pad,
|
||||
_L("How solid the frame window looks while you place it. Lower to see the "
|
||||
"model through it; it does not affect the result.")))
|
||||
if (int_row("##projector_opacity", _L("Opacity"), &m_projector_opacity, 20, 255, "%d", card_pad))
|
||||
m_projector_frame->set_opacity(m_projector_opacity);
|
||||
hover_tip(_u8L("How solid the frame window looks while you place it. Lower to see the "
|
||||
"model through it; it does not affect the result."));
|
||||
|
||||
if (m_imgui->button(_u8L("Apply projection frame"))) {
|
||||
const int painted_count = apply_projection_frame();
|
||||
@@ -7144,57 +6999,57 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
// pattern can sample four points that all happen to land at similar heights, report no error,
|
||||
// and stall before refinement ever starts.
|
||||
if (float_row("##subdiv_target", m_subdivide_feature ? _L("Max edge") : _L("Target edge"), &m_subdivide_target_mm,
|
||||
0.001f, 20.f, "%.3f mm", true, 0.f,
|
||||
m_subdivide_feature ?
|
||||
_L("No triangle in the painted area stays larger than this, even where the texture "
|
||||
"is flat. Keep it near the size of the smallest feature you want to come out.") :
|
||||
_L("Triangles in the painted area are split until none is larger than this. Smaller "
|
||||
"means finer detail and, fast, a lot more triangles.")))
|
||||
0.001f, 20.f, "%.3f mm", true, 0.f))
|
||||
preview_live();
|
||||
hover_tip(m_subdivide_feature ?
|
||||
_u8L("No triangle in the painted area stays larger than this, even where the texture "
|
||||
"is flat. Keep it near the size of the smallest feature you want to come out.") :
|
||||
_u8L("Triangles in the painted area are split until none is larger than this. Smaller "
|
||||
"means finer detail and, fast, a lot more triangles."));
|
||||
|
||||
if (m_subdivide_feature) {
|
||||
if (float_row("##subdiv_detail", _L("Detail"), &m_subdivide_detail_mm, 0.001f, 1.f, "%.3f mm", true, 0.f,
|
||||
_L("How far the mesh may sit from the shape the texture describes, in millimetres. "
|
||||
"Smaller follows fine detail and costs triangles; larger only chases the big "
|
||||
"features.")))
|
||||
if (float_row("##subdiv_detail", _L("Detail"), &m_subdivide_detail_mm, 0.001f, 1.f, "%.3f mm", true, 0.f))
|
||||
preview_live();
|
||||
if (float_row("##subdiv_min", _L("Min edge"), &m_subdivide_min_edge_mm, 0.001f, 20.f, "%.3f mm", true, 0.f,
|
||||
_L("A floor on triangle size, so a sharp step in the texture cannot be chased "
|
||||
"forever. Lower it for finer relief, raise it if the count runs away at hard "
|
||||
"edges.")))
|
||||
hover_tip(_u8L("How far the mesh may sit from the shape the texture describes, in millimetres. "
|
||||
"Smaller follows fine detail and costs triangles; larger only chases the big "
|
||||
"features."));
|
||||
if (float_row("##subdiv_min", _L("Min edge"), &m_subdivide_min_edge_mm, 0.001f, 20.f, "%.3f mm", true, 0.f))
|
||||
preview_live();
|
||||
hover_tip(_u8L("A floor on triangle size, so a sharp step in the texture cannot be chased "
|
||||
"forever. Lower it for finer relief, raise it if the count runs away at hard "
|
||||
"edges."));
|
||||
}
|
||||
|
||||
// Applies in both adaptive sub-modes: it is about the step the bake puts at the paint's edge, which
|
||||
// exists whether or not "Follow texture detail" is on. 0 turns the band off.
|
||||
if (float_row("##subdiv_border", _L("Edge detail"), &m_subdivide_border_mm, 0.f, 5.f, "%.3f mm", false, 0.f,
|
||||
_L("Triangle size along the outline of the painted area, where the relief drops back to the "
|
||||
"bare surface. Lower it if that rim looks jagged; it only costs triangles along the "
|
||||
"outline. 0 turns it off.")))
|
||||
if (float_row("##subdiv_border", _L("Edge detail"), &m_subdivide_border_mm, 0.f, 5.f, "%.3f mm", false, 0.f))
|
||||
preview_live();
|
||||
hover_tip(_u8L("Triangle size along the outline of the painted area, where the relief drops back to the "
|
||||
"bare surface. Lower it if that rim looks jagged; it only costs triangles along the "
|
||||
"outline. 0 turns it off."));
|
||||
|
||||
// Only worth showing when a layer is actually colouring: with no colour there is no boundary for it
|
||||
// to refine and the control would do nothing whatever it is set to.
|
||||
if (mv != nullptr && any_layer_colors(*mv)) {
|
||||
if (float_row("##subdiv_color", _L("Color detail"), &m_subdivide_color_mm, 0.f, 5.f, "%.3f mm", false, 0.f,
|
||||
_L("Triangle size where two colors meet. Each triangle prints in one filament, so a "
|
||||
"color edge can only be as sharp as the triangles along it - and nothing else "
|
||||
"refines there, since the surface is flat across a change of color. 0 turns it off.")))
|
||||
if (float_row("##subdiv_color", _L("Color detail"), &m_subdivide_color_mm, 0.f, 5.f, "%.3f mm", false, 0.f))
|
||||
preview_live();
|
||||
hover_tip(_u8L("Triangle size where two colors meet. Each triangle prints in one filament, so a "
|
||||
"color edge can only be as sharp as the triangles along it - and nothing else "
|
||||
"refines there, since the surface is flat across a change of color. 0 turns it off."));
|
||||
}
|
||||
|
||||
ImGui::TextDisabled("%s", _u8L("Triangle budget: set with Triangles, below.").c_str());
|
||||
if (m_subdivide_editing && m_subdivide_preview_tris > 0)
|
||||
m_imgui->text(Slic3r::format(_u8L("Preview: %1% triangles"), m_subdivide_preview_tris));
|
||||
} else {
|
||||
if (int_row("##subdiv_steps", _L("Steps"), &m_subdivide_count, 0, 5, "%d", 0.f,
|
||||
_L("Splits every triangle of the model into four, this many times over. Each step "
|
||||
"quadruples the count - 3 turns 100 k triangles into 6.4 M - so prefer refining "
|
||||
"only the painted area unless you need the whole model finer."))) {
|
||||
if (int_row("##subdiv_steps", _L("Steps"), &m_subdivide_count, 0, 5, "%d", 0.f)) {
|
||||
if (m_subdivide_editing)
|
||||
rebuild_subdivide_preview(); // a count of 0 clears the preview, it doesn't compute one
|
||||
m_parent.set_as_dirty();
|
||||
}
|
||||
hover_tip(_u8L("Splits every triangle of the model into four, this many times over. Each step "
|
||||
"quadruples the count - 3 turns 100 k triangles into 6.4 M - so prefer refining "
|
||||
"only the painted area unless you need the whole model finer."));
|
||||
}
|
||||
|
||||
{
|
||||
@@ -7256,9 +7111,9 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
}
|
||||
m_remesh_target_edge_mm = cnt > 0 ? std::clamp(float(sum / double(cnt)), 0.1f, 20.f) : 1.f;
|
||||
}
|
||||
float_row("##remesh_edge", _L("Target edge"), &m_remesh_target_edge_mm, 0.1f, 20.f, "%.2f mm", true, 0.f,
|
||||
_L("Triangle size the whole model is rebuilt with, in millimetres. Displacement works best on an "
|
||||
"even mesh; this is what makes one out of an uneven import."));
|
||||
float_row("##remesh_edge", _L("Target edge"), &m_remesh_target_edge_mm, 0.1f, 20.f, "%.2f mm", true, 0.f);
|
||||
hover_tip(_u8L("Triangle size the whole model is rebuilt with, in millimetres. Displacement works best on an "
|
||||
"even mesh; this is what makes one out of an uneven import."));
|
||||
|
||||
m_imgui->bbl_checkbox(_L("Keep sharp edges") + "##remesh_sharp", m_remesh_keep_sharp_edges);
|
||||
hover_tip(_u8L("Holds hard edges and open borders in place while the rest is remeshed. Without it "
|
||||
@@ -7266,10 +7121,11 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
"a cube comes back with wobbly edges."));
|
||||
ImGui::SameLine();
|
||||
m_imgui->disabled_begin(!m_remesh_keep_sharp_edges);
|
||||
typed_slider("##remesh_sharp_angle", -(1.f + edit_icon_room), &m_remesh_sharp_angle_deg, 5.f, 90.f, "%.0f°", false,
|
||||
_L("How sharp a fold has to be, in degrees, before the remesher treats it as an edge worth "
|
||||
"keeping. Lower protects more of the model's shape; higher rebuilds more of it evenly."));
|
||||
ImGui::SetNextItemWidth(-1.f);
|
||||
ImGui::SliderFloat("##remesh_sharp_angle", &m_remesh_sharp_angle_deg, 5.f, 90.f, "%.0f°", ImGuiSliderFlags_AlwaysClamp);
|
||||
m_imgui->disabled_end();
|
||||
hover_tip(_u8L("How sharp a fold has to be, in degrees, before the remesher treats it as an edge worth "
|
||||
"keeping. Lower protects more of the model's shape; higher rebuilds more of it evenly."));
|
||||
|
||||
m_imgui->disabled_begin(mv == nullptr || busy);
|
||||
if (ImGui::Button(_u8L("Remesh").c_str()))
|
||||
@@ -7297,16 +7153,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
"on a layer is a different thing: it blurs the image before it is used."));
|
||||
if (opts.smooth_enabled) {
|
||||
float percent = opts.smooth_strength * 100.f;
|
||||
if (float_row("##dispsmooth", _L_CONTEXT("Strength", "Texture Displacement"), &percent, 1.f, 100.f, "%.0f %%", false, 0.f,
|
||||
_L("How far each pass pulls a vertex towards its neighbours. High values round the "
|
||||
"relief off quickly; low values need more passes but keep more of the detail."))) {
|
||||
if (float_row("##dispsmooth", _L_CONTEXT("Strength", "Texture Displacement"), &percent, 1.f, 100.f, "%.0f %%", false, 0.f)) {
|
||||
opts.smooth_strength = std::clamp(percent / 100.f, 0.01f, 1.f);
|
||||
m_preview_params_dirty = true;
|
||||
}
|
||||
if (int_row("##dispsmoothit", _L("Passes"), &opts.smooth_iterations, 1, 10, "%d", 0.f,
|
||||
_L("How many smoothing passes to run. More passes spread the smoothing further across "
|
||||
"the surface; Strength decides how much each one moves.")))
|
||||
hover_tip(_u8L("How far each pass pulls a vertex towards its neighbours. High values round the "
|
||||
"relief off quickly; low values need more passes but keep more of the detail."));
|
||||
if (int_row("##dispsmoothit", _L("Passes"), &opts.smooth_iterations, 1, 10, "%d", 0.f))
|
||||
m_preview_params_dirty = true;
|
||||
hover_tip(_u8L("How many smoothing passes to run. More passes spread the smoothing further across "
|
||||
"the surface; Strength decides how much each one moves."));
|
||||
|
||||
m_preview_params_dirty |= m_imgui->bbl_checkbox(_L("Ignore outer ring"), opts.smooth_skip_border);
|
||||
hover_tip(_u8L("Keeps the outer ring of the painted area out of the smoothing. Its neighbours "
|
||||
@@ -7349,16 +7205,16 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
int shown_k = auto_budget ? v2_recommendation(*mv).budget_k : opts.v2_max_triangles_k;
|
||||
m_imgui->disabled_begin(auto_budget);
|
||||
// TRN Slider value: %d is the triangle budget in thousands
|
||||
if (int_row("##v2budget", _L("Budget"), &shown_k, 0, 4000, auto_budget ? _u8L("%d k (auto)").c_str() : "%d k", 0.f,
|
||||
_L("How many thousand triangles this bake may spend on the area you painted. "
|
||||
"Relief already baked into the rest of the model is kept on top of it, so a "
|
||||
"second bake somewhere else gets the same budget as the first. Raise it if the "
|
||||
"warning below Resolution says the detail will not fit; 0 keeps every triangle "
|
||||
"the refinement produced, however many that is."))) {
|
||||
if (int_row("##v2budget", _L("Budget"), &shown_k, 0, 4000, auto_budget ? _u8L("%d k (auto)").c_str() : "%d k", 0.f)) {
|
||||
opts.v2_max_triangles_k = shown_k;
|
||||
m_preview_params_dirty = true;
|
||||
}
|
||||
m_imgui->disabled_end();
|
||||
hover_tip(_u8L("How many thousand triangles this bake may spend on the area you painted. "
|
||||
"Relief already baked into the rest of the model is kept on top of it, so a "
|
||||
"second bake somewhere else gets the same budget as the first. Raise it if the "
|
||||
"warning below Resolution says the detail will not fit; 0 keeps every triangle "
|
||||
"the refinement produced, however many that is."));
|
||||
}
|
||||
if (SHOW_PIPELINE_DEV_CONTROLS && opts.pipeline_v2) {
|
||||
// Keeping the relief above the plate is not a checkbox: it is unconditional, in both pipelines
|
||||
@@ -7465,28 +7321,26 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
"default. Untick to set both yourself - worth doing for a texture much finer or "
|
||||
"much coarser than the part it sits on."));
|
||||
ImGui::SameLine();
|
||||
ImGui::SetNextItemWidth(x0 + panel_w - ImGui::GetCursorPosX());
|
||||
float shown = auto_res ? rec.edge_mm : opts.v2_refine_mm;
|
||||
// Held in a local: the format outlives the call that reads it, and the slider and the
|
||||
// range in its tooltip are then formatted the same way.
|
||||
const std::string v2edge_format = auto_res ? _u8L("%.2f mm (auto)") : std::string("%.2f mm");
|
||||
const wxString v2edge_tip =
|
||||
auto_res && rec.edge_mm > 0.f ?
|
||||
from_u8(Slic3r::format(_u8L("Chosen from the size of the model: %1$.2f mm triangles, "
|
||||
"budget %2% k. Untick Auto to set them yourself."),
|
||||
rec.edge_mm, rec.budget_k)) :
|
||||
_L("How fine the mesh is made under the paint, in millimetres. It has to be "
|
||||
"smaller than the detail you want out of the texture - a 0.5 mm groove needs "
|
||||
"triangles well under 0.5 mm. Smaller costs triangles fast: halving it needs "
|
||||
"four times as many, and once they no longer fit the budget the bake simplifies "
|
||||
"back down and the detail goes with it.");
|
||||
m_imgui->disabled_begin(busy || auto_res);
|
||||
if (typed_slider("##v2edge", x0 + panel_w - ImGui::GetCursorPosX() - edit_icon_room, &shown, 0.02f, 2.f,
|
||||
v2edge_format.c_str(), true, v2edge_tip)) {
|
||||
if (ImGui::SliderFloat("##v2edge", &shown, 0.02f, 2.f, auto_res ? _u8L("%.2f mm (auto)").c_str() : "%.2f mm",
|
||||
ImGuiSliderFlags_AlwaysClamp | ImGuiSliderFlags_Logarithmic)) {
|
||||
opts.v2_refine_mm = shown;
|
||||
m_preview_params_dirty = true;
|
||||
m_parent.set_as_dirty();
|
||||
}
|
||||
m_imgui->disabled_end();
|
||||
if (auto_res && rec.edge_mm > 0.f)
|
||||
hover_tip(Slic3r::format(_u8L("Chosen from the size of the model: %1$.2f mm triangles, "
|
||||
"budget %2% k. Untick Auto to set them yourself."),
|
||||
rec.edge_mm, rec.budget_k));
|
||||
else
|
||||
hover_tip(_u8L("How fine the mesh is made under the paint, in millimetres. It has to be "
|
||||
"smaller than the detail you want out of the texture - a 0.5 mm groove needs "
|
||||
"triangles well under 0.5 mm. Smaller costs triangles fast: halving it needs "
|
||||
"four times as many, and once they no longer fit the budget the bake simplifies "
|
||||
"back down and the detail goes with it."));
|
||||
|
||||
// What this resolution costs over what is painted, against what the budget allows. Refining
|
||||
// past the budget is not an error - the bake simplifies back down to it - but the result
|
||||
@@ -7518,17 +7372,18 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
m_imgui->text(_L("Triangles"));
|
||||
ImGui::SameLine();
|
||||
ImGui::SetCursorPosX(std::max(ImGui::GetCursorPosX(), x0 + label_w));
|
||||
ImGui::SetNextItemWidth(x0 + panel_w - ImGui::GetCursorPosX());
|
||||
m_imgui->disabled_begin(busy);
|
||||
if (typed_slider_int("##subdivbudget", x0 + panel_w - ImGui::GetCursorPosX() - edit_icon_room,
|
||||
&m_subdivide_budget_k, 10, 2000, "+%d k", true,
|
||||
_L("How many thousand triangles the refinement may add to the model. The triangle "
|
||||
"that fits worst is always split first, so even a run that spends the lot has "
|
||||
"spent it where it shows most. Raise it if the relief still looks coarse."))) {
|
||||
if (ImGui::SliderInt("##subdivbudget", &m_subdivide_budget_k, 10, 2000, "+%d k",
|
||||
ImGuiSliderFlags_AlwaysClamp | ImGuiSliderFlags_Logarithmic)) {
|
||||
if (m_subdivide_editing)
|
||||
rebuild_subdivide_preview();
|
||||
m_parent.set_as_dirty();
|
||||
}
|
||||
m_imgui->disabled_end();
|
||||
hover_tip(_u8L("How many thousand triangles the refinement may add to the model. The triangle "
|
||||
"that fits worst is always split first, so even a run that spends the lot has "
|
||||
"spent it where it shows most. Raise it if the relief still looks coarse."));
|
||||
}
|
||||
|
||||
const float button_h = std::round(frame_h * 1.25f);
|
||||
@@ -7547,7 +7402,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
|
||||
: m_tool_type == ToolType::SMART_FILL ? m_shortcuts_bucket_fill
|
||||
: m_tool_type == ToolType::BRUSH ? m_shortcuts_brush
|
||||
: m_tool_type == ToolType::GAP_FILL ? m_shortcuts_gap_fill
|
||||
: m_shortcuts_sliders; // the sliders are there whether or not a painting tool is
|
||||
: std::vector<std::pair<wxString, wxString>>{};
|
||||
|
||||
ImGui::SetCursorPosY(row_y + (row_h - icon_h) * .5f); // center vertically
|
||||
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(int(m_imgui->scaled(.5f)), style.ItemSpacing.y));
|
||||
|
||||
@@ -197,27 +197,6 @@ public:
|
||||
};
|
||||
static PaintedColors painted_colors(const TriangleMesh &mesh, const TriangleSelector::TriangleSplittingData &paint);
|
||||
|
||||
// The view while the UV editor's selected islands are highlighted on the model. The highlight lies on the
|
||||
// undisplaced surface, so the Normal view's relief hides it wherever it rises: Normal gives way to Fast
|
||||
// while islands are selected and comes back once none are. A view the user clicks in the View row is
|
||||
// theirs - the pane's background buttons are not a pick, Height only meaning "the texture view".
|
||||
struct IslandViewFollow
|
||||
{
|
||||
bool shown = false; // the highlight, as of the last step()
|
||||
bool switched = false; // Fast was switched on for the highlight, so Normal comes back once it is gone
|
||||
bool keep_normal = false; // the user picked Normal in the View row while the highlight was shown
|
||||
// The view to apply this frame (0 Normal, 1 Fast), or -1 for none. `view` is the one on screen, numbered as
|
||||
// apply_view_mode() takes it; `debug_open` a debug stage on screen, which holds Normal itself.
|
||||
int step(bool shown_now, int view, bool debug_open);
|
||||
// A View row button clicked, the active one included. The row is drawn after step() in the same frame,
|
||||
// so `shown` is this frame's.
|
||||
void picked(int view)
|
||||
{
|
||||
switched = false;
|
||||
keep_normal = shown && view == 0;
|
||||
}
|
||||
};
|
||||
|
||||
void render_painter_gizmo() override;
|
||||
|
||||
// Intercepts mouse input while "Adjust Texture" mode is on (dragging the on-canvas offset/
|
||||
@@ -428,12 +407,6 @@ private:
|
||||
// Per slot: whether the layer's card shows every setting or only Depth, Tile size and Rotation.
|
||||
// Panel state only, not saved with the project.
|
||||
std::array<bool, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_layer_expanded{};
|
||||
// The slider whose edit icon was just clicked, as its ImGui id, and the frame it was clicked on.
|
||||
// The row acts on it on the next frame - ImGui's keyboard-focus request only takes effect a frame
|
||||
// later - and clears it; the frame number is what retires a request whose row has gone off screen
|
||||
// in the meantime. Panel state only, not saved with the project.
|
||||
std::string m_slider_type_request;
|
||||
int m_slider_type_request_frame = 0;
|
||||
|
||||
// "Adjust Texture" mode: instead of painting, dragging an on-canvas handle changes the active
|
||||
// layer's offset. The handle is a flat panel lying in the paint patch's own tangent plane
|
||||
@@ -534,11 +507,6 @@ private:
|
||||
// The panel's view modes: 0 Normal, 1 Fast, 2 Checker, 3 Distortion. Shared by the View row and the pane's
|
||||
// background buttons, so both switch views the same way.
|
||||
void apply_view_mode(int mode);
|
||||
// The view on screen, numbered as apply_view_mode() takes it.
|
||||
int view_mode() const;
|
||||
// Run once a frame, after the pane's commands: switches the view as m_island_view says.
|
||||
void follow_island_highlight();
|
||||
IslandViewFollow m_island_view;
|
||||
// The pane header's thumbnail of the active layer's texture, rebuilt only when its image changes.
|
||||
static constexpr int UV_THUMB_PX = 64;
|
||||
const void *m_uv_thumb_source = nullptr;
|
||||
@@ -770,8 +738,6 @@ private:
|
||||
// in place. Rebuilt whenever the pane's selection differs from the one it was built for.
|
||||
GLModel m_island_overlay_glmodel;
|
||||
std::vector<int> m_island_overlay_selection;
|
||||
// The pane's selection while the overlay applies - the pane open over an unwrapped LSCM layer - else null.
|
||||
const std::vector<int> *island_highlight_selection();
|
||||
void rebuild_island_overlay(const std::vector<int> &selection);
|
||||
void render_island_overlay();
|
||||
// Set on every paint event, cleared when the overlay is rebuilt in render_painter_gizmo(). Kept
|
||||
@@ -952,26 +918,25 @@ private:
|
||||
bool m_preview_job_pending = false;
|
||||
void queue_preview_job();
|
||||
|
||||
// Per-slot GPU thumbnail cache for the layer list panel, each keyed by the image_data it was built from
|
||||
// (see get_layer_thumbnail()). Held weakly rather than by address, as decode_height_texture()'s cache is:
|
||||
// an image freed and replaced by another at the same address must not pass for it.
|
||||
std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnails;
|
||||
std::array<std::weak_ptr<const std::vector<unsigned char>>, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnail_source;
|
||||
// Per-slot GPU thumbnail cache for the layer list panel, keyed by the image_data pointer that
|
||||
// was current the last time each thumbnail was built (see get_layer_thumbnail()).
|
||||
std::array<std::unique_ptr<GLTexture>, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnails;
|
||||
std::array<const void *, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnail_source{};
|
||||
// The smoothing each cached thumbnail was built at, so a smoothing change re-uploads it.
|
||||
std::array<float, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnail_smoothing{};
|
||||
std::array<float, TEXTURE_DISPLACEMENT_MAX_LAYERS> m_thumbnail_smoothing{};
|
||||
|
||||
// Full-resolution height texture for the preview shader, keyed the same way (see
|
||||
// get_layer_height_texture()). A smoothing change re-uploads it, so the fast preview shows the
|
||||
// blur the bake will apply.
|
||||
std::unique_ptr<GLTexture> m_height_tex;
|
||||
std::weak_ptr<const std::vector<unsigned char>> m_height_tex_source;
|
||||
float m_height_tex_smoothing = -1.f;
|
||||
std::unique_ptr<GLTexture> m_height_tex;
|
||||
const void *m_height_tex_source = nullptr;
|
||||
float m_height_tex_smoothing = -1.f;
|
||||
|
||||
// The same, for the layer's *colour*, which the fast preview quantizes per fragment so it shows
|
||||
// the image at texel resolution rather than at the mesh's. Null for a grayscale texture.
|
||||
std::unique_ptr<GLTexture> m_color_tex;
|
||||
std::weak_ptr<const std::vector<unsigned char>> m_color_tex_source;
|
||||
float m_color_tex_smoothing = -1.f;
|
||||
std::unique_ptr<GLTexture> m_color_tex;
|
||||
const void *m_color_tex_source = nullptr;
|
||||
float m_color_tex_smoothing = -1.f;
|
||||
|
||||
// Library textures the picker has shown at least once, keyed by file path (see LibraryTexture).
|
||||
std::map<std::string, LibraryTexture> m_library_textures;
|
||||
@@ -1057,9 +1022,6 @@ private:
|
||||
std::vector<std::pair<wxString, wxString>> m_shortcuts_bucket_fill;
|
||||
// Contains all shortcuts in the format of {shortcut, description}, e.g. {alt + _L("Left mouse button"), _L("Part_selection")}
|
||||
std::vector<std::pair<wxString, wxString>> m_shortcuts_gap_fill;
|
||||
// The two ways every slider in the panel takes a typed value. They hold whatever tool is selected,
|
||||
// so they are tacked onto each of the lists above and stand on their own when no tool is active.
|
||||
std::vector<std::pair<wxString, wxString>> m_shortcuts_sliders;
|
||||
|
||||
// Icons for the panel's icon buttons (tools, views, mapping, tiling, layer actions). Loaded through IconManager with
|
||||
// the same colour/monochrome variants the main toolbar uses, so an inactive button shows the icon in
|
||||
|
||||
@@ -420,10 +420,7 @@ void GLGizmosManager::refresh_on_off_state()
|
||||
|
||||
void GLGizmosManager::reset_all_states()
|
||||
{
|
||||
// The restore/new-project event can run before deferred OpenGL resource
|
||||
// loading has populated the gizmo list. There is nothing to reset until
|
||||
// initialization completes.
|
||||
if (! m_enabled || m_serializing || m_gizmos.empty())
|
||||
if (! m_enabled || m_serializing)
|
||||
return;
|
||||
|
||||
const EType current = get_current_type();
|
||||
@@ -438,9 +435,6 @@ void GLGizmosManager::reset_all_states()
|
||||
|
||||
bool GLGizmosManager::open_gizmo(EType type)
|
||||
{
|
||||
if (m_gizmos.empty())
|
||||
return false;
|
||||
|
||||
int idx = static_cast<int>(type);
|
||||
|
||||
// re-open same type cause closing
|
||||
@@ -528,7 +522,7 @@ bool GLGizmosManager::is_running() const
|
||||
|
||||
bool GLGizmosManager::open_gizmo_by_shortcut(Shortcut shortcut)
|
||||
{
|
||||
if (!m_enabled || m_gizmos.empty())
|
||||
if (!m_enabled)
|
||||
return false;
|
||||
|
||||
// The text tool opens without a selection because it creates its own object.
|
||||
@@ -1433,12 +1427,10 @@ void GLGizmosManager::update_hover_state(const EType &type)
|
||||
|
||||
bool GLGizmosManager::activate_gizmo(EType type)
|
||||
{
|
||||
// already activated
|
||||
if (m_current == type)
|
||||
return true;
|
||||
assert(!m_gizmos.empty());
|
||||
|
||||
if (m_gizmos.empty())
|
||||
return false;
|
||||
// already activated
|
||||
if (m_current == type) return true;
|
||||
|
||||
if (m_current != Undefined) {
|
||||
// clean up previous gizmo
|
||||
|
||||
@@ -925,9 +925,8 @@ void GizmoObjectManipulation::do_render_move_window(ImGuiWrapper *imgui_wrapper,
|
||||
|
||||
m_last_active_item = current_active_id;
|
||||
last_move_input_window_width = ImGui::GetWindowWidth();
|
||||
ImGui::PopStyleVar();
|
||||
imgui_wrapper->end();
|
||||
ImGui::PopStyleVar();
|
||||
ImGui::PopStyleVar(2);
|
||||
ImGuiWrapper::pop_toolbar_style();
|
||||
}
|
||||
|
||||
@@ -1132,11 +1131,10 @@ void GizmoObjectManipulation::do_render_rotate_window(ImGuiWrapper *imgui_wrappe
|
||||
|
||||
m_last_active_item = current_active_id;
|
||||
last_rotate_input_window_width = ImGui::GetWindowWidth();
|
||||
ImGui::PopStyleVar();
|
||||
imgui_wrapper->end();
|
||||
|
||||
// BBS
|
||||
ImGui::PopStyleVar();
|
||||
ImGui::PopStyleVar(2);
|
||||
ImGuiWrapper::pop_toolbar_style();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
|
||||
namespace Slic3r {
|
||||
namespace GUI {
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
@@ -0,0 +1,11 @@
|
||||
#ifndef slic3r_MultiTaskModel_hpp_
|
||||
#define slic3r_MultiTaskModel_hpp_
|
||||
|
||||
namespace Slic3r {
|
||||
namespace GUI {
|
||||
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif
|
||||
@@ -1880,6 +1880,13 @@ void PartPlate::render_exclude_area(bool force_default_color) {
|
||||
// draw exclude area
|
||||
glsafe(::glDepthMask(GL_FALSE));
|
||||
|
||||
if (m_selected) {
|
||||
glsafe(::glColor4fv(select_color.data()));
|
||||
}
|
||||
else {
|
||||
glsafe(::glColor4fv(unselect_color.data()));
|
||||
}
|
||||
|
||||
m_exclude_triangles.set_color(m_selected ? select_color : unselect_color);
|
||||
m_exclude_triangles.render();
|
||||
glsafe(::glDepthMask(GL_TRUE));
|
||||
|
||||
+24
-11
@@ -14984,8 +14984,24 @@ bool Plater::priv::can_fix_through_cgal() const
|
||||
std::vector<int> obj_idxs, vol_idxs;
|
||||
sidebar->obj_list()->get_selection_indexes(obj_idxs, vol_idxs);
|
||||
|
||||
// A closed mesh may still self-intersect, so fixing is always allowed.
|
||||
#if FIX_THROUGH_CGAL_ALWAYS
|
||||
// Fixing always.
|
||||
return ! obj_idxs.empty() || ! vol_idxs.empty();
|
||||
#else // FIX_THROUGH_CGAL_ALWAYS
|
||||
// Fixing only if the model is not manifold.
|
||||
if (vol_idxs.empty()) {
|
||||
for (auto obj_idx : obj_idxs)
|
||||
if (model.objects[obj_idx]->get_repaired_errors_count() > 0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
int obj_idx = obj_idxs.front();
|
||||
for (auto vol_idx : vol_idxs)
|
||||
if (model.objects[obj_idx]->get_repaired_errors_count(vol_idx) > 0)
|
||||
return true;
|
||||
return false;
|
||||
#endif // FIX_THROUGH_CGAL_ALWAYS
|
||||
}
|
||||
|
||||
bool Plater::priv::can_simplify() const
|
||||
@@ -22025,16 +22041,13 @@ void Plater::clear_before_change_mesh(int obj_idx)
|
||||
mv->mmu_segmentation_facets.reset();
|
||||
mv->fuzzy_skin_facets.reset();
|
||||
}
|
||||
if (paint_removed)
|
||||
notify_painting_removed();
|
||||
}
|
||||
|
||||
void Plater::notify_painting_removed()
|
||||
{
|
||||
get_notification_manager()->push_notification(
|
||||
NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
|
||||
NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
|
||||
_u8L("Custom supports and color painting were removed before repairing."));
|
||||
if (paint_removed) {
|
||||
// snapshot_time is captured by copy so the lambda knows where to undo/redo to.
|
||||
get_notification_manager()->push_notification(
|
||||
NotificationType::CustomSupportsAndSeamRemovedAfterRepair,
|
||||
NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
|
||||
_u8L("Custom supports and color painting were removed before repairing."));
|
||||
}
|
||||
}
|
||||
|
||||
void Plater::changed_mesh(int obj_idx)
|
||||
|
||||
@@ -599,7 +599,6 @@ public:
|
||||
void reslice_SLA_until_step(SLAPrintObjectStep step, const ModelObject &object, bool postpone_error_messages = false);
|
||||
|
||||
void clear_before_change_mesh(int obj_idx);
|
||||
void notify_painting_removed();
|
||||
void changed_mesh(int obj_idx);
|
||||
|
||||
void changed_object(ModelObject &object);
|
||||
|
||||
@@ -1610,12 +1610,6 @@ void PlaterPresetComboBox::show_default_color_picker()
|
||||
{
|
||||
DynamicPrintConfig* cfg = &wxGetApp().preset_bundle->project_config;
|
||||
auto colors = static_cast<ConfigOptionStrings*>(cfg->option("filament_colour")->clone());
|
||||
// The combo can outlive the project's colour array (e.g. a slot padded onto the printer's
|
||||
// nozzle count); guard before indexing so a stale slot index cannot read past the end.
|
||||
if (m_filament_idx < 0 || m_filament_idx >= static_cast<int>(colors->values.size())) {
|
||||
BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": m_filament_idx %1% out of range %2%") % m_filament_idx % colors->values.size();
|
||||
return;
|
||||
}
|
||||
wxColour current_clr(colors->values[m_filament_idx]);
|
||||
if (!current_clr.IsOk())
|
||||
current_clr = wxColour(0, 0, 0); // Don't set alfa to transparence
|
||||
|
||||
@@ -0,0 +1,232 @@
|
||||
#include "SysInfoDialog.hpp"
|
||||
#include "I18N.hpp"
|
||||
#include "3DScene.hpp"
|
||||
#include "GUI.hpp"
|
||||
#include "../Utils/UndoRedo.hpp"
|
||||
#include "Plater.hpp"
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <Eigen/Core>
|
||||
|
||||
#include <wx/clipbrd.h>
|
||||
#include <wx/platinfo.h>
|
||||
#include "GUI_App.hpp"
|
||||
#include "MainFrame.hpp"
|
||||
#include "wxExtensions.hpp"
|
||||
#include "libslic3r/BlacklistedLibraryCheck.hpp"
|
||||
#include "libslic3r/Color.hpp"
|
||||
#include "format.hpp"
|
||||
|
||||
#ifdef _WIN32
|
||||
// The standard Windows includes.
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <Windows.h>
|
||||
#include <psapi.h>
|
||||
#endif /* _WIN32 */
|
||||
|
||||
namespace Slic3r {
|
||||
namespace GUI {
|
||||
|
||||
std::string get_main_info(bool format_as_html)
|
||||
{
|
||||
std::stringstream out;
|
||||
|
||||
std::string b_start = format_as_html ? "<b>" : "";
|
||||
std::string b_end = format_as_html ? "</b>" : "";
|
||||
std::string line_end = format_as_html ? "<br>" : "\n";
|
||||
|
||||
if (!format_as_html)
|
||||
out << b_start << (wxGetApp().is_editor() ? SLIC3R_APP_FULL_NAME : GCODEVIEWER_APP_NAME) << b_end << line_end;
|
||||
out << b_start << "Version: " << b_end << SLIC3R_VERSION << line_end;
|
||||
out << b_start << "Build: " << b_end << (wxGetApp().is_editor() ? SLIC3R_BUILD_ID : GCODEVIEWER_BUILD_ID) << line_end;
|
||||
out << line_end;
|
||||
out << b_start << "Operating System: " << b_end << wxPlatformInfo::Get().GetOperatingSystemFamilyName() << line_end;
|
||||
out << b_start << "System Architecture: " << b_end << wxPlatformInfo::Get().GetArchName() << line_end;
|
||||
out << b_start <<
|
||||
#if defined _WIN32
|
||||
"Windows Version: "
|
||||
#else
|
||||
// Hopefully some kind of unix / linux.
|
||||
"System Version: "
|
||||
#endif
|
||||
<< b_end << wxPlatformInfo::Get().GetOperatingSystemDescription() << line_end;
|
||||
out << b_start << "Total RAM size [MB]: " << b_end << Slic3r::format_memsize_MB(Slic3r::total_physical_memory());
|
||||
|
||||
return out.str();
|
||||
}
|
||||
|
||||
std::string get_mem_info(bool format_as_html)
|
||||
{
|
||||
std::stringstream out;
|
||||
|
||||
std::string b_start = format_as_html ? "<b>" : "";
|
||||
std::string b_end = format_as_html ? "</b>" : "";
|
||||
std::string line_end = format_as_html ? "<br>" : "\n";
|
||||
|
||||
std::string mem_info_str = log_memory_info(true);
|
||||
std::istringstream mem_info(mem_info_str);
|
||||
std::string value;
|
||||
while (std::getline(mem_info, value, ':')) {
|
||||
out << b_start << (value+": ") << b_end;
|
||||
std::getline(mem_info, value, ';');
|
||||
out << value << line_end;
|
||||
}
|
||||
|
||||
const Slic3r::UndoRedo::Stack &stack = wxGetApp().plater()->undo_redo_stack_main();
|
||||
out << b_start << "RAM size reserved for the Undo / Redo stack: " << b_end << Slic3r::format_memsize_MB(stack.get_memory_limit()) << line_end;
|
||||
out << b_start << "RAM size occupied by the Undo / Redo stack: " << b_end << Slic3r::format_memsize_MB(stack.memsize()) << line_end << line_end;
|
||||
|
||||
return out.str();
|
||||
}
|
||||
|
||||
SysInfoDialog::SysInfoDialog()
|
||||
: DPIDialog(static_cast<wxWindow*>(wxGetApp().mainframe), wxID_ANY, (wxGetApp().is_editor() ? wxString(SLIC3R_APP_FULL_NAME) : wxString(GCODEVIEWER_APP_NAME)) + " - " + _L("System Information"), wxDefaultPosition, wxDefaultSize, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
|
||||
{
|
||||
wxColour bgr_clr = wxGetApp().get_window_default_clr();//wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
|
||||
SetBackgroundColour(bgr_clr);
|
||||
SetFont(wxGetApp().normal_font());
|
||||
|
||||
wxBoxSizer* hsizer = new wxBoxSizer(wxHORIZONTAL);
|
||||
hsizer->SetMinSize(wxSize(50 * wxGetApp().em_unit(), -1));
|
||||
|
||||
auto main_sizer = new wxBoxSizer(wxVERTICAL);
|
||||
main_sizer->Add(hsizer, 1, wxEXPAND | wxALL, 10);
|
||||
|
||||
// logo
|
||||
m_logo_bmp = ScalableBitmap(this, wxGetApp().logo_name(), 192);
|
||||
m_logo = new wxStaticBitmap(this, wxID_ANY, m_logo_bmp.bmp());
|
||||
hsizer->Add(m_logo, 0, wxALIGN_CENTER_VERTICAL);
|
||||
|
||||
wxBoxSizer* vsizer = new wxBoxSizer(wxVERTICAL);
|
||||
hsizer->Add(vsizer, 1, wxEXPAND|wxLEFT, 20);
|
||||
|
||||
// title
|
||||
{
|
||||
wxStaticText* title = new wxStaticText(this, wxID_ANY, wxGetApp().is_editor() ? SLIC3R_APP_FULL_NAME : GCODEVIEWER_APP_NAME, wxDefaultPosition, wxDefaultSize);
|
||||
wxFont title_font = wxGetApp().bold_font();
|
||||
title_font.SetFamily(wxFONTFAMILY_ROMAN);
|
||||
title_font.SetPointSize(22);
|
||||
title->SetFont(title_font);
|
||||
vsizer->Add(title, 0, wxEXPAND | wxTOP, wxGetApp().em_unit()/*50*/);
|
||||
}
|
||||
|
||||
// main_info_text
|
||||
wxFont font = get_default_font(this);
|
||||
const auto text_clr = wxGetApp().get_label_clr_default();//wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
|
||||
auto text_clr_str = encode_color(ColorRGB(text_clr.Red(), text_clr.Green(), text_clr.Blue()));
|
||||
auto bgr_clr_str = encode_color(ColorRGB(bgr_clr.Red(), bgr_clr.Green(), bgr_clr.Blue()));
|
||||
|
||||
const int fs = font.GetPointSize() - 1;
|
||||
int size[] = { static_cast<int>(fs*1.5), static_cast<int>(fs*1.4), static_cast<int>(fs*1.3), fs, fs, fs, fs };
|
||||
|
||||
m_html = new wxHtmlWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_NEVER);
|
||||
{
|
||||
m_html->SetFonts(font.GetFaceName(), font.GetFaceName(), size);
|
||||
m_html->SetBorders(2);
|
||||
const auto text = wxString::Format(
|
||||
"<html>"
|
||||
"<body bgcolor= %s link= %s>"
|
||||
"<font color=%s>"
|
||||
"%s"
|
||||
"</font>"
|
||||
"</body>"
|
||||
"</html>", bgr_clr_str, text_clr_str, text_clr_str,
|
||||
get_main_info(true));
|
||||
m_html->SetPage(text);
|
||||
vsizer->Add(m_html, 1, wxEXPAND | wxBOTTOM, wxGetApp().em_unit());
|
||||
}
|
||||
|
||||
// opengl_info
|
||||
m_opengl_info_html = new wxHtmlWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHW_SCROLLBAR_AUTO);
|
||||
{
|
||||
m_opengl_info_html->SetMinSize(wxSize(-1, 16 * wxGetApp().em_unit()));
|
||||
m_opengl_info_html->SetFonts(font.GetFaceName(), font.GetFaceName(), size);
|
||||
m_opengl_info_html->SetBorders(10);
|
||||
wxString blacklisted_libraries_message;
|
||||
#ifdef WIN32
|
||||
std::wstring blacklisted_libraries = BlacklistedLibraryCheck::get_instance().get_blacklisted_string().c_str();
|
||||
if (! blacklisted_libraries.empty())
|
||||
blacklisted_libraries_message = wxString("<br><b>") + _L("Blacklisted libraries loaded into OrcaSlicer process:") + "</b><br>" + blacklisted_libraries;
|
||||
#endif // WIN32
|
||||
const auto text = GUI::format_wxstr(
|
||||
"<html>"
|
||||
"<body bgcolor= %s link= %s>"
|
||||
"<font color=%s>"
|
||||
"%s<br>%s<br>%s<br>%s"
|
||||
"</font>"
|
||||
"</body>"
|
||||
"</html>", bgr_clr_str, text_clr_str, text_clr_str,
|
||||
blacklisted_libraries_message,
|
||||
get_mem_info(true), wxGetApp().get_gl_info(false),
|
||||
"<b>" + _L("SIMD is supported:") + "</b> " + Eigen::SimdInstructionSetsInUse());
|
||||
|
||||
m_opengl_info_html->SetPage(text);
|
||||
main_sizer->Add(m_opengl_info_html, 1, wxEXPAND | wxBOTTOM, 15);
|
||||
}
|
||||
|
||||
wxStdDialogButtonSizer* buttons = this->CreateStdDialogButtonSizer(wxOK);
|
||||
m_btn_copy_to_clipboard = new wxButton(this, wxID_ANY, _L("Copy to Clipboard"), wxDefaultPosition, wxDefaultSize);
|
||||
|
||||
buttons->Insert(0, m_btn_copy_to_clipboard, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 5);
|
||||
m_btn_copy_to_clipboard->Bind(wxEVT_BUTTON, &SysInfoDialog::onCopyToClipboard, this);
|
||||
|
||||
this->SetEscapeId(wxID_OK);
|
||||
this->Bind(wxEVT_BUTTON, &SysInfoDialog::onCloseDialog, this, wxID_OK);
|
||||
main_sizer->Add(buttons, 0, wxEXPAND | wxRIGHT | wxBOTTOM, 3);
|
||||
|
||||
wxGetApp().UpdateDlgDarkUI(this, true);
|
||||
|
||||
// this->Bind(wxEVT_LEFT_DOWN, &SysInfoDialog::onCloseDialog, this);
|
||||
// logo->Bind(wxEVT_LEFT_DOWN, &SysInfoDialog::onCloseDialog, this);
|
||||
|
||||
SetSizer(main_sizer);
|
||||
main_sizer->SetSizeHints(this);
|
||||
}
|
||||
|
||||
void SysInfoDialog::on_dpi_changed(const wxRect &suggested_rect)
|
||||
{
|
||||
m_logo_bmp.msw_rescale();
|
||||
m_logo->SetBitmap(m_logo_bmp.bmp());
|
||||
|
||||
wxFont font = get_default_font(this);
|
||||
const int fs = font.GetPointSize() - 1;
|
||||
int font_size[] = { static_cast<int>(fs*1.5), static_cast<int>(fs*1.4), static_cast<int>(fs*1.3), fs, fs, fs, fs };
|
||||
|
||||
m_html->SetFonts(font.GetFaceName(), font.GetFaceName(), font_size);
|
||||
m_html->Refresh();
|
||||
|
||||
const int& em = em_unit();
|
||||
|
||||
msw_buttons_rescale(this, em, { wxID_OK, m_btn_copy_to_clipboard->GetId() });
|
||||
|
||||
m_opengl_info_html->SetMinSize(wxSize(-1, 16 * em));
|
||||
m_opengl_info_html->SetFonts(font.GetFaceName(), font.GetFaceName(), font_size);
|
||||
m_opengl_info_html->Refresh();
|
||||
|
||||
const wxSize& size = wxSize(65 * em, 55 * em);
|
||||
|
||||
SetMinSize(size);
|
||||
Fit();
|
||||
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void SysInfoDialog::onCopyToClipboard(wxEvent &)
|
||||
{
|
||||
wxTheClipboard->Open();
|
||||
const auto text = get_main_info(false) + "\n" + wxGetApp().get_gl_info(true);
|
||||
wxTheClipboard->SetData(new wxTextDataObject(text));
|
||||
wxTheClipboard->Close();
|
||||
}
|
||||
|
||||
void SysInfoDialog::onCloseDialog(wxEvent &)
|
||||
{
|
||||
this->EndModal(wxID_CLOSE);
|
||||
}
|
||||
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
@@ -0,0 +1,36 @@
|
||||
#ifndef slic3r_GUI_SysInfoDialog_hpp_
|
||||
#define slic3r_GUI_SysInfoDialog_hpp_
|
||||
|
||||
#include <wx/event.h>
|
||||
#include <wx/wx.h>
|
||||
#include <wx/html/htmlwin.h>
|
||||
|
||||
#include "GUI_Utils.hpp"
|
||||
#include "wxExtensions.hpp"
|
||||
|
||||
namespace Slic3r {
|
||||
namespace GUI {
|
||||
|
||||
class SysInfoDialog : public DPIDialog
|
||||
{
|
||||
ScalableBitmap m_logo_bmp;
|
||||
wxStaticBitmap* m_logo;
|
||||
wxHtmlWindow* m_opengl_info_html;
|
||||
wxHtmlWindow* m_html;
|
||||
|
||||
wxButton* m_btn_copy_to_clipboard;
|
||||
|
||||
public:
|
||||
SysInfoDialog();
|
||||
|
||||
protected:
|
||||
void on_dpi_changed(const wxRect &suggested_rect) override;
|
||||
|
||||
private:
|
||||
void onCopyToClipboard(wxEvent &);
|
||||
void onCloseDialog(wxEvent &);
|
||||
};
|
||||
} // namespace GUI
|
||||
} // namespace Slic3r
|
||||
|
||||
#endif
|
||||
@@ -3098,7 +3098,6 @@ void TabPrint::build()
|
||||
optgroup = page->new_optgroup(L("Raft"), L"param_raft");
|
||||
optgroup->append_single_option_line("raft_layers", "support_settings_raft");
|
||||
optgroup->append_single_option_line("raft_contact_distance", "support_settings_raft");
|
||||
optgroup->append_single_option_line("raft_expansion", "support_settings_raft");
|
||||
|
||||
optgroup = page->new_optgroup(L("Filament for Supports"), L"param_support_filament");
|
||||
optgroup->append_single_option_line("support_filament", "support_settings_filament#base");
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
#include "Widgets/StateColor.hpp"
|
||||
#include "Widgets/StaticLine.hpp"
|
||||
#include "libslic3r/ColorDecomposeRecipe.hpp"
|
||||
#include "libslic3r/MeshRepair.hpp"
|
||||
#include "libslic3r/MeshBoolean.hpp"
|
||||
#include "libslic3r/TriangleSelector.hpp"
|
||||
|
||||
#include <utility>
|
||||
@@ -2436,25 +2436,25 @@ void TextureImportDialog::start_computation(bool auto_color, bool initial)
|
||||
settings.target_colors_num = auto_color ? 0 : (size_t)m_param_color_count;
|
||||
settings.smooth_weight = m_param_smooth / 10.0;
|
||||
settings.mesh_repair_decision = m_mesh_repair_decision;
|
||||
// BBS repairs the mesh through the Windows 3D SDK, which is only available on Windows
|
||||
// builds that ship the SDK. Orca's CGAL-based repair (MeshBoolean::cgal::repair) works
|
||||
// on all three platforms, so use that instead.
|
||||
settings.mesh_repair_callback = [](const indexed_triangle_set& mesh,
|
||||
indexed_triangle_set& repaired_mesh,
|
||||
std::function<void(const char*, unsigned)> progress_callback,
|
||||
std::function<bool()> cancel_callback,
|
||||
std::string* error_message) -> bool {
|
||||
if (cancel_callback && cancel_callback())
|
||||
return false;
|
||||
if (progress_callback)
|
||||
progress_callback(_u8L("Repairing mesh").c_str(), 0);
|
||||
|
||||
struct Canceled {};
|
||||
TriangleMesh tm(mesh);
|
||||
try {
|
||||
if (!repair_mesh(tm, nullptr, error_message, [&cancel_callback](int) {
|
||||
if (cancel_callback && cancel_callback())
|
||||
throw Canceled();
|
||||
}))
|
||||
return false;
|
||||
} catch (const Canceled &) {
|
||||
if (!MeshBoolean::cgal::repair(tm, nullptr, error_message))
|
||||
return false;
|
||||
|
||||
if (cancel_callback && cancel_callback())
|
||||
return false;
|
||||
}
|
||||
repaired_mesh = tm.its;
|
||||
if (progress_callback)
|
||||
progress_callback(_u8L("Repairing mesh").c_str(), 100);
|
||||
@@ -2683,12 +2683,12 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
|
||||
m_progress_dlg = nullptr;
|
||||
}
|
||||
|
||||
#ifdef HAS_WIN10SDK
|
||||
Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
|
||||
_L("The mesh has non-manifold geometry or open boundaries. You can import it as-is or repair it before importing."),
|
||||
_L("Mesh repair"), wxYES_NO | wxCANCEL | wxICON_WARNING | wxYES_DEFAULT);
|
||||
_L("The mesh has non-manifold geometry or open boundaries. You can import it as-is or repair it with Windows 3D repair service before importing."),
|
||||
_L("Mesh repair"), wxYES_NO | wxICON_WARNING | wxYES_DEFAULT);
|
||||
dlg.SetButtonLabel(wxID_YES, _L("Import without repair"));
|
||||
dlg.SetButtonLabel(wxID_NO, _L("Repair and import"), true);
|
||||
dlg.SetButtonLabel(wxID_CANCEL, _L("Cancel"));
|
||||
// "Repair and import" is the recommended action here, so the accent moves off the default YES
|
||||
// button onto NO. MsgDialog::add_button already styled both as ButtonType::Choice, so restyling
|
||||
// with the same type swaps only the palette and leaves the geometry alone.
|
||||
@@ -2704,7 +2704,17 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
|
||||
dlg.Fit();
|
||||
dlg.CenterOnParent();
|
||||
int ret = dlg.ShowModal();
|
||||
if (ret == wxID_CANCEL) {
|
||||
m_mesh_repair_decision = (ret == wxID_NO)
|
||||
? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
|
||||
: Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
|
||||
#else
|
||||
Slic3r::GUI::MessageDialog dlg(initial ? GetParent() : this,
|
||||
_L("Please note that the mesh has non-manifold geometry or open boundaries."),
|
||||
_L("Mesh issue"), wxOK | wxCANCEL | wxICON_WARNING | wxOK_DEFAULT);
|
||||
dlg.SetButtonLabel(wxID_OK, _L("Continue"), true);
|
||||
dlg.SetButtonLabel(wxID_CANCEL, _L("Cancel"));
|
||||
int ret = dlg.ShowModal();
|
||||
if (ret != wxID_OK) {
|
||||
m_cancel_flag = true;
|
||||
if (initial) {
|
||||
m_initial_computation_cancelled = true;
|
||||
@@ -2717,9 +2727,8 @@ void TextureImportDialog::on_mesh_repair_decision_required(wxCommandEvent&)
|
||||
}
|
||||
return;
|
||||
}
|
||||
m_mesh_repair_decision = (ret == wxID_NO)
|
||||
? Slic3r::TexturePaintingSettings::MeshRepairDecision::RepairAndImport
|
||||
: Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
|
||||
m_mesh_repair_decision = Slic3r::TexturePaintingSettings::MeshRepairDecision::ImportWithoutRepair;
|
||||
#endif
|
||||
|
||||
start_computation(auto_color, initial);
|
||||
}
|
||||
|
||||
@@ -36,7 +36,6 @@
|
||||
|
||||
#include "3DScene.hpp"
|
||||
#include "BitmapCache.hpp"
|
||||
#include "GLCanvas3D.hpp"
|
||||
#include "GLShader.hpp"
|
||||
#include "GUI_App.hpp"
|
||||
#include "I18N.hpp"
|
||||
@@ -940,8 +939,7 @@ void UVEditorCanvas::on_mouse(wxMouseEvent &evt)
|
||||
m_active_edge = (hit.first >= 0 && is_edge_selected(hit)) ? hit : std::pair<int, int>{ -1, -1 };
|
||||
m_gesture = (m_active_edge.first >= 0) ? Gesture::MoveEdge : Gesture::Pan;
|
||||
} else {
|
||||
const std::vector<int> selection_before = m_selection;
|
||||
const int hit = island_at(uv);
|
||||
const int hit = island_at(uv);
|
||||
if (hit >= 0) {
|
||||
if (evt.ShiftDown()) {
|
||||
// Shift adds to the selection (and makes the clicked one the new primary).
|
||||
@@ -971,10 +969,6 @@ void UVEditorCanvas::on_mouse(wxMouseEvent &evt)
|
||||
m_selected_island = -1;
|
||||
}
|
||||
m_gesture = (m_selected_island >= 0) ? Gesture::MoveIsland : Gesture::Pan;
|
||||
// The owner shows the selection on the model and would not hear of this click otherwise in time: a
|
||||
// click that clears the selection starts no gesture, and one that sets it reports only on release.
|
||||
if (m_selection != selection_before)
|
||||
run_command(Command::SelectionChanged);
|
||||
}
|
||||
grab_mouse();
|
||||
Refresh();
|
||||
@@ -1325,13 +1319,8 @@ void UVEditorCanvas::on_size(wxSizeEvent &evt)
|
||||
// Update() flushes it immediately - still through the normal paint path (unlike calling
|
||||
// render() directly), which matters because this canvas shares the app's one GL context with
|
||||
// the 3D view and must not hijack it outside its own paint.
|
||||
// Not while a 3D canvas frame is in progress, though: wxGTK delivers this size event synchronously
|
||||
// when the texture displacement gizmo relays out the pane from its ImGui panel, i.e. from inside
|
||||
// that frame, and flushing the paint there would take the shared context away from it. The Refresh()
|
||||
// then runs the paint once the frame is over.
|
||||
Refresh();
|
||||
if (!GLCanvas3D::is_frame_in_progress())
|
||||
Update();
|
||||
Update();
|
||||
}
|
||||
|
||||
void UVEditorCanvas::on_leave(wxMouseEvent &evt)
|
||||
@@ -1352,16 +1341,6 @@ void UVEditorCanvas::render()
|
||||
{
|
||||
if (m_context == nullptr || !IsShownOnScreen())
|
||||
return;
|
||||
// Painted from inside a 3D canvas frame - a modal dialog the gizmo opened from its ImGui panel runs
|
||||
// this paint, as does any other synchronous event raised there. Making this surface current now
|
||||
// would take the shared context away from that canvas mid-frame: its remaining draws would land
|
||||
// here and, on Mesa/X11, its SwapBuffers() would be a fatal BadMatch. Skip, but ask for another
|
||||
// paint so the skipped one is not simply lost. The pane stays stale for as long as a nested modal
|
||||
// loop keeps a frame on the stack, which is behind the dialog anyway.
|
||||
if (GLCanvas3D::is_frame_in_progress()) {
|
||||
Refresh();
|
||||
return;
|
||||
}
|
||||
|
||||
// wxGLCanvas::SetCurrent() genuinely fails (returns false) on a canvas that isn't shown on
|
||||
// screen, and can also fail on a pixel-format mismatch with the context - and every GL call
|
||||
|
||||
@@ -108,12 +108,10 @@ public:
|
||||
// the command callback - the canvas has the selection and the view, the gizmo has the layer.
|
||||
// `value` carries the new setting for the Set* commands (an angle, a flag as 0/1, or an index into
|
||||
// SelectMode / Background) and is 0 otherwise.
|
||||
// SelectionChanged is sent by the canvas itself when a click changes the island selection. It carries
|
||||
// nothing: the owner reads selected_islands() back, and only needs telling that it should look.
|
||||
enum class Command {
|
||||
FrameAll, ToggleSnap, AverageScale, CutSelectedIsland, ProjectFromView, JoinSelected, UnjoinSelected,
|
||||
Unwrap, SetSeamAngle, SetConnectIslands, SetSelectMode, SetMarkSeams, SetSeamPath, ClearSeams, ClearUVEdits,
|
||||
SetBackground, PickTexture, PaneClosed, SelectionChanged
|
||||
SetBackground, PickTexture, PaneClosed
|
||||
};
|
||||
void run_command(Command cmd, float value = 0.f);
|
||||
using CommandFn = std::function<void(Command, float)>;
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
#ifndef slic3r_wxinit_hpp_
|
||||
#define slic3r_wxinit_hpp_
|
||||
|
||||
#include <wx/wx.h>
|
||||
#include <wx/intl.h>
|
||||
#include <wx/html/htmlwin.h>
|
||||
|
||||
// Perl redefines a _ macro, so we undef this one
|
||||
#undef _
|
||||
|
||||
// We do want to use translation however, so define it as __ so we can do a find/replace
|
||||
// later when we no longer need to undef _
|
||||
#define __(s) wxGetTranslation((s))
|
||||
|
||||
#endif
|
||||
@@ -3,115 +3,240 @@
|
||||
#include <algorithm>
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <cmath>
|
||||
#include <condition_variable>
|
||||
#include <cstddef>
|
||||
#include "libslic3r/TriangleMesh.hpp"
|
||||
#include "libslic3r/BoundingBox.hpp"
|
||||
#include "libslic3r/Point.hpp"
|
||||
#include "libslic3r/libslic3r.h"
|
||||
#include <exception>
|
||||
#include <cstddef>
|
||||
#include "libslic3r/Exception.hpp"
|
||||
#include <limits>
|
||||
#include <mutex>
|
||||
#include "slic3r/GUI/Widgets/ProgressDialog.hpp"
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <wx/string.h>
|
||||
|
||||
#include "libslic3r/Format/bbs_3mf.hpp"
|
||||
#include "libslic3r/MeshRepair.hpp"
|
||||
#include "libslic3r/MeshBoolean.hpp"
|
||||
#include "libslic3r/Model.hpp"
|
||||
#include "libslic3r/Format/bbs_3mf.hpp"
|
||||
#include "libslic3r/format.hpp"
|
||||
#include "libslic3r/Thread.hpp"
|
||||
#include "slic3r/GUI/I18N.hpp"
|
||||
#include "slic3r/GUI/Widgets/ProgressDialog.hpp"
|
||||
#include "../GUI/I18N.hpp"
|
||||
#include "libslic3r/TriangleSelector.hpp"
|
||||
|
||||
// Orca: This file provides utilities for repairing 3D model meshes using the CGAL library, handling mesh splitting, merging, and boolean operations.
|
||||
|
||||
namespace Slic3r {
|
||||
|
||||
namespace {
|
||||
|
||||
class RepairCanceledException : public std::exception
|
||||
// Orca: Helper functions for analyzing mesh properties and transformations.
|
||||
|
||||
bool is_not_3dimensional_part(const TriangleMesh &mesh)
|
||||
{
|
||||
public:
|
||||
const char *what() const noexcept override { return "Model repair has been canceled"; }
|
||||
};
|
||||
// Orca: Determines if a mesh is degenerate or represents a non-3dimensional part by checking volume and bounding box dimensions.
|
||||
if (mesh.its.indices.empty())
|
||||
return true;
|
||||
|
||||
indexed_triangle_set tmp = mesh.its;
|
||||
its_remove_degenerate_faces(tmp, true);
|
||||
if (tmp.indices.empty())
|
||||
return true;
|
||||
|
||||
const BoundingBoxf3 bbox = mesh.bounding_box();
|
||||
const Vec3d size = bbox.size();
|
||||
const double min_dim = std::min(size.x(), std::min(size.y(), size.z()));
|
||||
const double max_dim = std::max(size.x(), std::max(size.y(), size.z()));
|
||||
if (min_dim <= EPSILON)
|
||||
return true;
|
||||
|
||||
const double volume = std::abs(its_volume(mesh.its));
|
||||
const double bbox_volume = size.x() * size.y() * size.z();
|
||||
if (volume <= EPSILON)
|
||||
return true;
|
||||
|
||||
const double min_relative_thickness = 1e-6;
|
||||
const double min_volume_ratio = 1e-6;
|
||||
if (min_dim / max_dim <= min_relative_thickness)
|
||||
return true;
|
||||
if (bbox_volume > 0.0 && volume / bbox_volume <= min_volume_ratio)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dialog, const wxString &msg_header, std::string &fix_result, bool keep_painting,
|
||||
bool *modified)
|
||||
// Orca: Exception class for handling user-initiated cancellation of model repair operations.
|
||||
class RepairCanceledException : public std::exception {
|
||||
public:
|
||||
const char* what() const noexcept override { return "Model repair has been canceled"; }
|
||||
};
|
||||
|
||||
// Orca: Main function to repair model objects using CGAL, with progress dialog and cancellation support.
|
||||
// Returns false if fixing was canceled. fix_result contains error message if failed.
|
||||
bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dialog, const wxString &msg_header, std::string &fix_result, bool keep_painting)
|
||||
{
|
||||
// Keeps the backup manager from reading a mesh while the worker replaces it.
|
||||
// Hold SaveObjectGaurd to prevent backup manager from racing concurrent mesh mutations (use-after-free).
|
||||
SaveObjectGaurd backup_gaurd(model_object);
|
||||
|
||||
std::vector<ModelVolume *> volumes;
|
||||
if (volume_idx < 0)
|
||||
volumes = model_object.volumes;
|
||||
else if (std::size_t(volume_idx) < model_object.volumes.size())
|
||||
volumes.push_back(model_object.volumes[volume_idx]);
|
||||
|
||||
std::mutex mtx;
|
||||
// Orca: Synchronization primitives for progress updates between worker thread and GUI.
|
||||
std::mutex mtx;
|
||||
std::condition_variable condition;
|
||||
struct Progress
|
||||
{
|
||||
struct Progress {
|
||||
std::string message;
|
||||
int percent = 0;
|
||||
bool updated = false;
|
||||
int percent = 0;
|
||||
bool updated = false;
|
||||
} progress;
|
||||
|
||||
std::atomic<bool> canceled = false;
|
||||
std::atomic<bool> finished = false;
|
||||
bool any_modified = false;
|
||||
std::string errors;
|
||||
|
||||
auto on_progress = [&mtx, &condition, &progress](const std::string &msg, int percent) {
|
||||
std::lock_guard<std::mutex> lock(mtx);
|
||||
bool success = false;
|
||||
size_t ivolume = 0;
|
||||
|
||||
// Orca: Lambda for updating progress from worker thread.
|
||||
auto on_progress = [&mtx, &condition, &ivolume, &model_object, &progress](const std::string &msg, unsigned prcnt) {
|
||||
std::unique_lock<std::mutex> lock(mtx);
|
||||
progress.message = msg;
|
||||
progress.percent = percent;
|
||||
const size_t total = std::max<size_t>(1, model_object.volumes.size());
|
||||
progress.percent = int(std::floor((float(prcnt) + float(ivolume) * 100.f) / float(total)));
|
||||
progress.updated = true;
|
||||
condition.notify_all();
|
||||
};
|
||||
|
||||
auto worker_thread = std::thread([&]() {
|
||||
set_current_thread_name("cgal_fix_model");
|
||||
// Orca: Worker thread that performs the actual model repair operations.
|
||||
auto worker_thread = std::thread([&model_object, volume_idx, &ivolume, on_progress, &success, &canceled, &finished, &fix_result, keep_painting]() {
|
||||
try {
|
||||
for (std::size_t i = 0; i < volumes.size(); ++i) {
|
||||
ModelVolume *volume = volumes[i];
|
||||
const std::string name = volumes.size() > 1 ? volume->name : std::string();
|
||||
const auto report = [&](int percent) {
|
||||
if (canceled)
|
||||
throw RepairCanceledException();
|
||||
on_progress(name, int((100 * i + std::size_t(percent)) / volumes.size()));
|
||||
};
|
||||
report(0);
|
||||
set_current_thread_name("cgal_fix_model");
|
||||
|
||||
MeshRepairStats stats;
|
||||
std::string error;
|
||||
if (!volume->repair(keep_painting, &stats, &error, report))
|
||||
errors += (errors.empty() ? "" : "\n") + (volumes.size() > 1 ? volume->name + ": " : std::string()) + error;
|
||||
any_modified = any_modified || stats.modified;
|
||||
size_t start_volume = volume_idx == -1 ? 0 : size_t(volume_idx);
|
||||
size_t end_volume = volume_idx == -1 ? std::numeric_limits<size_t>::max() : size_t(volume_idx);
|
||||
|
||||
for (ivolume = start_volume; ivolume < model_object.volumes.size(); ++ivolume) {
|
||||
if (volume_idx != -1 && ivolume > end_volume)
|
||||
break;
|
||||
if (canceled)
|
||||
throw RepairCanceledException();
|
||||
|
||||
on_progress(_u8L("Repairing model object"), 10);
|
||||
|
||||
ModelVolume *volume = model_object.volumes[ivolume];
|
||||
|
||||
// Orca: Split splittable volumes into parts for individual processing.
|
||||
size_t parts_count = 1;
|
||||
if (volume->is_splittable()) {
|
||||
parts_count = volume->split(1, keep_painting);
|
||||
if (parts_count > 1) {
|
||||
const std::string msg = Slic3r::format(L("Split into %1% parts"), parts_count);
|
||||
on_progress(msg, 10);
|
||||
}
|
||||
}
|
||||
|
||||
size_t part_end = std::min(ivolume + parts_count - 1, model_object.volumes.size() - 1);
|
||||
if (volume_idx != -1)
|
||||
end_volume = part_end;
|
||||
|
||||
size_t removed_parts = 0;
|
||||
for (size_t idx = part_end + 1; idx > ivolume; --idx) {
|
||||
const size_t part_idx = idx - 1;
|
||||
const ModelVolume *part_volume = model_object.volumes[part_idx];
|
||||
if (!is_not_3dimensional_part(part_volume->mesh()))
|
||||
continue;
|
||||
|
||||
model_object.delete_volume(part_idx);
|
||||
++removed_parts;
|
||||
if (part_end > 0)
|
||||
--part_end;
|
||||
else
|
||||
part_end = 0;
|
||||
if (volume_idx != -1)
|
||||
end_volume = part_end;
|
||||
}
|
||||
|
||||
if (removed_parts >= parts_count) {
|
||||
ivolume = part_end;
|
||||
on_progress(_u8L("Repair finished"), 100);
|
||||
continue;
|
||||
}
|
||||
|
||||
for (size_t part_idx = ivolume; part_idx <= part_end && part_idx < model_object.volumes.size(); ++part_idx) {
|
||||
ModelVolume *part_volume = model_object.volumes[part_idx];
|
||||
TriangleMesh mesh = part_volume->mesh();
|
||||
if (its_num_open_edges(mesh.its) != 0) {
|
||||
|
||||
// Save painting for later remap
|
||||
const std::optional<TriangleSelector::SavedPainting> saved_painting = keep_painting ?
|
||||
part_volume->save_painting() :
|
||||
std::optional<TriangleSelector::SavedPainting>{};
|
||||
|
||||
std::string error;
|
||||
if (!MeshBoolean::cgal::repair(mesh, nullptr, &error))
|
||||
throw Slic3r::RuntimeError(error.empty() ? _u8L("Repair failed") : error);
|
||||
|
||||
part_volume->set_mesh(std::move(mesh));
|
||||
part_volume->calculate_convex_hull();
|
||||
part_volume->invalidate_convex_hull_2d();
|
||||
part_volume->set_new_unique_id();
|
||||
|
||||
// Remap paint back
|
||||
part_volume->restore_painting(saved_painting);
|
||||
}
|
||||
}
|
||||
|
||||
ivolume = part_end;
|
||||
|
||||
on_progress(_u8L("Repair finished"), 100);
|
||||
}
|
||||
} catch (const RepairCanceledException &) {
|
||||
|
||||
model_object.invalidate_bounding_box();
|
||||
|
||||
if (ivolume > 0)
|
||||
--ivolume;
|
||||
on_progress(_u8L("Repair finished"), 100);
|
||||
success = true;
|
||||
finished = true;
|
||||
} catch (RepairCanceledException &) {
|
||||
canceled = true;
|
||||
} catch (const std::exception &ex) {
|
||||
errors += (errors.empty() ? "" : "\n") + std::string(ex.what());
|
||||
finished = true;
|
||||
on_progress(_u8L("Repair canceled"), 100);
|
||||
} catch (std::exception &ex) {
|
||||
success = false;
|
||||
finished = true;
|
||||
fix_result = ex.what();
|
||||
on_progress(ex.what(), 100);
|
||||
}
|
||||
// Volumes repaired before a cancel or an error keep their new mesh.
|
||||
model_object.invalidate_bounding_box();
|
||||
finished = true;
|
||||
on_progress(_u8L("Repair finished"), 100);
|
||||
});
|
||||
|
||||
// Orca: Main GUI loop to update progress dialog and handle cancellation.
|
||||
while (!finished) {
|
||||
std::unique_lock<std::mutex> lock(mtx);
|
||||
condition.wait_for(lock, std::chrono::milliseconds(250), [&progress] { return progress.updated; });
|
||||
// One percent short of the maximum, so that the dialog does not close itself.
|
||||
if (!progress_dialog.Update(std::max(0, progress.percent - 1), msg_header + wxString::FromUTF8(progress.message)))
|
||||
condition.wait_for(lock, std::chrono::milliseconds(250), [&progress]{ return progress.updated; });
|
||||
|
||||
// Decrease progress percent slightly to avoid auto-closing.
|
||||
if (!progress_dialog.Update(progress.percent - 1, msg_header + _(progress.message)))
|
||||
canceled = true;
|
||||
else
|
||||
progress_dialog.Fit();
|
||||
|
||||
progress.updated = false;
|
||||
}
|
||||
|
||||
if (canceled) {
|
||||
// Nothing to show.
|
||||
} else if (success) {
|
||||
fix_result.clear();
|
||||
}
|
||||
|
||||
if (worker_thread.joinable())
|
||||
worker_thread.join();
|
||||
|
||||
fix_result = canceled ? std::string() : errors;
|
||||
if (modified)
|
||||
*modified = any_modified;
|
||||
return !canceled;
|
||||
}
|
||||
|
||||
|
||||
@@ -12,9 +12,8 @@ class Model;
|
||||
class ModelObject;
|
||||
class Print;
|
||||
|
||||
// Return false if fixing was canceled. fix_result is empty on success; modified tells whether any mesh changed.
|
||||
extern bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dlg, const wxString &msg_header, std::string &fix_result, bool keep_painting,
|
||||
bool *modified = nullptr);
|
||||
// Return false if fixing was canceled. fix_result is empty on success.
|
||||
extern bool fix_model_with_cgal_gui(ModelObject &model_object, int volume_idx, GUI::ProgressDialog &progress_dlg, const wxString &msg_header, std::string &fix_result, bool keep_painting);
|
||||
|
||||
} // namespace Slic3r
|
||||
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
#ifndef slic3r_GUI_Profile_hpp_
|
||||
#define slic3r_GUI_Profile_hpp_
|
||||
|
||||
// Profiling support using the Shiny intrusive profiler
|
||||
//#define SLIC3R_PROFILE_GUI
|
||||
#if defined(SLIC3R_PROFILE) && defined(SLIC3R_PROFILE_GUI)
|
||||
#include <Shiny/Shiny.h>
|
||||
#define SLIC3R_GUI_PROFILE_FUNC() PROFILE_FUNC()
|
||||
#define SLIC3R_GUI_PROFILE_BLOCK(name) PROFILE_BLOCK(name)
|
||||
#define SLIC3R_GUI_PROFILE_UPDATE() PROFILE_UPDATE()
|
||||
#define SLIC3R_GUI_PROFILE_OUTPUT(x) PROFILE_OUTPUT(x)
|
||||
#else
|
||||
#define SLIC3R_GUI_PROFILE_FUNC()
|
||||
#define SLIC3R_GUI_PROFILE_BLOCK(name)
|
||||
#define SLIC3R_GUI_PROFILE_UPDATE()
|
||||
#define SLIC3R_GUI_PROFILE_OUTPUT(x)
|
||||
#endif
|
||||
|
||||
#endif // slic3r_GUI_Profile_hpp_
|
||||
@@ -31,22 +31,6 @@ set_tests_properties(cli_project_missing_keys PROPERTIES
|
||||
SKIP_RETURN_CODE 77
|
||||
TIMEOUT 900)
|
||||
|
||||
add_test(NAME cli_arrange_rotations
|
||||
COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_arrange_rotations.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
|
||||
${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
|
||||
set_tests_properties(cli_arrange_rotations PROPERTIES
|
||||
LABELS "CLI;RequiresApp"
|
||||
SKIP_RETURN_CODE 77
|
||||
TIMEOUT 900)
|
||||
|
||||
add_test(NAME cli_no_suitable_objects
|
||||
COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_no_suitable_objects.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
|
||||
${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
|
||||
set_tests_properties(cli_no_suitable_objects PROPERTIES
|
||||
LABELS "CLI;RequiresApp"
|
||||
SKIP_RETURN_CODE 77
|
||||
TIMEOUT 900)
|
||||
|
||||
add_test(NAME cli_malformed_input
|
||||
COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_malformed_input.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON})
|
||||
set_tests_properties(cli_malformed_input PROPERTIES
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# End-to-end check of the CLI's arrange rotation policy.
|
||||
#
|
||||
# Arrange is translate-only unless --allow-rotations is passed, so a bar that fits the bed only
|
||||
# diagonally is not placed and the plate ends up with nothing fully inside the print volume. The
|
||||
# run must then say that rotations were off, on stderr as well as in result.json, because
|
||||
# result.json is written on Linux only. Passing the flag must place the same bar and slice it, and
|
||||
# an object that fits axis-aligned must be unaffected by the default.
|
||||
#
|
||||
# usage: test_cli_arrange_rotations.sh <orca-slicer binary> <python3> <resources/profiles/BBL>
|
||||
set -u
|
||||
|
||||
BIN="${1:-}"
|
||||
PY="${2:-python3}"
|
||||
PROFILES="${3:-}"
|
||||
# 77 is the test's SKIP_RETURN_CODE.
|
||||
[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
|
||||
[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; }
|
||||
|
||||
WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-arrange-rotations.XXXXXX")"
|
||||
trap 'rm -rf "$WORK"' EXIT
|
||||
|
||||
# box <file> <x> <y> <z>: an ASCII STL box, so the test needs no fixture.
|
||||
box() {
|
||||
"$PY" - "$@" <<'EOF'
|
||||
import sys
|
||||
|
||||
out, sx, sy, sz = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), float(sys.argv[4])
|
||||
v = [(x, y, z) for z in (0, sz) for y in (0, sy) for x in (0, sx)]
|
||||
with open(out, "w") as f:
|
||||
f.write("solid box\n")
|
||||
for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
|
||||
for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])):
|
||||
f.write("facet normal 0 0 0\nouter loop\n")
|
||||
for p in tri:
|
||||
f.write("vertex %g %g %g\n" % p)
|
||||
f.write("endloop\nendfacet\n")
|
||||
f.write("endsolid box\n")
|
||||
EOF
|
||||
}
|
||||
|
||||
# Longer than the 256 mm bed edge, shorter than its 362 mm diagonal: it fits only turned.
|
||||
box "$WORK/bar.stl" 300 10 5
|
||||
# Fits axis-aligned, so the default must not change anything for it.
|
||||
box "$WORK/cube.stl" 10 10 10
|
||||
|
||||
# slice <tag> <input> [option...] -> $WORK/<tag>/{rc,stdout,stderr,result.json}
|
||||
slice() {
|
||||
local out="$WORK/$1" input="$2"; shift 2
|
||||
mkdir -p "$out"
|
||||
timeout 300 "$BIN" --datadir "$out/datadir" \
|
||||
--load-settings "$PROFILES/machine/Bambu Lab X1 Carbon 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
|
||||
--load-defaultfila "$@" --slice 0 --outputdir "$out" "$input" \
|
||||
> "$out/stdout" 2> "$out/stderr"
|
||||
echo "$?" > "$out/rc"
|
||||
}
|
||||
|
||||
# exit_code <tag>: the CLI's negative code as the shell saw it, e.g. -50 arrives as 206.
|
||||
exit_code() { "$PY" -c "import sys; rc = int(open(sys.argv[1]).read()); print(rc - 256 if rc > 127 else rc)" "$WORK/$1/rc"; }
|
||||
|
||||
fail() { echo "FAIL: $*"; exit 1; }
|
||||
|
||||
# 1. Default: no flag, so no rotations, so the bar does not fit and the reason names rotation.
|
||||
slice default "$WORK/bar.stl"
|
||||
[ "$(exit_code default)" = "-50" ] || fail "default: expected -50, got $(exit_code default)"
|
||||
grep -q "Arrange ran without rotations" "$WORK/default/stderr" \
|
||||
|| fail "default: stderr does not mention rotations: $(cat "$WORK/default/stderr")"
|
||||
"$PY" - "$WORK/default/result.json" <<'EOF' || exit 1
|
||||
import json, sys
|
||||
|
||||
result = json.load(open(sys.argv[1]))
|
||||
if result["return_code"] != -50:
|
||||
sys.exit("FAIL: result.json return_code %s, expected -50" % result["return_code"])
|
||||
if "Arrange ran without rotations" not in result["error_string"]:
|
||||
sys.exit("FAIL: result.json error_string does not mention rotations: %s" % result["error_string"])
|
||||
EOF
|
||||
|
||||
# 2. The flag is coBool, so it takes no value: it must place the same bar and slice it.
|
||||
slice rotations "$WORK/bar.stl" --allow-rotations
|
||||
[ "$(exit_code rotations)" = "0" ] || fail "--allow-rotations: expected 0, got $(exit_code rotations); $(tail -n 5 "$WORK/rotations/stdout")"
|
||||
[ -s "$WORK/rotations/plate_1.gcode" ] || fail "--allow-rotations: no g-code written"
|
||||
|
||||
# 3. An object that fits axis-aligned is unaffected by the default, and says nothing about rotation.
|
||||
slice cube "$WORK/cube.stl"
|
||||
[ "$(exit_code cube)" = "0" ] || fail "cube: expected 0, got $(exit_code cube); $(tail -n 5 "$WORK/cube/stdout")"
|
||||
[ -s "$WORK/cube/plate_1.gcode" ] || fail "cube: no g-code written"
|
||||
grep -q "Arrange ran without rotations" "$WORK/cube/stderr" && fail "cube: unexpected rotation message on a successful run"
|
||||
|
||||
echo "PASS: arrange rotation default, its failure message, and the opt-in flag"
|
||||
@@ -1,83 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# The reason recorded for CLI_NO_SUITABLE_OBJECTS (-50) has to fit the input the CLI was given.
|
||||
# Any input format is arranged and sliced, so an object larger than the bed empties the plate just
|
||||
# as a 3mf with an empty plate does, and the recorded reason must not send such a caller off to
|
||||
# inspect a 3mf or an upload that is not part of their run.
|
||||
#
|
||||
# usage: test_cli_no_suitable_objects.sh <orca-slicer binary> <python3> <resources/profiles/BBL>
|
||||
set -u
|
||||
|
||||
BIN="${1:-}"
|
||||
PY="${2:-python3}"
|
||||
PROFILES="${3:-}"
|
||||
# 77 is the test's SKIP_RETURN_CODE.
|
||||
[ -x "$BIN" ] || { echo "SKIP: orca-slicer binary not found: $BIN"; exit 77; }
|
||||
[ -d "$PROFILES" ] || { echo "FAIL: profiles directory not found: $PROFILES"; exit 1; }
|
||||
|
||||
WORK="$(mktemp -d "${TMPDIR:-/tmp}/orca-cli-no-suitable-objects.XXXXXX")"
|
||||
trap 'rm -rf "$WORK"' EXIT
|
||||
|
||||
# box <file> <x> <y> <z>: an ASCII STL box, so the test needs no fixture.
|
||||
box() {
|
||||
"$PY" - "$@" <<'EOF'
|
||||
import sys
|
||||
|
||||
out, sx, sy, sz = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), float(sys.argv[4])
|
||||
v = [(x, y, z) for z in (0, sz) for y in (0, sy) for x in (0, sx)]
|
||||
with open(out, "w") as f:
|
||||
f.write("solid box\n")
|
||||
for a, b, c, d in ((0, 2, 3, 1), (4, 5, 7, 6), (0, 1, 5, 4), (2, 6, 7, 3), (0, 4, 6, 2), (1, 3, 7, 5)):
|
||||
for tri in ((v[a], v[b], v[c]), (v[a], v[c], v[d])):
|
||||
f.write("facet normal 0 0 0\nouter loop\n")
|
||||
for p in tri:
|
||||
f.write("vertex %g %g %g\n" % p)
|
||||
f.write("endloop\nendfacet\n")
|
||||
f.write("endsolid box\n")
|
||||
EOF
|
||||
}
|
||||
|
||||
# Wider than the 256 mm bed and wider than its 362 mm diagonal, so no placement can fit it.
|
||||
box "$WORK/slab.stl" 400 400 5
|
||||
# Fits, so the run must succeed: proves the harness itself is sound.
|
||||
box "$WORK/cube.stl" 10 10 10
|
||||
|
||||
# slice <tag> <input> [option...] -> $WORK/<tag>/{rc,stdout,stderr,result.json}
|
||||
slice() {
|
||||
local out="$WORK/$1" input="$2"; shift 2
|
||||
mkdir -p "$out"
|
||||
timeout 300 "$BIN" --datadir "$out/datadir" \
|
||||
--load-settings "$PROFILES/machine/Bambu Lab X1 Carbon 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
|
||||
"$@" --slice 0 --outputdir "$out" "$input" \
|
||||
> "$out/stdout" 2> "$out/stderr"
|
||||
echo "$?" > "$out/rc"
|
||||
}
|
||||
|
||||
# exit_code <tag>: the CLI's negative code as the shell saw it, e.g. -50 arrives as 206.
|
||||
exit_code() { "$PY" -c "import sys; rc = int(open(sys.argv[1]).read()); print(rc - 256 if rc > 127 else rc)" "$WORK/$1/rc"; }
|
||||
|
||||
fail() { echo "FAIL: $*"; exit 1; }
|
||||
|
||||
# --allow-rotations keeps this on the generic reason: a translate-only arrange has its own,
|
||||
# more specific one. The slab is wider than the 362 mm bed diagonal, so rotation cannot place it.
|
||||
slice slab "$WORK/slab.stl" --allow-rotations
|
||||
[ "$(exit_code slab)" = "-50" ] || fail "slab: expected -50, got $(exit_code slab); $(tail -n 5 "$WORK/slab/stdout")"
|
||||
"$PY" - "$WORK/slab/result.json" <<'EOF' || exit 1
|
||||
import json, sys
|
||||
|
||||
result = json.load(open(sys.argv[1]))
|
||||
if result["return_code"] != -50:
|
||||
sys.exit("FAIL: result.json return_code %s, expected -50" % result["return_code"])
|
||||
reason = result["error_string"]
|
||||
if not reason.strip():
|
||||
sys.exit("FAIL: result.json carries no error_string")
|
||||
# The run was handed an STL and asked for g-code: neither a 3mf nor an upload exists to check.
|
||||
for word in ("3mf", "3MF", "upload"):
|
||||
if word in reason:
|
||||
sys.exit("FAIL: error_string mentions %r for an STL run: %s" % (word, reason))
|
||||
EOF
|
||||
|
||||
slice cube "$WORK/cube.stl"
|
||||
[ "$(exit_code cube)" = "0" ] || fail "cube: expected 0, got $(exit_code cube); $(tail -n 5 "$WORK/cube/stdout")"
|
||||
[ -s "$WORK/cube/plate_1.gcode" ] || fail "cube: no g-code written"
|
||||
|
||||
echo "PASS: the no-suitable-objects reason fits a non-3mf run"
|
||||
@@ -1,35 +0,0 @@
|
||||
ISO-10303-21;
|
||||
HEADER;
|
||||
FILE_DESCRIPTION((''),'2;1');
|
||||
FILE_NAME('surface_model_geometric_set','2026-10-12T00:00:00',(''),(''),'','','');
|
||||
FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
|
||||
ENDSEC;
|
||||
DATA;
|
||||
#1=APPLICATION_CONTEXT('configuration controlled 3d designs of mechanical parts and assemblies');
|
||||
#2=APPLICATION_PROTOCOL_DEFINITION('international standard','config_control_design',1994,#1);
|
||||
#3=MECHANICAL_CONTEXT('',#1,'mechanical');
|
||||
#4=PRODUCT('surfaces','surfaces','',(#3));
|
||||
#5=PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE('','',#4,.NOT_KNOWN.);
|
||||
#6=DESIGN_CONTEXT('',#1,'design');
|
||||
#7=PRODUCT_DEFINITION('','',#5,#6);
|
||||
#8=PRODUCT_DEFINITION_SHAPE('','',#7);
|
||||
#9=SHAPE_DEFINITION_REPRESENTATION(#8,#20);
|
||||
#10=(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.));
|
||||
#11=(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.));
|
||||
#12=(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT());
|
||||
#13=UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-6),#10,'distance_accuracy_value','');
|
||||
#14=(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#13))GLOBAL_UNIT_ASSIGNED_CONTEXT((#10,#11,#12))REPRESENTATION_CONTEXT('',''));
|
||||
#15=CARTESIAN_POINT('',(0.,0.,0.));
|
||||
#16=DIRECTION('',(0.,0.,1.));
|
||||
#17=DIRECTION('',(1.,0.,0.));
|
||||
#18=AXIS2_PLACEMENT_3D('',#15,#16,#17);
|
||||
#19=GEOMETRIC_SET('',(#30,#40));
|
||||
#20=GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION('',(#18,#19),#14);
|
||||
#30=RECTANGULAR_TRIMMED_SURFACE('',#31,0.,10.,0.,10.,.T.,.T.);
|
||||
#31=PLANE('',#18);
|
||||
#40=RECTANGULAR_TRIMMED_SURFACE('',#41,0.,10.,0.,10.,.T.,.T.);
|
||||
#41=PLANE('',#42);
|
||||
#42=AXIS2_PLACEMENT_3D('',#43,#16,#17);
|
||||
#43=CARTESIAN_POINT('',(0.,0.,10.));
|
||||
ENDSEC;
|
||||
END-ISO-10303-21;
|
||||
@@ -178,61 +178,6 @@ bool is_block_move(const GCodeProcessorResult::MoveVertex &move)
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("Loaded manual tool change comments switch subsequent moves when enabled", "[GCodeProcessor][Regression]")
|
||||
{
|
||||
const bool manual_filament_change = GENERATE(false, true);
|
||||
CAPTURE(manual_filament_change);
|
||||
const DynamicPrintConfig config = Test::multifilament_config(2, {
|
||||
{ "gcode_flavor", "marlin" },
|
||||
{ "filament_type", "PLA;PETG" },
|
||||
{ "manual_filament_change", manual_filament_change },
|
||||
});
|
||||
const bool was_bbl_printer = GCodeProcessor::s_IsBBLPrinter;
|
||||
const ScopeGuard restore_bbl_printer([was_bbl_printer] { GCodeProcessor::s_IsBBLPrinter = was_bbl_printer; });
|
||||
GCodeProcessor::s_IsBBLPrinter = false;
|
||||
|
||||
ScopedTemporaryFile temp(".gcode");
|
||||
{
|
||||
std::ofstream out(temp.string());
|
||||
REQUIRE(out.is_open());
|
||||
out << "; generated by OrcaSlicer\n"
|
||||
<< "G90\nM83\nT0\n"
|
||||
<< "G1 X10 Y10 Z0.2 F3000\n"
|
||||
<< "G1 X20 E1\n"
|
||||
<< "; MANUAL_TOOL_CHANGE T1\n"
|
||||
<< "G1 X30\nG1 X40 E1\nG1 X50\nG1 X60 E1\n";
|
||||
// Let process_file load the embedded DynamicPrintConfig, as the standalone viewer does.
|
||||
out << "; CONFIG_BLOCK_START\n";
|
||||
for (const std::string &key : config.keys())
|
||||
out << "; " << key << " = " << config.opt_serialize(key) << '\n';
|
||||
out << "; CONFIG_BLOCK_END\n";
|
||||
REQUIRE(out.good());
|
||||
}
|
||||
|
||||
GCodeProcessor processor;
|
||||
processor.process_file(temp.string());
|
||||
const auto &result = processor.get_result();
|
||||
REQUIRE(result.filaments_count == 2);
|
||||
|
||||
constexpr unsigned int tool_change_line = 7;
|
||||
size_t before = 0;
|
||||
size_t after = 0;
|
||||
for (const auto &move : result.moves) {
|
||||
if (!is_block_move(move))
|
||||
continue;
|
||||
CAPTURE(move.gcode_id, move.type);
|
||||
if (move.gcode_id < tool_change_line) {
|
||||
++before;
|
||||
CHECK(move.extruder_id == 0);
|
||||
} else if (move.gcode_id > tool_change_line) {
|
||||
++after;
|
||||
CHECK(move.extruder_id == (manual_filament_change ? 1 : 0));
|
||||
}
|
||||
}
|
||||
REQUIRE(before > 0);
|
||||
REQUIRE(after > 0);
|
||||
}
|
||||
|
||||
TEST_CASE("Actual speed moves are inserted on their block's segment just before its move", "[GCodeProcessor]")
|
||||
{
|
||||
// 60 squares take several planner passes, which remap the blocks kept between passes.
|
||||
|
||||
@@ -1748,29 +1748,3 @@ TEST_CASE("Percent accelerations resolve against the option they are a percentag
|
||||
REQUIRE(accelerations_by_role[role_name] == std::set<int>{ value });
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Initial filament start G-code tolerates a list shorter than the filament count", "[GCodeWriter]")
|
||||
{
|
||||
// Two filaments but only one filament_start_gcode entry, and the only object prints on
|
||||
// filament 2, so the BBL export starts on a filament past the end of the list.
|
||||
DynamicPrintConfig config = multifilament_config(2);
|
||||
config.set_key_value("filament_start_gcode", new ConfigOptionStrings({"; filament start"}));
|
||||
|
||||
Model model;
|
||||
auto *obj = model.add_object();
|
||||
obj->add_volume(cube(20));
|
||||
obj->add_instance();
|
||||
obj->config.set_key_value("extruder", new ConfigOptionInt(2));
|
||||
|
||||
Print print;
|
||||
print.is_BBL_printer() = true;
|
||||
arrange_objects_on_test_bed(model, config);
|
||||
for (auto *mo : model.objects) {
|
||||
mo->ensure_on_bed();
|
||||
print.auto_assign_extruders(mo);
|
||||
}
|
||||
print.apply(model, config);
|
||||
print.validate();
|
||||
|
||||
REQUIRE_NOTHROW(Slic3r::Test::gcode(print));
|
||||
}
|
||||
|
||||
@@ -223,10 +223,7 @@ DynamicPrintConfig multifilament_config(unsigned int filaments, std::initializer
|
||||
// These are read by filament id during export but absent from filament_option_keys(),
|
||||
// so set_num_filaments leaves them size 1; size them too, else out-of-range access.
|
||||
const auto &defaults = FullPrintConfig::defaults();
|
||||
for (const char *key : { "filament_type", "filament_vendor", "filament_start_gcode", "filament_change_length", "filament_change_length_nc",
|
||||
"filament_ramming_travel_time", "filament_ramming_travel_time_nc",
|
||||
"filament_ramming_volumetric_speed", "filament_ramming_volumetric_speed_nc",
|
||||
"nozzle_temperature", "nozzle_temperature_initial_layer" })
|
||||
for (const char *key : { "filament_type", "filament_vendor", "filament_start_gcode" })
|
||||
static_cast<ConfigOptionVectorBase *>(config.option(key, true))->resize(filaments, defaults.option(key));
|
||||
|
||||
// flush_volumes_matrix must be sized filaments*filaments or export rejects it.
|
||||
|
||||
@@ -315,79 +315,6 @@ TEST_CASE("Per-object wall filament override is honored", "[MultiFilament]")
|
||||
CHECK(tools_for_role(gcode, "infill") == std::set<int>{ 0 }); // infill not overridden: stays on F1
|
||||
}
|
||||
|
||||
// FanMover's guard against splitting a G1 inside custom gcode keys off the ";_FAN_MOVER_SKIP_START/END"
|
||||
// markers GCode::set_extruder() must emit around change_filament_gcode's output. Direct
|
||||
// toolchanges and Type2's wipe-tower toolchange (append_tcr2() calls set_extruder()) both go
|
||||
// through it; Type1's wipe-tower toolchange (WipeTowerIntegration::append_tcr(), append_tcr2's only
|
||||
// sibling caller of change_filament_gcode) needs the same bracketing of its own.
|
||||
TEST_CASE("Toolchange gcode is bracketed against FanMover splitting its moves", "[MultiFilament]")
|
||||
{
|
||||
const std::string custom_gcode = "; fan full\nM106 P1 S255\nM400 S3\nG1 X77 F5000\nG1 X91 F3000\n";
|
||||
|
||||
// "direct": no prime tower, GCode::set_extruder() runs the toolchange. By-object sequencing
|
||||
// with a per-object filament override is what makes one happen at all without a tower.
|
||||
// "type1": a Type1 prime tower routes the toolchange through WipeTowerIntegration::append_tcr()
|
||||
// instead (append_tcr2, Type2's equivalent, itself calls set_extruder() - so Type2 needs no
|
||||
// separate case here).
|
||||
const std::string path = GENERATE(as<std::string>{}, "direct", "type1");
|
||||
CAPTURE(path);
|
||||
|
||||
std::string gcode_str;
|
||||
if (path == "direct") {
|
||||
const std::vector<std::vector<Slic3r::ConfigBase::SetDeserializeItem>> per_object_overrides = {
|
||||
{}, { { "outer_wall_filament_id", "2" }, { "inner_wall_filament_id", "2" } }
|
||||
};
|
||||
DynamicPrintConfig config = multifilament_config(2, {
|
||||
{ "skirt_loops", 0 },
|
||||
{ "brim_type", "no_brim" },
|
||||
{ "print_sequence", "by object" },
|
||||
{ "change_filament_gcode", custom_gcode },
|
||||
{ "fan_speedup_time", 0.5 },
|
||||
{ "fan_kickstart", 0.1 },
|
||||
});
|
||||
gcode_str = slice_with_object_overrides({ cube(20), cube(20) }, config, per_object_overrides);
|
||||
} else {
|
||||
const std::vector<std::vector<Slic3r::ConfigBase::SetDeserializeItem>> per_object_overrides = {
|
||||
{ { "extruder", "1" } }, { { "extruder", "2" } }
|
||||
};
|
||||
DynamicPrintConfig config = multifilament_config(2, {
|
||||
{ "change_filament_gcode", custom_gcode },
|
||||
{ "fan_speedup_time", 0.5 },
|
||||
{ "fan_kickstart", 0.1 },
|
||||
{ "enable_prime_tower", true },
|
||||
{ "wipe_tower_type", "type1" },
|
||||
{ "prime_tower_width", 35 },
|
||||
{ "wipe_tower_x", 120 },
|
||||
{ "wipe_tower_y", 120 },
|
||||
{ "printable_area", "0x0,200x0,200x200,0x200" },
|
||||
{ "skirt_loops", 0 },
|
||||
{ "brim_type", "no_brim" },
|
||||
});
|
||||
gcode_str = slice_with_object_overrides({ cube(20), cube(20) }, config, per_object_overrides);
|
||||
}
|
||||
|
||||
// The resolved-settings config footer echoes "change_filament_gcode = ..." with its value
|
||||
// escaped, so drop it before counting or its own copy of "G1 X77 F5000" is miscounted.
|
||||
const size_t footer_start = gcode_str.find("; CONFIG_BLOCK_START");
|
||||
REQUIRE(footer_start != std::string::npos);
|
||||
gcode_str.erase(footer_start);
|
||||
|
||||
auto count_occurrences = [](const std::string &haystack, const std::string &needle) {
|
||||
size_t count = 0, pos = 0;
|
||||
while ((pos = haystack.find(needle, pos)) != std::string::npos) {
|
||||
++count;
|
||||
pos += needle.size();
|
||||
}
|
||||
return count;
|
||||
};
|
||||
const size_t total_waypoints = count_occurrences(gcode_str, "G1 X77 F5000");
|
||||
const size_t bracketed = count_occurrences(gcode_str, "M400 S3\nG1 X77 F5000");
|
||||
REQUIRE(total_waypoints > 0);
|
||||
CHECK(bracketed == total_waypoints);
|
||||
// FanMover drops its own markers; only the start-of-print toolchange, which it never processes, keeps them.
|
||||
CHECK(count_occurrences(gcode_str, ";_FAN_MOVER_SKIP_START") <= 1);
|
||||
}
|
||||
|
||||
// With wait_for_temp_on_wipe_tower the blocking M109 moves from right after the Tn command to
|
||||
// a stop point parked beside the wipe tower (heat-up drool falls next to the tower, not onto
|
||||
// its top): tagged with _WAIT_FOR_TEMP_ON_WIPE_TOWER, after the toolchange and before the
|
||||
|
||||
@@ -43,7 +43,6 @@
|
||||
#include "libslic3r/GCode/GCodeProcessor.hpp"
|
||||
#include "libslic3r/Exception.hpp"
|
||||
#include "libslic3r/LifecycleEvents.hpp"
|
||||
#include "libslic3r/Utils.hpp"
|
||||
|
||||
#include "test_helpers.hpp"
|
||||
#include "test_utils.hpp"
|
||||
@@ -157,81 +156,6 @@ SCENARIO("Changing the number of solid shell layers does not make all surfaces i
|
||||
}
|
||||
}
|
||||
|
||||
// Two copies of one object share a single slice. When a copy that has sliced itself becomes identical to an
|
||||
// earlier object, it keeps its own layers while that object slices and only then takes the shared layers over.
|
||||
TEST_CASE("An object that starts sharing another object's slices keeps its own layers until it takes them over", "[Print][Regression]")
|
||||
{
|
||||
DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
|
||||
config.set_deserialize_strict({
|
||||
{ "layer_height", 0.2 },
|
||||
{ "initial_layer_print_height", 0.2 },
|
||||
{ "raft_layers", 1 }, // each object gets support layers of its own
|
||||
{ "sparse_infill_density", "20%" }, // object_a's override below differs from this
|
||||
});
|
||||
// Activates the slicing-pipeline hook installed for the second slice below.
|
||||
config.set_key_value("slicing_pipeline_plugin", new ConfigOptionStrings({"probe"}));
|
||||
|
||||
Print print;
|
||||
Model model;
|
||||
init_print({cube(20)}, print, model, config);
|
||||
ModelObject *object_a = model.objects.front();
|
||||
// add_object() gives the copy extruder 1, and objects only share slices when their configs match.
|
||||
object_a->config.set_key_value("extruder", new ConfigOptionInt(1));
|
||||
ModelObject *object_b = model.add_object(*object_a); // shares object_a's mesh
|
||||
for (ModelInstance *instance : object_b->instances)
|
||||
instance->set_offset(instance->get_offset() + Vec3d(40., 0., 0.));
|
||||
// A per-object override makes the objects differ, so each slices itself.
|
||||
object_a->config.set_key_value("sparse_infill_density", new ConfigOptionPercent(40));
|
||||
|
||||
print.apply(model, config);
|
||||
print.process();
|
||||
REQUIRE(print.objects().size() == 2);
|
||||
// The non-const accessors hand out the layer vectors themselves, which the checks below compare.
|
||||
PrintObject *print_b = print.get_object(1);
|
||||
REQUIRE(print_b->model_object()->id() == object_b->id()); // Print slices its own copy of the model
|
||||
REQUIRE(print_b->get_shared_object() == nullptr);
|
||||
const LayerPtrs own_layers = print_b->layers();
|
||||
const SupportLayerPtrs own_support_layers = print_b->support_layers();
|
||||
REQUIRE(!own_layers.empty());
|
||||
REQUIRE(!own_support_layers.empty());
|
||||
|
||||
// Without the override the objects are identical again: print_a redoes the steps the setting invalidated,
|
||||
// and print_b shares it.
|
||||
object_a->config.erase("sparse_infill_density");
|
||||
print.apply(model, config);
|
||||
REQUIRE(print.objects().size() == 2);
|
||||
PrintObject *print_a = print.get_object(0);
|
||||
|
||||
// Erasing the override invalidates print_a's posPrepareInfill and the steps after it. Its hook is the first one
|
||||
// print_a fires, and it runs after print_b starts sharing but before print_b takes the shared layers over.
|
||||
bool hook_fired = false;
|
||||
bool shared_while_a_runs = false;
|
||||
bool kept_layers = false;
|
||||
bool kept_support_layers = false;
|
||||
{
|
||||
Print::set_slicing_pipeline_hook_fn([&](Print &, const PrintObject *object, SlicingPipelineStepPlugin) {
|
||||
if (object != print_a || hook_fired)
|
||||
return;
|
||||
hook_fired = true;
|
||||
shared_while_a_runs = print_b->get_shared_object() == print_a;
|
||||
kept_layers = print_b->layers() == own_layers;
|
||||
kept_support_layers = print_b->support_layers() == own_support_layers;
|
||||
});
|
||||
const ScopeGuard reset_hook([] { Print::set_slicing_pipeline_hook_fn(nullptr); });
|
||||
print.process();
|
||||
}
|
||||
|
||||
REQUIRE(hook_fired);
|
||||
CHECK(print.objects()[1] == print_b);
|
||||
CHECK(shared_while_a_runs);
|
||||
CHECK(kept_layers);
|
||||
CHECK(kept_support_layers);
|
||||
CHECK(print_b->get_shared_object() == print_a);
|
||||
REQUIRE(!print_a->layers().empty());
|
||||
CHECK(print_b->layers() == print_a->layers());
|
||||
CHECK(print_b->support_layers() == print_a->support_layers());
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Print::validate() warning collection
|
||||
//
|
||||
|
||||
@@ -53,7 +53,6 @@ add_executable(${_TEST_NAME}_tests
|
||||
test_stl.cpp
|
||||
test_triangle_selector.cpp
|
||||
test_meshboolean.cpp
|
||||
test_mesh_repair.cpp
|
||||
test_trianglemesh_slicer.cpp
|
||||
test_marchingsquares.cpp
|
||||
test_lay_on_face.cpp
|
||||
|
||||
+311
-163
@@ -29,9 +29,11 @@
|
||||
#include "libslic3r/TriangleMesh.hpp"
|
||||
#include "libslic3r/TriangleSelector.hpp"
|
||||
#include "libslic3r/TextureDisplacement.hpp"
|
||||
#include "libslic3r/PNGReadWrite.hpp"
|
||||
#include <memory>
|
||||
#include <cstdint>
|
||||
#include <ios>
|
||||
#include <iterator>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include <boost/filesystem/operations.hpp>
|
||||
@@ -39,7 +41,6 @@
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
|
||||
#include <catch2/catch_tostring.hpp>
|
||||
#include <Eigen/Core>
|
||||
@@ -351,10 +352,10 @@ static bool replace_in_3mf_entry(const std::string& path, const std::string& suf
|
||||
return replaced;
|
||||
}
|
||||
|
||||
// Stores `model` as a one-plate project.
|
||||
static void store_project(Model& model, const std::string& path, SaveStrategy strategy)
|
||||
// Writes `model` out as a one-plate project, which is what the application's Save does with it.
|
||||
static void store_project(const std::string& path, Model& model)
|
||||
{
|
||||
ScopedTemporaryDir backup_dir("orca_paint_src");
|
||||
ScopedTemporaryDir backup_dir("orca_project_src");
|
||||
model.set_backup_path(backup_dir.string());
|
||||
|
||||
DynamicPrintConfig cfg;
|
||||
@@ -364,7 +365,7 @@ static void store_project(Model& model, const std::string& path, SaveStrategy st
|
||||
sp.path = path.c_str();
|
||||
sp.model = &model;
|
||||
sp.config = &cfg;
|
||||
sp.strategy = strategy;
|
||||
sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
|
||||
sp.plate_data_list.push_back(&plate);
|
||||
REQUIRE(store_bbs_3mf(sp));
|
||||
}
|
||||
@@ -383,7 +384,7 @@ static void store_painted_cube(const std::string& path)
|
||||
selector.set_facet(1, EnforcerBlockerType::Extruder3);
|
||||
REQUIRE(volume->mmu_segmentation_facets.set(selector));
|
||||
}
|
||||
store_project(model, path, SaveStrategy::Zip64 | SaveStrategy::Silence);
|
||||
store_project(path, model);
|
||||
}
|
||||
|
||||
// Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
|
||||
@@ -509,163 +510,6 @@ TEST_CASE("A project with malformed paint data loads without the damaged facet",
|
||||
REQUIRE(selector.num_facets(EnforcerBlockerType::Extruder3) == 1);
|
||||
}
|
||||
|
||||
// Paints `triangles` of `volume` on texture displacement layer slot `slot`.
|
||||
static void paint_texture_slot(ModelVolume& volume, int slot, std::initializer_list<int> triangles)
|
||||
{
|
||||
TriangleSelector selector(volume.mesh());
|
||||
for (const int triangle : triangles)
|
||||
selector.set_facet(triangle, EnforcerBlockerType::ENFORCER);
|
||||
REQUIRE(volume.texture_displacement_facet(slot).set(selector));
|
||||
}
|
||||
|
||||
// Every triangle's texture paint on every slot, in the form the exporter writes it, so two volumes
|
||||
// compare equal only when the same triangles are painted on the same slots.
|
||||
static std::vector<std::string> texture_paint(const ModelVolume& volume)
|
||||
{
|
||||
std::vector<std::string> paint;
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
|
||||
for (size_t i = 0; i < volume.mesh().its.indices.size(); ++i)
|
||||
paint.push_back(volume.texture_displacement_facet(slot).get_triangle_as_string(int(i)));
|
||||
return paint;
|
||||
}
|
||||
|
||||
// A cube with one texture displacement layer in slot 2 and texture paint on gapped triangles of two
|
||||
// slots. The layer's image bytes need not decode: the archive stores them as they are.
|
||||
static ModelVolume& add_texture_displaced_cube(Model& model)
|
||||
{
|
||||
ModelObject* object = model.add_object();
|
||||
ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
|
||||
object->add_instance();
|
||||
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 2;
|
||||
layer.name = "Bark";
|
||||
layer.depth_mm = 1.25f;
|
||||
layer.image_data = std::make_shared<std::vector<unsigned char>>(std::vector<unsigned char>{ 0x89, 'P', 'N', 'G', 1, 2, 3 });
|
||||
volume->texture_displacement_layers.push_back(layer);
|
||||
volume->texture_displacement_options.active_slot = 2;
|
||||
|
||||
paint_texture_slot(*volume, 2, { 3, 7 });
|
||||
paint_texture_slot(*volume, 5, { 10 });
|
||||
return *volume;
|
||||
}
|
||||
|
||||
TEST_CASE("Texture displacement layers, textures and paint survive a project round trip", "[3mf]")
|
||||
{
|
||||
// A single model file, and one file per object (read by a separate importer).
|
||||
const SaveStrategy strategy = GENERATE(SaveStrategy::Zip64 | SaveStrategy::Silence,
|
||||
SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::SplitModel);
|
||||
INFO("save strategy " << int(strategy));
|
||||
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
Model source;
|
||||
const ModelVolume& painted = add_texture_displaced_cube(source);
|
||||
const std::vector<std::string> paint = texture_paint(painted);
|
||||
REQUIRE(std::count_if(paint.begin(), paint.end(), [](const std::string& s) { return !s.empty(); }) == 3);
|
||||
store_project(source, temp.string(), strategy);
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
REQUIRE(load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
const ModelVolume& volume = *model.objects.front()->volumes.front();
|
||||
|
||||
REQUIRE(volume.texture_displacement_layers.size() == 1);
|
||||
const TextureDisplacementLayer& layer = volume.texture_displacement_layers.front();
|
||||
CHECK(layer.slot == 2);
|
||||
CHECK(layer.name == "Bark");
|
||||
CHECK_THAT(layer.depth_mm, Catch::Matchers::WithinAbs(1.25f, 1e-6f));
|
||||
REQUIRE(layer.image_data);
|
||||
CHECK(*layer.image_data == *painted.texture_displacement_layers.front().image_data);
|
||||
CHECK(volume.texture_displacement_options.active_slot == 2);
|
||||
CHECK(texture_paint(volume) == paint);
|
||||
}
|
||||
|
||||
TEST_CASE("Volumes sharing a mesh keep their own texture displacement paint", "[3mf]")
|
||||
{
|
||||
Model source;
|
||||
ModelObject* first_object = source.add_object();
|
||||
ModelVolume* first = first_object->add_volume(make_cube(10., 10., 10.));
|
||||
first_object->add_instance();
|
||||
ModelVolume* second = source.add_object(*first_object)->volumes.front();
|
||||
REQUIRE(second->mesh_ptr() == first->mesh_ptr());
|
||||
paint_texture_slot(*first, 0, { 3 });
|
||||
paint_texture_slot(*second, 0, { 7 });
|
||||
|
||||
// What a project save from the app uses: one file per object, an identical mesh written once.
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_project(source, temp.string(),
|
||||
SaveStrategy::Zip64 | SaveStrategy::Silence | SaveStrategy::SplitModel | SaveStrategy::ShareMesh);
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
REQUIRE(load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(model.objects.size() == 2);
|
||||
CHECK(texture_paint(*model.objects[0]->volumes.front()) == texture_paint(*first));
|
||||
CHECK(texture_paint(*model.objects[1]->volumes.front()) == texture_paint(*second));
|
||||
}
|
||||
|
||||
TEST_CASE("A texture displacement layer never loads its image from outside the project", "[3mf]")
|
||||
{
|
||||
// A file the layer names, on the machine opening the project, that the project did not carry.
|
||||
ScopedTemporaryFile texture(".png");
|
||||
{
|
||||
boost::nowide::ofstream file(texture.string(), std::ios::binary);
|
||||
file << "not part of the project";
|
||||
}
|
||||
REQUIRE(boost::filesystem::file_size(texture.path()) > 0);
|
||||
|
||||
Model source;
|
||||
ModelObject* object = source.add_object();
|
||||
ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
|
||||
object->add_instance();
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 0;
|
||||
layer.name = "Elsewhere";
|
||||
layer.path = texture.string();
|
||||
layer.depth_mm = 0.75f;
|
||||
volume->texture_displacement_layers.push_back(layer);
|
||||
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_project(source, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
REQUIRE(load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
const std::vector<TextureDisplacementLayer>& layers = model.objects.front()->volumes.front()->texture_displacement_layers;
|
||||
REQUIRE(layers.size() == 1);
|
||||
CHECK(layers.front().name == "Elsewhere");
|
||||
CHECK_THAT(layers.front().depth_mm, Catch::Matchers::WithinAbs(0.75f, 1e-6f));
|
||||
CHECK_FALSE(layers.front().image_data);
|
||||
}
|
||||
|
||||
TEST_CASE("A project with a malformed texture displacement value still loads", "[3mf][Regression]")
|
||||
{
|
||||
const auto [from, to] = GENERATE(table<std::string, std::string>({
|
||||
{ "\"islands\":[]", "\"islands\":[[null,0,0,1]]" }, // a number that is null
|
||||
{ "\"slot\":2", "\"slot\":8" }, // a slot past the last
|
||||
}));
|
||||
INFO(from << " -> " << to);
|
||||
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
Model source;
|
||||
const ModelVolume& painted = add_texture_displaced_cube(source);
|
||||
store_project(source, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
|
||||
REQUIRE(replace_in_3mf_entry(temp.string(), ".json", from, to));
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
bool loaded = false;
|
||||
REQUIRE_NOTHROW(loaded = load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(loaded);
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
const ModelVolume& volume = *model.objects.front()->volumes.front();
|
||||
// The layer stack is dropped as a whole; the paint, stored apart from it, still loads.
|
||||
CHECK(volume.texture_displacement_layers.empty());
|
||||
CHECK(texture_paint(volume) == texture_paint(painted));
|
||||
}
|
||||
|
||||
// The recipe lives only in the BBS-native backend, because that is the only one that runs:
|
||||
// store_bbs_3mf is the sole exporter the app calls, and 3mf.cpp's load_3mf is reached only for
|
||||
// files fingerprinted as PrusaSlicer's, which never carry a recipe. This locks in both halves:
|
||||
@@ -2245,3 +2089,307 @@ TEST_CASE("Loading a gcode.3mf from a stream keeps the plate's pick and pattern
|
||||
CHECK(dst_plates.front()->pattern_bbox_file == "Metadata/plate_1.json");
|
||||
release_PlateData_list(dst_plates);
|
||||
}
|
||||
|
||||
// Encodes a flat grayscale PNG the way the texture panel's import does, so what the archive carries
|
||||
// is a real texture rather than an opaque blob.
|
||||
static std::shared_ptr<std::vector<unsigned char>> make_gray_png(uint8_t value, size_t w = 4, size_t h = 4)
|
||||
{
|
||||
ScopedTemporaryFile file(".png");
|
||||
const std::vector<uint8_t> pixels(w * h, value);
|
||||
REQUIRE(png::write_gray_to_file(file.string(), w, h, pixels));
|
||||
|
||||
boost::nowide::ifstream in(file.string(), std::ios::binary);
|
||||
std::vector<unsigned char> bytes((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
|
||||
REQUIRE_FALSE(bytes.empty());
|
||||
return std::make_shared<std::vector<unsigned char>>(std::move(bytes));
|
||||
}
|
||||
|
||||
// Every entry name in a 3mf archive, with the separators normalised the way the importer sees them.
|
||||
static std::vector<std::string> zip_entry_names(const std::string& path)
|
||||
{
|
||||
std::vector<std::string> names;
|
||||
mz_zip_archive zip;
|
||||
mz_zip_zero_struct(&zip);
|
||||
REQUIRE(open_zip_reader(&zip, path));
|
||||
const mz_uint n = mz_zip_reader_get_num_files(&zip);
|
||||
for (mz_uint i = 0; i < n; ++i) {
|
||||
mz_zip_archive_file_stat st;
|
||||
if (!mz_zip_reader_file_stat(&zip, i, &st) || st.m_is_directory)
|
||||
continue;
|
||||
std::string name(st.m_filename);
|
||||
std::replace(name.begin(), name.end(), '\\', '/');
|
||||
names.push_back(std::move(name));
|
||||
}
|
||||
close_zip_reader(&zip);
|
||||
return names;
|
||||
}
|
||||
|
||||
static const std::string TEXTURE_DISPLACEMENT_ENTRY_DIR = "Metadata/texture_displacement/";
|
||||
|
||||
// Stores a one-plate project holding a cube with one texture displacement layer, painted on that
|
||||
// layer's own slot. The caller fills the layer in, and gets back the mask string the exporter wrote
|
||||
// for `painted_facet`, which is what the load has to reproduce.
|
||||
//
|
||||
// The painted facet is deliberately not the first one: the importer keeps a slot's masks only as far
|
||||
// as its last painted triangle, so a facet in the middle is the case where that run has to be padded
|
||||
// in front and left short at the back.
|
||||
static void store_texture_displaced_cube(const std::string& path, const TextureDisplacementLayer& layer,
|
||||
const TextureDisplacementOptions& options, std::string& painted_mask,
|
||||
int painted_facet = 5)
|
||||
{
|
||||
Model model;
|
||||
ModelObject* object = model.add_object();
|
||||
ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
|
||||
object->add_instance();
|
||||
|
||||
volume->texture_displacement_layers.push_back(layer);
|
||||
volume->texture_displacement_options = options;
|
||||
REQUIRE(painted_facet < int(volume->mesh().its.indices.size()));
|
||||
{
|
||||
TriangleSelector selector(volume->mesh());
|
||||
selector.set_facet(painted_facet, EnforcerBlockerType::ENFORCER);
|
||||
REQUIRE(volume->texture_displacement_facet(layer.slot).set(selector));
|
||||
}
|
||||
painted_mask = volume->texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet);
|
||||
REQUIRE_FALSE(painted_mask.empty());
|
||||
|
||||
store_project(path, model);
|
||||
}
|
||||
|
||||
// Returns the only volume of the only object in the project at `path`, loaded through the importer.
|
||||
static const ModelVolume& load_single_volume(const std::string& path, Model& model, const ScopedTemporaryDir& backup_dir)
|
||||
{
|
||||
REQUIRE(load_project(path, model, backup_dir));
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
REQUIRE(model.objects.front()->volumes.size() == 1);
|
||||
return *model.objects.front()->volumes.front();
|
||||
}
|
||||
|
||||
// A texture displacement stack is the one paint tool whose settings live outside the volume's config:
|
||||
// the layer stack goes into the archive as its own JSON file, each layer's texture as a PNG beside it,
|
||||
// and the paint as a per-triangle attribute (see add_texture_displacement). A project only reopens
|
||||
// with its relief intact if all three come back together.
|
||||
TEST_CASE("A texture displacement layer, its texture and its paint survive a project round trip", "[3mf][TextureDisplacement]")
|
||||
{
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 3; // not the first slot, so the per-slot attribute names have to line up
|
||||
layer.name = "Bark";
|
||||
layer.path = "/textures/bark.png";
|
||||
layer.depth_mm = 1.25f;
|
||||
layer.tiling_scale = 7.5f;
|
||||
layer.midlevel = 0.5f;
|
||||
layer.invert = true;
|
||||
layer.tile_method = TextureTileMethod::MirroredRepeat;
|
||||
layer.projection_method = TextureProjectionMethod::LSCM;
|
||||
layer.blend_mode = TextureBlendMode::Subtract;
|
||||
layer.lscm_seam_edges = { { 1, 2 }, { 3, 5 } };
|
||||
layer.image_data = make_gray_png(128);
|
||||
|
||||
TextureDisplacementOptions options;
|
||||
options.smooth_enabled = true;
|
||||
options.smooth_iterations = 4;
|
||||
options.active_slot = layer.slot;
|
||||
options.panel_mode = 1;
|
||||
|
||||
const int painted_facet = 5;
|
||||
std::string painted;
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_texture_displaced_cube(temp.string(), layer, options, painted, painted_facet);
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
|
||||
|
||||
REQUIRE(volume.texture_displacement_layers.size() == 1);
|
||||
const TextureDisplacementLayer& read = volume.texture_displacement_layers.front();
|
||||
CHECK(read.slot == layer.slot);
|
||||
CHECK(read.name == layer.name);
|
||||
CHECK(read.path == layer.path);
|
||||
CHECK_THAT(read.depth_mm, Catch::Matchers::WithinAbs(layer.depth_mm, 1e-6f));
|
||||
CHECK_THAT(read.tiling_scale, Catch::Matchers::WithinAbs(layer.tiling_scale, 1e-6f));
|
||||
CHECK_THAT(read.midlevel, Catch::Matchers::WithinAbs(layer.midlevel, 1e-6f));
|
||||
CHECK(read.invert == layer.invert);
|
||||
CHECK(read.tile_method == layer.tile_method);
|
||||
CHECK(read.projection_method == layer.projection_method);
|
||||
CHECK(read.blend_mode == layer.blend_mode);
|
||||
CHECK(read.lscm_seam_edges == layer.lscm_seam_edges);
|
||||
|
||||
// The texture rides along in the archive, named after the slot it belongs to, byte for byte.
|
||||
CHECK(boost::algorithm::starts_with(read.path_in_3mf, TEXTURE_DISPLACEMENT_ENTRY_DIR));
|
||||
CHECK(boost::algorithm::ends_with(read.path_in_3mf, "_" + std::to_string(layer.slot) + ".png"));
|
||||
REQUIRE(read.image_data);
|
||||
CHECK(*read.image_data == *layer.image_data);
|
||||
|
||||
CHECK(volume.texture_displacement_options.smooth_enabled);
|
||||
CHECK(volume.texture_displacement_options.smooth_iterations == options.smooth_iterations);
|
||||
CHECK(volume.texture_displacement_options.active_slot == options.active_slot);
|
||||
CHECK(volume.texture_displacement_options.panel_mode == options.panel_mode);
|
||||
|
||||
// The paint comes back on the facet it was put on, on its own slot and nowhere else.
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet) == painted);
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(0).empty());
|
||||
for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot)
|
||||
if (slot != layer.slot)
|
||||
CHECK(volume.texture_displacement_facet(slot).empty());
|
||||
}
|
||||
|
||||
// A layer names the file its texture was imported from, which the library panel uses to point at the
|
||||
// entry the layer came from. That name must not be opened: the project may come from anyone, the path
|
||||
// may name any file the user can read - on Windows a UNC path names a host as well - and the next save
|
||||
// would copy whatever was found there into the archive. A layer the archive has no image for comes
|
||||
// back without pixels instead, which the user fixes by picking the texture again.
|
||||
TEST_CASE("A texture displacement layer whose image the archive lacks is not read from the path it names", "[3mf][TextureDisplacement][Regression]")
|
||||
{
|
||||
// A file that really is there, so the test fails if the importer ever reaches for it.
|
||||
ScopedTemporaryFile texture(".png");
|
||||
REQUIRE(png::write_gray_to_file(texture.string(), 4, 4, std::vector<uint8_t>(16, 200)));
|
||||
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 0;
|
||||
layer.name = "Bark";
|
||||
layer.path = texture.string(); // and no image_data: nothing for the exporter to put in the archive
|
||||
|
||||
std::string painted;
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted);
|
||||
|
||||
for (const std::string& name : zip_entry_names(temp.string()))
|
||||
if (boost::algorithm::starts_with(name, TEXTURE_DISPLACEMENT_ENTRY_DIR))
|
||||
CHECK_FALSE(boost::algorithm::ends_with(name, ".png"));
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
|
||||
|
||||
REQUIRE(volume.texture_displacement_layers.size() == 1);
|
||||
CHECK(volume.texture_displacement_layers.front().path == texture.string());
|
||||
CHECK_FALSE(bool(volume.texture_displacement_layers.front().image_data));
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(5) == painted);
|
||||
}
|
||||
|
||||
// The stack's JSON is arbitrary text by the time it is read back, and a value of the wrong type in it
|
||||
// throws out of the parse. That has to cost the volume its layers, not the project: the model, and the
|
||||
// paint the user can still build on, load as they would from a build without the feature.
|
||||
TEST_CASE("A malformed texture displacement block leaves the rest of the project loadable", "[3mf][TextureDisplacement][Regression]")
|
||||
{
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 0;
|
||||
layer.name = "Bark";
|
||||
layer.image_data = make_gray_png(128);
|
||||
|
||||
std::string painted;
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted);
|
||||
|
||||
REQUIRE(rewrite_3mf_entries(temp.string(), [](std::string& name, std::string& data) {
|
||||
if (!boost::algorithm::starts_with(name, TEXTURE_DISPLACEMENT_ENTRY_DIR) ||
|
||||
!boost::algorithm::ends_with(name, ".json"))
|
||||
return false;
|
||||
// `offset` goes through a typed accessor, so a string in it throws; a plain setting like
|
||||
// depth_mm would be shrugged off by the parse instead, leaving the layer loadable.
|
||||
data = R"({"version":1,"layers":[{"slot":0,"offset":["deep","deep"]}]})";
|
||||
return true;
|
||||
}));
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
bool loaded = false;
|
||||
REQUIRE_NOTHROW(loaded = load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(loaded);
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
REQUIRE(model.objects.front()->volumes.size() == 1);
|
||||
const ModelVolume& volume = *model.objects.front()->volumes.front();
|
||||
|
||||
CHECK(volume.texture_displacement_layers.empty());
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(5) == painted);
|
||||
}
|
||||
|
||||
// A slot's masks are kept only as far as its last painted triangle, so where the paint falls in the
|
||||
// list decides whether that run has to be padded in front of the paint, cut short behind it, or both.
|
||||
TEST_CASE("Texture displacement paint survives wherever it falls in the triangle list", "[3mf][TextureDisplacement]")
|
||||
{
|
||||
const int painted_facet = GENERATE(0, 5, 11); // first, middle and last facet of a cube
|
||||
INFO("painted facet " << painted_facet);
|
||||
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 0;
|
||||
layer.name = "Bark";
|
||||
layer.image_data = make_gray_png(128);
|
||||
|
||||
std::string painted;
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
store_texture_displaced_cube(temp.string(), layer, TextureDisplacementOptions{}, painted, painted_facet);
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
const ModelVolume& volume = load_single_volume(temp.string(), model, backup_dir);
|
||||
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facet) == painted);
|
||||
for (int facet = 0; facet < int(volume.mesh().its.indices.size()); ++facet)
|
||||
if (facet != painted_facet)
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(facet).empty());
|
||||
}
|
||||
|
||||
// Each volume's stack is written under the volume's own id, and the paint of a whole object arrives as
|
||||
// one run of triangles that the volumes take their slices of. Two volumes using the same slot are the
|
||||
// case where both of those have to tell the volumes apart.
|
||||
TEST_CASE("Two volumes of one object keep their own texture displacement layers", "[3mf][TextureDisplacement]")
|
||||
{
|
||||
const auto first_image = make_gray_png(64);
|
||||
const auto second_image = make_gray_png(192);
|
||||
REQUIRE(*first_image != *second_image);
|
||||
|
||||
// The facet each volume is painted on, volume-local, so a mask landing on the wrong volume shows up.
|
||||
const int painted_facets[2] = { 0, 7 };
|
||||
std::string painted[2];
|
||||
|
||||
ScopedTemporaryFile temp(".3mf");
|
||||
{
|
||||
Model model;
|
||||
ModelObject* object = model.add_object();
|
||||
object->add_instance();
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
|
||||
TextureDisplacementLayer layer;
|
||||
layer.slot = 0; // the same slot in both, which is what makes their names collide
|
||||
layer.name = i == 0 ? "First" : "Second";
|
||||
layer.depth_mm = i == 0 ? 0.5f : 1.5f;
|
||||
layer.image_data = i == 0 ? first_image : second_image;
|
||||
volume->texture_displacement_layers.push_back(layer);
|
||||
|
||||
TriangleSelector selector(volume->mesh());
|
||||
selector.set_facet(painted_facets[i], EnforcerBlockerType::ENFORCER);
|
||||
REQUIRE(volume->texture_displacement_facet(layer.slot).set(selector));
|
||||
painted[i] = volume->texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[i]);
|
||||
REQUIRE_FALSE(painted[i].empty());
|
||||
}
|
||||
store_project(temp.string(), model);
|
||||
}
|
||||
|
||||
ScopedTemporaryDir backup_dir("orca_texdisp_dst");
|
||||
Model model;
|
||||
REQUIRE(load_project(temp.string(), model, backup_dir));
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
REQUIRE(model.objects.front()->volumes.size() == 2);
|
||||
|
||||
const std::shared_ptr<std::vector<unsigned char>> images[2] = { first_image, second_image };
|
||||
const std::string names[2] = { "First", "Second" };
|
||||
const float depths[2] = { 0.5f, 1.5f };
|
||||
std::string entries[2];
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
INFO("volume " << i);
|
||||
const ModelVolume& volume = *model.objects.front()->volumes[i];
|
||||
REQUIRE(volume.texture_displacement_layers.size() == 1);
|
||||
const TextureDisplacementLayer& layer = volume.texture_displacement_layers.front();
|
||||
CHECK(layer.name == names[i]);
|
||||
CHECK_THAT(layer.depth_mm, Catch::Matchers::WithinAbs(depths[i], 1e-6f));
|
||||
REQUIRE(layer.image_data);
|
||||
CHECK(*layer.image_data == *images[i]);
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[i]) == painted[i]);
|
||||
CHECK(volume.texture_displacement_facet(layer.slot).get_triangle_as_string(painted_facets[1 - i]).empty());
|
||||
entries[i] = layer.path_in_3mf;
|
||||
}
|
||||
// Both volumes paint slot 0, so only the volume id keeps their textures apart in the archive.
|
||||
CHECK(entries[0] != entries[1]);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,255 +0,0 @@
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/matchers/catch_matchers.hpp>
|
||||
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <libslic3r/MeshBoolean.hpp>
|
||||
#include <libslic3r/MeshRepair.hpp>
|
||||
#include <libslic3r/Point.hpp>
|
||||
#include <libslic3r/libslic3r.h>
|
||||
#include <libslic3r/TriangleMesh.hpp>
|
||||
|
||||
using namespace Slic3r;
|
||||
using Catch::Matchers::WithinRel;
|
||||
|
||||
namespace {
|
||||
|
||||
indexed_triangle_set cube(double size, const Vec3d &offset = Vec3d::Zero())
|
||||
{
|
||||
TriangleMesh mesh = make_cube(size, size, size);
|
||||
mesh.translate(offset.cast<float>());
|
||||
return mesh.its;
|
||||
}
|
||||
|
||||
indexed_triangle_set merged(const std::vector<indexed_triangle_set> &parts)
|
||||
{
|
||||
indexed_triangle_set out;
|
||||
for (const indexed_triangle_set &part : parts)
|
||||
its_merge(out, part);
|
||||
return out;
|
||||
}
|
||||
|
||||
// Every triangle with its own three vertices, as some exporters write meshes.
|
||||
indexed_triangle_set soup(const indexed_triangle_set &its)
|
||||
{
|
||||
indexed_triangle_set out;
|
||||
for (const stl_triangle_vertex_indices &f : its.indices) {
|
||||
const int first = int(out.vertices.size());
|
||||
for (int k = 0; k < 3; ++k)
|
||||
out.vertices.push_back(its.vertices[f[k]]);
|
||||
out.indices.emplace_back(first, first + 1, first + 2);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
double regular_polygon_area(int sides, double radius) { return 0.5 * sides * radius * radius * std::sin(2. * PI / sides); }
|
||||
|
||||
// Closed by vertex indices, outward oriented and free of self-intersections.
|
||||
void check_solid(const TriangleMesh &mesh, double volume)
|
||||
{
|
||||
CHECK(its_num_open_edges(mesh.its) == 0);
|
||||
CHECK_THAT(its_volume(mesh.its), WithinRel(volume, 1e-4));
|
||||
CHECK_FALSE(MeshBoolean::cgal::does_self_intersect(mesh));
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("A triangle soup repairs into the solid it describes", "[MeshRepair]")
|
||||
{
|
||||
TriangleMesh mesh(soup(cube(20.)));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK(stats.modified);
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
CHECK(mesh.its.vertices.size() == 8);
|
||||
}
|
||||
|
||||
TEST_CASE("Flipped triangles take the orientation of their neighbours", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its = cube(20.);
|
||||
std::swap(its.indices[1][1], its.indices[1][2]);
|
||||
std::swap(its.indices[5][1], its.indices[5][2]);
|
||||
TriangleMesh mesh(std::move(its));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
}
|
||||
|
||||
TEST_CASE("An inside-out mesh is turned outward", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its = cube(20.);
|
||||
its_flip_triangles(its);
|
||||
TriangleMesh mesh(std::move(its));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
}
|
||||
|
||||
TEST_CASE("Holes are filled", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its = cube(20.);
|
||||
its.indices.erase(its.indices.begin(), its.indices.begin() + 3);
|
||||
TriangleMesh mesh(std::move(its));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK(stats.filled_holes > 0);
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
}
|
||||
|
||||
TEST_CASE("Cracks between triangles that should share corners are closed", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its = soup(cube(20.));
|
||||
// Shift the corners of two triangles by far less than a micron, as float rounding in an exporter would.
|
||||
for (std::size_t v = 0; v < 6; ++v)
|
||||
its.vertices[v] += Vec3f(1e-5f, -1e-5f, 1e-5f);
|
||||
TriangleMesh mesh(std::move(its));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK(stats.welded_vertices > 0);
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
}
|
||||
|
||||
TEST_CASE("A T-junction is closed", "[MeshRepair]")
|
||||
{
|
||||
// The top of the cube is split at the middle of its front edge, which the front side does not share.
|
||||
indexed_triangle_set its;
|
||||
its.vertices = {{0, 0, 0}, {20, 0, 0}, {20, 20, 0}, {0, 20, 0}, {0, 0, 20}, {20, 0, 20}, {20, 20, 20}, {0, 20, 20}, {10, 0, 20}};
|
||||
its.indices = {{0, 2, 1}, {0, 3, 2}, {4, 8, 7}, {8, 6, 7}, {8, 5, 6}, {0, 1, 5}, {0, 5, 4},
|
||||
{1, 2, 6}, {1, 6, 5}, {2, 3, 7}, {2, 7, 6}, {3, 0, 4}, {3, 4, 7}};
|
||||
TriangleMesh mesh(std::move(its));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 20. * 20. * 20.);
|
||||
}
|
||||
|
||||
TEST_CASE("Crossing shells stay separate parts and are made solid", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set inside_out = cube(20., {10., 10., 10.});
|
||||
its_flip_triangles(inside_out);
|
||||
TriangleMesh mesh(merged({cube(20.), inside_out}));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK(stats.reversed_shells == 1);
|
||||
CHECK(its_num_open_edges(mesh.its) == 0);
|
||||
CHECK_THAT(its_volume(mesh.its), WithinRel(2 * 8000., 1e-4));
|
||||
CHECK(mesh.split().size() == 2);
|
||||
}
|
||||
|
||||
TEST_CASE("Solids touching face to face in a soup lose the wall between them", "[MeshRepair]")
|
||||
{
|
||||
// The mirrored copy shares the wall at x = 10 with exactly the same triangles, reversed.
|
||||
TriangleMesh right = make_cube(10., 10., 10.);
|
||||
right.mirror(X);
|
||||
right.translate(20.f, 0.f, 0.f);
|
||||
TriangleMesh mesh(soup(merged({cube(10.), right.its})));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 2 * 1000.);
|
||||
CHECK(mesh.split().size() == 1);
|
||||
}
|
||||
|
||||
TEST_CASE("A shell inside a solid follows the nonzero winding rule of slicing", "[MeshRepair]")
|
||||
{
|
||||
SECTION("Oriented like the outer shell, it adds nothing and is removed")
|
||||
{
|
||||
TriangleMesh mesh(merged({cube(20.), cube(10., {5., 5., 5.})}));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 8000.);
|
||||
CHECK(mesh.its.indices.size() == 12);
|
||||
}
|
||||
SECTION("Oriented inward, it is a cavity and stays")
|
||||
{
|
||||
indexed_triangle_set cavity = cube(10., {5., 5., 5.});
|
||||
its_flip_triangles(cavity);
|
||||
TriangleMesh mesh(merged({cube(20.), cavity}));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK_FALSE(stats.modified);
|
||||
CHECK_THAT(its_volume(mesh.its), WithinRel(8000. - 1000., 1e-4));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("A pipe missing its end caps gets annular caps", "[MeshRepair]")
|
||||
{
|
||||
const int n = 64;
|
||||
const double h = 20., r_out = 10., r_in = 7.;
|
||||
indexed_triangle_set its;
|
||||
for (const double r : {r_out, r_in})
|
||||
for (int k = 0; k < n; ++k) {
|
||||
const double a = 2. * PI * k / n;
|
||||
its.vertices.emplace_back(float(r * std::cos(a)), float(r * std::sin(a)), 0.f);
|
||||
its.vertices.emplace_back(float(r * std::cos(a)), float(r * std::sin(a)), float(h));
|
||||
}
|
||||
for (int k = 0; k < n; ++k) {
|
||||
const int a0 = 2 * k, b0 = a0 + 1, a1 = 2 * ((k + 1) % n), b1 = a1 + 1;
|
||||
its.indices.emplace_back(a0, a1, b1);
|
||||
its.indices.emplace_back(a0, b1, b0);
|
||||
its.indices.emplace_back(2 * n + a0, 2 * n + b1, 2 * n + a1);
|
||||
its.indices.emplace_back(2 * n + a0, 2 * n + b0, 2 * n + b1);
|
||||
}
|
||||
TriangleMesh mesh(std::move(its));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, h * (regular_polygon_area(n, r_out) - regular_polygon_area(n, r_in)));
|
||||
}
|
||||
|
||||
TEST_CASE("A stray flat triangle is dropped", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its = cube(20.);
|
||||
its.vertices.insert(its.vertices.end(), {{30, 0, 0}, {40, 0, 0}, {30, 10, 0}});
|
||||
its.indices.emplace_back(8, 9, 10);
|
||||
TriangleMesh mesh(std::move(its));
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK(stats.removed_shells == 1);
|
||||
check_solid(mesh, 8000.);
|
||||
}
|
||||
|
||||
TEST_CASE("A two-sided export keeps one side of each triangle", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set back = cube(20.);
|
||||
its_flip_triangles(back);
|
||||
TriangleMesh mesh(soup(merged({cube(20.), back})));
|
||||
REQUIRE(repair_mesh(mesh));
|
||||
check_solid(mesh, 8000.);
|
||||
}
|
||||
|
||||
TEST_CASE("A valid mesh is left untouched", "[MeshRepair]")
|
||||
{
|
||||
TriangleMesh mesh = make_sphere(10., 2. * PI / 36.);
|
||||
const TriangleMesh original = mesh;
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(repair_mesh(mesh, &stats));
|
||||
CHECK_FALSE(stats.modified);
|
||||
CHECK(mesh.its.vertices == original.its.vertices);
|
||||
CHECK(mesh.its.indices == original.its.indices);
|
||||
}
|
||||
|
||||
TEST_CASE("A mesh enclosing no volume is reported and left untouched", "[MeshRepair]")
|
||||
{
|
||||
indexed_triangle_set its;
|
||||
its.vertices = {{0, 0, 0}, {10, 0, 0}, {10, 10, 0}, {0, 10, 0}};
|
||||
its.indices = {{0, 1, 2}, {0, 2, 3}};
|
||||
TriangleMesh mesh(its);
|
||||
std::string error;
|
||||
CHECK_FALSE(repair_mesh(mesh, nullptr, &error));
|
||||
CHECK_FALSE(error.empty());
|
||||
CHECK(mesh.its.indices.size() == 2);
|
||||
}
|
||||
|
||||
TEST_CASE("Progress is reported in order and throwing from it cancels the repair", "[MeshRepair]")
|
||||
{
|
||||
TriangleMesh mesh(soup(cube(20.)));
|
||||
std::vector<int> reported;
|
||||
REQUIRE(repair_mesh(mesh, nullptr, nullptr, [&reported](int percent) { reported.push_back(percent); }));
|
||||
CHECK_FALSE(reported.empty());
|
||||
CHECK(std::is_sorted(reported.begin(), reported.end()));
|
||||
|
||||
struct Canceled {};
|
||||
TriangleMesh canceled(soup(cube(20.)));
|
||||
const TriangleMesh original = canceled;
|
||||
CHECK_THROWS_AS(repair_mesh(canceled, nullptr, nullptr, [](int) { throw Canceled(); }), Canceled);
|
||||
CHECK(canceled.its.vertices == original.its.vertices);
|
||||
CHECK(canceled.its.indices == original.its.indices);
|
||||
}
|
||||
@@ -12,9 +12,7 @@
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include <catch2/matchers/catch_matchers.hpp>
|
||||
#include <catch2/matchers/catch_matchers_floating_point.hpp>
|
||||
#include "libslic3r/MeshRepair.hpp"
|
||||
#include "libslic3r/Model.hpp"
|
||||
#include "libslic3r/ObjectID.hpp"
|
||||
#include "libslic3r/Geometry.hpp"
|
||||
#include "libslic3r/libslic3r.h"
|
||||
|
||||
@@ -99,104 +97,3 @@ TEST_CASE("An instance added from another's scale, rotation and mirror matches i
|
||||
original->get_rotation(), original->get_mirror());
|
||||
CHECK(copy->get_matrix().linear().isApprox(original->get_matrix().linear(), 1e-9));
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
// A flat triangle first, then a cube for each offset, all in one mesh.
|
||||
TriangleMesh flat_triangle_then_cubes(const std::vector<double> &cube_offsets)
|
||||
{
|
||||
indexed_triangle_set its;
|
||||
its.vertices = {{-20.f, 0.f, 0.f}, {-10.f, 0.f, 0.f}, {-15.f, 5.f, 0.f}};
|
||||
its.indices = {{0, 1, 2}};
|
||||
for (double offset : cube_offsets) {
|
||||
TriangleMesh cube = make_cube(10, 10, 10);
|
||||
cube.translate(float(offset), 0.f, 0.f);
|
||||
its_merge(its, cube.its);
|
||||
}
|
||||
return TriangleMesh(its);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("Splitting a part drops pieces enclosing no volume and keeps the part itself", "[Model]")
|
||||
{
|
||||
Model model;
|
||||
ModelObject *object = model.add_object();
|
||||
ModelVolume *volume = object->add_volume(flat_triangle_then_cubes({0., 30.}), ModelVolumeType::MODEL_PART, false);
|
||||
REQUIRE(volume->is_splittable());
|
||||
|
||||
CHECK(volume->split(1, false) == 2);
|
||||
REQUIRE(object->volumes.size() == 2);
|
||||
CHECK(std::find(object->volumes.begin(), object->volumes.end(), volume) != object->volumes.end());
|
||||
for (const ModelVolume *part : object->volumes) {
|
||||
CHECK(part->mesh().facets_count() == 12);
|
||||
CHECK_FALSE(part->is_splittable());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Splitting a part with a single solid piece keeps just that piece", "[Model]")
|
||||
{
|
||||
Model model;
|
||||
ModelObject *object = model.add_object();
|
||||
ModelVolume *volume = object->add_volume(flat_triangle_then_cubes({0.}), ModelVolumeType::MODEL_PART, false);
|
||||
|
||||
CHECK(volume->split(1, false) == 1);
|
||||
REQUIRE(object->volumes.size() == 1);
|
||||
CHECK(object->volumes.front() == volume);
|
||||
CHECK(volume->mesh().facets_count() == 12);
|
||||
}
|
||||
|
||||
TEST_CASE("Splitting a part made only of pieces enclosing no volume leaves it whole", "[Model]")
|
||||
{
|
||||
Model model;
|
||||
ModelObject *object = model.add_object();
|
||||
indexed_triangle_set its;
|
||||
its.vertices = {{0.f, 0.f, 0.f}, {10.f, 0.f, 0.f}, {5.f, 5.f, 0.f}, {20.f, 0.f, 0.f}, {30.f, 0.f, 0.f}, {25.f, 5.f, 0.f}};
|
||||
its.indices = {{0, 1, 2}, {3, 4, 5}};
|
||||
ModelVolume *volume = object->add_volume(TriangleMesh(its), ModelVolumeType::MODEL_PART, false);
|
||||
|
||||
CHECK(volume->split(1, false) == 1);
|
||||
REQUIRE(object->volumes.size() == 1);
|
||||
CHECK(object->volumes.front() == volume);
|
||||
CHECK(volume->mesh().facets_count() == 2);
|
||||
}
|
||||
|
||||
TEST_CASE("Replacing a part's mesh updates whether it can be split", "[Model]")
|
||||
{
|
||||
Model model;
|
||||
ModelObject *object = model.add_object();
|
||||
TriangleMesh two_cubes = make_cube(10, 10, 10);
|
||||
TriangleMesh second = make_cube(10, 10, 10);
|
||||
second.translate(30.f, 0.f, 0.f);
|
||||
two_cubes.merge(second);
|
||||
ModelVolume *volume = object->add_volume(std::move(two_cubes), ModelVolumeType::MODEL_PART, false);
|
||||
REQUIRE(volume->is_splittable());
|
||||
|
||||
volume->set_mesh(make_cube(10, 10, 10));
|
||||
CHECK_FALSE(volume->is_splittable());
|
||||
}
|
||||
|
||||
TEST_CASE("Repairing a part replaces its mesh only when the repair changes it", "[Model]")
|
||||
{
|
||||
Model model;
|
||||
ModelObject *object = model.add_object();
|
||||
TriangleMesh flipped = make_cube(10, 10, 10);
|
||||
std::swap(flipped.its.indices.front()[1], flipped.its.indices.front()[2]);
|
||||
ModelVolume *broken = object->add_volume(std::move(flipped), ModelVolumeType::MODEL_PART, false);
|
||||
TriangleMesh cube = make_cube(10, 10, 10);
|
||||
cube.translate(30.f, 0.f, 0.f);
|
||||
ModelVolume *valid = object->add_volume(std::move(cube), ModelVolumeType::MODEL_PART, false);
|
||||
const ObjectID broken_id = broken->id();
|
||||
const ObjectID valid_id = valid->id();
|
||||
|
||||
MeshRepairStats stats;
|
||||
REQUIRE(broken->repair(false, &stats));
|
||||
CHECK(stats.modified);
|
||||
CHECK(broken->id() != broken_id);
|
||||
CHECK_THAT(its_volume(broken->mesh().its), Catch::Matchers::WithinRel(1000., 1e-6));
|
||||
CHECK_FALSE(broken->get_convex_hull().empty());
|
||||
|
||||
REQUIRE(valid->repair(false, &stats));
|
||||
CHECK_FALSE(stats.modified);
|
||||
CHECK(valid->id() == valid_id);
|
||||
}
|
||||
|
||||
@@ -37,7 +37,6 @@
|
||||
#include <utility>
|
||||
#include "libslic3r/Config.hpp"
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include "libslic3r/libslic3r.h"
|
||||
#include "libslic3r/PublishSettings.hpp"
|
||||
#include <set>
|
||||
@@ -334,105 +333,6 @@ TEST_CASE("A directory of user presets loads with each one resolved against its
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("A user preset synced to the cloud and back keeps its values on every nozzle variant", "[Preset][Bundle]")
|
||||
{
|
||||
// Two extruders with a Standard and a High Flow variant each, as on a dual-nozzle printer.
|
||||
auto add_parent = [](PresetCollection &coll) {
|
||||
Preset &parent = add_inmemory_preset(coll, "Parent Process");
|
||||
parent.config.set_key_value("print_extruder_variant",
|
||||
new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow", "Direct Drive Standard", "Direct Drive High Flow"}));
|
||||
parent.config.set_key_value("print_extruder_id", new ConfigOptionInts({1, 1, 2, 2}));
|
||||
parent.config.set_deserialize_strict("outer_wall_speed", "50,50,50,50");
|
||||
parent.is_system = true;
|
||||
parent.setting_id = "parent-id";
|
||||
return parent.config;
|
||||
};
|
||||
|
||||
RenameTestCollection local;
|
||||
const DynamicPrintConfig parent_config = add_parent(local);
|
||||
Preset &child = add_inmemory_preset(local, "User Process", "Parent Process");
|
||||
child.config.apply_only(parent_config, {"print_extruder_variant", "print_extruder_id"});
|
||||
child.config.set_deserialize_strict("outer_wall_speed", "11,12,21,22");
|
||||
child.version = Semver(1, 0, 0);
|
||||
|
||||
std::map<std::string, std::string> uploaded;
|
||||
REQUIRE(local.get_differed_values_to_update(child, uploaded) == 0);
|
||||
uploaded[BBL_JSON_KEY_SETTING_ID] = "child-id";
|
||||
uploaded[BBL_JSON_KEY_USER_ID] = "user";
|
||||
|
||||
// A cloud copy stored before uploads carried the variant layout holds the values alone.
|
||||
std::map<std::string, std::string> stored_without_layout = uploaded;
|
||||
stored_without_layout.erase("print_extruder_variant");
|
||||
stored_without_layout.erase("print_extruder_id");
|
||||
// One saved while the parent had a single variant covers the first extruder only.
|
||||
std::map<std::string, std::string> stored_single_value = stored_without_layout;
|
||||
stored_single_value["outer_wall_speed"] = "11";
|
||||
|
||||
struct Case { const char *label; std::map<std::string, std::string> values; const char *expected; };
|
||||
for (const Case &c : {Case{"current upload", uploaded, "11,12,21,22"},
|
||||
Case{"stored without layout", stored_without_layout, "11,12,21,22"},
|
||||
Case{"stored with a single value", stored_single_value, "11,11,50,50"}}) {
|
||||
DYNAMIC_SECTION(c.label) {
|
||||
RenameTestCollection downloaded;
|
||||
PresetsConfigSubstitutions substitutions;
|
||||
add_parent(downloaded);
|
||||
REQUIRE(downloaded.load_user_preset("User Process", c.values, substitutions, ForwardCompatibilitySubstitutionRule::Disable));
|
||||
|
||||
const Preset *synced = downloaded.find_preset("User Process");
|
||||
REQUIRE(synced != nullptr);
|
||||
CHECK(synced->config.opt_serialize("outer_wall_speed") == c.expected);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("A user filament synced to the cloud and back keeps its values and unset overrides on every variant", "[Preset][Bundle]")
|
||||
{
|
||||
auto add_parent = [](PresetCollection &coll) {
|
||||
Preset &parent = add_inmemory_preset(coll, "Parent Filament");
|
||||
parent.config.set_key_value("filament_extruder_variant",
|
||||
new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"}));
|
||||
parent.config.set_deserialize_strict("nozzle_temperature", "220,220");
|
||||
parent.config.set_deserialize_strict("filament_retraction_length", "nil,nil");
|
||||
parent.is_system = true;
|
||||
parent.setting_id = "parent-id";
|
||||
return parent.config;
|
||||
};
|
||||
auto make_collection = [] {
|
||||
return std::make_unique<PresetCollection>(Preset::TYPE_FILAMENT, Preset::filament_options(),
|
||||
static_cast<const PrintRegionConfig &>(FullPrintConfig::defaults()));
|
||||
};
|
||||
|
||||
auto local = make_collection();
|
||||
add_parent(*local);
|
||||
Preset &child = add_inmemory_preset(*local, "User Filament", "Parent Filament");
|
||||
child.config.apply_only(add_parent(*make_collection()), {"filament_extruder_variant"});
|
||||
child.config.set_deserialize_strict("nozzle_temperature", "200,210");
|
||||
child.config.set_deserialize_strict("filament_retraction_length", "1.2,nil");
|
||||
child.version = Semver(1, 0, 0);
|
||||
|
||||
std::map<std::string, std::string> uploaded;
|
||||
REQUIRE(local->get_differed_values_to_update(child, uploaded) == 0);
|
||||
uploaded[BBL_JSON_KEY_SETTING_ID] = "child-id";
|
||||
uploaded[BBL_JSON_KEY_USER_ID] = "user";
|
||||
std::map<std::string, std::string> stored_without_layout = uploaded;
|
||||
stored_without_layout.erase("filament_extruder_variant");
|
||||
|
||||
for (const auto &[label, values] : {std::make_pair("current upload", uploaded),
|
||||
std::make_pair("stored without layout", stored_without_layout)}) {
|
||||
DYNAMIC_SECTION(label) {
|
||||
auto downloaded = make_collection();
|
||||
PresetsConfigSubstitutions substitutions;
|
||||
add_parent(*downloaded);
|
||||
REQUIRE(downloaded->load_user_preset("User Filament", values, substitutions, ForwardCompatibilitySubstitutionRule::Disable));
|
||||
|
||||
const Preset *synced = downloaded->find_preset("User Filament");
|
||||
REQUIRE(synced != nullptr);
|
||||
CHECK(synced->config.opt_serialize("nozzle_temperature") == "200,210");
|
||||
CHECK(synced->config.opt_serialize("filament_retraction_length") == "1.2,nil");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_CASE("Repeated loads of a user preset directory produce the same presets", "[Preset][Bundle]")
|
||||
{
|
||||
ScopedTemporaryDir temp_dir;
|
||||
|
||||
@@ -4,7 +4,6 @@
|
||||
#include <string>
|
||||
#include <ios>
|
||||
|
||||
#include <catch2/catch_message.hpp>
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
#include "libslic3r/Model.hpp"
|
||||
@@ -92,26 +91,6 @@ TEST_CASE("A cone with a slightly tilted seam imports as a closed mesh", "[Step]
|
||||
CHECK(its_num_open_edges(model.objects.front()->volumes.front()->mesh().its) == 0);
|
||||
}
|
||||
|
||||
// The fixture holds two trimmed planes in a geometric set and no shells or solids, as some CAD exporters write
|
||||
// surface models, so OCCT reads it as a compound of loose faces.
|
||||
TEST_CASE("A surface model imports whether or not compounds are split", "[Step]")
|
||||
{
|
||||
const std::string path = std::string(TEST_DATA_DIR) + PATH_SEPARATOR "surface_model_geometric_set.step";
|
||||
const bool split = GENERATE(false, true);
|
||||
CAPTURE(split);
|
||||
|
||||
Model model;
|
||||
bool cancel = false;
|
||||
Step step(path);
|
||||
|
||||
REQUIRE(step.load() == Step::Step_Status::LOAD_SUCCESS);
|
||||
REQUIRE(step.mesh(&model, cancel, split) == Step::Step_Status::MESH_SUCCESS);
|
||||
|
||||
REQUIRE(model.objects.size() == 1);
|
||||
REQUIRE(model.objects.front()->volumes.size() == 1);
|
||||
CHECK(model.objects.front()->volumes.front()->mesh().facets_count() > 0);
|
||||
}
|
||||
|
||||
TEST_CASE("isUtf8 recognises two, three and four byte sequences", "[Step]")
|
||||
{
|
||||
CHECK(StepPreProcessor::isUtf8("\xC3\xA9")); // U+00E9
|
||||
|
||||
@@ -32,7 +32,6 @@
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <boost/filesystem.hpp>
|
||||
|
||||
#include "libslic3r/AABBMesh.hpp"
|
||||
@@ -2301,32 +2300,45 @@ TEST_CASE("Texture displacement JSON keeps defaults for keys it does not carry",
|
||||
CHECK(!texture_displacement_layers_from_json("not json at all", unused_layers, unused_options));
|
||||
}
|
||||
|
||||
TEST_CASE("Texture displacement JSON with a wrong-typed element or an out-of-range slot is rejected", "[TextureDisplacement]")
|
||||
// The vectors, the islands and the UV overrides are read through nlohmann's typed accessors, which
|
||||
// throw on a value of the wrong type rather than returning anything. Nothing between here and the
|
||||
// project load catches that, so a document carrying one has to come back as "malformed block".
|
||||
TEST_CASE("Texture displacement JSON reports a value of the wrong type instead of throwing", "[TextureDisplacement]")
|
||||
{
|
||||
const std::string layer = GENERATE(as<std::string>{},
|
||||
R"({"slot":0,"offset":["x",0]})",
|
||||
R"({"slot":0,"view_project_right":[null,0,0]})",
|
||||
R"({"slot":0,"view_project_matrix":[0,0,0,0,0,0,0,0,0,0,0,"x"]})",
|
||||
R"({"slot":0,"lscm_seam_edges":[1,null]})",
|
||||
R"({"slot":0,"islands":[[0,0,"x",1]]})",
|
||||
R"({"slot":0,"lscm_uv_overrides":[[null,0,0]]})",
|
||||
R"({"slot":8})",
|
||||
R"({"slot":-1})",
|
||||
R"({"slot":"x"})",
|
||||
R"({"name":"No slot"})");
|
||||
INFO(layer);
|
||||
const std::string json = GENERATE(
|
||||
R"({"layers":[{"slot":0,"offset":["a","b"]}]})",
|
||||
R"({"layers":[{"slot":0,"view_project_right":[1,null,3]}]})",
|
||||
R"({"layers":[{"slot":0,"view_project_matrix":[1,2,3,4,5,6,7,8,9,10,11,"x"]}]})",
|
||||
R"({"layers":[{"slot":0,"lscm_seam_edges":["a","b"]}]})",
|
||||
R"({"layers":[{"slot":0,"islands":[[1,2,"a",4]]}]})",
|
||||
R"({"layers":[{"slot":0,"lscm_uv_overrides":[[1,"a",3]]}]})");
|
||||
INFO(json);
|
||||
|
||||
std::vector<TextureDisplacementLayer> layers(1);
|
||||
layers.front().name = "Kept";
|
||||
TextureDisplacementOptions options;
|
||||
options.color_mix_count = 7;
|
||||
|
||||
bool parsed = true;
|
||||
REQUIRE_NOTHROW(parsed = texture_displacement_layers_from_json(R"({"version":1,"layers":[)" + layer + "]}", layers, options));
|
||||
std::vector<TextureDisplacementLayer> layers;
|
||||
TextureDisplacementOptions options;
|
||||
bool parsed = true;
|
||||
REQUIRE_NOTHROW(parsed = texture_displacement_layers_from_json(json, layers, options));
|
||||
CHECK_FALSE(parsed);
|
||||
CHECK(layers.empty());
|
||||
}
|
||||
|
||||
// A plain setting is read through a helper that shrugs a wrong type off, which is the deliberate
|
||||
// other half of the case above: the field keeps its default and the rest of the layer still loads.
|
||||
TEST_CASE("Texture displacement JSON keeps the default for a setting of the wrong type", "[TextureDisplacement]")
|
||||
{
|
||||
const std::string json = R"({"options":{"smooth_strength":"a lot"},"layers":[{"slot":"two","name":"Old","depth_mm":0.75}]})";
|
||||
|
||||
std::vector<TextureDisplacementLayer> layers;
|
||||
TextureDisplacementOptions options;
|
||||
REQUIRE(texture_displacement_layers_from_json(json, layers, options));
|
||||
REQUIRE(layers.size() == 1);
|
||||
CHECK(layers.front().name == "Kept");
|
||||
CHECK(options.color_mix_count == 7);
|
||||
|
||||
const TextureDisplacementLayer fresh;
|
||||
const TextureDisplacementOptions defaults;
|
||||
CHECK(layers[0].slot == fresh.slot);
|
||||
CHECK(layers[0].name == "Old");
|
||||
CHECK_THAT(layers[0].depth_mm, WithinAbs(0.75f, 1e-6f));
|
||||
CHECK_THAT(options.smooth_strength, WithinAbs(defaults.smooth_strength, 1e-6f));
|
||||
}
|
||||
|
||||
TEST_CASE("whether a layer's texture has colour agrees with its decode", "[TextureDisplacement]")
|
||||
|
||||
@@ -37,7 +37,6 @@ add_executable(${_TEST_NAME}_tests
|
||||
test_plugin_json_depth.cpp
|
||||
test_shortcuts.cpp
|
||||
test_texture_color_palette.cpp
|
||||
test_texture_island_view.cpp
|
||||
test_file_url.cpp
|
||||
test_user_manager.cpp
|
||||
../fff_print/test_helpers.cpp
|
||||
|
||||
@@ -1,99 +0,0 @@
|
||||
// How the texture displacement gizmo's view follows the UV editor's island highlight. The rules live in
|
||||
// libslic3r_gui; this is the suite that links it. Same Windows include prologue as
|
||||
// test_texture_color_palette.cpp (wx pulls in <windows.h>; keep WIN32_LEAN_AND_MEAN / NOMINMAX ahead of it).
|
||||
#ifdef WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <Windows.h>
|
||||
#endif
|
||||
|
||||
#include <catch2/catch_test_macros.hpp>
|
||||
#include <catch2/generators/catch_generators.hpp>
|
||||
|
||||
#include "slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp"
|
||||
|
||||
using Follow = Slic3r::GUI::GLGizmoTextureDisplacement::IslandViewFollow;
|
||||
|
||||
namespace {
|
||||
|
||||
// The View row's indices, and step()'s "apply nothing".
|
||||
constexpr int NORMAL = 0, FAST = 1, CHECKER = 2, DISTORTION = 3, NONE = -1;
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST_CASE("a Normal view gives way to Fast while islands are selected and comes back once none are", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
CHECK(f.step(false, NORMAL, false) == NONE);
|
||||
CHECK(f.step(true, NORMAL, false) == FAST);
|
||||
CHECK(f.step(true, FAST, false) == NONE);
|
||||
CHECK(f.step(false, FAST, false) == NORMAL);
|
||||
CHECK(f.step(false, NORMAL, false) == NONE);
|
||||
}
|
||||
|
||||
TEST_CASE("a Fast, Checker or Distortion view is left alone by the island highlight", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
const int view = GENERATE(FAST, CHECKER, DISTORTION);
|
||||
Follow f;
|
||||
CHECK(f.step(true, view, false) == NONE);
|
||||
CHECK(f.step(false, view, false) == NONE);
|
||||
}
|
||||
|
||||
TEST_CASE("arriving in Normal with islands already selected switches to Fast", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
// The pane's Height button over Checker lands in Normal with the islands still selected.
|
||||
Follow f;
|
||||
CHECK(f.step(true, CHECKER, false) == NONE);
|
||||
CHECK(f.step(true, NORMAL, false) == FAST);
|
||||
CHECK(f.step(false, FAST, false) == NORMAL);
|
||||
}
|
||||
|
||||
TEST_CASE("Normal picked while islands are selected stays until they are deselected", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
REQUIRE(f.step(true, NORMAL, false) == FAST);
|
||||
f.picked(NORMAL);
|
||||
CHECK(f.step(true, NORMAL, false) == NONE);
|
||||
// A debug stage opening and closing over it changes nothing.
|
||||
CHECK(f.step(true, NORMAL, true) == NONE);
|
||||
CHECK(f.step(true, NORMAL, false) == NONE);
|
||||
CHECK(f.step(false, NORMAL, false) == NONE);
|
||||
CHECK(f.step(true, NORMAL, false) == FAST);
|
||||
}
|
||||
|
||||
TEST_CASE("Fast picked while it was switched on stays after deselecting", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
REQUIRE(f.step(true, NORMAL, false) == FAST);
|
||||
f.picked(FAST);
|
||||
CHECK(f.step(false, FAST, false) == NONE);
|
||||
}
|
||||
|
||||
TEST_CASE("Normal picked with nothing selected does not hold off the next switch", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
CHECK(f.step(false, NORMAL, false) == NONE);
|
||||
f.picked(NORMAL);
|
||||
CHECK(f.step(true, NORMAL, false) == FAST);
|
||||
}
|
||||
|
||||
TEST_CASE("a debug stage holds Normal while it is open, and the switch follows once it closes", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
REQUIRE(f.step(true, NORMAL, false) == FAST);
|
||||
// The stage takes Normal itself, with the islands still selected.
|
||||
CHECK(f.step(true, NORMAL, true) == NONE);
|
||||
CHECK(f.step(true, NORMAL, false) == FAST);
|
||||
}
|
||||
|
||||
TEST_CASE("islands deselected while a debug stage is open apply no view over it", "[TextureIslandView][TextureDisplacement]")
|
||||
{
|
||||
Follow f;
|
||||
REQUIRE(f.step(true, NORMAL, false) == FAST);
|
||||
CHECK(f.step(false, NORMAL, true) == NONE);
|
||||
CHECK(f.step(false, NORMAL, false) == NONE);
|
||||
}
|
||||
Reference in New Issue
Block a user