libvgcode::ViewerImpl Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/ViewerImpl.hpp>

Collaboration diagram for libvgcode::ViewerImpl:

Classes
struct	SegmentsUniforms
struct	LayerColorsUniforms
struct	TranslucentTargets

Public Member Functions
	ViewerImpl ()
	~ViewerImpl ()
	ViewerImpl (const ViewerImpl &other)=delete
	ViewerImpl (ViewerImpl &&other)=delete
ViewerImpl &	operator= (const ViewerImpl &other)=delete
ViewerImpl &	operator= (ViewerImpl &&other)=delete
void	init (const std::string &opengl_context_version)
void	shutdown ()
void	reset ()
void	load (GCodeInputData &&gcode_data)
void	update_enabled_entities ()
void	update_colors ()
void	update_colors_texture ()
void	render (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix)
void	render_translucent (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix)
bool	has_translucent_toolpaths () const
void	render_shadow_casters (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix, const Vec3 &light_position)
void	set_shadow_map (int texture_unit, const Mat4x4 &light_view_projection, float intensity, float texel_size)
void	set_tone (float exposure, float saturation)
void	set_clipping_plane (const std::array< float, 4 > &plane)
void	set_light_top_dir (const Vec3 &direction)
void	set_gloss (bool gloss)
EViewType	get_view_type () const
void	set_view_type (EViewType type)
ETimeMode	get_time_mode () const
void	set_time_mode (ETimeMode mode)
const Interval &	get_layers_view_range () const
void	set_layers_view_range (const Interval &range)
void	set_layers_view_range (Interval::value_type min, Interval::value_type max)
bool	is_top_layer_only_view_range () const
void	toggle_top_layer_only_view_range ()
bool	is_dim_previous_layers () const
void	set_dim_previous_layers (bool value)
float	get_dim_previous_layers_brightness () const
void	set_dim_previous_layers_brightness (float value)
bool	is_translucent_filaments () const
void	set_translucent_filaments (bool value)
bool	is_spiral_vase_mode () const
std::vector< ETimeMode >	get_time_modes () const
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_layer_id_at (float z) const
size_t	get_used_extruders_count () const
std::vector< uint8_t >	get_used_extruders_ids () const
size_t	get_color_prints_count (uint8_t extruder_id) const
std::vector< ColorPrint >	get_color_prints (uint8_t extruder_id) const
AABox	get_bounding_box (const std::vector< EMoveType > &types={ EMoveType::Retract, EMoveType::Unretract, EMoveType::Seam, EMoveType::ToolChange, EMoveType::ColorChange, EMoveType::PausePrint, EMoveType::CustomGCode, EMoveType::Travel, EMoveType::Wipe, EMoveType::Extrude }) const
AABox	get_extrusion_bounding_box (const std::vector< EGCodeExtrusionRole > &roles={ EGCodeExtrusionRole::Perimeter, EGCodeExtrusionRole::ExternalPerimeter, EGCodeExtrusionRole::OverhangPerimeter, EGCodeExtrusionRole::InternalInfill, EGCodeExtrusionRole::SolidInfill, EGCodeExtrusionRole::TopSolidInfill, EGCodeExtrusionRole::Ironing, EGCodeExtrusionRole::BridgeInfill, EGCodeExtrusionRole::GapFill, EGCodeExtrusionRole::Skirt, EGCodeExtrusionRole::SupportMaterial, EGCodeExtrusionRole::SupportMaterialInterface, EGCodeExtrusionRole::WipeTower, EGCodeExtrusionRole::Custom, EGCodeExtrusionRole::BottomSurface, EGCodeExtrusionRole::InternalBridgeInfill, EGCodeExtrusionRole::Brim, EGCodeExtrusionRole::SupportTransition, EGCodeExtrusionRole::Mixed }) const
bool	is_option_visible (EOptionType type) const
void	toggle_option_visibility (EOptionType type)
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
void	set_view_visible_range (Interval::value_type min, Interval::value_type max)
size_t	get_vertices_count () const
const PathVertex &	get_current_vertex () const
size_t	get_current_vertex_id () const
const PathVertex &	get_vertex_at (size_t id) const
float	get_estimated_time () const
float	get_estimated_time_at (size_t id) const
Color	get_vertex_color (const PathVertex &vertex) const
size_t	get_extrusion_roles_count () const
std::vector< EGCodeExtrusionRole >	get_extrusion_roles () const
float	get_extrusion_role_estimated_time (EGCodeExtrusionRole role) const
size_t	get_options_count () const
const std::vector< EOptionType > &	get_options () const
float	get_travels_estimated_time () const
std::vector< float >	get_layers_estimated_times () const
size_t	get_tool_colors_count () const
const PaletteWithAlpha &	get_tool_colors () const
void	set_tool_colors (const PaletteWithAlpha &colors)
size_t	get_color_print_colors_count () const
const PaletteWithAlpha &	get_color_print_colors () const
void	set_color_print_colors (const PaletteWithAlpha &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 ()
const Color &	get_option_color (EOptionType type) const
void	set_option_color (EOptionType type, const Color &color)
void	reset_default_options_colors ()
const ColorRange &	get_color_range (EViewType type) const
void	set_color_range_palette (EViewType type, const Palette &palette)
float	get_travels_radius () const
void	set_travels_radius (float radius)
float	get_wipes_radius () const
void	set_wipes_radius (float radius)
size_t	get_used_cpu_memory () const
size_t	get_used_gpu_memory () const

Private Member Functions
void	apply_pending_updates ()
void	update_view_full_range ()
void	update_color_ranges ()
void	update_heights_widths ()
uint8_t	get_vertex_alpha (const PathVertex &v) const
void	render_segments (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix, const Vec3 &camera_position, bool translucent=false)
void	render_options (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix)
void	render_translucent_segments (const Mat4x4 &view_matrix, const Mat4x4 &projection_matrix, const Vec3 &camera_position)
void	set_layer_colors (const LayerColorsUniforms &uni) const

Private Attributes
Settings	m_settings
Layers	m_layers
ExtrusionRoles	m_extrusion_roles
std::vector< EOptionType >	m_options
std::map< uint8_t, std::vector< ColorPrint > >	m_used_extruders
ViewRange	m_view_range
std::array< float, TIME_MODES_COUNT >	m_total_time { 0.0f, 0.0f }
std::array< std::vector< float >, TIME_MODES_COUNT >	m_layer_start_times
std::vector< uint32_t >	m_layer_first_vertex
bool	m_layers_in_vertex_order { false }
std::array< float, TIME_MODES_COUNT >	m_travels_time { 0.0f, 0.0f }
float	m_travels_radius { DEFAULT_TRAVELS_RADIUS_MM }
float	m_wipes_radius { DEFAULT_WIPES_RADIUS_MM }
std::array< Color, size_t(EGCodeExtrusionRole::COUNT)>	m_extrusion_roles_colors
std::array< Color, size_t(EOptionType::COUNT)>	m_options_colors
bool	m_initialized { false }
SegmentTemplate	m_segment_template
OptionTemplate	m_option_template
std::vector< PathVertex >	m_vertices
std::vector< ColorWithAlpha >	m_vertices_colors
bool	m_has_translucent_colors { false }
size_t	m_enabled_translucent_segments_count { 0 }
BitSet	m_valid_lines_bitset
std::optional< Settings >	m_settings_used_for_ranges
ColorRange	m_height_range
ColorRange	m_width_range
ColorRange	m_speed_range
ColorRange	m_actual_speed_range
ColorRange	m_fan_speed_range
ColorRange	m_temperature_range
ColorRange	m_pressure_advance_range
ColorRange	m_acceleration_range
ColorRange	m_jerk_range
ColorRange	m_volumetric_rate_range
ColorRange	m_actual_volumetric_rate_range
std::array< ColorRange, COLOR_RANGE_TYPES_COUNT >	m_layer_time_range
PaletteWithAlpha	m_tool_colors
PaletteWithAlpha	m_color_print_colors
unsigned int	m_segments_shader_id { 0 }
unsigned int	m_segments_caster_shader_id { 0 }
unsigned int	m_segments_caster_vao_id { 0 }
unsigned int	m_options_shader_id { 0 }
SegmentsUniforms	m_uni_segments
SegmentsUniforms	m_uni_segments_caster
int	m_uni_segments_shadow_map_id { -1 }
int	m_uni_segments_shadow_light_vp_id { -1 }
int	m_uni_segments_shadow_intensity_id { -1 }
int	m_uni_segments_shadow_map_texel_id { -1 }
int	m_uni_segments_exposure_id { -1 }
int	m_uni_segments_saturation_id { -1 }
int	m_uni_segments_light_top_dir_id { -1 }
int	m_uni_segments_gloss_id { -1 }
LayerColorsUniforms	m_uni_segments_layer_colors
int	m_uni_options_view_matrix_id { -1 }
int	m_uni_options_projection_matrix_id { -1 }
int	m_uni_options_positions_tex_id { -1 }
int	m_uni_options_height_width_angle_tex_id { -1 }
int	m_uni_options_colors_tex_id { -1 }
int	m_uni_options_segment_index_tex_id { -1 }
int	m_uni_options_clipping_plane_id { -1 }
LayerColorsUniforms	m_uni_options_layer_colors
unsigned int	m_positions_buf_id { 0 }
unsigned int	m_positions_tex_id { 0 }
unsigned int	m_heights_widths_angles_buf_id { 0 }
unsigned int	m_heights_widths_angles_tex_id { 0 }
unsigned int	m_colors_buf_id { 0 }
unsigned int	m_colors_tex_id { 0 }
unsigned int	m_enabled_segments_buf_id { 0 }
unsigned int	m_enabled_segments_tex_id { 0 }
size_t	m_enabled_segments_count { 0 }
unsigned int	m_enabled_options_buf_id { 0 }
unsigned int	m_enabled_options_tex_id { 0 }
size_t	m_enabled_options_count { 0 }
size_t	m_positions_tex_size { 0 }
size_t	m_height_width_angle_tex_size { 0 }
size_t	m_colors_tex_size { 0 }
size_t	m_enabled_segments_tex_size { 0 }
size_t	m_enabled_options_tex_size { 0 }
int	m_shadow_map_texture_unit { 4 }
Mat4x4	m_shadow_light_vp { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }
float	m_shadow_intensity { 0.0f }
float	m_shadow_map_texel { 0.0f }
bool	m_rendering_shadow_casters { false }
float	m_exposure { 1.0f }
float	m_saturation { 1.0f }
Vec3	m_light_top_dir { -0.4574957f, 0.4574957f, 0.7624929f }
bool	m_gloss { true }
std::array< float, 4 >	m_clipping_plane { 0.0f, 0.0f, 0.0f, 1.0f }
AABox	m_extrusions_box { Vec3{ 0.0f, 0.0f, 0.0f }, Vec3{ 0.0f, 0.0f, 0.0f } }
TranslucentTargets	m_translucent_targets
unsigned int	m_translucent_composite_shader_id { 0 }
int	m_uni_translucent_composite_accum_tex_id { -1 }
int	m_uni_translucent_composite_reveal_tex_id { -1 }
int	m_uni_translucent_composite_front_tex_id { -1 }
int	m_uni_translucent_composite_origin_id { -1 }
int	m_uni_segments_oit_pass_id { -1 }
int	m_uni_segments_opaque_depth_id { -1 }
int	m_uni_segments_front_depth_id { -1 }
int	m_uni_segments_oit_depth_range_id { -1 }
unsigned int	m_segments_depth_shader_id { 0 }
SegmentsUniforms	m_uni_segments_depth
int	m_uni_segments_depth_opaque_depth_id { -1 }
std::array< float, 2 >	m_oit_depth_range { 0.0f, 1.0f }
int	m_translucent_pass { 0 }

Detailed Description

Constructor & Destructor Documentation

ViewerImpl() [1/3]

libvgcode::ViewerImpl::ViewerImpl

(

)

{
    reset_default_extrusion_roles_colors();
    reset_default_options_colors();
}

References reset_default_extrusion_roles_colors(), and reset_default_options_colors().

Referenced by ViewerImpl(), ViewerImpl(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~ViewerImpl()

libvgcode::ViewerImpl::~ViewerImpl ( )

inline

{ shutdown(); }

References shutdown().

Here is the call graph for this function:

ViewerImpl() [2/3]

libvgcode::ViewerImpl::ViewerImpl ( const ViewerImpl & other )

delete

References ViewerImpl().

Here is the call graph for this function:

ViewerImpl() [3/3]

libvgcode::ViewerImpl::ViewerImpl ( ViewerImpl && other )

delete

References ViewerImpl().

Here is the call graph for this function:

Member Function Documentation

apply_pending_updates()

void libvgcode::ViewerImpl::apply_pending_updates ( )

private

{
    if (m_settings.update_view_full_range)
        update_view_full_range();
 
    // ORCA: the colors first, which decide the order of the enabled segments
    if (m_settings.update_colors)
        update_colors();
 
    if (m_settings.update_enabled_entities)
        update_enabled_entities();
}

References m_settings, update_colors(), update_enabled_entities(), and update_view_full_range().

Referenced by render(), render_shadow_casters(), and render_translucent().

Here is the call graph for this function:

Here is the caller graph for this function:

get_bounding_box()

AABox libvgcode::ViewerImpl::get_bounding_box

(

const std::vector< EMoveType > &

types = { EMoveType::Retract, EMoveType::Unretract, EMoveType::Seam, EMoveType::ToolChange, EMoveType::ColorChange, EMoveType::PausePrint, EMoveType::CustomGCode, EMoveType::Travel, EMoveType::Wipe, EMoveType::Extrude }

)

const

{
    Vec3 min = { FLT_MAX, FLT_MAX, FLT_MAX };
    Vec3 max = { -FLT_MAX, -FLT_MAX, -FLT_MAX };
    for (const PathVertex& v : m_vertices) {
        if (std::find(types.begin(), types.end(), v.type) != types.end()) {
            for (int j = 0; j < 3; ++j) {
                min[j] = std::min(min[j], v.position[j]);
                max[j] = std::max(max[j], v.position[j]);
            }
        }
    }
    return { min, max };
}

References m_vertices.

Referenced by load().

Here is the caller graph for this function:

get_color_print_colors()

const PaletteWithAlpha & libvgcode::ViewerImpl::get_color_print_colors ( ) const

inline

{ return m_color_print_colors; }

References m_color_print_colors.

get_color_print_colors_count()

size_t libvgcode::ViewerImpl::get_color_print_colors_count ( ) const

inline

{ return m_color_print_colors.size(); }

References m_color_print_colors.

get_color_prints()

std::vector< ColorPrint > libvgcode::ViewerImpl::get_color_prints

(

uint8_t

extruder_id

)

const

{
    const auto it = m_used_extruders.find(extruder_id);
    return (it == m_used_extruders.end()) ? std::vector<ColorPrint>() : it->second;
}

References m_used_extruders.

get_color_prints_count()

size_t libvgcode::ViewerImpl::get_color_prints_count

(

uint8_t

extruder_id

)

const

{
    const auto it = m_used_extruders.find(extruder_id);
    return (it == m_used_extruders.end()) ? 0 : it->second.size();
}

References m_used_extruders.

get_color_range()

const ColorRange & libvgcode::ViewerImpl::get_color_range

(

EViewType

type

)

const

{
    switch (type)
    {
    case EViewType::Height:                   { return m_height_range; }
    case EViewType::Width:                    { return m_width_range; }
    case EViewType::Speed:                    { return m_speed_range; }
    case EViewType::ActualSpeed:              { return m_actual_speed_range; }
    case EViewType::FanSpeed:                 { return m_fan_speed_range; }
    case EViewType::Temperature:              { return m_temperature_range; }
// ORCA: Add Pressure Advance visualization support
    case EViewType::PressureAdvance:          { return m_pressure_advance_range; }
    // ORCA: Add Acceleration visualization support
    case EViewType::Acceleration:             { return m_acceleration_range; }
    // ORCA: Add Jerk visualization support
    case EViewType::Jerk:                     { return m_jerk_range; }
    case EViewType::VolumetricFlowRate:       { return m_volumetric_rate_range; }
    case EViewType::ActualVolumetricFlowRate: { return m_actual_volumetric_rate_range; }
    case EViewType::LayerTimeLinear:          { return m_layer_time_range[0]; }
    case EViewType::LayerTimeLogarithmic:     { return m_layer_time_range[1]; }
    default:                                  { return ColorRange::DUMMY_COLOR_RANGE; }
    }
}

References libvgcode::Acceleration, libvgcode::ActualSpeed, libvgcode::ActualVolumetricFlowRate, libvgcode::ColorRange::DUMMY_COLOR_RANGE, libvgcode::FanSpeed, libvgcode::Height, libvgcode::Jerk, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, m_acceleration_range, m_actual_speed_range, m_actual_volumetric_rate_range, m_fan_speed_range, m_height_range, m_jerk_range, m_layer_time_range, m_pressure_advance_range, m_speed_range, m_temperature_range, m_volumetric_rate_range, m_width_range, libvgcode::PressureAdvance, libvgcode::Speed, libvgcode::Temperature, libvgcode::VolumetricFlowRate, and libvgcode::Width.

get_current_vertex()

const PathVertex & libvgcode::ViewerImpl::get_current_vertex ( ) const

inline

{ return get_vertex_at(get_current_vertex_id()); }

References get_current_vertex_id(), and get_vertex_at().

Here is the call graph for this function:

get_current_vertex_id()

size_t libvgcode::ViewerImpl::get_current_vertex_id ( ) const

inline

{ return static_cast<size_t>(m_view_range.get_visible()[1]); }

References m_view_range.

Referenced by get_current_vertex().

Here is the caller graph for this function:

get_dim_previous_layers_brightness()

float libvgcode::ViewerImpl::get_dim_previous_layers_brightness ( ) const

inline

{ return m_settings.dim_previous_layers_brightness; }

References m_settings.

get_estimated_time()

float libvgcode::ViewerImpl::get_estimated_time ( ) const

inline

{ return m_total_time[static_cast<size_t>(m_settings.time_mode)]; }

References m_settings, and m_total_time.

get_estimated_time_at()

float libvgcode::ViewerImpl::get_estimated_time_at

(

size_t

id

)

const

{
    const size_t mode = static_cast<size_t>(m_settings.time_mode);
    if (mode >= TIME_MODES_COUNT || id >= m_vertices.size())
        return 0.0f;
    size_t first = 0;
    float time = 0.0f;
    const size_t layer = static_cast<size_t>(m_vertices[id].layer_id);
    if (layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] <= id) {
        first = m_layer_first_vertex[layer];
        time = m_layer_start_times[mode][layer];
    }
    for (size_t i = first; i <= id; ++i)
        time += m_vertices[i].times[mode];
    return time;
}

References m_layer_first_vertex, m_layer_start_times, m_settings, m_vertices, and libvgcode::TIME_MODES_COUNT.

get_extrusion_bounding_box()

AABox libvgcode::ViewerImpl::get_extrusion_bounding_box

(

const std::vector< EGCodeExtrusionRole > &

roles = { EGCodeExtrusionRole::Perimeter, EGCodeExtrusionRole::ExternalPerimeter, EGCodeExtrusionRole::OverhangPerimeter, EGCodeExtrusionRole::InternalInfill, EGCodeExtrusionRole::SolidInfill, EGCodeExtrusionRole::TopSolidInfill, EGCodeExtrusionRole::Ironing, EGCodeExtrusionRole::BridgeInfill, EGCodeExtrusionRole::GapFill, EGCodeExtrusionRole::Skirt, EGCodeExtrusionRole::SupportMaterial, EGCodeExtrusionRole::SupportMaterialInterface, EGCodeExtrusionRole::WipeTower, EGCodeExtrusionRole::Custom,  EGCodeExtrusionRole::BottomSurface, EGCodeExtrusionRole::InternalBridgeInfill, EGCodeExtrusionRole::Brim, EGCodeExtrusionRole::SupportTransition, EGCodeExtrusionRole::Mixed }

)

const

{
    Vec3 min = { FLT_MAX, FLT_MAX, FLT_MAX };
    Vec3 max = { -FLT_MAX, -FLT_MAX, -FLT_MAX };
    for (const PathVertex& v : m_vertices) {
        if (v.is_extrusion() && std::find(roles.begin(), roles.end(), v.role) != roles.end()) {
            for (int j = 0; j < 3; ++j) {
              min[j] = std::min(min[j], v.position[j]);
              max[j] = std::max(max[j], v.position[j]);
            }
        }
    }
    return { min, max };
}

References m_vertices.

get_extrusion_role_color()

const Color & libvgcode::ViewerImpl::get_extrusion_role_color

(

EGCodeExtrusionRole

role

)

const

{
    return m_extrusion_roles_colors[size_t(role)];
}

References m_extrusion_roles_colors.

Referenced by get_vertex_color().

Here is the caller graph for this function:

get_extrusion_role_estimated_time()

float libvgcode::ViewerImpl::get_extrusion_role_estimated_time ( EGCodeExtrusionRole role ) const

inline

{ return m_extrusion_roles.get_time(role, m_settings.time_mode); }

References m_extrusion_roles, and m_settings.

get_extrusion_roles()

std::vector< EGCodeExtrusionRole > libvgcode::ViewerImpl::get_extrusion_roles ( ) const

inline

{ return m_extrusion_roles.get_roles(); }

References m_extrusion_roles.

get_extrusion_roles_count()

size_t libvgcode::ViewerImpl::get_extrusion_roles_count ( ) const

inline

{ return m_extrusion_roles.get_roles_count(); }

References m_extrusion_roles.

get_layer_id_at()

size_t libvgcode::ViewerImpl::get_layer_id_at ( float z ) const

inline

{ return m_layers.get_layer_id_at(z); }

References m_layers.

get_layer_z()

float libvgcode::ViewerImpl::get_layer_z ( size_t layer_id ) const

inline

{ return m_layers.get_layer_z(layer_id); }

References m_layers.

get_layers_count()

size_t libvgcode::ViewerImpl::get_layers_count ( ) const

inline

{ return m_layers.count(); }

References m_layers.

get_layers_estimated_times()

std::vector< float > libvgcode::ViewerImpl::get_layers_estimated_times ( ) const

inline

{ return m_layers.get_times(m_settings.time_mode); }

References m_layers, and m_settings.

get_layers_view_range()

const Interval & libvgcode::ViewerImpl::get_layers_view_range ( ) const

inline

{ return m_layers.get_view_range(); }

References m_layers.

get_layers_zs()

std::vector< float > libvgcode::ViewerImpl::get_layers_zs ( ) const

inline

{ return m_layers.get_zs(); }

References m_layers.

get_option_color()

const Color & libvgcode::ViewerImpl::get_option_color

(

EOptionType

type

)

const

{
    return m_options_colors[size_t(type)];
}

References m_options_colors.

Referenced by get_vertex_color().

Here is the caller graph for this function:

get_options()

const std::vector< EOptionType > & libvgcode::ViewerImpl::get_options ( ) const

inline

{ return m_options; }

References m_options.

get_options_count()

size_t libvgcode::ViewerImpl::get_options_count ( ) const

inline

{ return m_options.size(); }

References m_options.

get_time_mode()

ETimeMode libvgcode::ViewerImpl::get_time_mode ( ) const

inline

{ return m_settings.time_mode; }

References m_settings.

get_time_modes()

std::vector< ETimeMode > libvgcode::ViewerImpl::get_time_modes

(

)

const

{
    std::vector<ETimeMode> ret;
    for (size_t i = 0; i < TIME_MODES_COUNT; ++i) {
        if (std::accumulate(m_vertices.begin(), m_vertices.end(), 0.0f,
            [i](float a, const PathVertex& v) { return a + v.times[i]; }) > 0.0f)
            ret.push_back(static_cast<ETimeMode>(i));
    }
    return ret;
}

References m_vertices, and libvgcode::TIME_MODES_COUNT.

get_tool_colors()

const PaletteWithAlpha & libvgcode::ViewerImpl::get_tool_colors ( ) const

inline

{ return m_tool_colors; }

References m_tool_colors.

get_tool_colors_count()

size_t libvgcode::ViewerImpl::get_tool_colors_count ( ) const

inline

{ return m_tool_colors.size(); }

References m_tool_colors.

get_travels_estimated_time()

float libvgcode::ViewerImpl::get_travels_estimated_time ( ) const

inline

{ return m_travels_time[static_cast<size_t>(m_settings.time_mode)]; }

References m_settings, and m_travels_time.

get_travels_radius()

float libvgcode::ViewerImpl::get_travels_radius ( ) const

inline

{ return m_travels_radius; }

References m_travels_radius.

get_used_cpu_memory()

size_t libvgcode::ViewerImpl::get_used_cpu_memory

(

)

const

{
    size_t ret = sizeof(*this);
    ret += m_layers.size_in_bytes_cpu();
    ret += STDVEC_MEMSIZE(m_options, EOptionType);
    ret += m_used_extruders.size() * sizeof(std::map<uint8_t, ColorPrint>::value_type);
    ret += sizeof(m_extrusion_roles_colors);
    ret += sizeof(m_options_colors);
    ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
    ret += STDVEC_MEMSIZE(m_vertices_colors, ColorWithAlpha);
    for (const std::vector<float>& times : m_layer_start_times)
        ret += STDVEC_MEMSIZE(times, float);
    ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);
    ret += m_valid_lines_bitset.size_in_bytes_cpu();
    ret += m_height_range.size_in_bytes_cpu();
    ret += m_width_range.size_in_bytes_cpu();
    ret += m_speed_range.size_in_bytes_cpu();
    ret += m_actual_speed_range.size_in_bytes_cpu();
    ret += m_fan_speed_range.size_in_bytes_cpu();
    ret += m_temperature_range.size_in_bytes_cpu();
    // ORCA: Add Pressure Advance visualization support
    ret += m_pressure_advance_range.size_in_bytes_cpu();
    // ORCA: Add Acceleration visualization support
    ret += m_acceleration_range.size_in_bytes_cpu();
    // ORCA: Add Jerk visualization support
    ret += m_jerk_range.size_in_bytes_cpu();
    ret += m_volumetric_rate_range.size_in_bytes_cpu();
    ret += m_actual_volumetric_rate_range.size_in_bytes_cpu();
    for (size_t i = 0; i < COLOR_RANGE_TYPES_COUNT; ++i) {
        ret += m_layer_time_range[i].size_in_bytes_cpu();
    }
    ret += STDVEC_MEMSIZE(m_tool_colors, ColorWithAlpha);
    ret += STDVEC_MEMSIZE(m_color_print_colors, ColorWithAlpha);
    return ret;
}

