GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-08-14 00:26:01 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

New gcode visualization - Inlining in source code

Browse Source
This commit is contained in:
enricoturri1966 2023-12-15 15:40:55 +01:00 committed by Lukas Matena
parent f11fdf4432
commit 5534e7f849
12 changed files with 115 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/slic3r/GUI/LibVGCode/src/ExtrusionRoles.cpp
View File

@ -27,11 +27,6 @@ void ExtrusionRoles::add(EGCodeExtrusionRole role, const std::array<float, Time_
}
}
size_t ExtrusionRoles::get_roles_count() const
{
return m_items.size();
}
std::vector<EGCodeExtrusionRole> ExtrusionRoles::get_roles() const
{
std::vector<EGCodeExtrusionRole> ret;
@ -51,11 +46,6 @@ float ExtrusionRoles::get_time(EGCodeExtrusionRole role, ETimeMode mode) const
return (mode < ETimeMode::COUNT) ? role_it->second.times[static_cast<size_t>(mode)] : 0.0f;
}
void ExtrusionRoles::reset()
{
m_items.clear();
}
} // namespace libvgcode
//################################################################################################################################

4
src/slic3r/GUI/LibVGCode/src/ExtrusionRoles.hpp
View File

@ -26,11 +26,11 @@ public:
void add(EGCodeExtrusionRole role, const std::array<float, Time_Modes_Count>& times);
size_t get_roles_count() const;
size_t get_roles_count() const { return m_items.size(); }
std::vector<EGCodeExtrusionRole> get_roles() const;
float get_time(EGCodeExtrusionRole role, ETimeMode mode) const;
void reset();
void reset() { m_items.clear(); }
private:
std::map<EGCodeExtrusionRole, Item> m_items;

41
src/slic3r/GUI/LibVGCode/src/Layers.cpp
View File

@ -55,16 +55,6 @@ void Layers::reset()
m_view_range.reset();
}
bool Layers::empty() const
{
return m_items.empty();
}
size_t Layers::count() const
{
return m_items.size();
}
std::vector<float> Layers::get_times(ETimeMode mode) const
{
std::vector<float> ret;
@ -86,43 +76,12 @@ std::vector<float> Layers::get_zs() const
return ret;
}
float Layers::get_layer_time(ETimeMode mode, size_t layer_id) const
{
return (mode < ETimeMode::COUNT&& layer_id < m_items.size()) ?
m_items[layer_id].times[static_cast<size_t>(mode)] : 0.0f;
}
float Layers::get_layer_z(size_t layer_id) const
{
return (layer_id < m_items.size()) ? m_items[layer_id].z : 0.0f;
}
size_t Layers::get_layer_id_at(float z) const
{
auto iter = std::upper_bound(m_items.begin(), m_items.end(), z, [](float z, const Item& item) { return item.z < z; });
return std::distance(m_items.begin(), iter);
}
const Interval& Layers::get_view_range() const
{
return m_view_range.get();
}
void Layers::set_view_range(const Interval& range)
{
set_view_range(range[0], range[1]);
}
void Layers::set_view_range(Interval::value_type min, Interval::value_type max)
{
m_view_range.set(min, max);
}
bool Layers::layer_contains_colorprint_options(size_t layer_id) const
{
return (layer_id < m_items.size()) ? m_items[layer_id].contains_colorprint_options : false;
}
} // namespace libvgcode
//################################################################################################################################

25
src/slic3r/GUI/LibVGCode/src/Layers.hpp
View File

