Keep OBJ Texture Coordinates That Carry a W Component

The vt parser stopped reading the optional third component when texture
coordinates were cut down to u and v, but the check that nothing is left
on the line stayed. A legal "vt u v w" line was therefore rejected and
silently dropped, shifting every later texture index. The w component is
parsed again and discarded.

The texture coordinate stride is now a named constant, OBJ_TEXCOORD_LENGTH,
used by the parser and the importer, so the relative-index rebase cannot
drift from the storage layout again.

src/OrcaSlicer.cpp

@@ -2116,14 +2116,9 @@ int CLI::run(int argc, char **argv)
 
     // One resolver for the whole run, so presets from the same vendor tree share its load.
     std::unique_ptr<PresetBundle> system_preset_resolver;
-    auto ensure_system_preset_resolver = [&system_preset_resolver]() -> PresetBundle & {
+    auto resolve_preset = [&ensure_cli_preset_bundle, &system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
-        if (!system_preset_resolver)
+                                                                               std::string &config_type, const std::string &config_from,
-            system_preset_resolver = std::make_unique<PresetBundle>();
+                                                                               bool probe_type, std::string &error) {
-        return *system_preset_resolver;
-    };
-    auto resolve_preset = [&ensure_cli_preset_bundle, &ensure_system_preset_resolver](const std::string &file, DynamicPrintConfig &config,
-                                                                                      std::string &config_type, const std::string &config_from,
-                                                                                      bool probe_type, std::string &error) {
         const auto *inherits = config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS);
         if (!probe_type && (inherits == nullptr || inherits->value.empty()))
             return true;
@@ -2131,7 +2126,9 @@ int CLI::run(int argc, char **argv)
         PresetBundle                 *bundle = nullptr;
         bool                          allow_source_manifest = false;
         if (config_from == "system") {
-            bundle                = &ensure_system_preset_resolver();
+            if (!system_preset_resolver)
+                system_preset_resolver = std::make_unique<PresetBundle>();
+            bundle                = system_preset_resolver.get();
             allow_source_manifest = true;
         } else {
             bundle = ensure_cli_preset_bundle(error);
@@ -3123,49 +3120,6 @@ int CLI::run(int argc, char **argv)
         return 0;
     };
 
-    // A project saved before a printer or process option existed has no value for it. The GUI takes such
-    // keys from the project's system preset (load_external_preset refreshes every key the project did not
-    // override), so fill them from there too instead of leaving them to the option default.
-    // The extruder variant keys describe the project's variant layout and are kept as they are, so an
-    // older project is not left with a variant list from one layout and ids from another.
-    auto fill_missing_project_keys = [this, &ensure_system_preset_resolver](const std::string &system_name, Preset::Type type) {
-        if (system_name.empty())
-            return;
-        static const std::set<std::string> skip_keys = {
-            "inherits", "compatible_printers", "compatible_prints", "compatible_printers_condition", "compatible_prints_condition",
-            "print_settings_id", "filament_settings_id", "printer_settings_id",
-            "print_host", "print_host_webui", "printhost_apikey", "printhost_cafile", "printhost_user", "printhost_password", "printhost_port",
-            "printer_extruder_id", "printer_extruder_variant", "print_extruder_id", "print_extruder_variant", "extruder_variant_list"};
-        const std::vector<std::string> &options = type == Preset::TYPE_PRINTER ? Preset::printer_options() : Preset::print_options();
-        // Keys the legacy handler drops on load can never be in a project, so they do not count as missing.
-        auto dropped_on_load = [](std::string key) {
-            std::string value;
-            PrintConfigDef::handle_legacy(key, value);
-            return key.empty();
-        };
-        std::vector<std::string> missing;
-        for (const std::string &key : options)
-            if (m_print_config.option(key) == nullptr && skip_keys.count(key) == 0 && !dropped_on_load(key))
-                missing.push_back(key);
-        if (missing.empty())
-            return;
-        DynamicPrintConfig system_config;
-        std::string        error;
-        if (!ensure_system_preset_resolver().resolve_system_preset(system_config, type, system_name, config_substitution_rule, error)) {
-            BOOST_LOG_TRIVIAL(warning) << boost::format("CLI: system preset '%1%' not resolved (%2%); keys missing from the project keep their defaults") % system_name % error;
-            return;
-        }
-        for (const std::string &key : missing)
-            if (const ConfigOption *opt = system_config.option(key)) {
-                m_print_config.set_key_value(key, opt->clone());
-                BOOST_LOG_TRIVIAL(info) << boost::format("CLI: %1% missing from the project, taken from '%2%': %3%") % key % system_name % opt->serialize();
-            }
-    };
-    if (new_printer_name.empty())
-        fill_missing_project_keys(current_printer_system_name, Preset::TYPE_PRINTER);
-    if (new_process_name.empty())
-        fill_missing_project_keys(current_process_system_name, Preset::TYPE_PRINT);
-
     std::vector<std::string>& different_settings = m_print_config.option<ConfigOptionStrings>("different_settings_to_system", true)->values;
     std::vector<std::string>& inherits_group = m_print_config.option<ConfigOptionStrings>("inherits_group", true)->values;
     inherits_group.resize(filament_count + 2, std::string());

src/libslic3r/Format/DRC.cpp

@@ -48,24 +48,37 @@ bool load_drc(const char *path, TriangleMesh *meshptr)
         indexed_triangle_set its;
 
         const PointAttribute *const positions = dracoMesh.GetNamedAttribute(GeometryAttribute::POSITION);
+        if (positions == nullptr) {
+            BOOST_LOG_TRIVIAL(error) << "load_drc: the mesh has no POSITION attribute";
+            return false;
+        }
         size_t num_vertices = positions->size();
         its.vertices.reserve(num_vertices);
         for (AttributeValueIndex i(0); i < num_vertices; ++ i) {
             float pos[3];
-            positions->ConvertValue<float>(i, 3, pos);
+            if (!positions->ConvertValue<float>(i, 3, pos)) {
+                BOOST_LOG_TRIVIAL(error) << "load_drc: invalid vertex position";
+                return false;
+            }
             its.vertices.emplace_back(pos[0], pos[1], pos[2]);
         }
 
+        // The Draco decoder does not check face indices against the point count.
+        const uint32_t num_points = dracoMesh.num_points();
         size_t num_faces = dracoMesh.num_faces();
         its.indices.reserve(num_faces);
         for (FaceIndex i(0); i < num_faces; ++ i) {
-            Mesh::Face face = dracoMesh.face(i);
+            const Mesh::Face &face = dracoMesh.face(i);
-
+            stl_triangle_vertex_indices facet;
-            its.indices.emplace_back(
+            for (int k = 0; k < 3; ++ k) {
-                positions->mapped_index(face[0]).value(),
+                const size_t vertex_idx = face[k].value() < num_points ? positions->mapped_index(face[k]).value() : num_vertices;
-                positions->mapped_index(face[1]).value(),
+                if (vertex_idx >= num_vertices) {
-                positions->mapped_index(face[2]).value()
+                    BOOST_LOG_TRIVIAL(error) << "load_drc: invalid vertex index";
-            );
+                    return false;
+                }
+                facet[k] = static_cast<int>(vertex_idx);
+            }
+            its.indices.emplace_back(facet);
         }
 
         *meshptr = TriangleMesh(std::move(its));

src/libslic3r/Format/OBJ.cpp

@@ -166,10 +166,15 @@ bool load_obj(const char *path, TriangleMesh *meshptr, ObjInfo& obj_info, std::s
                             obj_info.uv_map_pngs[face_index] = png_name;
                         }
                         if (data.textureCoordinates.size() > 0) {
-                            Vec2f                uv0(data.textureCoordinates[uvs[0] * 2], data.textureCoordinates[uvs[0] * 2 + 1]);
+                            // A face vertex may omit vt or reference a missing one. Fall back to (0, 0) rather than
-                            Vec2f                uv1(data.textureCoordinates[uvs[1] * 2], data.textureCoordinates[uvs[1] * 2 + 1]);
+                            // skipping the face, so obj_info.uvs stays aligned with the face indices.
-                            Vec2f                uv2(data.textureCoordinates[uvs[2] * 2], data.textureCoordinates[uvs[2] * 2 + 1]);
+                            const int uv_count = static_cast<int>(data.textureCoordinates.size() / OBJ_TEXCOORD_LENGTH);
-                            std::array<Vec2f, 3> uv_array{uv0, uv1, uv2};
+                            auto      uv_at    = [&data, uv_count](int idx) -> Vec2f {
+                                if (idx < 0 || idx >= uv_count)
+                                    return Vec2f::Zero();
+                                return Vec2f(data.textureCoordinates[idx * OBJ_TEXCOORD_LENGTH], data.textureCoordinates[idx * OBJ_TEXCOORD_LENGTH + 1]);
+                            };
+                            std::array<Vec2f, 3> uv_array{uv_at(uvs[0]), uv_at(uvs[1]), uv_at(uvs[2])};
                             obj_info.uvs.emplace_back(uv_array);
                         }
                         obj_info.face_colors.emplace_back(face_color);

src/libslic3r/Format/objparser.cpp

@@ -51,19 +51,18 @@ static bool obj_parseline(const char *line, ObjData &data)
 				line = endptr;
 				EATWS();
 			}
-			/*double w = 0;
+			// The optional w is accepted but not stored: only u and v are used.
 			if (*line != 0) {
-				w = strtod(line, &endptr);
+				strtod(line, &endptr);
 				if (endptr == 0 || (*endptr != ' ' && *endptr != '\t' && *endptr != 0))
 					return false;
 				line = endptr;
 				EATWS();
-			}*/
+			}
 			if (*line != 0)
 				return false;
 			data.textureCoordinates.push_back((float)u);
 			data.textureCoordinates.push_back((float)v);
-			//data.textureCoordinates.push_back((float)w);
 			break;
 		}
 		case 'n':
@@ -245,7 +244,7 @@ static bool obj_parseline(const char *line, ObjData &data)
             else
 				-- vertex.normalIdx;
 			if (vertex.textureCoordIdx < 0)
-                vertex.textureCoordIdx += (int)data.textureCoordinates.size() / 3;
+                vertex.textureCoordIdx += (int)data.textureCoordinates.size() / OBJ_TEXCOORD_LENGTH;
             else
 				-- vertex.textureCoordIdx;
 			data.vertices.push_back(vertex);

src/libslic3r/Format/objparser.hpp

@@ -92,6 +92,7 @@ inline bool operator==(const ObjSmoothingGroup &v1, const ObjSmoothingGroup &v2)
 }
 #define OBJ_VERTEX_COLOR_ALPHA 6
 #define OBJ_VERTEX_LENGTH   7  // x, y, z, color_x,color_y,color_z,color_w
+#define OBJ_TEXCOORD_LENGTH 2  // u, v
 #define ONE_FACE_SIZE 4//ONE_FACE format: f 8/4/6 7/3/6 6/2/6 -1/-1/-1
 struct ObjData {
 	// Version of the data structure for load / store in the private binary format.
@@ -100,7 +101,7 @@ struct ObjData {
 	// x, y, z, color_x,color_y,color_z,color_w
 	std::vector<float>				coordinates;
     bool                            has_vertex_color{false};
-	// u, v, w
+	// u, v
 	std::vector<float>				textureCoordinates;
 	// x, y, z
 	std::vector<float>				normals;

src/libslic3r/PresetBundle.cpp

@@ -575,20 +575,18 @@ bool PresetBundle::resolve_preset_config(DynamicPrintConfig &config, Preset::Typ
 const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::path &root_dir,
                                                     const std::string &vendor_id,
                                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                                    std::string &error, bool allow_cache)
+                                                    std::string &error)
 {
-    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule, allow_cache);
+    auto key = std::make_tuple(root_dir.string(), vendor_id, compatibility_rule);
     if (auto it = m_source_vendor_bundles.find(key); it != m_source_vendor_bundles.end())
         return it->second.get();
 
     // The library loads with no base of its own, so the tree a vendor inherits from
     // is the same one that resolves the library's own presets.
-    const std::string   library_file = std::string(ORCA_FILAMENT_LIBRARY);
+    const PresetBundle *library = nullptr;
-    const PresetBundle *library      = nullptr;
     if (vendor_id != ORCA_FILAMENT_LIBRARY &&
-        (boost::filesystem::is_regular_file(root_dir / (library_file + ".json")) ||
+        boost::filesystem::is_regular_file(root_dir / (std::string(ORCA_FILAMENT_LIBRARY) + ".json"))) {
-         (allow_cache && boost::filesystem::is_regular_file(root_dir / (library_file + ".opc"))))) {
+        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error);
-        library = load_source_vendor(root_dir, ORCA_FILAMENT_LIBRARY, compatibility_rule, error, allow_cache);
         if (library == nullptr) {
             error = "OrcaFilamentLibrary contains invalid presets";
             return nullptr;
@@ -597,7 +595,7 @@ const PresetBundle *PresetBundle::load_source_vendor(const boost::filesystem::pa
 
     auto bundle = std::make_unique<PresetBundle>();
     bundle->m_preserve_vendor_source_paths = true;
-    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, allow_cache);
+    bundle->load_vendor_configs_from_json(root_dir.string(), vendor_id, LoadSystem, compatibility_rule, library, false);
     if (bundle->error_count() != 0) {
         error = "Vendor bundle contains invalid presets";
         return nullptr;
@@ -640,43 +638,6 @@ bool PresetBundle::resolve_preset_config_type(DynamicPrintConfig &config, Preset
     return true;
 }
 
-bool PresetBundle::resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                                         ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error)
-{
-    const std::string vendor_id = find_preset_vendor(name, type);
-    if (vendor_id.empty()) {
-        error = "No vendor lists the preset";
-        return false;
-    }
-    // Release builds ship a vendor as its preset cache alone, without the profile JSONs.
-    auto installed = [&vendor_id](const fs::path &root) {
-        return fs::is_regular_file(root / (vendor_id + ".json")) || fs::is_regular_file(root / (vendor_id + ".opc"));
-    };
-    fs::path root_dir = fs::path(data_dir()) / PRESET_SYSTEM_DIR;
-    if (!installed(root_dir))
-        root_dir = fs::path(resources_dir()) / PRESET_PROFILES_DIR;
-    const bool cache_only = !fs::is_regular_file(root_dir / (vendor_id + ".json"));
-
-    try {
-        const PresetBundle *vendor = load_source_vendor(root_dir, vendor_id, compatibility_rule, error, cache_only);
-        if (vendor == nullptr)
-            return false;
-        const PresetCollection &collection = type == Preset::TYPE_PRINTER ? vendor->printers :
-                                             type == Preset::TYPE_PRINT   ? vendor->prints : vendor->filaments;
-        const Preset *preset = collection.find_preset(name, false);
-        if (preset == nullptr) {
-            error = "Preset was not found in its vendor bundle";
-            return false;
-        }
-        config = preset->config;
-    } catch (const std::exception &ex) {
-        error = ex.what();
-        return false;
-    }
-    error.clear();
-    return true;
-}
-
 PresetBundle::PresetBundle(const PresetBundle &rhs)
 {
     *this = rhs;

src/libslic3r/PresetBundle.hpp

@@ -273,10 +273,6 @@ public:
                                     const std::string &source_file,
                                     ForwardCompatibilitySubstitutionRule compatibility_rule,
                                     std::string &error, bool allow_source_manifest = true);
-    // Resolve a system preset by name. The vendor tree is read from data_dir()/system when installed
-    // there, as the GUI reads it, and from the bundled profiles otherwise.
-    bool resolve_system_preset(DynamicPrintConfig &config, Preset::Type type, const std::string &name,
-                               ForwardCompatibilitySubstitutionRule compatibility_rule, std::string &error);
 
     // Load selections (current print, current filaments, current printer) from config.ini
     // This is done just once on application start up.
@@ -667,14 +663,13 @@ private:
     // Vendor trees loaded by resolve_preset_config's manifest path, so every preset
     // resolved through this bundle shares one load per source root and vendor. The
     // filament library is one such tree, shared by every vendor under its root.
-    // A tree read from its preset cache is kept apart: its presets carry no source file.
+    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule>, std::unique_ptr<PresetBundle>>
-    std::map<std::tuple<std::string, std::string, ForwardCompatibilitySubstitutionRule, bool>, std::unique_ptr<PresetBundle>>
         m_source_vendor_bundles;
 
     const PresetBundle *load_source_vendor(const boost::filesystem::path &root_dir,
                                            const std::string &vendor_id,
                                            ForwardCompatibilitySubstitutionRule compatibility_rule,
-                                           std::string &error, bool allow_cache = false);
+                                           std::string &error);
 
     // Orca: validation only - flag any printer with two or more compatible
     // filament presets sharing one filament_id (ambiguous AMS subtype match).

src/libvgcode/src/Shaders.hpp

@@ -34,10 +34,6 @@ static const char* Segments_Vertex_Shader =
 // ORCA: 0 during the shadow caster pass - the bias below shifts eye_position but not
 // world_position, so the caster would write a depth the receiver never looks up.
 "uniform float bias_scale;\n"
-// draw the instances last to first, top layers before the ones they hide, so that early depth
-// rejection discards most of the hidden fragments; set when the camera looks down on the print
-"uniform int reverse_order;\n"
-"uniform int instance_count;\n"
 "in int vertex_id;\n"
 "out vec3 color;\n"
 "// ORCA: realistic view - the light the shadow map is able to block, kept apart from the\n"
@@ -63,8 +59,7 @@ static const char* Segments_Vertex_Shader =
 "  return top_diffuse + front_diffuse + top_specular;\n"
 "}\n"
 "void main() {\n"
-"  int instance = (reverse_order != 0) ? instance_count - 1 - gl_InstanceID : gl_InstanceID;\n"
+"  int id_a = int(texelFetch(segment_index_tex, gl_InstanceID).r);\n"
-"  int id_a = int(texelFetch(segment_index_tex, instance).r);\n"
 "  int id_b = id_a + 1;\n"
 "  vec3 pos_a = texelFetch(position_tex, id_a).xyz;\n"
 "  vec3 pos_b = texelFetch(position_tex, id_b).xyz;\n"

src/libvgcode/src/ViewerImpl.cpp

@@ -763,8 +763,6 @@ void ViewerImpl::init(const std::string& opengl_context_version)
     m_uni_segments_height_width_angle_tex_id = glGetUniformLocation(m_segments_shader_id, "height_width_angle_tex");
     m_uni_segments_colors_tex_id             = glGetUniformLocation(m_segments_shader_id, "color_tex");
     m_uni_segments_segment_index_tex_id      = glGetUniformLocation(m_segments_shader_id, "segment_index_tex");
-    m_uni_segments_reverse_order_id          = glGetUniformLocation(m_segments_shader_id, "reverse_order");
-    m_uni_segments_instance_count_id         = glGetUniformLocation(m_segments_shader_id, "instance_count");
     // ORCA: realistic view
     m_uni_segments_shadow_map_id             = glGetUniformLocation(m_segments_shader_id, "shadow_map");
     m_uni_segments_shadow_light_vp_id        = glGetUniformLocation(m_segments_shader_id, "shadow_light_vp");
@@ -2092,15 +2090,6 @@ void ViewerImpl::render_segments(const Mat4x4& view_matrix, const Mat4x4& projec
     glsafe(glUniformMatrix4fv(m_uni_segments_view_matrix_id, 1, GL_FALSE, view_matrix.data()));
     glsafe(glUniformMatrix4fv(m_uni_segments_projection_matrix_id, 1, GL_FALSE, projection_matrix.data()));
     glsafe(glUniform3fv(m_uni_segments_camera_position_id, 1, camera_position.data()));
-    // The segments come in print order, bottom layer first. Seen from above, that is back to front,
-    // and every hidden fragment is shaded before the one that covers it. Drawing them last to first
-    // lets the depth test reject the hidden ones instead. The camera looks down when the world's
-    // up axis points towards it, which is the view matrix's (2, 2) entry being positive.
-    const bool top_down = !m_rendering_shadow_casters && view_matrix[10] > 0.0f;
-    glsafe(glUniform1i(m_uni_segments_reverse_order_id, top_down ? 1 : 0));
-#ifndef ENABLE_OPENGL_ES
-    glsafe(glUniform1i(m_uni_segments_instance_count_id, static_cast<int>(m_enabled_segments_count)));
-#endif // ENABLE_OPENGL_ES
     // ORCA: realistic view. The depth pass writes the map it would otherwise read, so it shades
     // with the lookup off.
     glsafe(glUniform1i(m_uni_segments_shadow_map_id, m_shadow_map_texture_unit));

src/libvgcode/src/ViewerImpl.hpp

@@ -362,8 +362,6 @@ private:
     int m_uni_segments_height_width_angle_tex_id{ -1 };
     int m_uni_segments_colors_tex_id{ -1 };
     int m_uni_segments_segment_index_tex_id{ -1 };
-    int m_uni_segments_reverse_order_id{ -1 };
-    int m_uni_segments_instance_count_id{ -1 };
     int m_uni_segments_shadow_map_id{ -1 };
     int m_uni_segments_shadow_light_vp_id{ -1 };
     int m_uni_segments_shadow_intensity_id{ -1 };

tests/cli/CMakeLists.txt

@@ -15,11 +15,3 @@ set_tests_properties(cli_strict_mode PROPERTIES
     LABELS "CLI;RequiresApp"
     SKIP_RETURN_CODE 77
     TIMEOUT 900)
-
-add_test(NAME cli_project_missing_keys
-    COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cli_project_missing_keys.sh $<TARGET_FILE:OrcaSlicer> ${ORCA_CLI_TEST_PYTHON}
-        ${CMAKE_SOURCE_DIR}/resources/profiles/BBL)
-set_tests_properties(cli_project_missing_keys PROPERTIES
-    LABELS "CLI;RequiresApp"
-    SKIP_RETURN_CODE 77
-    TIMEOUT 900)

tests/cli/test_cli_project_missing_keys.sh

@@ -1,89 +0,0 @@
-#!/usr/bin/env bash
-# End-to-end check that the CLI fills settings missing from a project from the project's system presets.
-#
-# A project saved before an option existed has no value for it. The GUI takes such keys from the
-# project's system printer and process presets, not from the option defaults, and the CLI must slice
-# the project with the same values. A project is exported from the shipped Bambu Lab P1S presets, one
-# printer key and one process key are removed from it, one kept key is changed, and it is sliced again.
-#
-# usage: test_cli_project_missing_keys.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-missing-keys.XXXXXX")"
-trap 'rm -rf "$WORK"' EXIT
-
-"$PY" - "$WORK/cube.stl" <<'EOF'
-import sys
-
-v = [(x, y, z) for z in (0, 10) for y in (0, 10) for x in (0, 10)]
-with open(sys.argv[1], "w") as f:
-    f.write("solid cube\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 cube\n")
-EOF
-
-# slice <tag> <input> [option...]: slice into $WORK/<tag>/out.3mf with a fresh data directory.
-slice() {
-    local out="$WORK/$1" input="$2"; shift 2
-    mkdir -p "$out"
-    timeout 300 "$BIN" --datadir "$out/datadir" "$@" --slice 0 --outputdir "$out" --export-3mf out.3mf "$input" \
-        > "$out/log" 2>&1 || { echo "FAIL: $1: orca-slicer exited $?"; tail -n 40 "$out/log"; exit 1; }
-}
-
-slice base "$WORK/cube.stl" \
-    --load-settings "$PROFILES/machine/Bambu Lab P1S 0.4 nozzle.json;$PROFILES/process/0.20mm Standard @BBL X1C.json" \
-    --load-filaments "$PROFILES/filament/Bambu PLA Basic @BBL P1S 0.4 nozzle.json"
-
-# The removed keys, with their option defaults from PrintConfig.cpp, and a kept key with a new value.
-"$PY" - "$WORK/base/out.3mf" "$WORK/old.3mf" <<'EOF' || exit $?
-import json, sys, zipfile
-
-src, dst = sys.argv[1], sys.argv[2]
-missing = {"extruder_clearance_dist_to_rod": "40", "sparse_infill_density": "20%"}
-with zipfile.ZipFile(src) as zin, zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
-    for item in zin.infolist():
-        data = zin.read(item.filename)
-        if item.filename == "Metadata/project_settings.config":
-            config = json.loads(data)
-            for key, default in missing.items():
-                if config[key] == default:
-                    print("SKIP: %s is %s in the system preset, the option default, so the test cannot tell them apart" % (key, default))
-                    sys.exit(77)
-            expected = {key: config.pop(key) for key in missing}
-            expected["wall_loops"] = str(int(config["wall_loops"]) + 1)
-            config["wall_loops"] = expected["wall_loops"]
-            data = json.dumps(config, indent=4)
-        zout.writestr(item, data)
-with open(dst + ".expected.json", "w") as f:
-    json.dump(expected, f)
-EOF
-
-slice project "$WORK/old.3mf"
-
-"$PY" - "$WORK/project/out.3mf" "$WORK/old.3mf.expected.json" <<'EOF'
-import json, sys, zipfile
-
-with zipfile.ZipFile(sys.argv[1]) as z:
-    config = json.loads(z.read("Metadata/project_settings.config"))
-with open(sys.argv[2]) as f:
-    expected = json.load(f)
-errors = ["%s is %r, want %r" % (key, config.get(key), want) for key, want in expected.items() if config.get(key) != want]
-for e in errors:
-    print("FAIL: " + e)
-sys.exit(1 if errors else 0)
-EOF
-status=$?
-[ "$status" -eq 0 ] || { tail -n 40 "$WORK/project/log"; exit 1; }
-echo "PASS"

tests/libslic3r/CMakeLists.txt

@@ -14,6 +14,7 @@ add_executable(${_TEST_NAME}_tests
     test_clipper_utils.cpp
     test_config.cpp
     test_config_variant_expansion.cpp
+    test_drc.cpp
     test_toolordering_nozzle_group.cpp
     test_preset_bundle_loading.cpp
     test_preset_setting_id.cpp
@@ -32,6 +33,7 @@ add_executable(${_TEST_NAME}_tests
     test_mutable_priority_queue.cpp
     test_minimum_spanning_tree.cpp
     test_nozzle_volume_type.cpp
+    test_obj.cpp
     test_step.cpp
     test_stl.cpp
     test_triangle_selector.cpp
@@ -67,7 +69,9 @@ if (TARGET OpenVDB::openvdb)
     target_sources(${_TEST_NAME}_tests PRIVATE test_hollowing.cpp)
 endif()
 
-target_link_libraries(${_TEST_NAME}_tests test_common libslic3r Catch2::Catch2WithMain)
+# libslic3r links Draco privately; test_drc.cpp encodes its own fixtures.
+find_package(Draco REQUIRED)
+target_link_libraries(${_TEST_NAME}_tests test_common libslic3r draco::draco Catch2::Catch2WithMain)
 target_include_directories(${_TEST_NAME}_tests PRIVATE ${CMAKE_SOURCE_DIR}/src)
 set_property(TARGET ${_TEST_NAME}_tests PROPERTY FOLDER "tests")
 

tests/libslic3r/test_drc.cpp

@@ -0,0 +1,71 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/Format/DRC.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+
+#include <boost/nowide/fstream.hpp>
+
+#include <draco/compression/encode.h>
+#include <draco/mesh/mesh.h>
+
+#include "test_utils.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+// Encodes one triangle whose vertices carry a single attribute of the given type.
+// The decoder accepts both a mesh without POSITION and a face index past the point count.
+void write_drc_triangle(const std::string &path, draco::GeometryAttribute::Type attribute_type, uint32_t second_point)
+{
+    draco::Mesh mesh;
+    mesh.set_num_points(3);
+    draco::GeometryAttribute attribute;
+    attribute.Init(attribute_type, nullptr, 3, draco::DT_FLOAT32, false, sizeof(float) * 3, 0);
+    const int attribute_id = mesh.AddAttribute(attribute, true, 3);
+    const float points[3][3] = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}};
+    for (int i = 0; i < 3; ++i)
+        mesh.attribute(attribute_id)->SetAttributeValue(draco::AttributeValueIndex(i), points[i]);
+    draco::Mesh::Face face;
+    face[0] = draco::PointIndex(0);
+    face[1] = draco::PointIndex(second_point);
+    face[2] = draco::PointIndex(2);
+    mesh.AddFace(face);
+
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::MESH_SEQUENTIAL_ENCODING);
+    draco::EncoderBuffer buffer;
+    REQUIRE(encoder.EncodeMeshToBuffer(mesh, &buffer).ok());
+    boost::nowide::ofstream out(path, std::ios::binary);
+    out.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
+}
+
+} // namespace
+
+TEST_CASE("A Draco triangle with positions loads", "[DRC]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::POSITION, 1);
+
+    TriangleMesh mesh;
+    REQUIRE(load_drc(drc.string().c_str(), &mesh));
+    CHECK(mesh.facets_count() == 1);
+}
+
+TEST_CASE("A Draco mesh without a POSITION attribute fails to load", "[DRC][Regression]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::GENERIC, 1);
+
+    TriangleMesh mesh;
+    CHECK_FALSE(load_drc(drc.string().c_str(), &mesh));
+}
+
+TEST_CASE("A Draco face referencing a missing point fails to load", "[DRC][Regression]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::POSITION, 200);
+
+    TriangleMesh mesh;
+    CHECK_FALSE(load_drc(drc.string().c_str(), &mesh));
+}

tests/libslic3r/test_obj.cpp

@@ -0,0 +1,122 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/Format/OBJ.hpp"
+
+#include <boost/nowide/fstream.hpp>
+
+#include "test_utils.hpp"
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+
+namespace {
+
+struct LoadedObj
+{
+    bool         ok{false};
+    TriangleMesh mesh;
+    ObjInfo      info;
+};
+
+// A tetrahedron with a material and two texture coordinates, (0.25, 0.5) and (0.75, 1).
+// Only the first face and the vt lines are varied; the other three faces reference vt 1.
+LoadedObj load_textured_tetrahedron(const std::string &first_face, const std::string &vts = "vt 0.25 0.5\nvt 0.75 1\n")
+{
+    ScopedTemporaryFile obj(".obj");
+    ScopedTemporaryFile mtl(".mtl");
+    {
+        boost::nowide::ofstream out(mtl.string());
+        out << "newmtl a\nKd 1 0 0\n";
+    }
+    {
+        boost::nowide::ofstream out(obj.string());
+        out << "mtllib " << mtl.path().filename().string() << "\n"
+            << "v 0 0 0\nv 10 0 0\nv 0 10 0\nv 0 0 10\n"
+            << vts
+            << "usemtl a\n"
+            << first_face << "\n"
+            << "f 1/1 2/1 4/1\nf 1/1 4/1 3/1\nf 2/1 3/1 4/1\n";
+    }
+    LoadedObj   loaded;
+    std::string message;
+    loaded.ok = load_obj(obj.string().c_str(), &loaded.mesh, loaded.info, message);
+    return loaded;
+}
+
+} // namespace
+
+TEST_CASE("An out-of-range texture index falls back to a zero UV and keeps the geometry", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/1000000000 3/1 2/1");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0., 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0., 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(0.5, 1e-6));
+}
+
+TEST_CASE("A face without texture indices loads among faces that have them", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1 3 2");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    // One UV entry per face, so later faces keep their own coordinates.
+    REQUIRE(loaded.info.uvs.size() == 4);
+    for (const Vec2f &uv : loaded.info.uvs.front()) {
+        CHECK_THAT(uv.x(), WithinAbs(0., 1e-6));
+        CHECK_THAT(uv.y(), WithinAbs(0., 1e-6));
+    }
+    CHECK_THAT(loaded.info.uvs[1][0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(loaded.info.uvs[1][0].y(), WithinAbs(0.5, 1e-6));
+}
+
+TEST_CASE("A negative texture index counts back from the last texture coordinate", "[OBJ]")
+{
+    // -1 is the most recent vt (0.75, 1), -2 the one before it (0.25, 0.5).
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/-2 3/-1 2/-1");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+}
+
+TEST_CASE("Texture coordinates with a w component are kept", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/1 3/2 2/2", "vt 0.25 0.5 0\nvt 0.75 1 0\n");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+}
+
+TEST_CASE("A texture coordinate with w does not shift the indices of the ones after it", "[OBJ][Regression]")
+{
+    // The w on the first vt used to drop that line, so vt 2 resolved to the third coordinate.
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/2 3/3 2/-1", "vt 0.1 0.2 0\nvt 0.25 0.5\nvt 0.75 1\n");
+
+    REQUIRE(loaded.ok);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+    CHECK_THAT(uv[2].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[2].y(), WithinAbs(1., 1e-6));
+}

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -5405,35 +5405,6 @@ struct ScopedDataDir
     ~ScopedDataDir() { set_data_dir(previous); }
 };
 
-// resources_dir() is process-wide too; system preset lookups scan its profiles directory.
-struct ScopedResourcesDir
-{
-    std::string previous = resources_dir();
-    explicit ScopedResourcesDir(const fs::path &dir) { set_resources_dir(dir.string()); }
-    ~ScopedResourcesDir() { set_resources_dir(previous); }
-};
-
-// An "Acme" vendor under root whose "Acme Printer" inherits extruder_clearance_dist_to_rod from an
-// abstract base, with the printer in a nested sub_path so the name cannot be derived from the file.
-void write_acme_printer_vendor(const fs::path &root, double dist_to_rod)
-{
-    const fs::path machine_dir = root / "Acme" / "machine";
-    fs::create_directories(machine_dir / "nested");
-    std::ofstream((root / "Acme.json").string())
-        << R"({"version":"1.0.0","name":"Acme",)"
-        << R"("machine_model_list":[{"name":"Acme One","sub_path":"machine/model.json"}],"machine_list":[)"
-        << R"({"name":"fdm_acme_common","sub_path":"machine/base.json"},)"
-        << R"({"name":"Acme Printer","sub_path":"machine/nested/printer.json"}]})";
-    std::ofstream((machine_dir / "model.json").string())
-        << R"({"type":"machine_model","name":"Acme One","nozzle_diameter":"0.4"})";
-    std::ofstream((machine_dir / "base.json").string())
-        << R"({"type":"machine","name":"fdm_acme_common","from":"system","instantiation":"false",)"
-        << R"("extruder_clearance_dist_to_rod":")" << dist_to_rod << R"("})";
-    std::ofstream((machine_dir / "nested" / "printer.json").string())
-        << R"({"type":"machine","name":"Acme Printer","from":"system","instantiation":"true","inherits":"fdm_acme_common",)"
-        << R"("printer_model":"Acme One","printer_variant":"0.4"})";
-}
-
 std::string read_file(const fs::path &file)
 {
     std::ifstream in(file.string(), std::ios::binary);
@@ -5511,75 +5482,3 @@ TEST_CASE("Config import confines zip entries, preset names and bundle ids to th
         CHECK_FALSE(any_filename_contains(temp_dir.path(), "bundle-escape"));
     }
 }
-
-TEST_CASE("A system preset resolves by name from the bundled profiles", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK(error.empty());
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6));
-}
-
-TEST_CASE("A system preset resolves from the data directory copy of its vendor", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-    write_acme_printer_vendor(temp_dir.path() / "data" / PRESET_SYSTEM_DIR, 35.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(35., 1e-6));
-}
-
-TEST_CASE("A system preset resolves from a vendor shipped as its preset cache alone", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    const fs::path     profiles = temp_dir.path() / "resources" / "profiles";
-    write_acme_printer_vendor(profiles, 33.);
-
-    PresetBundle writer;
-    writer.set_generate_vendor_caches(true);
-    writer.load_vendor_configs_from_json(profiles.string(), "Acme", PresetBundle::LoadSystem,
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent);
-    REQUIRE(fs::exists(profiles / "Acme.opc"));
-    // Release builds ship the cache and drop the profile JSONs, manifest included.
-    fs::remove(profiles / "Acme.json");
-    fs::remove_all(profiles / "Acme");
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    REQUIRE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Acme Printer",
-                                         ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_THAT(config.opt_float("extruder_clearance_dist_to_rod"), Catch::Matchers::WithinAbs(33., 1e-6));
-}
-
-TEST_CASE("A system preset no vendor lists is not resolved", "[Preset][Bundle]")
-{
-    ScopedTemporaryDir temp_dir;
-    ScopedDataDir      data(temp_dir.path() / "data");
-    ScopedResourcesDir resources(temp_dir.path() / "resources");
-    write_acme_printer_vendor(temp_dir.path() / "resources" / "profiles", 33.);
-
-    PresetBundle       bundle;
-    DynamicPrintConfig config;
-    std::string        error;
-    CHECK_FALSE(bundle.resolve_system_preset(config, Preset::TYPE_PRINTER, "Unknown Printer",
-                                             ForwardCompatibilitySubstitutionRule::EnableSilent, error));
-    CHECK_FALSE(error.empty());
-}