References libvgcode::COLOR_RANGE_TYPES_COUNT, m_acceleration_range, m_actual_speed_range, m_actual_volumetric_rate_range, m_color_print_colors, m_extrusion_roles_colors, m_fan_speed_range, m_height_range, m_jerk_range, m_layer_first_vertex, m_layer_start_times, m_layer_time_range, m_layers, m_options, m_options_colors, m_pressure_advance_range, m_speed_range, m_temperature_range, m_tool_colors, m_used_extruders, m_valid_lines_bitset, m_vertices, m_vertices_colors, m_volumetric_rate_range, m_width_range, and STDVEC_MEMSIZE.

get_used_extruders_count()

size_t libvgcode::ViewerImpl::get_used_extruders_count ( ) const

inline

{ return m_used_extruders.size(); }

References m_used_extruders.

get_used_extruders_ids()

std::vector< uint8_t > libvgcode::ViewerImpl::get_used_extruders_ids

(

)

const

{
    std::vector<uint8_t> ret;
    ret.reserve(m_used_extruders.size());
    for (const auto& [id, colors] : m_used_extruders) {
        ret.emplace_back(id);
    }
    return ret;
}

References m_used_extruders.

get_used_gpu_memory()

size_t libvgcode::ViewerImpl::get_used_gpu_memory

(

)

const

{
    size_t ret = 0;
    ret += m_segment_template.size_in_bytes_gpu();
    ret += m_option_template.size_in_bytes_gpu();
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    ret += m_tool_marker.size_in_bytes_gpu();
    ret += m_cog_marker.size_in_bytes_gpu();
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
#ifdef ENABLE_OPENGL_ES
    ret += m_texture_data.get_used_gpu_memory();
#else
    ret += m_positions_tex_size;
    ret += m_height_width_angle_tex_size;
    ret += m_colors_tex_size;
    ret += m_enabled_segments_tex_size;
    ret += m_enabled_options_tex_size;
    ret += m_translucent_targets.size_in_bytes();
#endif // ENABLE_OPENGL_ES
    return ret;
}

References m_colors_tex_size, m_enabled_options_tex_size, m_enabled_segments_tex_size, m_height_width_angle_tex_size, m_option_template, m_positions_tex_size, m_segment_template, and m_translucent_targets.

get_vertex_alpha()

uint8_t libvgcode::ViewerImpl::get_vertex_alpha ( const PathVertex & v ) const

private

{
    if (!m_settings.translucent_filaments || !v.is_extrusion())
        return 255;
 
    switch (m_settings.view_type)
    {
    case EViewType::Tool:
        return m_tool_colors[v.extruder_id][3];
    case EViewType::Summary:
    case EViewType::ColorPrint:
        return m_layers.layer_contains_colorprint_options(static_cast<size_t>(v.layer_id)) ? 255 :
            m_color_print_colors[static_cast<size_t>(v.color_id) % m_color_print_colors.size()][3];
    default:
        return 255;
    }
}

References libvgcode::PathVertex::color_id, libvgcode::ColorPrint, libvgcode::PathVertex::extruder_id, libvgcode::PathVertex::is_extrusion(), libvgcode::PathVertex::layer_id, m_color_print_colors, m_layers, m_settings, m_tool_colors, libvgcode::Summary, and libvgcode::Tool.

Referenced by update_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

get_vertex_at()

const PathVertex & libvgcode::ViewerImpl::get_vertex_at ( size_t id ) const

inline

                                                     {
        return (id < m_vertices.size()) ? m_vertices[id] : PathVertex::DUMMY_PATH_VERTEX;
    }

References libvgcode::PathVertex::DUMMY_PATH_VERTEX, and m_vertices.

Referenced by get_current_vertex().

Here is the caller graph for this function:

get_vertex_color()

Color libvgcode::ViewerImpl::get_vertex_color

(

const PathVertex &

vertex

)

const

{
    if (v.type == EMoveType::Noop)
        return DUMMY_COLOR;
 
    if ((v.is_wipe() && (m_settings.view_type != EViewType::Speed && m_settings.view_type != EViewType::ActualSpeed && m_settings.view_type != EViewType::Acceleration && m_settings.view_type != EViewType::Jerk)) || v.is_option())
        return get_option_color(move_type_to_option(v.type));
 
    switch (m_settings.view_type)
    {
    case EViewType::FeatureType:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : get_extrusion_role_color(v.role);
    }
    case EViewType::Height:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_height_range.get_color_at(v.height);
    }
    case EViewType::Width:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_width_range.get_color_at(v.width);
    }
    case EViewType::Speed:
    {
        return m_speed_range.get_color_at(v.feedrate);
    }
    case EViewType::ActualSpeed:
    {
        return m_actual_speed_range.get_color_at(v.actual_feedrate);
    }
    case EViewType::FanSpeed:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_fan_speed_range.get_color_at(v.fan_speed);
    }
    case EViewType::Temperature:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_temperature_range.get_color_at(v.temperature);
    }
// ORCA: Add Pressure Advance visualization support
    case EViewType::PressureAdvance:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_pressure_advance_range.get_color_at(v.pressure_advance);
    }
    // ORCA: Add Acceleration visualization support
    case EViewType::Acceleration:
    {
        return m_acceleration_range.get_color_at(v.acceleration);
    }
    // ORCA: Add Jerk visualization support
    case EViewType::Jerk:
    {
        return m_jerk_range.get_color_at(v.jerk);
    }
    case EViewType::VolumetricFlowRate:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_volumetric_rate_range.get_color_at(v.volumetric_rate());
    }
    case EViewType::ActualVolumetricFlowRate:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) : m_actual_volumetric_rate_range.get_color_at(v.actual_volumetric_rate());
    }
    case EViewType::LayerTimeLinear:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) :
            m_layer_time_range[0].get_color_at(m_layers.get_layer_time(m_settings.time_mode, static_cast<size_t>(v.layer_id)));
    }
    case EViewType::LayerTimeLogarithmic:
    {
        return v.is_travel() ? get_option_color(move_type_to_option(v.type)) :
            m_layer_time_range[1].get_color_at(m_layers.get_layer_time(m_settings.time_mode, static_cast<size_t>(v.layer_id)));
    }
    case EViewType::Tool:
    {
        assert(static_cast<size_t>(v.extruder_id) < m_tool_colors.size());
        const ColorWithAlpha& color = m_tool_colors[v.extruder_id];
        return { color[0], color[1], color[2] };
    }
    case EViewType::Summary: // ORCA
    case EViewType::ColorPrint:
    {
        if (m_layers.layer_contains_colorprint_options(static_cast<size_t>(v.layer_id)))
            return DUMMY_COLOR;
        const ColorWithAlpha& color = m_color_print_colors[static_cast<size_t>(v.color_id) % m_color_print_colors.size()];
        return { color[0], color[1], color[2] };
    }
    default: { break; }
    }
 
    return DUMMY_COLOR;
}

References libvgcode::Acceleration, libvgcode::PathVertex::acceleration, libvgcode::PathVertex::actual_feedrate, libvgcode::PathVertex::actual_volumetric_rate(), libvgcode::ActualSpeed, libvgcode::ActualVolumetricFlowRate, libvgcode::PathVertex::color_id, libvgcode::ColorPrint, libvgcode::DUMMY_COLOR, libvgcode::PathVertex::extruder_id, libvgcode::PathVertex::fan_speed, libvgcode::FanSpeed, libvgcode::FeatureType, libvgcode::PathVertex::feedrate, get_extrusion_role_color(), get_option_color(), libvgcode::Height, libvgcode::PathVertex::height, libvgcode::PathVertex::is_option(), libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), libvgcode::Jerk, libvgcode::PathVertex::jerk, libvgcode::PathVertex::layer_id, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, m_acceleration_range, m_actual_speed_range, m_actual_volumetric_rate_range, m_color_print_colors, m_fan_speed_range, m_height_range, m_jerk_range, m_layer_time_range, m_layers, m_pressure_advance_range, m_settings, m_speed_range, m_temperature_range, m_tool_colors, m_volumetric_rate_range, m_width_range, libvgcode::move_type_to_option(), libvgcode::Noop, libvgcode::PathVertex::pressure_advance, libvgcode::PressureAdvance, libvgcode::PathVertex::role, libvgcode::Speed, libvgcode::Summary, libvgcode::Temperature, libvgcode::PathVertex::temperature, libvgcode::Tool, libvgcode::PathVertex::type, libvgcode::PathVertex::volumetric_rate(), libvgcode::VolumetricFlowRate, libvgcode::Width, and libvgcode::PathVertex::width.

Referenced by update_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

get_vertices_count()

size_t libvgcode::ViewerImpl::get_vertices_count ( ) const

inline

{ return m_vertices.size(); }

References m_vertices.

get_view_enabled_range()

const Interval & libvgcode::ViewerImpl::get_view_enabled_range ( ) const

inline

{ return m_view_range.get_enabled(); }

References m_view_range.

get_view_full_range()

const Interval & libvgcode::ViewerImpl::get_view_full_range ( ) const

inline

{ return m_view_range.get_full(); }

References m_view_range.

get_view_type()

EViewType libvgcode::ViewerImpl::get_view_type ( ) const

inline

{ return m_settings.view_type; }

References m_settings.

get_view_visible_range()

const Interval & libvgcode::ViewerImpl::get_view_visible_range ( ) const

inline

{ return m_view_range.get_visible(); }

References m_view_range.

get_wipes_radius()

float libvgcode::ViewerImpl::get_wipes_radius ( ) const

inline

{ return m_wipes_radius; }

References m_wipes_radius.

has_translucent_toolpaths()

bool libvgcode::ViewerImpl::has_translucent_toolpaths ( ) const

inline

{ return m_enabled_translucent_segments_count > 0; }

References m_enabled_translucent_segments_count.

init()

void libvgcode::ViewerImpl::init

(

const std::string &

opengl_context_version

)

