New gcode visualization - Inlining in source code

src/slic3r/GUI/LibVGCode/src/ExtrusionRoles.cpp

@@ -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
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/src/ExtrusionRoles.hpp

@@ -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;

src/slic3r/GUI/LibVGCode/src/Layers.cpp

@@ -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
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/src/Layers.hpp

@@ -22,21 +22,28 @@ public:
     void update(const PathVertex& vertex, uint32_t vertex_id);
     void reset();
     
-    bool empty() const;
+    bool empty() const { return m_items.empty(); }
-    size_t count() const;
+    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_time(ETimeMode mode, size_t layer_id) const {
-    float get_layer_z(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;
+    const Interval& get_view_range() const { return m_view_range.get(); }
-    void set_view_range(const Interval& range);
+    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);
+    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

src/slic3r/GUI/LibVGCode/src/Range.cpp

@@ -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
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/src/Range.hpp

@@ -17,23 +17,23 @@ namespace libvgcode {
 class Range
 {
 public:
-    const Interval& get() const;
+    const Interval& get() const { return m_range; }
-    void set(const Range& other);
+    void set(const Range& other) { m_range = other.m_range; }
-    void set(const Interval& 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;
+    Interval::value_type get_min() const { return m_range[0]; }
-    void set_min(Interval::value_type min);
+    void set_min(Interval::value_type min) { set(min, m_range[1]); }
 
-    Interval::value_type get_max() const;
+    Interval::value_type get_max() const { return m_range[1]; }
-    void set_max(Interval::value_type max);
+    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();
+    void reset() { m_range = { 0, 0 }; }
 
-    bool operator == (const Range& other) const;
+    bool operator == (const Range& other) const { return m_range == other.m_range; }
-    bool operator != (const Range& other) const;
+    bool operator != (const Range& other) const { return m_range != other.m_range; }
 
 private:
     Interval m_range{ 0, 0 };

src/slic3r/GUI/LibVGCode/src/ToolMarker.cpp

@@ -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
 
 //################################################################################################################################

src/slic3r/GUI/LibVGCode/src/ToolMarker.hpp

@@ -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;
+    bool is_enabled() const { return m_enabled; }
-    void enable(bool value);
+    void enable(bool value) { m_enabled = value; }
 
-    const Vec3& get_position() const;
+    const Vec3& get_position() const { return m_position; }
-    void set_position(const Vec3& position);
+    void set_position(const Vec3& position) { m_position = position; }
 
-    float get_offset_z() const;
+    float get_offset_z() const { return m_offset_z; }
-    void set_offset_z(float offset_z);
+    void set_offset_z(float offset_z) { m_offset_z = std::max(offset_z, 0.0f); }
 
-    const Color& get_color() const;
+    const Color& get_color() const { return m_color; }
-    void set_color(const Color& color);
+    void set_color(const Color& color) { m_color = color; }
 
-    float get_alpha() const;
+    float get_alpha() const { return m_alpha; }
-    void set_alpha(float alpha);
+    void set_alpha(float alpha) { m_alpha = std::clamp(alpha, 0.25f, 0.75f); }
 
 private:
     bool m_enabled{ false };

src/slic3r/GUI/LibVGCode/src/ViewRange.cpp

@@ -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);

src/slic3r/GUI/LibVGCode/src/ViewRange.hpp

@@ -17,19 +17,19 @@ namespace libvgcode {
 class ViewRange
 {
 public:
-    const Interval& get_full() const;
+    const Interval& get_full() const { return m_full.get(); }
-    void set_full(const Range& other);
+    void set_full(const Range& other) { set_full(other.get()); }
-    void set_full(const Interval& range);
+    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;
+    const Interval& get_enabled() const { return m_enabled.get(); }
-    void set_enabled(const Range& other);
+    void set_enabled(const Range& other) { set_enabled(other.get()); }
-    void set_enabled(const Interval& range);
+    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;
+    const Interval& get_visible() const { return m_visible.get(); }
-		void set_visible(const Range& other);
+    void set_visible(const Range& other) { set_visible(other.get()); }
-    void set_visible(const Interval& range);
+    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();

src/slic3r/GUI/LibVGCode/src/ViewerImpl.cpp

@@ -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 {

src/slic3r/GUI/LibVGCode/src/ViewerImpl.hpp

@@ -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;
+    const Interval& get_layers_view_range() const { return m_layers.get_view_range(); }
-    void set_layers_view_range(const Interval& 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;
+    size_t get_layers_count() const { return m_layers.count(); }
-    float get_layer_z(size_t layer_id) const;
+    float get_layer_z(size_t layer_id) const { return m_layers.get_layer_z(layer_id); }
-    std::vector<float> get_layers_zs() const;
+    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;
+    size_t get_used_extruders_count() const { return m_used_extruders_ids.size(); }
-    const std::vector<uint8_t>& get_used_extruders_ids() const;
+    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_full_range() const { return m_view_range.get_full(); }
-    const Interval& get_view_enabled_range() const;
+    const Interval& get_view_enabled_range() const { return m_view_range.get_enabled(); }
-    const Interval& get_view_visible_range() const;
+    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;
+    size_t get_vertices_count() const { return m_vertices.size(); }
-    const PathVertex& get_current_vertex() const;
+    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;
+    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;
+    size_t get_enabled_segments_count() const { return m_enabled_segments_count; }
-    const Interval& get_enabled_segments_range() const;
+    const Interval& get_enabled_segments_range() const { return m_enabled_segments_range.get(); }
 
-    size_t get_enabled_options_count() const;
+    size_t get_enabled_options_count() const { return m_enabled_options_count; }
-    const Interval& get_enabled_options_range() const;
+    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 { return m_extrusion_roles.get_roles(); }
-    std::vector<EGCodeExtrusionRole> get_extrusion_roles() const;
+    float get_extrusion_role_time(EGCodeExtrusionRole role) const { return m_extrusion_roles.get_time(role, m_settings.time_mode); }
-    float get_extrusion_role_time(EGCodeExtrusionRole role) const;
+    size_t get_extrusion_roles_count() const { return m_extrusion_roles.get_roles_count(); }
-    float get_extrusion_role_time(EGCodeExtrusionRole role, ETimeMode mode) const;
+    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() const { return get_travels_time(m_settings.time_mode); }
-    float get_travels_time(ETimeMode mode) const;
+    float get_travels_time(ETimeMode mode) const {
-    std::vector<float> get_layers_times() const;
+        return (mode < ETimeMode::COUNT) ? m_travels_time[static_cast<size_t>(mode)] : 0.0f;
-    std::vector<float> get_layers_times(ETimeMode mode) const;
+    }
+    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;
+    size_t get_tool_colors_count() const { return m_tool_colors.size(); }
-    const std::vector<Color>& get_tool_colors() const;
+    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_height_range() const { return m_height_range; }
-    const ColorRange& get_width_range() const;
+    const ColorRange& get_width_range() const { return m_width_range; }
-    const ColorRange& get_speed_range() const;
+    const ColorRange& get_speed_range() const { return m_speed_range; }
-    const ColorRange& get_fan_speed_range() const;
+    const ColorRange& get_fan_speed_range() const { return m_fan_speed_range; }
-    const ColorRange& get_temperature_range() const;
+    const ColorRange& get_temperature_range() const { return m_temperature_range; }
-    const ColorRange& get_volumetric_rate_range() const;
+    const ColorRange& get_volumetric_rate_range() const { return m_volumetric_rate_range; }
-    const ColorRange& get_layer_time_range(EColorRangeType type) const;
+    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;
+    float get_cog_marker_scale_factor() const { return m_cog_marker_scale_factor; }
-    void set_cog_marker_scale_factor(float 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;
+    bool is_tool_marker_enabled() const { return m_tool_marker.is_enabled(); }
-    void enable_tool_marker(bool value);
+    void enable_tool_marker(bool value) { m_tool_marker.enable(value); }
 
-    const Vec3& get_tool_marker_position() const;
+    const Vec3& get_tool_marker_position() const { return m_tool_marker.get_position(); }
-    void set_tool_marker_position(const Vec3& position);
+    void set_tool_marker_position(const Vec3& position) { m_tool_marker.set_position(position); }
 
-    float get_tool_marker_offset_z() const;
+    float get_tool_marker_offset_z() const { return m_tool_marker.get_offset_z(); }
-    void set_tool_marker_offset_z(float 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;
+    float get_tool_marker_scale_factor() const { return m_tool_marker_scale_factor; }
-    void set_tool_marker_scale_factor(float 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;
+    const Color& get_tool_marker_color() const { return m_tool_marker.get_color(); }
-    void set_tool_marker_color(const Color& color);
+    void set_tool_marker_color(const Color& color) { m_tool_marker.set_color(color); }
 
-    float get_tool_marker_alpha() const;
+    float get_tool_marker_alpha() const { return m_tool_marker.get_alpha(); }
-    void set_tool_marker_alpha(float size);
+    void set_tool_marker_alpha(float alpha) { m_tool_marker.set_alpha(alpha); }
 #endif // !ENABLE_NEW_GCODE_VIEWER_NO_COG_AND_TOOL_MARKERS
 
 private: