Address the review on saving texture displacement

Read each layer's texture from the archive only. `layer.path` comes from the project
file, so following it let any .3mf pick a local file to read, a UNC path among them,
and have the next save copy what it found into the archive. Reverts the disk fallback
added in 8ecfee6a2.

Store a paint mask only for the slots a triangle names. Eight empty strings per
triangle cost every project hundreds of megabytes on a large mesh, whether or not it
uses the feature. A slot's run is padded to the triangles seen so far on its first
value, so it stays indexed by triangle, and ends at its last painted one.

Report a malformed layer block instead of throwing out of the project load. The typed
accessors throw on a value of the wrong type and nothing above them caught that, so
one bad number cost the whole file rather than one volume's relief.

Cover the store and load round trip in test_3mf.cpp: the layer, its image, the options
and the paint, the two regressions above, paint at either end of the triangle list, two
volumes sharing a slot, and the wrong-typed documents at the unit level.

src/libslic3r/Format/bbs_3mf.cpp

@@ -22,6 +22,7 @@
 #include "libslic3r/BrimEarsPoint.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/CustomGCode.hpp"
+#include "libslic3r/TextureDisplacement.hpp"
 #include "libslic3r_version.h"
 
 #include "bbs_3mf.hpp"
@@ -63,6 +64,7 @@
 #include <ostream>
 #include <sstream>
 #include <set>
+#include <iterator>
 #include <memory>
 #include <optional>
 #include <map>
@@ -354,6 +356,13 @@ static constexpr const char* CUSTOM_SUPPORTS_ATTR = "paint_supports";
 static constexpr const char* CUSTOM_FUZZY_SKIN_ATTR  = "paint_fuzzy_skin";
 static constexpr const char* CUSTOM_SEAM_ATTR = "paint_seam";
 static constexpr const char* MMU_SEGMENTATION_ATTR = "paint_color";
+// Texture displacement. One paint mask per layer slot, mirroring paint_color; the layer stack itself is
+// a JSON file in the archive, named by the volume metadata key below (see add_texture_displacement()).
+static constexpr const char* TEXTURE_DISPLACEMENT_ATTRS[Slic3r::TEXTURE_DISPLACEMENT_MAX_LAYERS] = {
+    "paint_texture_0", "paint_texture_1", "paint_texture_2", "paint_texture_3",
+    "paint_texture_4", "paint_texture_5", "paint_texture_6", "paint_texture_7" };
+static constexpr const char* TEXTURE_DISPLACEMENT_KEY = "texture_displacement";
+static constexpr const char* TEXTURE_DISPLACEMENT_DIR = "Metadata/texture_displacement/";
 // BBS
 static constexpr const char* FACE_PROPERTY_ATTR = "face_property";
 
@@ -847,11 +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 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);
@@ -867,6 +895,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 custom_seam.clear();
                 mmu_segmentation.clear();
                 fuzzy_skin.clear();
+                for (std::vector<std::string> &slot : texture_displacement)
+                    slot.clear();
             }
         };
 
@@ -1200,6 +1230,11 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         /*IdToSlaSupportPointsMap m_sla_support_points;
         IdToSlaDrainHolesMap    m_sla_drain_holes;*/
         PathToEmbossShapeFileMap m_path_to_emboss_shape_files;
+        // Texture displacement: every file under Metadata/texture_displacement/, by archive path. Volumes
+        // are built only after the whole archive has been walked, so by the time a volume names its JSON
+        // every file it could refer to is already in here, whatever order the archive happened to be in.
+        std::map<std::string, std::string> m_texture_displacement_files;
+        void _apply_texture_displacement(ModelVolume &volume, const std::string &json_path);
         std::string m_curr_metadata_name;
         std::string m_curr_characters;
         std::string m_name;
@@ -2073,6 +2108,13 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 else if (_is_svg_shape_file(name)) {
                     _extract_embossed_svg_shape_file(name, archive, stat);
                 }
+                else if (boost::algorithm::istarts_with(name, TEXTURE_DISPLACEMENT_DIR)) {
+                    std::string contents(stat.m_uncomp_size, '\0');
+                    if (mz_zip_reader_extract_to_mem(&archive, stat.m_file_index, contents.data(), stat.m_uncomp_size, 0))
+                        m_texture_displacement_files.emplace(name, std::move(contents));
+                    else
+                        add_error("Error while reading texture displacement data");
+                }
                 else if (!dont_load_config && boost::algorithm::iequals(name, SLICE_INFO_CONFIG_FILE)) {
                     m_parsing_slice_info = true;
                     //extract slice info from archive
@@ -3310,6 +3352,48 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         }
     }*/
 
+    // Restores one volume's texture displacement stack from the JSON it named. Called while the volume is
+    // being built, which is after the whole archive has been walked - so every file it can refer to is
+    // already extracted, and no deferral is needed.
+    //
+    // A missing or malformed JSON leaves the volume with no layers but keeps the paint mask it already
+    // loaded, which is the same state as a project saved by a build without the feature: recoverable by
+    // picking the texture again rather than a hard failure.
+    void _BBS_3MF_Importer::_apply_texture_displacement(ModelVolume &volume, const std::string &json_path)
+    {
+        const auto json = m_texture_displacement_files.find(json_path);
+        if (json == m_texture_displacement_files.end()) {
+            add_error("Missing texture displacement data: " + json_path);
+            return;
+        }
+        std::vector<TextureDisplacementLayer> layers;
+        TextureDisplacementOptions            options;
+        if (!texture_displacement_layers_from_json(json->second, layers, options)) {
+            add_error("Malformed texture displacement data: " + json_path);
+            return;
+        }
+        // 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;
+            const auto image = m_texture_displacement_files.find(layer.path_in_3mf);
+            if (image == m_texture_displacement_files.end()) {
+                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());
+        }
+        volume.texture_displacement_layers  = std::move(layers);
+        volume.texture_displacement_options = options;
+    }
+
     void _BBS_3MF_Importer::_extract_embossed_svg_shape_file(const std::string &filename, mz_zip_archive &archive, const mz_zip_archive_file_stat &stat){
         assert(m_path_to_emboss_shape_files.find(filename) == m_path_to_emboss_shape_files.end());
         auto file = std::make_unique<std::string>(stat.m_uncomp_size, '\0');
@@ -3966,6 +4050,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             m_curr_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             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)
+                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));
         }
@@ -5317,6 +5404,18 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                 volume->mmu_segmentation_facets.touch();
                 volume->fuzzy_skin_facets.shrink_to_fit();
                 volume->fuzzy_skin_facets.touch();
+                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; // 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)
+                        if (!mask[i].empty())
+                            facets.set_triangle_from_string(i, mask[i]);
+                    facets.shrink_to_fit();
+                    facets.touch();
+                }
             }
 
             volume->set_type(volume_data->part_type);
@@ -5332,6 +5431,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             for (const Metadata& metadata : volume_data->metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5496,12 +5597,28 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             volume->seam_facets.shrink_to_fit();
             volume->mmu_segmentation_facets.shrink_to_fit();
 
+            for (int slot = 0; slot < int(TEXTURE_DISPLACEMENT_MAX_LAYERS); ++slot) {
+                const std::vector<std::string> &mask = geometry.texture_displacement[slot];
+                if (mask.empty())
+                    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) {
+                    const size_t index = volume_data.first_triangle_id + i;
+                    if (index < mask.size() && !mask[index].empty())
+                        facets.set_triangle_from_string(i, mask[index]);
+                }
+                facets.shrink_to_fit();
+                facets.touch();
+            }
             volume->set_type(volume_data.part_type);
 
             // apply the remaining volume's metadata
             for (const Metadata& metadata : volume_data.metadata) {
                 if (metadata.key == NAME_KEY)
                     volume->name = metadata.value;
+                else if (metadata.key == TEXTURE_DISPLACEMENT_KEY)
+                    _apply_texture_displacement(*volume, metadata.value);
                 //else if ((metadata.key == MODIFIER_KEY) && (metadata.value == "1"))
 				//	volume->set_type(ModelVolumeType::PARAMETER_MODIFIER);
 				//for old format
@@ -5805,6 +5922,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             current_object->geometry.custom_seam.push_back(bbs_get_attribute_value_string(attributes, num_attributes, CUSTOM_SEAM_ATTR));
             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)
+                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));
         }
@@ -6808,6 +6928,9 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         stream << " <Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\n";
         stream << " <Default Extension=\"model\" ContentType=\"application/vnd.ms-package.3dmanufacturing-3dmodel+xml\"/>\n";
         stream << " <Default Extension=\"png\" ContentType=\"image/png\"/>\n";
+        stream << " <Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\n";
+        stream << " <Default Extension=\"json\" ContentType=\"application/json\"/>\n";
         stream << " <Default Extension=\"gcode\" ContentType=\"text/x.gcode\"/>\n";
         stream << "</Types>";
 
@@ -7651,6 +7774,20 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                     output_buffer += "\"";
                 }
 
+                // One attribute per texture displacement layer slot. Older readers ignore attributes they do
+                // not know, so a project written here still opens in a build without the feature - it just
+                // loses the paint, which is also all it could have done with it.
+                for (int slot = 0; slot < TEXTURE_DISPLACEMENT_MAX_LAYERS; ++slot) {
+                    const std::string texture_paint = volume->texture_displacement_facet(slot).get_triangle_as_string(i);
+                    if (texture_paint.empty())
+                        continue;
+                    output_buffer += " ";
+                    output_buffer += TEXTURE_DISPLACEMENT_ATTRS[slot];
+                    output_buffer += "=\"";
+                    output_buffer += texture_paint;
+                    output_buffer += "\"";
+                }
+
                 // BBS
                 if (i < its.properties.size()) {
                     std::string prop_str = its.properties[i].to_string();
@@ -8100,7 +8237,42 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         return file_path;
     }
 
-    bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
+    // Writes a volume's texture displacement stack into the archive and points the volume's metadata at it.
+// The layer settings go in as JSON and each layer's texture as the image file it was loaded from, both
+// referenced by path - the same split EmbossShape makes for its SVG. The image deliberately stays out of
+// the XML: it is binary and routinely megabytes, and base64 in an attribute would bloat the one file
+// every reader has to parse just to list the objects.
+static void add_texture_displacement(std::stringstream &stream, const ModelVolume &volume, mz_zip_archive &archive,
+                                     const std::string &id)
+{
+    if (volume.texture_displacement_layers.empty())
+        return;
+
+    // A copy, because path_in_3mf is only meaningful inside the archive being written and the volume
+    // being exported is const (and may be saved again, elsewhere, with different paths).
+    std::vector<TextureDisplacementLayer> layers = volume.texture_displacement_layers;
+    for (TextureDisplacementLayer &layer : layers) {
+        layer.path_in_3mf.clear();
+        if (!layer.image_data || layer.image_data->empty())
+            continue;
+        // Always .png: the importer converts whatever the user picked (jpg, bmp, ...) to an 8-bit
+        // greyscale PNG, so image_data is PNG whatever layer.path happens to be named.
+        const std::string path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + "_" + std::to_string(layer.slot) + ".png";
+        // No deflate: a PNG is already compressed, so a second pass only costs time.
+        if (mz_zip_writer_add_mem(&archive, path.c_str(), layer.image_data->data(), layer.image_data->size(),
+                                  MZ_NO_COMPRESSION))
+            layer.path_in_3mf = path;
+    }
+
+    const std::string json      = texture_displacement_layers_to_json(layers, volume.texture_displacement_options);
+    const std::string json_path = std::string(TEXTURE_DISPLACEMENT_DIR) + id + ".json";
+    if (!mz_zip_writer_add_mem(&archive, json_path.c_str(), json.data(), json.size(), MZ_DEFAULT_COMPRESSION))
+        return;
+    stream << "      <" << METADATA_TAG << " " << KEY_ATTR << "=\"" << TEXTURE_DISPLACEMENT_KEY << "\" "
+           << VALUE_ATTR << "=\"" << xml_escape(json_path) << "\"/>\n";
+}
+
+bool _BBS_3MF_Exporter::_add_model_config_file_to_archive(mz_zip_archive& archive, const Model& model, PlateDataPtrs& plate_data_list, const ObjectToObjectDataMap &objects_data, const DynamicPrintConfig& config, int export_plate_idx, bool save_gcode, bool use_loaded_id)
     {
         std::stringstream stream;
         // Store mesh transformation in full precision, as the volumes are stored transformed and they need to be transformed back
@@ -8211,6 +8383,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
                             if (const std::optional<EmbossShape> &es = volume->emboss_shape; es.has_value()) {
                                 to_xml(stream, *es, *volume, archive, m_fullpath_sources);
                             }
+
+                            add_texture_displacement(stream, *volume, archive, std::to_string(volume->id().id));
                     
                             if (const std::optional<TextConfiguration> &tc = volume->text_configuration;
                                 tc.has_value())

src/libslic3r/TextureDisplacement.cpp

@@ -19,6 +19,7 @@
 #include <mutex>
 #include <numeric>
 #include <optional>
+#include "nlohmann/json.hpp"
 #include <queue>
 #include <ratio>
 #include <string>
@@ -5166,5 +5167,256 @@ indexed_triangle_set cut_mesh_at_steps(const indexed_triangle_set &mesh, const s
     return out;
 }
 
+// ---------------------------------------------------------------------------------------------
+// Project persistence. See the declarations in TextureDisplacement.hpp for why this is JSON rather
+// than the cereal stream next to them.
+// ---------------------------------------------------------------------------------------------
+namespace {
+
+nlohmann::json vec2_to_json(const Vec2f &v) { return nlohmann::json::array({ v.x(), v.y() }); }
+nlohmann::json vec3_to_json(const Vec3f &v) { return nlohmann::json::array({ v.x(), v.y(), v.z() }); }
+
+Vec2f vec2_from_json(const nlohmann::json &j, const Vec2f &fallback)
+{
+    if (!j.is_array() || j.size() != 2)
+        return fallback;
+    return Vec2f(j[0].get<float>(), j[1].get<float>());
+}
+Vec3f vec3_from_json(const nlohmann::json &j, const Vec3f &fallback)
+{
+    if (!j.is_array() || j.size() != 3)
+        return fallback;
+    return Vec3f(j[0].get<float>(), j[1].get<float>(), j[2].get<float>());
+}
+
+// Reads key `k` into `out` when it is present and of the expected type, leaving `out` alone otherwise.
+// That "leave it alone" is the whole point: every member starts at its struct default, so a project
+// written by an older build simply keeps the defaults for whatever it did not know about.
+template<class T> void read(const nlohmann::json &j, const char *k, T &out)
+{
+    const auto it = j.find(k);
+    if (it == j.end())
+        return;
+    try {
+        out = it->get<T>();
+    } catch (...) {
+    }
+}
+void read_enum(const nlohmann::json &j, const char *k, int &out)
+{
+    const auto it = j.find(k);
+    if (it != j.end() && it->is_number_integer())
+        out = it->get<int>();
+}
+
+} // namespace
+
+std::string texture_displacement_layers_to_json(const std::vector<TextureDisplacementLayer> &layers,
+                                                const TextureDisplacementOptions            &options)
+{
+    nlohmann::json root;
+    root["version"] = 1;
+
+    nlohmann::json &opt = root["options"];
+    opt["displace_border"]    = options.displace_border;
+    opt["smooth_enabled"]     = options.smooth_enabled;
+    opt["smooth_strength"]    = options.smooth_strength;
+    opt["smooth_iterations"]  = options.smooth_iterations;
+    opt["smooth_skip_border"] = options.smooth_skip_border;
+    opt["pipeline_v2"]        = options.pipeline_v2;
+    opt["v2_refine_mm"]       = options.v2_refine_mm;
+    opt["v2_regularize"]      = options.v2_regularize;
+    opt["v2_max_triangles_k"] = options.v2_max_triangles_k;
+    opt["v2_relocate"]        = options.v2_relocate;
+    opt["v2_flip_edges"]      = options.v2_flip_edges;
+    opt["color_mix_enabled"]  = options.color_mix_enabled;
+    opt["color_despeckle"]    = options.color_despeckle;
+    opt["color_mix_count"]    = options.color_mix_count;
+    opt["active_slot"]        = options.active_slot;
+    opt["panel_mode"]         = options.panel_mode;
+
+    nlohmann::json &arr = root["layers"];
+    arr                 = nlohmann::json::array();
+    for (const TextureDisplacementLayer &l : layers) {
+        nlohmann::json j;
+        j["slot"]        = l.slot;
+        j["name"]        = l.name;
+        j["path"]        = l.path;
+        j["path_in_3mf"] = l.path_in_3mf;
+
+        j["depth_mm"]     = l.depth_mm;
+        j["tiling_scale"] = l.tiling_scale;
+        j["rotation_deg"] = l.rotation_deg;
+        j["offset"]       = vec2_to_json(l.offset);
+        j["invert"]       = l.invert;
+        j["midlevel"]     = l.midlevel;
+        j["smoothing"]    = l.smoothing;
+
+        j["edge_smoothing"]        = l.edge_smoothing;
+        j["edge_smoothing_amount"] = l.edge_smoothing_amount;
+        j["auto_connect_islands"]  = l.auto_connect_islands;
+
+        j["tile_enabled"]      = l.tile_enabled;
+        j["tile_method"]       = int(l.tile_method);
+        j["projection_method"] = int(l.projection_method);
+        j["blend_mode"]        = int(l.blend_mode);
+        j["color_enabled"]     = l.color_enabled;
+
+        j["lscm_seam_angle_deg"] = l.lscm_seam_angle_deg;
+        j["island_padding_mm"]   = l.island_padding_mm;
+
+        j["view_project_right"]      = vec3_to_json(l.view_project_right);
+        j["view_project_up"]         = vec3_to_json(l.view_project_up);
+        j["view_project_projective"] = l.view_project_projective;
+        j["view_project_matrix"]     = l.view_project_matrix;
+
+        // Flat pairs rather than nested arrays: shorter, and the reader can simply ignore a trailing
+        // odd element instead of having to validate every sub-array.
+        nlohmann::json &seams = j["lscm_seam_edges"];
+        seams                 = nlohmann::json::array();
+        for (const auto &[a, b] : l.lscm_seam_edges) {
+            seams.push_back(a);
+            seams.push_back(b);
+        }
+
+        nlohmann::json &islands = j["islands"];
+        islands                 = nlohmann::json::array();
+        for (const TextureIsland &island : l.islands)
+            islands.push_back(nlohmann::json::array(
+                { island.offset.x(), island.offset.y(), island.rotation_deg, island.scale }));
+
+        j["island_groups"] = l.island_groups;
+
+        nlohmann::json &overrides = j["lscm_uv_overrides"];
+        overrides                 = nlohmann::json::array();
+        for (const auto &[key, uv] : l.lscm_uv_overrides)
+            overrides.push_back(nlohmann::json::array({ key, uv.x(), uv.y() }));
+
+        arr.push_back(std::move(j));
+    }
+    return root.dump();
+}
+
+bool texture_displacement_layers_from_json(const std::string                     &text,
+                                           std::vector<TextureDisplacementLayer> &layers,
+                                           TextureDisplacementOptions            &options)
+{
+    nlohmann::json root;
+    try {
+        root = nlohmann::json::parse(text);
+    } catch (...) {
+        return false;
+    }
+    if (!root.is_object())
+        return false;
+
+    TextureDisplacementOptions            out_options;
+    std::vector<TextureDisplacementLayer> out_layers;
+    // 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);
+                read(j, "name", l.name);
+                read(j, "path", l.path);
+                read(j, "path_in_3mf", l.path_in_3mf);
+
+                read(j, "depth_mm", l.depth_mm);
+                read(j, "tiling_scale", l.tiling_scale);
+                read(j, "rotation_deg", l.rotation_deg);
+                if (const auto o = j.find("offset"); o != j.end())
+                    l.offset = vec2_from_json(*o, l.offset);
+                read(j, "invert", l.invert);
+                read(j, "midlevel", l.midlevel);
+                read(j, "smoothing", l.smoothing);
+
+                read(j, "edge_smoothing", l.edge_smoothing);
+                read(j, "edge_smoothing_amount", l.edge_smoothing_amount);
+                read(j, "auto_connect_islands", l.auto_connect_islands);
+
+                read(j, "tile_enabled", l.tile_enabled);
+                read(j, "color_enabled", l.color_enabled);
+                int tile_method = int(l.tile_method), projection = int(l.projection_method), blend = int(l.blend_mode);
+                read_enum(j, "tile_method", tile_method);
+                read_enum(j, "projection_method", projection);
+                read_enum(j, "blend_mode", blend);
+                l.tile_method       = TextureTileMethod(tile_method);
+                l.projection_method = TextureProjectionMethod(std::clamp(projection, 0, 4));
+                l.blend_mode        = TextureBlendMode(blend);
+
+                read(j, "lscm_seam_angle_deg", l.lscm_seam_angle_deg);
+                read(j, "island_padding_mm", l.island_padding_mm);
+
+                if (const auto v = j.find("view_project_right"); v != j.end())
+                    l.view_project_right = vec3_from_json(*v, l.view_project_right);
+                if (const auto v = j.find("view_project_up"); v != j.end())
+                    l.view_project_up = vec3_from_json(*v, l.view_project_up);
+                read(j, "view_project_projective", l.view_project_projective);
+                if (const auto v = j.find("view_project_matrix"); v != j.end() && v->is_array() && v->size() == 12)
+                    for (size_t i = 0; i < 12; ++i)
+                        l.view_project_matrix[i] = (*v)[i].get<float>();
+
+                if (const auto v = j.find("lscm_seam_edges"); v != j.end() && v->is_array())
+                    for (size_t i = 0; i + 1 < v->size(); i += 2)
+                        l.lscm_seam_edges.emplace_back((*v)[i].get<int>(), (*v)[i + 1].get<int>());
+
+                if (const auto v = j.find("islands"); v != j.end() && v->is_array())
+                    for (const nlohmann::json &e : *v) {
+                        if (!e.is_array() || e.size() != 4)
+                            continue;
+                        TextureIsland island;
+                        island.offset       = Vec2f(e[0].get<float>(), e[1].get<float>());
+                        island.rotation_deg = e[2].get<float>();
+                        island.scale        = e[3].get<float>();
+                        l.islands.push_back(island);
+                    }
+
+                read(j, "island_groups", l.island_groups);
+
+                if (const auto v = j.find("lscm_uv_overrides"); v != j.end() && v->is_array())
+                    for (const nlohmann::json &e : *v) {
+                        if (!e.is_array() || e.size() != 3)
+                            continue;
+                        l.lscm_uv_overrides.emplace_back(e[0].get<int>(), Vec2f(e[1].get<float>(), e[2].get<float>()));
+                    }
+
+                out_layers.push_back(std::move(l));
+            }
+        }
+    } catch (...) {
+        return false;
+    }
+
+    layers  = std::move(out_layers);
+    options = out_options;
+    return true;
+}
 
 } // namespace Slic3r

src/libslic3r/TextureDisplacement.hpp

@@ -397,14 +397,38 @@ struct TextureDisplacementOptions
     // finer than the mesh leaves behind, without eating features that are genuinely a facet wide.
     int          color_despeckle   = 2;
 
+    // Where the panel was left, rather than anything the bake reads. It lives with the volume because
+    // that is what it describes: reopening a project should put the user back on the layer they were
+    // editing, in the mode they were editing it in, not on slot 0 in Standard.
+    int active_slot = 0;
+    int panel_mode  = 0; // 0 Standard, 1 Pro
+
     template<class Archive> void serialize(Archive &ar)
     {
         ar(displace_border, smooth_enabled, smooth_strength, smooth_iterations, smooth_skip_border,
            pipeline_v2, v2_refine_mm, v2_regularize, v2_max_triangles_k,
-           v2_relocate, color_mix_enabled, color_despeckle, color_mix_count);
+           v2_relocate, v2_flip_edges, color_mix_enabled, color_despeckle, color_mix_count,
+           active_slot, panel_mode);
     }
 };
 
+// Project persistence (see bbs_3mf.cpp). The layer stack and the per-volume options are written to the
+// .3mf as JSON rather than through the cereal save()/load() above: those two are positional and
+// unversioned, which is right for the undo/redo stack they serve (one session, one binary) but would
+// make every future field a project-breaking change. A JSON object tolerates both directions - an
+// unknown key is ignored, a missing one keeps the member's default - so old projects keep loading and
+// new ones degrade gracefully in older builds.
+//
+// The texture image itself is *not* in here. It is a binary blob that belongs in the archive as a file
+// of its own, exactly as EmbossShape stores its SVG; `path_in_3mf` names that file, and the caller is
+// 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 valid JSON.
+bool texture_displacement_layers_from_json(const std::string                      &text,
+                                           std::vector<TextureDisplacementLayer>  &layers,
+                                           TextureDisplacementOptions             &options);
+
 // How much detail a height texture carries: central differences of the grey image, the mean gradient
 // and the share of texels steeper than 30 grey levels, mapped to how many texels one mesh edge may
 // span (1 for a hard-edged image, 4 for a smooth one). Cached per image, like the decode.

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.cpp