{
    if (m_initialized)
        return;
 
    if (!OpenGLWrapper::load_opengl(opengl_context_version)) {
        if (OpenGLWrapper::is_valid_context())
            throw std::runtime_error("LibVGCode was unable to initialize the GLAD library.\n");
        else {
#ifdef ENABLE_OPENGL_ES
            throw std::runtime_error("LibVGCode requires an OpenGL ES context based on OpenGL ES 3.0 or higher.\n");
#else
            throw std::runtime_error("LibVGCode requires an OpenGL context based on OpenGL 3.2 or higher.\n");
#endif // ENABLE_OPENGL_ES
        }
    }
 
    // segments shader
#ifdef ENABLE_OPENGL_ES
    m_segments_shader_id = init_shader("segments", Segments_Vertex_Shader_ES, Segments_Fragment_Shader_ES);
#else
    m_segments_shader_id = init_shader("segments", Segments_Vertex_Shader, Segments_Fragment_Shader, { "fragment_color", "oit_reveal", "oit_front" });
    m_uni_segments_oit_pass_id        = glGetUniformLocation(m_segments_shader_id, "oit_pass");
    m_uni_segments_opaque_depth_id    = glGetUniformLocation(m_segments_shader_id, "opaque_depth");
    m_uni_segments_front_depth_id     = glGetUniformLocation(m_segments_shader_id, "front_depth");
    m_uni_segments_oit_depth_range_id = glGetUniformLocation(m_segments_shader_id, "oit_depth_range");
    m_translucent_composite_shader_id = init_shader("translucent_composite", Translucent_Composite_Vertex_Shader, Translucent_Composite_Fragment_Shader);
    m_uni_translucent_composite_accum_tex_id  = glGetUniformLocation(m_translucent_composite_shader_id, "accum_tex");
    m_uni_translucent_composite_reveal_tex_id = glGetUniformLocation(m_translucent_composite_shader_id, "reveal_tex");
    m_uni_translucent_composite_front_tex_id  = glGetUniformLocation(m_translucent_composite_shader_id, "front_tex");
    m_uni_translucent_composite_origin_id     = glGetUniformLocation(m_translucent_composite_shader_id, "origin");
    const std::string depth_vs = with_define(Segments_Vertex_Shader, "DEPTH_ONLY");
    const std::string depth_fs = with_define(Segments_Fragment_Shader, "DEPTH_ONLY");
    m_segments_depth_shader_id = init_shader("segments_depth", depth_vs.c_str(), depth_fs.c_str(), { "fragment_color", "oit_reveal", "oit_front" });
    m_uni_segments_depth.init(m_segments_depth_shader_id);
    m_uni_segments_depth_opaque_depth_id = glGetUniformLocation(m_segments_depth_shader_id, "opaque_depth");
#endif // ENABLE_OPENGL_ES
 
    m_uni_segments.init(m_segments_shader_id);
    // ORCA: realistic view
    m_uni_segments_shadow_map_id             = glGetUniformLocation(m_segments_shader_id, "shadow_map");
    m_uni_segments_shadow_light_vp_id        = glGetUniformLocation(m_segments_shader_id, "shadow_light_vp");
    m_uni_segments_shadow_intensity_id       = glGetUniformLocation(m_segments_shader_id, "shadow_intensity");
    m_uni_segments_shadow_map_texel_id       = glGetUniformLocation(m_segments_shader_id, "shadow_map_texel");
    m_uni_segments_exposure_id               = glGetUniformLocation(m_segments_shader_id, "exposure");
    m_uni_segments_saturation_id             = glGetUniformLocation(m_segments_shader_id, "saturation");
    m_uni_segments_light_top_dir_id          = glGetUniformLocation(m_segments_shader_id, "light_top_dir");
    m_uni_segments_gloss_id                  = glGetUniformLocation(m_segments_shader_id, "gloss_strength");
    m_uni_segments_layer_colors.init(m_segments_shader_id);
    glcheck();
    assert(m_uni_segments.view_matrix != -1 &&
           m_uni_segments.projection_matrix != -1 &&
           m_uni_segments.camera_position != -1 &&
           m_uni_segments.positions_tex != -1 &&
           m_uni_segments.height_width_angle_tex != -1 &&
           m_uni_segments.colors_tex != -1 &&
           m_uni_segments.segment_index_tex != -1 &&
           m_uni_segments.reverse_order != -1 &&
           m_uni_segments.instances_count != -1);
 
    // ORCA: realistic view
#ifdef ENABLE_OPENGL_ES
    m_segments_caster_shader_id = init_shader("segments_shadow_caster", Segments_Shadow_Caster_Vertex_Shader_ES, Segments_Shadow_Caster_Fragment_Shader_ES);
#else
    m_segments_caster_shader_id = init_shader("segments_shadow_caster", Segments_Shadow_Caster_Vertex_Shader, Segments_Shadow_Caster_Fragment_Shader);
#endif // ENABLE_OPENGL_ES
    m_uni_segments_caster.init(m_segments_caster_shader_id);
    // The caster pulls its vertices from gl_VertexID, but a core profile needs a vertex array bound to draw.
    glsafe(glGenVertexArrays(1, &m_segments_caster_vao_id));
    glcheck();
 
    m_segment_template.init();
 
    // options shader
#ifdef ENABLE_OPENGL_ES
    m_options_shader_id = init_shader("options", Options_Vertex_Shader_ES, Options_Fragment_Shader_ES);
#else
    m_options_shader_id = init_shader("options", Options_Vertex_Shader, Options_Fragment_Shader);
#endif // ENABLE_OPENGL_ES
 
    m_uni_options_view_matrix_id            = glGetUniformLocation(m_options_shader_id, "view_matrix");
    m_uni_options_projection_matrix_id      = glGetUniformLocation(m_options_shader_id, "projection_matrix");
    m_uni_options_positions_tex_id          = glGetUniformLocation(m_options_shader_id, "position_tex");
    m_uni_options_height_width_angle_tex_id = glGetUniformLocation(m_options_shader_id, "height_width_angle_tex");
    m_uni_options_colors_tex_id             = glGetUniformLocation(m_options_shader_id, "color_tex");
    m_uni_options_segment_index_tex_id      = glGetUniformLocation(m_options_shader_id, "segment_index_tex");
    // ORCA: section view
    m_uni_options_clipping_plane_id         = glGetUniformLocation(m_options_shader_id, "clipping_plane");
    m_uni_options_layer_colors.init(m_options_shader_id);
    glcheck();
    assert(m_uni_options_view_matrix_id != -1 &&
           m_uni_options_projection_matrix_id != -1 &&
           m_uni_options_positions_tex_id != -1 &&
           m_uni_options_height_width_angle_tex_id != -1 &&
           m_uni_options_colors_tex_id != -1 &&
           m_uni_options_segment_index_tex_id != -1);
 
    m_option_template.init(16);
 
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    // cog marker shader
#ifdef ENABLE_OPENGL_ES
    m_cog_marker_shader_id = init_shader("cog_marker", Cog_Marker_Vertex_Shader_ES, Cog_Marker_Fragment_Shader_ES);
#else
    m_cog_marker_shader_id = init_shader("cog_marker", Cog_Marker_Vertex_Shader, Cog_Marker_Fragment_Shader);
#endif // ENABLE_OPENGL_ES
 
    m_uni_cog_marker_world_center_position = glGetUniformLocation(m_cog_marker_shader_id, "world_center_position");
    m_uni_cog_marker_scale_factor          = glGetUniformLocation(m_cog_marker_shader_id, "scale_factor");
    m_uni_cog_marker_view_matrix           = glGetUniformLocation(m_cog_marker_shader_id, "view_matrix");
    m_uni_cog_marker_projection_matrix     = glGetUniformLocation(m_cog_marker_shader_id, "projection_matrix");
    glcheck();
    assert(m_uni_cog_marker_world_center_position != -1 &&
           m_uni_cog_marker_scale_factor != -1 &&
           m_uni_cog_marker_view_matrix != -1 &&
           m_uni_cog_marker_projection_matrix != -1);
 
    m_cog_marker.init(32, 1.0f);
 
    // tool marker shader
#ifdef ENABLE_OPENGL_ES
    m_tool_marker_shader_id = init_shader("tool_marker", Tool_Marker_Vertex_Shader_ES, Tool_Marker_Fragment_Shader_ES);
#else
    m_tool_marker_shader_id = init_shader("tool_marker", Tool_Marker_Vertex_Shader, Tool_Marker_Fragment_Shader);
#endif // ENABLE_OPENGL_ES
 
    m_uni_tool_marker_world_origin      = glGetUniformLocation(m_tool_marker_shader_id, "world_origin");
    m_uni_tool_marker_scale_factor      = glGetUniformLocation(m_tool_marker_shader_id, "scale_factor");
    m_uni_tool_marker_view_matrix       = glGetUniformLocation(m_tool_marker_shader_id, "view_matrix");
    m_uni_tool_marker_projection_matrix = glGetUniformLocation(m_tool_marker_shader_id, "projection_matrix");
    m_uni_tool_marker_color_base        = glGetUniformLocation(m_tool_marker_shader_id, "color_base");
 
    glcheck();
    assert(m_uni_tool_marker_world_origin != -1 &&
           m_uni_tool_marker_scale_factor != -1 &&
           m_uni_tool_marker_view_matrix != -1 &&
           m_uni_tool_marker_projection_matrix != -1 &&
           m_uni_tool_marker_color_base != -1);
 
    m_tool_marker.init(32, 2.0f, 4.0f, 1.0f, 8.0f);
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
 
    m_initialized = true;
}

References glcheck, glGenVertexArrays, glGetUniformLocation, glsafe, libvgcode::init_shader(), libvgcode::OpenGLWrapper::is_valid_context(), libvgcode::OpenGLWrapper::load_opengl(), m_initialized, m_option_template, m_options_shader_id, m_segment_template, m_segments_caster_shader_id, m_segments_caster_vao_id, m_segments_depth_shader_id, m_segments_shader_id, m_translucent_composite_shader_id, m_uni_options_clipping_plane_id, m_uni_options_colors_tex_id, m_uni_options_height_width_angle_tex_id, m_uni_options_layer_colors, m_uni_options_positions_tex_id, m_uni_options_projection_matrix_id, m_uni_options_segment_index_tex_id, m_uni_options_view_matrix_id, m_uni_segments, m_uni_segments_caster, m_uni_segments_depth, m_uni_segments_depth_opaque_depth_id, m_uni_segments_exposure_id, m_uni_segments_front_depth_id, m_uni_segments_gloss_id, m_uni_segments_layer_colors, m_uni_segments_light_top_dir_id, m_uni_segments_oit_depth_range_id, m_uni_segments_oit_pass_id, m_uni_segments_opaque_depth_id, m_uni_segments_saturation_id, m_uni_segments_shadow_intensity_id, m_uni_segments_shadow_light_vp_id, m_uni_segments_shadow_map_id, m_uni_segments_shadow_map_texel_id, m_uni_translucent_composite_accum_tex_id, m_uni_translucent_composite_front_tex_id, m_uni_translucent_composite_origin_id, m_uni_translucent_composite_reveal_tex_id, libvgcode::Options_Fragment_Shader, libvgcode::Options_Fragment_Shader_ES, libvgcode::Options_Vertex_Shader, libvgcode::Options_Vertex_Shader_ES, libvgcode::Segments_Fragment_Shader, libvgcode::Segments_Fragment_Shader_ES, libvgcode::Segments_Shadow_Caster_Fragment_Shader, libvgcode::Segments_Shadow_Caster_Fragment_Shader_ES, libvgcode::Segments_Shadow_Caster_Vertex_Shader, libvgcode::Segments_Shadow_Caster_Vertex_Shader_ES, libvgcode::Segments_Vertex_Shader, libvgcode::Segments_Vertex_Shader_ES, libvgcode::Translucent_Composite_Fragment_Shader, libvgcode::Translucent_Composite_Vertex_Shader, and libvgcode::with_define().

Here is the call graph for this function:

is_dim_previous_layers()

bool libvgcode::ViewerImpl::is_dim_previous_layers ( ) const

inline

{ return m_settings.dim_previous_layers; }

References m_settings.

is_extrusion_role_visible()

bool libvgcode::ViewerImpl::is_extrusion_role_visible

(

EGCodeExtrusionRole

role

)

const

{
    return m_settings.extrusion_roles_visibility[size_t(role)];
}

References m_settings.

is_option_visible()

bool libvgcode::ViewerImpl::is_option_visible

(

EOptionType

type

)

const

{
    return m_settings.options_visibility[size_t(type)];
}

References m_settings.

is_spiral_vase_mode()

bool libvgcode::ViewerImpl::is_spiral_vase_mode ( ) const

inline

{ return m_settings.spiral_vase_mode; }

References m_settings.

is_top_layer_only_view_range()

bool libvgcode::ViewerImpl::is_top_layer_only_view_range ( ) const

inline

{ return m_settings.top_layer_only_view_range; }

References m_settings.

is_translucent_filaments()

bool libvgcode::ViewerImpl::is_translucent_filaments ( ) const

inline

{ return m_settings.translucent_filaments; }

References m_settings.

load()

void libvgcode::ViewerImpl::load

(

GCodeInputData &&

gcode_data

)

{
    if (!m_initialized)
        return;
 
    if (gcode_data.vertices.empty())
        return;
 
    reset();
 
    m_vertices = std::move(gcode_data.vertices);
    m_tool_colors = std::move(gcode_data.tools_colors);
    m_color_print_colors = std::move(gcode_data.color_print_colors);
    m_vertices_colors.resize(m_vertices.size());
 
    m_settings.spiral_vase_mode = gcode_data.spiral_vase_mode;
 
    m_extrusions_box = get_bounding_box({ EMoveType::Extrude });
    for (size_t i = 0; i < m_vertices.size(); ++i) {
        const PathVertex& v = m_vertices[i];
 
        m_layers.update(v, static_cast<uint32_t>(i));
 
        for (size_t j = 0; j < TIME_MODES_COUNT; ++j) {
            m_total_time[j] += v.times[j];
            if (v.type == EMoveType::Travel)
                m_travels_time[j] += v.times[j];
        }
 
        const EOptionType option_type = move_type_to_option(v.type);
        if (option_type != EOptionType::COUNT)
            m_options.emplace_back(option_type);
 
        if (v.type == EMoveType::Extrude) {
            m_extrusion_roles.add(v.role, v.times);
 
            auto estruder_it = m_used_extruders.find(v.extruder_id);
            if (estruder_it == m_used_extruders.end())
                estruder_it = m_used_extruders.insert({ v.extruder_id, std::vector<ColorPrint>() }).first;
            if (estruder_it->second.empty() || estruder_it->second.back().color_id != v.color_id) {
                const ColorPrint cp = { v.extruder_id, v.color_id, v.layer_id, m_total_time };
                estruder_it->second.emplace_back(cp);
            }
        }
 
        if (i > 0) {
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
            // updates calculation for center of gravity
            if (v.type == EMoveType::Extrude &&
                v.role != EGCodeExtrusionRole::Skirt &&
                v.role != EGCodeExtrusionRole::SupportMaterial &&
                v.role != EGCodeExtrusionRole::SupportMaterialInterface &&
                v.role != EGCodeExtrusionRole::WipeTower &&
                v.role != EGCodeExtrusionRole::Custom &&
                v.role != EGCodeExtrusionRole::Brim &&
                v.role != EGCodeExtrusionRole::SupportTransition) {
                m_cog_marker.update(0.5f * (v.position + m_vertices[i - 1].position), v.weight);
            }
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
        }
    }
 
    // Populate layer_duration for each vertex from the accumulated layer times
    for (PathVertex& v : m_vertices) {
        v.layer_duration = m_layers.get_layer_time(m_settings.time_mode, static_cast<size_t>(v.layer_id));
    }
 
    // Index of the first vertex of each layer, walked back to front so that a layer with no
    // vertex of its own inherits the next layer's index and the array stays non-decreasing.
    if (!m_layers.empty()) {
        const uint32_t vertices_count = static_cast<uint32_t>(m_vertices.size());
        m_layer_first_vertex.assign(m_layers.count(), vertices_count);
        for (uint32_t i = vertices_count; i > 0; --i) {
            const uint32_t layer_id = m_vertices[i - 1].layer_id;
            if (layer_id < m_layer_first_vertex.size())
                m_layer_first_vertex[layer_id] = i - 1;
        }
        for (size_t i = m_layer_first_vertex.size() - 1; i > 0; --i)
            m_layer_first_vertex[i - 1] = std::min(m_layer_first_vertex[i - 1], m_layer_first_vertex[i]);
        m_layers_in_vertex_order = std::is_sorted(m_vertices.begin(), m_vertices.end(),
            [](const PathVertex& a, const PathVertex& b) { return a.layer_id < b.layer_id; });
 
        // the running time at each layer's first vertex, summed in vertex order so that
        // get_estimated_time_at() matches a full accumulation exactly
        std::array<float, TIME_MODES_COUNT> running{};
        for (std::vector<float>& times : m_layer_start_times)
            times.assign(m_layer_first_vertex.size(), 0.0f);
        size_t layer = 0;
        for (size_t i = 0; i <= m_vertices.size(); ++i) {
            for (; layer < m_layer_first_vertex.size() && m_layer_first_vertex[layer] == i; ++layer) {
                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
                    m_layer_start_times[j][layer] = running[j];
            }
            if (i < m_vertices.size()) {
                for (size_t j = 0; j < TIME_MODES_COUNT; ++j)
                    running[j] += m_vertices[i].times[j];
            }
        }
    }
 
    if (!m_layers.empty())
        m_layers.set_view_range(0, static_cast<uint32_t>(m_layers.count()) - 1);
 
    std::sort(m_options.begin(), m_options.end());
    m_options.erase(std::unique(m_options.begin(), m_options.end()), m_options.end());
    m_options.shrink_to_fit();
 
    // reset segments visibility bitset
    m_valid_lines_bitset = BitSet<>(m_vertices.size());
    m_valid_lines_bitset.setAll();
 
    if (m_settings.time_mode != ETimeMode::Normal && m_total_time[static_cast<size_t>(m_settings.time_mode)] == 0.0f)
        m_settings.time_mode = ETimeMode::Normal;
 
    // buffers to send to gpu
    // the last component is a dummy float to comply with GL_RGBA32F format
    std::vector<Vec4> positions;
    std::vector<Vec4> heights_widths_angles;
    positions.reserve(m_vertices.size());
    heights_widths_angles.reserve(m_vertices.size());
    extract_pos_and_or_hwa(m_vertices, m_travels_radius, m_wipes_radius, m_valid_lines_bitset, &positions, &heights_widths_angles, true);
 
    if (!positions.empty()) {
#ifdef ENABLE_OPENGL_ES
        m_texture_data.init(positions.size());
        // create and fill position textures
        m_texture_data.set_positions(positions);
        // create and fill height, width and angle textures
        m_texture_data.set_heights_widths_angles(heights_widths_angles);
#else
        m_positions_tex_size = positions.size() * sizeof(Vec3);
        m_height_width_angle_tex_size = heights_widths_angles.size() * sizeof(Vec3);
 
        int old_bound_texture = 0;
        glsafe(glGetIntegerv(GL_TEXTURE_BINDING_BUFFER, &old_bound_texture));
 
        // create and fill positions buffer
        glsafe(glGenBuffers(1, &m_positions_buf_id));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_positions_buf_id));
        glsafe(glBufferData(GL_TEXTURE_BUFFER, positions.size() * sizeof(Vec4), positions.data(), GL_STATIC_DRAW));
        glsafe(glGenTextures(1, &m_positions_tex_id));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_positions_tex_id));
 
        // create and fill height, width and angles buffer
        glsafe(glGenBuffers(1, &m_heights_widths_angles_buf_id));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_heights_widths_angles_buf_id));
        glsafe(glBufferData(GL_TEXTURE_BUFFER, heights_widths_angles.size() * sizeof(Vec4), heights_widths_angles.data(), GL_DYNAMIC_DRAW));
        glsafe(glGenTextures(1, &m_heights_widths_angles_tex_id));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_heights_widths_angles_tex_id));
 
        // create (but do not fill) colors buffer (data is set in update_colors())
        glsafe(glGenBuffers(1, &m_colors_buf_id));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_colors_buf_id));
        glsafe(glGenTextures(1, &m_colors_tex_id));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_colors_tex_id));
 
        // create (but do not fill) enabled segments buffer (data is set in update_enabled_entities())
        glsafe(glGenBuffers(1, &m_enabled_segments_buf_id));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_segments_buf_id));
        glsafe(glGenTextures(1, &m_enabled_segments_tex_id));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_segments_tex_id));
 
        // create (but do not fill) enabled options buffer (data is set in update_enabled_entities())
        glsafe(glGenBuffers(1, &m_enabled_options_buf_id));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_options_buf_id));
        glsafe(glGenTextures(1, &m_enabled_options_tex_id));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_options_tex_id));
 
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, old_bound_texture));
#endif // ENABLE_OPENGL_ES
    }
 
    update_view_full_range();
    m_view_range.set_visible(m_view_range.get_enabled());
    update_colors();
    update_enabled_entities();
}

References libvgcode::Brim, libvgcode::PathVertex::color_id, libvgcode::COUNT, libvgcode::Custom, libvgcode::extract_pos_and_or_hwa(), libvgcode::Extrude, libvgcode::PathVertex::extruder_id, get_bounding_box(), GL_DYNAMIC_DRAW, GL_STATIC_DRAW, GL_TEXTURE_BINDING_BUFFER, GL_TEXTURE_BUFFER, glBindBuffer, glBindTexture, glBufferData, glGenBuffers, glGenTextures, glGetIntegerv, glsafe, libvgcode::PathVertex::layer_id, m_color_print_colors, m_colors_buf_id, m_colors_tex_id, m_enabled_options_buf_id, m_enabled_options_tex_id, m_enabled_segments_buf_id, m_enabled_segments_tex_id, m_extrusion_roles, m_extrusions_box, m_height_width_angle_tex_size, m_heights_widths_angles_buf_id, m_heights_widths_angles_tex_id, m_initialized, m_layer_first_vertex, m_layer_start_times, m_layers, m_layers_in_vertex_order, m_options, m_positions_buf_id, m_positions_tex_id, m_positions_tex_size, m_settings, m_tool_colors, m_total_time, m_travels_radius, m_travels_time, m_used_extruders, m_valid_lines_bitset, m_vertices, m_vertices_colors, m_view_range, m_wipes_radius, libvgcode::move_type_to_option(), libvgcode::Normal, libvgcode::PathVertex::position, reset(), libvgcode::PathVertex::role, libvgcode::Skirt, libvgcode::SupportMaterial, libvgcode::SupportMaterialInterface, libvgcode::SupportTransition, libvgcode::TIME_MODES_COUNT, libvgcode::PathVertex::times, libvgcode::Travel, libvgcode::PathVertex::type, update_colors(), update_enabled_entities(), update_view_full_range(), and libvgcode::WipeTower.

Here is the call graph for this function:

operator=() [1/2]

ViewerImpl & libvgcode::ViewerImpl::operator= ( const ViewerImpl & other )

delete

References ViewerImpl().

Here is the call graph for this function:

operator=() [2/2]

ViewerImpl & libvgcode::ViewerImpl::operator= ( ViewerImpl && other )

delete

References ViewerImpl().

Here is the call graph for this function:

render()

void libvgcode::ViewerImpl::render	(	const Mat4x4 &	view_matrix,
		const Mat4x4 &	projection_matrix )

{
    apply_pending_updates();
 
    const Mat4x4 inv_view_matrix = inverse(view_matrix);
    const Vec3 camera_position = { inv_view_matrix[12], inv_view_matrix[13], inv_view_matrix[14] };
    render_segments(view_matrix, projection_matrix, camera_position);
    render_options(view_matrix, projection_matrix);
 
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    if (m_settings.options_visibility[size_t(EOptionType::ToolMarker)])
        render_tool_marker(view_matrix, projection_matrix);
    if (m_settings.options_visibility[size_t(EOptionType::CenterOfGravity)])
        render_cog_marker(view_matrix, projection_matrix);
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
}

References apply_pending_updates(), libvgcode::inverse(), m_settings, render_options(), and render_segments().

Here is the call graph for this function:

render_options()

void libvgcode::ViewerImpl::render_options ( const Mat4x4 & view_matrix, const Mat4x4 & projection_matrix )

private

{
    if (m_options_shader_id == 0)
        return;
 
#ifdef ENABLE_OPENGL_ES
    if (m_texture_data.get_enabled_options_count() == 0)
#else
    if (m_enabled_options_count == 0)
#endif // ENABLE_OPENGL_ES
        return;
 
    int curr_active_texture = 0;
    glsafe(glGetIntegerv(GL_ACTIVE_TEXTURE, &curr_active_texture));
    int curr_shader;
    glsafe(glGetIntegerv(GL_CURRENT_PROGRAM, &curr_shader));
    const bool curr_cull_face = glIsEnabled(GL_CULL_FACE);
    glcheck();
 
    glsafe(glUseProgram(m_options_shader_id));
 
    glsafe(glUniform1i(m_uni_options_positions_tex_id, 0));
    glsafe(glUniform1i(m_uni_options_height_width_angle_tex_id, 1));
    glsafe(glUniform1i(m_uni_options_colors_tex_id, 2));
    glsafe(glUniform1i(m_uni_options_segment_index_tex_id, 3));
    glsafe(glUniformMatrix4fv(m_uni_options_view_matrix_id, 1, GL_FALSE, view_matrix.data()));
    glsafe(glUniformMatrix4fv(m_uni_options_projection_matrix_id, 1, GL_FALSE, projection_matrix.data()));
    glsafe(glUniform4fv(m_uni_options_clipping_plane_id, 1, m_clipping_plane.data()));
    set_layer_colors(m_uni_options_layer_colors);
 
    glsafe(glEnable(GL_CULL_FACE));
 
#ifdef ENABLE_OPENGL_ES
    int curr_bound_texture = 0;
    glsafe(glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_bound_texture));
 
    for (size_t i = 0; i < m_texture_data.get_count(); ++i) {
        const auto [id, count] = m_texture_data.get_enabled_options_tex_id(i);
        if (count == 0)
            continue;
        glsafe(glActiveTexture(GL_TEXTURE0));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_positions_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE1));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_heights_widths_angles_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE2));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_colors_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE3));
        glsafe(glBindTexture(GL_TEXTURE_2D, id));
        m_option_template.render(count);
    }
#else
    std::array<int, 4> curr_bound_texture = { 0, 0, 0, 0 };
    for (int i = 0; i < curr_bound_texture.size(); ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + i));
        glsafe(glGetIntegerv(GL_TEXTURE_BINDING_BUFFER, &curr_bound_texture[i]));
        //assert(curr_bound_texture[i] == 0);
    }
 
    glsafe(glActiveTexture(GL_TEXTURE0));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_positions_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_positions_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE1));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_heights_widths_angles_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_heights_widths_angles_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE2));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_colors_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, m_colors_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE3));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_options_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_enabled_options_buf_id));
 
    m_option_template.render(m_enabled_options_count);
#endif // ENABLE_OPENGL_ES
 
    if (!curr_cull_face)
        glsafe(glDisable(GL_CULL_FACE));
 
    glsafe(glUseProgram(curr_shader));
#ifdef ENABLE_OPENGL_ES
    glsafe(glBindTexture(GL_TEXTURE_2D, curr_bound_texture));
#else
    for (int i = 0; i < curr_bound_texture.size(); ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + i));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, curr_bound_texture[i]));
    }
#endif // ENABLE_OPENGL_ES
    glsafe(glActiveTexture(curr_active_texture));
}

References count, GL_ACTIVE_TEXTURE, GL_CULL_FACE, GL_CURRENT_PROGRAM, GL_FALSE, GL_R32UI, GL_RGBA32F, GL_RGBA8, GL_TEXTURE0, GL_TEXTURE1, GL_TEXTURE2, GL_TEXTURE3, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_BINDING_BUFFER, GL_TEXTURE_BUFFER, glActiveTexture, glBindTexture, glcheck, glDisable, glEnable, glGetIntegerv, glIsEnabled, glsafe, glTexBuffer, glUniform1i, glUniform4fv, glUniformMatrix4fv, glUseProgram, m_clipping_plane, m_colors_buf_id, m_colors_tex_id, m_enabled_options_buf_id, m_enabled_options_count, m_enabled_options_tex_id, m_heights_widths_angles_buf_id, m_heights_widths_angles_tex_id, m_option_template, m_options_shader_id, m_positions_buf_id, m_positions_tex_id, m_uni_options_clipping_plane_id, m_uni_options_colors_tex_id, m_uni_options_height_width_angle_tex_id, m_uni_options_layer_colors, m_uni_options_positions_tex_id, m_uni_options_projection_matrix_id, m_uni_options_segment_index_tex_id, m_uni_options_view_matrix_id, and set_layer_colors().

Referenced by render().

Here is the call graph for this function:

Here is the caller graph for this function:

render_segments()

void libvgcode::ViewerImpl::render_segments ( const Mat4x4 & view_matrix, const Mat4x4 & projection_matrix, const Vec3 & camera_position, bool translucent = false )

private

{
    // ORCA: realistic view. The shadow caster pass draws depth only, as does the first order independent pass.
#ifndef ENABLE_OPENGL_ES
    const bool depth_only = m_translucent_pass == 1;
    const unsigned int shader_id = m_rendering_shadow_casters ? m_segments_caster_shader_id : depth_only ? m_segments_depth_shader_id : m_segments_shader_id;
    const SegmentsUniforms& uni = m_rendering_shadow_casters ? m_uni_segments_caster : depth_only ? m_uni_segments_depth : m_uni_segments;
#else
    const bool depth_only = false;
    const unsigned int shader_id = m_rendering_shadow_casters ? m_segments_caster_shader_id : m_segments_shader_id;
    const SegmentsUniforms& uni = m_rendering_shadow_casters ? m_uni_segments_caster : m_uni_segments;
#endif // ENABLE_OPENGL_ES
    if (shader_id == 0)
        return;
 
#ifdef ENABLE_OPENGL_ES
    if (m_texture_data.get_enabled_segments_count() == 0)
#else
    if (m_enabled_segments_count == 0)
#endif // ENABLE_OPENGL_ES
        return;
 
    int curr_active_texture = 0;
    glsafe(glGetIntegerv(GL_ACTIVE_TEXTURE, &curr_active_texture));
    int curr_shader;
    glsafe(glGetIntegerv(GL_CURRENT_PROGRAM, &curr_shader));
    const bool curr_cull_face = glIsEnabled(GL_CULL_FACE);
    glcheck();
 
    glsafe(glUseProgram(shader_id));
 
    glsafe(glUniform1i(uni.positions_tex, 0));
    glsafe(glUniform1i(uni.height_width_angle_tex, 1));
    glsafe(glUniform1i(uni.colors_tex, 2));
    glsafe(glUniform1i(uni.segment_index_tex, 3));
    glsafe(glUniformMatrix4fv(uni.view_matrix, 1, GL_FALSE, view_matrix.data()));
    glsafe(glUniformMatrix4fv(uni.projection_matrix, 1, GL_FALSE, projection_matrix.data()));
    glsafe(glUniform3fv(uni.camera_position, 1, camera_position.data()));
    // ORCA: view_matrix(2,2) > 0 is looking down, where the last segments printed are the nearest.
    // Blending goes the other way, from the farthest.
    const bool reverse_order = (view_matrix[10] > 0.0f) != translucent;
    glsafe(glUniform1i(uni.reverse_order, reverse_order ? 1 : 0));
    glsafe(glUniform4fv(uni.clipping_plane, 1, m_clipping_plane.data()));
#ifndef ENABLE_OPENGL_ES
    if (depth_only)
        glsafe(glUniform1i(m_uni_segments_depth_opaque_depth_id, TRANSLUCENT_TEXTURE_UNIT));
#endif // ENABLE_OPENGL_ES
    if (!m_rendering_shadow_casters && !depth_only) {
        // ORCA: realistic view
        glsafe(glUniform1i(m_uni_segments_shadow_map_id, m_shadow_map_texture_unit));
        glsafe(glUniformMatrix4fv(m_uni_segments_shadow_light_vp_id, 1, GL_FALSE, m_shadow_light_vp.data()));
        glsafe(glUniform1f(m_uni_segments_shadow_intensity_id, m_shadow_intensity));
        glsafe(glUniform1f(m_uni_segments_shadow_map_texel_id, m_shadow_map_texel));
        glsafe(glUniform1f(m_uni_segments_exposure_id, m_exposure));
        glsafe(glUniform1f(m_uni_segments_saturation_id, m_saturation));
        glsafe(glUniform3fv(m_uni_segments_light_top_dir_id, 1, m_light_top_dir.data()));
        glsafe(glUniform1f(m_uni_segments_gloss_id, m_gloss ? 0.6f : 0.0f));
        set_layer_colors(m_uni_segments_layer_colors);
#ifndef ENABLE_OPENGL_ES
        glsafe(glUniform1i(m_uni_segments_oit_pass_id, m_translucent_pass));
        glsafe(glUniform1i(m_uni_segments_opaque_depth_id, TRANSLUCENT_TEXTURE_UNIT));
        glsafe(glUniform1i(m_uni_segments_front_depth_id, TRANSLUCENT_TEXTURE_UNIT + 1));
        glsafe(glUniform2fv(m_uni_segments_oit_depth_range_id, 1, m_oit_depth_range.data()));
#endif // ENABLE_OPENGL_ES
    }
 
    // ORCA: the translucent segments neither hide each other nor what is drawn after them. Drawn late in the
    // frame, they cannot count on the depth test the toolpaths left on, which hides them behind opaque ones.
    const bool curr_blend = glIsEnabled(GL_BLEND);
    const bool curr_depth_test = glIsEnabled(GL_DEPTH_TEST);
    std::array<int, 4> curr_blend_func = { 0, 0, 0, 0 };
    std::array<int, 2> curr_blend_equation = { 0, 0 };
    GLboolean curr_depth_mask = GL_TRUE;
    if (translucent) {
        glsafe(glEnable(GL_DEPTH_TEST));
        glsafe(glGetIntegerv(GL_BLEND_SRC_RGB, &curr_blend_func[0]));
        glsafe(glGetIntegerv(GL_BLEND_DST_RGB, &curr_blend_func[1]));
        glsafe(glGetIntegerv(GL_BLEND_SRC_ALPHA, &curr_blend_func[2]));
        glsafe(glGetIntegerv(GL_BLEND_DST_ALPHA, &curr_blend_func[3]));
        glsafe(glGetIntegerv(GL_BLEND_EQUATION_RGB, &curr_blend_equation[0]));
        glsafe(glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &curr_blend_equation[1]));
        glsafe(glGetBooleanv(GL_DEPTH_WRITEMASK, &curr_depth_mask));
        glsafe(glEnable(GL_BLEND));
        // premultiplied, the highlights are not scaled by the opacity; the nearest depth, then sums,
        // in the passes of render_translucent_segments()
        glsafe(glBlendEquation(m_translucent_pass == 1 ? GL_MIN : GL_FUNC_ADD));
        glsafe(glBlendFunc(GL_ONE, m_translucent_pass != 0 ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA));
        glsafe(glDepthMask(GL_FALSE));
    }
 
    glsafe(glDisable(GL_CULL_FACE));
 
    // ORCA: of the count enabled segments, the last translucent_count are the translucent ones
    auto draw = [this, &uni, translucent](size_t count, size_t translucent_count) {
        const size_t first = translucent ? count - translucent_count : 0;
        if (!m_rendering_shadow_casters)
            count = translucent ? translucent_count : count - translucent_count;
        if (count == 0)
            return;
        glsafe(glUniform1i(uni.instances_count, static_cast<int>(count)));
        glsafe(glUniform1i(uni.first_instance, static_cast<int>(first)));
        if (!m_rendering_shadow_casters) {
            m_segment_template.render(count);
            return;
        }
        // ORCA: realistic view. 6 vertices per caster ribbon.
        int curr_vertex_array = 0;
        glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
        glsafe(glBindVertexArray(m_segments_caster_vao_id));
        glsafe(glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(6 * count)));
        glsafe(glBindVertexArray(curr_vertex_array));
    };
 
#ifdef ENABLE_OPENGL_ES
    int curr_bound_texture = 0;
    glsafe(glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_bound_texture));
 
    const size_t tex_count = m_texture_data.get_count();
    for (size_t n = 0; n < tex_count; ++n) {
        const size_t i = reverse_order ? tex_count - 1 - n : n;
        const auto [id, count] = m_texture_data.get_enabled_segments_tex_id(i);
        if (count == 0)
            continue;
        glsafe(glActiveTexture(GL_TEXTURE0));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_positions_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE1));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_heights_widths_angles_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE2));
        glsafe(glBindTexture(GL_TEXTURE_2D, m_texture_data.get_colors_tex_id(i).first));
        glsafe(glActiveTexture(GL_TEXTURE3));
        glsafe(glBindTexture(GL_TEXTURE_2D, id));
        draw(count, m_texture_data.get_enabled_translucent_segments_count(i));
    }