@ -22,21 +22,28 @@ public:
void update(const PathVertex& vertex, uint32_t vertex_id);
void reset();
bool empty() const;
size_t count() const;
bool empty() const { return m_items.empty(); }
size_t count() const { return m_items.size(); }
std::vector<float> get_times(ETimeMode mode) const;
std::vector<float> get_zs() const;
float get_layer_time(ETimeMode mode, size_t layer_id) const;
float get_layer_z(size_t layer_id) const;
float get_layer_time(ETimeMode mode, size_t layer_id) const {
return (mode < ETimeMode::COUNT&& layer_id < m_items.size()) ?
m_items[layer_id].times[static_cast<size_t>(mode)] : 0.0f;
}
float get_layer_z(size_t layer_id) const {
return (layer_id < m_items.size()) ? m_items[layer_id].z : 0.0f;
}
size_t get_layer_id_at(float z) const;
const Interval& get_view_range() const;
void set_view_range(const Interval& range);
void set_view_range(Interval::value_type min, Interval::value_type max);
const Interval& get_view_range() const { return m_view_range.get(); }
void set_view_range(const Interval& range) { set_view_range(range[0], range[1]); }
void set_view_range(Interval::value_type min, Interval::value_type max) { m_view_range.set(min, max); }
bool layer_contains_colorprint_options(size_t layer_id) const;
bool layer_contains_colorprint_options(size_t layer_id) const {
return (layer_id < m_items.size()) ? m_items[layer_id].contains_colorprint_options : false;
}
private:
struct Item

50
src/slic3r/GUI/LibVGCode/src/Range.cpp
View File

@ -18,21 +18,6 @@
namespace libvgcode {
const Interval& Range::get() const
{
return m_range;
}
void Range::set(const Range& other)
{
m_range = other.m_range;
}
void Range::set(const Interval& range)
{
set(range[0], range[1]);
}
void Range::set(Interval::value_type min, Interval::value_type max)
{
if (max < min)
@ -41,47 +26,12 @@ void Range::set(Interval::value_type min, Interval::value_type max)
m_range[1] = max;
}
Interval::value_type Range::get_min() const
{
return m_range[0];
}
void Range::set_min(Interval::value_type min)
{
set(min, m_range[1]);
}
Interval::value_type Range::get_max() const
{
return m_range[1];
}
void Range::set_max(Interval::value_type max)
{
set(m_range[0], max);
}
void Range::clamp(Range& other)
{
other.m_range[0] = std::clamp(other.m_range[0], m_range[0], m_range[1]);
other.m_range[1] = std::clamp(other.m_range[1], m_range[0], m_range[1]);
}
void Range::reset()
{
m_range = { 0, 0 };
}
bool Range::operator == (const Range& other) const
{
return m_range == other.m_range;
}
bool Range::operator != (const Range& other) const
{
return m_range != other.m_range;
}
} // namespace libvgcode
//################################################################################################################################

26
src/slic3r/GUI/LibVGCode/src/Range.hpp
View File

@ -17,23 +17,23 @@ namespace libvgcode {
class Range
{
public:
const Interval& get() const;
void set(const Range& other);
void set(const Interval& range);
const Interval& get() const { return m_range; }
void set(const Range& other) { m_range = other.m_range; }
void set(const Interval& range) { set(range[0], range[1]); }
void set(Interval::value_type min, Interval::value_type max);
Interval::value_type get_min() const;
void set_min(Interval::value_type min);
Interval::value_type get_max() const;
void set_max(Interval::value_type max);
Interval::value_type get_min() const { return m_range[0]; }
void set_min(Interval::value_type min) { set(min, m_range[1]); }
Interval::value_type get_max() const { return m_range[1]; }
void set_max(Interval::value_type max) { set(m_range[0], max); }
// clamp the given range to stay inside this range
void clamp(Range& other);
void reset();
bool operator == (const Range& other) const;
bool operator != (const Range& other) const;
void reset() { m_range = { 0, 0 }; }
bool operator == (const Range& other) const { return m_range == other.m_range; }
bool operator != (const Range& other) const { return m_range != other.m_range; }
private:
Interval m_range{ 0, 0 };

50
src/slic3r/GUI/LibVGCode/src/ToolMarker.cpp
View File

@ -165,56 +165,6 @@ void ToolMarker::render()
glsafe(glBindVertexArray(curr_vertex_array));
}
bool ToolMarker::is_enabled() const
{
return m_enabled;
}
void ToolMarker::enable(bool value)
{
m_enabled = value;
}
const Vec3& ToolMarker::get_position() const
{
return m_position;
}
void ToolMarker::set_position(const Vec3& position)
{
m_position = position;
}
float ToolMarker::get_offset_z() const
{
return m_offset_z;
}
void ToolMarker::set_offset_z(float offset_z)
{
m_offset_z = std::max(offset_z, 0.0f);
}
const Color& ToolMarker::get_color() const
{
return m_color;
}
void ToolMarker::set_color(const Color& color)
{
m_color = color;
}
float ToolMarker::get_alpha() const
{
return m_alpha;
}
void ToolMarker::set_alpha(float alpha)
{
m_alpha = std::clamp(alpha, 0.25f, 0.75f);
}
} // namespace libvgcode
//################################################################################################################################