@@ -3558,6 +3558,7 @@ const ModelVolume* GLGizmoTextureDisplacement::texture_volume() const
 
 void GLGizmoTextureDisplacement::update_model_object()
 {
+    store_panel_state();
     bool         updated = false;
     ModelObject *mo      = m_c->selection_info()->model_object();
     int          idx     = -1;
@@ -3593,6 +3594,24 @@ void GLGizmoTextureDisplacement::update_from_model_object(bool first_update)
 {
     wxBusyCursor wait;
 
+    // Opening the gizmo puts the panel back where it was left: the layer and the mode come off the
+    // volume, because they are the user's place in this model's stack, and the dock state off the
+    // application config, because it is about their window. Only on open - this also runs on an
+    // undo/redo and on a layer switch, where overriding what the user is doing now would be wrong.
+    if (first_update) {
+        if (const ModelVolume *mv = texture_volume(); mv != nullptr) {
+            const TextureDisplacementOptions &opts = mv->texture_displacement_options;
+            m_panel_mode = std::clamp(opts.panel_mode, 0, 1);
+            // Only if that slot still holds a layer: the stack can have been edited by anything that
+            // does not go through the panel, and a selection pointing at nothing shows an empty panel.
+            const auto &stack = mv->texture_displacement_layers;
+            if (std::any_of(stack.begin(), stack.end(),
+                            [&opts](const TextureDisplacementLayer &l) { return l.slot == opts.active_slot; }))
+                m_active_layer_slot = opts.active_slot;
+        }
+        m_undocked = wxGetApp().app_config->get_bool(UNDOCKED_CONFIG_KEY);
+    }
+
     const ModelObject *mo = m_c->selection_info()->model_object();
     m_triangle_selectors.clear();
     // The base keeps the last mesh a fill tool hovered, and render_painter_gizmo() reads it as a hover that is
@@ -3641,6 +3660,14 @@ void GLGizmoTextureDisplacement::update_from_model_object(bool first_update)
     rebuild_preview();
 }
 
+void GLGizmoTextureDisplacement::store_panel_state()
+{
+    if (ModelVolume *mv = texture_volume(); mv != nullptr) {
+        mv->texture_displacement_options.active_slot = m_active_layer_slot;
+        mv->texture_displacement_options.panel_mode  = m_panel_mode;
+    }
+}
+
 void GLGizmoTextureDisplacement::set_active_layer(int slot)
 {
     if (slot == m_active_layer_slot)
@@ -3649,6 +3676,7 @@ void GLGizmoTextureDisplacement::set_active_layer(int slot)
     // reflect - otherwise they would be silently lost.
     update_model_object();
     m_active_layer_slot = slot;
+    store_panel_state();
     update_from_model_object(false);
     // The on-canvas gizmo (if on) is anchored to whichever layer is active - keep it in sync
     // instead of leaving it pointing at the previous layer's (now stale) paint patch.
@@ -5986,6 +6014,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                                    "not what you wanted and you know why."));
             if (clicked && !on) {
                 m_panel_mode = m;
+                store_panel_state();
                 if (!pro_mode()) {
                     // Leaving the subdivision preview open would strand a wireframe whose controls just
                     // disappeared, so close it as part of the switch.
@@ -6008,6 +6037,7 @@ void GLGizmoTextureDisplacement::on_render_input_window(float x, float y, float
                         _L("Detach this panel so it can be dragged anywhere over the 3D view, or dock it back beside "
                            "the toolbar.")))
             m_undocked = !m_undocked;
+            wxGetApp().app_config->set_bool(UNDOCKED_CONFIG_KEY, m_undocked);
     }
     ImGui::Separator();
 

src/slic3r/GUI/Gizmos/GLGizmoTextureDisplacement.hpp

@@ -262,6 +262,9 @@ private:
     // Standard is active so what Preview shows is always what Bake will do. Returns true if it actually
     // changed something, so the caller can invalidate the preview.
     bool apply_standard_mode_presets(ModelVolume *mv);
+    // Copies the panel's own state (active layer, Standard/Pro) onto the volume, so the project file
+    // can carry it. Cheap and idempotent - called wherever either of the two changes.
+    void store_panel_state();
     // Standard mode's Bake: remesh to an even density, refine where the texture bends, then displace.
     // The order matters and is the whole reason this is one button - a height map can only move
     // existing vertices, so the mesh has to be prepared first, and remeshing after painting would drop
@@ -971,9 +974,12 @@ private:
     PatchUnwrap m_uv_editor_unwrap;
 
     // When set, the panel is a free-floating window the user can drag anywhere (with a title bar to
-    // grab), instead of being pinned to the right of the gizmo toolbar. Persisted across gizmo
-    // open/close within a session, so the choice sticks while working.
+    // grab), instead of being pinned to the right of the gizmo toolbar. Kept in the application
+    // config rather than in the project: it describes the user's window, not the model, so opening
+    // someone else's project must not move their panel.
     bool m_undocked = false;
+    // The config key behind m_undocked.
+    static constexpr const char *UNDOCKED_CONFIG_KEY = "texture_displacement_panel_undocked";
 
     // Smooth scrolling for the panel body (everything between the header and the pinned Bake footer).
     // ImGui jumps a fixed number of lines per wheel notch, which on tall layer cards reads as a hard

tests/libslic3r/test_3mf.cpp

@@ -28,9 +28,12 @@
 #include <miniz.h>
 #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>
@@ -349,6 +352,24 @@ static bool replace_in_3mf_entry(const std::string& path, const std::string& suf
     return replaced;
 }
 
+// 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_project_src");
+    model.set_backup_path(backup_dir.string());
+
+    DynamicPrintConfig cfg;
+    PlateData          plate;
+    plate.plate_index = 0;
+    StoreParams sp;
+    sp.path     = path.c_str();
+    sp.model    = &model;
+    sp.config   = &cfg;
+    sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+    sp.plate_data_list.push_back(&plate);
+    REQUIRE(store_bbs_3mf(sp));
+}
+
 // Stores a one-plate project holding a cube whose first two facets are painted Extruder2 and
 // Extruder3, which the exporter writes as paint_color="8" and paint_color="0C".
 static void store_painted_cube(const std::string& path)
@@ -363,19 +384,7 @@ static void store_painted_cube(const std::string& path)
         selector.set_facet(1, EnforcerBlockerType::Extruder3);
         REQUIRE(volume->mmu_segmentation_facets.set(selector));
     }
-    ScopedTemporaryDir backup_dir("orca_paint_src");
-    model.set_backup_path(backup_dir.string());
-
-    DynamicPrintConfig cfg;
-    PlateData          plate;
-    plate.plate_index = 0;
-    StoreParams sp;
-    sp.path     = path.c_str();
-    sp.model    = &model;
-    sp.config   = &cfg;
-    sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
-    sp.plate_data_list.push_back(&plate);
-    REQUIRE(store_bbs_3mf(sp));
+    store_project(path, model);
 }
 
 // Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
@@ -2080,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]);
+}
+

tests/libslic3r/test_texture_displacement.cpp

@@ -2157,6 +2157,190 @@ TEST_CASE("A second bake beside a first comes out as fine as a single bake", "[T
     CHECK(second <= single * 5 / 4);
 }
 
+// The .3mf stores the layer stack as JSON (see texture_displacement_layers_to_json). Two properties
+// matter: everything the UV editor and the panel can set has to survive a round trip, and a document
+// written by a build that knew fewer fields has to keep loading, with the missing ones left at their
+// defaults rather than zeroed.
+TEST_CASE("Texture displacement layers survive a JSON round trip", "[TextureDisplacement]")
+{
+    std::vector<TextureDisplacementLayer> layers(2);
+    TextureDisplacementLayer             &a = layers[0];
+    a.slot                 = 0;
+    a.name                 = "Bark";
+    a.path                 = "/textures/bark.png";
+    a.depth_mm             = 1.25f;
+    a.tiling_scale         = 7.5f;
+    a.rotation_deg         = 30.f;
+    a.offset               = Vec2f(0.25f, -0.5f);
+    a.invert               = true;
+    a.midlevel             = 0.125f;
+    a.smoothing            = 0.75f;
+    a.edge_smoothing       = true;
+    a.edge_smoothing_amount = 0.25f;
+    a.auto_connect_islands = false;
+    a.tile_enabled         = false;
+    a.tile_method          = TextureTileMethod::MirroredRepeat;
+    a.projection_method    = TextureProjectionMethod::LSCM;
+    a.blend_mode           = TextureBlendMode::Subtract;
+    a.color_enabled        = true;
+    a.lscm_seam_angle_deg  = 45.f;
+    a.island_padding_mm    = 0.5f;
+    a.lscm_seam_edges      = { { 1, 2 }, { 3, 5 } };
+    a.islands              = { TextureIsland{ Vec2f(1.f, 2.f), 15.f, 1.5f }, TextureIsland{} };
+    a.island_groups        = { 0, 0 };
+    a.lscm_uv_overrides    = { { -4, Vec2f(0.5f, 0.75f) } };
+
+    TextureDisplacementLayer &b = layers[1];
+    b.slot                    = 1;
+    b.projection_method       = TextureProjectionMethod::ViewProjected;
+    b.view_project_right      = Vec3f(0.f, 1.f, 0.f);
+    b.view_project_up         = Vec3f(0.f, 0.f, 1.f);
+    b.view_project_projective = true;
+    for (size_t i = 0; i < b.view_project_matrix.size(); ++i)
+        b.view_project_matrix[i] = float(i) + 0.5f;
+
+    TextureDisplacementOptions options;
+    options.displace_border   = false;
+    options.smooth_enabled    = true;
+    options.smooth_strength   = 0.6f;
+    options.smooth_iterations = 5;
+    options.pipeline_v2       = false;
+    options.v2_max_triangles_k = 250;
+    options.color_mix_count   = 3;
+    options.color_despeckle   = 4;
+    options.active_slot       = 3;
+    options.panel_mode        = 1;
+
+    const std::string json = texture_displacement_layers_to_json(layers, options);
+
+    std::vector<TextureDisplacementLayer> read_layers;
+    TextureDisplacementOptions            read_options;
+    REQUIRE(texture_displacement_layers_from_json(json, read_layers, read_options));
+    REQUIRE(read_layers.size() == layers.size());
+
+    const TextureDisplacementLayer &ra = read_layers[0];
+    CHECK(ra.name == a.name);
+    CHECK(ra.path == a.path);
+    CHECK_THAT(ra.depth_mm, WithinAbs(a.depth_mm, 1e-6f));
+    CHECK_THAT(ra.tiling_scale, WithinAbs(a.tiling_scale, 1e-6f));
+    CHECK_THAT(ra.rotation_deg, WithinAbs(a.rotation_deg, 1e-6f));
+    CHECK(ra.offset.isApprox(a.offset));
+    CHECK(ra.invert == a.invert);
+    CHECK_THAT(ra.midlevel, WithinAbs(a.midlevel, 1e-6f));
+    CHECK_THAT(ra.smoothing, WithinAbs(a.smoothing, 1e-6f));
+    CHECK(ra.edge_smoothing == a.edge_smoothing);
+    CHECK_THAT(ra.edge_smoothing_amount, WithinAbs(a.edge_smoothing_amount, 1e-6f));
+    CHECK(ra.auto_connect_islands == a.auto_connect_islands);
+    CHECK(ra.tile_enabled == a.tile_enabled);
+    CHECK(ra.tile_method == a.tile_method);
+    CHECK(ra.projection_method == a.projection_method);
+    CHECK(ra.blend_mode == a.blend_mode);
+    CHECK(ra.color_enabled == a.color_enabled);
+    CHECK_THAT(ra.lscm_seam_angle_deg, WithinAbs(a.lscm_seam_angle_deg, 1e-6f));
+    CHECK_THAT(ra.island_padding_mm, WithinAbs(a.island_padding_mm, 1e-6f));
+    CHECK(ra.lscm_seam_edges == a.lscm_seam_edges);
+    REQUIRE(ra.islands.size() == a.islands.size());
+    CHECK(ra.islands[0].offset.isApprox(a.islands[0].offset));
+    CHECK_THAT(ra.islands[0].rotation_deg, WithinAbs(a.islands[0].rotation_deg, 1e-6f));
+    CHECK_THAT(ra.islands[0].scale, WithinAbs(a.islands[0].scale, 1e-6f));
+    CHECK(ra.island_groups == a.island_groups);
+    REQUIRE(ra.lscm_uv_overrides.size() == 1);
+    CHECK(ra.lscm_uv_overrides[0].first == -4);
+    CHECK(ra.lscm_uv_overrides[0].second.isApprox(Vec2f(0.5f, 0.75f)));
+
+    const TextureDisplacementLayer &rb = read_layers[1];
+    CHECK(rb.projection_method == TextureProjectionMethod::ViewProjected);
+    CHECK(rb.view_project_right.isApprox(b.view_project_right));
+    CHECK(rb.view_project_up.isApprox(b.view_project_up));
+    CHECK(rb.view_project_projective);
+    CHECK(rb.view_project_matrix == b.view_project_matrix);
+
+    CHECK(read_options.displace_border == options.displace_border);
+    CHECK(read_options.smooth_enabled == options.smooth_enabled);
+    CHECK_THAT(read_options.smooth_strength, WithinAbs(options.smooth_strength, 1e-6f));
+    CHECK(read_options.smooth_iterations == options.smooth_iterations);
+    CHECK(read_options.pipeline_v2 == options.pipeline_v2);
+    CHECK(read_options.v2_max_triangles_k == options.v2_max_triangles_k);
+    CHECK(read_options.color_mix_count == options.color_mix_count);
+    CHECK(read_options.color_despeckle == options.color_despeckle);
+    // Where the panel was left comes back with the rest, so a reopened project is on the same layer.
+    CHECK(read_options.active_slot == options.active_slot);
+    CHECK(read_options.panel_mode == options.panel_mode);
+}
+
+TEST_CASE("Texture displacement JSON keeps defaults for keys it does not carry", "[TextureDisplacement]")
+{
+    // What a build that knew fewer fields would have written: one layer, almost nothing set.
+    const std::string sparse = R"({"version":1,"layers":[{"slot":2,"name":"Old","depth_mm":0.75}]})";
+
+    std::vector<TextureDisplacementLayer> layers;
+    TextureDisplacementOptions            options;
+    REQUIRE(texture_displacement_layers_from_json(sparse, layers, options));
+    REQUIRE(layers.size() == 1);
+
+    const TextureDisplacementLayer  &l = layers[0];
+    const TextureDisplacementLayer   fresh;
+    const TextureDisplacementOptions defaults;
+    CHECK(l.slot == 2);
+    CHECK(l.name == "Old");
+    CHECK_THAT(l.depth_mm, WithinAbs(0.75f, 1e-6f));
+    // Everything absent keeps the struct's own default rather than becoming zero.
+    CHECK_THAT(l.tiling_scale, WithinAbs(fresh.tiling_scale, 1e-6f));
+    CHECK(l.auto_connect_islands == fresh.auto_connect_islands);
+    CHECK(l.tile_enabled == fresh.tile_enabled);
+    CHECK(l.projection_method == fresh.projection_method);
+    CHECK_THAT(l.lscm_seam_angle_deg, WithinAbs(fresh.lscm_seam_angle_deg, 1e-6f));
+    CHECK(options.color_mix_count == defaults.color_mix_count);
+    CHECK(options.pipeline_v2 == defaults.pipeline_v2);
+    CHECK(options.active_slot == defaults.active_slot);
+    CHECK(options.panel_mode == defaults.panel_mode);
+
+    std::vector<TextureDisplacementLayer> unused_layers;
+    TextureDisplacementOptions            unused_options;
+    CHECK(!texture_displacement_layers_from_json("not json at all", unused_layers, unused_options));
+}
+
+// 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 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;
+    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);
+
+    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]")
 {
     TextureDisplacementLayer gray;