#else
    std::array<int, 4> curr_bound_texture = { 0, 0, 0, 0 };
    for (int i = 0; i < curr_bound_texture.size(); ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + i));
        glsafe(glGetIntegerv(GL_TEXTURE_BINDING_BUFFER, &curr_bound_texture[i]));
        //assert(curr_bound_texture[i] == 0);
    }
 
    glsafe(glActiveTexture(GL_TEXTURE0));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_positions_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_positions_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE1));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_heights_widths_angles_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, m_heights_widths_angles_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE2));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_colors_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, m_colors_buf_id));
    glsafe(glActiveTexture(GL_TEXTURE3));
    glsafe(glBindTexture(GL_TEXTURE_BUFFER, m_enabled_segments_tex_id));
    glsafe(glTexBuffer(GL_TEXTURE_BUFFER, GL_R32UI, m_enabled_segments_buf_id));
 
    draw(m_enabled_segments_count, m_enabled_translucent_segments_count);
#endif // ENABLE_OPENGL_ES
 
    if (curr_cull_face)
        glsafe(glEnable(GL_CULL_FACE));
    if (translucent) {
        if (!curr_depth_test)
            glsafe(glDisable(GL_DEPTH_TEST));
        glsafe(glDepthMask(curr_depth_mask));
        glsafe(glBlendEquationSeparate(curr_blend_equation[0], curr_blend_equation[1]));
        glsafe(glBlendFuncSeparate(curr_blend_func[0], curr_blend_func[1], curr_blend_func[2], curr_blend_func[3]));
        if (!curr_blend)
            glsafe(glDisable(GL_BLEND));
    }
 
    glsafe(glUseProgram(curr_shader));
#ifdef ENABLE_OPENGL_ES
    glsafe(glBindTexture(GL_TEXTURE_2D, curr_bound_texture));
#else
    for (int i = 0; i < curr_bound_texture.size(); ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + i));
        glsafe(glBindTexture(GL_TEXTURE_BUFFER, curr_bound_texture[i]));
    }
#endif // ENABLE_OPENGL_ES
    glsafe(glActiveTexture(curr_active_texture));
}

References libvgcode::ViewerImpl::SegmentsUniforms::camera_position, libvgcode::ViewerImpl::SegmentsUniforms::clipping_plane, libvgcode::ViewerImpl::SegmentsUniforms::colors_tex, count, libvgcode::ViewerImpl::SegmentsUniforms::first_instance, GL_ACTIVE_TEXTURE, GL_BLEND, GL_BLEND_DST_ALPHA, GL_BLEND_DST_RGB, GL_BLEND_EQUATION_ALPHA, GL_BLEND_EQUATION_RGB, GL_BLEND_SRC_ALPHA, GL_BLEND_SRC_RGB, GL_CULL_FACE, GL_CURRENT_PROGRAM, GL_DEPTH_TEST, GL_DEPTH_WRITEMASK, GL_FALSE, GL_FUNC_ADD, GL_MIN, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_R32UI, GL_RGBA32F, GL_RGBA8, GL_TEXTURE0, GL_TEXTURE1, GL_TEXTURE2, GL_TEXTURE3, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_BINDING_BUFFER, GL_TEXTURE_BUFFER, GL_TRIANGLES, GL_TRUE, GL_VERTEX_ARRAY_BINDING, glActiveTexture, glBindTexture, glBindVertexArray, glBlendEquation, glBlendEquationSeparate, glBlendFunc, glBlendFuncSeparate, glcheck, glDepthMask, glDisable, glDrawArrays, glEnable, glGetBooleanv, glGetIntegerv, glIsEnabled, glsafe, glTexBuffer, glUniform1f, glUniform1i, glUniform2fv, glUniform3fv, glUniform4fv, glUniformMatrix4fv, glUseProgram, libvgcode::ViewerImpl::SegmentsUniforms::height_width_angle_tex, libvgcode::ViewerImpl::SegmentsUniforms::instances_count, m_clipping_plane, m_colors_buf_id, m_colors_tex_id, m_enabled_segments_buf_id, m_enabled_segments_count, m_enabled_segments_tex_id, m_enabled_translucent_segments_count, m_exposure, m_gloss, m_heights_widths_angles_buf_id, m_heights_widths_angles_tex_id, m_light_top_dir, m_oit_depth_range, m_positions_buf_id, m_positions_tex_id, m_rendering_shadow_casters, m_saturation, m_segment_template, m_segments_caster_shader_id, m_segments_caster_vao_id, m_segments_depth_shader_id, m_segments_shader_id, m_shadow_intensity, m_shadow_light_vp, m_shadow_map_texel, m_shadow_map_texture_unit, m_translucent_pass, m_uni_segments, m_uni_segments_caster, m_uni_segments_depth, m_uni_segments_depth_opaque_depth_id, m_uni_segments_exposure_id, m_uni_segments_front_depth_id, m_uni_segments_gloss_id, m_uni_segments_layer_colors, m_uni_segments_light_top_dir_id, m_uni_segments_oit_depth_range_id, m_uni_segments_oit_pass_id, m_uni_segments_opaque_depth_id, m_uni_segments_saturation_id, m_uni_segments_shadow_intensity_id, m_uni_segments_shadow_light_vp_id, m_uni_segments_shadow_map_id, m_uni_segments_shadow_map_texel_id, libvgcode::ViewerImpl::SegmentsUniforms::positions_tex, libvgcode::ViewerImpl::SegmentsUniforms::projection_matrix, libvgcode::ViewerImpl::SegmentsUniforms::reverse_order, libvgcode::ViewerImpl::SegmentsUniforms::segment_index_tex, set_layer_colors(), libvgcode::TRANSLUCENT_TEXTURE_UNIT, and libvgcode::ViewerImpl::SegmentsUniforms::view_matrix.

Referenced by render(), render_shadow_casters(), and render_translucent_segments().

Here is the call graph for this function:

Here is the caller graph for this function:

render_shadow_casters()

void libvgcode::ViewerImpl::render_shadow_casters	(	const Mat4x4 &	view_matrix,
		const Mat4x4 &	projection_matrix,
		const Vec3 &	light_position )

{
    apply_pending_updates();
 
    // Only the extrusions and travels cast: the option markers are indicators, not material.
    m_rendering_shadow_casters = true;
    render_segments(view_matrix, projection_matrix, light_position);
    m_rendering_shadow_casters = false;
}

References apply_pending_updates(), m_rendering_shadow_casters, and render_segments().

Here is the call graph for this function:

render_translucent()

void libvgcode::ViewerImpl::render_translucent	(	const Mat4x4 &	view_matrix,
		const Mat4x4 &	projection_matrix )

{
    apply_pending_updates();
    if (m_enabled_translucent_segments_count == 0)
        return;
 
    const Mat4x4 inv_view_matrix = inverse(view_matrix);
    render_translucent_segments(view_matrix, projection_matrix, { inv_view_matrix[12], inv_view_matrix[13], inv_view_matrix[14] });
}

References apply_pending_updates(), libvgcode::inverse(), m_enabled_translucent_segments_count, and render_translucent_segments().

Here is the call graph for this function:

render_translucent_segments()

void libvgcode::ViewerImpl::render_translucent_segments ( const Mat4x4 & view_matrix, const Mat4x4 & projection_matrix, const Vec3 & camera_position )

private

{
#ifndef ENABLE_OPENGL_ES
    // ORCA: the order independent path, whose targets are as large as the canvas: the nearest translucent surface
    // over the weighted blended order independent transparency (McGuire and Bavoil, 2013) of the others. Blended in
    // print order, even one color shows the order, its surfaces being shaded apart.
    std::array<int, 4> viewport = { 0, 0, 0, 0 };
    int draw_fbo = 0;
    int read_fbo = 0;
    int samples = 0;
    glsafe(glGetIntegerv(GL_VIEWPORT, viewport.data()));
    glsafe(glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_fbo));
    glsafe(glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_fbo));
    glsafe(glGetIntegerv(GL_SAMPLES, &samples));
    // the depth of a multisampled framebuffer object cannot be copied into a texture
    if ((read_fbo != 0 && samples > 0) || !m_translucent_targets.update(viewport[2], viewport[3])) {
        render_segments(view_matrix, projection_matrix, camera_position, true);
        return;
    }
    const TranslucentTargets& targets = m_translucent_targets;
    const int width = viewport[2];
    const int height = viewport[3];
 
    int curr_active_texture = 0;
    std::array<int, 3> curr_textures = { 0, 0, 0 };
    glsafe(glGetIntegerv(GL_ACTIVE_TEXTURE, &curr_active_texture));
    for (int i = 0; i < 3; ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT + i));
        glsafe(glGetIntegerv(GL_TEXTURE_BINDING_2D, &curr_textures[i]));
    }
 
    // the opaque scene, to hide the translucent segments behind it
    glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT));
    glsafe(glBindTexture(GL_TEXTURE_2D, targets.depth_tex));
    glsafe(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, viewport[0], viewport[1], width, height));
 
    // the weights fall with the depth across the extrusions
    float near_z = FLT_MAX;
    float far_z = -FLT_MAX;
    for (int i = 0; i < 8; ++i) {
        const Vec3 p = { m_extrusions_box[i & 1][0], m_extrusions_box[(i >> 1) & 1][1], m_extrusions_box[(i >> 2) & 1][2] };
        const float z = -(view_matrix[2] * p[0] + view_matrix[6] * p[1] + view_matrix[10] * p[2] + view_matrix[14]);
        near_z = std::min(near_z, z);
        far_z = std::max(far_z, z);
    }
    m_oit_depth_range = { near_z, std::max(far_z, near_z + 1.0f) };
 
    // the depth of the nearest translucent surface, as the fragments see it, kept by GL_MIN
    const std::array<float, 4> zero = { 0.0f, 0.0f, 0.0f, 0.0f };
    const std::array<float, 4> one = { 1.0f, 1.0f, 1.0f, 1.0f };
    glsafe(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, targets.front_depth_fbo));
    glsafe(glViewport(0, 0, width, height));
    glsafe(glClearBufferfv(GL_COLOR, 0, one.data()));
    m_translucent_pass = 1;
    render_segments(view_matrix, projection_matrix, camera_position, true);
    glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT + 1));
    glsafe(glBindTexture(GL_TEXTURE_2D, targets.front_depth_tex));
 
    // that surface apart, the others summed
    glsafe(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, targets.fbo));
    for (int i = 0; i < 3; ++i)
        glsafe(glClearBufferfv(GL_COLOR, i, zero.data()));
    m_translucent_pass = 2;
    render_segments(view_matrix, projection_matrix, camera_position, true);
    m_translucent_pass = 0;
 
    glsafe(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_fbo));
    glsafe(glBindFramebuffer(GL_READ_FRAMEBUFFER, read_fbo));
    glsafe(glViewport(viewport[0], viewport[1], width, height));
 
    // composite over the scene
    int curr_shader = 0;
    int curr_vertex_array = 0;
    std::array<int, 4> curr_blend_func = { 0, 0, 0, 0 };
    GLboolean curr_depth_mask = GL_TRUE;
    const bool curr_blend = glIsEnabled(GL_BLEND);
    const bool curr_depth_test = glIsEnabled(GL_DEPTH_TEST);
    glsafe(glGetIntegerv(GL_CURRENT_PROGRAM, &curr_shader));
    glsafe(glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &curr_vertex_array));
    glsafe(glGetIntegerv(GL_BLEND_SRC_RGB, &curr_blend_func[0]));
    glsafe(glGetIntegerv(GL_BLEND_DST_RGB, &curr_blend_func[1]));
    glsafe(glGetIntegerv(GL_BLEND_SRC_ALPHA, &curr_blend_func[2]));
    glsafe(glGetIntegerv(GL_BLEND_DST_ALPHA, &curr_blend_func[3]));
    glsafe(glGetBooleanv(GL_DEPTH_WRITEMASK, &curr_depth_mask));
 
    glsafe(glUseProgram(m_translucent_composite_shader_id));
    glsafe(glUniform1i(m_uni_translucent_composite_accum_tex_id, TRANSLUCENT_TEXTURE_UNIT));
    glsafe(glUniform1i(m_uni_translucent_composite_reveal_tex_id, TRANSLUCENT_TEXTURE_UNIT + 1));
    glsafe(glUniform1i(m_uni_translucent_composite_front_tex_id, TRANSLUCENT_TEXTURE_UNIT + 2));
    glsafe(glUniform2i(m_uni_translucent_composite_origin_id, viewport[0], viewport[1]));
    glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT));
    glsafe(glBindTexture(GL_TEXTURE_2D, targets.accum_tex));
    glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT + 1));
    glsafe(glBindTexture(GL_TEXTURE_2D, targets.reveal_tex));
    glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT + 2));
    glsafe(glBindTexture(GL_TEXTURE_2D, targets.front_tex));
    glsafe(glEnable(GL_BLEND));
    glsafe(glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
    glsafe(glDisable(GL_DEPTH_TEST));
    glsafe(glDepthMask(GL_FALSE));
    glsafe(glBindVertexArray(m_segments_caster_vao_id));
    glsafe(glDrawArrays(GL_TRIANGLES, 0, 3));
 
    glsafe(glBindVertexArray(curr_vertex_array));
    glsafe(glDepthMask(curr_depth_mask));
    if (curr_depth_test)
        glsafe(glEnable(GL_DEPTH_TEST));
    glsafe(glBlendFuncSeparate(curr_blend_func[0], curr_blend_func[1], curr_blend_func[2], curr_blend_func[3]));
    if (!curr_blend)
        glsafe(glDisable(GL_BLEND));
    glsafe(glUseProgram(curr_shader));
    for (int i = 0; i < 3; ++i) {
        glsafe(glActiveTexture(GL_TEXTURE0 + TRANSLUCENT_TEXTURE_UNIT + i));
        glsafe(glBindTexture(GL_TEXTURE_2D, curr_textures[i]));
    }
    glsafe(glActiveTexture(curr_active_texture));
#else
    render_segments(view_matrix, projection_matrix, camera_position, true);
#endif // ENABLE_OPENGL_ES
}

References libvgcode::ViewerImpl::TranslucentTargets::accum_tex, libvgcode::ViewerImpl::TranslucentTargets::depth_tex, libvgcode::ViewerImpl::TranslucentTargets::fbo, libvgcode::ViewerImpl::TranslucentTargets::front_depth_fbo, libvgcode::ViewerImpl::TranslucentTargets::front_depth_tex, libvgcode::ViewerImpl::TranslucentTargets::front_tex, GL_ACTIVE_TEXTURE, GL_BLEND, GL_BLEND_DST_ALPHA, GL_BLEND_DST_RGB, GL_BLEND_SRC_ALPHA, GL_BLEND_SRC_RGB, GL_COLOR, GL_CURRENT_PROGRAM, GL_DEPTH_TEST, GL_DEPTH_WRITEMASK, GL_DRAW_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER_BINDING, GL_FALSE, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_READ_FRAMEBUFFER, GL_READ_FRAMEBUFFER_BINDING, GL_SAMPLES, GL_TEXTURE0, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D, GL_TRIANGLES, GL_TRUE, GL_VERTEX_ARRAY_BINDING, GL_VIEWPORT, glActiveTexture, glBindFramebuffer, glBindTexture, glBindVertexArray, glBlendFunc, glBlendFuncSeparate, glClearBufferfv, glCopyTexSubImage2D, glDepthMask, glDisable, glDrawArrays, glEnable, glGetBooleanv, glGetIntegerv, glIsEnabled, glsafe, glUniform1i, glUniform2i, glUseProgram, glViewport, m_extrusions_box, m_oit_depth_range, m_segments_caster_vao_id, m_translucent_composite_shader_id, m_translucent_pass, m_translucent_targets, m_uni_translucent_composite_accum_tex_id, m_uni_translucent_composite_front_tex_id, m_uni_translucent_composite_origin_id, m_uni_translucent_composite_reveal_tex_id, render_segments(), libvgcode::ViewerImpl::TranslucentTargets::reveal_tex, and libvgcode::TRANSLUCENT_TEXTURE_UNIT.

Referenced by render_translucent().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void libvgcode::ViewerImpl::reset

(

)

{
    m_layers.reset();
    m_view_range.reset();
    m_extrusion_roles.reset();
    m_options.clear();
    m_used_extruders.clear();
    m_total_time = { 0.0f, 0.0f };
    m_travels_time = { 0.0f, 0.0f };
    // swap rather than clear: these are sized by the print, and a reset means the memory
    // should go back, not sit reserved until the next load
    std::vector<PathVertex>().swap(m_vertices);
    std::vector<ColorWithAlpha>().swap(m_vertices_colors);
    m_has_translucent_colors = false;
    m_enabled_translucent_segments_count = 0;
    m_extrusions_box = { Vec3{ 0.0f, 0.0f, 0.0f }, Vec3{ 0.0f, 0.0f, 0.0f } };
    for (std::vector<float>& times : m_layer_start_times)
        std::vector<float>().swap(times);
    std::vector<uint32_t>().swap(m_layer_first_vertex);
    m_layers_in_vertex_order = false;
    // BitSet::clear() only zeroes the bits, it keeps the blocks allocated; load() builds a new
    // bitset anyway and it is never read while m_vertices is empty
    m_valid_lines_bitset = BitSet<>();
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    m_cog_marker.reset();
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
 
#ifdef ENABLE_OPENGL_ES
    m_texture_data.reset();
#else
    m_enabled_segments_count = 0;
    m_enabled_options_count = 0;
 
    m_settings_used_for_ranges = std::nullopt;
 
    delete_textures(m_enabled_options_tex_id);
    delete_buffers(m_enabled_options_buf_id);
    delete_textures(m_enabled_segments_tex_id);
    delete_buffers(m_enabled_segments_buf_id);
    delete_textures(m_colors_tex_id);
    delete_buffers(m_colors_buf_id);
    delete_textures(m_heights_widths_angles_tex_id);
    delete_buffers(m_heights_widths_angles_buf_id);
    delete_textures(m_positions_tex_id);
    delete_buffers(m_positions_buf_id);
    m_translucent_targets.release();
#endif // ENABLE_OPENGL_ES
}

References libvgcode::delete_buffers(), libvgcode::delete_textures(), m_colors_buf_id, m_colors_tex_id, m_enabled_options_buf_id, m_enabled_options_count, m_enabled_options_tex_id, m_enabled_segments_buf_id, m_enabled_segments_count, m_enabled_segments_tex_id, m_enabled_translucent_segments_count, m_extrusion_roles, m_extrusions_box, m_has_translucent_colors, m_heights_widths_angles_buf_id, m_heights_widths_angles_tex_id, m_layer_first_vertex, m_layer_start_times, m_layers, m_layers_in_vertex_order, m_options, m_positions_buf_id, m_positions_tex_id, m_settings_used_for_ranges, m_total_time, m_translucent_targets, m_travels_time, m_used_extruders, m_valid_lines_bitset, m_vertices, m_vertices_colors, and m_view_range.

Referenced by load(), and shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_default_extrusion_roles_colors()

void libvgcode::ViewerImpl::reset_default_extrusion_roles_colors

(

)

{
    m_extrusion_roles_colors = DEFAULT_EXTRUSION_ROLES_COLORS;
}

References libvgcode::DEFAULT_EXTRUSION_ROLES_COLORS, and m_extrusion_roles_colors.

Referenced by ViewerImpl().

Here is the caller graph for this function:

reset_default_options_colors()

void libvgcode::ViewerImpl::reset_default_options_colors

(

)

{
    m_options_colors = DEFAULT_OPTIONS_COLORS;
}

References libvgcode::DEFAULT_OPTIONS_COLORS, and m_options_colors.

Referenced by ViewerImpl().

Here is the caller graph for this function:

set_clipping_plane()

void libvgcode::ViewerImpl::set_clipping_plane ( const std::array< float, 4 > & plane )

inline

{ m_clipping_plane = plane; }

References m_clipping_plane.

set_color_print_colors()

void libvgcode::ViewerImpl::set_color_print_colors

(

const PaletteWithAlpha &

colors

)

{
    m_color_print_colors = colors;
    m_settings.update_colors = true;
}

References m_color_print_colors, and m_settings.

set_color_range_palette()

void libvgcode::ViewerImpl::set_color_range_palette	(	EViewType	type,
		const Palette &	palette )

{
    switch (type)
    {
    case EViewType::Height:                   { m_height_range.set_palette(palette);          break; }
    case EViewType::Width:                    { m_width_range.set_palette(palette);           break; }
    case EViewType::Speed:                    { m_speed_range.set_palette(palette);           break; }
    case EViewType::ActualSpeed:              { m_actual_speed_range.set_palette(palette);    break; }
    case EViewType::FanSpeed:                 { m_fan_speed_range.set_palette(palette);       break; }
    case EViewType::Temperature:              { m_temperature_range.set_palette(palette);     break; }
// ORCA: Add Pressure Advance visualization support
    case EViewType::PressureAdvance:          { m_pressure_advance_range.set_palette(palette); break; }
    // ORCA: Add Acceleration visualization support
    case EViewType::Acceleration:             { m_acceleration_range.set_palette(palette);     break; }
    // ORCA: Add Jerk visualization support
    case EViewType::Jerk:                     { m_jerk_range.set_palette(palette);             break; }
    case EViewType::VolumetricFlowRate:       { m_volumetric_rate_range.set_palette(palette); break; }
    case EViewType::ActualVolumetricFlowRate: { m_actual_volumetric_rate_range.set_palette(palette); break; }
    case EViewType::LayerTimeLinear:          { m_layer_time_range[0].set_palette(palette);   break; }
    case EViewType::LayerTimeLogarithmic:     { m_layer_time_range[1].set_palette(palette);   break; }
    default:                                  { break; }
    }
    m_settings.update_colors = true;
}

References libvgcode::Acceleration, libvgcode::ActualSpeed, libvgcode::ActualVolumetricFlowRate, libvgcode::FanSpeed, libvgcode::Height, libvgcode::Jerk, libvgcode::LayerTimeLinear, libvgcode::LayerTimeLogarithmic, m_acceleration_range, m_actual_speed_range, m_actual_volumetric_rate_range, m_fan_speed_range, m_height_range, m_jerk_range, m_layer_time_range, m_pressure_advance_range, m_settings, m_speed_range, m_temperature_range, m_volumetric_rate_range, m_width_range, libvgcode::PressureAdvance, libvgcode::Speed, libvgcode::Temperature, libvgcode::VolumetricFlowRate, and libvgcode::Width.

set_dim_previous_layers()

void libvgcode::ViewerImpl::set_dim_previous_layers

(

bool

value

)

{
    if (m_settings.dim_previous_layers == value)
        return;
    m_settings.dim_previous_layers = value;
}

References m_settings.

set_dim_previous_layers_brightness()

void libvgcode::ViewerImpl::set_dim_previous_layers_brightness

(

float

value

)

{
    value = std::clamp(value, 0.0f, 1.0f);
    if (m_settings.dim_previous_layers_brightness == value)
        return;
    m_settings.dim_previous_layers_brightness = value;
}

References m_settings.

set_extrusion_role_color()

void libvgcode::ViewerImpl::set_extrusion_role_color	(	EGCodeExtrusionRole	role,
		const Color &	color )

{
    m_extrusion_roles_colors[size_t(role)] = color;
    m_settings.update_colors = true;
}

References m_extrusion_roles_colors, and m_settings.

set_gloss()

void libvgcode::ViewerImpl::set_gloss ( bool gloss )

inline

{ m_gloss = gloss; }

References m_gloss.

set_layer_colors()

void libvgcode::ViewerImpl::set_layer_colors ( const LayerColorsUniforms & uni ) const

private

{
    const size_t top_layer_id = m_settings.top_layer_only_view_range ? m_layers.get_view_range()[1] : 0;
    const bool color_top_layer_only = m_view_range.get_full()[1] != m_view_range.get_visible()[1];
 
    // ORCA: when dim_previous_layers is enabled, darken every layer (keeping its color) except the
    // one(s) the layer slider is being scrubbed to, so that only those are shown at full brightness.
    // A slider thumb marks a layer as inspected only once it is moved away from
    // its end of the print: the upper one while it is below the last layer (or while the moves
    // slider is not at the end of the layer), the lower one while it is above the first layer, so
    // trimming the print from the bottom lights up the lowest visible layer and using the slider as
    // a range lights up both ends. When neither thumb is moved the whole print is rendered normally.
    // Gated on top-layer-only mode, which the greying path below also keys off of, so that the moves
    // slider still animates normally across all layers when that mode is disabled.
    const Interval& layers_range = m_layers.get_view_range();
    const bool inspecting_top_layer = layers_range[1] + 1 < m_layers.count() || color_top_layer_only;
    const bool inspecting_bottom_layer = layers_range[0] > 0;
    const bool dim_previous_layers = m_settings.dim_previous_layers && m_settings.top_layer_only_view_range &&
                                     !m_layers.empty() && (inspecting_top_layer || inspecting_bottom_layer);
 
    // Without dimming, the layers below the top one go dark grey while the moves slider is short of
    // the end. Neither touches the inspected layers, nor the first vertex of a spiral vase layer.
    glsafe(glUniform2i(uni.lit_layers, dim_previous_layers && inspecting_bottom_layer ? static_cast<int>(layers_range[0]) : -1,
                                       dim_previous_layers && inspecting_top_layer ? static_cast<int>(layers_range[1]) : -1));
    glsafe(glUniform1i(uni.grey_below_layer, color_top_layer_only ? static_cast<int>(top_layer_id) : 0));
    glsafe(glUniform1f(uni.dim_brightness, dim_previous_layers ? m_settings.dim_previous_layers_brightness : -1.0f));
    glsafe(glUniform1i(uni.kept_vertex, m_settings.spiral_vase_mode ? static_cast<int>(m_view_range.get_enabled()[0]) : -1));
}

References libvgcode::ViewerImpl::LayerColorsUniforms::dim_brightness, glsafe, glUniform1f, glUniform1i, glUniform2i, libvgcode::ViewerImpl::LayerColorsUniforms::grey_below_layer, libvgcode::ViewerImpl::LayerColorsUniforms::kept_vertex, libvgcode::ViewerImpl::LayerColorsUniforms::lit_layers, m_layers, m_settings, and m_view_range.

Referenced by render_options(), and render_segments().

Here is the caller graph for this function:

set_layers_view_range() [1/2]

void libvgcode::ViewerImpl::set_layers_view_range ( const Interval & range )

inline

{ set_layers_view_range(range[0], range[1]); }

References set_layers_view_range().

Referenced by set_layers_view_range().

Here is the call graph for this function:

Here is the caller graph for this function:

set_layers_view_range() [2/2]

void libvgcode::ViewerImpl::set_layers_view_range	(	Interval::value_type	min,
		Interval::value_type	max )

{
    min = std::clamp<Interval::value_type>(min, 0, m_layers.count() - 1);
    max = std::clamp<Interval::value_type>(max, 0, m_layers.count() - 1);
    m_layers.set_view_range(min, max);
    // force immediate update of the full range
    update_view_full_range();
    m_view_range.set_visible(m_view_range.get_enabled());
    m_settings.update_enabled_entities = true;
}

References m_layers, m_settings, m_view_range, and update_view_full_range().

Here is the call graph for this function:

set_light_top_dir()

void libvgcode::ViewerImpl::set_light_top_dir ( const Vec3 & direction )

inline

{ m_light_top_dir = direction; }

References m_light_top_dir.

set_option_color()

void libvgcode::ViewerImpl::set_option_color	(	EOptionType	type,
		const Color &	color )

{
    m_options_colors[size_t(type)] = color;
    m_settings.update_colors = true;
}

References m_options_colors, and m_settings.

set_shadow_map()

void libvgcode::ViewerImpl::set_shadow_map	(	int	texture_unit,
		const Mat4x4 &	light_view_projection,
		float	intensity,
		float	texel_size )

{
    m_shadow_map_texture_unit = texture_unit;
    m_shadow_light_vp = light_view_projection;
    m_shadow_intensity = intensity;
    m_shadow_map_texel = texel_size;
}

References m_shadow_intensity, m_shadow_light_vp, m_shadow_map_texel, and m_shadow_map_texture_unit.

set_time_mode()

void libvgcode::ViewerImpl::set_time_mode

(

ETimeMode

mode

)

{
    m_settings.time_mode = mode;
    m_settings.update_colors = true;
    // Update layer_duration for all vertices based on the new time mode
    for (PathVertex& v : m_vertices) {
        v.layer_duration = m_layers.get_layer_time(mode, static_cast<size_t>(v.layer_id));
    }
}

References m_layers, m_settings, and m_vertices.

set_tone()

void libvgcode::ViewerImpl::set_tone	(	float	exposure,
		float	saturation )

{
    m_exposure = exposure;
    m_saturation = saturation;
}

References m_exposure, and m_saturation.

set_tool_colors()

void libvgcode::ViewerImpl::set_tool_colors

(

const PaletteWithAlpha &

colors

)

{
    m_tool_colors = colors;
    m_settings.update_colors = true;
}

References m_settings, and m_tool_colors.

set_translucent_filaments()

void libvgcode::ViewerImpl::set_translucent_filaments

(

bool

value

)

{
    if (m_settings.translucent_filaments == value)
        return;
    m_settings.translucent_filaments = value;
    m_settings.update_colors = true;
}

References m_settings.

set_travels_radius()

void libvgcode::ViewerImpl::set_travels_radius

(

float

radius

)

{
    m_travels_radius = std::clamp(radius, MIN_TRAVELS_RADIUS_MM, MAX_TRAVELS_RADIUS_MM);
    update_heights_widths();
}

References m_travels_radius, libvgcode::MAX_TRAVELS_RADIUS_MM, libvgcode::MIN_TRAVELS_RADIUS_MM, and update_heights_widths().

Here is the call graph for this function:

set_view_type()

void libvgcode::ViewerImpl::set_view_type

(

EViewType

type

)

{
    m_settings.view_type = type;
    m_settings.update_colors = true;
}

References m_settings.

set_view_visible_range()

void libvgcode::ViewerImpl::set_view_visible_range	(	Interval::value_type	min,
		Interval::value_type	max )

{
    // force update of the full range, to avoid clamping the visible range with full old values
    // when calling m_view_range.set_visible()
    update_view_full_range();
    m_view_range.set_visible(min, max);
    update_enabled_entities();
}

References m_view_range, update_enabled_entities(), and update_view_full_range().

Here is the call graph for this function:

set_wipes_radius()

void libvgcode::ViewerImpl::set_wipes_radius

(

float

radius

)

{
    m_wipes_radius = std::clamp(radius, MIN_WIPES_RADIUS_MM, MAX_WIPES_RADIUS_MM);
    update_heights_widths();
}

References m_wipes_radius, libvgcode::MAX_WIPES_RADIUS_MM, libvgcode::MIN_WIPES_RADIUS_MM, and update_heights_widths().

Here is the call graph for this function:

shutdown()

void libvgcode::ViewerImpl::shutdown

(

)

{
    reset();
#if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    m_tool_marker.shutdown();
    m_cog_marker.shutdown();
#endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    m_option_template.shutdown();
    m_segment_template.shutdown();
    if (m_options_shader_id != 0) {
        glsafe(glDeleteProgram(m_options_shader_id));
        m_options_shader_id = 0;
    }
    if (m_segments_shader_id != 0) {
        glsafe(glDeleteProgram(m_segments_shader_id));
        m_segments_shader_id = 0;
    }
    if (m_segments_caster_shader_id != 0) {
        glsafe(glDeleteProgram(m_segments_caster_shader_id));
        m_segments_caster_shader_id = 0;
    }
    if (m_segments_caster_vao_id != 0) {
        glsafe(glDeleteVertexArrays(1, &m_segments_caster_vao_id));
        m_segments_caster_vao_id = 0;
    }
#ifndef ENABLE_OPENGL_ES
    if (m_translucent_composite_shader_id != 0) {
        glsafe(glDeleteProgram(m_translucent_composite_shader_id));
        m_translucent_composite_shader_id = 0;
    }
    if (m_segments_depth_shader_id != 0) {
        glsafe(glDeleteProgram(m_segments_depth_shader_id));
        m_segments_depth_shader_id = 0;
    }
#endif // ENABLE_OPENGL_ES
    m_initialized = false;
    OpenGLWrapper::unload_opengl();
}

References glDeleteProgram, glDeleteVertexArrays, glsafe, m_initialized, m_option_template, m_options_shader_id, m_segment_template, m_segments_caster_shader_id, m_segments_caster_vao_id, m_segments_depth_shader_id, m_segments_shader_id, m_translucent_composite_shader_id, reset(), and libvgcode::OpenGLWrapper::unload_opengl().

Referenced by ~ViewerImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_extrusion_role_visibility()

void libvgcode::ViewerImpl::toggle_extrusion_role_visibility

(

EGCodeExtrusionRole

role

)

{
    m_settings.extrusion_roles_visibility[size_t(role)] = ! m_settings.extrusion_roles_visibility[size_t(role)];
    update_view_full_range();
    m_settings.update_enabled_entities = true;
    m_settings.update_colors = true;
}

References m_settings, and update_view_full_range().

Here is the call graph for this function:

toggle_option_visibility()

void libvgcode::ViewerImpl::toggle_option_visibility

(

EOptionType

type

)

{
    m_settings.options_visibility[size_t(type)] = ! m_settings.options_visibility[size_t(type)];
    const Interval old_enabled_range = m_view_range.get_enabled();
    update_view_full_range();
    const Interval& new_enabled_range = m_view_range.get_enabled();
    if (old_enabled_range != new_enabled_range) {
        const Interval& visible_range = m_view_range.get_visible();
        if (old_enabled_range == visible_range)
            m_view_range.set_visible(new_enabled_range);
        else if (m_settings.top_layer_only_view_range && new_enabled_range[0] < visible_range[0])
            m_view_range.set_visible(new_enabled_range[0], visible_range[1]);
    }
    m_settings.update_enabled_entities = true;
    m_settings.update_colors = true;
}

References m_settings, m_view_range, and update_view_full_range().

Here is the call graph for this function:

toggle_top_layer_only_view_range()

void libvgcode::ViewerImpl::toggle_top_layer_only_view_range

(

)

{
    m_settings.top_layer_only_view_range = !m_settings.top_layer_only_view_range;
    update_view_full_range();
    m_view_range.set_visible(m_view_range.get_enabled());
    m_settings.update_enabled_entities = true;
}

References m_settings, m_view_range, and update_view_full_range().

Here is the call graph for this function:

update_color_ranges()

void libvgcode::ViewerImpl::update_color_ranges ( )

private

{
    // Color ranges do not need to be recalculated that often. If the following settings are the same
    // as last time, the current ranges are still valid. The recalculation is quite expensive.
    if (m_settings_used_for_ranges.has_value() &&
        m_settings.extrusion_roles_visibility == m_settings_used_for_ranges->extrusion_roles_visibility &&
        m_settings.options_visibility == m_settings_used_for_ranges->options_visibility)
        return;
 
    m_width_range.reset();
    m_height_range.reset();
    m_speed_range.reset();
    m_actual_speed_range.reset();
    m_fan_speed_range.reset();
    m_temperature_range.reset();
    // ORCA: Add Pressure Advance visualization support
    m_pressure_advance_range.reset();
    // ORCA: Add Acceleration visualization support
    m_acceleration_range.reset();
    // ORCA: Add Jerk visualization support
    m_jerk_range.reset();
    m_volumetric_rate_range.reset();
    m_actual_volumetric_rate_range.reset();
    m_layer_time_range[0].reset(); // ColorRange::EType::Linear
    m_layer_time_range[1].reset(); // ColorRange::EType::Logarithmic
 
    for (size_t i = 0; i < m_vertices.size(); i++) {
        const PathVertex& v = m_vertices[i];
        if (v.is_extrusion()) {
            m_height_range.update(round_to_bin(v.height));
            if (!v.is_custom_gcode() || m_settings.extrusion_roles_visibility[size_t(EGCodeExtrusionRole::Custom)]) {
                m_width_range.update(round_to_bin(v.width));
                m_volumetric_rate_range.update(round_to_bin(v.volumetric_rate()));
                m_actual_volumetric_rate_range.update(round_to_bin(v.actual_volumetric_rate()));
            }
            m_fan_speed_range.update(round_to_bin(v.fan_speed));
            m_temperature_range.update(round_to_bin(v.temperature));
            // ORCA: Add Pressure Advance visualization support
            if (v.pressure_advance >= 0.0f)
                m_pressure_advance_range.update(v.pressure_advance);
        }
        if ((v.is_travel() && m_settings.options_visibility[size_t(EOptionType::Travels)]) ||
            (v.is_wipe() && m_settings.options_visibility[size_t(EOptionType::Wipes)]) ||
             v.is_extrusion()) {
            m_speed_range.update(v.feedrate);
            m_actual_speed_range.update(v.actual_feedrate);
            // ORCA: Add Acceleration visualization support
            m_acceleration_range.update(v.acceleration);
            // ORCA: Add Jerk visualization support
            m_jerk_range.update(v.jerk);
        }
    }
 
    const std::vector<float> times = m_layers.get_times(m_settings.time_mode);
    for (size_t i = 0; i < m_layer_time_range.size(); ++i) {
        for (float t : times) {
            m_layer_time_range[i].update(t);
        }
    }
 
    m_settings_used_for_ranges = m_settings;
}