20
src/slic3r/GUI/LibVGCode/src/ToolMarker.hpp
View File

@ -28,20 +28,20 @@ public:
void init(uint16_t resolution, float tip_radius, float tip_height, float stem_radius, float stem_height);
void render();
bool is_enabled() const;
void enable(bool value);
bool is_enabled() const { return m_enabled; }
void enable(bool value) { m_enabled = value; }
const Vec3& get_position() const;
void set_position(const Vec3& position);
const Vec3& get_position() const { return m_position; }
void set_position(const Vec3& position) { m_position = position; }
float get_offset_z() const;
void set_offset_z(float offset_z);
float get_offset_z() const { return m_offset_z; }
void set_offset_z(float offset_z) { m_offset_z = std::max(offset_z, 0.0f); }
const Color& get_color() const;
void set_color(const Color& color);
const Color& get_color() const { return m_color; }
void set_color(const Color& color) { m_color = color; }
float get_alpha() const;
void set_alpha(float alpha);
float get_alpha() const { return m_alpha; }
void set_alpha(float alpha) { m_alpha = std::clamp(alpha, 0.25f, 0.75f); }
private:
bool m_enabled{ false };

45
src/slic3r/GUI/LibVGCode/src/ViewRange.cpp
View File

@ -16,21 +16,6 @@
namespace libvgcode {
const Interval& ViewRange::get_full() const
{
return m_full.get();
}
void ViewRange::set_full(const Range& other)
{
set_full(other.get());
}
void ViewRange::set_full(const Interval& range)
{
set_full(range[0], range[1]);
}
void ViewRange::set_full(Interval::value_type min, Interval::value_type max)
{
// is the full range being extended ?
@ -45,21 +30,6 @@ void ViewRange::set_full(Interval::value_type min, Interval::value_type max)
m_enabled.set_max(max);
}
const Interval& ViewRange::get_enabled() const
{
return m_enabled.get();
}
void ViewRange::set_enabled(const Range& other)
{
set_enabled(other.get());
}
void ViewRange::set_enabled(const Interval& range)
{
set_enabled(range[0], range[1]);
}
void ViewRange::set_enabled(Interval::value_type min, Interval::value_type max)
{
// is the enabled range being extended ?
@ -72,21 +42,6 @@ void ViewRange::set_enabled(Interval::value_type min, Interval::value_type max)
m_visible.set_max(max);
}
const Interval& ViewRange::get_visible() const
{
return m_visible.get();
}
void ViewRange::set_visible(const Range& other)
{
set_visible(other.get());
}
void ViewRange::set_visible(const Interval& range)
{
set_visible(range[0], range[1]);
}
void ViewRange::set_visible(Interval::value_type min, Interval::value_type max)
{
m_visible.set(min, max);

18
src/slic3r/GUI/LibVGCode/src/ViewRange.hpp
View File

@ -17,19 +17,19 @@ namespace libvgcode {
class ViewRange
{
public:
const Interval& get_full() const;
void set_full(const Range& other);
void set_full(const Interval& range);
const Interval& get_full() const { return m_full.get(); }
void set_full(const Range& other) { set_full(other.get()); }
void set_full(const Interval& range) { set_full(range[0], range[1]); }
void set_full(Interval::value_type min, Interval::value_type max);
const Interval& get_enabled() const;
void set_enabled(const Range& other);
void set_enabled(const Interval& range);
const Interval& get_enabled() const { return m_enabled.get(); }
void set_enabled(const Range& other) { set_enabled(other.get()); }
void set_enabled(const Interval& range) { set_enabled(range[0], range[1]); }
void set_enabled(Interval::value_type min, Interval::value_type max);
const Interval& get_visible() const;
void set_visible(const Range& other);
void set_visible(const Interval& range);
const Interval& get_visible() const { return m_visible.get(); }
void set_visible(const Range& other) { set_visible(other.get()); }
void set_visible(const Interval& range) { set_visible(range[0], range[1]); }
void set_visible(Interval::value_type min, Interval::value_type max);
void reset();

293
src/slic3r/GUI/LibVGCode/src/ViewerImpl.cpp
View File

@ -743,38 +743,18 @@ void ViewerImpl::render(const Mat4x4& view_matrix, const Mat4x4& projection_matr
#endif // !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
}
EViewType ViewerImpl::get_view_type() const
{
return m_settings.view_type;
}
void ViewerImpl::set_view_type(EViewType type)
{
m_settings.view_type = type;
m_settings.update_colors = true;
}
ETimeMode ViewerImpl::get_time_mode() const
{
return m_settings.time_mode;
}
void ViewerImpl::set_time_mode(ETimeMode mode)
{
m_settings.time_mode = mode;
m_settings.update_colors = true;
}
const Interval& ViewerImpl::get_layers_view_range() const
{
return m_layers.get_view_range();
}
void ViewerImpl::set_layers_view_range(const Interval& range)
{
set_layers_view_range(range[0], range[1]);
}
void ViewerImpl::set_layers_view_range(Interval::value_type min, Interval::value_type max)
{
m_layers.set_view_range(min, max);
@ -785,47 +765,12 @@ void ViewerImpl::set_layers_view_range(Interval::value_type min, Interval::value
m_settings.update_colors = true;
}
bool ViewerImpl::is_top_layer_only_view_range() const
{
return m_settings.top_layer_only_view_range;
}
void ViewerImpl::set_top_layer_only_view_range(bool top_layer_only_view_range)
{
m_settings.top_layer_only_view_range = top_layer_only_view_range;
m_settings.update_colors = true;
}
size_t ViewerImpl::get_layers_count() const
{
return m_layers.count();
}
float ViewerImpl::get_layer_z(size_t layer_id) const
{
return m_layers.get_layer_z(layer_id);
}
std::vector<float> ViewerImpl::get_layers_zs() const
{
return m_layers.get_zs();
}
size_t ViewerImpl::get_layer_id_at(float z) const
{
return m_layers.get_layer_id_at(z);
}
size_t ViewerImpl::get_used_extruders_count() const
{
return m_used_extruders_ids.size();
}
const std::vector<uint8_t>& ViewerImpl::get_used_extruders_ids() const
{
return m_used_extruders_ids;
}
AABox ViewerImpl::get_bounding_box(EBBoxType type) const
{
assert(type < EBBoxType::COUNT);
@ -879,21 +824,6 @@ void ViewerImpl::toggle_extrusion_role_visibility(EGCodeExtrusionRole role)
}
}
const Interval& ViewerImpl::get_view_full_range() const
{
return m_view_range.get_full();
}
const Interval& ViewerImpl::get_view_enabled_range() const
{
return m_view_range.get_enabled();
}
const Interval& ViewerImpl::get_view_visible_range() const
{
return m_view_range.get_visible();
}
void ViewerImpl::set_view_visible_range(uint32_t min, uint32_t max)
{
// force update of the full range, to avoid clamping the visible range with full old values
@ -904,21 +834,6 @@ void ViewerImpl::set_view_visible_range(uint32_t min, uint32_t max)
m_settings.update_colors = true;
}
size_t ViewerImpl::get_vertices_count() const
{
return m_vertices.size();
}
const PathVertex& ViewerImpl::get_current_vertex() const
{
return get_vertex_at(m_view_range.get_visible()[1]);
}
const PathVertex& ViewerImpl::get_vertex_at(size_t id) const
{
return (id < m_vertices.size()) ? m_vertices[id] : Dummy_Path_Vertex;
}
Color ViewerImpl::get_vertex_color(const PathVertex& v) const
{
if (v.type == EMoveType::Noop)
@ -986,76 +901,6 @@ Color ViewerImpl::get_vertex_color(const PathVertex& v) const
return Dummy_Color;
}
size_t ViewerImpl::get_enabled_segments_count() const
{
return m_enabled_segments_count;
}
const Interval& ViewerImpl::get_enabled_segments_range() const
{
return m_enabled_segments_range.get();
}
size_t ViewerImpl::get_enabled_options_count() const
{
return m_enabled_options_count;
}
const Interval& ViewerImpl::get_enabled_options_range() const
{
return m_enabled_options_range.get();
}
std::vector<EGCodeExtrusionRole> ViewerImpl::get_extrusion_roles() const
{
return m_extrusion_roles.get_roles();
}
float ViewerImpl::get_extrusion_role_time(EGCodeExtrusionRole role) const
{
return m_extrusion_roles.get_time(role, m_settings.time_mode);
}
size_t ViewerImpl::get_extrusion_roles_count() const
{
return m_extrusion_roles.get_roles_count();
}
float ViewerImpl::get_extrusion_role_time(EGCodeExtrusionRole role, ETimeMode mode) const
{
return m_extrusion_roles.get_time(role, mode);
}
float ViewerImpl::get_travels_time() const
{
return get_travels_time(m_settings.time_mode);
}
float ViewerImpl::get_travels_time(ETimeMode mode) const
{
return (mode < ETimeMode::COUNT) ? m_travels_time[static_cast<size_t>(mode)] : 0.0f;
}
std::vector<float> ViewerImpl::get_layers_times() const
{
return get_layers_times(m_settings.time_mode);
}
std::vector<float> ViewerImpl::get_layers_times(ETimeMode mode) const
{
return m_layers.get_times(mode);
}
size_t ViewerImpl::get_tool_colors_count() const
{
return m_tool_colors.size();
}
const std::vector<Color>& ViewerImpl::get_tool_colors() const
{
return m_tool_colors;
}
void ViewerImpl::set_tool_colors(const std::vector<Color>& colors)
{
m_tool_colors = colors;
@ -1075,11 +920,6 @@ void ViewerImpl::set_extrusion_role_color(EGCodeExtrusionRole role, const Color&
it->second = color;
}
void ViewerImpl::reset_default_extrusion_roles_colors()
{
m_extrusion_roles_colors = Default_Extrusion_Roles_Colors;
}
const Color& ViewerImpl::get_option_color(EOptionType type) const
{
const auto it = m_options_colors.find(type);
@ -1093,11 +933,6 @@ void ViewerImpl::set_option_color(EOptionType type, const Color& color)
it->second = color;
}
void ViewerImpl::reset_default_options_colors()
{
m_options_colors = Default_Options_Colors;
}
const Color& ViewerImpl::get_travel_move_color(ETravelMoveType type) const
{
const auto it = m_travel_moves_colors.find(type);
@ -1111,146 +946,18 @@ void ViewerImpl::set_travel_move_color(ETravelMoveType type, const Color& color)
it->second = color;
}
void ViewerImpl::reset_default_travel_moves_colors()
{
m_travel_moves_colors = Default_Travel_Moves_Colors;
}
const ColorRange& ViewerImpl::get_height_range() const
{
return m_height_range;
}
const ColorRange& ViewerImpl::get_width_range() const
{
return m_width_range;
}
const ColorRange& ViewerImpl::get_speed_range() const
{
return m_speed_range;
}
const ColorRange& ViewerImpl::get_fan_speed_range() const
{
return m_fan_speed_range;
}
const ColorRange& ViewerImpl::get_temperature_range() const
{
return m_temperature_range;
}
const ColorRange& ViewerImpl::get_volumetric_rate_range() const
{
return m_volumetric_rate_range;
}
const ColorRange& ViewerImpl::get_layer_time_range(EColorRangeType type) const
{
return (static_cast<size_t>(type) < m_layer_time_range.size()) ?
m_layer_time_range[static_cast<size_t>(type)] : ColorRange::Dummy_Color_Range;
}
float ViewerImpl::get_travels_radius() const
{
return m_travels_radius;
}
void ViewerImpl::set_travels_radius(float radius)
{
m_travels_radius = std::clamp(radius, 0.05f, 0.5f);
update_heights_widths();
}
float ViewerImpl::get_wipes_radius() const
{
return m_wipes_radius;
}
void ViewerImpl::set_wipes_radius(float radius)
{
m_wipes_radius = std::clamp(radius, 0.05f, 0.5f);
update_heights_widths();
}
#if !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
Vec3 ViewerImpl::get_cog_marker_position() const
{
return m_cog_marker.get_position();
}
float ViewerImpl::get_cog_marker_scale_factor() const
{
return m_cog_marker_scale_factor;
}
void ViewerImpl::set_cog_marker_scale_factor(float factor)
{
m_cog_marker_scale_factor = std::max(factor, 0.001f);
}
bool ViewerImpl::is_tool_marker_enabled() const
{
return m_tool_marker.is_enabled();
}
void ViewerImpl::enable_tool_marker(bool value)
{
m_tool_marker.enable(value);
}
const Vec3& ViewerImpl::get_tool_marker_position() const
{
return m_tool_marker.get_position();
}
void ViewerImpl::set_tool_marker_position(const Vec3& position)
{
m_tool_marker.set_position(position);
}
float ViewerImpl::get_tool_marker_offset_z() const
{
return m_tool_marker.get_offset_z();
}
void ViewerImpl::set_tool_marker_offset_z(float offset_z)
{
m_tool_marker.set_offset_z(offset_z);
}
float ViewerImpl::get_tool_marker_scale_factor() const
{
return m_tool_marker_scale_factor;
}
void ViewerImpl::set_tool_marker_scale_factor(float factor)
{
m_tool_marker_scale_factor = std::max(factor, 0.001f);
}
const Color& ViewerImpl::get_tool_marker_color() const
{
return m_tool_marker.get_color();
}
void ViewerImpl::set_tool_marker_color(const Color& color)
{
m_tool_marker.set_color(color);
}
float ViewerImpl::get_tool_marker_alpha() const
{
return m_tool_marker.get_alpha();
}
void ViewerImpl::set_tool_marker_alpha(float alpha)
{
m_tool_marker.set_alpha(alpha);
}
#endif // !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
static bool is_visible(const PathVertex& v, const Settings& settings)
{
try {

123
src/slic3r/GUI/LibVGCode/src/ViewerImpl.hpp
View File

@ -71,27 +71,27 @@ public:
//
void render(const Mat4x4& view_matrix, const Mat4x4& projection_matrix);
EViewType get_view_type() const;
EViewType get_view_type() const { return m_settings.view_type; }
void set_view_type(EViewType type);
ETimeMode get_time_mode() const;
ETimeMode get_time_mode() const { return m_settings.time_mode; }
void set_time_mode(ETimeMode mode);
const Interval& get_layers_view_range() const;
void set_layers_view_range(const Interval& range);
const Interval& get_layers_view_range() const { return m_layers.get_view_range(); }
void set_layers_view_range(const Interval& range) { set_layers_view_range(range[0], range[1]); }
void set_layers_view_range(Interval::value_type min, Interval::value_type max);
bool is_top_layer_only_view_range() const;
bool is_top_layer_only_view_range() const { return m_settings.top_layer_only_view_range; }
void set_top_layer_only_view_range(bool top_layer_only_view_range);
size_t get_layers_count() const;
float get_layer_z(size_t layer_id) const;
std::vector<float> get_layers_zs() const;
size_t get_layers_count() const { return m_layers.count(); }
float get_layer_z(size_t layer_id) const { return m_layers.get_layer_z(layer_id); }
std::vector<float> get_layers_zs() const { return m_layers.get_zs(); }
size_t get_layer_id_at(float z) const;
size_t get_layer_id_at(float z) const { return m_layers.get_layer_id_at(z); }
size_t get_used_extruders_count() const;
const std::vector<uint8_t>& get_used_extruders_ids() const;
size_t get_used_extruders_count() const { return m_used_extruders_ids.size(); }
const std::vector<uint8_t>& get_used_extruders_ids() const { return m_used_extruders_ids; }
AABox get_bounding_box(EBBoxType type) const;
@ -101,84 +101,91 @@ public:
bool is_extrusion_role_visible(EGCodeExtrusionRole role) const;
void toggle_extrusion_role_visibility(EGCodeExtrusionRole role);
const Interval& get_view_full_range() const;
const Interval& get_view_enabled_range() const;
const Interval& get_view_visible_range() const;
const Interval& get_view_full_range() const { return m_view_range.get_full(); }
const Interval& get_view_enabled_range() const { return m_view_range.get_enabled(); }
const Interval& get_view_visible_range() const { return m_view_range.get_visible(); }
void set_view_visible_range(uint32_t min, uint32_t max);
size_t get_vertices_count() const;
const PathVertex& get_current_vertex() const;
const PathVertex& get_vertex_at(size_t id) const;
size_t get_vertices_count() const { return m_vertices.size(); }
const PathVertex& get_current_vertex() const { return get_vertex_at(m_view_range.get_visible()[1]); }
const PathVertex& get_vertex_at(size_t id) const {
return (id < m_vertices.size()) ? m_vertices[id] : Dummy_Path_Vertex;
}
Color get_vertex_color(const PathVertex& vertex) const;
size_t get_enabled_segments_count() const;
const Interval& get_enabled_segments_range() const;
size_t get_enabled_segments_count() const { return m_enabled_segments_count; }
const Interval& get_enabled_segments_range() const { return m_enabled_segments_range.get(); }
size_t get_enabled_options_count() const;
const Interval& get_enabled_options_range() const;
size_t get_enabled_options_count() const { return m_enabled_options_count; }
const Interval& get_enabled_options_range() const { return m_enabled_options_range.get(); }
size_t get_extrusion_roles_count() const;
std::vector<EGCodeExtrusionRole> get_extrusion_roles() const;
float get_extrusion_role_time(EGCodeExtrusionRole role) const;
float get_extrusion_role_time(EGCodeExtrusionRole role, ETimeMode mode) const;
std::vector<EGCodeExtrusionRole> get_extrusion_roles() const { return m_extrusion_roles.get_roles(); }
float get_extrusion_role_time(EGCodeExtrusionRole role) const { return m_extrusion_roles.get_time(role, m_settings.time_mode); }
size_t get_extrusion_roles_count() const { return m_extrusion_roles.get_roles_count(); }
float get_extrusion_role_time(EGCodeExtrusionRole role, ETimeMode mode) const { return m_extrusion_roles.get_time(role, mode); }
float get_travels_time() const;
float get_travels_time(ETimeMode mode) const;
std::vector<float> get_layers_times() const;
std::vector<float> get_layers_times(ETimeMode mode) const;
float get_travels_time() const { return get_travels_time(m_settings.time_mode); }
float get_travels_time(ETimeMode mode) const {
return (mode < ETimeMode::COUNT) ? m_travels_time[static_cast<size_t>(mode)] : 0.0f;
}
std::vector<float> get_layers_times() const { return get_layers_times(m_settings.time_mode); }
std::vector<float> get_layers_times(ETimeMode mode) const { return m_layers.get_times(mode); }
size_t get_tool_colors_count() const;
const std::vector<Color>& get_tool_colors() const;
size_t get_tool_colors_count() const { return m_tool_colors.size(); }
const std::vector<Color>& get_tool_colors() const { return m_tool_colors; }
void set_tool_colors(const std::vector<Color>& colors);
const Color& get_extrusion_role_color(EGCodeExtrusionRole role) const;
void set_extrusion_role_color(EGCodeExtrusionRole role, const Color& color);
void reset_default_extrusion_roles_colors();
void reset_default_extrusion_roles_colors() { m_extrusion_roles_colors = Default_Extrusion_Roles_Colors; }
const Color& get_option_color(EOptionType type) const;
void set_option_color(EOptionType type, const Color& color);
void reset_default_options_colors();
void reset_default_options_colors() { m_options_colors = Default_Options_Colors; }
const Color& get_travel_move_color(ETravelMoveType type) const;
void set_travel_move_color(ETravelMoveType type, const Color& color);
void reset_default_travel_moves_colors();
void reset_default_travel_moves_colors() { m_travel_moves_colors = Default_Travel_Moves_Colors; }
const ColorRange& get_height_range() const;
const ColorRange& get_width_range() const;
const ColorRange& get_speed_range() const;
const ColorRange& get_fan_speed_range() const;
const ColorRange& get_temperature_range() const;
const ColorRange& get_volumetric_rate_range() const;
const ColorRange& get_layer_time_range(EColorRangeType type) const;
const ColorRange& get_height_range() const { return m_height_range; }
const ColorRange& get_width_range() const { return m_width_range; }
const ColorRange& get_speed_range() const { return m_speed_range; }
const ColorRange& get_fan_speed_range() const { return m_fan_speed_range; }
const ColorRange& get_temperature_range() const { return m_temperature_range; }
const ColorRange& get_volumetric_rate_range() const { return m_volumetric_rate_range; }
const ColorRange& get_layer_time_range(EColorRangeType type) const {
return (static_cast<size_t>(type) < m_layer_time_range.size()) ?
m_layer_time_range[static_cast<size_t>(type)] : ColorRange::Dummy_Color_Range;
}
float get_travels_radius() const;
float get_travels_radius() const { return m_travels_radius; }
void set_travels_radius(float radius);
float get_wipes_radius() const;
float get_wipes_radius() const { return m_wipes_radius; }
void set_wipes_radius(float radius);
#if !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
Vec3 get_cog_marker_position() const;
Vec3 get_cog_marker_position() const { return m_cog_marker.get_position(); }
float get_cog_marker_scale_factor() const;
void set_cog_marker_scale_factor(float factor);
float get_cog_marker_scale_factor() const { return m_cog_marker_scale_factor; }
void set_cog_marker_scale_factor(float factor) { m_cog_marker_scale_factor = std::max(factor, 0.001f); }
bool is_tool_marker_enabled() const;
void enable_tool_marker(bool value);
bool is_tool_marker_enabled() const { return m_tool_marker.is_enabled(); }
void enable_tool_marker(bool value) { m_tool_marker.enable(value); }
const Vec3& get_tool_marker_position() const;
void set_tool_marker_position(const Vec3& position);
const Vec3& get_tool_marker_position() const { return m_tool_marker.get_position(); }
void set_tool_marker_position(const Vec3& position) { m_tool_marker.set_position(position); }
float get_tool_marker_offset_z() const;
void set_tool_marker_offset_z(float offset_z);
float get_tool_marker_offset_z() const { return m_tool_marker.get_offset_z(); }
void set_tool_marker_offset_z(float offset_z) { m_tool_marker.set_offset_z(offset_z); }
float get_tool_marker_scale_factor() const;
void set_tool_marker_scale_factor(float factor);
float get_tool_marker_scale_factor() const { return m_tool_marker_scale_factor; }
void set_tool_marker_scale_factor(float factor) { m_tool_marker_scale_factor = std::max(factor, 0.001f); }
const Color& get_tool_marker_color() const;
void set_tool_marker_color(const Color& color);
const Color& get_tool_marker_color() const { return m_tool_marker.get_color(); }
void set_tool_marker_color(const Color& color) { m_tool_marker.set_color(color); }
float get_tool_marker_alpha() const;
void set_tool_marker_alpha(float size);
float get_tool_marker_alpha() const { return m_tool_marker.get_alpha(); }
void set_tool_marker_alpha(float alpha) { m_tool_marker.set_alpha(alpha); }
#endif // !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
private: