mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-04 22:31:02 +00:00
HanifKoh
a80c323614
Release builds install each vendor as its preset cache alone. The read-only preset load the CLI uses to resolve an inheriting user preset passed allow_cache = false to keep caches from being written, which also stopped them from being read, so every vendor fell back to JSONs that are not installed and the CLI failed. The flag now only gates writing: a read-only load reads caches and writes none. The filament library is also read from its cache whenever that is all that is installed, so a vendor updated over the air still resolves against it.
894 lines
48 KiB
C++
894 lines
48 KiB
C++
#ifndef slic3r_PresetBundle_hpp_
|
|
#define slic3r_PresetBundle_hpp_
|
|
|
|
#include "Config.hpp"
|
|
#include "Preset.hpp"
|
|
#include "PresetCacheFormat.hpp"
|
|
#include "AppConfig.hpp"
|
|
#include "PrintConfig.hpp"
|
|
#include "PublishSettings.hpp"
|
|
#include "Semver.hpp"
|
|
#include "enum_bitmask.hpp"
|
|
|
|
#include <climits>
|
|
#include <functional>
|
|
#include <cstddef>
|
|
#include <memory>
|
|
#include <map>
|
|
#include <set>
|
|
#include <shared_mutex>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <unordered_map>
|
|
#include <optional>
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <boost/filesystem/path.hpp>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
#include <utility>
|
|
|
|
#define DEFAULT_USER_FOLDER_NAME "default"
|
|
#define BUNDLE_STRUCTURE_JSON_NAME "bundle_structure.json"
|
|
|
|
#define VALIDATE_PRESETS_SUCCESS 0
|
|
#define VALIDATE_PRESETS_PRINTER_NOT_FOUND 1
|
|
#define VALIDATE_PRESETS_FILAMENTS_NOT_FOUND 2
|
|
#define VALIDATE_PRESETS_MODIFIED_GCODES 3
|
|
|
|
|
|
// define an enum class of vendor type
|
|
enum class VendorType {
|
|
Unknown = 0,
|
|
Klipper,
|
|
Marlin,
|
|
Marlin_BBL,
|
|
Klipper_Qidi
|
|
};
|
|
namespace Slic3r {
|
|
|
|
struct AMSMapInfo
|
|
{
|
|
/*for new ams mapping*/ // from struct FilamentInfo
|
|
std::string ams_id{""};
|
|
std::string slot_id{""};
|
|
};
|
|
struct AMSComboInfo
|
|
{
|
|
std::vector<std::string> ams_filament_colors;
|
|
std::vector<std::vector<std::string>> ams_multi_color_filment;
|
|
std::vector<std::string> ams_filament_presets;
|
|
std::vector<std::string> ams_names;
|
|
void clear() {
|
|
ams_filament_colors.clear();
|
|
ams_multi_color_filment.clear();
|
|
ams_filament_presets.clear();
|
|
ams_names.clear();
|
|
}
|
|
bool empty() {
|
|
return ams_names.empty();
|
|
}
|
|
};
|
|
struct MergeFilamentInfo {
|
|
std::vector<std::vector<int>> merges;
|
|
bool is_empty() { return merges.empty();}
|
|
};
|
|
|
|
|
|
struct FilamentBaseInfo
|
|
{
|
|
std::string filament_name;
|
|
std::string filament_id;
|
|
std::string filament_type;
|
|
std::string vendor;
|
|
int nozzle_temp_range_low{ 220 };
|
|
int nozzle_temp_range_high{ 220 };
|
|
int temperature_vitrification = INT_MAX;
|
|
bool is_support{ false };
|
|
bool is_system{ true };
|
|
int filament_printable = 3;
|
|
|
|
// filament_extruder_compatibility packs one compatibility level per extruder into a single
|
|
// 32-bit int, 3 bits per extruder (up to 10 extruders). Levels: 0 = printable, 1 = error,
|
|
// 2 = critical warning, 3 = warning (4-7 reserved). extruder_id is 0-based.
|
|
int get_extruder_compatibility(int extruder_id) const {
|
|
constexpr int bits_per_extruder = 3;
|
|
constexpr int extruder_mask = (1 << bits_per_extruder) - 1; // 0x7
|
|
constexpr int max_extruder_count = 32 / bits_per_extruder; // 10
|
|
|
|
if (extruder_id < 0 || extruder_id >= max_extruder_count)
|
|
return 0;
|
|
return (m_filament_extruder_compatibility >> (bits_per_extruder * extruder_id)) & extruder_mask;
|
|
}
|
|
|
|
void set_filament_extruder_compatibility(int value) { m_filament_extruder_compatibility = value; }
|
|
int get_filament_extruder_compatibility() const { return m_filament_extruder_compatibility; }
|
|
|
|
private:
|
|
int m_filament_extruder_compatibility = 0;
|
|
};
|
|
|
|
enum BundleType{
|
|
Default = 0,
|
|
Local,
|
|
Subscribed,
|
|
};
|
|
|
|
// Orca: Bundle metadata structure for imported preset bundles
|
|
struct BundleMetadata
|
|
{
|
|
std::string id; // Bundle ID: UUID (OrcaCloud) or name+timestamp (external)
|
|
std::string name; // Display name
|
|
std::string version; // Bundle version
|
|
std::string description;
|
|
std::string author;
|
|
long long imported_time{0};
|
|
long long updated_time{0};
|
|
|
|
BundleType bundle_type{Default};
|
|
std::string path;
|
|
|
|
// Cached preset names by type (populated on load)
|
|
std::vector<std::string> print_presets;
|
|
std::vector<std::string> filament_presets;
|
|
std::vector<std::string> printer_presets;
|
|
|
|
// Runtime-only flags
|
|
bool is_subscribed{false};
|
|
bool update_available{false};
|
|
bool not_found{false};
|
|
bool unauthorized{false};
|
|
|
|
bool load_from_json(const std::string& path);
|
|
bool save_to_json(const std::string& path) const;
|
|
};
|
|
|
|
struct PresetBundleMetadata
|
|
{
|
|
// To make sure write locks take precedent, pausereads needs to be true for when Orca needs to read or manipulate the container
|
|
// We only need to explicitly pause reads when entering a region in Orca which we deem necessary to quickly acquire write locks.
|
|
std::unordered_map<std::string, BundleMetadata> m_bundles;
|
|
std::shared_mutex RWMtx;
|
|
std::atomic<bool> pauseReads{false};
|
|
|
|
void PauseRead()
|
|
{
|
|
pauseReads.store(true);
|
|
}
|
|
|
|
void UnpauseRead()
|
|
{
|
|
pauseReads.store(false);
|
|
}
|
|
|
|
void ReadLock()
|
|
{
|
|
RWMtx.lock_shared();
|
|
}
|
|
void ReadUnlock()
|
|
{
|
|
RWMtx.unlock_shared();
|
|
}
|
|
|
|
void WriteLock()
|
|
{
|
|
RWMtx.lock();
|
|
}
|
|
|
|
void WriteUnlock()
|
|
{
|
|
RWMtx.unlock();
|
|
}
|
|
};
|
|
|
|
// A "published" 3MF project: keeps the user's currently-selected presets and overlays only the
|
|
// author-selected published keys onto the edited presets.
|
|
struct PublishedConfig
|
|
{
|
|
bool published = false;
|
|
std::vector<std::string> published_keys;
|
|
// Per-slot published material keys, applied positionally (author slot N -> receiver slot N).
|
|
// Partial entries are gated by the author's optional type requirement and written onto the
|
|
// slot's stored preset in place; full entries instead detach (see PublishedMaterialEntry in
|
|
// PublishSettings.hpp).
|
|
std::vector<PublishedMaterialEntry> material_keys;
|
|
// Keys that could not be applied (missing on the user's machine or vector size mismatch),
|
|
// filled in by load_config_file_config for notification purposes.
|
|
std::vector<std::string> skipped_keys;
|
|
// Human-readable notices of the slot material replacements performed while loading a
|
|
// published project, for the load notification.
|
|
std::vector<std::string> material_replacements;
|
|
// Mixed-filament entries that had to be moved off their authored slot on load (a real,
|
|
// physical filament occupied it): maps the author's zero-based slot number to its final
|
|
// zero-based slot. Consumers (e.g. model extruder/color-painting remapping) use this to
|
|
// keep geometry references pointing at the relocated definitions.
|
|
std::map<int, int> mixed_slot_relocations;
|
|
};
|
|
|
|
// Bundle of Print + Filament + Printer presets.
|
|
class PresetBundle
|
|
{
|
|
public:
|
|
// ---- Per-vendor preset cache --------------------------------------------
|
|
// One cache file per vendor (plus the Orca filament library), stamped with
|
|
// the vendor's own profile version rather than a directory scan. The bytes
|
|
// on disk are VendorCacheFile's business (PresetCacheFormat.hpp); what
|
|
// lives here is how a cache's contents install into a bundle.
|
|
|
|
// The cache is not something a caller loads from: a vendor is loaded with
|
|
// load_vendor_configs_from_json, which comes from the cache whenever one covers
|
|
// it. What is public here is what the cache's own tests drive directly.
|
|
|
|
// Load a per-vendor cache into this bundle by installing its entries, with
|
|
// base_bundle's filament library as the inheritance base. Rejects (returns
|
|
// false, with this bundle left clean) unless VendorCacheFile::load accepts
|
|
// the file — see its contract for the version and identity checks — and
|
|
// every entry installs. Options this build no longer defines are dropped,
|
|
// not fatal — the payload names its own keys.
|
|
bool load_vendor_cache(const std::string& cache_path, const std::string& expected_vendor_name,
|
|
const Semver& expected_vendor_version, const PresetBundle* base_bundle = nullptr);
|
|
|
|
// Enable writing a per-vendor cache after a JSON parse (off by default). Cache
|
|
// content is pure parse output, so the guard is policy, not correctness: only
|
|
// the deliberate generators (load_system_presets_from_json, the cache build
|
|
// tool) write files, not every incidental load a dialog performs.
|
|
void set_generate_vendor_caches(bool enable) { m_generate_vendor_caches = enable; }
|
|
|
|
static DynamicPrintConfig construct_full_config(Preset &in_printer_preset,
|
|
Preset &in_print_preset,
|
|
const DynamicPrintConfig &project_config,
|
|
std::vector<Preset> &in_filament_presets,
|
|
bool apply_extruder,
|
|
std::optional<std::vector<int>> filament_maps_new,
|
|
std::optional<std::vector<int>> filament_volume_maps_new = std::nullopt);
|
|
|
|
// ORCA: utility function to find the vendor for a given preset name
|
|
static std::string find_preset_vendor(const std::string& preset_name, Preset::Type type);
|
|
// Keys a project keeps when its presets are loaded: those listed in its escaped
|
|
// "different_settings_to_system" entry for the preset, plus the preset bookkeeping keys.
|
|
static std::set<std::string> project_different_keys(const std::string &different_settings);
|
|
// A project filament saved under a name the current presets split per nozzle (e.g. H2D 0.6) is loaded from
|
|
// the preset that now holds its values.
|
|
static void convert_filament_preset_name(const std::string& machine_name, std::string& filament_name);
|
|
|
|
PresetBundle();
|
|
PresetBundle(const PresetBundle &rhs);
|
|
PresetBundle& operator=(const PresetBundle &rhs);
|
|
|
|
// Remove all the presets but the "-- default --".
|
|
// Optionally remove all the files referenced by the presets from the user profile directory.
|
|
void reset(bool delete_files);
|
|
|
|
void setup_directories();
|
|
void copy_files(const std::string& from);
|
|
|
|
struct PresetPreferences {
|
|
std::string printer_model_id;// name of a preferred printer model
|
|
std::string printer_variant; // name of a preferred printer variant
|
|
std::string filament; // name of a preferred filament preset
|
|
std::string sla_material; // name of a preferred sla_material preset
|
|
};
|
|
|
|
// Load ini files of all types (print, filament, printer) from Slic3r::data_dir() / presets.
|
|
// Load selections (current print, current filaments, current printer) from config.ini
|
|
// select preferred presets, if any exist
|
|
PresetsConfigSubstitutions load_presets(AppConfig &config, ForwardCompatibilitySubstitutionRule rule,
|
|
const PresetPreferences& preferred_selection = PresetPreferences(),
|
|
std::string *errors = nullptr, bool read_only = false);
|
|
|
|
// Resolve an explicitly named source file through a canonical flattened
|
|
// preset. Exact loaded-file identity is preferred; otherwise a manifest-
|
|
// backed vendor tree is loaded from that source root without using caches.
|
|
bool resolve_preset_config(DynamicPrintConfig &config, Preset::Type type,
|
|
const std::string &source_file,
|
|
ForwardCompatibilitySubstitutionRule compatibility_rule,
|
|
std::string &error, bool allow_source_manifest = true);
|
|
// Resolve a source file whose JSON omits `type`. Succeeds only when exactly
|
|
// one FFF preset collection owns the file and returns that collection's type.
|
|
bool resolve_preset_config_type(DynamicPrintConfig &config, Preset::Type &type,
|
|
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.
|
|
//BBS: change it to public
|
|
void load_selections(AppConfig &config, const PresetPreferences& preferred_selection = PresetPreferences());
|
|
|
|
// BBS Load user presets
|
|
PresetsConfigSubstitutions load_user_presets(std::string user, ForwardCompatibilitySubstitutionRule rule, bool read_only = false);
|
|
PresetsConfigSubstitutions load_user_presets(AppConfig &config, std::map<std::string, std::map<std::string, std::string>>& my_presets, ForwardCompatibilitySubstitutionRule rule);
|
|
// Orca: Import subscribed bundle presets (load and save to disk in one operation), handles one bundle at a time
|
|
PresetsConfigSubstitutions update_subscribed_presets(AppConfig& config,
|
|
const std::map<std::string, std::map<std::string, std::string>>& bundle_presets,
|
|
const BundleMetadata& remote_metadata,
|
|
ForwardCompatibilitySubstitutionRule rule);
|
|
|
|
PresetsConfigSubstitutions import_presets(std::vector<std::string>& files,
|
|
std::function<int(std::string const&)> override_confirm,
|
|
ForwardCompatibilitySubstitutionRule rule,
|
|
AppConfig& config);
|
|
|
|
bool import_json_presets(PresetsConfigSubstitutions& substitutions,
|
|
std::string& file,
|
|
std::function<int(std::string const&)> override_confirm,
|
|
ForwardCompatibilitySubstitutionRule rule,
|
|
int& overwrite,
|
|
std::vector<std::string>& result,
|
|
const std::string& bundle_dir = "");
|
|
|
|
void save_user_presets(AppConfig& config, std::map<std::string, std::string>& need_to_delete_list);
|
|
void check_and_fix_user_presets_syncinfo(const std::string& user_id);
|
|
void remove_users_preset(AppConfig &config, std::map<std::string, std::map<std::string, std::string>> * my_presets = nullptr);
|
|
void update_user_presets_directory(const std::string preset_folder);
|
|
void remove_user_presets_directory(const std::string preset_folder);
|
|
void update_system_preset_setting_ids(std::map<std::string, std::map<std::string, std::string>>& system_presets);
|
|
|
|
// Apply vendor configuration changes (Core library version, no GUI dependencies)
|
|
// This function installs vendors from resources and loads them into the preset bundle
|
|
//
|
|
// Parameters:
|
|
// new_vendors: Map of vendor names to their enabled printer models and variants
|
|
// new_filaments: Map of filament names to their settings
|
|
// app_config: Pointer to AppConfig to update with new vendor/filament selections
|
|
// preferred_printer_model: Optional preferred printer model to select
|
|
// preferred_printer_variant: Optional preferred printer variant to select
|
|
// preferred_filament: Optional preferred filament to select
|
|
//
|
|
// Returns: true if successful, false otherwise
|
|
bool apply_vendor_config(
|
|
const std::map<std::string, std::map<std::string, std::set<std::string>>>& new_vendors,
|
|
const std::map<std::string, std::string>& new_filaments,
|
|
AppConfig* app_config,
|
|
bool overwrite = true,
|
|
const std::string& preferred_printer_model = std::string(),
|
|
const std::string& preferred_printer_variant = std::string(),
|
|
const std::string& preferred_filament = std::string());
|
|
|
|
//BBS: add API to get previous machine
|
|
int validate_presets(const std::string &file_name, DynamicPrintConfig& config, std::set<std::string>& different_gcodes);
|
|
|
|
//BBS: add function to generate differed preset for save
|
|
//the pointer should be freed by the caller
|
|
Preset* get_preset_differed_for_save(Preset& preset);
|
|
int get_differed_values_to_update(Preset& preset, std::map<std::string, std::string>& key_values);
|
|
|
|
|
|
//BBS: get vendor's current version
|
|
Semver get_vendor_profile_version(std::string vendor_name);
|
|
|
|
std::optional<FilamentBaseInfo> get_filament_by_filament_id(const std::string& filament_id, const std::string& printer_name = std::string()) const;
|
|
|
|
// Orca: get vendor type
|
|
VendorType get_current_vendor_type();
|
|
// Vendor related handy functions
|
|
bool is_bbl_vendor() { return get_current_vendor_type() == VendorType::Marlin_BBL; }
|
|
|
|
// Whether using bbl network for print upload
|
|
bool use_bbl_network();
|
|
// Whether using bbl's device tab
|
|
bool use_bbl_device_tab();
|
|
|
|
bool backup_user_folder() const;
|
|
|
|
//BBS: project embedded preset logic
|
|
PresetsConfigSubstitutions load_project_embedded_presets(std::vector<Preset*> project_presets, ForwardCompatibilitySubstitutionRule substitution_rule);
|
|
std::vector<Preset*> get_current_project_embedded_presets();
|
|
void reset_project_embedded_presets();
|
|
|
|
//BBS: find printer model
|
|
std::string get_texture_for_printer_model(std::string model_name);
|
|
std::string get_stl_model_for_printer_model(std::string model_name);
|
|
std::string get_hotend_model_for_printer_model(std::string model_name);
|
|
|
|
// Export selections (current print, current filaments, current printer) into config.ini
|
|
void export_selections(AppConfig &config);
|
|
|
|
// n is the total slot count, and growth appends at the raw tail - which is where the mixed
|
|
// slots live. A caller adding physical filaments has to add num_mixed_filaments() on top and
|
|
// then move the new slots ahead of the mixed tail, as Sidebar::add_custom_filament does.
|
|
void set_num_filaments(unsigned int n, std::string new_col = "");
|
|
void update_num_filaments(unsigned int to_del_flament_id);
|
|
|
|
void get_ams_cobox_infos(AMSComboInfo &combox_info);
|
|
unsigned int sync_ams_list(std::vector<std::pair<DynamicPrintConfig *,std::string>> &unknowns, bool use_map, std::map<int, AMSMapInfo> &maps, bool enable_append, MergeFilamentInfo &merge_info, bool color_only = false);
|
|
//BBS: check whether this is the only edited filament
|
|
bool is_the_only_edited_filament(unsigned int filament_index);
|
|
|
|
void reset_default_nozzle_volume_type();
|
|
|
|
std::vector<int> get_used_tpu_filaments(const std::vector<int> &used_filaments);
|
|
// Orca: update selected filament and print
|
|
void update_selections(AppConfig &config);
|
|
void set_calibrate_printer(std::string name);
|
|
|
|
void set_is_validation_mode(bool mode) { validation_mode = mode; }
|
|
void set_vendor_to_validate(std::string vendor) { vendor_to_validate = vendor; }
|
|
|
|
std::vector<std::vector<DynamicPrintConfig>> get_extruder_filament_info() const;
|
|
|
|
std::set<std::string> get_printer_names_by_printer_type_and_nozzle(const std::string &printer_type, std::string nozzle_diameter_str, bool system_only = true);
|
|
// Orca: the root filament presets a connected machine can use, resolved with the rule the rest
|
|
// of the app applies (is_compatible_with_printer): an empty compatible_printers means every
|
|
// printer, minus the alias shadowing exclusions the Orca Filament Library records in
|
|
// Preset::m_excluded_from.
|
|
std::vector<Preset *> get_filament_presets_for_machine(const std::string &printer_type,
|
|
const std::string &nozzle_diameter_str,
|
|
bool include_user_presets);
|
|
// Orca: the variant index of a filament preset's per-variant options on extruder extruder_id of a printer
|
|
// preset, with the nozzle volume type the machine reports; 0 when the filament has no such variant.
|
|
static int get_filament_variant_index(const DynamicPrintConfig &filament_config,
|
|
const DynamicPrintConfig &printer_config,
|
|
int extruder_id,
|
|
NozzleVolumeType nozzle_volume_type);
|
|
// extruder_id and nozzle_volume_type identify the tray's nozzle, whose variant the temperature range is compared for.
|
|
bool check_filament_temp_equation_by_printer_type_and_nozzle_for_mas_tray(const std::string &printer_type,
|
|
std::string & nozzle_diameter_str,
|
|
std::string & setting_id,
|
|
std::string & tag_uid,
|
|
std::string & nozzle_temp_min,
|
|
std::string & nozzle_temp_max,
|
|
std::string & preset_setting_id,
|
|
int extruder_id,
|
|
NozzleVolumeType nozzle_volume_type);
|
|
Preset * get_similar_printer_preset(std::string printer_model, std::string printer_variant);
|
|
|
|
PresetCollection prints;
|
|
PresetCollection sla_prints;
|
|
PresetCollection filaments;
|
|
PresetCollection sla_materials;
|
|
PresetCollection& materials(PrinterTechnology pt) { return pt == ptFFF ? this->filaments : this->sla_materials; }
|
|
const PresetCollection& materials(PrinterTechnology pt) const { return pt == ptFFF ? this->filaments : this->sla_materials; }
|
|
PrinterPresetCollection printers;
|
|
PhysicalPrinterCollection physical_printers;
|
|
// Filament preset names for a multi-extruder or multi-material print.
|
|
// extruders.size() should be the same as printers.get_edited_preset().config.nozzle_diameter.size()
|
|
std::vector<std::string> filament_presets;
|
|
// BBS: ams
|
|
std::map<int, DynamicPrintConfig> filament_ams_list;
|
|
std::vector<std::vector<std::string>> ams_multi_color_filment;
|
|
|
|
std::vector<std::map<int, int>> extruder_ams_counts;
|
|
|
|
// Calibrate
|
|
Preset const * calibrate_printer = nullptr;
|
|
std::set<Preset const *> calibrate_filaments;
|
|
|
|
// The project configuration values are kept separated from the print/filament/printer preset,
|
|
// they are being serialized / deserialized from / to the .amf, .3mf, .config, .gcode,
|
|
// and they are being used by slicing core.
|
|
DynamicPrintConfig project_config;
|
|
|
|
// There will be an entry for each system profile loaded,
|
|
// and the system profiles will point to the VendorProfile instances owned by PresetBundle::vendors.
|
|
VendorMap vendors;
|
|
|
|
// Orca: for OrcaFilamentLibrary
|
|
std::map<std::string, DynamicPrintConfig> m_config_maps;
|
|
std::map<std::string, std::string> m_filament_id_maps;
|
|
|
|
// Orca: Bundle metadata and cached preset names
|
|
// std::map<std::string, BundleMetadata> m_bundles;
|
|
fs::path dir_user_presets_local;
|
|
fs::path dir_user_presets_subscribed;
|
|
PresetBundleMetadata bundles;
|
|
|
|
struct ObsoletePresets
|
|
{
|
|
std::vector<std::string> prints;
|
|
std::vector<std::string> sla_prints;
|
|
std::vector<std::string> filaments;
|
|
std::vector<std::string> sla_materials;
|
|
std::vector<std::string> printers;
|
|
};
|
|
ObsoletePresets obsolete_presets;
|
|
|
|
bool has_defauls_only() const
|
|
{ return prints.has_defaults_only() && filaments.has_defaults_only() && printers.has_defaults_only(); }
|
|
|
|
DynamicPrintConfig full_config(bool apply_extruder = true, std::optional<std::vector<int>>filament_maps = std::nullopt, std::optional<std::vector<int>> filament_volume_maps = std::nullopt) const;
|
|
// full_config() with the some "useless" config removed.
|
|
DynamicPrintConfig full_config_secure(std::optional<std::vector<int>>filament_maps = std::nullopt) const;
|
|
|
|
// Default per-filament nozzle-volume types: each filament inherits the volume type of the
|
|
// extruder it maps to (1-based f_maps), Standard when unknown.
|
|
std::vector<int> get_default_nozzle_volume_types_for_filaments(std::vector<int>& f_maps);
|
|
|
|
// Per-extruder flush matrix [extruder_id][from_filament][to_filament] in mm^3, optionally scaled
|
|
// by the per-extruder flush_multiplier (or flush_multiplier_fast when prime_volume_mode==Fast).
|
|
// Used by the print-dispatch nozzle-mapping flush-weight estimate.
|
|
std::vector<std::vector<std::vector<float>>> get_full_flush_matrix(bool with_multiplier = true) const;
|
|
|
|
//BBS: add some functions for multiple extruders
|
|
int get_printer_extruder_count() const;
|
|
bool support_different_extruders() const;
|
|
|
|
// Orca: Ensure filament_presets has at least one slot per nozzle on FFF printers.
|
|
// Called from (load|update)_selections before the parallel project_config arrays
|
|
// (filament_colour/colour_type/map) are sized off filament_presets.size(), so a
|
|
// short saved filament list doesn't truncate the loaded colors.
|
|
void update_filament_count();
|
|
|
|
// Load user configuration and store it into the user profiles.
|
|
// This method is called by the configuration wizard.
|
|
void load_config_from_wizard(const std::string &name, DynamicPrintConfig config, Semver file_version)
|
|
{ this->load_config_file_config(name, false, std::move(config), file_version, true); }
|
|
|
|
// Load configuration that comes from a model file containing configuration, such as 3MF et al.
|
|
// This method is called by the Plater.
|
|
void load_config_model(const std::string &name, DynamicPrintConfig config, Semver file_version = Semver(), PublishedConfig *published_config = nullptr)
|
|
{ this->load_config_file_config(name, true, std::move(config), file_version, false, published_config); }
|
|
|
|
// Load an external config file containing the print, filament and printer presets.
|
|
// Instead of a config file, a G-code may be loaded containing the full set of parameters.
|
|
// In the future the configuration will likely be read from an AMF file as well.
|
|
// If the file is loaded successfully, its print / filament / printer profiles will be activated.
|
|
ConfigSubstitutions load_config_file(const std::string &path, ForwardCompatibilitySubstitutionRule compatibility_rule);
|
|
|
|
// Load a config bundle file, into presets and store the loaded presets into separate files
|
|
// of the local configuration directory.
|
|
// Load settings into the provided settings instance.
|
|
// Activate the presets stored in the config bundle.
|
|
// Returns the number of presets loaded successfully.
|
|
enum LoadConfigBundleAttribute {
|
|
// Save the profiles, which have been loaded.
|
|
SaveImported,
|
|
// Delete all old config profiles before loading.
|
|
ResetUserProfile,
|
|
// Load a system config bundle.
|
|
LoadSystem,
|
|
LoadVendorOnly,
|
|
LoadFilamentOnly,
|
|
};
|
|
using LoadConfigBundleAttributes = enum_bitmask<LoadConfigBundleAttribute>;
|
|
// Load the config bundle based on the flags.
|
|
// Don't do any config substitutions when loading a system profile, perform and report substitutions otherwise.
|
|
/*std::pair<PresetsConfigSubstitutions, size_t> load_configbundle(
|
|
const std::string &path, LoadConfigBundleAttributes flags, ForwardCompatibilitySubstitutionRule compatibility_rule);*/
|
|
//Orca: load config bundle from json, pass the base bundle to support cross vendor inheritance
|
|
// Orca: `dir` is where the vendor is looked for — its own directory, whether or
|
|
// not the profile JSONs are still there. A whole-vendor load comes from the
|
|
// vendor's preset cache whenever one covers the profile on disk and allow_cache
|
|
// is true, and is parsed from the JSONs in `dir` otherwise. Nothing here reads
|
|
// resources implicitly.
|
|
std::pair<PresetsConfigSubstitutions, size_t> load_vendor_configs_from_json(
|
|
const std::string &dir, const std::string &vendor_name, LoadConfigBundleAttributes flags,
|
|
ForwardCompatibilitySubstitutionRule compatibility_rule, const PresetBundle* base_bundle = nullptr,
|
|
bool allow_cache = true);
|
|
|
|
// Export a config bundle file containing all the presets and the names of the active presets.
|
|
//void export_configbundle(const std::string &path, bool export_system_settings = false, bool export_physical_printers = false);
|
|
//BBS: add a function to export current configbundle as default
|
|
//void export_current_configbundle(const std::string &path);
|
|
//BBS: add a function to export system presets for cloud-slicer
|
|
//void export_system_configs(const std::string &path);
|
|
std::vector<std::string> export_current_configs(const std::string &path, std::function<int(std::string const &)> override_confirm,
|
|
bool include_modify, bool export_system_settings = false);
|
|
|
|
// Enable / disable the "- default -" preset.
|
|
void set_default_suppressed(bool default_suppressed);
|
|
|
|
// Set the filament preset name. As the name could come from the UI selection box,
|
|
// an optional "(modified)" suffix will be removed from the filament name.
|
|
void set_filament_preset(size_t idx, const std::string &name);
|
|
|
|
// Read out the number of extruders from an active printer preset,
|
|
// update size and content of filament_presets.
|
|
void update_multi_material_filament_presets(size_t to_delete_filament_id = size_t(-1));
|
|
// Mixed-color filament slots: virtual slots realized from 2-3 physical filaments.
|
|
bool is_mixed_filament(size_t idx) const;
|
|
std::vector<size_t> physical_filament_config_indices() const;
|
|
// How many slots are mixed. They sit at the tail of the filament list and have no nozzle of
|
|
// their own, so any resize driven by the printer's extruder count has to add this on top.
|
|
size_t num_mixed_filaments() const;
|
|
// How many slots hold a real filament, i.e. everything ahead of the mixed tail.
|
|
size_t num_physical_filaments() const;
|
|
|
|
void on_extruders_count_changed(int extruder_count);
|
|
|
|
// Update the is_compatible flag of all print and filament presets depending on whether they are marked
|
|
// as compatible with the currently selected printer (and print in case of filament presets).
|
|
// Also updates the is_visible flag of each preset.
|
|
// If select_other_if_incompatible is true, then the print or filament preset is switched to some compatible
|
|
// preset if the current print or filament preset is not compatible.
|
|
void update_compatible(PresetSelectCompatibleType select_other_print_if_incompatible, PresetSelectCompatibleType select_other_filament_if_incompatible);
|
|
void update_compatible(PresetSelectCompatibleType select_other_if_incompatible) { this->update_compatible(select_other_if_incompatible, select_other_if_incompatible); }
|
|
|
|
// Rewrite compatible_printers / compatible_prints references that point at a renamed system
|
|
// preset to the current name, mirroring Preset::normalize_inherits for the "inherits" field.
|
|
// Call after loading presets and before selection; requires update_system_maps() to have run.
|
|
void normalize_compatible_presets();
|
|
|
|
// Set the is_visible flag for printer vendors, printer models and printer variants
|
|
// based on the user configuration.
|
|
// If the "vendor" section is missing, enable all models and variants of the particular vendor.
|
|
void load_installed_printers(const AppConfig &config);
|
|
|
|
const std::string& get_preset_name_by_alias(const Preset::Type& preset_type, const std::string& alias) const;
|
|
|
|
const int get_required_hrc_by_filament_type(const std::string& filament_type) const;
|
|
// Save current preset of a provided type under a new name. If the name is different from the old one,
|
|
// Unselected option would be reverted to the beginning values
|
|
//BBS: add project embedded preset logic
|
|
void save_changes_for_preset(const std::string& new_name, Preset::Type type, const std::vector<std::string>& unselected_options, bool save_to_project = false);
|
|
|
|
std::pair<PresetsConfigSubstitutions, std::string> load_system_models_from_json(ForwardCompatibilitySubstitutionRule compatibility_rule);
|
|
std::pair<PresetsConfigSubstitutions, std::string> load_system_filaments_json(ForwardCompatibilitySubstitutionRule compatibility_rule);
|
|
VendorProfile get_custom_vendor_models() const;
|
|
|
|
//orca: add 'custom' as default
|
|
static const char *ORCA_DEFAULT_BUNDLE;
|
|
static const char *ORCA_DEFAULT_PRINTER_MODEL;
|
|
static const char *ORCA_DEFAULT_PRINTER_VARIANT;
|
|
static const char *ORCA_DEFAULT_FILAMENT;
|
|
static const char *ORCA_FILAMENT_LIBRARY;
|
|
static const char *ORCA_DEFAULT_FILAMENT_PLACEHOLDER;
|
|
|
|
|
|
static std::array<Preset::Type, 3> types_list(PrinterTechnology pt) {
|
|
if (pt == ptFFF)
|
|
return { Preset::TYPE_PRINTER, Preset::TYPE_PRINT, Preset::TYPE_FILAMENT };
|
|
return { Preset::TYPE_PRINTER, Preset::TYPE_SLA_PRINT, Preset::TYPE_SLA_MATERIAL };
|
|
}
|
|
|
|
// Orca: for validation only.
|
|
bool has_errors(bool check_duplicate_filament_subtypes = false) const;
|
|
|
|
// Errors the last load recorded. What the cache's error accounting promises —
|
|
// a cache-served vendor reports what its parse would — is pinned against this.
|
|
int error_count() const { return m_errors; }
|
|
|
|
// Orca: for validation only. Flag any system preset whose inherits / compatible_printers /
|
|
// compatible_prints references a deleted (unknown) or renamed (old) preset name.
|
|
bool check_preset_references() const;
|
|
|
|
// Validator-only: every system FFF printer variant needs a compatible system filament
|
|
// named in its model's default_materials, every name there and in the printer's
|
|
// default_filament_profile must resolve to a system filament.
|
|
bool check_printer_default_materials() const;
|
|
|
|
// One vendor to load, and the directory it is installed in.
|
|
struct VendorSource
|
|
{
|
|
std::string name;
|
|
boost::filesystem::path dir;
|
|
};
|
|
|
|
// Load `vendors` into this bundle, the Orca filament library directly and every
|
|
// other vendor in parallel into a bundle of its own that inherits from it, merged
|
|
// in the order given. A vendor that cannot be loaded has its error added to the
|
|
// returned text, or thrown in validation mode, and its name to `failed`; it is
|
|
// left out, except for the library, which keeps what it installed before the
|
|
// failure. Once `cancel` is set, no further vendor starts loading.
|
|
std::pair<PresetsConfigSubstitutions, std::string> load_vendors(const std::vector<VendorSource>& vendors,
|
|
ForwardCompatibilitySubstitutionRule compatibility_rule, bool allow_cache,
|
|
const std::atomic<bool>* cancel = nullptr, std::vector<std::string>* failed = nullptr);
|
|
|
|
private:
|
|
// Move the presets and vendor profiles of `others` into this bundle, in one pass
|
|
// over each collection. A preset whose name this bundle or an earlier one of
|
|
// `others` already has is left out and listed under the bundle that repeats it.
|
|
std::vector<std::vector<std::string>> merge_presets(const std::vector<PresetBundle*> &others);
|
|
|
|
// What parsing one entry's JSON sub-file reported. Its errors and warnings are
|
|
// logged when the entry installs, so they come out in listing order with the
|
|
// entry's install errors, as parsing and installing one entry at a time leaves them.
|
|
struct EntryParse
|
|
{
|
|
ConfigSubstitutions substitutions;
|
|
// Counted in the bundle's error count.
|
|
std::vector<std::string> errors;
|
|
std::vector<std::string> warnings;
|
|
};
|
|
|
|
// An EntryParse for each entry of the VendorCacheData list of the same name.
|
|
struct VendorParse
|
|
{
|
|
std::vector<EntryParse> process_entries;
|
|
std::vector<EntryParse> filament_entries;
|
|
std::vector<EntryParse> machine_entries;
|
|
};
|
|
|
|
// One vendor read from its cache or its JSONs by read_vendor, for
|
|
// install_vendor_read to install.
|
|
struct VendorRead
|
|
{
|
|
std::string dir;
|
|
std::string vendor_name;
|
|
LoadConfigBundleAttributes flags;
|
|
ForwardCompatibilitySubstitutionRule compatibility_rule;
|
|
// The errors this bundle had counted before the read, which the cache stamp leaves out.
|
|
int errors_at_entry { 0 };
|
|
// A whole-vendor load, which can read a cache and write one.
|
|
bool cacheable { false };
|
|
// Read from the cache at cache_path, which install can still reject.
|
|
bool from_cache { false };
|
|
std::string cache_path;
|
|
// Only the vendor profile was asked for.
|
|
bool vendor_only { false };
|
|
VendorCacheData data;
|
|
// What each entry's JSON parse reported, and whether and with which version
|
|
// the cache is written once the entries install.
|
|
VendorParse parsed;
|
|
bool will_cache { false };
|
|
std::string version;
|
|
// The sub-file the parse stopped at, its kind, why, and the errors it reported.
|
|
std::string reason;
|
|
std::string failed_subfile;
|
|
const char* failed_kind { nullptr };
|
|
std::vector<std::string> failed_errors;
|
|
};
|
|
|
|
// Read a vendor into this bundle's vendor profiles and `data`, from its cache
|
|
// when one covers it, else from its JSONs; nothing is installed. Throws
|
|
// ConfigurationError when the vendor's own JSON cannot be parsed.
|
|
VendorRead read_vendor(const std::string& dir, const std::string& vendor_name, LoadConfigBundleAttributes flags,
|
|
ForwardCompatibilitySubstitutionRule compatibility_rule, bool allow_cache);
|
|
|
|
// Parse the vendor's JSONs into `read`, up to the first sub-file that fails.
|
|
void parse_vendor_json(VendorRead& read);
|
|
|
|
// Install what read_vendor read, against base_bundle's filament library. A cache
|
|
// that cannot be installed is replaced by a parse of the JSONs. Throws
|
|
// ConfigurationError at the first entry that cannot be installed, or after
|
|
// installing the entries before a sub-file that could not be parsed.
|
|
std::pair<PresetsConfigSubstitutions, size_t> install_vendor_read(VendorRead&& read, const PresetBundle* base_bundle);
|
|
|
|
// Install a cache's entries. False, with this bundle left clean, when one of them
|
|
// cannot be installed.
|
|
bool install_vendor_cache(const std::string& cache_path, const std::string& vendor_name, VendorCacheData&& data,
|
|
const PresetBundle* base_bundle);
|
|
|
|
// Log and count errors reported by a resolve or a parse.
|
|
void log_errors(const std::vector<std::string>& errors);
|
|
|
|
// The state of installing one collection of one vendor, which
|
|
// resolve_vendor_preset reads through a const reference and only
|
|
// commit_vendor_preset writes.
|
|
struct VendorInstall
|
|
{
|
|
// The directory holding <vendor_name>/, whose sub-paths the entries name.
|
|
std::string path;
|
|
std::string vendor_name;
|
|
const VendorProfile* vendor_profile;
|
|
const PresetBundle* base_bundle;
|
|
LoadConfigBundleAttributes flags;
|
|
PresetCollection* presets;
|
|
// The Orca filament library, which keeps every config for other vendors to
|
|
// resolve against.
|
|
bool is_from_lib;
|
|
PresetsConfigSubstitutions* substitutions;
|
|
// The names some entry inherits / includes, the only ones whose configs /
|
|
// include diffs are looked up again.
|
|
std::set<std::string> inherited;
|
|
std::set<std::string> included;
|
|
std::map<std::string, DynamicPrintConfig> config_maps;
|
|
std::map<std::string, DynamicPrintConfig> include_maps;
|
|
std::map<std::string, std::string> filament_id_maps;
|
|
std::unordered_set<std::string> installed_names;
|
|
size_t count { 0 };
|
|
};
|
|
|
|
// Install a vendor's source-form entries, parsed from its JSON or read from its
|
|
// cache: processes, then filaments, then printers. Both loads go through here,
|
|
// so a cache-loaded bundle cannot come out different from a JSON-loaded one.
|
|
// `parsed` is given for entries parsed just now. `complete` says the entries
|
|
// are the vendor's whole lists; only then are the filament library's configs
|
|
// and filament ids left in m_config_maps and m_filament_id_maps. Returns the
|
|
// number of presets installed, and throws ConfigurationError at the first
|
|
// entry that cannot be installed.
|
|
size_t install_vendor(const std::string& path, const std::string& vendor_name, const PresetBundle* base_bundle,
|
|
LoadConfigBundleAttributes flags, const VendorCacheData& entries,
|
|
VendorParse* parsed, bool complete, PresetsConfigSubstitutions& substitutions);
|
|
|
|
// Install one collection's entries in the order they are listed.
|
|
void install_vendor_entries(VendorInstall& install, const std::vector<CachedPreset>& entries,
|
|
std::vector<EntryParse>* parsed);
|
|
|
|
// One entry flattened against the preset it inherits, before anything this
|
|
// bundle shares has been touched.
|
|
struct PresetInstall
|
|
{
|
|
DynamicPrintConfig config;
|
|
std::string file_path;
|
|
// Empty when the preset is its own alias.
|
|
std::string alias;
|
|
std::string filament_id;
|
|
std::vector<std::string> renamed_from;
|
|
// Reported by commit, so resolving entries together leaves the log and
|
|
// the error count as one entry at a time produces them.
|
|
std::vector<std::string> errors;
|
|
// What a base states for the presets that include it, when it is retained.
|
|
std::optional<DynamicPrintConfig> included;
|
|
// The config kept for the entries that inherit this one, or for other
|
|
// vendors when this is the filament library.
|
|
std::optional<DynamicPrintConfig> retained;
|
|
// Not instantiated, so it contributes a config and no preset.
|
|
bool config_only { false };
|
|
// Non-empty when the entry is rejected, and says why.
|
|
std::string reason;
|
|
};
|
|
|
|
// Flatten one entry against the config it inherits, from this collection's
|
|
// config_maps or base_bundle's filament library, with the include diffs it
|
|
// names layered in. It looks up nothing but the names the entry inherits and
|
|
// includes, and writes nothing.
|
|
PresetInstall resolve_vendor_preset(const CachedPreset& entry, const VendorInstall& install) const;
|
|
|
|
// Install a resolved entry. The collections, the maps in `install` and the
|
|
// error count are touched here and only here, one entry at a time.
|
|
// Presets are appended, so a repeated name is caught with `installed_names`,
|
|
// and the collection is sorted once every entry is in.
|
|
std::string commit_vendor_preset(const CachedPreset& entry, PresetInstall&& resolved,
|
|
ConfigSubstitutions&& substitutions, VendorInstall& install);
|
|
|
|
// Clear every collection's m_printer_hold_alias, which reset() leaves alone.
|
|
void clear_printer_hold_aliases();
|
|
|
|
// Whether to (re)write a per-vendor cache after a JSON parse.
|
|
bool m_generate_vendor_caches { false };
|
|
bool m_preserve_vendor_source_paths { false };
|
|
|
|
// 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, 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);
|
|
|
|
// Orca: validation only - flag any printer with two or more compatible
|
|
// filament presets sharing one filament_id (ambiguous AMS subtype match).
|
|
bool check_duplicate_filament_subtypes() const;
|
|
|
|
//std::pair<PresetsConfigSubstitutions, std::string> load_system_presets(ForwardCompatibilitySubstitutionRule compatibility_rule);
|
|
//BBS: add json related logic
|
|
// Reads each vendor from its preset cache where one covers the profile, as every load does.
|
|
// write_caches = false keeps a read-only load from writing caches into the data directory.
|
|
std::pair<PresetsConfigSubstitutions, std::string> load_system_presets_from_json(ForwardCompatibilitySubstitutionRule compatibility_rule, bool write_caches = true);
|
|
// Update the multicolor information for filaments.
|
|
void update_filament_multi_color();
|
|
// Update renamed_from and alias maps of system profiles.
|
|
void update_system_maps();
|
|
|
|
// Set the is_visible flag for filaments and sla materials,
|
|
// apply defaults based on enabled printers when no filaments/materials are installed.
|
|
void load_installed_filaments(AppConfig &config);
|
|
void load_installed_sla_materials(AppConfig &config);
|
|
|
|
// Load print, filament & printer presets from a config. If it is an external config, then the name is extracted from the external path.
|
|
// and the external config is just referenced, not stored into user profile directory.
|
|
// If it is not an external config, then the config will be stored into the user profile directory.
|
|
void load_config_file_config(const std::string &name_or_path, bool is_external, DynamicPrintConfig &&config, Semver file_version = Semver(), bool selected = false, PublishedConfig *published_config = nullptr);
|
|
/*ConfigSubstitutions load_config_file_config_bundle(
|
|
const std::string &path, const boost::property_tree::ptree &tree, ForwardCompatibilitySubstitutionRule compatibility_rule);*/
|
|
|
|
DynamicPrintConfig full_fff_config(bool apply_extruder, std::optional<std::vector<int>> filament_maps=std::nullopt, std::optional<std::vector<int>> filament_volume_maps=std::nullopt) const;
|
|
DynamicPrintConfig full_sla_config() const;
|
|
|
|
// Orca: used for validation only
|
|
bool validation_mode = false;
|
|
std::string vendor_to_validate = "";
|
|
int m_errors = 0;
|
|
|
|
// Helper function: save preset to bundle directory with common logic
|
|
bool save_preset_to_bundle_dir(Preset& preset, PresetCollection* collection,
|
|
const std::string& bundle_id, const std::string& type_subdir,
|
|
const std::string& bundle_base_dir);
|
|
|
|
};
|
|
|
|
ENABLE_ENUM_BITMASK_OPERATORS(PresetBundle::LoadConfigBundleAttribute)
|
|
|
|
} // namespace Slic3r
|
|
|
|
#endif /* slic3r_PresetBundle_hpp_ */
|