References libvgcode::PathVertex::acceleration, libvgcode::PathVertex::actual_feedrate, libvgcode::PathVertex::actual_volumetric_rate(), libvgcode::Custom, libvgcode::PathVertex::fan_speed, libvgcode::PathVertex::feedrate, libvgcode::PathVertex::height, libvgcode::PathVertex::is_custom_gcode(), libvgcode::PathVertex::is_extrusion(), libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), libvgcode::PathVertex::jerk, m_acceleration_range, m_actual_speed_range, m_actual_volumetric_rate_range, m_fan_speed_range, m_height_range, m_jerk_range, m_layer_time_range, m_layers, m_pressure_advance_range, m_settings, m_settings_used_for_ranges, m_speed_range, m_temperature_range, m_vertices, m_volumetric_rate_range, m_width_range, libvgcode::PathVertex::pressure_advance, libvgcode::round_to_bin(), libvgcode::PathVertex::temperature, libvgcode::Travels, libvgcode::PathVertex::volumetric_rate(), libvgcode::PathVertex::width, and libvgcode::Wipes.

Referenced by update_colors().

Here is the call graph for this function:

Here is the caller graph for this function:

update_colors()

void libvgcode::ViewerImpl::update_colors

(

)

{
 
 
    if (!m_used_extruders.empty()) {
        // ensure that the number of defined tool colors matches the max id of the used extruders 
        const size_t max_used_extruder_id = 1 + static_cast<size_t>(m_used_extruders.rbegin()->first);
        const size_t tool_colors_size = m_tool_colors.size();
        if (m_tool_colors.size() < max_used_extruder_id) {
            for (size_t i = 0; i < max_used_extruder_id - tool_colors_size; ++i) {
                m_tool_colors.push_back({ DUMMY_COLOR[0], DUMMY_COLOR[1], DUMMY_COLOR[2], 255 });
            }
        }
    }
 
    update_color_ranges();
    
    // Recalculate "normal" colors of all the vertices for current view settings.
    // If some part of the preview should be rendered in dark grey, it is taken
    // care of in the shaders, see set_layer_colors(). That is to avoid the need to recalculate
    // the "normal" color on every slider move.
    const bool had_translucent_colors = m_has_translucent_colors;
    m_has_translucent_colors = false;
    for (size_t i = 0; i < m_vertices.size(); ++i) {
        const Color color = get_vertex_color(m_vertices[i]);
        const uint8_t alpha = get_vertex_alpha(m_vertices[i]);
        m_vertices_colors[i] = { color[0], color[1], color[2], alpha };
        m_has_translucent_colors |= alpha < 255;
    }
 
    update_colors_texture();
    m_settings.update_colors = false;
 
    // ORCA: the enabled segments are sorted by opacity
    if (had_translucent_colors || m_has_translucent_colors)
        m_settings.update_enabled_entities = true;
}

References libvgcode::DUMMY_COLOR, get_vertex_alpha(), get_vertex_color(), m_has_translucent_colors, m_settings, m_tool_colors, m_used_extruders, m_vertices, m_vertices_colors, update_color_ranges(), and update_colors_texture().

Referenced by apply_pending_updates(), and load().

Here is the call graph for this function:

Here is the caller graph for this function:

update_colors_texture()

void libvgcode::ViewerImpl::update_colors_texture

(

)

{
#if !defined(ENABLE_OPENGL_ES)
    if (m_colors_buf_id == 0)
        return;
#endif // ENABLE_OPENGL_ES
 
    // ORCA: the colors of the vertices alone; the layers greyed or dimmed around the one the sliders
    // show are left to the shaders, see set_layer_colors(), so that a slider step uploads nothing.
    #ifdef ENABLE_OPENGL_ES
        if (!m_vertices_colors.empty())
            // update gpu buffer for colors
            m_texture_data.set_colors(m_vertices_colors);
    #else
        m_colors_tex_size = m_vertices_colors.size() * sizeof(ColorWithAlpha);
 
        // update gpu buffer for colors
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_colors_buf_id));
        glsafe(glBufferData(GL_TEXTURE_BUFFER, m_colors_tex_size, m_vertices_colors.data(), GL_STATIC_DRAW));
        glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
    #endif // ENABLE_OPENGL_ES
}

References GL_STATIC_DRAW, GL_TEXTURE_BUFFER, glBindBuffer, glBufferData, glsafe, m_colors_buf_id, m_colors_tex_size, and m_vertices_colors.

Referenced by update_colors().

Here is the caller graph for this function:

update_enabled_entities()

void libvgcode::ViewerImpl::update_enabled_entities

(

)

{
    if (m_vertices.empty())
        return;
 
    std::vector<uint32_t> enabled_segments;
    std::vector<uint32_t> enabled_options;
    Interval range = m_view_range.get_visible();
 
    // when top layer only visualization is enabled, we need to render
    // all the toolpaths in the other layers as grayed, so extend the range
    // to contain them
    if (m_settings.top_layer_only_view_range)
        range[0] = m_view_range.get_full()[0];
 
    // to show the options at the current tool marker position we need to extend the range by one extra step
    if (m_vertices[range[1]].is_option() && range[1] < static_cast<uint32_t>(m_vertices.size()) - 1)
        ++range[1];
 
    if (m_settings.spiral_vase_mode) {
        // when spiral vase mode is enabled and only one layer is shown, extend the range by one step
        const Interval& layers_range = m_layers.get_view_range();
        if (layers_range[0] > 0 && layers_range[0] == layers_range[1])
            --range[0];
    }
 
    for (size_t i = range[0]; i < range[1]; ++i) {
        const PathVertex& v = m_vertices[i];
 
        if (!m_valid_lines_bitset[i] && !v.is_option())
            continue;
        if (v.is_travel()) {
            if (!m_settings.options_visibility[size_t(EOptionType::Travels)])
                continue;
        }
        else if (v.is_wipe()) {
            if (!m_settings.options_visibility[size_t(EOptionType::Wipes)])
                continue;
        }
        else if (v.is_option()) {
            if (!m_settings.options_visibility[size_t(move_type_to_option(v.type))])
                continue;
        }
        else if (v.is_extrusion()) {
            if (!m_settings.extrusion_roles_visibility[size_t(v.role)])
                continue;
        }
        else
            continue;
 
        if (v.is_option())
            enabled_options.push_back(static_cast<uint32_t>(i));
        else
            enabled_segments.push_back(static_cast<uint32_t>(i));
    }
 
    // ORCA: so that each pass of render() draws only its own segments, in print order
    m_enabled_translucent_segments_count = 0;
#ifdef ENABLE_OPENGL_ES
    m_texture_data.set_enabled_segments(enabled_segments, m_vertices_colors, m_has_translucent_colors);
    for (size_t i = 0; i < m_texture_data.get_count(); ++i)
        m_enabled_translucent_segments_count += m_texture_data.get_enabled_translucent_segments_count(i);
    m_texture_data.set_enabled_options(enabled_options);
#else
    if (m_has_translucent_colors) {
        const auto is_opaque = [this](uint32_t id) { return m_vertices_colors[id][3] == 255; };
        const auto translucent_begin = std::stable_partition(enabled_segments.begin(), enabled_segments.end(), is_opaque);
        m_enabled_translucent_segments_count = static_cast<size_t>(std::distance(translucent_begin, enabled_segments.end()));
    }
 
    m_enabled_segments_count = enabled_segments.size();
    m_enabled_options_count = enabled_options.size();
 
    m_enabled_segments_tex_size = enabled_segments.size() * sizeof(uint32_t);
    m_enabled_options_tex_size = enabled_options.size() * sizeof(uint32_t);
 
    // update gpu buffer for enabled segments
    assert(m_enabled_segments_buf_id > 0);
    glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_segments_buf_id));
    if (!enabled_segments.empty())
        glsafe(glBufferData(GL_TEXTURE_BUFFER, enabled_segments.size() * sizeof(uint32_t), enabled_segments.data(), GL_STATIC_DRAW));
    else
        glsafe(glBufferData(GL_TEXTURE_BUFFER, 0, nullptr, GL_STATIC_DRAW));
 
    // update gpu buffer for enabled options
    assert(m_enabled_options_buf_id > 0);
    glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_enabled_options_buf_id));
    if (!enabled_options.empty())
        glsafe(glBufferData(GL_TEXTURE_BUFFER, enabled_options.size() * sizeof(uint32_t), enabled_options.data(), GL_STATIC_DRAW));
    else
        glsafe(glBufferData(GL_TEXTURE_BUFFER, 0, nullptr, GL_STATIC_DRAW));
 
    glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
#endif // ENABLE_OPENGL_ES
 
    m_settings.update_enabled_entities = false;
}

References GL_STATIC_DRAW, GL_TEXTURE_BUFFER, glBindBuffer, glBufferData, glsafe, libvgcode::PathVertex::is_extrusion(), libvgcode::PathVertex::is_option(), libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), m_enabled_options_buf_id, m_enabled_options_count, m_enabled_options_tex_size, m_enabled_segments_buf_id, m_enabled_segments_count, m_enabled_segments_tex_size, m_enabled_translucent_segments_count, m_has_translucent_colors, m_layers, m_settings, m_valid_lines_bitset, m_vertices, m_vertices_colors, m_view_range, libvgcode::move_type_to_option(), libvgcode::PathVertex::role, libvgcode::Travels, libvgcode::PathVertex::type, and libvgcode::Wipes.

Referenced by apply_pending_updates(), load(), and set_view_visible_range().

Here is the call graph for this function:

Here is the caller graph for this function:

update_heights_widths()

void libvgcode::ViewerImpl::update_heights_widths ( )

private

{
#ifdef ENABLE_OPENGL_ES
    std::vector<Vec4> heights_widths_angles;
    heights_widths_angles.reserve(m_vertices.size());
    extract_pos_and_or_hwa(m_vertices, m_travels_radius, m_wipes_radius, m_valid_lines_bitset, nullptr, &heights_widths_angles);
    m_texture_data.set_heights_widths_angles(heights_widths_angles);
#else
    if (m_heights_widths_angles_buf_id == 0)
        return;
 
    glsafe(glBindBuffer(GL_TEXTURE_BUFFER, m_heights_widths_angles_buf_id));
 
    Vec3* buffer = static_cast<Vec3*>(glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY));
    glcheck();
 
    for (size_t i = 0; i < m_vertices.size(); ++i) {
        const PathVertex& v = m_vertices[i];
        if (v.is_travel()) {
            buffer[i][0] = m_travels_radius;
            buffer[i][1] = m_travels_radius;
        }
        else if (v.is_wipe()) {
            buffer[i][0] = m_wipes_radius;
            buffer[i][1] = m_wipes_radius;
        }
    }
 
    glsafe(glUnmapBuffer(GL_TEXTURE_BUFFER));
    glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
#endif // ENABLE_OPENGL_ES
}

References libvgcode::extract_pos_and_or_hwa(), GL_TEXTURE_BUFFER, GL_WRITE_ONLY, glBindBuffer, glcheck, glMapBuffer, glsafe, glUnmapBuffer, libvgcode::PathVertex::is_travel(), libvgcode::PathVertex::is_wipe(), m_heights_widths_angles_buf_id, m_travels_radius, m_valid_lines_bitset, m_vertices, and m_wipes_radius.

Referenced by set_travels_radius(), and set_wipes_radius().

Here is the call graph for this function:

Here is the caller graph for this function:

update_view_full_range()

void libvgcode::ViewerImpl::update_view_full_range ( )

private

{
    const Interval& layers_range = m_layers.get_view_range();
    const bool travels_visible = m_settings.options_visibility[size_t(EOptionType::Travels)];
    const bool wipes_visible   = m_settings.options_visibility[size_t(EOptionType::Wipes)];
 
    // every vertex before m_layer_first_vertex[layers_range[0]] has a smaller layer_id, so the loop
    // below would skip all of them anyway
    auto first_it = m_vertices.begin();
    if (layers_range[0] < m_layer_first_vertex.size())
        first_it += m_layer_first_vertex[layers_range[0]];
    while (first_it != m_vertices.end() &&
           (first_it->layer_id < layers_range[0] || !is_visible(*first_it, m_settings))) {
        ++first_it;
    }
 
    // If the first vertex is an extrusion, add an extra step to properly detect the first segment
    if (first_it != m_vertices.begin() && first_it != m_vertices.end() && first_it->type == EMoveType::Extrude)
        --first_it;
 
    if (first_it == m_vertices.end())
        m_view_range.set_full(Range());
    else {
        if (travels_visible || wipes_visible) {
            // if the global range starts with a travel/wipe move, extend it to the travel/wipe start
            while (first_it != m_vertices.begin() &&
                   ((travels_visible && first_it->is_travel()) ||
                    (wipes_visible && first_it->is_wipe()))) {
                --first_it;
            }
        }
 
        auto last_it = first_it;
        // ORCA: skip straight to the layer above the range rather than walking there
        if (m_layers_in_vertex_order && layers_range[1] + 1 < m_layer_first_vertex.size())
            last_it = std::max(first_it, m_vertices.begin() + m_layer_first_vertex[layers_range[1] + 1]);
        else if (m_layers_in_vertex_order)
            last_it = m_vertices.end();
        while (last_it != m_vertices.end() && last_it->layer_id <= layers_range[1]) {
            ++last_it;
        }
        if (last_it != first_it)
            --last_it;
 
        // remove disabled trailing options, if any 
        auto rev_first_it = std::make_reverse_iterator(first_it);
        if (rev_first_it != m_vertices.rbegin())
            --rev_first_it;
        auto rev_last_it = std::make_reverse_iterator(last_it);
        if (rev_last_it != m_vertices.rbegin())
            --rev_last_it;
 
        bool reduced = false;
        while (rev_last_it != rev_first_it && !is_visible(*rev_last_it, m_settings)) {
            ++rev_last_it;
            reduced = true;
        }
 
        if (reduced && rev_last_it != m_vertices.rend())
            last_it = rev_last_it.base() - 1;
 
        if (travels_visible || wipes_visible) {
            // if the global range ends with a travel/wipe move, extend it to the travel/wipe end
            while (last_it != m_vertices.end() && last_it + 1 != m_vertices.end() &&
                   ((travels_visible && last_it->is_travel() && (last_it + 1)->is_travel()) ||
                    (wipes_visible && last_it->is_wipe() && (last_it + 1)->is_wipe()))) {
                  ++last_it;
            }
        }
 
        if (first_it != last_it)
            m_view_range.set_full(std::distance(m_vertices.begin(), first_it), std::distance(m_vertices.begin(), last_it));
        else
            m_view_range.set_full(Range());
 
        if (m_settings.top_layer_only_view_range) {
            const Interval& full_range = m_view_range.get_full();
            const auto range_first_it = m_vertices.begin() + full_range[0];
            auto top_first_it = range_first_it;
            // ORCA: skip straight to the top layer rather than walking there
            if (m_layers_in_vertex_order)
                top_first_it = std::max(top_first_it, m_vertices.begin() + m_layer_first_vertex[layers_range[1]]);
            while (top_first_it != m_vertices.end() && (top_first_it->layer_id < layers_range[1] || !is_visible(*top_first_it, m_settings)))
                ++top_first_it;
            const bool shortened = top_first_it != range_first_it;
            if (shortened)
                --top_first_it;
 
            // when spiral vase mode is enabled and only one layer is shown, extend the range by one step
            if (m_settings.spiral_vase_mode && layers_range[0] > 0 && layers_range[0] == layers_range[1])
                --top_first_it;
            m_view_range.set_enabled(std::distance(m_vertices.begin(), top_first_it), full_range[1]);
        }
        else
            m_view_range.set_enabled(m_view_range.get_full());
    }
 
    m_settings.update_view_full_range = false;
}

References libvgcode::Extrude, libvgcode::is_visible(), m_layer_first_vertex, m_layers, m_layers_in_vertex_order, m_settings, m_vertices, m_view_range, libvgcode::Travels, and libvgcode::Wipes.

Referenced by apply_pending_updates(), load(), set_layers_view_range(), set_view_visible_range(), toggle_extrusion_role_visibility(), toggle_option_visibility(), and toggle_top_layer_only_view_range().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_acceleration_range

ColorRange libvgcode::ViewerImpl::m_acceleration_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_actual_speed_range

ColorRange libvgcode::ViewerImpl::m_actual_speed_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_actual_volumetric_rate_range

ColorRange libvgcode::ViewerImpl::m_actual_volumetric_rate_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_clipping_plane

std::array<float, 4> libvgcode::ViewerImpl::m_clipping_plane { 0.0f, 0.0f, 0.0f, 1.0f }

private

{ 0.0f, 0.0f, 0.0f, 1.0f };

Referenced by render_options(), render_segments(), and set_clipping_plane().

m_color_print_colors

PaletteWithAlpha libvgcode::ViewerImpl::m_color_print_colors

private

Referenced by get_color_print_colors(), get_color_print_colors_count(), get_used_cpu_memory(), get_vertex_alpha(), get_vertex_color(), load(), and set_color_print_colors().

m_colors_buf_id

unsigned int libvgcode::ViewerImpl::m_colors_buf_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), reset(), and update_colors_texture().

m_colors_tex_id

unsigned int libvgcode::ViewerImpl::m_colors_tex_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), and reset().

m_colors_tex_size

size_t libvgcode::ViewerImpl::m_colors_tex_size { 0 }

private

{ 0 };

Referenced by get_used_gpu_memory(), and update_colors_texture().

m_enabled_options_buf_id

unsigned int libvgcode::ViewerImpl::m_enabled_options_buf_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), reset(), and update_enabled_entities().

m_enabled_options_count

size_t libvgcode::ViewerImpl::m_enabled_options_count { 0 }

private

{ 0 };

Referenced by render_options(), reset(), and update_enabled_entities().

m_enabled_options_tex_id

unsigned int libvgcode::ViewerImpl::m_enabled_options_tex_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), and reset().

m_enabled_options_tex_size

size_t libvgcode::ViewerImpl::m_enabled_options_tex_size { 0 }

private

{ 0 };

Referenced by get_used_gpu_memory(), and update_enabled_entities().

m_enabled_segments_buf_id

unsigned int libvgcode::ViewerImpl::m_enabled_segments_buf_id { 0 }

private

{ 0 };

Referenced by load(), render_segments(), reset(), and update_enabled_entities().

m_enabled_segments_count

size_t libvgcode::ViewerImpl::m_enabled_segments_count { 0 }

private

{ 0 };

Referenced by render_segments(), reset(), and update_enabled_entities().

m_enabled_segments_tex_id

unsigned int libvgcode::ViewerImpl::m_enabled_segments_tex_id { 0 }

private

{ 0 };

Referenced by load(), render_segments(), and reset().

m_enabled_segments_tex_size

size_t libvgcode::ViewerImpl::m_enabled_segments_tex_size { 0 }

private

{ 0 };

Referenced by get_used_gpu_memory(), and update_enabled_entities().

m_enabled_translucent_segments_count

size_t libvgcode::ViewerImpl::m_enabled_translucent_segments_count { 0 }

private

{ 0 };

Referenced by has_translucent_toolpaths(), render_segments(), render_translucent(), reset(), and update_enabled_entities().

m_exposure

float libvgcode::ViewerImpl::m_exposure { 1.0f }

private

{ 1.0f };

Referenced by render_segments(), and set_tone().

m_extrusion_roles

ExtrusionRoles libvgcode::ViewerImpl::m_extrusion_roles

private

Referenced by get_extrusion_role_estimated_time(), get_extrusion_roles(), get_extrusion_roles_count(), load(), and reset().

m_extrusion_roles_colors

std::array<Color, size_t(EGCodeExtrusionRole::COUNT)> libvgcode::ViewerImpl::m_extrusion_roles_colors

private

Referenced by get_extrusion_role_color(), get_used_cpu_memory(), reset_default_extrusion_roles_colors(), and set_extrusion_role_color().

m_extrusions_box

AABox libvgcode::ViewerImpl::m_extrusions_box { Vec3{ 0.0f, 0.0f, 0.0f }, Vec3{ 0.0f, 0.0f, 0.0f } }

private

{ Vec3{ 0.0f, 0.0f, 0.0f }, Vec3{ 0.0f, 0.0f, 0.0f } };

Referenced by load(), render_translucent_segments(), and reset().

m_fan_speed_range

ColorRange libvgcode::ViewerImpl::m_fan_speed_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_gloss

bool libvgcode::ViewerImpl::m_gloss { true }

private

{ true };

Referenced by render_segments(), and set_gloss().

m_has_translucent_colors

bool libvgcode::ViewerImpl::m_has_translucent_colors { false }

private

{ false };

Referenced by reset(), update_colors(), and update_enabled_entities().

m_height_range

ColorRange libvgcode::ViewerImpl::m_height_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_height_width_angle_tex_size

size_t libvgcode::ViewerImpl::m_height_width_angle_tex_size { 0 }

private

{ 0 };

Referenced by get_used_gpu_memory(), and load().

m_heights_widths_angles_buf_id

unsigned int libvgcode::ViewerImpl::m_heights_widths_angles_buf_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), reset(), and update_heights_widths().

m_heights_widths_angles_tex_id

unsigned int libvgcode::ViewerImpl::m_heights_widths_angles_tex_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), and reset().

m_initialized

bool libvgcode::ViewerImpl::m_initialized { false }

private

{ false };

Referenced by init(), load(), and shutdown().

m_jerk_range

ColorRange libvgcode::ViewerImpl::m_jerk_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_layer_first_vertex

std::vector<uint32_t> libvgcode::ViewerImpl::m_layer_first_vertex

private

Referenced by get_estimated_time_at(), get_used_cpu_memory(), load(), reset(), and update_view_full_range().

m_layer_start_times

std::array<std::vector<float>, TIME_MODES_COUNT> libvgcode::ViewerImpl::m_layer_start_times

private

Referenced by get_estimated_time_at(), get_used_cpu_memory(), load(), and reset().

m_layer_time_range

std::array<ColorRange, COLOR_RANGE_TYPES_COUNT> libvgcode::ViewerImpl::m_layer_time_range

private

Initial value:

{
        ColorRange(EColorRangeType::Linear), ColorRange(EColorRangeType::Logarithmic)
    }

                                                                    {
        ColorRange(EColorRangeType::Linear), ColorRange(EColorRangeType::Logarithmic)
    };

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_layers

Layers libvgcode::ViewerImpl::m_layers

private

Referenced by get_layer_id_at(), get_layer_z(), get_layers_count(), get_layers_estimated_times(), get_layers_view_range(), get_layers_zs(), get_used_cpu_memory(), get_vertex_alpha(), get_vertex_color(), load(), reset(), set_layer_colors(), set_layers_view_range(), set_time_mode(), update_color_ranges(), update_enabled_entities(), and update_view_full_range().

m_layers_in_vertex_order

bool libvgcode::ViewerImpl::m_layers_in_vertex_order { false }

private

{ false };

Referenced by load(), reset(), and update_view_full_range().

m_light_top_dir

Vec3 libvgcode::ViewerImpl::m_light_top_dir { -0.4574957f, 0.4574957f, 0.7624929f }

private

{ -0.4574957f, 0.4574957f, 0.7624929f };

Referenced by render_segments(), and set_light_top_dir().

m_oit_depth_range

std::array<float, 2> libvgcode::ViewerImpl::m_oit_depth_range { 0.0f, 1.0f }

private

{ 0.0f, 1.0f };

Referenced by render_segments(), and render_translucent_segments().

m_option_template

OptionTemplate libvgcode::ViewerImpl::m_option_template

private

Referenced by get_used_gpu_memory(), init(), render_options(), and shutdown().

m_options

std::vector<EOptionType> libvgcode::ViewerImpl::m_options

private

Referenced by get_options(), get_options_count(), get_used_cpu_memory(), load(), and reset().

m_options_colors

std::array<Color, size_t(EOptionType::COUNT)> libvgcode::ViewerImpl::m_options_colors

private

Referenced by get_option_color(), get_used_cpu_memory(), reset_default_options_colors(), and set_option_color().

m_options_shader_id

unsigned int libvgcode::ViewerImpl::m_options_shader_id { 0 }

private

{ 0 };

Referenced by init(), render_options(), and shutdown().

m_positions_buf_id

unsigned int libvgcode::ViewerImpl::m_positions_buf_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), and reset().

m_positions_tex_id

unsigned int libvgcode::ViewerImpl::m_positions_tex_id { 0 }

private

{ 0 };

Referenced by load(), render_options(), render_segments(), and reset().

m_positions_tex_size

size_t libvgcode::ViewerImpl::m_positions_tex_size { 0 }

private

{ 0 };

Referenced by get_used_gpu_memory(), and load().

m_pressure_advance_range

ColorRange libvgcode::ViewerImpl::m_pressure_advance_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_rendering_shadow_casters

bool libvgcode::ViewerImpl::m_rendering_shadow_casters { false }

private

{ false };

Referenced by render_segments(), and render_shadow_casters().

m_saturation

float libvgcode::ViewerImpl::m_saturation { 1.0f }

private

{ 1.0f };

Referenced by render_segments(), and set_tone().

m_segment_template

SegmentTemplate libvgcode::ViewerImpl::m_segment_template

private

Referenced by get_used_gpu_memory(), init(), render_segments(), and shutdown().

m_segments_caster_shader_id

unsigned int libvgcode::ViewerImpl::m_segments_caster_shader_id { 0 }

private

{ 0 };

Referenced by init(), render_segments(), and shutdown().

m_segments_caster_vao_id

unsigned int libvgcode::ViewerImpl::m_segments_caster_vao_id { 0 }

private

{ 0 };

Referenced by init(), render_segments(), render_translucent_segments(), and shutdown().

m_segments_depth_shader_id

unsigned int libvgcode::ViewerImpl::m_segments_depth_shader_id { 0 }

private

{ 0 };

Referenced by init(), render_segments(), and shutdown().

m_segments_shader_id

unsigned int libvgcode::ViewerImpl::m_segments_shader_id { 0 }

private

{ 0 };

Referenced by init(), render_segments(), and shutdown().

m_settings

Settings libvgcode::ViewerImpl::m_settings

private

Referenced by apply_pending_updates(), get_dim_previous_layers_brightness(), get_estimated_time(), get_estimated_time_at(), get_extrusion_role_estimated_time(), get_layers_estimated_times(), get_time_mode(), get_travels_estimated_time(), get_vertex_alpha(), get_vertex_color(), get_view_type(), is_dim_previous_layers(), is_extrusion_role_visible(), is_option_visible(), is_spiral_vase_mode(), is_top_layer_only_view_range(), is_translucent_filaments(), load(), render(), set_color_print_colors(), set_color_range_palette(), set_dim_previous_layers(), set_dim_previous_layers_brightness(), set_extrusion_role_color(), set_layer_colors(), set_layers_view_range(), set_option_color(), set_time_mode(), set_tool_colors(), set_translucent_filaments(), set_view_type(), toggle_extrusion_role_visibility(), toggle_option_visibility(), toggle_top_layer_only_view_range(), update_color_ranges(), update_colors(), update_enabled_entities(), and update_view_full_range().

m_settings_used_for_ranges

std::optional<Settings> libvgcode::ViewerImpl::m_settings_used_for_ranges

private

Referenced by reset(), and update_color_ranges().

m_shadow_intensity

float libvgcode::ViewerImpl::m_shadow_intensity { 0.0f }

private

{ 0.0f };

Referenced by render_segments(), and set_shadow_map().

m_shadow_light_vp

Mat4x4 libvgcode::ViewerImpl::m_shadow_light_vp { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }

private

{ 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f };

Referenced by render_segments(), and set_shadow_map().

m_shadow_map_texel

float libvgcode::ViewerImpl::m_shadow_map_texel { 0.0f }

private

{ 0.0f };

Referenced by render_segments(), and set_shadow_map().

m_shadow_map_texture_unit

int libvgcode::ViewerImpl::m_shadow_map_texture_unit { 4 }

private

{ 4 };

Referenced by render_segments(), and set_shadow_map().

m_speed_range

ColorRange libvgcode::ViewerImpl::m_speed_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_temperature_range

ColorRange libvgcode::ViewerImpl::m_temperature_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_tool_colors

PaletteWithAlpha libvgcode::ViewerImpl::m_tool_colors

private

Referenced by get_tool_colors(), get_tool_colors_count(), get_used_cpu_memory(), get_vertex_alpha(), get_vertex_color(), load(), set_tool_colors(), and update_colors().

m_total_time

std::array<float, TIME_MODES_COUNT> libvgcode::ViewerImpl::m_total_time { 0.0f, 0.0f }

private

{ 0.0f, 0.0f };

Referenced by get_estimated_time(), load(), and reset().

m_translucent_composite_shader_id

unsigned int libvgcode::ViewerImpl::m_translucent_composite_shader_id { 0 }

private

{ 0 };

Referenced by init(), render_translucent_segments(), and shutdown().

m_translucent_pass

int libvgcode::ViewerImpl::m_translucent_pass { 0 }

private

{ 0 };

Referenced by render_segments(), and render_translucent_segments().

m_translucent_targets

TranslucentTargets libvgcode::ViewerImpl::m_translucent_targets

private

Referenced by get_used_gpu_memory(), render_translucent_segments(), and reset().

m_travels_radius

float libvgcode::ViewerImpl::m_travels_radius { DEFAULT_TRAVELS_RADIUS_MM }

private

{ DEFAULT_TRAVELS_RADIUS_MM };

Referenced by get_travels_radius(), load(), set_travels_radius(), and update_heights_widths().

m_travels_time

std::array<float, TIME_MODES_COUNT> libvgcode::ViewerImpl::m_travels_time { 0.0f, 0.0f }

private

{ 0.0f, 0.0f };

Referenced by get_travels_estimated_time(), load(), and reset().

m_uni_options_clipping_plane_id

int libvgcode::ViewerImpl::m_uni_options_clipping_plane_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_colors_tex_id

int libvgcode::ViewerImpl::m_uni_options_colors_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_height_width_angle_tex_id

int libvgcode::ViewerImpl::m_uni_options_height_width_angle_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_layer_colors

LayerColorsUniforms libvgcode::ViewerImpl::m_uni_options_layer_colors

private

Referenced by init(), and render_options().

m_uni_options_positions_tex_id

int libvgcode::ViewerImpl::m_uni_options_positions_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_projection_matrix_id

int libvgcode::ViewerImpl::m_uni_options_projection_matrix_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_segment_index_tex_id

int libvgcode::ViewerImpl::m_uni_options_segment_index_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_options_view_matrix_id

int libvgcode::ViewerImpl::m_uni_options_view_matrix_id { -1 }

private

{ -1 };

Referenced by init(), and render_options().

m_uni_segments

SegmentsUniforms libvgcode::ViewerImpl::m_uni_segments

private

Referenced by init(), and render_segments().

m_uni_segments_caster

SegmentsUniforms libvgcode::ViewerImpl::m_uni_segments_caster

private

Referenced by init(), and render_segments().

m_uni_segments_depth

SegmentsUniforms libvgcode::ViewerImpl::m_uni_segments_depth

private

Referenced by init(), and render_segments().

m_uni_segments_depth_opaque_depth_id

int libvgcode::ViewerImpl::m_uni_segments_depth_opaque_depth_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_exposure_id

int libvgcode::ViewerImpl::m_uni_segments_exposure_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_front_depth_id

int libvgcode::ViewerImpl::m_uni_segments_front_depth_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_gloss_id

int libvgcode::ViewerImpl::m_uni_segments_gloss_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_layer_colors

LayerColorsUniforms libvgcode::ViewerImpl::m_uni_segments_layer_colors

private

Referenced by init(), and render_segments().

m_uni_segments_light_top_dir_id

int libvgcode::ViewerImpl::m_uni_segments_light_top_dir_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_oit_depth_range_id

int libvgcode::ViewerImpl::m_uni_segments_oit_depth_range_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_oit_pass_id

int libvgcode::ViewerImpl::m_uni_segments_oit_pass_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_opaque_depth_id

int libvgcode::ViewerImpl::m_uni_segments_opaque_depth_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_saturation_id

int libvgcode::ViewerImpl::m_uni_segments_saturation_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_shadow_intensity_id

int libvgcode::ViewerImpl::m_uni_segments_shadow_intensity_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_shadow_light_vp_id

int libvgcode::ViewerImpl::m_uni_segments_shadow_light_vp_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_shadow_map_id

int libvgcode::ViewerImpl::m_uni_segments_shadow_map_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_segments_shadow_map_texel_id

int libvgcode::ViewerImpl::m_uni_segments_shadow_map_texel_id { -1 }

private

{ -1 };

Referenced by init(), and render_segments().

m_uni_translucent_composite_accum_tex_id

int libvgcode::ViewerImpl::m_uni_translucent_composite_accum_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_translucent_segments().

m_uni_translucent_composite_front_tex_id

int libvgcode::ViewerImpl::m_uni_translucent_composite_front_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_translucent_segments().

m_uni_translucent_composite_origin_id

int libvgcode::ViewerImpl::m_uni_translucent_composite_origin_id { -1 }

private

{ -1 };

Referenced by init(), and render_translucent_segments().

m_uni_translucent_composite_reveal_tex_id

int libvgcode::ViewerImpl::m_uni_translucent_composite_reveal_tex_id { -1 }

private

{ -1 };

Referenced by init(), and render_translucent_segments().

m_used_extruders

std::map<uint8_t, std::vector<ColorPrint> > libvgcode::ViewerImpl::m_used_extruders

private

Referenced by get_color_prints(), get_color_prints_count(), get_used_cpu_memory(), get_used_extruders_count(), get_used_extruders_ids(), load(), reset(), and update_colors().

m_valid_lines_bitset

BitSet libvgcode::ViewerImpl::m_valid_lines_bitset

private

Referenced by get_used_cpu_memory(), load(), reset(), update_enabled_entities(), and update_heights_widths().

m_vertices

std::vector<PathVertex> libvgcode::ViewerImpl::m_vertices

private

Referenced by get_bounding_box(), get_estimated_time_at(), get_extrusion_bounding_box(), get_time_modes(), get_used_cpu_memory(), get_vertex_at(), get_vertices_count(), load(), reset(), set_time_mode(), update_color_ranges(), update_colors(), update_enabled_entities(), update_heights_widths(), and update_view_full_range().

m_vertices_colors

std::vector<ColorWithAlpha> libvgcode::ViewerImpl::m_vertices_colors

private

Referenced by get_used_cpu_memory(), load(), reset(), update_colors(), update_colors_texture(), and update_enabled_entities().

m_view_range

ViewRange libvgcode::ViewerImpl::m_view_range

private

Referenced by get_current_vertex_id(), get_view_enabled_range(), get_view_full_range(), get_view_visible_range(), load(), reset(), set_layer_colors(), set_layers_view_range(), set_view_visible_range(), toggle_option_visibility(), toggle_top_layer_only_view_range(), update_enabled_entities(), and update_view_full_range().

m_volumetric_rate_range

ColorRange libvgcode::ViewerImpl::m_volumetric_rate_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_width_range

ColorRange libvgcode::ViewerImpl::m_width_range

private

Referenced by get_color_range(), get_used_cpu_memory(), get_vertex_color(), set_color_range_palette(), and update_color_ranges().

m_wipes_radius

float libvgcode::ViewerImpl::m_wipes_radius { DEFAULT_WIPES_RADIUS_MM }

private

{ DEFAULT_WIPES_RADIUS_MM };

Referenced by get_wipes_radius(), load(), set_wipes_radius(), and update_heights_widths().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/ViewerImpl.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libvgcode/src/ViewerImpl.cpp